diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
new file mode 100644
index 00000000..c16a5c28
--- /dev/null
+++ b/ARCHITECTURE.md
@@ -0,0 +1,95 @@
+# Project Architecture and Data Model
+
+This document provides an overview of the project files, their roles, and a detailed description of the database architecture and data model.
+
+## Project Structure
+
+Root directory:
+- **Dockerfile**: Defines the Python 3.12-slim image, installs dependencies (FastAPI, Uvicorn, SQLAlchemy, databases, TimescaleDB support), and runs the app.
+- **docker-compose.yml**: Orchestrates two services:
+  - **dereth-tracker**: The FastAPI application container.
+  - **db**: A TimescaleDB (PostgreSQL 14 + TimescaleDB extension) container for persistent storage.
+- **README.md**: High-level documentation and usage instructions.
+- **EVENT_FORMATS.json**: Example JSON payloads for all event types (`telemetry`, `spawn`, `chat`, `rare`).
+- **db.py**: Legacy SQLite-based storage (telemetry_log & live_state tables, WAL mode, auto-vacuum).
+ - **db_async.py**: Async database definitions for PostgreSQL/TimescaleDB:
+  - Table schemas (SQLAlchemy Core):
+    - `telemetry_events`,
+    - `char_stats`,
+    - `rare_stats`,
+    - `rare_stats_sessions`,
+    - `spawn_events`,
+    - `rare_events`.
+  - `init_db_async()`: Creates tables, enables TimescaleDB extension, and configures a hypertable on `telemetry_events`.
+- **main.py**: The FastAPI application:
+  - HTTP endpoints: `/debug`, `/live`, `/history`, `/trails`.
+  - WebSocket endpoints: `/ws/position` (plugin data in), `/ws/live` (browser live updates).
+  - Pydantic models: `TelemetrySnapshot`, `SpawnEvent`.
+  - In-memory state: `live_snapshots`, WebSocket connection registries.
+- **generate_data.py**: Sample WebSocket client that sends synthetic telemetry snapshots.
+- **alembic/** & **alembic.ini**: Migration tooling for evolving the database schema.
+- **static/**: Frontend assets (HTML, CSS, JavaScript, images) for the live map UI.
+- **FIXES.md**, **LESSONSLEARNED.md**, **TODO.md**: Project notes and future work.
+
+## Database Overview
+
+### Technology Stack
+- **PostgreSQL** 14 with **TimescaleDB** extension for time-series optimization.
+- **databases** library (async) with **SQLAlchemy Core** for schema definitions and queries.
+- Environment variable: `DATABASE_URL` controls the connection string.
+
+### Tables and Hypertable
+1. **telemetry_events** (hypertable)
+   - Columns:
+     - `id`: Integer, primary key.
+     - `character_name` (String), `char_tag` (String, nullable), `session_id` (String, indexed).
+     - `timestamp` (DateTime with TZ, indexed) — partitioning column for the hypertable.
+     - `ew`, `ns`, `z`: Float coordinates.
+     - `kills`, `deaths`, `rares_found`, `prismatic_taper_count`: Integer metrics.
+     - `kills_per_hour`, `onlinetime` (String), `vt_state` (String).
+     - Optional: `mem_mb`, `cpu_pct`, `mem_handles`, `latency_ms`.
+   - Created via `SELECT create_hypertable('telemetry_events', 'timestamp', if_not_exists=>true, create_default_indexes=>false)`.
+
+2. **char_stats**
+   - Tracks cumulative kills per character.
+   - Columns: `character_name` (PK), `total_kills` (Integer).
+
+3. **rare_stats**
+   - Tracks total rare spawns per character.
+   - Columns: `character_name` (PK), `total_rares` (Integer).
+
+4. **rare_stats_sessions**
+   - Tracks rarities per session.
+   - Columns: composite PK `(character_name, session_id)`, `session_rares` (Integer).
+
+5. **spawn_events**
+   - Records individual mob spawn events for heatmapping.
+   - Columns: `id` (PK), `character_name` (String), `mob` (String), `timestamp` (DateTime), `ew`, `ns`, `z` (Float).
+   - Coordinates (`ew`, `ns`, `z`) can be sent as JSON numbers or strings and are coerced to floats.
+
+6. **rare_events**
+   - Records each rare spawn event for future heatmaps and analysis.
+   - Columns: `id` (PK), `character_name` (String), `name` (String), `timestamp` (DateTime), `ew`, `ns`, `z` (Float).
+
+### Initialization and Migrations
+- On startup (`main.py`), `init_db_async()` is called:
+  1. Creates all tables via SQLAlchemy’s `metadata.create_all()`.
+  2. Enables TimescaleDB extension.
+  3. Converts `telemetry_events` to a hypertable, skipping default index creation to avoid PK/index collisions.
+- Alembic is configured for schema migrations (`alembic/` directory).
+
+## Data Ingestion Flow
+1. **Plugin** connects to `/ws/position` with a shared secret.
+2. Sends JSON frames of types:
+   - `telemetry`: parsed into `TelemetrySnapshot`, upserted into `live_snapshots`, persisted to `telemetry_events`, and broadcast to browser clients.
+   - `spawn`: parsed into `SpawnEvent`, inserted into `spawn_events`.
+   - `rare`: increments `rare_stats` and `rare_stats_sessions` via upsert operations.
+   - `chat`: broadcast to browser clients without DB writes.
+3. **Browser** connects to `/ws/live` to receive live updates and can send commands to plugins.
+
+## HTTP Query Endpoints
+- **GET /live**: returns recent snapshots (last 30s) plus rare counts per character.
+- **GET /history**: returns ordered telemetry history with optional time filters.
+- **GET /trails**: returns positional trails for a lookback window.
+
+This architecture enables real-time telemetry ingestion, historical time-series analysis, and an interactive front-end map for tracking players and spawn events.
\ No newline at end of file
diff --git a/EVENT_FORMATS.json b/EVENT_FORMATS.json
new file mode 100644
index 00000000..48240575
--- /dev/null
+++ b/EVENT_FORMATS.json
@@ -0,0 +1,45 @@
+{
+  "_comment": "These are individual example payloads keyed by event type. Send each payload separately over the WS connection.",
+  "telemetry": {
+    "type": "telemetry",
+    "character_name": "string",
+    "session_id": "string",
+    "timestamp": "2025-04-22T13:45:00Z",
+    "ew": 123.4,
+    "ns": 567.8,
+    "z": 10.2,
+    "kills": 42,
+    "kills_per_hour": 7.0,
+    "onlinetime": "00.05:00",
+    "deaths": 1,
+    "prismatic_taper_count": 17,
+    "vt_state": "Combat",
+    "mem_mb": 256.5,
+    "cpu_pct": 12.3,
+    "mem_handles": 1024
+  },
+  "spawn": {
+    "type": "spawn",
+    "timestamp": "2025-04-22T13:46:00Z",
+    "character_name": "MyCharacter",
+    "mob": "Forest Troll",
+    "ew": 100.1,
+    "ns": 200.2
+  },
+  "chat": {
+    "type": "chat",
+    "timestamp": "2025-04-22T13:47:00Z",
+    "character_name": "MyCharacter",
+    "text": "Hello world!",
+    "color": "#88FF00"
+  },
+  "rare": {
+    "type": "rare",
+    "timestamp": "2025-04-22T13:48:00Z",
+    "character_name": "MyCharacter",
+    "name": "Golden Gryphon",
+    "ew": 150.5,
+    "ns": 350.7,
+    "z": 5.0
+  }
+}
\ No newline at end of file
diff --git a/FIXES.md b/FIXES.md
new file mode 100644
index 00000000..c8160b85
--- /dev/null
+++ b/FIXES.md
@@ -0,0 +1,48 @@
+# Planned Fixes and Enhancements
+
+_This document captures the next set of improvements and fixes for Dereth Tracker._
+
+## 1. Chat Window Styling and Format
+- **Terminal-style chat interface**
+  - Redesign the chat window to mimic Asheron’s Call in-game chat: monospaced font, dark semi-transparent background, and text entry at the bottom.
+  - Implement timestamped message prefixes (e.g., `[12:34] character: message`).
+  - Support command- and system-level styling (e.g., whispers, party chat) with distinct color cues.
+
+## 2. Incoming Message Parsing
+- **Strip protocol overhead**
+  - Remove JSON envelope artifacts (e.g., remove quotes, braces) so only raw message text appears.
+  - Validate and sanitize incoming payloads (e.g., escape HTML, truncate length).
+  - Optionally support rich-text / emotes by parsing simple markup (e.g., `*bold*`, `/me action`).
+
+## 3. Message Color Scheme
+- **Per-character consistent colors**
+  - Map each character name to a unique, but legible, pastel or muted color.
+  - Ensure sufficient contrast with the chat background (WCAG AA compliance).
+  - Provide user override settings for theme (light/dark) and custom palettes.
+
+## 4. Command Prompt Integration
+- **Client-side command entry**
+  - Allow slash-commands in chat input (e.g., `/kick PlayerName`, `/whisper PlayerName Hello`).
+  - Validate commands before sending to `/ws/live` and route to the correct plugin WebSocket.
+  - Show feedback on command success/failure in the chat window.
+
+## 5. Security Hardening
+- **Authentication & Authorization**
+  - Enforce TLS (HTTPS/WSS) for all HTTP and WebSocket connections.
+  - Protect `/ws/position` with rotating shared secrets or token-based auth (e.g., JWT).
+  - Rate-limit incoming telemetry and chat messages to prevent flooding.
+  - Sanitize all inputs to guard against injection (SQL, XSS) and implement strict CSP headers.
+
+## 6. Performance and Scalability
+- **Throttling and Load Handling**
+  - Batch updates during high-frequency telemetry bursts to reduce WebSocket churn.
+  - Cache recent `/live` and `/trails` responses in-memory to relieve SQLite under load.
+  - Plan for horizontal scaling: stateless FastAPI behind a load balancer with shared database or in-memory pub/sub.
+
+## 7. Testing and Quality Assurance
+- **Automated Tests**
+  - Unit tests for `db.save_snapshot`, HTTP endpoints, and WebSocket handlers.
+  - E2E tests for the frontend UI (using Puppeteer or Playwright) to verify chat and map functionality.
+  - Security regression tests for input sanitization and auth enforcement.
+
+_Refer to this list when planning next development sprints. Each item should be broken down into individual tickets or pull requests._
\ No newline at end of file
diff --git a/LESSONSLEARNED.md b/LESSONSLEARNED.md
new file mode 100644
index 00000000..2ee1085d
--- /dev/null
+++ b/LESSONSLEARNED.md
@@ -0,0 +1,38 @@
+# Lessons Learned
+
+_This document captures the key takeaways and implementation details from today's troubleshooting session._
+
+## 1. API Routing & Proxy Configuration
+- **API_BASE constant**: The frontend (`static/script.js`) uses a base path `API_BASE` (default `/api`) to prefix all HTTP and WebSocket calls. Always update this to match your proxy mount point.
+- **Nginx WebSocket forwarding**: To proxy WebSockets, you must forward the `Upgrade` and `Connection` headers:
+  ```nginx
+  proxy_set_header Upgrade    $http_upgrade;
+  proxy_set_header Connection "upgrade";
+  ```
+  Without these, the WS handshake downgrades to a normal HTTP GET, resulting in 404s.
+
+## 2. Debugging WebSocket Traffic
+- Logged all incoming WS frames in `main.py`:
+  - `[WS-PLUGIN RX] <client>: <raw>` for messages on `/ws/position`
+  - `[WS-LIVE RX]   <client>: <parsed-json>` for messages on `/ws/live`
+- These prints surface registration, telemetry, chat, and command packets, aiding root-cause analysis.
+
+## 3. Data Serialization Fix
+- Python `datetime` objects are not JSON-serializable by default. We wrapped outbound payloads via FastAPI’s `jsonable_encoder` in `_broadcast_to_browser_clients` so that:
+  ```python
+  data = jsonable_encoder(snapshot)
+  await ws.send_json(data)
+  ```
+  This ensures ISO8601 strings for timestamps and eliminates `TypeError: Object of type datetime is not JSON serializable`.
+
+## 4. Frontend Adjustments
+- **Chat input positioning**: Moved the `.chat-form` to `position: absolute; bottom: 0;` so the input always sticks to the bottom of its window.
+- **Text color**: Forced the input text and placeholder to white (`.chat-input, .chat-input::placeholder { color: #fff; }`) and forcibly set all incoming messages to white via `.chat-messages div { color: #fff !important; }`.
+- **Padding for messages**: Added `padding-bottom` to `.chat-messages` to avoid new messages being hidden behind the fixed input bar.
+
+## 5. General Best Practices
+- Clear browser cache after updating static assets to avoid stale JS/CSS.
+- Keep patches targeted: fix the source of issues (e.g., JSON encoding or missing headers) rather than applying superficial workarounds.
+- Use consistent CSS variables for theming (e.g., `--text`, `--bg-main`).
+
+By consolidating these lessons, we can onboard faster next time and avoid repeating these pitfalls.
\ No newline at end of file
diff --git a/README.md b/README.md
index 14a24307..3578c5de 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Dereth Tracker
 
-Dereth Tracker is a real-time telemetry service for the world of Dereth. It collects player data, stores it in a PostgreSQL (TimescaleDB) database for efficient time-series storage, provides a live map interface, and includes a comprehensive inventory management system for tracking and searching character equipment.
+Dereth Tracker is a real-time telemetry service for the world of Dereth. It collects player data, stores it in a PostgreSQL (TimescaleDB) database for efficient time-series storage, and provides a live map interface along with a sample data generator for testing.
 
 ## Table of Contents
 - [Overview](#overview)
@@ -16,27 +16,20 @@ Dereth Tracker is a real-time telemetry service for the world of Dereth. It coll
 
 ## Overview
 
-This project provides:
+- This project provides:
 - A FastAPI backend with endpoints for receiving and querying telemetry data.
 - PostgreSQL/TimescaleDB-based storage for time-series telemetry and per-character stats.
 - A live, interactive map using static HTML, CSS, and JavaScript.
-- A comprehensive inventory management system with search capabilities.
-- Real-time inventory updates via WebSocket when characters log in/out.
+- A sample data generator script (`generate_data.py`) for simulating telemetry snapshots.
 - A sample data generator script (`generate_data.py`) for simulating telemetry snapshots.
 
 ## Features
 
-- **WebSocket /ws/position**: Stream telemetry snapshots and inventory updates (protected by a shared secret).
+- **WebSocket /ws/position**: Stream telemetry snapshots (protected by a shared secret).
 - **GET /live**: Fetch active players seen in the last 30 seconds.
 - **GET /history**: Retrieve historical telemetry data with optional time filtering.
 - **GET /debug**: Health check endpoint.
 - **Live Map**: Interactive map interface with panning, zooming, and sorting.
-- **Inventory Management**: 
-  - Real-time inventory updates via WebSocket on character login/logout
-  - Advanced search across all character inventories
-  - Filter by character, equipment type, material, stats, and more
-  - Sort by any column with live results
-  - Track item properties including spells, armor level, damage ratings
 - **Sample Data Generator**: `generate_data.py` sends telemetry snapshots over WebSocket for testing.
 
 ## Requirements
@@ -225,13 +218,11 @@ For a complete reference of JSON payloads accepted by the backend (over `/ws/pos
   - **Spawn events** (`type`: "spawn")
   - **Chat events** (`type`: "chat")
   - **Rare events** (`type`: "rare")
-  - **Inventory events** (`type`: "inventory")
 
 Notes on payload changes:
   - Spawn events no longer require the `z` coordinate; if omitted, the server defaults it to 0.0.
     Coordinates (`ew`, `ns`, `z`) may be sent as JSON numbers or strings; the backend will coerce them to floats.
   - Telemetry events have removed the `latency_ms` field; please omit it from your payloads.
-  - Inventory events are sent automatically on character login/logout containing complete inventory data.
 
 Each entry shows all required and optional fields, their types, and example values.
 
@@ -262,14 +253,11 @@ Response:
 ## Frontend
 
 - **Live Map**: `static/index.html` – Real-time player positions on a map.
-- **Inventory Search**: `static/inventory.html` – Search and browse character inventories with advanced filtering.
 
 ## Database Schema
 
-This service uses PostgreSQL with the TimescaleDB extension to store telemetry time-series data,
-aggregate character statistics, and a separate inventory database for equipment management. 
-
-### Telemetry Database Tables:
+This service uses PostgreSQL with the TimescaleDB extension to store telemetry time-series data
+and aggregate character statistics. The primary tables are:
 
 - **telemetry_events** (hypertable):
   - `id` (PK, serial)
@@ -309,41 +297,6 @@ aggregate character statistics, and a separate inventory database for equipment
   - `timestamp` (timestamptz)
   - `ew`, `ns`, `z` (float)
 
-### Inventory Database Tables:
-
-- **items**:
-  - `id` (PK, serial)
-  - `character_name` (text, indexed)
-  - `item_id` (bigint)
-  - `name` (text)
-  - `object_class` (integer)
-  - `icon`, `value`, `burden` (integer)
-  - `current_wielded_location`, `bonded`, `attuned`, `unique` (various)
-  - `timestamp` (timestamptz)
-
-- **item_combat_stats**:
-  - `item_id` (FK to items.id)
-  - `armor_level`, `max_damage` (integer)
-  - `damage_bonus`, `attack_bonus` (float)
-  - Various defense bonuses
-
-- **item_enhancements**:
-  - `item_id` (FK to items.id)
-  - `material` (varchar)
-  - `item_set` (varchar)
-  - `tinks`, `workmanship` (integer/float)
-
-- **item_spells**:
-  - `item_id` (FK to items.id)
-  - `spell_id` (integer)
-  - `spell_name` (text)
-  - `is_legendary`, `is_epic` (boolean)
-
-- **item_raw_data**:
-  - `item_id` (FK to items.id)
-  - `int_values`, `double_values`, `string_values`, `bool_values` (JSONB)
-  - `original_json` (JSONB)
-
 ## Contributing
 
 Contributions are welcome! Feel free to open issues or submit pull requests.
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 00000000..11318369
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,62 @@
+## TODO: Migration & Parity Plan
+
+### Detailed Plan
+1. [ ] Review Repository for Data Storage and Event Handling
+   - [ ] Scan for SQLite usage (telemetry, spawns, chat, session data)
+   - [ ] Identify all event ingestion code paths (WebSocket, HTTP, direct DB inserts)
+   - [ ] Locate old or deprecated payload handling
+2. [ ] Update Database Access Layer to PostgreSQL/TimescaleDB
+   - [ ] Replace SQLite code with SQLAlchemy models & Alembic migrations
+   - [ ] Configure TimescaleDB hypertable for telemetry data
+   - [ ] Create migration for spawn events table
+   - [ ] Set up `DATABASE_URL` and (optional) local Docker Compose service
+3. [ ] Refactor Event Ingestion Endpoints and Logic
+   - [ ] Modify `/ws/position` to accept new schemas (telemetry, spawn, chat)
+   - [ ] Persist telemetry and spawn events to PostgreSQL
+   - [ ] Continue broadcasting chat messages without persisting
+4. [ ] Update Data Models and API Response Types
+   - [ ] Align Pydantic schemas to new event payload structures
+   - [ ] Update `/live`, `/history`, `/trails` to query Postgres
+   - [ ] Optionally add `GET /spawns` endpoint for spawn data
+5. [ ] Migrate or Clean Historical Data
+   - [ ] If needed, write script to migrate existing SQLite data to Postgres
+   - [ ] Otherwise remove old migration and data transformation code
+6. [ ] Refactor Frontend to Query and Visualize New Data (deferred)
+7. [ ] Add or Update Grafana Dashboards (deferred)
+8. [ ] Testing & Verification (deferred)
+9. [ ] Documentation & Developer Instructions
+   - [ ] Update README and docs for PostgreSQL/TimescaleDB setup
+10. [ ] Maintenance and Future Enhancements
+   - [ ] Document data retention and aggregation policies for TimescaleDB
+
+### Phases
+
+### Phase 1: Core Migration & Parity
+- [ ] Remove SQLite usage and associated code (`db.py` and direct `sqlite3` calls).
+- [ ] Integrate PostgreSQL/TimescaleDB using SQLAlchemy and Alembic for migrations.
+  - Set up `DATABASE_URL` environment variable for connection.
+  - (Optional) Add a TimescaleDB service in `docker-compose.yml` for local development.
+- [ ] Define SQLAlchemy models and create initial Alembic migration:
+  - Telemetry table as a TimescaleDB hypertable.
+  - Spawn events table.
+- [ ] Update backend (`main.py`):
+  - Ingest `telemetry` and new `spawn` messages from `/ws/position` WebSocket.
+  - Persist telemetry and spawn events to PostgreSQL.
+  - Continue broadcasting `chat` messages without persisting.
+- [ ] Ensure existing endpoints (`/live`, `/history`, `/trails`) operate against the new database.
+- [ ] (Optional) Add retrieval endpoint for spawn events (e.g., `GET /spawns`).
+
+### Phase 2: Frontend & Visualization
+- [ ] Update frontend to display spawn events (markers or lists).
+- [ ] Expose new telemetry metrics in the UI: `latency_ms`, `mem_mb`, `cpu_pct`, `mem_handles`.
+
+### Phase 3: Dashboards & Monitoring
+* [ ] Provision or update Grafana dashboards for:
+  - Telemetry performance (TimescaleDB queries, hypertable metrics).
+  - Spawn event heatmaps and trends.
+  - Rare event heatmaps and trends.
+
+### Phase 4: Documentation & Maintenance
+- [ ] Finalize README and developer docs with PostgreSQL setup, migration steps, and usage examples.
+- [ ] Document how to add new event types or payload fields, including schema, migrations, and tests.
+- [ ] Establish data retention and aggregation policies for TimescaleDB hypertables.
\ No newline at end of file
diff --git a/inventory-service/main.py b/inventory-service/main.py
index 28ae5c69..6745473e 100644
--- a/inventory-service/main.py
+++ b/inventory-service/main.py
@@ -5,7 +5,6 @@ Handles enum translation, data normalization, and provides structured item data
 """
 
 import json
-import time
 import logging
 from pathlib import Path
 from typing import Dict, List, Optional, Any
@@ -13,8 +12,7 @@ from datetime import datetime
 
 from fastapi import FastAPI, HTTPException, Depends, Query
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse, StreamingResponse
-from sse_starlette.sse import EventSourceResponse
+from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 import databases
 import sqlalchemy as sa
@@ -254,18 +252,6 @@ def translate_item_type(item_type_id: int) -> str:
     item_types = ENUM_MAPPINGS.get('item_types', {})
     return item_types.get(item_type_id, f"Unknown_ItemType_{item_type_id}")
 
-def derive_item_type_from_object_class(object_class: int, item_data: dict = None) -> str:
-    """Derive ItemType from ObjectClass using the object_classes enum."""
-    # Use the object_classes enum directly for accurate classifications
-    object_classes = ENUM_MAPPINGS.get('object_classes', {})
-    item_type = object_classes.get(object_class)
-    
-    if item_type:
-        return item_type
-    else:
-        # Fallback to "Misc" if ObjectClass not found in enum
-        return "Misc"
-
 def translate_object_class(object_class_id: int, item_data: dict = None) -> str:
     """Translate object class ID to human-readable name with context-aware detection."""
     # Use the extracted ObjectClass enum first
@@ -376,8 +362,7 @@ def translate_coverage_mask(coverage_value: int) -> List[str]:
         'Head': 'Head',
         'Hands': 'Hands',
         'Feet': 'Feet',
-        'Cloak': 'Cloak',
-        'Robe': 'Robe'
+        'Cloak': 'Cloak'
     }
     
     return [name_mapping.get(part, part) for part in covered_parts if part]
@@ -524,7 +509,6 @@ def convert_slot_name_to_friendly(slot_name: str) -> str:
         'TwoHanded': 'Two-Handed',
         'TrinketOne': 'Trinket',
         'Cloak': 'Cloak',
-        'Robe': 'Robe',
         'SigilOne': 'Aetheria Blue',
         'SigilTwo': 'Aetheria Yellow', 
         'SigilThree': 'Aetheria Red'
@@ -580,22 +564,10 @@ def translate_equipment_slot(wielded_location: int) -> str:
             'Held': 'Held',
             'TwoHanded': 'Two-Handed',
             'TrinketOne': 'Trinket',
-            'Cloak': 'Cloak',
-            'Robe': 'Robe'
+            'Cloak': 'Cloak'
         }
         return name_mapping.get(slot_name, slot_name)
     
-    # Handle common equipment slots that may be missing from enum database
-    common_slots = {
-        30: "Shirt",  # ChestWear + AbdomenWear + UpperArmWear + LowerArmWear for shirts
-        786432: "Left Ring, Right Ring",  # 262144 + 524288 for rings that can go in either slot
-        262144: "Left Ring",
-        524288: "Right Ring"
-    }
-    
-    if wielded_location in common_slots:
-        return common_slots[wielded_location]
-    
     # If no exact match, decode bit flags
     slot_parts = []
     for mask_value, slot_name in equip_mask_map.items():
@@ -632,8 +604,7 @@ def translate_equipment_slot(wielded_location: int) -> str:
             'Held': 'Held',
             'TwoHanded': 'Two-Handed',
             'TrinketOne': 'Trinket',
-            'Cloak': 'Cloak',
-            'Robe': 'Robe'
+            'Cloak': 'Cloak'
         }
         
         translated_parts = [name_mapping.get(part, part) for part in slot_parts]
@@ -650,7 +621,7 @@ def translate_equipment_slot(wielded_location: int) -> str:
         else:
             return f"Special Slot ({wielded_location})"
     
-    return "-"
+    return f"Unknown Slot ({wielded_location})"
 
 def translate_workmanship(workmanship_value: int) -> str:
     """Translate workmanship value to descriptive text."""
@@ -868,21 +839,10 @@ def get_comprehensive_translations(item_data: Dict[str, Any]) -> Dict[str, Any]:
         translations['material_name'] = translate_material_type(material_id)
         translations['material_id'] = material_id
     
-    # Translate item type if present (check ItemType field or IntValues[1])
+    # Translate item type if present  
     item_type_id = item_data.get('ItemType')
-    if item_type_id is None:
-        # Check IntValues for ItemType (key 1)
-        int_values = item_data.get('IntValues', {})
-        if isinstance(int_values, dict):
-            item_type_id = int_values.get('1', int_values.get(1))
-    
     if item_type_id is not None:
         translations['item_type_name'] = translate_item_type(item_type_id)
-    else:
-        # Fallback: derive ItemType from ObjectClass
-        object_class = item_data.get('ObjectClass')
-        if object_class is not None:
-            translations['item_type_name'] = derive_item_type_from_object_class(object_class, item_data)
     
     # Translate object class using WeenieType enum
     object_class = item_data.get('ObjectClass')
@@ -914,7 +874,7 @@ def extract_item_properties(item_data: Dict[str, Any]) -> Dict[str, Any]:
             # Item state
             'bonded': int_values.get('33', int_values.get(33, 0)),
             'attuned': int_values.get('114', int_values.get(114, 0)),
-            'unique': bool(int_values.get('279', int_values.get(279, 0))),
+            'unique': int_values.get('279', int_values.get(279, 0)) != 0,
             
             # Stack/Container properties
             'stack_size': int_values.get('12', int_values.get(12, 1)),
@@ -975,11 +935,11 @@ def extract_item_properties(item_data: Dict[str, Any]) -> Dict[str, Any]:
             'equip_skill': item_data.get('EquipSkill'),
         },
         'enhancements': {
-            'material': None,  # Will be set below with proper logic
+            'material': item_data.get('Material'),
             'imbue': item_data.get('Imbue'),
             'tinks': item_data.get('Tinks', -1),
             'workmanship': item_data.get('Workmanship', -1.0),
-            'item_set': None,  # Will be set below with translation
+            'item_set': int_values.get('265', int_values.get(265)) if int_values.get('265', int_values.get(265)) else None,
             
             # Advanced tinkering
             'num_times_tinkered': int_values.get('171', int_values.get(171, -1)),
@@ -1031,32 +991,6 @@ def extract_item_properties(item_data: Dict[str, Any]) -> Dict[str, Any]:
         }
     }
     
-    # Handle material field properly - check if already translated or needs translation
-    material_field = item_data.get('Material')
-    if material_field and isinstance(material_field, str):
-        # Material is already a translated string (like "Gold", "Iron", "Brass")
-        properties['enhancements']['material'] = material_field
-    else:
-        # Material needs translation from IntValues[131]
-        material_id = int_values.get('131', int_values.get(131))
-        if material_id:
-            material_name = translate_material_type(material_id)
-            # Only store if translation succeeded (not "Unknown_Material_*")
-            if not material_name.startswith('Unknown_Material_'):
-                properties['enhancements']['material'] = material_name
-    
-    # Translate item_set ID to name for database storage
-    item_set_id = int_values.get('265', int_values.get(265))
-    if item_set_id:
-        dictionaries = ENUM_MAPPINGS.get('dictionaries', {})
-        attribute_set_info = dictionaries.get('AttributeSetInfo', {}).get('values', {})
-        set_name = attribute_set_info.get(str(item_set_id))
-        if set_name:
-            properties['enhancements']['item_set'] = set_name
-        else:
-            # Fallback to just store the ID as string
-            properties['enhancements']['item_set'] = str(item_set_id)
-    
     # Get comprehensive translations
     translations = get_comprehensive_translations(item_data)
     if translations:
@@ -1173,14 +1107,6 @@ async def process_inventory(inventory: InventoryItem):
                 
                 # Simple INSERT since we cleared the table first
                 basic = properties['basic']
-                
-                # Debug logging for problematic items
-                if item_id in [-2133380247, -2144880287, -2136150336]:
-                    logger.info(f"Debug item {item_id}: basic={basic}")
-                    logger.info(f"Debug item {item_id}: name='{basic['name']}' type={type(basic['name'])}")
-                    logger.info(f"Debug item {item_id}: current_wielded_location={basic['current_wielded_location']} type={type(basic['current_wielded_location'])}")
-                    logger.info(f"Debug item {item_id}: enhancements={properties['enhancements']}")
-                
                 item_stmt = sa.insert(Item).values(
                     character_name=inventory.character_name,
                     item_id=item_id,
@@ -1384,12 +1310,9 @@ async def get_character_inventory(
                 # Add translated properties to the item
                 processed_item['translated_properties'] = properties
                 
-                # Add material name - use material directly if it's already a string
+                # Add material translation
                 if processed_item.get('material'):
-                    if isinstance(processed_item['material'], str):
-                        processed_item['material_name'] = processed_item['material']
-                    else:
-                        processed_item['material_name'] = translate_material_type(processed_item['material'])
+                    processed_item['material_name'] = translate_material_type(processed_item['material'])
                 
                 # Add object class translation
                 if processed_item.get('object_class'):
@@ -1501,8 +1424,6 @@ async def get_character_inventory(
                     processed_item['material_name'] = trans['material_name']
                 if trans.get('material_id'):
                     processed_item['material_id'] = trans['material_id']
-                if trans.get('item_type_name'):
-                    processed_item['item_type_name'] = trans['item_type_name']
             
             # Continue with other enhancements
             if 'enhancements' in translated_props:
@@ -2165,15 +2086,11 @@ async def search_items(
                     if item.get('material') or properties.get('translations', {}).get('material_name'):
                         material_name = None
                         if item.get('material'):
-                            # Check if material is already a string or needs translation
-                            if isinstance(item['material'], str):
-                                material_name = item['material']
-                            else:
-                                material_name = translate_material_type(item['material'])
+                            material_name = translate_material_type(item['material'])
                         elif properties.get('translations', {}).get('material_name'):
                             material_name = properties['translations']['material_name']
                         
-                        if material_name and not material_name.startswith('Unknown_Material_'):
+                        if material_name:
                             item['material_name'] = material_name
                             # Apply material prefix to item name
                             original_name = item['name']
@@ -2185,13 +2102,6 @@ async def search_items(
                     if item.get('object_class'):
                         item['object_class_name'] = translate_object_class(item['object_class'], original_json)
                     
-                    # Add item type translation
-                    if properties.get('translations', {}).get('item_type_name'):
-                        item['item_type_name'] = properties['translations']['item_type_name']
-                    elif item.get('object_class'):
-                        # Fallback: derive ItemType from object_class when translation is missing
-                        item['item_type_name'] = derive_item_type_from_object_class(item['object_class'], {'Name': item.get('name', '')})
-                    
                     # Add spell information
                     if 'spells' in properties:
                         spell_info = properties['spells']
@@ -2252,15 +2162,11 @@ async def search_items(
                                 if slot_name and slot_name not in slot_names:
                                     slot_names.append(slot_name)
                             
-                            # Debug logging for slot issues
-                            if not slot_names and equippable_slots in [30, 786432]:
-                                logger.warning(f"No slot names found for item '{item['name']}' with equippable_slots={equippable_slots}, slot_options={slot_options}")
-                            
-                            item['slot_name'] = ', '.join(slot_names) if slot_names else "-"
+                            item['slot_name'] = ', '.join(slot_names) if slot_names else f"Slot_{equippable_slots}"
                         else:
-                            item['slot_name'] = "-"
+                            item['slot_name'] = "Unknown"
                     else:
-                        item['slot_name'] = "-"
+                        item['slot_name'] = "Unknown"
                     
                     # Use gear totals as display ratings when individual ratings don't exist
                     # For armor/clothing, ratings are often stored as gear totals (370, 372, 374) 
@@ -2518,3041 +2424,6 @@ async def list_inventory_characters():
         raise HTTPException(status_code=500, detail="Failed to list inventory characters")
 
 
-@app.get("/search/by-slot")
-async def search_items_by_slot(
-    slot: str = Query(..., description="Slot to search for (e.g., 'Head', 'Chest', 'Hands')"),
-    characters: str = Query(None, description="Comma-separated list of character names"),
-    include_all_characters: bool = Query(False, description="Include all characters"),
-    
-    # Equipment type
-    armor_only: bool = Query(True, description="Show only armor items"),
-    
-    # Pagination
-    limit: int = Query(100, le=1000),
-    offset: int = Query(0, ge=0)
-):
-    """Search for items that can be equipped in a specific slot."""
-    try:
-        # Build query
-        conditions = []
-        params = {}
-        
-        # TODO: Implement slot filtering once we have slot_name in DB
-        # For now, return message about missing implementation
-        if slot:
-            return {
-                "error": "Slot-based search not yet implemented",
-                "message": f"Cannot search for slot '{slot}' - slot_name field needs to be added to database",
-                "suggestion": "Use regular /search/items endpoint with filters for now"
-            }
-        
-        # Character filtering
-        if not include_all_characters and characters:
-            char_list = [c.strip() for c in characters.split(',') if c.strip()]
-            if char_list:
-                placeholders = [f":char_{i}" for i in range(len(char_list))]
-                conditions.append(f"character_name IN ({', '.join(placeholders)})")
-                for i, char in enumerate(char_list):
-                    params[f"char_{i}"] = char
-        
-        # Armor only filter
-        if armor_only:
-            conditions.append("(object_class IN (2, 3))")
-        
-        # Build final query
-        where_clause = " AND ".join(conditions) if conditions else "1=1"
-        
-        query = f"""
-            SELECT i.id, i.character_name, i.name, i.icon, i.object_class,
-                   i.current_wielded_location,
-                   CASE WHEN i.current_wielded_location > 0 THEN true ELSE false END as is_equipped
-            FROM items i
-            WHERE {where_clause}
-            ORDER BY i.character_name, i.name
-            LIMIT :limit OFFSET :offset
-        """
-        
-        params['limit'] = limit
-        params['offset'] = offset
-        
-        # Execute query
-        rows = await database.fetch_all(query, params)
-        
-        # Count total
-        count_query = f"SELECT COUNT(*) as total FROM items i WHERE {where_clause}"
-        count_params = {k: v for k, v in params.items() if k not in ['limit', 'offset', 'slot_requested']}
-        count_result = await database.fetch_one(count_query, count_params)
-        total = count_result[0] if count_result else 0
-        
-        # Process results
-        items = []
-        for row in rows:
-            items.append(dict(row))
-        
-        return {
-            "items": items,
-            "total_count": total or 0,
-            "slot_searched": slot,
-            "limit": limit,
-            "offset": offset
-        }
-        
-    except Exception as e:
-        logger.error(f"Error in slot search: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/analyze/sets")
-async def analyze_set_combinations(
-    characters: str = Query(None, description="Comma-separated list of character names"),
-    include_all_characters: bool = Query(False, description="Include all characters"),
-    primary_set: int = Query(..., description="Primary set ID (needs 5 pieces)"),
-    secondary_set: int = Query(..., description="Secondary set ID (needs 4 pieces)"),
-    primary_count: int = Query(5, description="Number of primary set pieces needed"),
-    secondary_count: int = Query(4, description="Number of secondary set pieces needed")
-):
-    """Analyze set combinations for valid 5+4 equipment builds."""
-    try:
-        # Simplified approach - just count items by set for each character
-        # This uses the same pattern as existing working queries
-        
-        if include_all_characters:
-            # Query all characters
-            char_filter = "1=1"
-            query_params = []
-        elif characters:
-            # Query specific characters
-            character_list = [c.strip() for c in characters.split(',') if c.strip()]
-            char_placeholders = ','.join(['%s'] * len(character_list))
-            char_filter = f"i.character_name IN ({char_placeholders})"
-            query_params = character_list
-        else:
-            raise HTTPException(status_code=400, detail="Must specify characters or include_all_characters")
-        
-        # Query for primary set
-        primary_query = f"""
-            SELECT 
-                i.character_name,
-                i.name,
-                i.current_wielded_location
-            FROM items i
-            LEFT JOIN item_raw_data ird ON i.id = ird.item_id
-            WHERE {char_filter}
-            AND i.object_class IN (2, 3)
-            AND ird.int_values ? '265'
-            AND (ird.int_values->>'265')::int = :primary_set_id
-        """
-        
-        # Query for secondary set
-        secondary_query = f"""
-            SELECT 
-                i.character_name,
-                i.name,
-                i.current_wielded_location
-            FROM items i
-            LEFT JOIN item_raw_data ird ON i.id = ird.item_id
-            WHERE {char_filter}
-            AND i.object_class IN (2, 3)
-            AND ird.int_values ? '265'
-            AND (ird.int_values->>'265')::int = :secondary_set_id
-        """
-        
-        # Build parameter dictionaries
-        if include_all_characters:
-            primary_params = {"primary_set_id": primary_set}
-            secondary_params = {"secondary_set_id": secondary_set}
-        else:
-            # For character filtering, we need to embed character names directly in query
-            # because using named parameters with IN clauses is complex
-            character_list = [c.strip() for c in characters.split(',') if c.strip()]
-            char_names = "', '".join(character_list)
-            
-            primary_query = primary_query.replace(char_filter, f"i.character_name IN ('{char_names}')")
-            secondary_query = secondary_query.replace(char_filter, f"i.character_name IN ('{char_names}')")
-            
-            primary_params = {"primary_set_id": primary_set}
-            secondary_params = {"secondary_set_id": secondary_set}
-        
-        # Execute queries
-        primary_result = await database.fetch_all(primary_query, primary_params)
-        secondary_result = await database.fetch_all(secondary_query, secondary_params)
-        
-        # Process results by character
-        primary_by_char = {}
-        secondary_by_char = {}
-        
-        for row in primary_result:
-            char = row['character_name']
-            if char not in primary_by_char:
-                primary_by_char[char] = []
-            primary_by_char[char].append({
-                'name': row['name'],
-                'equipped': row['current_wielded_location'] > 0
-            })
-        
-        for row in secondary_result:
-            char = row['character_name']
-            if char not in secondary_by_char:
-                secondary_by_char[char] = []
-            secondary_by_char[char].append({
-                'name': row['name'],
-                'equipped': row['current_wielded_location'] > 0
-            })
-        
-        # Analyze combinations
-        analysis_results = []
-        all_characters = set(primary_by_char.keys()) | set(secondary_by_char.keys())
-        
-        for char in all_characters:
-            primary_items = primary_by_char.get(char, [])
-            secondary_items = secondary_by_char.get(char, [])
-            
-            primary_available = len(primary_items)
-            secondary_available = len(secondary_items)
-            
-            can_build = (primary_available >= primary_count and 
-                        secondary_available >= secondary_count)
-            
-            analysis_results.append({
-                'character_name': char,
-                'primary_set_available': primary_available,
-                'primary_set_needed': primary_count,
-                'secondary_set_available': secondary_available,
-                'secondary_set_needed': secondary_count,
-                'can_build_combination': can_build,
-                'primary_items': primary_items[:primary_count] if can_build else primary_items,
-                'secondary_items': secondary_items[:secondary_count] if can_build else secondary_items
-            })
-        
-        # Sort by characters who can build first
-        analysis_results.sort(key=lambda x: (not x['can_build_combination'], x['character_name']))
-        
-        # Get set names for response
-        attribute_set_info = ENUM_MAPPINGS.get('AttributeSetInfo', {}).get('values', {})
-        primary_set_name = attribute_set_info.get(str(primary_set), f"Set {primary_set}")
-        secondary_set_name = attribute_set_info.get(str(secondary_set), f"Set {secondary_set}")
-        
-        return {
-            'primary_set': {
-                'id': primary_set,
-                'name': primary_set_name,
-                'pieces_needed': primary_count
-            },
-            'secondary_set': {
-                'id': secondary_set,
-                'name': secondary_set_name,
-                'pieces_needed': secondary_count
-            },
-            'character_analysis': analysis_results,
-            'total_characters': len(analysis_results),
-            'characters_can_build': len([r for r in analysis_results if r['can_build_combination']])
-        }
-        
-    except Exception as e:
-        logger.error(f"Error in set combination analysis: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/slots/available")
-async def get_available_items_by_slot(
-    characters: str = Query(None, description="Comma-separated list of character names"),
-    include_all_characters: bool = Query(False, description="Include all characters"),
-    equipment_sets: str = Query(None, description="Comma-separated equipment set IDs to filter by"),
-    legendary_cantrips: str = Query(None, description="Comma-separated legendary cantrips to filter by"),
-    min_crit_damage_rating: int = Query(None, description="Minimum crit damage rating"),
-    min_damage_rating: int = Query(None, description="Minimum damage rating"),
-    min_armor_level: int = Query(None, description="Minimum armor level")
-):
-    """Get available items organized by equipment slot across multiple characters."""
-    try:
-        # Build character filter
-        if include_all_characters:
-            char_filter = "1=1"
-            query_params = {}
-        elif characters:
-            character_list = [c.strip() for c in characters.split(',') if c.strip()]
-            char_names = "', '".join(character_list)
-            char_filter = f"i.character_name IN ('{char_names}')"
-            query_params = {}
-        else:
-            raise HTTPException(status_code=400, detail="Must specify characters or include_all_characters")
-        
-        # Build constraints - only filter if we have specific constraints
-        constraints = []
-        if equipment_sets or legendary_cantrips or min_crit_damage_rating or min_damage_rating or min_armor_level:
-            # Only filter by object class if we have other filters 
-            constraints.append("i.object_class IN (2, 3, 4)")  # Armor and jewelry
-        else:
-            # For general slot queries, include more object classes but focus on equipment
-            constraints.append("i.object_class IN (1, 2, 3, 4, 6, 7, 8)")  # All equipment types
-        
-        # Equipment set filtering
-        if equipment_sets:
-            set_ids = [s.strip() for s in equipment_sets.split(',') if s.strip()]
-            set_filter = " OR ".join([f"(ird.int_values->>'265')::int = {set_id}" for set_id in set_ids])
-            constraints.append(f"ird.int_values ? '265' AND ({set_filter})")
-        
-        # Rating filters using gear totals
-        if min_crit_damage_rating:
-            constraints.append(f"COALESCE((ird.int_values->>'370')::int, 0) >= {min_crit_damage_rating}")
-        if min_damage_rating:
-            constraints.append(f"COALESCE((ird.int_values->>'372')::int, 0) >= {min_damage_rating}")
-        if min_armor_level:
-            constraints.append(f"COALESCE((ird.int_values->>'28')::int, 0) >= {min_armor_level}")
-        
-        # Build WHERE clause properly
-        where_parts = [char_filter]
-        if constraints:
-            where_parts.extend(constraints)
-        where_clause = " AND ".join(where_parts)
-        
-        # Debug: let's see how many items Barris actually has first
-        debug_query = f"SELECT COUNT(*) as total FROM items WHERE {char_filter}"
-        debug_result = await database.fetch_one(debug_query, query_params)
-        print(f"DEBUG: Total items for query: {debug_result['total']}")
-        
-        # Main query to get items with slot information
-        query = f"""
-            SELECT DISTINCT
-                i.id,
-                i.character_name,
-                i.name,
-                i.object_class,
-                i.current_wielded_location,
-                CASE 
-                    WHEN ird.int_values ? '9' THEN (ird.int_values->>'9')::int
-                    ELSE 0
-                END as valid_locations,
-                CASE 
-                    WHEN ird.int_values ? '218103822' THEN (ird.int_values->>'218103822')::int
-                    WHEN ird.int_values ? '218103821' THEN (ird.int_values->>'218103821')::int
-                    ELSE 0
-                END as coverage_mask,
-                CASE 
-                    WHEN ird.int_values ? '265' THEN (ird.int_values->>'265')::int
-                    ELSE NULL
-                END as item_set_id,
-                CASE 
-                    WHEN ird.int_values ? '28' THEN (ird.int_values->>'28')::int
-                    ELSE 0
-                END as armor_level,
-                CASE 
-                    WHEN ird.int_values ? '370' THEN (ird.int_values->>'370')::int
-                    ELSE 0
-                END as crit_damage_rating,
-                CASE 
-                    WHEN ird.int_values ? '372' THEN (ird.int_values->>'372')::int
-                    ELSE 0
-                END as damage_rating,
-                CASE 
-                    WHEN ird.int_values ? '16' THEN (ird.int_values->>'16')::int
-                    ELSE NULL
-                END as material_type
-            FROM items i
-            LEFT JOIN item_raw_data ird ON i.id = ird.item_id
-            WHERE {where_clause}
-            ORDER BY i.character_name, i.name
-        """
-        
-        # Cantrip filtering if requested
-        if legendary_cantrips:
-            cantrip_list = [c.strip() for c in legendary_cantrips.split(',') if c.strip()]
-            # Get spell IDs for the requested cantrips
-            cantrip_spell_ids = []
-            spells_data = ENUM_MAPPINGS.get('spells', {}).get('values', {})
-            for cantrip in cantrip_list:
-                for spell_id, spell_name in spells_data.items():
-                    if cantrip.lower() in spell_name.lower():
-                        cantrip_spell_ids.append(int(spell_id))
-            
-            if cantrip_spell_ids:
-                # Add JOIN to filter by spells
-                spell_placeholders = ','.join(map(str, cantrip_spell_ids))
-                query = query.replace("FROM items i", f"""
-                    FROM items i
-                    INNER JOIN item_spells isp ON i.id = isp.item_id 
-                    AND isp.spell_id IN ({spell_placeholders})
-                """)
-        
-        # Execute query
-        rows = await database.fetch_all(query, query_params)
-        
-        # Organize items by slot
-        slots_data = {}
-        
-        # Define the 9 armor slots we care about
-        armor_slots = {
-            1: "Head",
-            512: "Chest", 
-            2048: "Upper Arms",
-            4096: "Lower Arms", 
-            32: "Hands",
-            1024: "Abdomen",
-            8192: "Upper Legs",
-            16384: "Lower Legs", 
-            256: "Feet"
-        }
-        
-        # Jewelry slots
-        jewelry_slots = {
-            "Neck": "Neck",
-            "Left Ring": "Left Ring",
-            "Right Ring": "Right Ring", 
-            "Left Wrist": "Left Wrist",
-            "Right Wrist": "Right Wrist"
-        }
-        
-        # Initialize all slots
-        for slot_name in armor_slots.values():
-            slots_data[slot_name] = []
-        for slot_name in jewelry_slots.values():
-            slots_data[slot_name] = []
-        
-        # Process each item
-        for row in rows:
-            item_data = {
-                "id": row['id'],
-                "character_name": row['character_name'],
-                "name": row['name'],
-                "is_equipped": row['current_wielded_location'] > 0,
-                "armor_level": row['armor_level'],
-                "crit_damage_rating": row['crit_damage_rating'],
-                "damage_rating": row['damage_rating'],
-                "item_set_id": row['item_set_id']
-            }
-            
-            # Add material name if available
-            if row['material_type']:
-                material_name = ENUM_MAPPINGS.get('materials', {}).get(str(row['material_type']), '')
-                if material_name and not row['name'].lower().startswith(material_name.lower()):
-                    item_data['name'] = f"{material_name} {row['name']}"
-            
-            # Add set name if available
-            if row['item_set_id']:
-                attribute_set_info = ENUM_MAPPINGS.get('AttributeSetInfo', {}).get('values', {})
-                set_name = attribute_set_info.get(str(row['item_set_id']), '')
-                if set_name:
-                    item_data['set_name'] = set_name
-            
-            # Use the same slot computation logic as the search endpoint
-            equippable_slots = row['valid_locations']
-            coverage_value = row['coverage_mask']
-            slot_names = []
-            
-            if equippable_slots and equippable_slots > 0:
-                # Get sophisticated slot options (handles armor reduction)
-                has_material = row['material_type'] is not None
-                slot_options = get_sophisticated_slot_options(equippable_slots, coverage_value, has_material)
-                
-                # Convert slot options to friendly slot names
-                for slot_option in slot_options:
-                    slot_name = translate_equipment_slot(slot_option)
-                    if slot_name and slot_name not in slot_names:
-                        slot_names.append(slot_name)
-                
-                # Add item to each computed slot
-                for slot_name in slot_names:
-                    if slot_name in slots_data:
-                        slots_data[slot_name].append(item_data.copy())
-            
-            # Handle jewelry separately if armor logic didn't work
-            if row['object_class'] == 4 and not slot_names:  # Jewelry
-                item_name = row['name'].lower()
-                
-                if 'ring' in item_name:
-                    slots_data["Left Ring"].append(item_data.copy())
-                    slots_data["Right Ring"].append(item_data.copy())
-                elif any(word in item_name for word in ['bracelet', 'wrist']):
-                    slots_data["Left Wrist"].append(item_data.copy())
-                    slots_data["Right Wrist"].append(item_data.copy())
-                elif any(word in item_name for word in ['necklace', 'amulet', 'gorget']):
-                    slots_data["Neck"].append(item_data.copy())
-        
-        # Sort items within each slot by character name, then by name
-        for slot in slots_data:
-            slots_data[slot].sort(key=lambda x: (x['character_name'], x['name']))
-        
-        return {
-            "slots": slots_data,
-            "total_items": sum(len(items) for items in slots_data.values()),
-            "constraints_applied": {
-                "equipment_sets": equipment_sets.split(',') if equipment_sets else None,
-                "legendary_cantrips": legendary_cantrips.split(',') if legendary_cantrips else None,
-                "min_crit_damage_rating": min_crit_damage_rating,
-                "min_damage_rating": min_damage_rating,
-                "min_armor_level": min_armor_level
-            }
-        }
-        
-    except Exception as e:
-        logger.error(f"Error in slots/available endpoint: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/optimize/suits")
-async def optimize_suits(
-    # Character selection
-    characters: str = Query(None, description="Comma-separated list of character names"),
-    include_all_characters: bool = Query(False, description="Search across all characters"),
-    
-    # Equipment sets (primary/secondary requirements)
-    primary_set: str = Query(None, description="Primary equipment set ID (requires 5 pieces)"),
-    secondary_set: str = Query(None, description="Secondary equipment set ID (requires 4 pieces)"),
-    
-    # Spell requirements
-    legendary_cantrips: str = Query(None, description="Comma-separated list of required legendary cantrips"),
-    legendary_wards: str = Query(None, description="Comma-separated list of required legendary wards"),
-    
-    # Rating requirements
-    min_armor: int = Query(None, description="Minimum total armor level"),
-    max_armor: int = Query(None, description="Maximum total armor level"),
-    min_crit_damage: int = Query(None, description="Minimum total crit damage rating"),
-    max_crit_damage: int = Query(None, description="Maximum total crit damage rating"),
-    min_damage_rating: int = Query(None, description="Minimum total damage rating"),
-    max_damage_rating: int = Query(None, description="Maximum total damage rating"),
-    
-    # Equipment status
-    include_equipped: bool = Query(True, description="Include equipped items"),
-    include_inventory: bool = Query(True, description="Include inventory items"),
-    
-    # Locked slots (exclude from optimization)
-    locked_slots: str = Query(None, description="Comma-separated list of locked slot names"),
-    
-    # Result options
-    max_results: int = Query(10, ge=1, le=50, description="Maximum number of suit results to return")
-):
-    """
-    MagSuitbuilder-inspired constraint solver for optimal equipment combinations.
-    
-    Uses two-phase algorithm: ArmorSearcher with strict set filtering, then AccessorySearcher for spells.
-    """
-    try:
-        # Parse character selection
-        char_list = []
-        if include_all_characters:
-            # Get all unique character names
-            query = "SELECT DISTINCT character_name FROM items ORDER BY character_name"
-            async with database.transaction():
-                rows = await database.fetch_all(query)
-                char_list = [row['character_name'] for row in rows]
-        elif characters:
-            char_list = [c.strip() for c in characters.split(',') if c.strip()]
-        
-        if not char_list:
-            return {
-                "suits": [],
-                "message": "No characters specified",
-                "total_found": 0
-            }
-        
-        # Determine equipment status filtering logic
-        equipment_status_filter = None
-        if include_equipped and include_inventory:
-            equipment_status_filter = "both"  # Mix equipped and inventory items
-        elif include_equipped:
-            equipment_status_filter = "equipped_only"  # Only currently equipped items
-        elif include_inventory:
-            equipment_status_filter = "inventory_only"  # Only unequipped items
-        else:
-            return {
-                "suits": [],
-                "message": "Must include either equipped or inventory items",
-                "total_found": 0
-            }
-        
-        # Build constraints dictionary
-        constraints = {
-            'primary_set': int(primary_set) if primary_set else None,
-            'secondary_set': int(secondary_set) if secondary_set else None,
-            'min_armor': min_armor or 0,
-            'min_crit_damage': min_crit_damage or 0,
-            'min_damage_rating': min_damage_rating or 0,
-            'min_heal_boost': 0,
-            'legendary_cantrips': [c.strip() for c in legendary_cantrips.split(',') if c.strip()] if legendary_cantrips else [],
-            'protection_spells': [w.strip() for w in legendary_wards.split(',') if w.strip()] if legendary_wards else [],
-            'equipment_status_filter': equipment_status_filter
-        }
-        
-        # Initialize MagSuitbuilder-inspired solver
-        solver = ConstraintSatisfactionSolver(char_list, constraints)
-        
-        # Execute two-phase search algorithm
-        results = await solver.find_optimal_suits()
-        
-        return {
-            "suits": results["suits"],
-            "total_found": results["total_found"],
-            "armor_items_available": results.get("armor_items_available", 0),
-            "accessory_items_available": results.get("accessory_items_available", 0),
-            "message": results.get("message", "Search completed successfully"),
-            "constraints": constraints,
-            "characters_searched": char_list
-        }
-    
-    except Exception as e:
-        logger.error(f"Error in optimize/suits endpoint: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/debug/available-sets")
-async def get_available_sets(characters: str = Query(..., description="Comma-separated character names")):
-    """Debug endpoint to see what equipment sets are available"""
-    character_list = [c.strip() for c in characters.split(',') if c.strip()]
-    
-    query = """
-    SELECT DISTINCT enh.item_set, COUNT(*) as item_count
-    FROM items i
-    LEFT JOIN item_enhancements enh ON i.id = enh.item_id  
-    LEFT JOIN item_combat_stats cs ON i.id = cs.item_id
-    WHERE i.character_name = ANY(:characters)
-    AND cs.armor_level > 0
-    AND enh.item_set IS NOT NULL
-    GROUP BY enh.item_set
-    ORDER BY item_count DESC
-    """
-    
-    async with database.transaction():
-        rows = await database.fetch_all(query, {"characters": character_list})
-    
-    return {"available_sets": [{"set_id": row["item_set"], "armor_count": row["item_count"]} for row in rows]}
-
-@app.get("/debug/test-simple-search")
-async def test_simple_search(characters: str = Query(..., description="Comma-separated character names")):
-    """Test endpoint to find suits with NO constraints"""
-    character_list = [c.strip() for c in characters.split(',') if c.strip()]
-    
-    # Create minimal constraints (no set requirements, no cantrip requirements)
-    constraints = {
-        'primary_set': None,
-        'secondary_set': None, 
-        'min_armor': 0,
-        'min_crit_damage': 0,
-        'min_damage_rating': 0,
-        'min_heal_boost': 0,
-        'legendary_cantrips': [],
-        'protection_spells': [],
-        'equipment_status_filter': 'both'
-    }
-    
-    try:
-        solver = ConstraintSatisfactionSolver(character_list, constraints)
-        result = await solver.find_optimal_suits()
-        
-        return {
-            "message": "Simple search (no constraints) completed",
-            "suits_found": result.get("total_found", 0),
-            "armor_items_available": result.get("armor_items_available", 0),
-            "accessory_items_available": result.get("accessory_items_available", 0),
-            "sample_suits": result.get("suits", [])[:3]  # First 3 suits
-        }
-    except Exception as e:
-        logger.error(f"Error in simple search: {e}")
-        return {"error": str(e)}
-
-@app.get("/optimize/suits/stream")
-async def stream_optimize_suits(
-    characters: str = Query(..., description="Comma-separated character names"),
-    primary_set: Optional[int] = Query(None, description="Primary set ID requirement"),
-    secondary_set: Optional[int] = Query(None, description="Secondary set ID requirement"), 
-    min_armor: Optional[int] = Query(None, description="Minimum armor requirement"),
-    min_crit_damage: Optional[int] = Query(None, description="Minimum crit damage requirement"),
-    min_damage_rating: Optional[int] = Query(None, description="Minimum damage rating requirement"),
-    legendary_cantrips: Optional[str] = Query(None, description="Comma-separated legendary cantrips"),
-    legendary_wards: Optional[str] = Query(None, description="Comma-separated protection spells"),
-    include_equipped: bool = Query(True, description="Include equipped items"),
-    include_inventory: bool = Query(True, description="Include inventory items"),
-    search_depth: str = Query("balanced", description="Search depth: quick, balanced, deep, exhaustive")
-):
-    """Stream suit optimization results progressively using Server-Sent Events"""
-    
-    # Validate input
-    if not characters:
-        raise HTTPException(status_code=400, detail="No characters specified")
-    
-    # Split character names
-    character_list = [c.strip() for c in characters.split(',') if c.strip()]
-    
-    # Determine equipment status filter
-    if include_equipped and include_inventory:
-        equipment_status_filter = "both"
-    elif include_equipped:
-        equipment_status_filter = "equipped_only"
-    elif include_inventory:
-        equipment_status_filter = "inventory_only"
-    else:
-        raise HTTPException(status_code=400, detail="Must include either equipped or inventory items")
-    
-    # Build constraints
-    constraints = {
-        'primary_set': primary_set,
-        'secondary_set': secondary_set,
-        'min_armor': min_armor or 0,
-        'min_crit_damage': min_crit_damage or 0,
-        'min_damage_rating': min_damage_rating or 0,
-        'min_heal_boost': 0,
-        'legendary_cantrips': [c.strip() for c in legendary_cantrips.split(',') if c.strip()] if legendary_cantrips else [],
-        'protection_spells': [w.strip() for w in legendary_wards.split(',') if w.strip()] if legendary_wards else [],
-        'equipment_status_filter': equipment_status_filter
-    }
-    
-    async def generate_suits():
-        """Generator that yields suits progressively"""
-        solver = ConstraintSatisfactionSolver(character_list, constraints)
-        
-        # Configure search depth
-        search_limits = {
-            "quick": {"max_combinations": 10, "time_limit": 2},
-            "balanced": {"max_combinations": 50, "time_limit": 10},
-            "deep": {"max_combinations": 200, "time_limit": 30},
-            "exhaustive": {"max_combinations": 1000, "time_limit": 120}
-        }
-        
-        limit_config = search_limits.get(search_depth, search_limits["balanced"])
-        solver.max_combinations = limit_config["max_combinations"]
-        
-        # Start search
-        start_time = time.time()
-        found_count = 0
-        
-        try:
-            # Phase 1: Get armor items
-            logger.info(f"Starting search with constraints: {constraints}")
-            armor_items = await solver._get_armor_items_with_set_filtering()
-            logger.info(f"Found {len(armor_items)} armor items")
-            if not armor_items:
-                logger.warning("No armor items found matching set requirements")
-                yield {
-                    "event": "error",
-                    "data": json.dumps({"message": "No armor items found matching set requirements"})
-                }
-                return
-            
-            # Phase 2: Get accessories
-            accessory_items = await solver._get_accessory_items()
-            logger.info(f"Found {len(accessory_items)} accessory items")
-            
-            # Yield initial status
-            yield {
-                "event": "status",
-                "data": json.dumps({
-                    "armor_items": len(armor_items),
-                    "accessory_items": len(accessory_items),
-                    "search_depth": search_depth
-                })
-            }
-            
-            # Phase 3: Generate combinations progressively
-            armor_combinations = solver._generate_armor_combinations(armor_items)
-            logger.info(f"Generated {len(armor_combinations)} armor combinations")
-            
-            for i, armor_combo in enumerate(armor_combinations):
-                # Check time limit
-                if time.time() - start_time > limit_config["time_limit"]:
-                    yield {
-                        "event": "timeout",
-                        "data": json.dumps({"message": f"Search time limit reached ({limit_config['time_limit']}s)"})
-                    }
-                    break
-                
-                # Complete suit with accessories
-                complete_suit = solver._complete_suit_with_accessories(armor_combo, accessory_items)
-                if complete_suit:
-                    # Score the suit
-                    scored_suits = solver._score_suits([complete_suit])
-                    if scored_suits:
-                        logger.info(f"Combination {i}: scored {scored_suits[0]['score']}")
-                        if scored_suits[0]["score"] > 0:
-                            found_count += 1
-                            
-                            # Yield the suit
-                            yield {
-                                "event": "suit",
-                                "data": json.dumps(scored_suits[0])
-                            }
-                            
-                            # Yield progress update
-                            if found_count % 5 == 0:
-                                yield {
-                                    "event": "progress", 
-                                    "data": json.dumps({
-                                        "found": found_count,
-                                        "checked": i + 1,
-                                        "elapsed": round(time.time() - start_time, 1)
-                                    })
-                                }
-                        else:
-                            logger.info(f"Combination {i}: suit scored 0, skipping")
-                    else:
-                        logger.info(f"Combination {i}: no scored suits returned")
-                else:
-                    logger.info(f"Combination {i}: no complete suit generated")
-            
-            # Final status
-            yield {
-                "event": "complete",
-                "data": json.dumps({
-                    "total_found": found_count,
-                    "combinations_checked": len(armor_combinations),
-                    "total_time": round(time.time() - start_time, 1)
-                })
-            }
-            
-        except Exception as e:
-            logger.error(f"Error in streaming search: {e}")
-            yield {
-                "event": "error",
-                "data": json.dumps({"message": str(e)})
-            }
-    
-    return EventSourceResponse(generate_suits())
-
-
-async def organize_items_by_slot(rows, locked_slots_str=None):
-    """
-    Organize items by their possible equipment slots.
-    """
-    locked_slots = set(locked_slots_str.split(',')) if locked_slots_str else set()
-    
-    # Define all possible equipment slots
-    armor_slots = ["Head", "Chest", "Upper Arms", "Lower Arms", "Hands", 
-                   "Abdomen", "Upper Legs", "Lower Legs", "Feet"]
-    jewelry_slots = ["Neck", "Left Ring", "Right Ring", "Left Wrist", "Right Wrist", "Trinket"]
-    clothing_slots = ["Shirt", "Pants"]
-    
-    all_slots = armor_slots + jewelry_slots + clothing_slots
-    
-    # Initialize slot dictionary
-    items_by_slot = {slot: [] for slot in all_slots if slot not in locked_slots}
-    
-    # Debug: Track slot assignment for troubleshooting
-    debug_slot_assignments = {}
-    
-    for row in rows:
-        # Convert row to item dict
-        item = {
-            "item_id": row["item_id"],
-            "character_name": row["character_name"],
-            "name": row["name"],
-            "icon": row["icon"],
-            "object_class": row["object_class"],
-            "is_equipped": row["current_wielded_location"] > 0,
-            "armor_level": row["armor_level"],
-            "crit_damage_rating": row["crit_damage_rating"],
-            "damage_rating": row["damage_rating"],
-            "item_set_id": row["item_set_id"],
-            "spell_names": row["spell_names"] or [],
-            "valid_locations": row["valid_locations"],
-            "coverage_mask": row["coverage_mask"]
-        }
-        
-        # Determine which slots this item can go in
-        possible_slots = determine_item_slots(item)
-        
-        # Debug: Log slot assignment
-        debug_slot_assignments[item["name"]] = {
-            "coverage_mask": row["coverage_mask"], 
-            "possible_slots": possible_slots,
-            "is_equipped": item["is_equipped"],
-            "item_set_id": row["item_set_id"]
-        }
-        
-        # Add item to each possible slot (excluding locked slots)
-        for slot in possible_slots:
-            if slot in items_by_slot:  # Skip locked slots
-                items_by_slot[slot].append(item.copy())
-    
-    # Debug: Log slot assignment summary for Barris
-    if any("Barris" in row["character_name"] for row in rows):
-        logger.info(f"DEBUG: Barris slot assignments: {debug_slot_assignments}")
-    
-    return items_by_slot
-
-
-def decode_valid_locations_to_jewelry_slots(valid_locations):
-    """
-    Decode ValidLocations bitmask to jewelry slot names.
-    Based on EquipMask enum from Mag-Plugins.
-    """
-    slots = []
-    
-    # Jewelry slot mappings (EquipMask values)
-    jewelry_location_map = {
-        0x00000001: "Head",           # HeadWear
-        0x00000008: "Neck",           # Necklace  
-        0x00000010: "Chest",          # ChestArmor
-        0x00000080: "Abdomen",        # AbdomenArmor
-        0x00000020: "Upper Arms",     # UpperArmArmor
-        0x00000040: "Lower Arms",     # LowerArmArmor
-        0x00000002: "Hands",          # HandWear
-        0x00000100: "Left Ring",      # LeftFinger
-        0x00000200: "Right Ring",     # RightFinger
-        0x00000400: "Left Wrist",     # LeftWrist
-        0x00000800: "Right Wrist",    # RightWrist
-        0x00000004: "Feet",           # FootWear
-        0x00001000: "Upper Legs",     # UpperLegArmor
-        0x00002000: "Lower Legs",     # LowerLegArmor
-        0x00008000: "Trinket"         # TrinketOne
-    }
-    
-    # Check each jewelry-relevant bit
-    jewelry_bits = {
-        0x00000008: "Neck",           # Necklace  
-        0x00000100: "Left Ring",      # LeftFinger
-        0x00000200: "Right Ring",     # RightFinger
-        0x00000400: "Left Wrist",     # LeftWrist
-        0x00000800: "Right Wrist",    # RightWrist
-        0x00008000: "Trinket"         # TrinketOne
-    }
-    
-    for bit_value, slot_name in jewelry_bits.items():
-        if valid_locations & bit_value:
-            slots.append(slot_name)
-    
-    return slots
-
-
-def detect_jewelry_slots_by_name(item_name):
-    """
-    Fallback jewelry slot detection based on item name patterns.
-    """
-    slots = []
-    
-    if "ring" in item_name:
-        slots.extend(["Left Ring", "Right Ring"])
-    elif any(word in item_name for word in ["bracelet", "wrist"]):
-        slots.extend(["Left Wrist", "Right Wrist"])
-    elif any(word in item_name for word in ["necklace", "amulet", "gorget"]):
-        slots.append("Neck")
-    elif any(word in item_name for word in ["trinket", "compass", "goggles"]):
-        slots.append("Trinket")
-    else:
-        # Default jewelry fallback
-        slots.append("Trinket")
-    
-    return slots
-
-
-def determine_item_slots(item):
-    """
-    Determine which equipment slots an item can be equipped to.
-    """
-    slots = []
-    
-    # Handle jewelry by ValidLocations and name patterns
-    if item["object_class"] == 4:  # Jewelry
-        valid_locations = item.get("valid_locations", 0)
-        item_name = item["name"].lower()
-        
-        # Use ValidLocations bitmask if available (more accurate)
-        if valid_locations and valid_locations > 0:
-            jewelry_slots = decode_valid_locations_to_jewelry_slots(valid_locations)
-            if jewelry_slots:
-                slots.extend(jewelry_slots)
-            else:
-                # Fallback to name-based detection
-                slots.extend(detect_jewelry_slots_by_name(item_name))
-        else:
-            # Fallback to name-based detection
-            slots.extend(detect_jewelry_slots_by_name(item_name))
-    
-    # Handle armor/clothing by coverage mask or name patterns
-    elif item["object_class"] in [2, 3]:  # Armor (2) or Clothing (3)
-        coverage = item.get("coverage_mask", item.get("coverage", 0))
-        item_name = item["name"].lower()
-        
-        # Use coverage mask if available
-        if coverage and coverage > 0:
-            slots.extend(decode_coverage_to_slots(coverage, item["object_class"], item["name"]))
-        else:
-            # Fallback to name-based detection
-            if any(word in item_name for word in ["helm", "cap", "hat", "circlet", "crown"]):
-                slots.append("Head")
-            elif any(word in item_name for word in ["robe", "pallium", "robes"]):
-                slots.append("Robe")  # Robes have their own dedicated slot
-            elif any(word in item_name for word in ["chest", "cuirass", "hauberk"]):
-                slots.append("Chest")
-            elif item["object_class"] == 3:  # Handle ObjectClass 3 items (clothing and robes)
-                # Use coverage mask detection for all ObjectClass 3 items
-                slots.extend(decode_coverage_to_slots(coverage, item["object_class"], item["name"]))
-            elif any(word in item_name for word in ["gauntlet", "glove"]):
-                slots.append("Hands")
-            elif any(word in item_name for word in ["boot", "shoe", "slipper"]):
-                slots.append("Feet")
-            elif any(word in item_name for word in ["pant", "trouser", "legging"]):
-                # Armor leggings (ObjectClass 2)
-                slots.extend(["Abdomen", "Upper Legs", "Lower Legs"])
-            elif "bracer" in item_name:
-                slots.append("Lower Arms")
-            elif "pauldron" in item_name:
-                slots.append("Upper Arms")
-            elif "cloak" in item_name:
-                slots.append("Cloak")  # Cloaks have their own dedicated slot
-    
-    return slots if slots else ["Trinket"]  # Default fallback
-
-
-def decode_coverage_to_slots(coverage_mask, object_class=None, item_name=''):
-    """
-    Convert coverage mask to equipment slot names, including clothing.
-    Only classify as clothing if ObjectClass is 3 (Clothing).
-    """
-    slots = []
-    
-    # Only check for clothing patterns if this is actually a clothing item (ObjectClass 3)
-    if object_class == 3:
-        # Check for clothing patterns based on actual inventory data
-        # Specific coverage patterns for ObjectClass 3 clothing items:
-        
-        # Shirt pattern: OuterwearChest + OuterwearUpperArms + OuterwearLowerArms = 1024 + 4096 + 8192 = 13312
-        shirt_pattern = (coverage_mask & 1024) and (coverage_mask & 4096) and (coverage_mask & 8192)
-        if shirt_pattern:
-            slots.append("Shirt")
-            return slots  # Return early for clothing to avoid adding armor slots
-        
-        # Pants pattern: OuterwearUpperLegs + OuterwearLowerLegs + OuterwearAbdomen = 256 + 512 + 2048 = 2816  
-        pants_pattern = (coverage_mask & 256) and (coverage_mask & 512) and (coverage_mask & 2048)
-        if pants_pattern:
-            slots.append("Pants")
-            return slots  # Return early for clothing to avoid adding armor slots
-        
-        # Check for underwear patterns (theoretical)
-        # Shirt = UnderwearChest (8) + UnderwearAbdomen (16) = 24
-        if coverage_mask & 8 and coverage_mask & 16:  # UnderwearChest + UnderwearAbdomen
-            slots.append("Shirt")
-            return slots
-        
-        # Pants = UnderwearUpperLegs (2) + UnderwearLowerLegs (4) = 6  
-        if coverage_mask & 2 and coverage_mask & 4:  # UnderwearUpperLegs + UnderwearLowerLegs
-            slots.append("Pants")
-            return slots
-        
-        # Cloak = 131072 - Exclude cloaks from suit building
-        if coverage_mask & 131072:
-            slots.append("Cloak")  # Cloaks have their own dedicated slot
-            return slots
-        
-        # Robe detection - Check for robe patterns that might differ from shirt patterns
-        # If an item has chest coverage but is ObjectClass 3 and doesn't match shirt patterns,
-        # and has name indicators, classify as robe
-        if (coverage_mask & 1024) and any(word in item_name.lower() for word in ['robe', 'pallium']):
-            slots.append("Robe")  # Robes have their own dedicated slot
-            return slots
-    
-    # Armor coverage bit mappings
-    armor_coverage_map = {
-        1: "Head",
-        256: "Upper Legs",      # OuterwearUpperLegs
-        512: "Lower Legs",      # OuterwearLowerLegs  
-        1024: "Chest",          # OuterwearChest
-        2048: "Abdomen",        # OuterwearAbdomen
-        4096: "Upper Arms",     # OuterwearUpperArms
-        8192: "Lower Arms",     # OuterwearLowerArms
-        16384: "Head",          # Head
-        32768: "Hands",         # Hands
-        65536: "Feet",          # Feet
-    }
-    
-    # Jewelry coverage bit mappings
-    jewelry_coverage_map = {
-        262144: "Neck",         # Necklace coverage
-        524288: "Left Ring",    # Ring coverage
-        1048576: "Right Ring",  # Ring coverage  
-        2097152: "Left Wrist",  # Wrist coverage
-        4194304: "Right Wrist", # Wrist coverage
-        8388608: "Trinket"      # Trinket coverage
-    }
-    
-    # Check armor coverage bits
-    for bit_value, slot_name in armor_coverage_map.items():
-        if coverage_mask & bit_value:
-            slots.append(slot_name)
-    
-    # Check jewelry coverage bits 
-    for bit_value, slot_name in jewelry_coverage_map.items():
-        if coverage_mask & bit_value:
-            slots.append(slot_name)
-    
-    return list(set(slots))  # Remove duplicates
-
-
-
-def categorize_items_by_set(items):
-    """Categorize items by equipment set for efficient set-based optimization."""
-    items_by_set = {}
-    for item in items:
-        set_id = item.get("item_set_id")
-        if set_id:
-            if set_id not in items_by_set:
-                items_by_set[set_id] = []
-            items_by_set[set_id].append(item)
-    return items_by_set
-
-
-def categorize_items_by_spell(items, required_spells):
-    """Categorize items by spells for efficient spell-based optimization."""
-    items_by_spell = {spell: [] for spell in required_spells}
-    
-    for item in items:
-        item_spells = item.get("spell_names", [])
-        for spell in required_spells:
-            if spell in item_spells:
-                items_by_spell[spell].append(item)
-    
-    return items_by_spell
-
-
-def build_suit_set_priority(items_by_set, items_by_spell, items_by_slot, 
-                           primary_set, secondary_set, required_spells):
-    """Build suit prioritizing equipment set requirements first."""
-    suit = {
-        "items": {},
-        "stats": {"primary_set_count": 0, "secondary_set_count": 0, "required_spells_found": 0},
-        "missing": [],
-        "notes": []
-    }
-    used_items = set()
-    
-    # Priority 1: Place primary set items
-    if primary_set and int(primary_set) in items_by_set:
-        primary_items = sorted(items_by_set[int(primary_set)], 
-                             key=lambda x: x.get("armor_level", 0), reverse=True)
-        placed = place_set_items_optimally(suit, primary_items, 5, used_items, items_by_slot)
-        suit["stats"]["primary_set_count"] = placed
-    
-    # Priority 2: Place secondary set items
-    if secondary_set and int(secondary_set) in items_by_set:
-        secondary_items = sorted(items_by_set[int(secondary_set)], 
-                               key=lambda x: x.get("armor_level", 0), reverse=True)
-        placed = place_set_items_optimally(suit, secondary_items, 4, used_items, items_by_slot)
-        suit["stats"]["secondary_set_count"] = placed
-    
-    # Priority 3: Fill remaining slots with best available items
-    fill_remaining_slots_optimally(suit, items_by_slot, used_items, required_spells)
-    
-    return suit
-
-
-def build_suit_spell_priority(items_by_set, items_by_spell, items_by_slot,
-                             primary_set, secondary_set, required_spells):
-    """Build suit prioritizing spell requirements first."""
-    suit = {
-        "items": {},
-        "stats": {"primary_set_count": 0, "secondary_set_count": 0, "required_spells_found": 0},
-        "missing": [],
-        "notes": []
-    }
-    used_items = set()
-    
-    # Priority 1: Place items with required spells
-    for spell in required_spells:
-        if spell in items_by_spell and items_by_spell[spell]:
-            spell_items = sorted(items_by_spell[spell], 
-                               key=lambda x: x.get("armor_level", 0), reverse=True)
-            for item in spell_items[:2]:  # Limit to prevent spell hogging
-                if item["item_id"] not in used_items:
-                    slots = determine_item_slots(item)
-                    for slot in slots:
-                        if slot not in suit["items"]:
-                            suit["items"][slot] = item
-                            used_items.add(item["item_id"])
-                            suit["stats"]["required_spells_found"] += 1
-                            break
-    
-    # Priority 2: Add set items to remaining slots
-    if primary_set and int(primary_set) in items_by_set:
-        primary_items = items_by_set[int(primary_set)]
-        placed = place_set_items_optimally(suit, primary_items, 5, used_items, items_by_slot, replace_ok=False)
-        suit["stats"]["primary_set_count"] = placed
-    
-    if secondary_set and int(secondary_set) in items_by_set:
-        secondary_items = items_by_set[int(secondary_set)]
-        placed = place_set_items_optimally(suit, secondary_items, 4, used_items, items_by_slot, replace_ok=False)
-        suit["stats"]["secondary_set_count"] = placed
-    
-    # Priority 3: Fill remaining slots
-    fill_remaining_slots_optimally(suit, items_by_slot, used_items, required_spells)
-    
-    return suit
-
-
-def build_suit_balanced(items_by_set, items_by_spell, items_by_slot,
-                       primary_set, secondary_set, required_spells):
-    """Build suit using balanced approach between sets and spells."""
-    suit = {
-        "items": {},
-        "stats": {"primary_set_count": 0, "secondary_set_count": 0, "required_spells_found": 0},
-        "missing": [],
-        "notes": []
-    }
-    used_items = set()
-    
-    # Interleave set and spell placement
-    armor_slots = ["Head", "Chest", "Upper Arms", "Lower Arms", "Hands", 
-                   "Abdomen", "Upper Legs", "Lower Legs", "Feet"]
-    jewelry_slots = ["Neck", "Left Ring", "Right Ring", "Left Wrist", "Right Wrist", "Trinket"]
-    clothing_slots = ["Shirt", "Pants"]
-    
-    set_items = []
-    if primary_set and int(primary_set) in items_by_set:
-        set_items.extend(items_by_set[int(primary_set)][:5])
-    if secondary_set and int(secondary_set) in items_by_set:
-        set_items.extend(items_by_set[int(secondary_set)][:4])
-    
-    # Sort all candidate items by combined value (armor + spell count)
-    def item_value(item):
-        spell_bonus = len([s for s in item.get("spell_names", []) if s in required_spells]) * 100
-        return item.get("armor_level", 0) + spell_bonus
-    
-    all_candidates = []
-    for slot_items in items_by_slot.values():
-        all_candidates.extend(slot_items)
-    
-    # Remove duplicates and sort by value
-    unique_candidates = {item["item_id"]: item for item in all_candidates}.values()
-    sorted_candidates = sorted(unique_candidates, key=item_value, reverse=True)
-    
-    # Place items greedily by value
-    for item in sorted_candidates:
-        if item["item_id"] in used_items:
-            continue
-            
-        slots = determine_item_slots(item)
-        for slot in slots:
-            if slot not in suit["items"]:
-                suit["items"][slot] = item
-                used_items.add(item["item_id"])
-                
-                # Update stats
-                item_set = item.get("item_set_id")
-                if primary_set and item_set == int(primary_set):
-                    suit["stats"]["primary_set_count"] += 1
-                elif secondary_set and item_set == int(secondary_set):
-                    suit["stats"]["secondary_set_count"] += 1
-                
-                item_spells = item.get("spell_names", [])
-                for spell in required_spells:
-                    if spell in item_spells:
-                        suit["stats"]["required_spells_found"] += 1
-                break
-    
-    return suit
-
-
-def place_set_items_optimally(suit, set_items, target_count, used_items, items_by_slot, replace_ok=True):
-    """Place set items optimally in available slots."""
-    placed_count = 0
-    
-    # Sort items by value (armor level, spell count, etc.)
-    def item_value(item):
-        return item.get("armor_level", 0) + len(item.get("spell_names", [])) * 10
-    
-    sorted_items = sorted(set_items, key=item_value, reverse=True)
-    
-    for item in sorted_items:
-        if placed_count >= target_count:
-            break
-            
-        if item["item_id"] in used_items:
-            continue
-            
-        slots = determine_item_slots(item)
-        placed = False
-        
-        for slot in slots:
-            # Try to place in empty slot first
-            if slot not in suit["items"]:
-                suit["items"][slot] = item
-                used_items.add(item["item_id"])
-                placed_count += 1
-                placed = True
-                break
-            # If replace_ok and this item is better, replace existing
-            elif replace_ok and item_value(item) > item_value(suit["items"][slot]):
-                old_item = suit["items"][slot]
-                used_items.discard(old_item["item_id"])
-                suit["items"][slot] = item
-                used_items.add(item["item_id"])
-                placed = True
-                break
-        
-        if placed:
-            continue
-    
-    return placed_count
-
-
-def fill_remaining_slots_optimally(suit, items_by_slot, used_items, required_spells):
-    """Fill remaining empty slots with best available items."""
-    armor_slots = ["Head", "Chest", "Upper Arms", "Lower Arms", "Hands", 
-                   "Abdomen", "Upper Legs", "Lower Legs", "Feet"]
-    jewelry_slots = ["Neck", "Left Ring", "Right Ring", "Left Wrist", "Right Wrist", "Trinket"]
-    clothing_slots = ["Shirt", "Pants"]
-    
-    for slot in armor_slots + jewelry_slots + clothing_slots:
-        if slot in suit["items"]:  # Slot already filled
-            continue
-            
-        if slot not in items_by_slot or not items_by_slot[slot]:
-            continue
-            
-        # Find best available item for this slot
-        available_items = [item for item in items_by_slot[slot] 
-                          if item["item_id"] not in used_items]
-        
-        if available_items:
-            # Score items by armor + spell value
-            def item_value(item):
-                spell_bonus = len([s for s in item.get("spell_names", []) if s in required_spells]) * 50
-                return item.get("armor_level", 0) + spell_bonus
-            
-            best_item = max(available_items, key=item_value)
-            suit["items"][slot] = best_item
-            used_items.add(best_item["item_id"])
-
-
-def is_duplicate_suit(new_suit, existing_suits):
-    """Check if this suit is substantially the same as an existing one."""
-    new_items = set(item["item_id"] for item in new_suit["items"].values())
-    
-    for existing_suit in existing_suits:
-        existing_items = set(item["item_id"] for item in existing_suit["items"].values())
-        
-        # If 80% or more items are the same, consider it a duplicate
-        if len(new_items & existing_items) / max(len(new_items), 1) >= 0.8:
-            return True
-    
-    return False
-
-
-def calculate_suit_stats(suit, primary_set, secondary_set, required_spells):
-    """Calculate comprehensive statistics for a suit."""
-    suit["stats"] = {
-        "total_armor": 0,
-        "total_crit_damage": 0,
-        "total_damage_rating": 0,
-        "primary_set_count": 0,
-        "secondary_set_count": 0,
-        "required_spells_found": 0
-    }
-    
-    found_spells = set()
-    
-    for item in suit["items"].values():
-        # Accumulate stats
-        suit["stats"]["total_armor"] += item.get("armor_level", 0)
-        suit["stats"]["total_crit_damage"] += item.get("crit_damage_rating", 0) 
-        suit["stats"]["total_damage_rating"] += item.get("damage_rating", 0)
-        
-        # Count set pieces
-        item_set = item.get("item_set_id")
-        if primary_set and item_set == int(primary_set):
-            suit["stats"]["primary_set_count"] += 1
-        if secondary_set and item_set == int(secondary_set):
-            suit["stats"]["secondary_set_count"] += 1
-        
-        # Count unique required spells
-        item_spells = item.get("spell_names", [])
-        for spell in required_spells:
-            if spell in item_spells:
-                found_spells.add(spell)
-    
-    suit["stats"]["required_spells_found"] = len(found_spells)
-
-
-class ConstraintSatisfactionSolver:
-    """
-    MagSuitbuilder-inspired two-phase constraint satisfaction solver.
-    
-    Phase 1: ArmorSearcher - Strict set filtering for armor pieces
-    Phase 2: AccessorySearcher - Spell optimization for jewelry/clothing
-    """
-    
-    def __init__(self, characters, constraints):
-        self.characters = characters
-        self.constraints = constraints
-        self.primary_set = constraints.get('primary_set')
-        self.secondary_set = constraints.get('secondary_set')
-        self.min_armor = constraints.get('min_armor', 0)
-        self.min_crit_damage = constraints.get('min_crit_damage', 0)
-        self.min_damage_rating = constraints.get('min_damage_rating', 0)
-        self.min_heal_boost = constraints.get('min_heal_boost', 0)
-        self.legendary_cantrips = constraints.get('legendary_cantrips', [])
-        self.protection_spells = constraints.get('protection_spells', [])
-        self.equipment_status_filter = constraints.get('equipment_status_filter', 'both')
-        
-        
-    async def find_optimal_suits(self):
-        """Find optimal equipment combinations using MagSuitbuilder's two-phase algorithm"""
-        try:
-            # Phase 1: ArmorSearcher - Get armor pieces with strict set filtering
-            armor_items = await self._get_armor_items_with_set_filtering()
-            
-            if not armor_items:
-                return {
-                    "suits": [],
-                    "message": "No armor items found matching set requirements",
-                    "total_found": 0
-                }
-            
-            # Phase 2: AccessorySearcher - Get jewelry/clothing (no set restrictions)
-            accessory_items = await self._get_accessory_items()
-            
-            # Generate armor combinations (9 slots max)
-            armor_combinations = self._generate_armor_combinations(armor_items)
-            
-            # For each viable armor combination, find best accessories
-            suits = []
-            for armor_combo in armor_combinations[:100]:  # Limit to prevent timeout
-                complete_suit = self._complete_suit_with_accessories(armor_combo, accessory_items)
-                if complete_suit:
-                    suits.append(complete_suit)
-            
-            # Score and rank suits
-            scored_suits = self._score_suits(suits)
-            
-            return {
-                "suits": scored_suits[:20],
-                "total_found": len(scored_suits),
-                "armor_items_available": len(armor_items),
-                "accessory_items_available": len(accessory_items)
-            }
-            
-        except Exception as e:
-            print(f"Error in constraint solver: {e}")
-            return {
-                "suits": [],
-                "message": f"Error: {str(e)}",
-                "total_found": 0
-            }
-    
-    def _item_meets_constraints(self, item):
-        """Check if an item contributes to meeting the specified constraints"""
-        # Convert item data for consistency
-        item_spells = item.get("spell_names", "")
-        if isinstance(item_spells, str):
-            item_spell_list = [s.strip() for s in item_spells.split(",") if s.strip()]
-        else:
-            item_spell_list = item_spells or []
-        
-        item_armor = item.get("armor_level", 0) or 0
-        item_crit = int(item.get("gear_crit_damage", 0) or 0)
-        item_damage = int(item.get("gear_damage_rating", 0) or 0)
-        item_heal = int(item.get("gear_heal_boost", 0) or 0)
-        item_set = int(item.get("item_set_id", 0) or 0)
-        
-        # If no constraints specified, item is useful if it has any meaningful stats
-        has_any_constraints = (
-            self.primary_set or self.secondary_set or
-            self.legendary_cantrips or self.protection_spells or
-            self.min_armor > 0 or self.min_crit_damage > 0 or
-            self.min_damage_rating > 0 or self.min_heal_boost > 0
-        )
-        
-        if not has_any_constraints:
-            # No constraints specified - any item with decent stats is useful
-            return item_armor > 0 or item_crit > 0 or item_damage > 0 or item_heal > 0
-        
-        # Check if item contributes to any constraint
-        contributes_to_constraint = False
-        
-        # Set constraints
-        if self.primary_set and item_set == self.primary_set:
-            contributes_to_constraint = True
-        if self.secondary_set and item_set == self.secondary_set:
-            contributes_to_constraint = True
-        
-        # Spell constraints
-        required_spell_names = self.legendary_cantrips + self.protection_spells
-        if required_spell_names:
-            for required_spell in required_spell_names:
-                for item_spell in item_spell_list:
-                    # Fuzzy matching like in scoring
-                    spell_words = item_spell.lower().split()
-                    required_words = required_spell.lower().split()
-                    matches_all_words = all(any(req_word in spell_word for spell_word in spell_words) 
-                                           for req_word in required_words)
-                    if matches_all_words:
-                        contributes_to_constraint = True
-                        break
-                if contributes_to_constraint:
-                    break
-        
-        # Stat constraints - item helps if it has meaningful amounts of required stats
-        if self.min_armor > 0 and item_armor >= 100:  # Meaningful armor contribution
-            contributes_to_constraint = True
-        if self.min_crit_damage > 0 and item_crit >= 5:  # Meaningful crit contribution
-            contributes_to_constraint = True
-        if self.min_damage_rating > 0 and item_damage >= 5:  # Meaningful damage contribution
-            contributes_to_constraint = True
-        if self.min_heal_boost > 0 and item_heal >= 5:  # Meaningful heal contribution
-            contributes_to_constraint = True
-        
-        return contributes_to_constraint
-
-    async def _get_armor_items_with_set_filtering(self):
-        """Phase 1: ArmorSearcher - Get armor with strict constraint filtering"""
-        query = """
-        SELECT DISTINCT i.id, i.character_name, i.item_id, i.name, i.icon, i.object_class,
-               i.current_wielded_location, i.timestamp,
-               enh.item_set as item_set_id,
-               cs.armor_level,
-               rd.int_values->>'374' as gear_crit_damage,
-               rd.int_values->>'370' as gear_damage_rating,
-               rd.int_values->>'372' as gear_heal_boost,
-               COALESCE((rd.int_values->>'218103821')::int, 0) as coverage,
-               string_agg(isp.spell_id::text, ',') as spell_ids
-        FROM items i
-        LEFT JOIN item_combat_stats cs ON i.id = cs.item_id
-        LEFT JOIN item_enhancements enh ON i.id = enh.item_id
-        LEFT JOIN item_raw_data rd ON i.id = rd.item_id
-        LEFT JOIN item_spells isp ON i.id = isp.item_id
-        WHERE i.character_name = ANY(:characters)
-        AND cs.armor_level > 0
-        """
-        
-        logger.info(f"Filtering armor for constraints: primary_set={self.primary_set}, secondary_set={self.secondary_set}, cantrips={self.legendary_cantrips}, wards={self.protection_spells}")
-        
-        # Apply set filtering if any sets are specified
-        set_filters = []
-        params = {"characters": self.characters}
-        
-        if self.primary_set:
-            set_filters.append("enh.item_set = :primary_set")
-            params["primary_set"] = str(self.primary_set)
-            
-        if self.secondary_set:
-            set_filters.append("enh.item_set = :secondary_set")
-            params["secondary_set"] = str(self.secondary_set)
-            
-        if set_filters:
-            query += f" AND ({' OR '.join(set_filters)})"
-            logger.info(f"Applied set filtering: {' OR '.join(set_filters)}")
-        else:
-            logger.info("No set filtering applied - will use all armor items")
-        
-        # Apply equipment status filtering
-        if self.equipment_status_filter == "equipped_only":
-            query += " AND i.current_wielded_location > 0"
-        elif self.equipment_status_filter == "inventory_only":
-            query += " AND i.current_wielded_location = 0"
-        # "both" requires no additional filter
-        
-        query += """
-        GROUP BY i.id, i.character_name, i.item_id, i.name, i.icon, i.object_class,
-                 i.current_wielded_location, i.timestamp,
-                 enh.item_set, cs.armor_level, rd.int_values->>'374', rd.int_values->>'370', rd.int_values->>'372', rd.int_values->>'218103821'
-        ORDER BY cs.armor_level DESC
-        """
-        
-        async with database.transaction():
-            rows = await database.fetch_all(query, params)
-            
-        items = []
-        spells_enum = ENUM_MAPPINGS.get('spells', {})
-        
-        for row in rows:
-            item = dict(row)
-            # Apply proper slot detection (including clothing)
-            item_for_slots = {
-                "object_class": item.get("object_class"),
-                "coverage_mask": item.get("coverage", 0),
-                "name": item.get("name", ""),
-                "valid_locations": item.get("valid_locations", 0)
-            }
-            slots = determine_item_slots(item_for_slots)
-            item["slot_name"] = ", ".join(slots)
-            
-            # Convert spell IDs to spell names
-            spell_ids_str = item.get("spell_ids", "")
-            spell_names = []
-            if spell_ids_str:
-                spell_ids = [int(sid.strip()) for sid in spell_ids_str.split(',') if sid.strip()]
-                for spell_id in spell_ids:
-                    spell_data = spells_enum.get(spell_id)
-                    if spell_data and isinstance(spell_data, dict):
-                        spell_name = spell_data.get('name', f'Unknown Spell {spell_id}')
-                        spell_names.append(spell_name)
-                    elif spell_data:
-                        spell_names.append(str(spell_data))
-            
-            item["spell_names"] = ", ".join(spell_names)
-            
-            # CRITICAL: Only include items that contribute to constraints
-            if self._item_meets_constraints(item):
-                items.append(item)
-                logger.debug(f"Included armor: {item['name']} (set: {item.get('item_set_id')}, spells: {item['spell_names'][:50]}...)")
-            else:
-                logger.debug(f"Filtered out armor: {item['name']} (set: {item.get('item_set_id')}, spells: {item['spell_names'][:50]}...) - doesn't meet constraints")
-            
-        logger.info(f"Armor filtering: {len(items)} items meet constraints out of {len(rows)} total armor items")
-        return items
-    
-    async def _get_accessory_items(self):
-        """Phase 2: AccessorySearcher - Get jewelry/clothing with constraint filtering"""
-        query = """
-        SELECT DISTINCT i.id, i.character_name, i.item_id, i.name, i.icon, i.object_class,
-               i.current_wielded_location, i.timestamp,
-               enh.item_set as item_set_id,
-               cs.armor_level,
-               COALESCE((rd.int_values->>'218103821')::int, 0) as coverage,
-               COALESCE((rd.int_values->>'9')::int, 0) as valid_locations,
-               COALESCE((rd.int_values->>'374')::int, 0) as gear_crit_damage,
-               COALESCE((rd.int_values->>'370')::int, 0) as gear_damage_rating,
-               COALESCE((rd.int_values->>'372')::int, 0) as gear_heal_boost,
-               string_agg(isp.spell_id::text, ',') as spell_ids
-        FROM items i
-        LEFT JOIN item_combat_stats cs ON i.id = cs.item_id
-        LEFT JOIN item_enhancements enh ON i.id = enh.item_id
-        LEFT JOIN item_raw_data rd ON i.id = rd.item_id
-        LEFT JOIN item_spells isp ON i.id = isp.item_id
-        WHERE i.character_name = ANY(:characters)
-        AND (i.object_class = 4   -- Jewelry (ObjectClass 4)
-             OR (i.object_class = 3 AND (
-                 ((rd.int_values->>'218103821')::int & 1024 = 1024 AND (rd.int_values->>'218103821')::int & 4096 = 4096 AND (rd.int_values->>'218103821')::int & 8192 = 8192)  -- Shirt pattern (13312)
-                 OR ((rd.int_values->>'218103821')::int & 256 = 256 AND (rd.int_values->>'218103821')::int & 512 = 512 AND (rd.int_values->>'218103821')::int & 2048 = 2048)  -- Pants pattern (2816)
-                 OR (rd.int_values->>'218103821')::int & 24 = 24  -- Underwear Shirt
-                 OR (rd.int_values->>'218103821')::int & 6 = 6  -- Underwear Pants
-             ) AND LOWER(i.name) NOT LIKE '%robe%' AND LOWER(i.name) NOT LIKE '%pallium%'))  -- Exclude robes and palliums from suit building
-        """
-        
-        # Apply equipment status filtering
-        if self.equipment_status_filter == "equipped_only":
-            query += " AND i.current_wielded_location > 0"
-        elif self.equipment_status_filter == "inventory_only":
-            query += " AND i.current_wielded_location = 0"
-        # "both" requires no additional filter
-        
-        query += """
-        GROUP BY i.id, i.character_name, i.item_id, i.name, i.icon, i.object_class,
-                 i.current_wielded_location, i.timestamp,
-                 enh.item_set, cs.armor_level, rd.int_values->>'218103821',
-                 rd.int_values->>'9', rd.int_values->>'374', 
-                 rd.int_values->>'370', rd.int_values->>'372'
-        ORDER BY cs.armor_level DESC
-        """
-        
-        params = {"characters": self.characters}
-        
-        async with database.transaction():
-            rows = await database.fetch_all(query, params)
-            
-        items = []
-        spells_enum = ENUM_MAPPINGS.get('spells', {})
-        
-        for row in rows:
-            item = dict(row)
-            # Apply proper slot detection (including clothing)
-            item_for_slots = {
-                "object_class": item.get("object_class"),
-                "coverage_mask": item.get("coverage", 0),
-                "name": item.get("name", ""),
-                "valid_locations": item.get("valid_locations", 0)
-            }
-            slots = determine_item_slots(item_for_slots)
-            item["slot_name"] = ", ".join(slots)
-            
-            # Convert spell IDs to spell names
-            spell_ids_str = item.get("spell_ids", "")
-            spell_names = []
-            if spell_ids_str:
-                spell_ids = [int(sid.strip()) for sid in spell_ids_str.split(',') if sid.strip()]
-                for spell_id in spell_ids:
-                    spell_data = spells_enum.get(spell_id)
-                    if spell_data and isinstance(spell_data, dict):
-                        spell_name = spell_data.get('name', f'Unknown Spell {spell_id}')
-                        spell_names.append(spell_name)
-                    elif spell_data:
-                        spell_names.append(str(spell_data))
-            
-            item["spell_names"] = ", ".join(spell_names)
-            
-            # CRITICAL: Only include accessories that contribute to constraints  
-            if self._item_meets_constraints(item):
-                items.append(item)
-                logger.debug(f"Included accessory: {item['name']} (spells: {item['spell_names'][:50]}..., crit: {item.get('gear_crit_damage', 0)}, damage: {item.get('gear_damage_rating', 0)})")
-            else:
-                logger.debug(f"Filtered out accessory: {item['name']} (spells: {item['spell_names'][:50]}...) - doesn't meet constraints")
-            
-        logger.info(f"Accessory filtering: {len(items)} items meet constraints out of {len(rows)} total accessory items")
-        return items
-    
-    def _generate_armor_combinations(self, armor_items):
-        """Generate ALL viable armor combinations using MagSuitbuilder's recursive approach"""
-        if not armor_items:
-            logger.warning("No armor items provided to _generate_armor_combinations")
-            return []
-            
-        # Group armor by slot
-        armor_by_slot = {}
-        for item in armor_items:
-            slots = item.get("slot_name", "").split(", ")
-            for slot in slots:
-                slot = slot.strip()
-                if slot and slot not in ["Neck", "Left Ring", "Right Ring", "Left Wrist", "Right Wrist", "Trinket"]:
-                    if slot not in armor_by_slot:
-                        armor_by_slot[slot] = []
-                    armor_by_slot[slot].append(item)
-        
-        logger.info(f"Armor grouped by slot: {[(slot, len(items)) for slot, items in armor_by_slot.items()]}")
-        
-        # Sort slots by number of items (least first for faster pruning)
-        slot_list = sorted(armor_by_slot.items(), key=lambda x: len(x[1]))
-        
-        # Initialize search state
-        self.combinations_found = []
-        self.best_scores = {}  # Track best scores to prune bad branches
-        self.max_combinations = 20  # Limit to prevent timeout
-        
-        # Start recursive search
-        current_combo = {}
-        self._recursive_armor_search(slot_list, 0, current_combo, set())
-        
-        logger.info(f"Generated {len(self.combinations_found)} armor combinations")
-        
-        # Return unique combinations sorted by score
-        return self.combinations_found[:self.max_combinations]
-    
-    def _recursive_armor_search(self, slot_list, index, current_combo, used_items):
-        """Recursive backtracking search (MagSuitbuilder approach)"""
-        # Base case: we've processed all slots
-        if index >= len(slot_list):
-            if current_combo:
-                # Calculate combo score
-                combo_score = self._calculate_combo_score(current_combo)
-                
-                # Only keep if it's a good combination
-                if combo_score >= 50:  # Minimum threshold
-                    # Check if we already have a similar combo
-                    if not self._is_duplicate_combo(current_combo):
-                        self.combinations_found.append(dict(current_combo))
-                        # Sort by score to keep best ones
-                        self.combinations_found.sort(
-                            key=lambda x: self._calculate_combo_score(x), 
-                            reverse=True
-                        )
-                        # Keep only top combinations
-                        if len(self.combinations_found) > self.max_combinations * 2:
-                            self.combinations_found = self.combinations_found[:self.max_combinations]
-            return
-        
-        # Stop if we've found enough good combinations
-        if len(self.combinations_found) >= self.max_combinations:
-            return
-        
-        slot_name, items = slot_list[index]
-        
-        # Try each item in this slot
-        for item in items[:5]:  # Limit items per slot to prevent explosion
-            if item["item_id"] not in used_items:
-                # Check if this item would help meet set requirements
-                if self._should_try_item(item, current_combo):
-                    # Push: Add item to current combination
-                    current_combo[slot_name] = item
-                    used_items.add(item["item_id"])
-                    
-                    # Recurse to next slot
-                    self._recursive_armor_search(slot_list, index + 1, current_combo, used_items)
-                    
-                    # Pop: Remove item (backtrack)
-                    del current_combo[slot_name]
-                    used_items.remove(item["item_id"])
-        
-        # Also try skipping this slot entirely (empty slot)
-        self._recursive_armor_search(slot_list, index + 1, current_combo, used_items)
-    
-    def _calculate_combo_score(self, combo):
-        """Quick score calculation for pruning"""
-        primary_set_int = int(self.primary_set) if self.primary_set else None
-        secondary_set_int = int(self.secondary_set) if self.secondary_set else None
-        
-        primary_count = sum(1 for item in combo.values() 
-                          if int(item.get("item_set_id", 0) or 0) == primary_set_int)
-        secondary_count = sum(1 for item in combo.values() 
-                            if int(item.get("item_set_id", 0) or 0) == secondary_set_int)
-        
-        score = 0
-        if primary_count >= 5:
-            score += 50
-        else:
-            score += primary_count * 8
-            
-        if secondary_count >= 4:
-            score += 40
-        else:
-            score += secondary_count * 8
-            
-        return score
-    
-    def _should_try_item(self, item, current_combo):
-        """Check if item is worth trying - must meet constraints and set logic"""
-        # CRITICAL: Item must meet constraints to be considered
-        if not self._item_meets_constraints(item):
-            return False
-        
-        primary_set_int = int(self.primary_set) if self.primary_set else None
-        secondary_set_int = int(self.secondary_set) if self.secondary_set else None
-        item_set_int = int(item.get("item_set_id", 0) or 0)
-        
-        # Count current sets
-        primary_count = sum(1 for i in current_combo.values() 
-                          if int(i.get("item_set_id", 0) or 0) == primary_set_int)
-        secondary_count = sum(1 for i in current_combo.values() 
-                            if int(i.get("item_set_id", 0) or 0) == secondary_set_int)
-        
-        # Apply MagSuitbuilder's logic but with constraint checking
-        if item_set_int == primary_set_int and primary_count < 5:
-            return True
-        elif item_set_int == secondary_set_int and secondary_count < 4:
-            return True
-        elif not item_set_int:  # Non-set items allowed if we have room and they meet constraints
-            return len(current_combo) < 9
-        else:  # Wrong set item
-            return False
-    
-    def _is_duplicate_combo(self, combo):
-        """Check if we already have this combination"""
-        combo_items = set(item["item_id"] for item in combo.values())
-        
-        for existing in self.combinations_found:
-            existing_items = set(item["item_id"] for item in existing.values())
-            if combo_items == existing_items:
-                return True
-        return False
-    
-    def _build_optimal_combination(self, armor_by_slot, strategy="balanced"):
-        """Build a single combination using specified strategy"""
-        combination = {}
-        primary_count = 0
-        secondary_count = 0
-        
-        primary_set_int = int(self.primary_set) if self.primary_set else None
-        secondary_set_int = int(self.secondary_set) if self.secondary_set else None
-        
-        # Process slots in order
-        for slot, items in armor_by_slot.items():
-            best_item = None
-            best_score = -1
-            
-            for item in items:
-                item_set_int = int(item.get("item_set_id", 0) or 0)
-                score = 0
-                
-                if strategy == "armor":
-                    # Prioritize armor level
-                    score = item.get("armor_level", 0)
-                    if item_set_int == primary_set_int:
-                        score += 50
-                    elif item_set_int == secondary_set_int:
-                        score += 30
-                        
-                elif strategy == "primary":
-                    # Maximize primary set
-                    if item_set_int == primary_set_int and primary_count < 5:
-                        score = 1000
-                    elif item_set_int == secondary_set_int and secondary_count < 4:
-                        score = 500
-                    else:
-                        score = item.get("armor_level", 0)
-                        
-                elif strategy == "balanced":
-                    # Balance sets according to requirements
-                    if item_set_int == primary_set_int and primary_count < 5:
-                        score = 800
-                    elif item_set_int == secondary_set_int and secondary_count < 4:
-                        score = 600
-                    else:
-                        score = item.get("armor_level", 0) / 10
-                
-                if score > best_score:
-                    best_item = item
-                    best_score = score
-            
-            if best_item:
-                combination[slot] = best_item
-                item_set_int = int(best_item.get("item_set_id", 0) or 0)
-                if item_set_int == primary_set_int:
-                    primary_count += 1
-                elif item_set_int == secondary_set_int:
-                    secondary_count += 1
-        
-        return combination if combination else None
-    
-    def _build_equipped_preferred_combination(self, armor_by_slot):
-        """Build combination preferring currently equipped items"""
-        combination = {}
-        
-        for slot, items in armor_by_slot.items():
-            # Prefer equipped items
-            equipped_items = [item for item in items if item.get("current_wielded_location", 0) > 0]
-            if equipped_items:
-                # Take the best equipped item for this slot
-                combination[slot] = max(equipped_items, key=lambda x: x.get("armor_level", 0))
-            elif items:
-                # Fall back to best available
-                combination[slot] = items[0]
-        
-        return combination if combination else None
-    
-    def _complete_suit_with_accessories(self, armor_combo, accessory_items):
-        """Complete armor combination with systematic jewelry optimization"""
-        complete_suit = {"items": dict(armor_combo)}
-        
-        # Only optimize accessories if there are accessory-related constraints
-        has_accessory_constraints = (
-            self.legendary_cantrips or 
-            self.protection_spells or 
-            self.min_crit_damage > 0 or 
-            self.min_damage_rating > 0 or
-            self.min_heal_boost > 0
-        )
-        
-        if has_accessory_constraints:
-            # Systematically optimize jewelry slots
-            jewelry_items = [item for item in accessory_items if item.get("object_class") == 4]
-            self._optimize_jewelry_systematically(complete_suit, jewelry_items)
-            
-            # Also optimize clothing slots
-            clothing_items = [item for item in accessory_items if item.get("object_class") == 3]
-            self._optimize_clothing_systematically(complete_suit, clothing_items)
-        
-        return complete_suit
-    
-    def _optimize_jewelry_systematically(self, suit, jewelry_items):
-        """
-        Systematically optimize all 6 jewelry slots for maximum benefit.
-        Phase 3D.2 implementation.
-        """
-        # Group jewelry by slot
-        jewelry_by_slot = self._group_jewelry_by_slot(jewelry_items)
-        
-        # Define jewelry slot priority (amulets often have best spells)
-        jewelry_slot_priority = [
-            "Neck",          # Amulets/necklaces often have legendary cantrips
-            "Left Ring",     # Rings often have high ratings
-            "Right Ring",
-            "Left Wrist",    # Bracelets 
-            "Right Wrist",
-            "Trinket"        # Special items
-        ]
-        
-        # Track spells already covered by armor
-        covered_spells = set()
-        for item in suit["items"].values():
-            item_spells = item.get("spell_names", "")
-            if item_spells:
-                if isinstance(item_spells, str):
-                    covered_spells.update(item_spells.split(", "))
-                elif isinstance(item_spells, list):
-                    covered_spells.update(item_spells)
-        
-        # Optimize each jewelry slot
-        for slot in jewelry_slot_priority:
-            if slot in jewelry_by_slot and jewelry_by_slot[slot]:
-                best_item = self._find_best_jewelry_for_slot(
-                    slot, jewelry_by_slot[slot], suit, covered_spells
-                )
-                if best_item:
-                    suit["items"][slot] = best_item
-                    
-                    # Update covered spells
-                    item_spells = best_item.get("spell_names", "")
-                    if item_spells:
-                        if isinstance(item_spells, str):
-                            covered_spells.update(item_spells.split(", "))
-                        elif isinstance(item_spells, list):
-                            covered_spells.update(item_spells)
-    
-    def _group_jewelry_by_slot(self, jewelry_items):
-        """Group jewelry items by their possible slots"""
-        jewelry_by_slot = {
-            "Neck": [], "Left Ring": [], "Right Ring": [],
-            "Left Wrist": [], "Right Wrist": [], "Trinket": []
-        }
-        
-        for item in jewelry_items:
-            possible_slots = determine_item_slots(item)
-            for slot in possible_slots:
-                if slot in jewelry_by_slot:
-                    jewelry_by_slot[slot].append(item)
-        
-        return jewelry_by_slot
-    
-    def _find_best_jewelry_for_slot(self, slot, slot_items, current_suit, covered_spells):
-        """Find the best jewelry item for a specific slot"""
-        if not slot_items:
-            return None
-        
-        required_spells = self.legendary_cantrips + self.protection_spells
-        best_item = None
-        best_score = -1
-        
-        for item in slot_items:
-            score = self._calculate_jewelry_item_score(item, required_spells, covered_spells)
-            if score > best_score:
-                best_score = score
-                best_item = item
-        
-        # CRITICAL: Only return item if it has a meaningful score (contributes to constraints)
-        # Score of 0 means it doesn't meet constraints, don't use it
-        if best_score <= 0:
-            return None
-        
-        return best_item
-    
-    def _optimize_clothing_systematically(self, suit, clothing_items):
-        """
-        Systematically optimize clothing slots (Shirt and Pants) for maximum benefit.
-        Similar to jewelry optimization but for clothing items.
-        """
-        # Group clothing by slot
-        clothing_by_slot = self._group_clothing_by_slot(clothing_items)
-        
-        # Define clothing slot priority
-        clothing_slot_priority = ["Shirt", "Pants"]
-        
-        # Track spells already covered by armor and jewelry
-        covered_spells = set()
-        for item in suit["items"].values():
-            item_spells = item.get("spell_names", "")
-            if item_spells:
-                if isinstance(item_spells, str):
-                    covered_spells.update(item_spells.split(", "))
-                elif isinstance(item_spells, list):
-                    covered_spells.update(item_spells)
-        
-        # Optimize each clothing slot
-        for slot in clothing_slot_priority:
-            if slot in clothing_by_slot and clothing_by_slot[slot]:
-                best_item = self._find_best_clothing_for_slot(
-                    slot, clothing_by_slot[slot], suit, covered_spells
-                )
-                if best_item:
-                    suit["items"][slot] = best_item
-                    
-                    # Update covered spells
-                    item_spells = best_item.get("spell_names", "")
-                    if item_spells:
-                        if isinstance(item_spells, str):
-                            covered_spells.update(item_spells.split(", "))
-                        elif isinstance(item_spells, list):
-                            covered_spells.update(item_spells)
-    
-    def _group_clothing_by_slot(self, clothing_items):
-        """Group clothing items by their possible slots"""
-        clothing_by_slot = {"Shirt": [], "Pants": []}
-        
-        for item in clothing_items:
-            possible_slots = determine_item_slots(item)
-            for slot in possible_slots:
-                if slot in clothing_by_slot:
-                    clothing_by_slot[slot].append(item)
-        
-        return clothing_by_slot
-    
-    def _find_best_clothing_for_slot(self, slot, slot_items, current_suit, covered_spells):
-        """Find the best clothing item for a specific slot"""
-        if not slot_items:
-            return None
-        
-        required_spells = self.legendary_cantrips + self.protection_spells
-        best_item = None
-        best_score = -1
-        
-        for item in slot_items:
-            score = self._calculate_clothing_item_score(item, required_spells, covered_spells)
-            if score > best_score:
-                best_score = score
-                best_item = item
-        
-        # CRITICAL: Only return item if it has a meaningful score (contributes to constraints)  
-        # Score of 0 means it doesn't meet constraints, don't use it
-        if best_score <= 0:
-            return None
-        
-        return best_item
-    
-    def _calculate_clothing_item_score(self, item, required_spells, covered_spells):
-        """Calculate optimization score for a clothing item"""
-        # CRITICAL: Items that don't meet constraints get score 0
-        if not self._item_meets_constraints(item):
-            return 0
-        
-        score = 0
-        
-        # Get item spells
-        item_spells = set()
-        spell_data = item.get("spell_names", "")
-        if spell_data:
-            if isinstance(spell_data, str):
-                item_spells.update(spell_data.split(", "))
-            elif isinstance(spell_data, list):
-                item_spells.update(spell_data)
-        
-        # High bonus for required spells that aren't covered yet
-        for spell in required_spells:
-            for item_spell in item_spells:
-                if spell.lower() in item_spell.lower() and item_spell not in covered_spells:
-                    score += 100  # Very high bonus for uncovered required spells
-        
-        # Bonus for any legendary spells
-        for spell in item_spells:
-            if "legendary" in spell.lower():
-                score += 20
-        
-        # Rating bonuses (clothing can have ratings too, only count if meeting constraints)
-        score += (item.get("gear_crit_damage", 0) or 0) * 2
-        score += (item.get("gear_damage_rating", 0) or 0) * 2
-        score += (item.get("gear_heal_boost", 0) or 0) * 1
-        
-        # Prefer unequipped items slightly
-        if item.get("current_wielded_location", 0) == 0:
-            score += 5
-        
-        return score
-    
-    def _calculate_jewelry_item_score(self, item, required_spells, covered_spells):
-        """Calculate optimization score for a jewelry item"""
-        # CRITICAL: Items that don't meet constraints get score 0
-        if not self._item_meets_constraints(item):
-            return 0
-        
-        score = 0
-        
-        # Get item spells
-        item_spells = set()
-        spell_data = item.get("spell_names", "")
-        if spell_data:
-            if isinstance(spell_data, str):
-                item_spells.update(spell_data.split(", "))
-            elif isinstance(spell_data, list):
-                item_spells.update(spell_data)
-        
-        # High bonus for required spells that aren't covered yet
-        for spell in required_spells:
-            for item_spell in item_spells:
-                if spell.lower() in item_spell.lower() and item_spell not in covered_spells:
-                    score += 100  # Very high bonus for uncovered required spells
-        
-        # Bonus for any legendary spells
-        for spell in item_spells:
-            if "legendary" in spell.lower():
-                score += 20
-        
-        # Rating bonuses (only count if meeting constraints)
-        score += (item.get("gear_crit_damage", 0) or 0) * 2
-        score += (item.get("gear_damage_rating", 0) or 0) * 2
-        score += (item.get("gear_heal_boost", 0) or 0) * 1
-        
-        # Prefer unequipped items slightly (so we don't disrupt current builds)
-        if item.get("current_wielded_location", 0) == 0:
-            score += 5
-        
-        return score
-    
-    def _calculate_jewelry_score_bonus(self, items):
-        """
-        Calculate scoring bonus for jewelry optimization.
-        Phase 3D.3 implementation.
-        """
-        jewelry_slots = ["Neck", "Left Ring", "Right Ring", "Left Wrist", "Right Wrist", "Trinket"]
-        jewelry_items = [item for slot, item in items.items() if slot in jewelry_slots]
-        
-        bonus = 0
-        
-        # Slot coverage bonus - 2 points per jewelry slot filled
-        bonus += len(jewelry_items) * 2
-        
-        # Rating bonus from jewelry (jewelry often has high ratings)
-        for item in jewelry_items:
-            bonus += int(item.get("gear_crit_damage", 0) or 0) * 0.1  # 0.1 points per crit damage point
-            bonus += int(item.get("gear_damage_rating", 0) or 0) * 0.1  # 0.1 points per damage rating point
-            bonus += int(item.get("gear_heal_boost", 0) or 0) * 0.05   # 0.05 points per heal boost point
-        
-        # Spell diversity bonus from jewelry
-        jewelry_spells = set()
-        for item in jewelry_items:
-            item_spells = item.get("spell_names", "")
-            if item_spells:
-                if isinstance(item_spells, str):
-                    jewelry_spells.update(item_spells.split(", "))
-                elif isinstance(item_spells, list):
-                    jewelry_spells.update(item_spells)
-        
-        # Bonus for legendary spells from jewelry
-        legendary_count = sum(1 for spell in jewelry_spells if "legendary" in spell.lower())
-        bonus += legendary_count * 3  # 3 points per legendary spell from jewelry
-        
-        # Bonus for spell diversity from jewelry
-        bonus += min(5, len(jewelry_spells) * 0.5)  # Up to 5 points for jewelry spell diversity
-        
-        return bonus
-    
-    def _create_disqualified_suit_result(self, index, items, reason):
-        """Create a result for a disqualified suit (overlapping cantrips)"""
-        # Extract basic info for display
-        primary_set_int = int(self.primary_set) if self.primary_set else None
-        secondary_set_int = int(self.secondary_set) if self.secondary_set else None
-        
-        primary_count = sum(1 for item in items.values() 
-                          if int(item.get("item_set_id", 0) or 0) == primary_set_int)
-        secondary_count = sum(1 for item in items.values() 
-                            if int(item.get("item_set_id", 0) or 0) == secondary_set_int)
-        
-        return {
-            "id": index + 1,
-            "score": 0,  # Disqualified suits get 0 score
-            "disqualified": True,
-            "disqualification_reason": reason,
-            "primary_set": self._get_set_name(self.primary_set) if self.primary_set else None,
-            "primary_set_count": primary_count,
-            "secondary_set": self._get_set_name(self.secondary_set) if self.secondary_set else None,
-            "secondary_set_count": secondary_count,
-            "spell_coverage": 0,
-            "total_armor": sum(item.get("armor_level", 0) or 0 for item in items.values()),
-            "stats": {
-                "primary_set_count": primary_count,
-                "secondary_set_count": secondary_count,
-                "required_spells_found": 0,
-                "total_armor": sum(item.get("armor_level", 0) or 0 for item in items.values()),
-                "total_crit_damage": sum(int(item.get("gear_crit_damage", 0) or 0) for item in items.values()),
-                "total_damage_rating": sum(int(item.get("gear_damage_rating", 0) or 0) for item in items.values()),
-                "total_heal_boost": sum(int(item.get("gear_heal_boost", 0) or 0) for item in items.values())
-            },
-            "items": {
-                slot: {
-                    "character_name": item["character_name"],
-                    "name": item["name"],
-                    "item_set_id": item.get("item_set_id"),
-                    "item_set_name": self._get_set_name(item.get("item_set_id")),
-                    "armor_level": item.get("armor_level", 0),
-                    "crit_damage_rating": item.get("gear_crit_damage", 0),
-                    "damage_rating": item.get("gear_damage_rating", 0),
-                    "heal_boost": item.get("gear_heal_boost", 0),
-                    "spell_names": item.get("spell_names", "").split(", ") if item.get("spell_names") else [],
-                    "slot_name": item.get("slot_name", slot)
-                }
-                for slot, item in items.items()
-            }
-        }
-    
-    def _score_suits(self, suits):
-        """Score suits using proper ranking priorities"""
-        scored_suits = []
-        
-        for i, suit in enumerate(suits):
-            items = suit["items"]
-            
-            # FIRST: Check for overlapping REQUESTED cantrips (HARD REQUIREMENT)
-            requested_cantrips = self.legendary_cantrips  # Only the cantrips user asked for
-            all_cantrips = []
-            cantrip_sources = {}  # Track which item has which requested cantrip
-            has_overlap = False
-            overlap_reason = ""
-            
-            # DEBUG: Log suit evaluation
-            logger.info(f"Evaluating suit {i}: {len(items)} items")
-            for slot, item in items.items():
-                logger.info(f"  {slot}: {item.get('name', 'Unknown')} (set: {item.get('item_set_id', 'None')}) spells: {item.get('spell_names', 'None')}")
-            
-            # Track overlaps but don't disqualify - just note them for scoring penalties
-            overlap_penalty = 0
-            overlap_notes = []
-            
-            if requested_cantrips:
-                logger.info(f"Checking for overlapping cantrips: {requested_cantrips}")
-                
-                # Define ward spells that are allowed to overlap (protection is stackable)
-                ward_spells = {
-                    "legendary flame ward", "legendary frost ward", "legendary acid ward", 
-                    "legendary storm ward", "legendary slashing ward", "legendary piercing ward", 
-                    "legendary bludgeoning ward", "legendary armor"
-                }
-                
-                for slot, item in items.items():
-                    item_spells = item.get("spell_names", [])
-                    if isinstance(item_spells, str):
-                        item_spells = item_spells.split(", ")
-                    
-                    for spell in item_spells:
-                        # Check if this spell is one of the REQUESTED cantrips
-                        for requested in requested_cantrips:
-                            # More precise matching - check if the requested cantrip is part of the spell name
-                            spell_words = spell.lower().split()
-                            requested_words = requested.lower().split()
-                            
-                            # Check if all words in the requested cantrip appear in the spell
-                            matches_all_words = all(any(req_word in spell_word for spell_word in spell_words) 
-                                                   for req_word in requested_words)
-                            
-                            if matches_all_words:
-                                logger.info(f"  Found match: '{requested}' matches '{spell}' on {slot}")
-                                
-                                # Check if this is a ward spell (protection) - these are allowed to overlap
-                                is_ward_spell = requested.lower() in ward_spells
-                                
-                                if requested in cantrip_sources and cantrip_sources[requested] != slot:
-                                    if is_ward_spell:
-                                        # Ward spells are allowed to overlap - no penalty
-                                        logger.info(f"  Ward overlap allowed: {requested} on {cantrip_sources[requested]} and {slot}")
-                                    else:
-                                        # Non-ward spells overlapping - apply penalty but don't disqualify
-                                        overlap_penalty += 50  # 50 point penalty per overlap
-                                        overlap_note = f"Overlapping {requested} on {cantrip_sources[requested]} and {slot}"
-                                        overlap_notes.append(overlap_note)
-                                        logger.warning(f"  OVERLAP PENALTY: {overlap_note}")
-                                cantrip_sources[requested] = slot
-                        
-                        # Also track all legendary cantrips for bonus scoring
-                        if "legendary" in spell.lower():
-                            all_cantrips.append(spell)
-            else:
-                # No cantrip constraints - just collect all legendary cantrips for bonus scoring
-                for slot, item in items.items():
-                    item_spells = item.get("spell_names", [])
-                    if isinstance(item_spells, str):
-                        item_spells = item_spells.split(", ")
-                    
-                    for spell in item_spells:
-                        if "legendary" in spell.lower():
-                            all_cantrips.append(spell)
-            
-            # Proceed with scoring (including any overlap penalties)
-            score = 0
-            
-            # Count set pieces
-            primary_set_int = int(self.primary_set) if self.primary_set else None
-            secondary_set_int = int(self.secondary_set) if self.secondary_set else None
-            
-            primary_count = sum(1 for item in items.values() 
-                              if int(item.get("item_set_id", 0) or 0) == primary_set_int)
-            secondary_count = sum(1 for item in items.values() 
-                                if int(item.get("item_set_id", 0) or 0) == secondary_set_int)
-            
-            # PRIORITY 1: Equipment Set Completion (300-500 points) - only if sets requested
-            if self.primary_set:
-                if primary_count >= 5:
-                    score += 300  # Full primary set
-                else:
-                    score += primary_count * 50  # 50 points per piece
-            
-            if self.secondary_set:
-                if secondary_count >= 4:
-                    score += 200  # Full secondary set
-                else:
-                    score += secondary_count * 40  # 40 points per piece
-            
-            # Calculate total ratings
-            total_armor = sum(item.get("armor_level", 0) or 0 for item in items.values())
-            total_crit_damage = sum(int(item.get("gear_crit_damage", 0) or 0) for item in items.values())
-            total_damage_rating = sum(int(item.get("gear_damage_rating", 0) or 0) for item in items.values())
-            total_heal_boost = sum(int(item.get("gear_heal_boost", 0) or 0) for item in items.values())
-            
-            # PRIORITY 2: Crit Damage Rating (10 points per point) - only if requested
-            if self.min_crit_damage > 0:
-                score += total_crit_damage * 10
-            else:
-                score += total_crit_damage * 1  # Minor bonus if not specifically requested
-            
-            # PRIORITY 3: Damage Rating (8 points per point) - only if requested
-            if self.min_damage_rating > 0:
-                score += total_damage_rating * 8
-            else:
-                score += total_damage_rating * 1  # Minor bonus if not specifically requested
-            
-            # BONUS: Required spell coverage (up to 50 points)
-            all_spells = set()
-            for item in items.values():
-                item_spells = item.get("spell_names", "")
-                if item_spells:
-                    if isinstance(item_spells, str):
-                        all_spells.update(item_spells.split(", "))
-                    else:
-                        all_spells.update(item_spells)
-            
-            required_spells = self.legendary_cantrips + self.protection_spells
-            if required_spells:
-                # Use fuzzy matching for spell coverage like we do for overlap detection
-                spell_coverage_count = 0
-                for required in required_spells:
-                    for actual_spell in all_spells:
-                        # More precise matching - check if the requested cantrip is part of the spell name
-                        spell_words = actual_spell.lower().split()
-                        required_words = required.lower().split()
-                        
-                        # Check if all words in the requested cantrip appear in the spell
-                        matches_all_words = all(any(req_word in spell_word for spell_word in spell_words) 
-                                               for req_word in required_words)
-                        
-                        if matches_all_words:
-                            spell_coverage_count += 1
-                            break  # Found this required spell, move to next
-                
-                logger.info(f"Spell coverage: {spell_coverage_count}/{len(required_spells)} required spells found")
-                score += (spell_coverage_count / len(required_spells)) * 50
-            
-            # BONUS: Total unique cantrips (2 points each)
-            score += len(all_cantrips) * 2
-            
-            # BONUS: Total armor level (only if armor minimum requested)
-            if self.min_armor > 0:
-                score += total_armor * 0.1  # Higher bonus if specifically requested
-            else:
-                score += total_armor * 0.01  # Minor bonus for general armor
-            
-            # BONUS: Meeting minimum requirements (10 points each)
-            armor_req_met = self.min_armor > 0 and total_armor >= self.min_armor
-            crit_req_met = self.min_crit_damage > 0 and total_crit_damage >= self.min_crit_damage
-            damage_req_met = self.min_damage_rating > 0 and total_damage_rating >= self.min_damage_rating
-            
-            if armor_req_met:
-                score += 10
-            if crit_req_met:
-                score += 10
-            if damage_req_met:
-                score += 10
-            
-            # Apply overlap penalty
-            score -= overlap_penalty
-            
-            # CRITICAL: Heavy penalty for not meeting required minimums
-            if self.min_armor > 0 and total_armor < self.min_armor:
-                score -= 200  # Heavy penalty for not meeting armor requirement
-            if self.min_crit_damage > 0 and total_crit_damage < self.min_crit_damage:
-                score -= 200  # Heavy penalty for not meeting crit requirement  
-            if self.min_damage_rating > 0 and total_damage_rating < self.min_damage_rating:
-                score -= 200  # Heavy penalty for not meeting damage requirement
-            if self.min_heal_boost > 0 and total_heal_boost < self.min_heal_boost:
-                score -= 200  # Heavy penalty for not meeting heal requirement
-            
-            # CRITICAL: Heavy penalty for not getting required set counts
-            if self.primary_set and primary_count < 5:
-                score -= (5 - primary_count) * 30  # 30 point penalty per missing primary set piece
-            if self.secondary_set and secondary_count < 4:
-                score -= (4 - secondary_count) * 25  # 25 point penalty per missing secondary set piece
-            
-            logger.info(f"Suit {i} final score: {int(score)} (primary: {primary_count}, secondary: {secondary_count}, armor: {total_armor}, crit: {total_crit_damage}, damage: {total_damage_rating}, overlap_penalty: {overlap_penalty})")
-                
-            # Create suit result
-            suit_result = {
-                "id": i + 1,
-                "score": int(score),
-                "primary_set": self._get_set_name(self.primary_set) if self.primary_set else None,
-                "primary_set_count": primary_count,
-                "secondary_set": self._get_set_name(self.secondary_set) if self.secondary_set else None,
-                "secondary_set_count": secondary_count,
-                "spell_coverage": len(all_spells),
-                "total_armor": total_armor,
-                "stats": {
-                    "primary_set_count": primary_count,
-                    "secondary_set_count": secondary_count,
-                    "required_spells_found": len([spell for spell in self.legendary_cantrips + self.protection_spells if spell in all_spells]),
-                    "total_armor": total_armor,
-                    "total_crit_damage": total_crit_damage,
-                    "total_damage_rating": total_damage_rating,
-                    "total_heal_boost": total_heal_boost
-                },
-                "items": {
-                    slot: {
-                        "character_name": item["character_name"],
-                        "name": item["name"],
-                        "item_set_id": item.get("item_set_id"),
-                        "item_set_name": self._get_set_name(item.get("item_set_id")),
-                        "armor_level": item.get("armor_level", 0),
-                        "crit_damage_rating": item.get("gear_crit_damage", 0),
-                        "damage_rating": item.get("gear_damage_rating", 0),
-                        "heal_boost": item.get("gear_heal_boost", 0),
-                        "spell_names": item.get("spell_names", "").split(", ") if item.get("spell_names") else [],
-                        "slot_name": item.get("slot_name", slot)
-                    }
-                    for slot, item in items.items()
-                },
-                "notes": overlap_notes if overlap_notes else []
-            }
-            
-            # Add comprehensive constraint analysis
-            add_suit_analysis(suit_result, self.primary_set, self.secondary_set, 
-                             self.legendary_cantrips + self.protection_spells,
-                             self.min_armor, self.min_crit_damage, self.min_damage_rating, self.min_heal_boost)
-            
-            scored_suits.append(suit_result)
-        
-        # Sort by score descending
-        scored_suits.sort(key=lambda x: x["score"], reverse=True)
-        return scored_suits
-    
-    def _get_set_name(self, set_id):
-        """Get human-readable set name from set ID"""
-        if not set_id:
-            return "No Set"
-            
-        set_id_str = str(set_id)
-        dictionaries = ENUM_MAPPINGS.get('dictionaries', {})
-        attribute_set_info = dictionaries.get('AttributeSetInfo', {}).get('values', {})
-        
-        if set_id_str in attribute_set_info:
-            return attribute_set_info[set_id_str]
-        else:
-            return f"Unknown Set ({set_id})"
-    
-    
-    def solve(self, max_results, max_iterations=1000):
-        """
-        Solve the constraint satisfaction problem using iterative search.
-        
-        Returns the top solutions found within the iteration limit.
-        """
-        logger.info(f"CSP Solver: Starting search with {len(self.candidate_items)} items, {max_iterations} max iterations")
-        
-        solutions = []
-        iteration = 0
-        
-        # Strategy 1: Set-First Greedy Search (50% of iterations)
-        for i in range(max_iterations // 2):
-            solution = self._solve_set_first_greedy()
-            if solution and self._is_unique_solution(solution, solutions):
-                solutions.append(solution)
-                if len(solutions) >= max_results * 2:  # Get extra solutions for ranking
-                    break
-            iteration += 1
-        
-        # Strategy 2: Backtracking Search (30% of iterations)
-        for i in range(max_iterations * 3 // 10):
-            solution = self._solve_backtracking()
-            if solution and self._is_unique_solution(solution, solutions):
-                solutions.append(solution)
-                if len(solutions) >= max_results * 2:
-                    break
-            iteration += 1
-        
-        # Strategy 3: Random Restarts (20% of iterations)
-        for i in range(max_iterations // 5):
-            solution = self._solve_random_restart()
-            if solution and self._is_unique_solution(solution, solutions):
-                solutions.append(solution)
-                if len(solutions) >= max_results * 2:
-                    break
-            iteration += 1
-        
-        logger.info(f"CSP Solver: Found {len(solutions)} solutions in {iteration} iterations")
-        
-        # Score and rank all solutions
-        for solution in solutions:
-            self._calculate_solution_stats(solution)
-            solution["score"] = self._calculate_solution_score(solution)
-            solution["id"] = solutions.index(solution) + 1
-            self._add_solution_analysis(solution)
-        
-        # Return top solutions
-        solutions.sort(key=lambda x: x["score"], reverse=True)
-        return solutions[:max_results]
-    
-    def _solve_set_first_greedy(self):
-        """
-        Greedy algorithm that prioritizes set requirements first.
-        """
-        solution = {"items": {}, "stats": {}}
-        used_items = set()
-        
-        # Phase 1: Place primary set items
-        primary_placed = 0
-        if self.primary_set and self.primary_set in self.items_by_set:
-            primary_items = sorted(self.items_by_set[self.primary_set], 
-                                 key=lambda x: self._item_value(x, solution), reverse=True)
-            
-            for item in primary_items:
-                if primary_placed >= 5:  # Only need 5 for primary set
-                    break
-                if item["item_id"] in used_items:
-                    continue
-                    
-                # Find best slot for this item
-                possible_slots = self._get_item_slots(item)
-                best_slot = self._find_best_available_slot(possible_slots, solution["items"])
-                
-                if best_slot:
-                    solution["items"][best_slot] = item
-                    used_items.add(item["item_id"])
-                    primary_placed += 1
-        
-        # Phase 2: Place secondary set items
-        secondary_placed = 0
-        if self.secondary_set and self.secondary_set in self.items_by_set:
-            secondary_items = sorted(self.items_by_set[self.secondary_set], 
-                                   key=lambda x: self._item_value(x, solution), reverse=True)
-            
-            for item in secondary_items:
-                if secondary_placed >= 4:  # Only need 4 for secondary set
-                    break
-                if item["item_id"] in used_items:
-                    continue
-                    
-                possible_slots = self._get_item_slots(item)
-                best_slot = self._find_best_available_slot(possible_slots, solution["items"])
-                
-                if best_slot:
-                    solution["items"][best_slot] = item
-                    used_items.add(item["item_id"])
-                    secondary_placed += 1
-        
-        # Phase 3: Place items with required spells
-        for spell in self.required_spells:
-            if spell in self.items_with_spells:
-                spell_items = sorted(self.items_with_spells[spell], 
-                                   key=lambda x: self._item_value(x), reverse=True)
-                
-                # Try to place at least one item with this spell
-                placed_spell = False
-                for item in spell_items:
-                    if item["item_id"] in used_items:
-                        continue
-                        
-                    possible_slots = self._get_item_slots(item)
-                    best_slot = self._find_best_available_slot(possible_slots, solution["items"])
-                    
-                    if best_slot:
-                        # Check if replacing existing item is beneficial
-                        existing_item = solution["items"].get(best_slot)
-                        if existing_item is None or self._should_replace_item(existing_item, item):
-                            if existing_item:
-                                used_items.discard(existing_item["item_id"])
-                            solution["items"][best_slot] = item
-                            used_items.add(item["item_id"])
-                            placed_spell = True
-                            break
-        
-        # Phase 4: Optimally fill remaining slots to maximize set bonuses
-        self._optimize_remaining_slots(solution, used_items)
-        
-        return solution if solution["items"] else None
-    
-    def _optimize_remaining_slots(self, solution, used_items):
-        """Optimally fill remaining slots to maximize constraint satisfaction."""
-        # Calculate current set counts
-        primary_count = sum(1 for item in solution["items"].values() 
-                          if item.get("item_set_id") == self.primary_set)
-        secondary_count = sum(1 for item in solution["items"].values() 
-                            if item.get("item_set_id") == self.secondary_set)
-        
-        # Fill slots prioritizing most needed sets
-        for slot in self.all_slots:
-            if slot in solution["items"]:
-                continue  # Already filled
-                
-            if slot not in self.items_by_slot:
-                continue
-                
-            available_items = [item for item in self.items_by_slot[slot] 
-                             if item["item_id"] not in used_items]
-            
-            if not available_items:
-                continue
-                
-            # Find best item for this slot based on current needs
-            best_item = None
-            best_value = -1
-            
-            for item in available_items:
-                item_value = self._item_value(item, solution)
-                
-                # Bonus for items that help with our priority sets
-                item_set = item.get("item_set_id")
-                if self.primary_set and item_set == self.primary_set and primary_count < 5:
-                    item_value += 2000  # Very high bonus for needed primary pieces
-                elif self.secondary_set and item_set == self.secondary_set and secondary_count < 4:
-                    item_value += 1500  # High bonus for needed secondary pieces
-                
-                if item_value > best_value:
-                    best_value = item_value
-                    best_item = item
-            
-            if best_item:
-                solution["items"][slot] = best_item
-                used_items.add(best_item["item_id"])
-                
-                # Update counts for next iteration
-                if best_item.get("item_set_id") == self.primary_set:
-                    primary_count += 1
-                elif best_item.get("item_set_id") == self.secondary_set:
-                    secondary_count += 1
-    
-    def _solve_backtracking(self):
-        """
-        Backtracking algorithm that explores solution space systematically.
-        """
-        solution = {"items": {}, "stats": {}}
-        used_items = set()
-        
-        # Create ordered list of (slot, constraints) for systematic search
-        slot_constraints = self._create_slot_constraints()
-        
-        # Attempt backtracking search
-        if self._backtrack_search(solution, used_items, slot_constraints, 0):
-            return solution
-        return None
-    
-    def _solve_random_restart(self):
-        """
-        Random restart algorithm for exploring different parts of solution space.
-        """
-        import random
-        
-        solution = {"items": {}, "stats": {}}
-        used_items = set()
-        
-        # Randomly order slots and items for different exploration paths
-        random_slots = self.all_slots.copy()
-        random.shuffle(random_slots)
-        
-        for slot in random_slots:
-            if slot not in self.items_by_slot:
-                continue
-                
-            available_items = [item for item in self.items_by_slot[slot] 
-                             if item["item_id"] not in used_items]
-            
-            if available_items:
-                # Add some randomness to item selection while still preferring better items
-                weights = [self._item_value(item) + random.randint(0, 100) for item in available_items]
-                max_weight = max(weights)
-                best_items = [item for i, item in enumerate(available_items) 
-                            if weights[i] >= max_weight * 0.8]  # Top 20% with randomness
-                
-                selected_item = random.choice(best_items)
-                solution["items"][slot] = selected_item
-                used_items.add(selected_item["item_id"])
-        
-        return solution if solution["items"] else None
-    
-    def _item_value(self, item, current_solution=None):
-        """Calculate the value/priority of an item for constraint satisfaction."""
-        value = 0
-        
-        # Get current set counts if solution provided
-        primary_count = 0
-        secondary_count = 0
-        if current_solution:
-            for existing_item in current_solution.get("items", {}).values():
-                existing_set = existing_item.get("item_set_id")
-                if self.primary_set and existing_set == self.primary_set:
-                    primary_count += 1
-                if self.secondary_set and existing_set == self.secondary_set:
-                    secondary_count += 1
-        
-        # Dynamic set bonus value based on current needs
-        item_set = item.get("item_set_id")
-        if self.primary_set and item_set == self.primary_set:
-            # Primary set priority decreases as we get closer to 5 pieces
-            if primary_count < 5:
-                value += 1000 + (5 - primary_count) * 100  # Higher priority when we need more
-            else:
-                value += 500  # Lower priority when we have enough
-                
-        if self.secondary_set and item_set == self.secondary_set:
-            # Secondary set priority increases when primary is satisfied
-            if secondary_count < 4:
-                if primary_count >= 4:  # If primary is mostly satisfied, prioritize secondary
-                    value += 1200 + (4 - secondary_count) * 150  # Very high priority
-                else:
-                    value += 800 + (4 - secondary_count) * 100   # High priority
-            else:
-                value += 400  # Lower priority when we have enough
-        
-        # Spell bonus value
-        item_spells = item.get("spell_names", [])
-        for spell in self.required_spells:
-            if spell in item_spells:
-                value += 500  # High priority for required spells
-        
-        # Rating value
-        value += item.get("armor_level", 0)
-        value += item.get("crit_damage_rating", 0) * 10
-        value += item.get("damage_rating", 0) * 10
-        
-        return value
-    
-    def _get_item_slots(self, item):
-        """Get list of slots this item can be equipped to."""
-        return determine_item_slots(item)
-    
-    def _find_best_available_slot(self, possible_slots, current_items):
-        """Find the best available slot from possible slots."""
-        for slot in possible_slots:
-            if slot not in current_items:
-                return slot
-        return None
-    
-    def _should_replace_item(self, existing_item, new_item):
-        """Determine if new item should replace existing item."""
-        existing_value = self._item_value(existing_item)
-        new_value = self._item_value(new_item)
-        return new_value > existing_value * 1.2  # 20% better to replace
-    
-    def _create_slot_constraints(self):
-        """Create ordered list of slot constraints for backtracking."""
-        # This is a simplified version - full implementation would be more sophisticated
-        return [(slot, []) for slot in self.all_slots]
-    
-    def _backtrack_search(self, solution, used_items, slot_constraints, slot_index):
-        """Recursive backtracking search."""
-        if slot_index >= len(slot_constraints):
-            return True  # Found complete solution
-        
-        slot, constraints = slot_constraints[slot_index]
-        
-        if slot not in self.items_by_slot:
-            return self._backtrack_search(solution, used_items, slot_constraints, slot_index + 1)
-        
-        # Try each item for this slot
-        available_items = [item for item in self.items_by_slot[slot] 
-                          if item["item_id"] not in used_items]
-        
-        # Sort by value for better pruning
-        available_items.sort(key=lambda x: self._item_value(x), reverse=True)
-        
-        for item in available_items[:5]:  # Limit search to top 5 items per slot
-            # Try placing this item
-            solution["items"][slot] = item
-            used_items.add(item["item_id"])
-            
-            # Recursive search
-            if self._backtrack_search(solution, used_items, slot_constraints, slot_index + 1):
-                return True
-            
-            # Backtrack
-            del solution["items"][slot]
-            used_items.remove(item["item_id"])
-        
-        # Try leaving slot empty
-        return self._backtrack_search(solution, used_items, slot_constraints, slot_index + 1)
-    
-    def _is_unique_solution(self, solution, existing_solutions):
-        """Check if solution is substantially different from existing ones."""
-        if not existing_solutions:
-            return True
-            
-        solution_items = set(item["item_id"] for item in solution["items"].values())
-        
-        for existing in existing_solutions:
-            existing_items = set(item["item_id"] for item in existing["items"].values())
-            overlap = len(solution_items & existing_items) / max(len(solution_items), 1)
-            if overlap > 0.7:  # 70% overlap = too similar
-                return False
-        
-        return True
-    
-    def _calculate_solution_stats(self, solution):
-        """Calculate comprehensive statistics for solution."""
-        calculate_suit_stats(solution, self.primary_set, self.secondary_set, self.required_spells)
-    
-    def _calculate_solution_score(self, solution):
-        """Calculate constraint satisfaction score for solution."""
-        return calculate_suit_score(solution, self.primary_set, self.secondary_set, self.required_spells,
-                                  self.min_armor, self.min_crit_damage, self.min_damage_rating)
-    
-    def _add_solution_analysis(self, solution):
-        """Add analysis of what's missing or achieved."""
-        add_suit_analysis(solution, self.primary_set, self.secondary_set, self.required_spells,
-                         self.min_armor, self.min_crit_damage, self.min_damage_rating, self.min_heal_boost)
-
-
-def generate_optimal_suits(items_by_slot, primary_set, secondary_set, required_spells, 
-                         min_armor, min_crit_damage, min_damage_rating, max_results):
-    """
-    Generate optimal equipment suit combinations using iterative constraint satisfaction.
-    """
-    # Convert items_by_slot to flat item list for easier processing
-    all_candidate_items = []
-    for slot_items in items_by_slot.values():
-        all_candidate_items.extend(slot_items)
-    
-    # Remove duplicates (same item might be valid for multiple slots)
-    unique_items = {item["item_id"]: item for item in all_candidate_items}
-    candidate_items = list(unique_items.values())
-    
-    # Initialize constraint satisfaction solver
-    solver = ConstraintSatisfactionSolver(candidate_items, items_by_slot, 
-                                        primary_set, secondary_set, required_spells,
-                                        min_armor, min_crit_damage, min_damage_rating)
-    
-    # Generate solutions using iterative constraint satisfaction
-    suits = solver.solve(max_results, max_iterations=1000)
-    
-    return suits
-
-
-def calculate_suit_score(suit, primary_set, secondary_set, required_spells,
-                        min_armor, min_crit_damage, min_damage_rating):
-    """
-    Calculate a score for how well a suit satisfies the constraints.
-    """
-    score = 0
-    stats = suit["stats"]
-    
-    # Set bonus scoring (most important)
-    if primary_set:
-        primary_target = 5
-        primary_actual = stats["primary_set_count"]
-        if primary_actual >= primary_target:
-            score += 40  # Full primary set bonus
-        else:
-            score += (primary_actual / primary_target) * 30  # Partial credit
-    
-    if secondary_set:
-        secondary_target = 4
-        secondary_actual = stats["secondary_set_count"]
-        if secondary_actual >= secondary_target:
-            score += 30  # Full secondary set bonus
-        else:
-            score += (secondary_actual / secondary_target) * 20  # Partial credit
-    
-    # Required spells scoring
-    if required_spells:
-        spell_ratio = min(1.0, stats["required_spells_found"] / len(required_spells))
-        score += spell_ratio * 20
-    
-    # Rating requirements scoring
-    if min_armor and stats["total_armor"] >= min_armor:
-        score += 5
-    if min_crit_damage and stats["total_crit_damage"] >= min_crit_damage:
-        score += 5
-    if min_damage_rating and stats["total_damage_rating"] >= min_damage_rating:
-        score += 5
-    
-    return int(score)
-
-
-def add_suit_analysis(suit, primary_set, secondary_set, required_spells, 
-                     min_armor=0, min_crit_damage=0, min_damage_rating=0, min_heal_boost=0):
-    """
-    Add comprehensive analysis of missing constraints and achievements in the suit.
-    """
-    stats = suit["stats"]
-    missing = []
-    notes = []
-    
-    # Get set names for display
-    set_names = {
-        13: "Soldier's Set", 14: "Adept's Set", 16: "Defender's Set", 21: "Wise Set",
-        40: "Heroic Protector", 41: "Heroic Destroyer", 46: "Relic Alduressa",
-        47: "Ancient Relic", 48: "Noble Relic", 15: "Archer's Set", 19: "Hearty Set",
-        20: "Dexterous Set", 22: "Swift Set", 24: "Reinforced Set", 26: "Flame Proof Set",
-        29: "Lightning Proof Set"
-    }
-    
-    # Check primary set requirements
-    if primary_set:
-        primary_set_int = int(primary_set)
-        set_name = set_names.get(primary_set_int, f"Set {primary_set}")
-        needed = 5 - stats.get("primary_set_count", 0)
-        if needed > 0:
-            missing.append(f"Need {needed} more {set_name} pieces")
-        else:
-            notes.append(f"✅ {set_name} (5/5)")
-    
-    # Check secondary set requirements
-    if secondary_set:
-        secondary_set_int = int(secondary_set)
-        set_name = set_names.get(secondary_set_int, f"Set {secondary_set}")
-        needed = 4 - stats.get("secondary_set_count", 0)
-        if needed > 0:
-            missing.append(f"Need {needed} more {set_name} pieces")
-        else:
-            notes.append(f"✅ {set_name} (4/4)")
-    
-    # Check legendary cantrips/spells requirements
-    if required_spells:
-        found = stats.get("required_spells_found", 0)
-        total = len(required_spells)
-        if found < total:
-            missing_count = total - found
-            missing_spells = []
-            
-            # Determine which specific spells are missing
-            suit_spells = set()
-            for item in suit["items"].values():
-                if "spell_names" in item and item["spell_names"]:
-                    if isinstance(item["spell_names"], str):
-                        suit_spells.update(spell.strip() for spell in item["spell_names"].split(","))
-                    elif isinstance(item["spell_names"], list):
-                        suit_spells.update(item["spell_names"])
-            
-            for req_spell in required_spells:
-                found_match = False
-                for suit_spell in suit_spells:
-                    if req_spell.lower() in suit_spell.lower() or suit_spell.lower() in req_spell.lower():
-                        found_match = True
-                        break
-                if not found_match:
-                    missing_spells.append(req_spell)
-            
-            if missing_spells:
-                missing.append(f"Missing: {', '.join(missing_spells[:3])}{'...' if len(missing_spells) > 3 else ''}")
-            else:
-                missing.append(f"Need {missing_count} more required spells")
-        else:
-            notes.append(f"✅ All {total} required spells found")
-    
-    # Check armor level requirements
-    if min_armor > 0:
-        current_armor = stats.get("total_armor", 0)
-        if current_armor < min_armor:
-            shortfall = min_armor - current_armor
-            missing.append(f"Armor: {current_armor}/{min_armor} (-{shortfall})")
-        else:
-            notes.append(f"✅ Armor: {current_armor} (≥{min_armor})")
-    
-    # Check crit damage rating requirements
-    if min_crit_damage > 0:
-        current_crit = stats.get("total_crit_damage", 0)
-        if current_crit < min_crit_damage:
-            shortfall = min_crit_damage - current_crit
-            missing.append(f"Crit Dmg: {current_crit}/{min_crit_damage} (-{shortfall})")
-        else:
-            notes.append(f"✅ Crit Dmg: {current_crit} (≥{min_crit_damage})")
-    
-    # Check damage rating requirements
-    if min_damage_rating > 0:
-        current_dmg = stats.get("total_damage_rating", 0)
-        if current_dmg < min_damage_rating:
-            shortfall = min_damage_rating - current_dmg
-            missing.append(f"Dmg Rating: {current_dmg}/{min_damage_rating} (-{shortfall})")
-        else:
-            notes.append(f"✅ Dmg Rating: {current_dmg} (≥{min_damage_rating})")
-    
-    # Check heal boost requirements
-    if min_heal_boost > 0:
-        current_heal = stats.get("total_heal_boost", 0)
-        if current_heal < min_heal_boost:
-            shortfall = min_heal_boost - current_heal
-            missing.append(f"Heal Boost: {current_heal}/{min_heal_boost} (-{shortfall})")
-        else:
-            notes.append(f"✅ Heal Boost: {current_heal} (≥{min_heal_boost})")
-    
-    # Add slot coverage analysis
-    armor_slots_filled = sum(1 for slot in ["Head", "Chest", "Upper Arms", "Lower Arms", "Hands", 
-                                           "Abdomen", "Upper Legs", "Lower Legs", "Feet"] 
-                            if slot in suit["items"])
-    jewelry_slots_filled = sum(1 for slot in ["Neck", "Left Ring", "Right Ring", 
-                                             "Left Wrist", "Right Wrist", "Trinket"] 
-                              if slot in suit["items"])
-    clothing_slots_filled = sum(1 for slot in ["Shirt", "Pants"] 
-                               if slot in suit["items"])
-    
-    if armor_slots_filled < 9:
-        missing.append(f"{9 - armor_slots_filled} armor slots empty")
-    else:
-        notes.append("✅ All 9 armor slots filled")
-    
-    if jewelry_slots_filled > 0:
-        notes.append(f"📿 {jewelry_slots_filled}/6 jewelry slots filled")
-    
-    if clothing_slots_filled > 0:
-        notes.append(f"👕 {clothing_slots_filled}/2 clothing slots filled")
-    
-    suit["missing"] = missing
-    suit["notes"] = notes
-
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)
diff --git a/inventory-service/requirements.txt b/inventory-service/requirements.txt
index 420a72f0..d2b5c831 100644
--- a/inventory-service/requirements.txt
+++ b/inventory-service/requirements.txt
@@ -6,5 +6,4 @@ databases[postgresql]==0.8.0
 pydantic==2.5.0
 python-multipart==0.0.6
 python-json-logger==2.0.7
-psycopg2-binary==2.9.9
-sse-starlette==1.8.2
\ No newline at end of file
+psycopg2-binary==2.9.9
\ No newline at end of file
diff --git a/main.py b/main.py
index 81b220cc..7ec722d2 100644
--- a/main.py
+++ b/main.py
@@ -10,7 +10,6 @@ import json
 import logging
 import os
 import sys
-import time
 from typing import Dict, List, Any
 from pathlib import Path
 
@@ -61,249 +60,6 @@ _cached_total_rares: dict = {"all_time": 0, "today": 0, "last_updated": None}
 _cache_task: asyncio.Task | None = None
 _rares_cache_task: asyncio.Task | None = None
 
-# Player tracking for debug purposes
-_player_history: list = []  # List of player sets from last 10 refreshes
-_player_events: list = []   # List of player enter/exit events
-_max_history_size = 10      # Keep last 10 player sets
-_max_events_size = 100      # Keep last 100 events
-
-# Telemetry timing tracking for debug purposes
-_player_telemetry_times: dict = {}  # character_name -> list of timestamps
-_max_telemetry_history = 20         # Keep last 20 telemetry timestamps per player
-
-# Simple WebSocket connection counters (Phase 1)
-_plugin_connections = 0
-_browser_connections = 0
-
-# Simple database query performance counters (Phase 2)
-_total_queries = 0
-_total_query_time = 0.0
-
-# Simple recent activity tracking (Phase 3)
-_recent_telemetry_messages = []
-_max_recent_messages = 50
-
-def _track_player_changes(new_players: list) -> None:
-    """Track player changes for debugging flapping issues."""
-    from datetime import datetime, timezone
-    
-    # Get current player names
-    current_players = {p["character_name"] for p in new_players}
-    timestamp = datetime.now(timezone.utc)
-    
-    # Track telemetry timing for each player
-    for player_data in new_players:
-        player_name = player_data["character_name"]
-        player_timestamp = player_data.get("timestamp")
-        
-        # Convert timestamp if it's a string
-        if isinstance(player_timestamp, str):
-            try:
-                player_timestamp = datetime.fromisoformat(player_timestamp.replace('Z', '+00:00'))
-            except:
-                player_timestamp = timestamp
-        elif player_timestamp is None:
-            player_timestamp = timestamp
-        
-        # Initialize player telemetry tracking if needed
-        if player_name not in _player_telemetry_times:
-            _player_telemetry_times[player_name] = []
-        
-        # Add this telemetry timestamp
-        _player_telemetry_times[player_name].append(player_timestamp)
-        
-        # Trim to max history
-        if len(_player_telemetry_times[player_name]) > _max_telemetry_history:
-            _player_telemetry_times[player_name].pop(0)
-    
-    # Get previous player names if we have history
-    previous_players = set()
-    if _player_history:
-        previous_players = {p["character_name"] for p in _player_history[-1]["players"]}
-    
-    # Find players who entered and exited
-    entered_players = current_players - previous_players
-    exited_players = previous_players - current_players
-    
-    # Log events with telemetry timing analysis
-    for player in entered_players:
-        # Check if this is due to timing gap
-        timing_gap = None
-        if player in _player_telemetry_times and len(_player_telemetry_times[player]) >= 2:
-            last_two = _player_telemetry_times[player][-2:]
-            timing_gap = (last_two[1] - last_two[0]).total_seconds()
-        
-        event = {
-            "timestamp": timestamp,
-            "type": "enter",
-            "character_name": player,
-            "total_players": len(current_players),
-            "timing_gap": timing_gap
-        }
-        _player_events.append(event)
-        gap_info = f" (gap: {timing_gap:.1f}s)" if timing_gap and timing_gap > 25 else ""
-        logger.debug(f"Player entered: {player} (total: {len(current_players)}){gap_info}")
-    
-    for player in exited_players:
-        # Calculate time since last telemetry
-        last_telemetry_age = None
-        if player in _player_telemetry_times and _player_telemetry_times[player]:
-            last_telemetry = _player_telemetry_times[player][-1]
-            last_telemetry_age = (timestamp - last_telemetry).total_seconds()
-        
-        event = {
-            "timestamp": timestamp,
-            "type": "exit", 
-            "character_name": player,
-            "total_players": len(current_players),
-            "last_telemetry_age": last_telemetry_age
-        }
-        _player_events.append(event)
-        age_info = f" (last telemetry: {last_telemetry_age:.1f}s ago)" if last_telemetry_age else ""
-        logger.debug(f"Player exited: {player} (total: {len(current_players)}){age_info}")
-    
-    # Add current state to history
-    history_entry = {
-        "timestamp": timestamp,
-        "players": new_players,
-        "player_count": len(new_players),
-        "player_names": list(current_players)
-    }
-    _player_history.append(history_entry)
-    
-    # Trim history to max size
-    if len(_player_history) > _max_history_size:
-        _player_history.pop(0)
-    
-    # Trim events to max size  
-    if len(_player_events) > _max_events_size:
-        _player_events.pop(0)
-
-def _analyze_flapping_patterns() -> dict:
-    """Analyze player events to identify flapping patterns."""
-    from collections import Counter, defaultdict
-    
-    if not _player_events:
-        return {"flapping_players": [], "frequent_events": [], "analysis": "No events to analyze"}
-    
-    # Count events per player
-    player_event_counts = Counter()
-    player_flap_counts = defaultdict(int)
-    
-    # Track recent activity per player (last 10 events)
-    recent_player_activity = defaultdict(list)
-    
-    for event in _player_events[-50:]:  # Analyze last 50 events
-        player = event["character_name"]
-        event_type = event["type"]
-        player_event_counts[player] += 1
-        recent_player_activity[player].append(event_type)
-    
-    # Identify flapping players (players with many enter/exit cycles)
-    flapping_players = []
-    for player, activity in recent_player_activity.items():
-        if len(activity) >= 4:  # At least 4 events
-            # Count alternating enter/exit patterns
-            flap_score = 0
-            for i in range(1, len(activity)):
-                if activity[i] != activity[i-1]:  # Different from previous
-                    flap_score += 1
-            
-            if flap_score >= 3:  # At least 3 transitions
-                flapping_players.append({
-                    "character_name": player,
-                    "events": len(activity),
-                    "flap_score": flap_score,
-                    "recent_activity": activity[-10:]  # Last 10 events
-                })
-    
-    # Sort by flap score
-    flapping_players.sort(key=lambda x: x["flap_score"], reverse=True)
-    
-    # Most active players
-    frequent_events = [
-        {"character_name": player, "event_count": count} 
-        for player, count in player_event_counts.most_common(10)
-    ]
-    
-    # Recent activity summary
-    recent_enters = sum(1 for e in _player_events[-20:] if e["type"] == "enter")
-    recent_exits = sum(1 for e in _player_events[-20:] if e["type"] == "exit")
-    
-    return {
-        "flapping_players": flapping_players,
-        "frequent_events": frequent_events,
-        "recent_activity": {
-            "enters": recent_enters,
-            "exits": recent_exits,
-            "net_change": recent_enters - recent_exits
-        },
-        "analysis": f"Found {len(flapping_players)} potentially flapping players"
-    }
-
-def _analyze_telemetry_timing() -> dict:
-    """Analyze telemetry timing patterns for all players."""
-    from datetime import datetime, timezone
-    
-    timing_analysis = {}
-    problem_players = []
-    
-    for player_name, timestamps in _player_telemetry_times.items():
-        if len(timestamps) < 2:
-            continue
-            
-        # Calculate intervals between telemetry messages
-        intervals = []
-        for i in range(1, len(timestamps)):
-            interval = (timestamps[i] - timestamps[i-1]).total_seconds()
-            intervals.append(interval)
-        
-        if not intervals:
-            continue
-            
-        # Calculate timing statistics
-        avg_interval = sum(intervals) / len(intervals)
-        min_interval = min(intervals)
-        max_interval = max(intervals)
-        
-        # Count problematic intervals (>30s)
-        long_gaps = [i for i in intervals if i > 30]
-        recent_long_gaps = [i for i in intervals[-5:] if i > 30]  # Last 5 intervals
-        
-        # Determine if this player has timing issues
-        has_timing_issues = len(long_gaps) > 0 or max_interval > 35
-        
-        timing_stats = {
-            "character_name": player_name,
-            "total_messages": len(timestamps),
-            "avg_interval": round(avg_interval, 1),
-            "min_interval": round(min_interval, 1),
-            "max_interval": round(max_interval, 1),
-            "long_gaps_count": len(long_gaps),
-            "recent_long_gaps": len(recent_long_gaps),
-            "last_message_age": (datetime.now(timezone.utc) - timestamps[-1]).total_seconds() if timestamps else 0,
-            "has_timing_issues": has_timing_issues,
-            "recent_intervals": [round(i, 1) for i in intervals[-5:]]  # Last 5 intervals
-        }
-        
-        timing_analysis[player_name] = timing_stats
-        
-        if has_timing_issues:
-            problem_players.append(timing_stats)
-    
-    # Sort problem players by severity (max interval)
-    problem_players.sort(key=lambda x: x["max_interval"], reverse=True)
-    
-    return {
-        "all_players": timing_analysis,
-        "problem_players": problem_players,
-        "summary": {
-            "total_tracked_players": len(timing_analysis),
-            "players_with_issues": len(problem_players),
-            "avg_intervals": [stats["avg_interval"] for stats in timing_analysis.values()],
-        }
-    }
-
 async def _refresh_cache_loop() -> None:
     """Background task: refresh `/live` and `/trails` caches every 5 seconds."""
     consecutive_failures = 0
@@ -336,12 +92,7 @@ async def _refresh_cache_loop() -> None:
             # Use a single connection for both queries to reduce connection churn
             async with database.connection() as conn:
                 rows = await conn.fetch_all(sql_live, {"cutoff": cutoff})
-                new_players = [dict(r) for r in rows]
-                
-                # Track player changes for debugging
-                _track_player_changes(new_players)
-                
-                _cached_live["players"] = new_players
+                _cached_live["players"] = [dict(r) for r in rows]
                 
                 # Recompute trails (last 600s)
                 cutoff2 = datetime.utcnow().replace(tzinfo=timezone.utc) - timedelta(seconds=600)
@@ -596,104 +347,6 @@ async def on_shutdown():
 def debug():
     return {"status": "OK"}
 
-@app.get("/debug/player-flapping")
-async def get_player_flapping_debug():
-    """Return player tracking data for debugging flapping issues."""
-    try:
-        # Analyze flapping patterns
-        flapping_analysis = _analyze_flapping_patterns()
-        
-        # Analyze telemetry timing
-        timing_analysis = _analyze_telemetry_timing()
-        
-        # Get recent events (last 50)
-        recent_events = _player_events[-50:] if len(_player_events) > 50 else _player_events
-        
-        # Convert timestamps to ISO format for JSON serialization
-        formatted_events = []
-        for event in recent_events:
-            formatted_event = event.copy()
-            formatted_event["timestamp"] = event["timestamp"].isoformat()
-            formatted_events.append(formatted_event)
-        
-        # Format history
-        formatted_history = []
-        for entry in _player_history:
-            formatted_entry = {
-                "timestamp": entry["timestamp"].isoformat(),
-                "player_count": entry["player_count"],
-                "player_names": entry["player_names"]
-            }
-            formatted_history.append(formatted_entry)
-        
-        # Format timing data for JSON serialization
-        formatted_timing = {}
-        for player_name, timing_data in timing_analysis["all_players"].items():
-            formatted_timing[player_name] = timing_data.copy()
-            # Round last_message_age for readability
-            formatted_timing[player_name]["last_message_age"] = round(timing_data["last_message_age"], 1)
-        
-        return {
-            "current_players": len(_cached_live.get("players", [])),
-            "history": formatted_history,
-            "recent_events": formatted_events,
-            "flapping_analysis": flapping_analysis,
-            "timing_analysis": {
-                "all_players": formatted_timing,
-                "problem_players": timing_analysis["problem_players"],
-                "summary": timing_analysis["summary"]
-            },
-            "tracking_stats": {
-                "history_entries": len(_player_history),
-                "total_events": len(_player_events),
-                "tracked_players": len(_player_telemetry_times),
-                "max_history_size": _max_history_size,
-                "max_events_size": _max_events_size
-            }
-        }
-    except Exception as e:
-        logger.error(f"Failed to get player flapping debug data: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail="Internal server error")
-
-@app.get("/debug/websocket-health")
-async def get_websocket_health():
-    """Return simple WebSocket connection counts."""
-    try:
-        return {
-            "plugin_connections": _plugin_connections,
-            "browser_connections": _browser_connections,
-            "total_connections": _plugin_connections + _browser_connections
-        }
-    except Exception as e:
-        logger.error(f"Failed to get WebSocket health data: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail="Internal server error")
-
-@app.get("/debug/database-performance")
-async def get_database_performance():
-    """Return simple database query performance statistics."""
-    try:
-        avg_query_time = (_total_query_time / _total_queries) if _total_queries > 0 else 0.0
-        return {
-            "total_queries": _total_queries,
-            "total_query_time": round(_total_query_time, 3),
-            "average_query_time": round(avg_query_time, 3)
-        }
-    except Exception as e:
-        logger.error(f"Failed to get database performance data: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail="Internal server error")
-
-@app.get("/debug/recent-activity")
-async def get_recent_activity():
-    """Return recent telemetry activity feed."""
-    try:
-        return {
-            "recent_messages": _recent_telemetry_messages.copy(),
-            "total_messages": len(_recent_telemetry_messages),
-            "max_messages": _max_recent_messages
-        }
-    except Exception as e:
-        logger.error(f"Failed to get recent activity data: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail="Internal server error")
 
 @app.get("/live", response_model=dict)
 @app.get("/live/", response_model=dict)
@@ -1246,8 +899,6 @@ async def ws_receive_snapshots(
       - rare: update total and session rare counts, persist event
       - chat: broadcast chat messages to browsers
     """
-    global _plugin_connections
-    
     # Authenticate plugin connection using shared secret
     key = secret or x_plugin_secret
     if key != SHARED_SECRET:
@@ -1257,11 +908,7 @@ async def ws_receive_snapshots(
         return
     # Accept the WebSocket connection
     await websocket.accept()
-    logger.info(f"🔌 PLUGIN_CONNECTED: {websocket.client}")
-    
-    # Track plugin connection
-    _plugin_connections += 1
-    
+    logger.info(f"Plugin WebSocket connected: {websocket.client}")
     try:
         while True:
             # Read next text frame
@@ -1270,7 +917,7 @@ async def ws_receive_snapshots(
                 # Debug: log all incoming plugin WebSocket messages  
                 logger.debug(f"Plugin WebSocket RX from {websocket.client}: {raw}")
             except WebSocketDisconnect:
-                logger.info(f"🔌 PLUGIN_DISCONNECTED: {websocket.client}")
+                logger.info(f"Plugin WebSocket disconnected: {websocket.client}")
                 break
             # Parse JSON payload
             try:
@@ -1284,7 +931,7 @@ async def ws_receive_snapshots(
                 name = data.get("character_name") or data.get("player_name")
                 if isinstance(name, str):
                     plugin_conns[name] = websocket
-                    logger.info(f"📋 PLUGIN_REGISTERED: {name} from {websocket.client}")
+                    logger.info(f"Registered plugin connection for character: {name}")
                 continue
             # --- Spawn event: persist to spawn_events table ---
             if msg_type == "spawn":
@@ -1305,12 +952,6 @@ async def ws_receive_snapshots(
                 # Parse telemetry snapshot and update in-memory state
                 payload = data.copy()
                 payload.pop("type", None)
-                character_name = payload.get('character_name', 'unknown')
-                
-                # Track message receipt and start timing
-                telemetry_start_time = time.time()
-                logger.info(f"📨 TELEMETRY_RECEIVED: {character_name} from {websocket.client}")
-                
                 try:
                     snap = TelemetrySnapshot.parse_obj(payload)
                     live_snapshots[snap.character_name] = snap.dict()
@@ -1333,16 +974,6 @@ async def ws_receive_snapshots(
                     
                     delta = snap.kills - last
                     # Persist snapshot and any kill delta in a single transaction
-                    db_start_time = time.time()
-                    
-                    # Log connection pool status before database operation
-                    try:
-                        pool_status = f"pool_size:{database._pool._queue.qsize()}" if hasattr(database, '_pool') and hasattr(database._pool, '_queue') else "pool_status:unknown"
-                    except:
-                        pool_status = "pool_status:error"
-                    
-                    logger.info(f"💾 TELEMETRY_DB_WRITE_ATTEMPT: {snap.character_name} session:{snap.session_id[:8]} kills:{snap.kills} delta:{delta} {pool_status}")
-                    
                     try:
                         async with database.transaction():
                             await database.execute(
@@ -1358,60 +989,15 @@ async def ws_receive_snapshots(
                                 )
                                 await database.execute(stmt)
                                 logger.debug(f"Updated kills for {snap.character_name}: +{delta} (total from {last} to {snap.kills})")
-                        
-                        # Success: log timing and update cache
-                        db_duration = (time.time() - db_start_time) * 1000
                         ws_receive_snapshots._last_kills[key] = snap.kills
-                        
-                        # Track database performance (Phase 2)
-                        global _total_queries, _total_query_time
-                        _total_queries += 1
-                        _total_query_time += db_duration / 1000.0  # Convert ms to seconds
-                        
-                        # Track recent activity (Phase 3)
-                        global _recent_telemetry_messages, _max_recent_messages
-                        activity_entry = {
-                            "timestamp": datetime.now(timezone.utc).isoformat(),
-                            "character_name": snap.character_name,
-                            "kills": snap.kills,
-                            "kill_delta": delta,
-                            "query_time": round(db_duration, 1)
-                        }
-                        _recent_telemetry_messages.append(activity_entry)
-                        if len(_recent_telemetry_messages) > _max_recent_messages:
-                            _recent_telemetry_messages.pop(0)
-                        
-                        
-                        # Log final pool status after successful operation
-                        try:
-                            final_pool_status = f"pool_size:{database._pool._queue.qsize()}" if hasattr(database, '_pool') and hasattr(database._pool, '_queue') else "pool_status:unknown"
-                        except:
-                            final_pool_status = "pool_status:error"
-                        
-                        logger.info(f"✅ TELEMETRY_DB_WRITE_SUCCESS: {snap.character_name} took {db_duration:.1f}ms {final_pool_status}")
-                        
                     except Exception as db_error:
-                        db_duration = (time.time() - db_start_time) * 1000
-                        
-                        
-                        # Log pool status during failure
-                        try:
-                            error_pool_status = f"pool_size:{database._pool._queue.qsize()}" if hasattr(database, '_pool') and hasattr(database._pool, '_queue') else "pool_status:unknown"
-                        except:
-                            error_pool_status = "pool_status:error"
-                        
-                        logger.error(f"❌ TELEMETRY_DB_WRITE_FAILED: {snap.character_name} session:{snap.session_id[:8]} took {db_duration:.1f}ms {error_pool_status} error:{db_error}", exc_info=True)
+                        logger.error(f"💾 Database transaction failed for {snap.character_name} (session: {snap.session_id[:8]}): {db_error}", exc_info=True)
                         continue
                     # Broadcast updated snapshot to all browser clients
                     await _broadcast_to_browser_clients(snap.dict())
-                    
-                    # Log successful processing completion with timing
-                    total_duration = (time.time() - telemetry_start_time) * 1000
-                    logger.info(f"⏱️ TELEMETRY_PROCESSING_COMPLETE: {snap.character_name} took {total_duration:.1f}ms total")
-                    
+                    logger.debug(f"✅ Processed telemetry from {snap.character_name} (session: {snap.session_id[:8]}, kills: {snap.kills})")
                 except Exception as e:
-                    total_duration = (time.time() - telemetry_start_time) * 1000
-                    logger.error(f"❌ TELEMETRY_PROCESSING_FAILED: {character_name} took {total_duration:.1f}ms error:{e}", exc_info=True)
+                    logger.error(f"❌ Failed to process telemetry event from {data.get('character_name', 'unknown')}: {e}", exc_info=True)
                 continue
             # --- Rare event: update total and session counters and persist ---
             if msg_type == "rare":
@@ -1496,9 +1082,6 @@ async def ws_receive_snapshots(
             if msg_type:
                 logger.warning(f"Unknown message type '{msg_type}' from {websocket.client}")
     finally:
-        # Track plugin disconnection
-        _plugin_connections = max(0, _plugin_connections - 1)
-        
         # Clean up any plugin registrations for this socket
         to_remove = [n for n, ws in plugin_conns.items() if ws is websocket]
         for n in to_remove:
@@ -1570,15 +1153,10 @@ async def ws_live_updates(websocket: WebSocket):
     Manages a set of connected browser clients; listens for incoming command messages
     and forwards them to the appropriate plugin client WebSocket.
     """
-    global _browser_connections
     # Add new browser client to the set
     await websocket.accept()
     browser_conns.add(websocket)
     logger.info(f"Browser WebSocket connected: {websocket.client}")
-    
-    # Track browser connection
-    _browser_connections += 1
-    
     try:
         while True:
             # Receive command messages from browser
@@ -1620,9 +1198,6 @@ async def ws_live_updates(websocket: WebSocket):
     except WebSocketDisconnect:
         pass
     finally:
-        # Track browser disconnection
-        _browser_connections = max(0, _browser_connections - 1)
-        
         browser_conns.discard(websocket)
         logger.debug(f"Removed browser WebSocket from connection pool: {websocket.client}")
 
diff --git a/static/debug.html b/static/debug.html
deleted file mode 100644
index 3f6199bc..00000000
--- a/static/debug.html
+++ /dev/null
@@ -1,654 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>Player Debug - Dereth Tracker</title>
-  <style>
-    body {
-      font-family: "Segoe UI", sans-serif;
-      background: #111;
-      color: #eee;
-      margin: 20px;
-      line-height: 1.4;
-    }
-    
-    .container {
-      max-width: 1200px;
-      margin: 0 auto;
-    }
-    
-    .header {
-      text-align: center;
-      margin-bottom: 30px;
-      border-bottom: 2px solid #333;
-      padding-bottom: 20px;
-    }
-    
-    .stats-grid {
-      display: grid;
-      grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-      gap: 20px;
-      margin-bottom: 30px;
-    }
-    
-    .stat-card {
-      background: #222;
-      border: 1px solid #444;
-      border-radius: 8px;
-      padding: 15px;
-    }
-    
-    .stat-card h3 {
-      margin: 0 0 10px 0;
-      color: #88f;
-      font-size: 1.1rem;
-    }
-    
-    .stat-value {
-      font-size: 1.8rem;
-      font-weight: bold;
-      color: #fff;
-    }
-    
-    .sections {
-      display: grid;
-      grid-template-columns: 1fr 1fr;
-      gap: 30px;
-    }
-    
-    .section {
-      background: #1a1a1a;
-      border: 1px solid #333;
-      border-radius: 8px;
-      padding: 20px;
-    }
-    
-    .section h2 {
-      margin: 0 0 15px 0;
-      color: #88f;
-      border-bottom: 1px solid #333;
-      padding-bottom: 10px;
-    }
-    
-    .event-log {
-      max-height: 400px;
-      overflow-y: auto;
-      background: #000;
-      border: 1px solid #333;
-      border-radius: 4px;
-      padding: 10px;
-      font-family: monospace;
-      font-size: 0.9rem;
-    }
-    
-    .event-enter {
-      color: #4f4;
-    }
-    
-    .event-exit {
-      color: #f44;
-    }
-    
-    .flapping-player {
-      background: #332;
-      border: 1px solid #664;
-      border-radius: 4px;
-      padding: 10px;
-      margin-bottom: 10px;
-    }
-    
-    .flapping-player .name {
-      font-weight: bold;
-      color: #ff6;
-    }
-    
-    .flapping-player .score {
-      color: #f88;
-      font-size: 0.9rem;
-    }
-    
-    .history-entry {
-      display: flex;
-      justify-content: space-between;
-      align-items: center;
-      padding: 8px;
-      border-bottom: 1px solid #333;
-      font-family: monospace;
-      font-size: 0.9rem;
-    }
-    
-    .history-entry:last-child {
-      border-bottom: none;
-    }
-    
-    .timestamp {
-      color: #888;
-      font-size: 0.8rem;
-    }
-    
-    .player-count {
-      font-weight: bold;
-      color: #4f4;
-    }
-    
-    .status {
-      text-align: center;
-      padding: 20px;
-      background: #222;
-      border-radius: 8px;
-      margin-bottom: 20px;
-    }
-    
-    .loading {
-      color: #88f;
-    }
-    
-    .error {
-      color: #f44;
-    }
-    
-    .last-updated {
-      text-align: center;
-      color: #888;
-      font-size: 0.9rem;
-      margin-top: 20px;
-    }
-    
-    .timing-player {
-      background: #223;
-      border: 1px solid #446;
-      border-radius: 4px;
-      padding: 10px;
-      margin-bottom: 10px;
-    }
-    
-    .timing-player .name {
-      font-weight: bold;
-      color: #ff8;
-    }
-    
-    .timing-player .issue {
-      color: #f88;
-      font-size: 0.9rem;
-    }
-    
-    .timing-player .stats {
-      color: #aaa;
-      font-size: 0.8rem;
-      margin-top: 5px;
-      font-family: monospace;
-    }
-    
-    .timing-good {
-      border-color: #464 !important;
-      background: #232 !important;
-    }
-    
-    .timing-warning {
-      border-color: #664 !important;
-      background: #332 !important;
-    }
-    
-    .timing-critical {
-      border-color: #644 !important;
-      background: #322 !important;
-    }
-    
-    @media (max-width: 768px) {
-      .sections {
-        grid-template-columns: 1fr;
-      }
-      
-      .stats-grid {
-        grid-template-columns: 1fr;
-      }
-    }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <div class="header">
-      <h1>🔍 Player Debug Dashboard</h1>
-      <p>Real-time tracking of player list changes to debug flapping issues</p>
-    </div>
-    
-    <div class="status" id="status">
-      <div class="loading">Loading player debug data...</div>
-    </div>
-    
-    <div class="stats-grid" id="statsGrid" style="display: none;">
-      <div class="stat-card">
-        <h3>Current Players</h3>
-        <div class="stat-value" id="currentPlayers">-</div>
-      </div>
-      <div class="stat-card">
-        <h3>Total Events</h3>
-        <div class="stat-value" id="totalEvents">-</div>
-      </div>
-      <div class="stat-card">
-        <h3>Flapping Players</h3>
-        <div class="stat-value" id="flappingCount">-</div>
-      </div>
-      <div class="stat-card">
-        <h3>Recent Activity</h3>
-        <div class="stat-value" id="recentActivity">-</div>
-      </div>
-      <div class="stat-card">
-        <h3>Timing Issues</h3>
-        <div class="stat-value" id="timingIssues">-</div>
-      </div>
-      <div class="stat-card">
-        <h3>Tracked Players</h3>
-        <div class="stat-value" id="trackedPlayers">-</div>
-      </div>
-      <div class="stat-card">
-        <h3>WebSocket Connections</h3>
-        <div class="stat-value" id="websocketConnections">-</div>
-      </div>
-      <div class="stat-card">
-        <h3>Database Queries</h3>
-        <div class="stat-value" id="databaseQueries">-</div>
-      </div>
-      <div class="stat-card">
-        <h3>Recent Activity</h3>
-        <div class="stat-value" id="recentActivityCount">-</div>
-      </div>
-    </div>
-    
-    <div class="sections" id="sections" style="display: none;">
-      <div class="section">
-        <h2>🔄 Flapping Players</h2>
-        <div id="flappingPlayers">
-          <p style="color: #888; font-style: italic;">No flapping detected</p>
-        </div>
-      </div>
-      
-      <div class="section">
-        <h2>⏰ Timing Issues</h2>
-        <div id="timingProblems">
-          <p style="color: #888; font-style: italic;">Loading timing analysis...</p>
-        </div>
-      </div>
-      
-      <div class="section">
-        <h2>📊 Player History</h2>
-        <div id="playerHistory" class="event-log">
-          <p style="color: #888; font-style: italic;">Loading history...</p>
-        </div>
-      </div>
-      
-      <div class="section">
-        <h2>📝 Recent Events</h2>
-        <div id="recentEvents" class="event-log">
-          <p style="color: #888; font-style: italic;">Loading events...</p>
-        </div>
-      </div>
-      
-      <div class="section">
-        <h2>🎯 Most Active Players</h2>
-        <div id="frequentEvents">
-          <p style="color: #888; font-style: italic;">Loading activity...</p>
-        </div>
-      </div>
-      
-      <div class="section">
-        <h2>📈 Telemetry Timing</h2>
-        <div id="telemetryTiming">
-          <p style="color: #888; font-style: italic;">Loading telemetry data...</p>
-        </div>
-      </div>
-      
-      <div class="section">
-        <h2>🔌 WebSocket Health</h2>
-        <div id="websocketHealth">
-          <p style="color: #888; font-style: italic;">Loading WebSocket data...</p>
-        </div>
-      </div>
-      
-      <div class="section">
-        <h2>🗄️ Database Performance</h2>
-        <div id="databasePerformance">
-          <p style="color: #888; font-style: italic;">Loading database data...</p>
-        </div>
-      </div>
-      
-      <div class="section">
-        <h2>⚡ Recent Activity</h2>
-        <div id="recentActivityFeed" class="event-log">
-          <p style="color: #888; font-style: italic;">Loading recent activity...</p>
-        </div>
-      </div>
-    </div>
-    
-    <div class="last-updated" id="lastUpdated"></div>
-  </div>
-  
-  <script>
-    let pollInterval;
-    let isPolling = false;
-    
-    function formatTimestamp(isoString) {
-      const date = new Date(isoString);
-      return date.toLocaleTimeString();
-    }
-    
-    function formatDate(isoString) {
-      const date = new Date(isoString);
-      return date.toLocaleString();
-    }
-    
-    async function fetchDebugData() {
-      try {
-        // Fetch all four endpoints
-        const [flappingResponse, websocketResponse, databaseResponse, activityResponse] = await Promise.all([
-          fetch('/debug/player-flapping'),
-          fetch('/debug/websocket-health'),
-          fetch('/debug/database-performance'),
-          fetch('/debug/recent-activity')
-        ]);
-        
-        if (!flappingResponse.ok) {
-          throw new Error(`HTTP ${flappingResponse.status}: ${flappingResponse.statusText}`);
-        }
-        
-        const data = await flappingResponse.json();
-        const websocketData = websocketResponse.ok ? await websocketResponse.json() : null;
-        const databaseData = databaseResponse.ok ? await databaseResponse.json() : null;
-        const activityData = activityResponse.ok ? await activityResponse.json() : null;
-        
-        // Combine the data
-        const enhancedData = {
-          ...data,
-          websocket_health: websocketData,
-          database_performance: databaseData,
-          recent_activity: activityData
-        };
-        
-        updateUI(enhancedData);
-        showSuccess();
-      } catch (error) {
-        console.error('Failed to fetch debug data:', error);
-        showError(`Failed to fetch data: ${error.message}`);
-      }
-    }
-    
-    function updateUI(data) {
-      // Update stats
-      document.getElementById('currentPlayers').textContent = data.current_players;
-      document.getElementById('totalEvents').textContent = data.tracking_stats.total_events;
-      document.getElementById('flappingCount').textContent = data.flapping_analysis.flapping_players.length;
-      
-      const recentActivity = data.flapping_analysis.recent_activity;
-      document.getElementById('recentActivity').textContent = 
-        `+${recentActivity.enters} -${recentActivity.exits} (${recentActivity.net_change > 0 ? '+' : ''}${recentActivity.net_change})`;
-      
-      // Update flapping players
-      const flappingDiv = document.getElementById('flappingPlayers');
-      if (data.flapping_analysis.flapping_players.length === 0) {
-        flappingDiv.innerHTML = '<p style="color: #4f4; font-style: italic;">✅ No flapping detected</p>';
-      } else {
-        flappingDiv.innerHTML = data.flapping_analysis.flapping_players.map(player => `
-          <div class="flapping-player">
-            <div class="name">${player.character_name}</div>
-            <div class="score">Flap Score: ${player.flap_score} | Events: ${player.events}</div>
-            <div style="font-size: 0.8rem; color: #aaa; margin-top: 5px;">
-              Recent: ${player.recent_activity.join(' → ')}
-            </div>
-          </div>
-        `).join('');
-      }
-      
-      // Update history
-      const historyDiv = document.getElementById('playerHistory');
-      if (data.history.length === 0) {
-        historyDiv.innerHTML = '<p style="color: #888; font-style: italic;">No history available</p>';
-      } else {
-        historyDiv.innerHTML = data.history.slice().reverse().map(entry => `
-          <div class="history-entry">
-            <span class="timestamp">${formatTimestamp(entry.timestamp)}</span>
-            <span class="player-count">${entry.player_count} players</span>
-          </div>
-        `).join('');
-      }
-      
-      // Update recent events
-      const eventsDiv = document.getElementById('recentEvents');
-      if (data.recent_events.length === 0) {
-        eventsDiv.innerHTML = '<p style="color: #888; font-style: italic;">No recent events</p>';
-      } else {
-        eventsDiv.innerHTML = data.recent_events.slice().reverse().map(event => `
-          <div class="event-${event.type}">
-            ${formatTimestamp(event.timestamp)} - ${event.character_name} ${event.type === 'enter' ? 'joined' : 'left'} (${event.total_players} total)
-          </div>
-        `).join('');
-      }
-      
-      // Update frequent events
-      const frequentDiv = document.getElementById('frequentEvents');
-      if (data.flapping_analysis.frequent_events.length === 0) {
-        frequentDiv.innerHTML = '<p style="color: #888; font-style: italic;">No activity data</p>';
-      } else {
-        frequentDiv.innerHTML = data.flapping_analysis.frequent_events.map(player => `
-          <div style="display: flex; justify-content: space-between; padding: 5px 0; border-bottom: 1px solid #333;">
-            <span>${player.character_name}</span>
-            <span style="color: #88f;">${player.event_count} events</span>
-          </div>
-        `).join('');
-      }
-      
-      // Update timing issues
-      const timingDiv = document.getElementById('timingProblems');
-      const timingData = data.timing_analysis || { problem_players: [], summary: { total_tracked_players: 0 } };
-      document.getElementById('timingIssues').textContent = timingData.problem_players.length;
-      document.getElementById('trackedPlayers').textContent = timingData.summary.total_tracked_players;
-      
-      if (timingData.problem_players.length === 0) {
-        timingDiv.innerHTML = '<p style="color: #4f4; font-style: italic;">✅ No timing issues detected</p>';
-      } else {
-        timingDiv.innerHTML = timingData.problem_players.map(player => {
-          let severityClass = 'timing-good';
-          const maxInterval = player.max_interval || 0;
-          const avgInterval = player.avg_interval || 0;
-          const totalMessages = player.total_messages || 0;
-          
-          if (maxInterval > 60) severityClass = 'timing-critical';
-          else if (maxInterval > 45) severityClass = 'timing-warning';
-          
-          const issue = maxInterval > 30 ? 
-            `Max gap: ${maxInterval.toFixed(1)}s (>${30}s threshold)` :
-            `Irregular timing patterns detected`;
-          
-          return `
-            <div class="timing-player ${severityClass}">
-              <div class="name">${player.character_name || 'Unknown'}</div>
-              <div class="issue">${issue}</div>
-              <div class="stats">
-                Messages: ${totalMessages} | 
-                Avg gap: ${avgInterval.toFixed(1)}s | 
-                Max gap: ${maxInterval.toFixed(1)}s
-              </div>
-            </div>
-          `;
-        }).join('');
-      }
-      
-      // Update telemetry timing section
-      const telemetryDiv = document.getElementById('telemetryTiming');
-      if (timingData.summary.total_tracked_players === 0) {
-        telemetryDiv.innerHTML = '<p style="color: #888; font-style: italic;">No telemetry data available</p>';
-      } else {
-        const healthyCount = timingData.summary.total_tracked_players - timingData.problem_players.length;
-        telemetryDiv.innerHTML = `
-          <div style="margin-bottom: 15px;">
-            <div style="display: flex; justify-content: space-between; margin-bottom: 5px;">
-              <span>Total Players Tracked:</span>
-              <span style="color: #88f; font-weight: bold;">${timingData.summary.total_tracked_players}</span>
-            </div>
-            <div style="display: flex; justify-content: space-between; margin-bottom: 5px;">
-              <span>Healthy Timing:</span>
-              <span style="color: #4f4; font-weight: bold;">${healthyCount}</span>
-            </div>
-            <div style="display: flex; justify-content: space-between;">
-              <span>Timing Issues:</span>
-              <span style="color: #f44; font-weight: bold;">${timingData.problem_players.length}</span>
-            </div>
-          </div>
-          <div style="font-size: 0.9rem; color: #aaa; line-height: 1.4;">
-            Players with telemetry gaps >30s are flagged as timing issues. 
-            This can cause players to temporarily disappear from the active list.
-          </div>
-        `;
-      }
-      
-      // Update WebSocket health data
-      const websocketData = data.websocket_health;
-      if (websocketData) {
-        // Update stat card
-        document.getElementById('websocketConnections').textContent = 
-          `${websocketData.total_connections} (P:${websocketData.plugin_connections}/B:${websocketData.browser_connections})`;
-        
-        // Update detailed section
-        const websocketDiv = document.getElementById('websocketHealth');
-        websocketDiv.innerHTML = `
-          <div style="margin-bottom: 15px;">
-            <div style="display: flex; justify-content: space-between; margin-bottom: 5px;">
-              <span>Plugin Connections:</span>
-              <span style="color: #88f; font-weight: bold;">${websocketData.plugin_connections}</span>
-            </div>
-            <div style="display: flex; justify-content: space-between; margin-bottom: 5px;">
-              <span>Browser Connections:</span>
-              <span style="color: #4f4; font-weight: bold;">${websocketData.browser_connections}</span>
-            </div>
-            <div style="display: flex; justify-content: space-between;">
-              <span>Total Connections:</span>
-              <span style="color: #ff8; font-weight: bold;">${websocketData.total_connections}</span>
-            </div>
-          </div>
-          <div style="font-size: 0.9rem; color: #aaa;">
-            Plugin connections receive telemetry from game clients.<br>
-            Browser connections show live updates to web users.
-          </div>
-        `;
-      } else {
-        document.getElementById('websocketConnections').textContent = 'Error';
-        document.getElementById('websocketHealth').innerHTML = '<p style="color: #f44;">Failed to load WebSocket data</p>';
-      }
-      
-      // Update database performance data
-      const databaseData = data.database_performance;
-      if (databaseData) {
-        // Update stat card
-        document.getElementById('databaseQueries').textContent = 
-          `${databaseData.total_queries} (${databaseData.average_query_time}s avg)`;
-        
-        // Update detailed section
-        const databaseDiv = document.getElementById('databasePerformance');
-        databaseDiv.innerHTML = `
-          <div style="margin-bottom: 15px;">
-            <div style="display: flex; justify-content: space-between; margin-bottom: 5px;">
-              <span>Total Queries:</span>
-              <span style="color: #88f; font-weight: bold;">${databaseData.total_queries}</span>
-            </div>
-            <div style="display: flex; justify-content: space-between; margin-bottom: 5px;">
-              <span>Total Query Time:</span>
-              <span style="color: #4f4; font-weight: bold;">${databaseData.total_query_time}s</span>
-            </div>
-            <div style="display: flex; justify-content: space-between;">
-              <span>Average Query Time:</span>
-              <span style="color: #ff8; font-weight: bold;">${databaseData.average_query_time}s</span>
-            </div>
-          </div>
-          <div style="font-size: 0.9rem; color: #aaa;">
-            Tracks telemetry database write operations performance.<br>
-            Each telemetry message triggers 1-2 database queries.
-          </div>
-        `;
-      } else {
-        document.getElementById('databaseQueries').textContent = 'Error';
-        document.getElementById('databasePerformance').innerHTML = '<p style="color: #f44;">Failed to load database performance data</p>';
-      }
-      
-      // Update recent activity data
-      const activityData = data.recent_activity;
-      if (activityData) {
-        // Update stat card
-        document.getElementById('recentActivityCount').textContent = 
-          `${activityData.total_messages}/${activityData.max_messages}`;
-        
-        // Update detailed section
-        const activityDiv = document.getElementById('recentActivityFeed');
-        if (activityData.recent_messages.length === 0) {
-          activityDiv.innerHTML = '<p style="color: #888; font-style: italic;">No recent activity</p>';
-        } else {
-          activityDiv.innerHTML = activityData.recent_messages.slice().reverse().map(msg => {
-            const timeStr = formatTimestamp(msg.timestamp);
-            const killInfo = msg.kill_delta > 0 ? ` (+${msg.kill_delta} kills)` : '';
-            const queryTime = msg.query_time ? ` ${msg.query_time}ms` : '';
-            return `
-              <div style="display: flex; justify-content: space-between; align-items: center; padding: 4px 0; border-bottom: 1px solid #333; font-family: monospace; font-size: 0.85rem;">
-                <span>
-                  <span style="color: #888;">${timeStr}</span>
-                  <span style="color: #88f; margin-left: 8px;">${msg.character_name}</span>
-                  <span style="color: #aaa; margin-left: 8px;">kills:${msg.kills}${killInfo}</span>
-                </span>
-                <span style="color: #666;">${queryTime}</span>
-              </div>
-            `;
-          }).join('');
-        }
-      } else {
-        document.getElementById('recentActivityCount').textContent = 'Error';
-        document.getElementById('recentActivityFeed').innerHTML = '<p style="color: #f44;">Failed to load recent activity data</p>';
-      }
-      
-      // Update last updated
-      document.getElementById('lastUpdated').textContent = `Last updated: ${formatDate(new Date().toISOString())}`;
-    }
-    
-    function showSuccess() {
-      document.getElementById('status').style.display = 'none';
-      document.getElementById('statsGrid').style.display = 'grid';
-      document.getElementById('sections').style.display = 'grid';
-    }
-    
-    function showError(message) {
-      const statusDiv = document.getElementById('status');
-      statusDiv.innerHTML = `<div class="error">❌ ${message}</div>`;
-      statusDiv.style.display = 'block';
-      document.getElementById('statsGrid').style.display = 'none';
-      document.getElementById('sections').style.display = 'none';
-    }
-    
-    function startPolling() {
-      if (isPolling) return;
-      
-      isPolling = true;
-      fetchDebugData(); // Initial fetch
-      pollInterval = setInterval(fetchDebugData, 5000); // Poll every 5 seconds
-    }
-    
-    function stopPolling() {
-      if (pollInterval) {
-        clearInterval(pollInterval);
-        pollInterval = null;
-      }
-      isPolling = false;
-    }
-    
-    // Handle page visibility changes
-    document.addEventListener('visibilitychange', () => {
-      if (document.hidden) {
-        stopPolling();
-      } else {
-        startPolling();
-      }
-    });
-    
-    // Start polling when page loads
-    window.addEventListener('load', startPolling);
-    
-    // Stop polling when page unloads
-    window.addEventListener('beforeunload', stopPolling);
-  </script>
-</body>
-</html>
\ No newline at end of file
diff --git a/static/index.html b/static/index.html
index 841162a6..565117bb 100644
--- a/static/index.html
+++ b/static/index.html
@@ -46,20 +46,6 @@
       </a>
     </div>
     
-    <!-- Suitbuilder link -->
-    <div class="suitbuilder-link">
-      <a href="#" id="suitbuilderBtn" onclick="openSuitbuilder()">
-        🛡️ Suitbuilder
-      </a>
-    </div>
-    
-    <!-- Player Debug link -->
-    <div class="debug-link">
-      <a href="#" id="playerDebugBtn" onclick="openPlayerDebug()">
-        🔍 Player Debug
-      </a>
-    </div>
-    
     <!-- Text input to filter active players by name -->
     <input type="text" id="playerFilter" class="player-filter" placeholder="Filter players..." />
     
diff --git a/static/inventory.html b/static/inventory.html
deleted file mode 100644
index 93f7624a..00000000
--- a/static/inventory.html
+++ /dev/null
@@ -1,715 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Inventory Search - Dereth Tracker</title>
-    <link rel="stylesheet" href="style.css">
-    <style>
-        /* Override main app styles to enable scrolling */
-        html, body {
-            overflow: auto !important;
-            height: auto !important;
-            display: block !important;
-            margin: 0;
-            padding: 0;
-            font-size: 11px;
-            font-family: Arial, sans-serif;
-            background: #f0f0f0;
-        }
-        
-        /* Inventory-specific styles */
-        .inventory-container {
-            display: flex;
-            gap: 5px;
-            padding: 5px;
-        }
-
-        .character-sidebar {
-            width: 120px;
-            background: white;
-            border: 1px solid #999;
-            padding: 3px;
-            height: fit-content;
-        }
-
-        .character-sidebar h4 {
-            margin: 0 0 3px 0;
-            font-size: 10px;
-            font-weight: bold;
-            color: #000;
-        }
-
-        .character-list {
-            max-height: 300px;
-            overflow-y: auto;
-        }
-
-        .character-item {
-            display: flex;
-            align-items: center;
-            margin-bottom: 1px;
-            font-size: 9px;
-        }
-
-        .character-item input[type="checkbox"] {
-            margin: 0 2px 0 0;
-            width: 9px;
-            height: 9px;
-        }
-
-        .character-item label {
-            cursor: pointer;
-            color: #000;
-            flex: 1;
-        }
-
-        .main-content {
-            flex: 1;
-        }
-
-        .inventory-header {
-            background: #333;
-            color: white;
-            padding: 4px 8px;
-            margin-bottom: 5px;
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-        }
-
-        .inventory-header h1 {
-            margin: 0;
-            font-size: 14px;
-            font-weight: normal;
-        }
-
-        .search-form {
-            background: white;
-            padding: 5px;
-            border: 1px solid #ccc;
-        }
-
-        .filter-row {
-            display: flex;
-            gap: 10px;
-            margin-bottom: 5px;
-            align-items: center;
-        }
-
-        .filter-group {
-            display: flex;
-            align-items: center;
-            gap: 3px;
-        }
-
-        .filter-group label {
-            font-weight: bold;
-            font-size: 10px;
-            color: #000;
-        }
-
-        input[type="text"],
-        input[type="number"],
-        select {
-            border: 1px solid #999;
-            padding: 1px 3px;
-            font-size: 11px;
-            height: 18px;
-        }
-
-        input[type="text"] {
-            width: 120px;
-        }
-
-        input[type="number"] {
-            width: 40px;
-        }
-
-        select {
-            width: 100px;
-        }
-
-        .filter-section {
-            display: flex;
-            align-items: flex-start;
-            gap: 5px;
-            margin-bottom: 3px;
-        }
-
-        .section-label {
-            font-weight: bold;
-            font-size: 10px;
-            min-width: 50px;
-            padding-top: 2px;
-            color: #000;
-        }
-
-        .checkbox-container {
-            display: flex;
-            flex-wrap: wrap;
-            gap: 10px;
-            flex: 1;
-        }
-
-        .checkbox-item {
-            display: flex;
-            align-items: center;
-            font-size: 9px;
-            white-space: nowrap;
-        }
-
-        .checkbox-item input[type="checkbox"] {
-            margin: 0 1px 0 0;
-            width: 9px;
-            height: 9px;
-        }
-
-        .checkbox-item label {
-            cursor: pointer;
-            color: #000;
-        }
-
-        .search-actions {
-            display: flex;
-            gap: 5px;
-            margin-top: 3px;
-        }
-
-        .btn {
-            padding: 2px 8px;
-            border: 1px solid #999;
-            background: #e0e0e0;
-            font-size: 10px;
-            cursor: pointer;
-        }
-
-        .btn-primary {
-            background: #4a80c0;
-            color: white;
-            border-color: #336699;
-        }
-
-        .btn:hover {
-            background: #d0d0d0;
-        }
-
-        .btn-primary:hover {
-            background: #336699;
-        }
-
-        .results-container {
-            background: white;
-            border: 1px solid #999;
-            margin-top: 5px;
-            max-height: calc(100vh - 150px);
-            overflow: auto;
-        }
-
-        .results-table {
-            width: 100%;
-            border-collapse: collapse;
-            font-size: 10px;
-            color: #000;
-        }
-
-        .results-table th {
-            background: #d0d0d0;
-            padding: 1px 3px;
-            text-align: left;
-            font-weight: bold;
-            border: 1px solid #999;
-            position: sticky;
-            top: 0;
-            font-size: 9px;
-        }
-
-        .results-table td {
-            padding: 1px 3px;
-            border: 1px solid #ddd;
-        }
-
-        .results-table tbody tr:hover {
-            background-color: #f0f0f0;
-        }
-
-        .item-name {
-            color: #0066cc;
-            font-weight: bold;
-        }
-
-        .status-equipped {
-            color: #008800;
-        }
-
-        .status-inventory {
-            color: #5f6368;
-        }
-
-        .loading {
-            text-align: center;
-            padding: 20px;
-            color: #5f6368;
-            font-size: 11px;
-        }
-
-        .no-results {
-            text-align: center;
-            padding: 20px;
-            color: #5f6368;
-            font-size: 11px;
-        }
-
-        .error {
-            text-align: center;
-            padding: 10px;
-            color: #d93025;
-            background: #fef7e0;
-            margin: 5px;
-            font-size: 11px;
-        }
-
-        .results-info {
-            padding: 3px 5px;
-            background: #f0f0f0;
-            border-bottom: 1px solid #999;
-            font-weight: normal;
-            color: #333;
-            font-size: 10px;
-        }
-
-        .back-link {
-            display: inline-flex;
-            align-items: center;
-            color: #1a73e8;
-            text-decoration: none;
-            font-weight: 500;
-            margin-bottom: 16px;
-            transition: color 0.2s;
-        }
-
-        .back-link:hover {
-            color: #1557b0;
-        }
-
-        .back-link::before {
-            content: "←";
-            margin-right: 8px;
-            font-size: 1.2rem;
-        }
-        
-        /* Set Analysis specific styles */
-        .set-analysis-section {
-            background: white;
-            border: 1px solid #999;
-            margin-top: 5px;
-        }
-        
-        .set-analysis-form {
-            background: #f8f8f8;
-            padding: 8px;
-            border-bottom: 1px solid #ddd;
-        }
-        
-        .set-analysis-form h3 {
-            margin: 0 0 8px 0;
-            font-size: 12px;
-            font-weight: bold;
-            color: #333;
-        }
-        
-        .set-analysis-form select {
-            width: 140px;
-        }
-        
-        .text-right {
-            text-align: right;
-        }
-    </style>
-</head>
-<body>
-    <div class="inventory-header">
-        <h1>Inventory Search</h1>
-        <a href="/" style="color: white; text-decoration: none; font-size: 11px;">← Back</a>
-    </div>
-    
-    <div class="inventory-container">
-        <!-- Character Selection Sidebar -->
-        <div class="character-sidebar">
-            <h4>Characters</h4>
-            <div class="character-item">
-                <input type="checkbox" id="char_all" checked>
-                <label for="char_all">All Characters</label>
-            </div>
-            <div class="character-list" id="characterList">
-                <!-- Character checkboxes will be populated by JavaScript -->
-            </div>
-        </div>
-        
-        <div class="main-content">
-            <form class="search-form" id="inventorySearchForm">
-            <!-- Row 0: Equipment Type Selection -->
-            <div class="filter-row">
-                <div class="filter-group">
-                    <label>Type:</label>
-                    <div style="display: flex; gap: 10px;">
-                        <label style="display: flex; align-items: center; font-weight: normal;">
-                            <input type="radio" name="equipmentType" id="armorOnly" value="armor" checked style="margin-right: 3px;">
-                            Armor Only
-                        </label>
-                        <label style="display: flex; align-items: center; font-weight: normal;">
-                            <input type="radio" name="equipmentType" id="jewelryOnly" value="jewelry" style="margin-right: 3px;">
-                            Jewelry Only
-                        </label>
-                        <label style="display: flex; align-items: center; font-weight: normal;">
-                            <input type="radio" name="equipmentType" id="allItems" value="all" style="margin-right: 3px;">
-                            All Items
-                        </label>
-                    </div>
-                </div>
-            </div>
-            
-            <!-- Row 0.5: Slot Selection -->
-            <div class="filter-row">
-                <div class="filter-group">
-                    <label>Slot:</label>
-                    <select id="slotFilter">
-                        <option value="">All Slots</option>
-                        <optgroup label="Armor Slots">
-                            <option value="Head">Head</option>
-                            <option value="Chest">Chest</option>
-                            <option value="Upper Arms">Upper Arms</option>
-                            <option value="Lower Arms">Lower Arms</option>
-                            <option value="Hands">Hands</option>
-                            <option value="Abdomen">Abdomen</option>
-                            <option value="Upper Legs">Upper Legs</option>
-                            <option value="Lower Legs">Lower Legs</option>
-                            <option value="Feet">Feet</option>
-                            <option value="Shield">Shield</option>
-                        </optgroup>
-                        <optgroup label="Jewelry Slots">
-                            <option value="Neck">Neck</option>
-                            <option value="Left Ring">Left Ring</option>
-                            <option value="Right Ring">Right Ring</option>
-                            <option value="Left Wrist">Left Wrist</option>
-                            <option value="Right Wrist">Right Wrist</option>
-                            <option value="Trinket">Trinket</option>
-                        </optgroup>
-                    </select>
-                </div>
-            </div>
-            
-            <!-- Row 1: Basic filters -->
-            <div class="filter-row">
-                <div class="filter-group">
-                    <label>Name:</label>
-                    <input type="text" id="searchText" placeholder="Item name">
-                </div>
-                <div class="filter-group">
-                    <label>Status:</label>
-                    <select id="searchEquipStatus">
-                        <option value="all">All</option>
-                        <option value="equipped">Equipped</option>
-                        <option value="unequipped">Inventory</option>
-                    </select>
-                </div>
-            </div>
-            
-            <!-- Row 2: Stats -->
-            <div class="filter-row">
-                <div class="filter-group">
-                    <label>Armor:</label>
-                    <input type="number" id="searchMinArmor" placeholder="Min">
-                    <span>-</span>
-                    <input type="number" id="searchMaxArmor" placeholder="Max">
-                </div>
-                <div class="filter-group">
-                    <label>Crit:</label>
-                    <input type="number" id="searchMinCritDamage" placeholder="Min">
-                    <span>-</span>
-                    <input type="number" id="searchMaxCritDamage" placeholder="Max">
-                </div>
-                <div class="filter-group">
-                    <label>Dmg:</label>
-                    <input type="number" id="searchMinDamageRating" placeholder="Min">
-                    <span>-</span>
-                    <input type="number" id="searchMaxDamageRating" placeholder="Max">
-                </div>
-                <div class="filter-group">
-                    <label>Heal:</label>
-                    <input type="number" id="searchMinHealBoost" placeholder="Min">
-                    <span>-</span>
-                    <input type="number" id="searchMaxHealBoost" placeholder="Max">
-                </div>
-            </div>
-
-            <!-- Equipment Sets -->
-            <div class="filter-section">
-                <label class="section-label">Set:</label>
-                <div class="checkbox-container" id="equipmentSets">
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_14" value="14">
-                        <label for="set_14">Adept's</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_16" value="16">
-                        <label for="set_16">Defender's</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_13" value="13">
-                        <label for="set_13">Soldier's</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_21" value="21">
-                        <label for="set_21">Wise</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_40" value="40">
-                        <label for="set_40">Heroic Protector</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_41" value="41">
-                        <label for="set_41">Heroic Destroyer</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_46" value="46">
-                        <label for="set_46">Relic Alduressa</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_47" value="47">
-                        <label for="set_47">Ancient Relic</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_48" value="48">
-                        <label for="set_48">Noble Relic</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_15" value="15">
-                        <label for="set_15">Archer's</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_19" value="19">
-                        <label for="set_19">Hearty</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_20" value="20">
-                        <label for="set_20">Dexterous</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_22" value="22">
-                        <label for="set_22">Swift</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_24" value="24">
-                        <label for="set_24">Reinforced</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_26" value="26">
-                        <label for="set_26">Flame Proof</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="set_29" value="29">
-                        <label for="set_29">Lightning Proof</label>
-                    </div>
-                </div>
-            </div>
-
-            <!-- Legendary Cantrips -->
-            <div class="filter-section">
-                <label class="section-label">Cantrips:</label>
-                <div class="checkbox-container" id="cantrips">
-                    <!-- Legendary Attributes -->
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_strength" value="Legendary Strength">
-                        <label for="cantrip_legendary_strength">Strength</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_endurance" value="Legendary Endurance">
-                        <label for="cantrip_legendary_endurance">Endurance</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_quickness" value="Legendary Quickness">
-                        <label for="cantrip_legendary_quickness">Quickness</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_coordination" value="Legendary Coordination">
-                        <label for="cantrip_legendary_coordination">Coordination</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_willpower" value="Legendary Willpower">
-                        <label for="cantrip_legendary_willpower">Willpower</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_focus" value="Legendary Focus">
-                        <label for="cantrip_legendary_focus">Focus</label>
-                    </div>
-                    <!-- Legendary Weapon Skills -->
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_finesse" value="Legendary Finesse Weapons">
-                        <label for="cantrip_legendary_finesse">Finesse</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_heavy" value="Legendary Heavy Weapons">
-                        <label for="cantrip_legendary_heavy">Heavy</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_light" value="Legendary Light Weapons">
-                        <label for="cantrip_legendary_light">Light</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_missile" value="Legendary Missile Weapons">
-                        <label for="cantrip_legendary_missile">Missile</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_twohanded" value="Legendary Two Handed Combat">
-                        <label for="cantrip_legendary_twohanded">Two-handed</label>
-                    </div>
-                    <!-- Legendary Magic Skills -->
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_war" value="Legendary War Magic">
-                        <label for="cantrip_legendary_war">War Magic</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_void" value="Legendary Void Magic">
-                        <label for="cantrip_legendary_void">Void Magic</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_creature" value="Legendary Creature Enchantment">
-                        <label for="cantrip_legendary_creature">Creature</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_item" value="Legendary Item Enchantment">
-                        <label for="cantrip_legendary_item">Item</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_life" value="Legendary Life Magic">
-                        <label for="cantrip_legendary_life">Life Magic</label>
-                    </div>
-                    <!-- Legendary Defense -->
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_magic_defense" value="Legendary Magic Defense">
-                        <label for="cantrip_legendary_magic_defense">Magic Def</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="cantrip_legendary_melee_defense" value="Legendary Melee Defense">
-                        <label for="cantrip_legendary_melee_defense">Melee Def</label>
-                    </div>
-                </div>
-            </div>
-
-            <!-- Legendary Wards -->
-            <div class="filter-section">
-                <label class="section-label">Wards:</label>
-                <div class="checkbox-container" id="protections">
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="protection_flame" value="Legendary Flame Ward">
-                        <label for="protection_flame">Flame</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="protection_frost" value="Legendary Frost Ward">
-                        <label for="protection_frost">Frost</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="protection_acid" value="Legendary Acid Ward">
-                        <label for="protection_acid">Acid</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="protection_storm" value="Legendary Storm Ward">
-                        <label for="protection_storm">Storm</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="protection_slashing" value="Legendary Slashing Ward">
-                        <label for="protection_slashing">Slashing</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="protection_piercing" value="Legendary Piercing Ward">
-                        <label for="protection_piercing">Piercing</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="protection_bludgeoning" value="Legendary Bludgeoning Ward">
-                        <label for="protection_bludgeoning">Bludgeoning</label>
-                    </div>
-                    <div class="checkbox-item">
-                        <input type="checkbox" id="protection_armor" value="Legendary Armor">
-                        <label for="protection_armor">Armor</label>
-                    </div>
-                </div>
-            </div>
-
-            <div class="search-actions">
-                <button type="button" class="btn btn-secondary" id="clearBtn">Clear All</button>
-                <button type="submit" class="btn btn-primary">Search Items</button>
-                <button type="button" class="btn btn-secondary" id="setAnalysisBtn">Analyze Sets</button>
-                <button type="button" class="btn btn-secondary" id="slotViewBtn">Slot View</button>
-            </div>
-        </form>
-
-            <!-- Set Analysis Section -->
-            <div class="set-analysis-section" id="setAnalysisSection" style="display: none;">
-                <div class="set-analysis-form">
-                    <h3>Equipment Set Combination Analysis</h3>
-                    <div class="filter-row">
-                        <div class="filter-group">
-                            <label>Primary Set (5 pieces):</label>
-                            <select id="primarySetSelect">
-                                <option value="14">Adept's Set</option>
-                                <option value="16">Defender's Set</option>
-                                <option value="13">Soldier's Set</option>
-                                <option value="21">Wise Set</option>
-                                <option value="40">Heroic Protector</option>
-                                <option value="41">Heroic Destroyer</option>
-                                <option value="46">Relic Alduressa</option>
-                                <option value="47">Ancient Relic</option>
-                                <option value="48">Noble Relic</option>
-                            </select>
-                        </div>
-                        <div class="filter-group">
-                            <label>Secondary Set (4 pieces):</label>
-                            <select id="secondarySetSelect">
-                                <option value="13">Soldier's Set</option>
-                                <option value="14">Adept's Set</option>
-                                <option value="16">Defender's Set</option>
-                                <option value="21">Wise Set</option>
-                                <option value="40">Heroic Protector</option>
-                                <option value="41">Heroic Destroyer</option>
-                                <option value="46">Relic Alduressa</option>
-                                <option value="47">Ancient Relic</option>
-                                <option value="48">Noble Relic</option>
-                            </select>
-                        </div>
-                        <div class="filter-group">
-                            <button type="button" class="btn btn-primary" id="runSetAnalysis">Analyze</button>
-                            <button type="button" class="btn btn-secondary" id="backToSearch">Back to Search</button>
-                        </div>
-                    </div>
-                </div>
-                
-                <div class="results-container" id="setAnalysisResults">
-                    <div class="no-results">Select primary and secondary sets above and click "Analyze" to find valid combinations.</div>
-                </div>
-            </div>
-
-            <!-- Slot View Section -->
-            <div class="slot-view-section" id="slotViewSection" style="display: none;">
-                <div class="slot-view-header">
-                    <h3>Equipment Slot View</h3>
-                    <div class="filter-row">
-                        <button type="button" class="btn btn-primary" id="loadSlotView">Load Items</button>
-                        <button type="button" class="btn btn-secondary" id="backToSearchFromSlots">Back to Search</button>
-                    </div>
-                </div>
-                
-                <div class="slots-grid" id="slotsGrid">
-                    <!-- Slots will be populated by JavaScript -->
-                </div>
-            </div>
-
-            <div class="results-container" id="searchResults">
-                <div class="no-results">Enter search criteria above and click "Search Items" to find inventory items.</div>
-            </div>
-        </div>
-    </div>
-
-    <script src="inventory.js"></script>
-</body>
-</html>
\ No newline at end of file
diff --git a/static/inventory.js b/static/inventory.js
deleted file mode 100644
index 9cd2e29d..00000000
--- a/static/inventory.js
+++ /dev/null
@@ -1,722 +0,0 @@
-/**
- * Inventory Search Application
- * Dedicated JavaScript for the inventory search page
- */
-
-// Configuration - use main app proxy for inventory service
-const API_BASE = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1' 
-  ? 'http://localhost:8766'  // Local development - direct to inventory service
-  : `${window.location.origin}/inv`;  // Production - through main app proxy
-
-// DOM Elements - will be set after DOM loads
-let searchForm, clearBtn, searchResults;
-
-// Sorting state
-let currentSort = {
-    field: 'name',
-    direction: 'asc'
-};
-
-// Store current search results for client-side sorting
-let currentResultsData = null;
-
-// Initialize the application
-document.addEventListener('DOMContentLoaded', function() {
-    // Get DOM elements after DOM is loaded
-    searchForm = document.getElementById('inventorySearchForm');
-    clearBtn = document.getElementById('clearBtn');
-    searchResults = document.getElementById('searchResults');
-    
-    
-    initializeEventListeners();
-    loadCharacterOptions();
-});
-
-/**
- * Initialize all event listeners
- */
-function initializeEventListeners() {
-    // Form submission
-    searchForm.addEventListener('submit', async (e) => {
-        e.preventDefault();
-        await performSearch();
-    });
-    
-    // Clear button
-    clearBtn.addEventListener('click', clearAllFields);
-    
-    // Slot filter change
-    document.getElementById('slotFilter').addEventListener('change', handleSlotFilterChange);
-    
-    // Set analysis buttons
-    document.getElementById('setAnalysisBtn').addEventListener('click', showSetAnalysis);
-    document.getElementById('backToSearch').addEventListener('click', showSearchSection);
-    document.getElementById('runSetAnalysis').addEventListener('click', performSetAnalysis);
-    
-    // Checkbox visual feedback for cantrips and equipment sets
-    document.querySelectorAll('.checkbox-item input[type="checkbox"]').forEach(checkbox => {
-        checkbox.addEventListener('change', handleCheckboxChange);
-    });
-}
-
-/**
- * Load available characters for the checkbox list
- */
-async function loadCharacterOptions() {
-    try {
-        // Use inventory service proxy endpoint for character list
-        const response = await fetch(`${window.location.origin}/inventory-characters`);
-        const data = await response.json();
-        
-        if (data.characters && data.characters.length > 0) {
-            const characterList = document.getElementById('characterList');
-            
-            // Sort characters by name
-            data.characters.sort((a, b) => a.character_name.localeCompare(b.character_name));
-            
-            // Add character checkboxes
-            data.characters.forEach(char => {
-                const div = document.createElement('div');
-                div.className = 'character-item';
-                
-                const checkbox = document.createElement('input');
-                checkbox.type = 'checkbox';
-                checkbox.id = `char_${char.character_name}`;
-                checkbox.value = char.character_name;
-                checkbox.className = 'character-checkbox';
-                checkbox.checked = true; // Check all by default
-                
-                const label = document.createElement('label');
-                label.htmlFor = checkbox.id;
-                label.textContent = char.character_name;
-                
-                div.appendChild(checkbox);
-                div.appendChild(label);
-                characterList.appendChild(div);
-            });
-            
-            // Set up event listeners for character selection
-            setupCharacterCheckboxes();
-        }
-    } catch (error) {
-        console.warn('Could not load character list:', error);
-    }
-}
-
-/**
- * Setup character checkbox functionality
- */
-function setupCharacterCheckboxes() {
-    const allCheckbox = document.getElementById('char_all');
-    const characterCheckboxes = document.querySelectorAll('.character-checkbox');
-    
-    // Handle "All Characters" checkbox
-    allCheckbox.addEventListener('change', function() {
-        characterCheckboxes.forEach(cb => {
-            cb.checked = this.checked;
-        });
-    });
-    
-    // Handle individual character checkboxes
-    characterCheckboxes.forEach(cb => {
-        cb.addEventListener('change', function() {
-            // If any individual checkbox is unchecked, uncheck "All"
-            if (!this.checked) {
-                allCheckbox.checked = false;
-            } else {
-                // If all individual checkboxes are checked, check "All"
-                const allChecked = Array.from(characterCheckboxes).every(checkbox => checkbox.checked);
-                allCheckbox.checked = allChecked;
-            }
-        });
-    });
-}
-
-/**
- * Handle checkbox change events for visual feedback
- */
-function handleCheckboxChange(e) {
-    const item = e.target.closest('.checkbox-item');
-    if (e.target.checked) {
-        item.classList.add('checked');
-    } else {
-        item.classList.remove('checked');
-    }
-}
-
-/**
- * Clear all form fields and checkboxes
- */
-function clearAllFields() {
-    searchForm.reset();
-    
-    // Reset character selection to "All"
-    document.getElementById('char_all').checked = true;
-    document.querySelectorAll('.character-checkbox').forEach(cb => {
-        cb.checked = true;
-    });
-    
-    // Clear checkbox visual states
-    document.querySelectorAll('.checkbox-item').forEach(item => {
-        item.classList.remove('checked');
-    });
-    
-    // Reset equipment type to armor
-    document.getElementById('armorOnly').checked = true;
-    
-    // Reset slot filter
-    document.getElementById('slotFilter').value = '';
-    
-    // Reset results and clear stored data
-    currentResultsData = null;
-    searchResults.innerHTML = '<div class="no-results">Enter search criteria above and click "Search Items" to find inventory items.</div>';
-}
-
-/**
- * Handle slot filter changes
- */
-function handleSlotFilterChange() {
-    // If we have current results, reapply filtering and sorting
-    if (currentResultsData) {
-        // Reset items to original unfiltered data
-        const originalData = JSON.parse(JSON.stringify(currentResultsData));
-        
-        // Apply slot filtering
-        applySlotFilter(originalData);
-        
-        // Apply sorting
-        sortResults(originalData);
-        
-        // Display results
-        displayResults(originalData);
-    }
-}
-
-
-/**
- * Perform the search based on form inputs
- */
-async function performSearch() {
-    searchResults.innerHTML = '<div class="loading">🔍 Searching inventory...</div>';
-    
-    try {
-        const params = buildSearchParameters();
-        const searchUrl = `${API_BASE}/search/items?${params.toString()}`;
-        console.log('Search URL:', searchUrl);
-        
-        const response = await fetch(searchUrl);
-        const data = await response.json();
-
-        if (!response.ok) {
-            throw new Error(data.detail || 'Search failed');
-        }
-
-        // Store results for client-side re-sorting
-        currentResultsData = data;
-        
-        // Apply client-side slot filtering
-        applySlotFilter(data);
-        
-        // Sort the results client-side before displaying
-        sortResults(data);
-        displayResults(data);
-        
-    } catch (error) {
-        console.error('Search error:', error);
-        searchResults.innerHTML = `<div class="error">❌ Search failed: ${error.message}</div>`;
-    }
-}
-
-/**
- * Build search parameters from form inputs
- */
-function buildSearchParameters() {
-    const params = new URLSearchParams();
-    
-    // Equipment type selection
-    const equipmentType = document.querySelector('input[name="equipmentType"]:checked').value;
-    if (equipmentType === 'armor') {
-        params.append('armor_only', 'true');
-    } else if (equipmentType === 'jewelry') {
-        params.append('jewelry_only', 'true');
-    }
-    // If 'all' is selected, don't add any type filter
-    
-    // Basic search parameters - handle character selection
-    const allCharactersChecked = document.getElementById('char_all').checked;
-    if (!allCharactersChecked) {
-        // Get selected characters
-        const selectedCharacters = Array.from(document.querySelectorAll('.character-checkbox:checked'))
-            .map(cb => cb.value);
-        
-        if (selectedCharacters.length === 1) {
-            // Single character selected
-            params.append('character', selectedCharacters[0]);
-        } else if (selectedCharacters.length > 1) {
-            // Multiple characters - use comma-separated list
-            params.append('characters', selectedCharacters.join(','));
-        } else {
-            // No characters selected - search nothing
-            return { items: [], total_count: 0, page: 1, total_pages: 0 };
-        }
-    } else {
-        // All characters selected
-        params.append('include_all_characters', 'true');
-    }
-    addParam(params, 'text', 'searchText');
-    addParam(params, 'material', 'searchMaterial');
-    
-    const equipStatus = document.getElementById('searchEquipStatus').value;
-    if (equipStatus && equipStatus !== 'all') {
-        params.append('equipment_status', equipStatus);
-    }
-    
-    // Armor statistics parameters
-    addParam(params, 'min_armor', 'searchMinArmor');
-    addParam(params, 'max_armor', 'searchMaxArmor');
-    addParam(params, 'min_crit_damage_rating', 'searchMinCritDamage');
-    addParam(params, 'max_crit_damage_rating', 'searchMaxCritDamage');
-    addParam(params, 'min_damage_rating', 'searchMinDamageRating');
-    addParam(params, 'max_damage_rating', 'searchMaxDamageRating');
-    addParam(params, 'min_heal_boost_rating', 'searchMinHealBoost');
-    addParam(params, 'max_heal_boost_rating', 'searchMaxHealBoost');
-    
-    // Requirements parameters
-    addParam(params, 'min_level', 'searchMinLevel');
-    addParam(params, 'max_level', 'searchMaxLevel');
-    addParam(params, 'min_workmanship', 'searchMinWorkmanship');
-    addParam(params, 'max_workmanship', 'searchMaxWorkmanship');
-    
-    // Value parameters
-    addParam(params, 'min_value', 'searchMinValue');
-    addParam(params, 'max_value', 'searchMaxValue');
-    addParam(params, 'max_burden', 'searchMaxBurden');
-    
-    // Equipment set filters
-    const selectedEquipmentSets = getSelectedEquipmentSets();
-    if (selectedEquipmentSets.length === 1) {
-        params.append('item_set', selectedEquipmentSets[0]);
-    } else if (selectedEquipmentSets.length > 1) {
-        params.append('item_sets', selectedEquipmentSets.join(','));
-    }
-    
-    // Cantrip filters
-    const selectedCantrips = getSelectedCantrips();
-    const selectedProtections = getSelectedProtections();
-    const allSpells = [...selectedCantrips, ...selectedProtections];
-    if (allSpells.length > 0) {
-        params.append('legendary_cantrips', allSpells.join(','));
-    }
-    
-    // Pagination only - sorting will be done client-side
-    params.append('limit', '1000'); // Show all items on one page
-    
-    return params;
-}
-
-/**
- * Helper function to add parameter if value exists
- */
-function addParam(params, paramName, elementId) {
-    const value = document.getElementById(elementId)?.value?.trim();
-    if (value) {
-        params.append(paramName, value);
-    }
-}
-
-/**
- * Get selected equipment sets
- */
-function getSelectedEquipmentSets() {
-    const selectedSets = [];
-    document.querySelectorAll('#equipmentSets input[type="checkbox"]:checked').forEach(cb => {
-        selectedSets.push(cb.value);
-    });
-    return selectedSets;
-}
-
-/**
- * Get selected legendary cantrips
- */
-function getSelectedCantrips() {
-    const selectedCantrips = [];
-    document.querySelectorAll('#cantrips input[type="checkbox"]:checked').forEach(cb => {
-        selectedCantrips.push(cb.value);
-    });
-    return selectedCantrips;
-}
-
-/**
- * Get selected protection spells
- */
-function getSelectedProtections() {
-    const selectedProtections = [];
-    document.querySelectorAll('#protections input[type="checkbox"]:checked').forEach(cb => {
-        selectedProtections.push(cb.value);
-    });
-    return selectedProtections;
-}
-
-/**
- * Display search results in the UI
- */
-function displayResults(data) {
-    if (!data.items || data.items.length === 0) {
-        searchResults.innerHTML = '<div class="no-results">No items found matching your search criteria.</div>';
-        return;
-    }
-
-    const getSortIcon = (field) => {
-        if (currentSort.field === field) {
-            return currentSort.direction === 'asc' ? ' ▲' : ' ▼';
-        }
-        return '';
-    };
-
-    let html = `
-        <div class="results-info">
-            Found <strong>${data.total_count}</strong> items - Showing all results
-        </div>
-        <table class="results-table">
-            <thead>
-                <tr>
-                    <th class="sortable" data-sort="character_name">Character${getSortIcon('character_name')}</th>
-                    <th class="sortable" data-sort="name">Item Name${getSortIcon('name')}</th>
-                    <th class="sortable" data-sort="item_type_name">Type${getSortIcon('item_type_name')}</th>
-                    <th class="text-right sortable" data-sort="slot_name">Slot${getSortIcon('slot_name')}</th>
-                    <th class="text-right sortable" data-sort="coverage">Coverage${getSortIcon('coverage')}</th>
-                    <th class="text-right sortable" data-sort="armor_level">Armor${getSortIcon('armor_level')}</th>
-                    <th class="sortable" data-sort="spell_names">Spells/Cantrips${getSortIcon('spell_names')}</th>
-                    <th class="text-right sortable" data-sort="crit_damage_rating">Crit Dmg${getSortIcon('crit_damage_rating')}</th>
-                    <th class="text-right sortable" data-sort="damage_rating">Dmg Rating${getSortIcon('damage_rating')}</th>
-                    <th class="text-right sortable" data-sort="last_updated">Last Updated${getSortIcon('last_updated')}</th>
-                </tr>
-            </thead>
-            <tbody>
-    `;
-
-    data.items.forEach((item) => {
-        const armor = item.armor_level > 0 ? item.armor_level : '-';
-        const critDmg = item.crit_damage_rating > 0 ? item.crit_damage_rating : '-';
-        const dmgRating = item.damage_rating > 0 ? item.damage_rating : '-';
-        const status = item.is_equipped ? '⚔️ Equipped' : '📦 Inventory';
-        const statusClass = item.is_equipped ? 'status-equipped' : 'status-inventory';
-        
-        // Use the slot_name provided by the API instead of incorrect mapping
-        const slot = item.slot_name || 'Unknown';
-        
-        // Coverage placeholder - will need to be added to backend later
-        const coverage = item.coverage || '-';
-        
-        // Format last updated timestamp
-        const lastUpdated = item.last_updated ? 
-            new Date(item.last_updated).toLocaleDateString('en-US', {
-                month: 'short',
-                day: 'numeric',
-                hour: '2-digit',
-                minute: '2-digit'
-            }) : '-';
-        
-        // Use the formatted name with material from the API
-        let displayName = item.name;
-        
-        // The API should already include material in the name, but use material_name if available
-        if (item.material_name && item.material_name !== '' && !item.name.toLowerCase().includes(item.material_name.toLowerCase())) {
-            displayName = `${item.material_name} ${item.name}`;
-        }
-        
-        // Format spells/cantrips list
-        let spellsDisplay = '-';
-        if (item.spell_names && item.spell_names.length > 0) {
-            // Highlight legendary cantrips in a different color
-            const formattedSpells = item.spell_names.map(spell => {
-                if (spell.toLowerCase().includes('legendary')) {
-                    return `<span class="legendary-cantrip">${spell}</span>`;
-                } else {
-                    return `<span class="regular-spell">${spell}</span>`;
-                }
-            });
-            spellsDisplay = formattedSpells.join('<br>');
-        }
-        
-        // Get item type for display
-        const itemType = item.item_type_name || '-';
-        
-        html += `
-            <tr>
-                <td>${item.character_name}</td>
-                <td class="item-name">${displayName}</td>
-                <td>${itemType}</td>
-                <td class="text-right">${slot}</td>
-                <td class="text-right">${coverage}</td>
-                <td class="text-right">${armor}</td>
-                <td class="spells-cell">${spellsDisplay}</td>
-                <td class="text-right">${critDmg}</td>
-                <td class="text-right">${dmgRating}</td>
-                <td class="text-right">${lastUpdated}</td>
-            </tr>
-        `;
-    });
-
-    html += `
-            </tbody>
-        </table>
-    `;
-
-    // Add pagination info if needed
-    if (data.total_pages > 1) {
-        html += `
-            <div style="padding: 16px 24px; text-align: center; color: #5f6368; border-top: 1px solid #e8eaed;">
-                Showing page ${data.page} of ${data.total_pages} pages
-            </div>
-        `;
-    }
-
-    searchResults.innerHTML = html;
-    
-    // Add click event listeners to sortable headers
-    document.querySelectorAll('.sortable').forEach(header => {
-        header.addEventListener('click', () => {
-            const sortField = header.getAttribute('data-sort');
-            handleSort(sortField);
-        });
-    });
-}
-/**
- * Apply client-side slot filtering
- */
-function applySlotFilter(data) {
-    const selectedSlot = document.getElementById('slotFilter').value;
-    
-    if (!selectedSlot || !data.items) {
-        return; // No filter or no data
-    }
-    
-    // Filter items that can be equipped in the selected slot
-    data.items = data.items.filter(item => {
-        const slotName = item.slot_name || '';
-        
-        // Check if the item's slot_name contains the selected slot
-        // This handles multi-slot items like "Left Ring, Right Ring"
-        return slotName.includes(selectedSlot);
-    });
-    
-    // Update total count
-    data.total_count = data.items.length;
-}
-
-/**
- * Sort results client-side based on current sort settings
- */
-function sortResults(data) {
-    if (!data.items || data.items.length === 0) return;
-    
-    const field = currentSort.field;
-    const direction = currentSort.direction;
-    
-    data.items.sort((a, b) => {
-        let aVal = a[field];
-        let bVal = b[field];
-        
-        // Handle null/undefined values
-        if (aVal == null && bVal == null) return 0;
-        if (aVal == null) return 1;
-        if (bVal == null) return -1;
-        
-        // Special handling for spell_names array
-        if (field === 'spell_names') {
-            // Convert arrays to strings for sorting
-            aVal = Array.isArray(aVal) ? aVal.join(', ').toLowerCase() : '';
-            bVal = Array.isArray(bVal) ? bVal.join(', ').toLowerCase() : '';
-            const result = aVal.localeCompare(bVal);
-            return direction === 'asc' ? result : -result;
-        }
-        
-        // Determine if we're sorting numbers or strings
-        const isNumeric = typeof aVal === 'number' || (!isNaN(aVal) && !isNaN(parseFloat(aVal)));
-        
-        if (isNumeric) {
-            // Numeric sorting
-            aVal = parseFloat(aVal) || 0;
-            bVal = parseFloat(bVal) || 0;
-            const result = aVal - bVal;
-            return direction === 'asc' ? result : -result;
-        } else {
-            // String sorting
-            aVal = String(aVal).toLowerCase();
-            bVal = String(bVal).toLowerCase();
-            const result = aVal.localeCompare(bVal);
-            return direction === 'asc' ? result : -result;
-        }
-    });
-}
-
-/**
- * Handle column sorting
- */
-function handleSort(field) {
-    // If clicking the same field, toggle direction
-    if (currentSort.field === field) {
-        currentSort.direction = currentSort.direction === 'asc' ? 'desc' : 'asc';
-    } else {
-        // New field, default to ascending
-        currentSort.field = field;
-        currentSort.direction = 'asc';
-    }
-    
-    // Re-display current results with new sorting (no new search needed)
-    if (currentResultsData) {
-        // Reset items to original unfiltered data
-        const originalData = JSON.parse(JSON.stringify(currentResultsData));
-        
-        // Apply slot filtering first
-        applySlotFilter(originalData);
-        
-        // Then apply sorting
-        sortResults(originalData);
-        
-        // Display results
-        displayResults(originalData);
-    }
-}
-
-/**
- * Show set analysis section
- */
-function showSetAnalysis() {
-    document.getElementById('setAnalysisSection').style.display = 'block';
-    document.getElementById('searchResults').style.display = 'none';
-    searchForm.style.display = 'none';
-}
-
-/**
- * Show search section
- */
-function showSearchSection() {
-    document.getElementById('setAnalysisSection').style.display = 'none';
-    document.getElementById('searchResults').style.display = 'block';
-    searchForm.style.display = 'block';
-}
-
-/**
- * Perform set combination analysis
- */
-async function performSetAnalysis() {
-    const primarySet = document.getElementById('primarySetSelect').value;
-    const secondarySet = document.getElementById('secondarySetSelect').value;
-    const setAnalysisResults = document.getElementById('setAnalysisResults');
-    
-    if (primarySet === secondarySet) {
-        setAnalysisResults.innerHTML = '<div class="error">❌ Primary and secondary sets must be different.</div>';
-        return;
-    }
-    
-    setAnalysisResults.innerHTML = '<div class="loading">🔍 Analyzing set combinations...</div>';
-    
-    try {
-        const params = new URLSearchParams();
-        params.append('primary_set', primarySet);
-        params.append('secondary_set', secondarySet);
-        params.append('primary_count', '5');
-        params.append('secondary_count', '4');
-        
-        // Use selected characters or all characters
-        const allCharactersChecked = document.getElementById('char_all').checked;
-        if (allCharactersChecked) {
-            params.append('include_all_characters', 'true');
-        } else {
-            const selectedCharacters = Array.from(document.querySelectorAll('.character-checkbox:checked'))
-                .map(cb => cb.value);
-            if (selectedCharacters.length > 0) {
-                params.append('characters', selectedCharacters.join(','));
-            } else {
-                setAnalysisResults.innerHTML = '<div class="error">❌ Please select at least one character or check "All Characters".</div>';
-                return;
-            }
-        }
-        
-        const analysisUrl = `${API_BASE}/analyze/sets?${params.toString()}`;
-        console.log('Set Analysis URL:', analysisUrl);
-        
-        const response = await fetch(analysisUrl);
-        const data = await response.json();
-
-        if (!response.ok) {
-            throw new Error(data.detail || 'Set analysis failed');
-        }
-
-        displaySetAnalysisResults(data);
-        
-    } catch (error) {
-        console.error('Set analysis error:', error);
-        setAnalysisResults.innerHTML = `<div class="error">❌ Set analysis failed: ${error.message}</div>`;
-    }
-}
-
-/**
- * Display set analysis results
- */
-function displaySetAnalysisResults(data) {
-    const setAnalysisResults = document.getElementById('setAnalysisResults');
-    
-    if (!data.character_analysis || data.character_analysis.length === 0) {
-        setAnalysisResults.innerHTML = '<div class="no-results">No characters found with the selected sets.</div>';
-        return;
-    }
-    
-    let html = `
-        <div class="results-info">
-            <strong>${data.primary_set.name}</strong> (${data.primary_set.pieces_needed} pieces) + 
-            <strong>${data.secondary_set.name}</strong> (${data.secondary_set.pieces_needed} pieces)<br>
-            Found <strong>${data.characters_can_build}</strong> of <strong>${data.total_characters}</strong> characters who can build this combination
-        </div>
-        <table class="results-table">
-            <thead>
-                <tr>
-                    <th>Character</th>
-                    <th>Can Build?</th>
-                    <th>${data.primary_set.name}</th>
-                    <th>${data.secondary_set.name}</th>
-                    <th>Primary Items</th>
-                    <th>Secondary Items</th>
-                </tr>
-            </thead>
-            <tbody>
-    `;
-
-    data.character_analysis.forEach((char) => {
-        const canBuild = char.can_build_combination;
-        const canBuildText = canBuild ? '✅ Yes' : '❌ No';
-        const canBuildClass = canBuild ? 'status-equipped' : 'status-inventory';
-        
-        const primaryStatus = `${char.primary_set_available}/${char.primary_set_needed}`;
-        const secondaryStatus = `${char.secondary_set_available}/${char.secondary_set_needed}`;
-        
-        // Format item lists
-        const primaryItems = char.primary_items.map(item => 
-            `${item.name}${item.equipped ? ' ⚔️' : ''}`
-        ).join('<br>') || '-';
-        
-        const secondaryItems = char.secondary_items.map(item => 
-            `${item.name}${item.equipped ? ' ⚔️' : ''}`
-        ).join('<br>') || '-';
-        
-        html += `
-            <tr>
-                <td><strong>${char.character_name}</strong></td>
-                <td class="${canBuildClass}">${canBuildText}</td>
-                <td class="text-right">${primaryStatus}</td>
-                <td class="text-right">${secondaryStatus}</td>
-                <td class="spells-cell">${primaryItems}</td>
-                <td class="spells-cell">${secondaryItems}</td>
-            </tr>
-        `;
-    });
-
-    html += `
-            </tbody>
-        </table>
-    `;
-
-    setAnalysisResults.innerHTML = html;
-}
diff --git a/static/script.js b/static/script.js
index 1a5f186d..ba505276 100644
--- a/static/script.js
+++ b/static/script.js
@@ -1776,20 +1776,4 @@ function openInventorySearch() {
   window.open('/inventory.html', '_blank');
 }
 
