diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
deleted file mode 100644
index c16a5c28..00000000
--- a/ARCHITECTURE.md
+++ /dev/null
@@ -1,95 +0,0 @@
-# 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
deleted file mode 100644
index 48240575..00000000
--- a/EVENT_FORMATS.json
+++ /dev/null
@@ -1,45 +0,0 @@
-{
-  "_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
deleted file mode 100644
index c8160b85..00000000
--- a/FIXES.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# 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
deleted file mode 100644
index 2ee1085d..00000000
--- a/LESSONSLEARNED.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# 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 3578c5de..14a24307 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, and provides a live map interface along with a sample data generator for testing.
+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.
 
 ## Table of Contents
 - [Overview](#overview)
@@ -16,20 +16,27 @@ 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 sample data generator script (`generate_data.py`) for simulating telemetry snapshots.
+- 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.
 
 ## Features
 
-- **WebSocket /ws/position**: Stream telemetry snapshots (protected by a shared secret).
+- **WebSocket /ws/position**: Stream telemetry snapshots and inventory updates (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
@@ -218,11 +225,13 @@ 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.
 
@@ -253,11 +262,14 @@ 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
-and aggregate character statistics. The primary tables are:
+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:
 
 - **telemetry_events** (hypertable):
   - `id` (PK, serial)
@@ -297,6 +309,41 @@ and aggregate character statistics. The primary tables are:
   - `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
deleted file mode 100644
index 11318369..00000000
--- a/TODO.md
+++ /dev/null
@@ -1,62 +0,0 @@
-## 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 6745473e..28ae5c69 100644
--- a/inventory-service/main.py
+++ b/inventory-service/main.py
@@ -5,6 +5,7 @@ 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
@@ -12,7 +13,8 @@ from datetime import datetime
 
 from fastapi import FastAPI, HTTPException, Depends, Query
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, StreamingResponse
+from sse_starlette.sse import EventSourceResponse
 from pydantic import BaseModel
 import databases
 import sqlalchemy as sa
@@ -252,6 +254,18 @@ 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
@@ -362,7 +376,8 @@ def translate_coverage_mask(coverage_value: int) -> List[str]:
         'Head': 'Head',
         'Hands': 'Hands',
         'Feet': 'Feet',
-        'Cloak': 'Cloak'
+        'Cloak': 'Cloak',
+        'Robe': 'Robe'
     }
     
     return [name_mapping.get(part, part) for part in covered_parts if part]
@@ -509,6 +524,7 @@ 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'
@@ -564,10 +580,22 @@ def translate_equipment_slot(wielded_location: int) -> str:
             'Held': 'Held',
             'TwoHanded': 'Two-Handed',
             'TrinketOne': 'Trinket',
-            'Cloak': 'Cloak'
+            'Cloak': 'Cloak',
+            'Robe': 'Robe'
         }
         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():
@@ -604,7 +632,8 @@ def translate_equipment_slot(wielded_location: int) -> str:
             'Held': 'Held',
             'TwoHanded': 'Two-Handed',
             'TrinketOne': 'Trinket',
-            'Cloak': 'Cloak'
+            'Cloak': 'Cloak',
+            'Robe': 'Robe'
         }
         
         translated_parts = [name_mapping.get(part, part) for part in slot_parts]
@@ -621,7 +650,7 @@ def translate_equipment_slot(wielded_location: int) -> str:
         else:
             return f"Special Slot ({wielded_location})"
     
-    return f"Unknown Slot ({wielded_location})"
+    return "-"
 
 def translate_workmanship(workmanship_value: int) -> str:
     """Translate workmanship value to descriptive text."""
@@ -839,10 +868,21 @@ 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  
+    # Translate item type if present (check ItemType field or IntValues[1])
     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')
@@ -874,7 +914,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': int_values.get('279', int_values.get(279, 0)) != 0,
+            'unique': bool(int_values.get('279', int_values.get(279, 0))),
             
             # Stack/Container properties
             'stack_size': int_values.get('12', int_values.get(12, 1)),
@@ -935,11 +975,11 @@ def extract_item_properties(item_data: Dict[str, Any]) -> Dict[str, Any]:
             'equip_skill': item_data.get('EquipSkill'),
         },
         'enhancements': {
-            'material': item_data.get('Material'),
+            'material': None,  # Will be set below with proper logic
             'imbue': item_data.get('Imbue'),
             'tinks': item_data.get('Tinks', -1),
             'workmanship': item_data.get('Workmanship', -1.0),
-            'item_set': int_values.get('265', int_values.get(265)) if int_values.get('265', int_values.get(265)) else None,
+            'item_set': None,  # Will be set below with translation
             
             # Advanced tinkering
             'num_times_tinkered': int_values.get('171', int_values.get(171, -1)),
@@ -991,6 +1031,32 @@ 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:
@@ -1107,6 +1173,14 @@ 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,
@@ -1310,9 +1384,12 @@ async def get_character_inventory(
                 # Add translated properties to the item
                 processed_item['translated_properties'] = properties
                 
-                # Add material translation
+                # Add material name - use material directly if it's already a string
                 if processed_item.get('material'):
-                    processed_item['material_name'] = translate_material_type(processed_item['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'])
                 
                 # Add object class translation
                 if processed_item.get('object_class'):
@@ -1424,6 +1501,8 @@ 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:
@@ -2086,11 +2165,15 @@ async def search_items(
                     if item.get('material') or properties.get('translations', {}).get('material_name'):
                         material_name = None
                         if item.get('material'):
-                            material_name = translate_material_type(item['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'])
                         elif properties.get('translations', {}).get('material_name'):
                             material_name = properties['translations']['material_name']
                         
-                        if material_name:
+                        if material_name and not material_name.startswith('Unknown_Material_'):
                             item['material_name'] = material_name
                             # Apply material prefix to item name
                             original_name = item['name']
@@ -2102,6 +2185,13 @@ 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']
@@ -2162,11 +2252,15 @@ async def search_items(
                                 if slot_name and slot_name not in slot_names:
                                     slot_names.append(slot_name)
                             
-                            item['slot_name'] = ', '.join(slot_names) if slot_names else f"Slot_{equippable_slots}"
+                            # 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 "-"
                         else:
-                            item['slot_name'] = "Unknown"
+                            item['slot_name'] = "-"
                     else:
-                        item['slot_name'] = "Unknown"
+                        item['slot_name'] = "-"
                     
                     # 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) 
@@ -2424,6 +2518,3041 @@ 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 d2b5c831..420a72f0 100644
--- a/inventory-service/requirements.txt
+++ b/inventory-service/requirements.txt
@@ -6,4 +6,5 @@ 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
\ No newline at end of file
+psycopg2-binary==2.9.9
+sse-starlette==1.8.2
\ No newline at end of file
diff --git a/main.py b/main.py
index 7ec722d2..81b220cc 100644
--- a/main.py
+++ b/main.py
@@ -10,6 +10,7 @@ import json
 import logging
 import os
 import sys
+import time
 from typing import Dict, List, Any
 from pathlib import Path
 
@@ -60,6 +61,249 @@ _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
@@ -92,7 +336,12 @@ 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})
-                _cached_live["players"] = [dict(r) for r in rows]
+                new_players = [dict(r) for r in rows]
+                
+                # Track player changes for debugging
+                _track_player_changes(new_players)
+                
+                _cached_live["players"] = new_players
                 
                 # Recompute trails (last 600s)
                 cutoff2 = datetime.utcnow().replace(tzinfo=timezone.utc) - timedelta(seconds=600)
@@ -347,6 +596,104 @@ 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)
@@ -899,6 +1246,8 @@ 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:
@@ -908,7 +1257,11 @@ async def ws_receive_snapshots(
         return
     # Accept the WebSocket connection
     await websocket.accept()
-    logger.info(f"Plugin WebSocket connected: {websocket.client}")
+    logger.info(f"🔌 PLUGIN_CONNECTED: {websocket.client}")
+    
+    # Track plugin connection
+    _plugin_connections += 1
+    
     try:
         while True:
             # Read next text frame
@@ -917,7 +1270,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 WebSocket disconnected: {websocket.client}")
+                logger.info(f"🔌 PLUGIN_DISCONNECTED: {websocket.client}")
                 break
             # Parse JSON payload
             try:
@@ -931,7 +1284,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"Registered plugin connection for character: {name}")
+                    logger.info(f"📋 PLUGIN_REGISTERED: {name} from {websocket.client}")
                 continue
             # --- Spawn event: persist to spawn_events table ---
             if msg_type == "spawn":
@@ -952,6 +1305,12 @@ 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()
@@ -974,6 +1333,16 @@ 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(
@@ -989,15 +1358,60 @@ 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:
-                        logger.error(f"💾 Database transaction failed for {snap.character_name} (session: {snap.session_id[:8]}): {db_error}", exc_info=True)
+                        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)
                         continue
                     # Broadcast updated snapshot to all browser clients
                     await _broadcast_to_browser_clients(snap.dict())
-                    logger.debug(f"✅ Processed telemetry from {snap.character_name} (session: {snap.session_id[:8]}, kills: {snap.kills})")
+                    
+                    # 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")
+                    
                 except Exception as e:
-                    logger.error(f"❌ Failed to process telemetry event from {data.get('character_name', 'unknown')}: {e}", exc_info=True)
+                    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)
                 continue
             # --- Rare event: update total and session counters and persist ---
             if msg_type == "rare":
@@ -1082,6 +1496,9 @@ 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:
@@ -1153,10 +1570,15 @@ 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
@@ -1198,6 +1620,9 @@ 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
new file mode 100644
index 00000000..3f6199bc
--- /dev/null
+++ b/static/debug.html
@@ -0,0 +1,654 @@
+<!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 565117bb..841162a6 100644
--- a/static/index.html
+++ b/static/index.html
@@ -46,6 +46,20 @@
       </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
new file mode 100644
index 00000000..93f7624a
--- /dev/null
+++ b/static/inventory.html
@@ -0,0 +1,715 @@
+<!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
new file mode 100644
index 00000000..9cd2e29d
--- /dev/null
+++ b/static/inventory.js
@@ -0,0 +1,722 @@
+/**
+ * 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 ba505276..1a5f186d 100644
--- a/static/script.js
+++ b/static/script.js
@@ -1776,4 +1776,20 @@ 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 29ba3b58..2f1de269 100644
--- a/static/style.css
+++ b/static/style.css
@@ -1240,6 +1240,62 @@ 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;