-/**
- * Opens the Suitbuilder interface in a new browser tab.
- */
-function openSuitbuilder() {
-  // Open the Suitbuilder page in a new tab
-  window.open('/suitbuilder.html', '_blank');
-}
-
-/**
- * Opens the Player Debug interface in a new browser tab.
- */
-function openPlayerDebug() {
-  // Open the Player Debug page in a new tab
-  window.open('/debug.html', '_blank');
-}
-
 
diff --git a/static/style.css b/static/style.css
index 2f1de269..29ba3b58 100644
--- a/static/style.css
+++ b/static/style.css
@@ -1240,62 +1240,6 @@ body.noselect, body.noselect * {
   margin: -2px -4px;
 }
 
-.suitbuilder-link {
-  margin: 0 0 12px;
-  padding: 8px 12px;
-  background: var(--card);
-  border: 1px solid #ff6b4a;
-  border-radius: 4px;
-  text-align: center;
-}
-
-.suitbuilder-link a {
-  color: #ff6b4a;
-  text-decoration: none;
-  font-size: 0.9rem;
-  font-weight: 500;
-  display: block;
-  cursor: pointer;
-  user-select: none;
-  transition: all 0.2s ease;
-}
-
-.suitbuilder-link a:hover {
-  color: #fff;
-  background: rgba(255, 107, 74, 0.1);
-  border-radius: 2px;
-  padding: 2px 4px;
-  margin: -2px -4px;
-}
-
-.debug-link {
-  margin: 0 0 12px;
-  padding: 8px 12px;
-  background: var(--card);
-  border: 1px solid #4aff6b;
-  border-radius: 4px;
-  text-align: center;
-}
-
-.debug-link a {
-  color: #4aff6b;
-  text-decoration: none;
-  font-size: 0.9rem;
-  font-weight: 500;
-  display: block;
-  cursor: pointer;
-  user-select: none;
-  transition: all 0.2s ease;
-}
-
-.debug-link a:hover {
-  color: #fff;
-  background: rgba(74, 255, 107, 0.1);
-  border-radius: 2px;
-  padding: 2px 4px;
-  margin: -2px -4px;
-}
-
 /* Sortable column styles for inventory tables */
 .sortable {
     cursor: pointer;