diff --git a/dashboard/css/ble-panel.css b/dashboard/css/ble-panel.css
new file mode 100644
index 0000000..8b76314
--- /dev/null
+++ b/dashboard/css/ble-panel.css
@@ -0,0 +1,423 @@
+/**
+ * Spaxel Dashboard - BLE Panel Styles
+ *
+ * People & Devices panel specific styles.
+ */
+
+/* ============================================
+   BLE Panel Layout
+   ============================================ */
+
+.ble-panel {
+    background: #1e1e3a;
+}
+
+/* Loading State */
+.ble-loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 40px 20px;
+    color: #888;
+    font-size: 14px;
+}
+
+/* Error State */
+.ble-error {
+    background: rgba(239, 83, 80, 0.1);
+    border: 1px solid rgba(239, 83, 80, 0.3);
+    border-radius: 8px;
+    padding: 16px;
+    color: #ef5350;
+    font-size: 13px;
+    text-align: center;
+}
+
+.ble-error button {
+    margin-top: 12px;
+    padding: 6px 12px;
+    background: rgba(239, 83, 80, 0.2);
+    border: 1px solid rgba(239, 83, 80, 0.4);
+    border-radius: 4px;
+    color: #ef5350;
+    font-size: 12px;
+    cursor: pointer;
+    transition: background 0.2s;
+}
+
+.ble-error button:hover {
+    background: rgba(239, 83, 80, 0.3);
+}
+
+/* Empty State */
+.ble-empty {
+    text-align: center;
+    padding: 40px 20px;
+    color: #666;
+    font-size: 13px;
+    line-height: 1.5;
+}
+
+/* Section Header */
+.ble-section-header {
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    color: #888;
+    margin: 20px 0 12px 0;
+    padding-bottom: 6px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.ble-section-header:first-child {
+    margin-top: 0;
+}
+
+/* ============================================
+   Device List
+   ============================================ */
+
+.ble-device-list {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+}
+
+.ble-device {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 12px;
+    background: rgba(255, 255, 255, 0.03);
+    border-radius: 6px;
+    cursor: pointer;
+    transition: background 0.2s;
+}
+
+.ble-device:hover {
+    background: rgba(255, 255, 255, 0.08);
+}
+
+.ble-device-person {
+    border-left: 3px solid #ab47bc;
+}
+
+.ble-device-unregistered {
+    border-left: 3px solid #666;
+}
+
+/* Device Icon */
+.ble-device-icon {
+    font-size: 18px;
+    flex-shrink: 0;
+    width: 24px;
+    text-align: center;
+}
+
+/* Device Name */
+.ble-device-name {
+    flex: 1;
+    font-size: 13px;
+    color: #eee;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+/* Device RSSI */
+.ble-device-rssi {
+    font-size: 11px;
+    color: #888;
+    font-family: monospace;
+    flex-shrink: 0;
+}
+
+/* Device Buttons */
+.ble-device-add,
+.ble-device-expand {
+    flex-shrink: 0;
+    width: 24px;
+    height: 24px;
+    border: none;
+    border-radius: 4px;
+    font-size: 14px;
+    cursor: pointer;
+    transition: background 0.2s, transform 0.1s;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.ble-device-add {
+    background: rgba(76, 175, 80, 0.2);
+    color: #66bb6a;
+}
+
+.ble-device-add:hover {
+    background: rgba(76, 175, 80, 0.3);
+    transform: scale(1.1);
+}
+
+.ble-device-expand {
+    background: rgba(255, 255, 255, 0.1);
+    color: #888;
+}
+
+.ble-device-expand:hover {
+    background: rgba(255, 255, 255, 0.15);
+}
+
+/* ============================================
+   Edit/Register Modal
+   ============================================ */
+
+.ble-edit-form {
+    padding: 8px 0;
+}
+
+.ble-edit-form h3 {
+    margin: 0 0 8px;
+    font-size: 16px;
+    color: #eee;
+}
+
+.ble-hint {
+    margin: 0 0 16px;
+    font-size: 13px;
+    color: #aaa;
+    line-height: 1.4;
+}
+
+.ble-form-group {
+    margin-bottom: 12px;
+}
+
+.ble-form-group label {
+    display: block;
+    font-size: 12px;
+    color: #aaa;
+    margin-bottom: 4px;
+}
+
+.ble-form-group input[type="text"],
+.ble-form-group input[type="color"],
+.ble-form-group select {
+    width: 100%;
+    padding: 8px 10px;
+    background: rgba(255, 255, 255, 0.05);
+    border: 1px solid rgba(255, 255, 255, 0.15);
+    border-radius: 4px;
+    color: #eee;
+    font-size: 13px;
+    box-sizing: border-box;
+}
+
+.ble-form-group input[type="color"] {
+    height: 36px;
+    padding: 2px;
+    cursor: pointer;
+}
+
+.ble-form-group input:focus,
+.ble-form-group select:focus {
+    outline: none;
+    border-color: #ab47bc;
+    box-shadow: 0 0 0 2px rgba(171, 71, 188, 0.15);
+}
+
+.ble-form-actions {
+    display: flex;
+    gap: 8px;
+    justify-content: flex-end;
+    margin-top: 16px;
+}
+
+.btn-cancel {
+    padding: 8px 16px;
+    background: rgba(255, 255, 255, 0.1);
+    border: none;
+    border-radius: 4px;
+    color: #ccc;
+    font-size: 13px;
+    cursor: pointer;
+    transition: background 0.2s;
+}
+
+.btn-cancel:hover {
+    background: rgba(255, 255, 255, 0.15);
+}
+
+.btn-primary {
+    padding: 8px 16px;
+    background: #ab47bc;
+    border: none;
+    border-radius: 4px;
+    color: #fff;
+    font-size: 13px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: background 0.2s;
+}
+
+.btn-primary:hover {
+    background: #9c4cb3;
+}
+
+.btn-secondary {
+    padding: 8px 16px;
+    background: rgba(255, 255, 255, 0.1);
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    border-radius: 4px;
+    color: #ccc;
+    font-size: 13px;
+    cursor: pointer;
+    transition: background 0.2s;
+}
+
+.btn-secondary:hover {
+    background: rgba(255, 255, 255, 0.15);
+    color: #eee;
+}
+
+.btn-danger {
+    padding: 8px 16px;
+    background: rgba(244, 67, 54, 0.2);
+    border: 1px solid rgba(244, 67, 54, 0.3);
+    border-radius: 4px;
+    color: #ef5350;
+    font-size: 13px;
+    cursor: pointer;
+    transition: background 0.2s;
+}
+
+.btn-danger:hover {
+    background: rgba(244, 67, 54, 0.3);
+}
+
+/* ============================================
+   Device Details Modal
+   ============================================ */
+
+.ble-device-details {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    margin-bottom: 16px;
+}
+
+.ble-detail-row {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 8px 0;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.ble-detail-label {
+    font-size: 12px;
+    color: #888;
+}
+
+.ble-detail-value {
+    font-size: 13px;
+    color: #eee;
+    font-family: monospace;
+}
+
+.ble-details-actions {
+    display: flex;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+.ble-details-actions button {
+    flex: 1;
+    min-width: 80px;
+}
+
+/* ============================================
+   History View (Future Enhancement)
+   ============================================ */
+
+.ble-history-list {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.ble-history-entry {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 6px 8px;
+    background: rgba(255, 255, 255, 0.03);
+    border-radius: 4px;
+    font-size: 11px;
+}
+
+.ble-history-time {
+    color: #888;
+    font-family: monospace;
+}
+
+.ble-history-rssi {
+    color: #4fc3f7;
+    font-family: monospace;
+}
+
+.ble-history-node {
+    color: #aaa;
+    font-size: 10px;
+}
+
+/* ============================================
+   Privacy Notice
+   ============================================ */
+
+.ble-privacy-notice {
+    background: rgba(171, 71, 188, 0.1);
+    border: 1px solid rgba(171, 71, 188, 0.2);
+    border-radius: 6px;
+    padding: 10px 12px;
+    margin-bottom: 16px;
+    font-size: 11px;
+    color: #ba68c8;
+    line-height: 1.4;
+}
+
+/* ============================================
+   Animations
+   ============================================ */
+
+@keyframes ble-pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.6; }
+}
+
+.ble-device.unseen .ble-device-icon {
+    animation: ble-pulse 2s ease-in-out infinite;
+}
+
+/* ============================================
+   Responsive
+   ============================================ */
+
+@media (max-width: 480px) {
+    .ble-device {
+        padding: 8px 10px;
+    }
+
+    .ble-device-name {
+        font-size: 12px;
+    }
+
+    .ble-details-actions {
+        flex-direction: column;
+    }
+
+    .ble-details-actions button {
+        width: 100%;
+    }
+}
diff --git a/dashboard/index.html b/dashboard/index.html
index 2e9a3f3..c60abd6 100644
--- a/dashboard/index.html
+++ b/dashboard/index.html
@@ -8,6 +8,7 @@
     <link rel="stylesheet" href="css/panels.css">
     <link rel="stylesheet" href="css/timeline.css">
     <link rel="stylesheet" href="css/apdetection.css">
+    <link rel="stylesheet" href="css/ble-panel.css">
     <style>
         * {
             margin: 0;
@@ -1362,6 +1363,43 @@
             color: #ccc;
         }
 
+        /* BLE button in status bar */
+        #ble-btn {
+            background: rgba(171, 71, 188, 0.15);
+            border: 1px solid rgba(171, 71, 188, 0.4);
+            color: #ba68c8;
+            font-size: 12px;
+            padding: 3px 10px;
+            border-radius: 4px;
+            cursor: pointer;
+            transition: background 0.2s, color 0.2s;
+            position: relative;
+        }
+
+        #ble-btn:hover {
+            background: rgba(171, 71, 188, 0.25);
+            color: #ce93d8;
+        }
+
+        #ble-btn .badge {
+            position: absolute;
+            top: -4px;
+            right: -4px;
+            background: #ef5350;
+            color: white;
+            font-size: 9px;
+            font-weight: 600;
+            padding: 1px 4px;
+            border-radius: 8px;
+            min-width: 14px;
+            text-align: center;
+            display: none;
+        }
+
+        #ble-btn.has-unregistered .badge {
+            display: block;
+        }
+
         /* Room editor button */
         #room-editor-btn {
             background: rgba(255,255,255,0.06);
@@ -2009,6 +2047,7 @@
             </div>
         </div>
         <div class="status-item" style="margin-left:auto; gap:6px;">
+            <button id="ble-btn" onclick="BLEPanel && BLEPanel.open()">People & Devices<span id="ble-unregistered-badge" class="badge"></span></button>
             <button id="settings-btn" onclick="openSettingsPanel && openSettingsPanel()">Settings</button>
             <button id="add-node-btn" onclick="SpaxelOnboard && SpaxelOnboard.start()">+ Add Node</button>
             <button id="add-virtual-btn" onclick="Placement && Placement.addVirtualNode()">+ Virtual</button>
@@ -2111,6 +2150,8 @@
     <script src="js/router.js"></script>
     <!-- Settings Panel -->
     <script src="js/settings-panel.js"></script>
+    <!-- BLE People & Devices Panel -->
+    <script src="js/ble-panel.js"></script>
     <!-- Troubleshooting manager (must load before app.js) -->
     <script src="js/troubleshoot.js"></script>
     <!-- First-time feature tooltips (must load before app.js) -->
diff --git a/dashboard/js/ble-panel.js b/dashboard/js/ble-panel.js
new file mode 100644
index 0000000..548002e
--- /dev/null
+++ b/dashboard/js/ble-panel.js
@@ -0,0 +1,931 @@
+/**
+ * Spaxel Dashboard - BLE Device Panel (Phase 6)
+ *
+ * People & Devices panel for discovering, registering, and labeling BLE devices.
+ * Uses the SpaxelPanels framework for integration.
+ */
+
+(function() {
+    'use strict';
+
+    // ============================================
+    // State
+    // ============================================
+    const state = {
+        devices: [],
+        registeredDevices: [],
+        discoveredDevices: [],
+        people: [],
+        selectedDevice: null,
+        loading: false,
+        error: null,
+        filters: {
+            showRegistered: true,
+            showDiscovered: true
+        },
+        // Auto-type detection hints
+        typeHints: {
+            'apple_phone': { icon: '📱', label: 'iPhone' },
+            'apple_watch': { icon: '⌚', label: 'Apple Watch' },
+            'apple_earbuds': { icon: '🎧', label: 'AirPods' },
+            'fitbit': { icon: '⌚', label: 'Fitbit' },
+            'garmin': { icon: '⌚', label: 'Garmin' },
+            'tile': { icon: '📍', label: 'Tile Tracker' },
+            'microsoft': { icon: '💻', label: 'Microsoft' },
+            'samsung': { icon: '📱', label: 'Samsung' },
+            'google': { icon: '📱', label: 'Google' },
+            'ruuvi': { icon: '🌡️', label: 'Ruuvi Sensor' }
+        }
+    };
+
+    // ============================================
+    // API Functions
+    // ============================================
+
+    function fetchDevices(filter) {
+        let url = '/api/ble/devices';
+        const params = [];
+
+        // Default to last 24 hours
+        params.push('hours=24');
+
+        if (filter === 'registered') {
+            params.push('registered=true');
+        } else if (filter === 'discovered') {
+            params.push('discovered=true');
+        }
+
+        if (params.length > 0) {
+            url += '?' + params.join('&');
+        }
+
+        return fetch(url)
+            .then(function(res) {
+                if (!res.ok) {
+                    throw new Error('Failed to fetch devices: ' + res.status);
+                }
+                return res.json();
+            })
+            .then(function(data) {
+                return data.devices || [];
+            });
+    }
+
+    function fetchPeople() {
+        return fetch('/api/people')
+            .then(function(res) {
+                if (!res.ok) {
+                    return []; // People API might not exist yet
+                }
+                return res.json();
+            })
+            .catch(function() {
+                return []; // Graceful degradation
+            });
+    }
+
+    function loadAllDevices() {
+        state.loading = true;
+
+        // Fetch devices and people in parallel
+        return Promise.all([
+            fetchDevices().then(function(devices) {
+                // Split into registered and discovered based on person_id
+                state.registeredDevices = devices.filter(function(d) {
+                    return d.person_id && d.person_id !== '';
+                });
+                state.discoveredDevices = devices.filter(function(d) {
+                    return !d.person_id || d.person_id === '';
+                });
+                return devices;
+            }),
+            fetchPeople().then(function(people) {
+                state.people = people || [];
+                return people;
+            })
+        ]).then(function() {
+            state.loading = false;
+            updateUnregisteredCount();
+        }).catch(function(err) {
+            state.loading = false;
+            state.error = err.message;
+            console.error('[BLEPanel] Error loading devices:', err);
+        });
+    }
+
+    function updateDevice(mac, data) {
+        return fetch('/api/ble/devices/' + encodeURIComponent(mac), {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(data)
+        })
+        .then(function(res) {
+            if (!res.ok) {
+                return res.json().then(function(err) {
+                    throw new Error(err.error || 'Failed to update device');
+                });
+            }
+            return res.json();
+        })
+        .then(function() {
+            return loadAllDevices();
+        });
+    }
+
+    function getDeviceHistory(mac) {
+        return fetch('/api/ble/devices/' + encodeURIComponent(mac) + '/history?limit=50')
+            .then(function(res) {
+                if (!res.ok) {
+                    throw new Error('Failed to fetch device history');
+                }
+                return res.json();
+            });
+    }
+
+    // ============================================
+    // UI Rendering
+    // ============================================
+
+    function renderLoading() {
+        return '<div class="ble-loading">Loading devices...</div>';
+    }
+
+    function renderError(error) {
+        return '<div class="ble-error">Error: ' + escapeHtml(error) +
+               '<button onclick="window.BLEPanel && window.BLEPanel.refresh()">Retry</button></div>';
+    }
+
+    function renderDeviceList(devices, title, showType) {
+        if (!devices || devices.length === 0) {
+            return '<div class="ble-empty">No ' + title.toLowerCase() + ' devices</div>';
+        }
+
+        // Sort by sighting frequency (rssi_count), then by last_seen
+        var sortedDevices = devices.slice().sort(function(a, b) {
+            var countDiff = (b.rssi_count || 0) - (a.rssi_count || 0);
+            if (countDiff !== 0) return countDiff;
+            return (b.last_seen_at || 0) - (a.last_seen_at || 0);
+        });
+
+        var html = '<div class="ble-section-header">' + title + ' (' + sortedDevices.length + ')</div>';
+        html += '<div class="ble-device-list">';
+
+        sortedDevices.forEach(function(device) {
+            var name = device.name || device.label || device.device_name || formatMAC(device.mac);
+            var typeIcon = getDeviceTypeIcon(device.device_type);
+            var typeLabel = device.device_type ? getTypeLabel(device.device_type) : '';
+            var rssiText = device.rssi_avg !== 0 ? device.rssi_avg + ' dBm' : '';
+            var lastSeenText = formatTime(device.last_seen_at);
+            var personName = device.person_name || '';
+
+            var color = device.color || '#888';
+            var cssClass = device.person_id ? 'ble-device-person' : 'ble-device-unregistered';
+
+            html += '<div class="ble-device ' + cssClass + '" data-mac="' + device.mac + '">' +
+                '<span class="ble-device-icon" style="color:' + color + '">' + typeIcon + '</span>' +
+                '<span class="ble-device-info">' +
+                    '<span class="ble-device-name">' + escapeHtml(name) + '</span>';
+
+            if (typeLabel) {
+                html += '<span class="ble-device-type">' + typeLabel + '</span>';
+            }
+
+            if (personName) {
+                html += '<span class="ble-device-person-label">(' + escapeHtml(personName) + ')</span>';
+            }
+
+            html += '</span>' + // Close ble-device-info
+                '<span class="ble-device-meta">' +
+                    (rssiText ? '<span class="ble-device-rssi">' + rssiText + '</span>' : '') +
+                    '<span class="ble-device-time">' + lastSeenText + '</span>' +
+                '</span>';
+
+            // Add action buttons
+            if (device.person_id) {
+                // Registered device - show expand for details
+                html += '<button class="ble-device-expand" data-mac="' + device.mac + '" title="View details">▼</button>';
+            } else {
+                // Unregistered device - show add button
+                html += '<button class="ble-device-add" data-mac="' + device.mac + '" title="Register device">+</button>';
+            }
+
+            html += '</div>';
+        });
+
+        html += '</div>';
+        return html;
+    }
+
+    function renderPanelContent() {
+        if (state.loading) {
+            return renderLoading();
+        }
+
+        if (state.error) {
+            return renderError(state.error);
+        }
+
+        var html = '';
+
+        // Add privacy notice
+        html += '<div class="ble-privacy-notice">' +
+            '📱 Phones may appear multiple times due to address rotation. ' +
+            'Wearables and tracker tags have stable addresses.</div>';
+
+        // Add manual pre-registration button
+        html += '<div class="ble-preregister-section">' +
+            '<button class="ble-preregister-btn" id="ble-preregister-btn">+ Pre-register Device</button>' +
+            '</div>';
+
+        // Add person section
+        if (state.filters.showRegistered) {
+            html += renderDeviceList(state.registeredDevices, 'People', 'person');
+        }
+
+        // Add discovered devices section
+        if (state.filters.showDiscovered) {
+            html += renderDeviceList(state.discoveredDevices, 'Discovered', 'unregistered');
+        }
+
+        if (html === '') {
+            html = '<div class="ble-empty">No BLE devices discovered yet. ' +
+                   'Devices will appear here automatically when nodes detect them.</div>';
+        }
+
+        return html;
+    }
+
+    function renderEditModal(device) {
+        var isNew = !device;
+        var title = isNew ? 'Register Device' : 'Edit Device';
+        var mac = device ? device.mac : '';
+        var deviceName = device ? (device.name || device.device_name || '') : '';
+        var label = device ? (device.label || '') : '';
+        var deviceType = device ? (device.device_type || 'unknown') : 'unknown';
+        var color = device ? (device.color || '#4fc3f7') : '#4fc3f7';
+
+        return '<div class="ble-edit-form">' +
+            '<h3>' + title + '</h3>' +
+            (isNew ? '<p class="ble-hint">Register this BLE device to track a person, pet, or object.</p>' : '') +
+            (device && device.device_name ? '<p class="ble-info"><strong>Detected:</strong> ' + escapeHtml(device.device_name) +
+                (device.manufacturer ? ' (' + escapeHtml(device.manufacturer) + ')' : '') + '</p>' : '') +
+            '<div class="ble-form-group">' +
+                '<label>Device Label</label>' +
+                '<input type="text" id="ble-edit-label" value="' + escapeHtml(label) + '" placeholder="e.g., Alice\'s Phone">' +
+            '</div>' +
+            '<div class="ble-form-group">' +
+                '<label>Assign to Person</label>' +
+                '<select id="ble-edit-person">' +
+                    '<option value="">-- Unassigned --</option>' +
+                    getPeopleOptions(device ? device.person_id : '') +
+                '</select>' +
+                '<p class="ble-hint">Or create a new person below</p>' +
+            '</div>' +
+            '<div class="ble-form-group">' +
+                '<label>New Person Name</label>' +
+                '<input type="text" id="ble-edit-new-person" placeholder="e.g., Alice">' +
+            '</div>' +
+            '<div class="ble-form-group">' +
+                '<label>Display Color</label>' +
+                '<input type="color" id="ble-edit-color" value="' + color + '">' +
+            '</div>' +
+            '<div class="ble-form-group">' +
+                '<label>Device Type</label>' +
+                '<select id="ble-edit-type">' +
+                    '<option value="unknown">Unknown</option>' +
+                    '<option value="person">Person (Phone)</option>' +
+                    '<option value="pet">Pet (Tracker)</option>' +
+                    '<option value="object">Object (Tag)</option>' +
+                    '<option value="wearable">Wearable (Watch/Tracker)</option>' +
+                    '<option value="headphones">Headphones/Earbuds</option>' +
+                    '<option value="tracker">Tracker Tag (Tile/AirTag)</option>' +
+                '</select>' +
+            '</div>' +
+            '<div class="ble-form-actions">' +
+                '<button class="btn-cancel" id="ble-edit-cancel">Cancel</button>' +
+                '<button class="btn-primary" id="ble-edit-save">Save</button>' +
+            '</div>' +
+            '</div>';
+    }
+
+    function getPeopleOptions(selectedPersonId) {
+        var html = '';
+        state.people.forEach(function(p) {
+            var selected = p.id === selectedPersonId ? ' selected' : '';
+            html += '<option value="' + escapeHtml(p.id) + '"' + selected + '>' +
+                escapeHtml(p.name) + '</option>';
+        });
+        return html;
+    }
+
+    // ============================================
+    // Panel Opening
+    // ============================================
+
+    function openBLEPanel() {
+        // Refresh data when opening
+        loadAllDevices();
+
+        // Open the panel using SpaxelPanels
+        return SpaxelPanels.openSidebar({
+            title: 'People & Devices',
+            content: function(contentEl) {
+                // Render initial content
+                contentEl.innerHTML = renderPanelContent();
+
+                // Set up event listeners
+                setupEventListeners(contentEl);
+
+                // Store reference for updates
+                contentEl._blePanelRefresh = refreshContent;
+            },
+            width: '380px',
+            className: 'ble-panel',
+            onOpen: function(contentEl) {
+                // Panel opened - refresh data
+                loadAllDevices();
+            },
+            onClose: function() {
+                // Panel closed - clean up
+            }
+        });
+    }
+
+    function refreshContent() {
+        return loadAllDevices().then(function() {
+            // After loading, re-render the panel content
+            var panel = document.querySelector('.ble-panel .panel-content');
+            if (panel) {
+                panel.innerHTML = renderPanelContent();
+                setupEventListeners(panel);
+            }
+        });
+    }
+
+    function setupEventListeners(contentEl) {
+        // Pre-register button
+        var preregBtn = contentEl.querySelector('#ble-preregister-btn');
+        if (preregBtn) {
+            preregBtn.addEventListener('click', showPreregisterModal);
+        }
+
+        // Device add buttons
+        var addBtns = contentEl.querySelectorAll('.ble-device-add');
+        addBtns.forEach(function(btn) {
+            btn.addEventListener('click', function(e) {
+                e.stopPropagation();
+                var mac = this.getAttribute('data-mac');
+                showRegisterModal(mac);
+            });
+        });
+
+        // Device expand buttons
+        var expandBtns = contentEl.querySelectorAll('.ble-device-expand');
+        expandBtns.forEach(function(btn) {
+            btn.addEventListener('click', function(e) {
+                e.stopPropagation();
+                var mac = this.getAttribute('data-mac');
+                var device = findDevice(mac);
+                if (device) {
+                    showDeviceDetails(device);
+                }
+            });
+        });
+
+        // Device items (for clicking through to details)
+        var devices = contentEl.querySelectorAll('.ble-device-person');
+        devices.forEach(function(item) {
+            item.addEventListener('click', function() {
+                var mac = this.getAttribute('data-mac');
+                var device = findDevice(mac);
+                if (device) {
+                    showDeviceDetails(device);
+                }
+            });
+        });
+
+        // Setup modal action button handlers
+        setupModalActionHandlers(contentEl);
+    }
+
+    function showPreregisterModal() {
+        SpaxelPanels.openModal({
+            title: 'Pre-register Device',
+            content: renderPreregisterForm(),
+            width: '400px',
+            showCancel: true,
+            showConfirm: false,
+            onOpen: function(modalEl) {
+                var registerBtn = modalEl.querySelector('#ble-preregister-submit');
+                var cancelBtn = modalEl.querySelector('#ble-preregister-cancel');
+
+                cancelBtn.addEventListener('click', function() {
+                    SpaxelPanels.closeModal();
+                });
+
+                registerBtn.addEventListener('click', function() {
+                    var mac = modalEl.querySelector('#ble-preregister-mac').value.trim();
+                    var label = modalEl.querySelector('#ble-preregister-label').value.trim();
+
+                    if (!mac) {
+                        SpaxelPanels.showError('Please enter a MAC address');
+                        return;
+                    }
+
+                    // Validate MAC format (basic validation)
+                    var macPattern = /^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$/;
+                    if (!macPattern.test(mac)) {
+                        SpaxelPanels.showError('Invalid MAC address format. Use format: AA:BB:CC:DD:EE:FF');
+                        return;
+                    }
+
+                    var data = { mac: mac };
+                    if (label) {
+                        data.label = label;
+                    }
+
+                    // Pre-register the device
+                    preregisterDevice(data).then(function() {
+                        SpaxelPanels.showSuccess('Device pre-registered. When your tracker tag is detected, it will be automatically associated with this entry.');
+                        SpaxelPanels.closeModal();
+                        loadAllDevices();
+                    }).catch(function(err) {
+                        SpaxelPanels.showError('Failed to pre-register device: ' + err.message);
+                    });
+                });
+            }
+        });
+    }
+
+    function renderPreregisterForm() {
+        return '<div class="ble-edit-form">' +
+            '<h3>Pre-register Device</h3>' +
+            '<p class="ble-hint">Manually register a tracker tag by its MAC address. Useful for pre-registering Tile, AirTag, or other trackers before they are detected.</p>' +
+            '<div class="ble-form-group">' +
+                '<label>MAC Address</label>' +
+                '<input type="text" id="ble-preregister-mac" placeholder="AA:BB:CC:DD:EE:FF" maxlength="17">' +
+            '</div>' +
+            '<div class="ble-form-group">' +
+                '<label>Label</label>' +
+                '<input type="text" id="ble-preregister-label" placeholder="e.g., Car Keys Tile">' +
+            '</div>' +
+            '<div class="ble-form-actions">' +
+                '<button class="btn-cancel" id="ble-preregister-cancel">Cancel</button>' +
+                '<button class="btn-primary" id="ble-preregister-submit">Pre-register</button>' +
+            '</div>' +
+            '</div>';
+    }
+
+    function preregisterDevice(data) {
+        return fetch('/api/ble/devices/preregister', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(data)
+        })
+        .then(function(res) {
+            if (!res.ok) {
+                return res.json().then(function(err) {
+                    throw new Error(err.error || 'Failed to pre-register device');
+                });
+            }
+            return res.json();
+        });
+    }
+
+    function setupModalActionHandlers(modalEl) {
+        // Edit button
+        var editBtn = modalEl.querySelector('#ble-edit-btn');
+        if (editBtn) {
+            editBtn.addEventListener('click', function() {
+                var mac = this.getAttribute('data-mac') || modalEl.getAttribute('data-device-mac');
+                if (mac) {
+                    var device = findDevice(mac);
+                    SpaxelPanels.closeModal();
+                    if (device) {
+                        showRegisterModal(mac);
+                    }
+                }
+            });
+        }
+
+        // Unregister button
+        var unregisterBtn = modalEl.querySelector('#ble-unregister-btn');
+        if (unregisterBtn) {
+            unregisterBtn.addEventListener('click', function() {
+                var mac = this.getAttribute('data-mac') || modalEl.getAttribute('data-device-mac');
+                if (mac && confirm('Unregister this device? This will remove the person association.')) {
+                    unregisterDevice(mac).then(function() {
+                        SpaxelPanels.showSuccess('Device unregistered');
+                        SpaxelPanels.closeModal();
+                        loadAllDevices();
+                    }).catch(function(err) {
+                        SpaxelPanels.showError('Failed to unregister device: ' + err.message);
+                    });
+                }
+            });
+        }
+    }
+
+    function unregisterDevice(mac) {
+        return fetch('/api/ble/devices/' + encodeURIComponent(mac), {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ person_id: null })
+        })
+        .then(function(res) {
+            if (!res.ok) {
+                return res.json().then(function(err) {
+                    throw new Error(err.error || 'Failed to unregister device');
+                });
+            }
+            return res.json();
+        });
+    }
+
+    // ============================================
+    // Modals
+    // ============================================
+
+    function showRegisterModal(mac) {
+        var device = findDevice(mac);
+        var isNew = !device;
+
+        SpaxelPanels.openModal({
+            title: isNew ? 'Register Device' : 'Edit Device',
+            content: renderEditModal(device),
+            width: '400px',
+            showCancel: true,
+            showConfirm: false,
+            onOpen: function(modalEl) {
+                var saveBtn = modalEl.querySelector('#ble-edit-save');
+                var cancelBtn = modalEl.querySelector('#ble-edit-cancel');
+
+                cancelBtn.addEventListener('click', function() {
+                    SpaxelPanels.closeModal();
+                });
+
+                saveBtn.addEventListener('click', function() {
+                    var label = modalEl.querySelector('#ble-edit-label').value;
+                    var personId = modalEl.querySelector('#ble-edit-person').value;
+                    var newPersonName = modalEl.querySelector('#ble-edit-new-person').value;
+                    var color = modalEl.querySelector('#ble-edit-color').value;
+                    var deviceType = modalEl.querySelector('#ble-edit-type').value;
+
+                    // Create new person if specified
+                    var registrationPromise = Promise.resolve();
+
+                    if (newPersonName && !personId) {
+                        // Need to create a new person first
+                        registrationPromise = createPerson(newPersonName, color).then(function(person) {
+                            return person.id;
+                        });
+                    } else if (newPersonName && personId) {
+                        // User selected a person AND entered a new name - prefer new person
+                        registrationPromise = createPerson(newPersonName, color).then(function(person) {
+                            return person.id;
+                        });
+                    } else {
+                        registrationPromise = Promise.resolve(personId);
+                    }
+
+                    registrationPromise.then(function(finalPersonId) {
+                        var data = {
+                            label: label || newPersonName || deviceName,
+                            device_type: deviceType
+                        };
+
+                        // Set color for the person (not the device)
+                        if (finalPersonId) {
+                            data.person_id = finalPersonId;
+                        }
+
+                        updateDevice(mac, data).then(function() {
+                            SpaxelPanels.showSuccess('Device registered successfully');
+                            SpaxelPanels.closeModal();
+                            // Refresh the panel and reload people
+                            loadAllDevices();
+                        }).catch(function(err) {
+                            SpaxelPanels.showError('Failed to register device: ' + err.message);
+                        });
+                    }).catch(function(err) {
+                        SpaxelPanels.showError('Failed to create person: ' + err.message);
+                    });
+                });
+            }
+        });
+    }
+
+    function createPerson(name, color) {
+        return fetch('/api/people', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: name, color: color })
+        })
+        .then(function(res) {
+            if (!res.ok) {
+                return res.json().then(function(err) {
+                    throw new Error(err.error || 'Failed to create person');
+                });
+            }
+            return res.json();
+        });
+    }
+
+    function showDeviceDetails(device) {
+        var deviceName = device.name || device.label || device.device_name || formatMAC(device.mac);
+
+        // Fetch device history
+        getDeviceHistory(device.mac).then(function(historyData) {
+            SpaxelPanels.openModal({
+                title: deviceName,
+                content: renderDeviceDetails(device, historyData),
+                width: '400px',
+                showCancel: true,
+                showConfirm: false,
+                className: 'ble-details-modal'
+            });
+        }).catch(function(err) {
+            // Show details without history if fetch fails
+            console.error('[BLEPanel] Failed to fetch device history:', err);
+            SpaxelPanels.openModal({
+                title: deviceName,
+                content: renderDeviceDetails(device, null),
+                width: '400px',
+                showCancel: true,
+                showConfirm: false,
+                className: 'ble-details-modal'
+            });
+        });
+    }
+
+    function renderDeviceDetails(device, historyData) {
+        var html = '<div class="ble-device-details">' +
+            '<div class="ble-detail-row">' +
+                '<span class="ble-detail-label">MAC Address</span>' +
+                '<span class="ble-detail-value">' + escapeHtml(device.mac) + '</span>' +
+            '</div>';
+
+        if (device.manufacturer) {
+            html += '<div class="ble-detail-row">' +
+                '<span class="ble-detail-label">Manufacturer</span>' +
+                '<span class="ble-detail-value">' + escapeHtml(device.manufacturer) + '</span>' +
+                '</div>';
+        }
+
+        if (device.device_type && device.device_type !== 'unknown') {
+            html += '<div class="ble-detail-row">' +
+                '<span class="ble-detail-label">Device Type</span>' +
+                '<span class="ble-detail-value">' + getTypeLabel(device.device_type) + '</span>' +
+                '</div>';
+        }
+
+        if (device.person_name) {
+            html += '<div class="ble-detail-row">' +
+                '<span class="ble-detail-label">Assigned To</span>' +
+                '<span class="ble-detail-value">' + escapeHtml(device.person_name) + '</span>' +
+                '</div>';
+        }
+
+        html += '<div class="ble-detail-row">' +
+            '<span class="ble-detail-label">First Seen</span>' +
+            '<span class="ble-detail-value">' + formatTime(device.first_seen_at) + '</span>' +
+        '</div>' +
+            '<div class="ble-detail-row">' +
+            '<span class="ble-detail-label">Last Seen</span>' +
+            '<span class="ble-detail-value">' + formatTime(device.last_seen_at) + '</span>' +
+            '</div>';
+
+        if (device.last_seen_node) {
+            html += '<div class="ble-detail-row">' +
+                '<span class="ble-detail-label">Last Seen By</span>' +
+                '<span class="ble-detail-value">' + escapeHtml(device.last_seen_node) + '</span>' +
+                '</div>';
+        }
+
+        if (device.rssi_count > 0) {
+            html += '<div class="ble-detail-row">' +
+                '<span class="ble-detail-label">Sighting Count</span>' +
+                '<span class="ble-detail-value">' + device.rssi_count + ' times</span>' +
+                '</div>';
+        }
+
+        if (device.rssi_avg !== 0) {
+            html += '<div class="ble-detail-row">' +
+                '<span class="ble-detail-label">Average RSSI</span>' +
+                '<span class="ble-detail-value">' + device.rssi_avg + ' dBm</span>' +
+                '</div>';
+        }
+
+        html += '</div>'; // Close ble-device-details
+
+        // Add recent history if available
+        if (historyData && historyData.history && historyData.history.length > 0) {
+            html += '<div class="ble-section-header">Recent Sightings</div>';
+            html += '<div class="ble-history-list">';
+            historyData.history.slice(0, 10).forEach(function(entry) {
+                html += '<div class="ble-history-entry">' +
+                    '<span class="ble-history-time">' + formatTime(entry.timestamp) + '</span>' +
+                    '<span class="ble-history-rssi">' + entry.rssi_dbm + ' dBm</span>' +
+                    '<span class="ble-history-node">from ' + escapeHtml(entry.node_mac) + '</span>' +
+                    '</div>';
+            });
+            html += '</div>';
+        }
+
+        // Add action buttons
+        html += '<div class="ble-details-actions" data-device-mac="' + escapeHtml(device.mac) + '">' +
+            '<button class="btn-secondary" id="ble-edit-btn" data-mac="' + escapeHtml(device.mac) + '">Edit</button> ';
+
+        if (device.person_id) {
+            html += '<button class="btn-danger" id="ble-unregister-btn" data-mac="' + escapeHtml(device.mac) + '">Unregister</button> ';
+        }
+
+        html += '</div>';
+
+        return html;
+    }
+
+    // Store reference to current device for modal handlers
+    state.currentModalDevice = device;
+}
+
+    // ============================================
+    // Utility Functions
+    // ============================================
+
+    function findDevice(mac) {
+        return state.registeredDevices.concat(state.discoveredDevices).find(function(d) {
+            return d.mac === mac;
+        });
+    }
+
+    function formatMAC(mac) {
+        if (!mac) return '';
+        // Show truncated MAC (last 4 segments) for privacy
+        var parts = mac.split(':');
+        if (parts.length === 6) {
+            return 'XX:XX:' + parts.slice(2).join(':');
+        }
+        return mac;
+    }
+
+    function getTypeLabel(type) {
+        switch (type) {
+            case 'apple_phone': return 'iPhone';
+            case 'apple_watch': return 'Apple Watch';
+            case 'apple_earbuds': return 'AirPods';
+            case 'fitbit': return 'Fitbit';
+            case 'garmin': return 'Garmin';
+            case 'tile': return 'Tile';
+            case 'microsoft': return 'Microsoft';
+            case 'samsung': return 'Samsung';
+            case 'google': return 'Google';
+            case 'ruuvi': return 'Ruuvi';
+            case 'person': return 'Phone';
+            case 'pet': return 'Pet Tracker';
+            case 'object': return 'Object';
+            case 'wearable': return 'Wearable';
+            case 'headphones': return 'Headphones';
+            case 'tracker': return 'Tracker Tag';
+            default: return '';
+        }
+    }
+
+    function getDeviceTypeIcon(type) {
+        if (!type) return '📡';
+
+        // Check if we have a type hint for this device type
+        if (state.typeHints[type]) {
+            return state.typeHints[type].icon;
+        }
+
+        // Fallback icons based on type category
+        switch (type) {
+            case 'apple_phone':
+            case 'person':
+                return '📱';
+            case 'apple_watch':
+            case 'fitbit':
+            case 'garmin':
+            case 'wearable':
+                return '⌚';
+            case 'apple_earbuds':
+            case 'headphones':
+                return '🎧';
+            case 'tile':
+            case 'tracker':
+                return '📍';
+            case 'microsoft':
+                return '💻';
+            case 'ruuvi':
+                return '🌡️';
+            default:
+                return '📡';
+        }
+    }
+
+    function getColorForPerson(personName) {
+        // Check if we have a person with this name in our people list
+        var person = state.people.find(function(p) { return p.name === personName; });
+        if (person && person.color) {
+            return person.color;
+        }
+
+        // Generate consistent color based on person name
+        var hash = 0;
+        for (var i = 0; i < personName.length; i++) {
+            hash = personName.charCodeAt(i) + ((hash << 5) - hash);
+        }
+        var hue = Math.abs(hash) % 360;
+        return 'hsl(' + hue + ', 70%, 60%)';
+    }
+
+    function formatTime(timestamp) {
+        if (!timestamp) return 'Unknown';
+        var date;
+        // Handle both Unix timestamps (in nanoseconds from Go) and JS dates
+        if (typeof timestamp === 'number') {
+            // If it's in nanoseconds (Go time), convert to milliseconds
+            if (timestamp > 10000000000) {
+                date = new Date(timestamp / 1000000);
+            } else {
+                date = new Date(timestamp);
+            }
+        } else {
+            date = new Date(timestamp);
+        }
+
+        var now = new Date();
+        var diff = now - date;
+
+        if (diff < 60000) return 'just now';
+        if (diff < 3600000) return Math.floor(diff / 60000) + 'm ago';
+        if (diff < 86400000) return Math.floor(diff / 3600000) + 'h ago';
+        if (diff < 604800000) return Math.floor(diff / 86400000) + 'd ago';
+        return date.toLocaleDateString();
+    }
+
+    function escapeHtml(text) {
+        if (!text) return '';
+        return String(text)
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;');
+    }
+
+    function updateUnregisteredCount() {
+        var count = state.discoveredDevices.length;
+        var badge = document.getElementById('ble-unregistered-badge');
+        if (badge) {
+            badge.textContent = count > 0 ? count : '';
+            badge.style.display = count > 0 ? 'inline' : 'none';
+        }
+    }
+
+    // ============================================
+    // Public API
+    // ============================================
+
+    window.BLEPanel = {
+        // Open the BLE panel
+        open: openBLEPanel,
+
+        // Refresh device list
+        refresh: loadAllDevices,
+
+        // Update devices (called from WebSocket)
+        updateDevices: function(devices) {
+            state.registeredDevices = devices.filter(function(d) { return d.person_id; });
+            state.discoveredDevices = devices.filter(function(d) { return !d.person_id; });
+            updateUnregisteredCount();
+
+            // If panel is open, refresh content
+            var panelContent = document.querySelector('.ble-panel .panel-content');
+            if (panelContent && panelContent._blePanelRefresh) {
+                panelContent.innerHTML = renderPanelContent();
+                setupEventListeners(panelContent);
+            }
+        }
+    };
+
+    // ============================================
+    // Registration & Initialization
+    // ============================================
+
+    // Register the BLE panel
+    if (window.SpaxelPanels) {
+        SpaxelPanels.register('ble', openBLEPanel);
+    }
+
+    // Also register as a global function for direct access
+    window.openBLEPanel = openBLEPanel;
+
+    // Initial data load
+    loadAllDevices();
+
+    // Update unregistered count badge periodically
+    setInterval(loadAllDevices, 30000); // Every 30 seconds
+
+    console.log('[BLEPanel] BLE device panel module loaded');
+})();
diff --git a/mothership/cmd/mothership/main.go b/mothership/cmd/mothership/main.go
index d4ed931..f93ac15 100644
--- a/mothership/cmd/mothership/main.go
+++ b/mothership/cmd/mothership/main.go
@@ -592,6 +592,28 @@ func main() {
 		log.Printf("[WARN] Failed to create BLE registry: %v (BLE API disabled)", err)
 	} else {
 		defer bleRegistry.Close()
+
+		// Wire BLE registry to dashboard hub for WebSocket broadcasts
+		dashboardHub.SetBLEState(bleRegistry)
+
+		// Wire ingestion server BLE handler to BLE registry
+		ingestSrv.SetBLEHandler(func(nodeMAC string, devices []ingestion.BLEDevice) {
+			// Convert ingestion.BLEDevice to ble.BLEObservation
+			observations := make([]ble.BLEObservation, len(devices))
+			for i, d := range devices {
+				observations[i] = ble.BLEObservation{
+					Addr:       d.Addr,
+					Name:       d.Name,
+					MfrID:      d.MfrID,
+					MfrDataHex: d.MfrDataHex,
+					RSSIdBm:    d.RSSIdBm,
+				}
+			}
+			if err := bleRegistry.ProcessRelayMessage(nodeMAC, observations); err != nil {
+				log.Printf("[WARN] Failed to process BLE relay from %s: %v", nodeMAC, err)
+			}
+		})
+
 		bleHandler := ble.NewHandler(bleRegistry)
 		if authHandler != nil {
 			bleRouter := chi.NewRouter()
diff --git a/mothership/internal/ble/handler.go b/mothership/internal/ble/handler.go
index 811b270..aef0447 100644
--- a/mothership/internal/ble/handler.go
+++ b/mothership/internal/ble/handler.go
@@ -28,6 +28,7 @@ func NewHandler(registry *Registry) *Handler {
 //	GET    /api/ble/devices/{mac}/aliases — get alias history for device
 //	PUT    /api/ble/devices/{mac}        — update device (label, device_type, person_id)
 //	DELETE /api/ble/devices/{mac}        — archive device (soft delete)
+//	POST   /api/ble/devices/preregister  — manually register a device by MAC address
 //	GET    /api/ble/duplicates           — list possible duplicate devices
 //	POST   /api/ble/merge                — merge two devices (MAC rotation)
 //	POST   /api/ble/split                — split alias from canonical device
@@ -40,9 +41,11 @@ func (h *Handler) RegisterRoutes(r chi.Router) {
 	// Device endpoints
 	r.Get("/api/ble/devices", h.listDevices)
 	r.Get("/api/ble/devices/{mac}", h.getDevice)
+	r.Get("/api/ble/devices/{mac}/history", h.getDeviceHistory)
 	r.Get("/api/ble/devices/{mac}/aliases", h.getDeviceAliases)
 	r.Put("/api/ble/devices/{mac}", h.updateDevice)
 	r.Delete("/api/ble/devices/{mac}", h.archiveDevice)
+	r.Post("/api/ble/devices/preregister", h.preregisterDevice)
 
 	// Duplicate detection
 	r.Get("/api/ble/duplicates", h.listDuplicates)
@@ -61,8 +64,47 @@ func (h *Handler) RegisterRoutes(r chi.Router) {
 
 func (h *Handler) listDevices(w http.ResponseWriter, r *http.Request) {
 	includeArchived := r.URL.Query().Get("archived") == "true"
+	registered := r.URL.Query().Get("registered")
+	discovered := r.URL.Query().Get("discovered")
+
+	// Parse hours parameter (default: 24 hours)
+	hoursStr := r.URL.Query().Get("hours")
+	hours := 24 // Default to last 24 hours
+	if hoursStr != "" {
+		if n, err := strconv.Atoi(hoursStr); err == nil && n > 0 {
+			hours = n
+		}
+	}
+
+	var devices []DeviceRecord
+	var err error
+
+	// Filter by registration status and time window
+	if registered == "true" {
+		devices, err = h.registry.GetDevicesSeenInHours(hours, includeArchived)
+		// Filter to only registered devices (has person_id)
+		var registeredDevices []DeviceRecord
+		for _, d := range devices {
+			if d.PersonID != "" {
+				registeredDevices = append(registeredDevices, d)
+			}
+		}
+		devices = registeredDevices
+	} else if discovered == "true" {
+		devices, err = h.registry.GetDevicesSeenInHours(hours, includeArchived)
+		// Filter to only unregistered devices (no person_id)
+		var unregisteredDevices []DeviceRecord
+		for _, d := range devices {
+			if d.PersonID == "" {
+				unregisteredDevices = append(unregisteredDevices, d)
+			}
+		}
+		devices = unregisteredDevices
+	} else {
+		// Get all devices seen in the time window
+		devices, err = h.registry.GetDevicesSeenInHours(hours, includeArchived)
+	}
 
-	devices, err := h.registry.GetDevices(includeArchived)
 	if err != nil {
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
@@ -94,6 +136,35 @@ func (h *Handler) getDevice(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, device)
 }
 
+func (h *Handler) getDeviceHistory(w http.ResponseWriter, r *http.Request) {
+	mac := chi.URLParam(r, "mac")
+
+	// Parse limit parameter
+	limitStr := r.URL.Query().Get("limit")
+	limit := 100
+	if limitStr != "" {
+		if n, err := strconv.Atoi(limitStr); err == nil && n > 0 {
+			limit = n
+		}
+	}
+
+	history, err := h.registry.GetDeviceSightingHistory(mac, limit)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			http.Error(w, "device not found", http.StatusNotFound)
+			return
+		}
+		http.Error(w, "internal error", http.StatusInternalServerError)
+		return
+	}
+
+	writeJSON(w, map[string]interface{}{
+		"mac":     mac,
+		"history": history,
+		"limit":   limit,
+	})
+}
+
 type updateDeviceRequest struct {
 	Label      string `json:"label"`
 	DeviceType string `json:"device_type"`
@@ -368,6 +439,37 @@ func (h *Handler) deletePerson(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusNoContent)
 }
 
+// ── Pre-registration endpoint ───────────────────────────────────────────────────────
+
+type preregisterDeviceRequest struct {
+	MAC   string `json:"mac"`
+	Label string `json:"label"`
+}
+
+// preregisterDevice manually creates a device entry for a known MAC address.
+// This is useful for pre-registering tracker tags that haven't been seen yet.
+func (h *Handler) preregisterDevice(w http.ResponseWriter, r *http.Request) {
+	var req preregisterDeviceRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.MAC == "" {
+		http.Error(w, "invalid request body: mac is required", http.StatusBadRequest)
+		return
+	}
+
+	// Default label to MAC if not provided
+	if req.Label == "" {
+		req.Label = req.MAC
+	}
+
+	device, err := h.registry.PreregisterDevice(req.MAC, req.Label)
+	if err != nil {
+		http.Error(w, "internal error", http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusCreated)
+	writeJSON(w, device)
+}
+
 // ── Alias endpoints ─────────────────────────────────────────────────────────────
 
 // getDeviceAliases returns the alias history for a device.
diff --git a/mothership/internal/ble/registry.go b/mothership/internal/ble/registry.go
index f374723..24e09a8 100644
--- a/mothership/internal/ble/registry.go
+++ b/mothership/internal/ble/registry.go
@@ -299,6 +299,20 @@ func (r *Registry) migrate() error {
 		return fmt.Errorf("create ble_device_aliases table: %w", err)
 	}
 
+	// Create ble_device_sightings table for sighting history timeline
+	if _, err := r.db.Exec(`
+		CREATE TABLE IF NOT EXISTS ble_device_sightings (
+			id         INTEGER PRIMARY KEY AUTOINCREMENT,
+			mac        TEXT    NOT NULL REFERENCES ble_devices(mac) ON DELETE CASCADE,
+			node_mac   TEXT    NOT NULL,
+			rssi_dbm   INTEGER NOT NULL,
+			timestamp  INTEGER NOT NULL,
+			FOREIGN KEY (mac) REFERENCES ble_devices(mac) ON DELETE CASCADE
+		)
+	`); err != nil {
+		return fmt.Errorf("create ble_device_sightings table: %w", err)
+	}
+
 	// Create indexes
 	indexes := []string{
 		`CREATE INDEX IF NOT EXISTS idx_ble_devices_person_id ON ble_devices(person_id)`,
@@ -307,6 +321,8 @@ func (r *Registry) migrate() error {
 		`CREATE INDEX IF NOT EXISTS idx_ble_devices_last_seen ON ble_devices(last_seen_at)`,
 		`CREATE INDEX IF NOT EXISTS idx_ble_device_aliases_canonical ON ble_device_aliases(canonical_addr)`,
 		`CREATE INDEX IF NOT EXISTS idx_ble_device_aliases_last_seen ON ble_device_aliases(last_seen)`,
+		`CREATE INDEX IF NOT EXISTS idx_ble_sightings_mac_timestamp ON ble_device_sightings(mac, timestamp DESC)`,
+		`CREATE INDEX IF NOT EXISTS idx_ble_sightings_timestamp ON ble_device_sightings(timestamp DESC)`,
 	}
 	for _, idx := range indexes {
 		if _, err := r.db.Exec(idx); err != nil {
@@ -375,6 +391,15 @@ func (r *Registry) ProcessRelayMessage(nodeMAC string, devices []BLEObservation)
 
 		if err != nil {
 			log.Printf("[WARN] ble: failed to upsert device %s: %v", dev.Addr, err)
+		} else {
+			// Record this sighting to the sightings table for history
+			_, err2 := r.db.Exec(`
+				INSERT INTO ble_device_sightings (mac, node_mac, rssi_dbm, timestamp)
+				VALUES (?, ?, ?, ?)
+			`, dev.Addr, nodeMAC, dev.RSSIdBm, now)
+			if err2 != nil {
+				log.Printf("[WARN] ble: failed to record sighting for %s: %v", dev.Addr, err2)
+			}
 		}
 	}
 
@@ -540,6 +565,116 @@ func (r *Registry) GetDevice(mac string) (*DeviceRecord, error) {
 	return scanDeviceRow(row)
 }
 
+// GetRegisteredDevices returns devices that have been assigned to a person.
+func (r *Registry) GetRegisteredDevices(includeArchived bool) ([]DeviceRecord, error) {
+	query := `
+		SELECT d.mac, d.name, d.label, d.manufacturer, d.device_type, d.device_name,
+		       d.mfr_id, d.mfr_data_hex, d.person_id, COALESCE(p.name, ''),
+		       d.rssi_min, d.rssi_max, d.rssi_avg,
+		       d.first_seen_at, d.last_seen_at, d.last_seen_node, d.is_archived, d.is_wearable, d.enabled,
+		       d.last_x, d.last_y, d.last_z, d.last_confidence, d.last_loc_time
+		FROM ble_devices d
+		LEFT JOIN people p ON d.person_id = p.id
+		WHERE d.person_id IS NOT NULL AND d.person_id != ''
+	`
+	if !includeArchived {
+		query += " AND d.is_archived = 0"
+	}
+	query += " ORDER BY d.last_seen_at DESC"
+
+	rows, err := r.db.Query(query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var devices []DeviceRecord
+	for rows.Next() {
+		d, err := scanDeviceRow(rows)
+		if err != nil {
+			log.Printf("[WARN] ble: scan device: %v", err)
+			continue
+		}
+		devices = append(devices, *d)
+	}
+	return devices, rows.Err()
+}
+
+// GetDiscoveredDevices returns devices that have NOT been assigned to a person.
+func (r *Registry) GetDiscoveredDevices(includeArchived bool) ([]DeviceRecord, error) {
+	query := `
+		SELECT d.mac, d.name, d.label, d.manufacturer, d.device_type, d.device_name,
+		       d.mfr_id, d.mfr_data_hex, d.person_id, COALESCE(p.name, ''),
+		       d.rssi_min, d.rssi_max, d.rssi_avg,
+		       d.first_seen_at, d.last_seen_at, d.last_seen_node, d.is_archived, d.is_wearable, d.enabled,
+		       d.last_x, d.last_y, d.last_z, d.last_confidence, d.last_loc_time
+		FROM ble_devices d
+		LEFT JOIN people p ON d.person_id = p.id
+		WHERE (d.person_id IS NULL OR d.person_id = '')
+	`
+	if !includeArchived {
+		query += " AND d.is_archived = 0"
+	}
+	query += " ORDER BY d.rssi_count DESC, d.last_seen_at DESC"
+
+	rows, err := r.db.Query(query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var devices []DeviceRecord
+	for rows.Next() {
+		d, err := scanDeviceRow(rows)
+		if err != nil {
+			log.Printf("[WARN] ble: scan device: %v", err)
+			continue
+		}
+		devices = append(devices, *d)
+	}
+	return devices, rows.Err()
+}
+
+// GetDeviceSightingHistory returns the sighting history for a device.
+func (r *Registry) GetDeviceSightingHistory(mac string, limit int) ([]SightingHistoryEntry, error) {
+	if limit <= 0 {
+		limit = 100
+	}
+
+	// Query sightings from the sightings table
+	rows, err := r.db.Query(`
+		SELECT node_mac, rssi_dbm, timestamp
+		FROM ble_device_sightings
+		WHERE mac = ?
+		ORDER BY timestamp DESC
+		LIMIT ?
+	`, mac, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var entries []SightingHistoryEntry
+	for rows.Next() {
+		var entry SightingHistoryEntry
+		var timestampNS int64
+		if err := rows.Scan(&entry.NodeMAC, &entry.RSSIdBm, &timestampNS); err != nil {
+			log.Printf("[WARN] ble: scan sighting: %v", err)
+			continue
+		}
+		entry.Timestamp = time.Unix(0, timestampNS)
+		entries = append(entries, entry)
+	}
+	return entries, rows.Err()
+}
+
+// SightingHistoryEntry represents a single sighting event in the device history.
+type SightingHistoryEntry struct {
+	Timestamp time.Time `json:"timestamp"`
+	RSSIdBm    int       `json:"rssi_dbm"`
+	NodeMAC    string    `json:"node_mac"`
+}
+
 // UpdateLabel updates the user-assigned label for a device.
 func (r *Registry) UpdateLabel(mac, label string) error {
 	_, err := r.db.Exec(`UPDATE ble_devices SET name = ? WHERE mac = ?`, label, mac)
@@ -602,6 +737,65 @@ func (r *Registry) DeleteDevice(mac string) error {
 	return err
 }
 
+// GetDevicesSeenInHours returns devices seen within the last N hours.
+func (r *Registry) GetDevicesSeenInHours(hours int, includeArchived bool) ([]DeviceRecord, error) {
+	cutoff := time.Now().Add(-time.Duration(hours) * time.Hour).UnixNano()
+
+	query := `
+		SELECT d.mac, d.name, d.label, d.manufacturer, d.device_type, d.device_name,
+		       d.mfr_id, d.mfr_data_hex, d.person_id, COALESCE(p.name, ''),
+		       d.rssi_min, d.rssi_max, d.rssi_avg,
+		       d.first_seen_at, d.last_seen_at, d.last_seen_node, d.is_archived, d.is_wearable, d.enabled,
+		       d.last_x, d.last_y, d.last_z, d.last_confidence, d.last_loc_time
+		FROM ble_devices d
+		LEFT JOIN people p ON d.person_id = p.id
+		WHERE d.last_seen_at >= ?
+	`
+	if !includeArchived {
+		query += " AND d.is_archived = 0"
+	}
+	query += " ORDER BY d.last_seen_at DESC"
+
+	rows, err := r.db.Query(query, cutoff)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var devices []DeviceRecord
+	for rows.Next() {
+		d, err := scanDeviceRow(rows)
+		if err != nil {
+			log.Printf("[WARN] ble: scan device: %v", err)
+			continue
+		}
+		devices = append(devices, *d)
+	}
+	return devices, rows.Err()
+}
+
+// PreregisterDevice manually creates a device entry for a known MAC address.
+// This is useful for pre-registering tracker tags that haven't been seen yet.
+func (r *Registry) PreregisterDevice(mac, label string) (*DeviceRecord, error) {
+	now := time.Now().UnixNano()
+
+	// Insert the device with minimal info
+	_, err := r.db.Exec(`
+		INSERT INTO ble_devices (
+			mac, name, label, device_type, first_seen_at, last_seen_at,
+			last_seen_node, rssi_avg, rssi_count, enabled
+		) VALUES (?, ?, ?, 'unknown', ?, ?, '', 0, 0, 1)
+		ON CONFLICT(mac) DO UPDATE SET
+			name = CASE WHEN excluded.name != '' THEN excluded.name ELSE name END,
+			label = CASE WHEN excluded.label != '' THEN excluded.label ELSE label END
+	`, mac, label, label, now, now)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.GetDevice(mac)
+}
+
 // ArchiveStale marks devices not seen for longer than olderThan as archived.
 func (r *Registry) ArchiveStale(olderThan time.Duration) (int64, error) {
 	cutoff := time.Now().Add(-olderThan).UnixNano()
@@ -868,6 +1062,19 @@ func (r *Registry) GetRSSICache() *RSSICache {
 	return r.rssiCache
 }
 
+// GetDeviceRSSICount returns the number of RSSI observations for a device.
+func (r *Registry) GetDeviceRSSICount(mac string) int {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	var count int
+	err := r.db.QueryRow(`SELECT rssi_count FROM ble_devices WHERE mac = ?`, mac).Scan(&count)
+	if err != nil {
+		return 0
+	}
+	return count
+}
+
 // GetAllPersonDevices returns all devices assigned to any person.
 func (r *Registry) GetAllPersonDevices() ([]DeviceRecord, error) {
 	rows, err := r.db.Query(`
@@ -1154,3 +1361,37 @@ func (r *Registry) GetCanonicalDevice(addr string) (*DeviceRecord, error) {
 	canonicalAddr := r.ResolveAlias(addr)
 	return r.GetDevice(canonicalAddr)
 }
+
+// GetCurrentDevices returns all BLE devices as a slice of maps for dashboard broadcast.
+// This implements the BLEState interface for the dashboard hub.
+func (r *Registry) GetCurrentDevices() []map[string]interface{} {
+	devices, err := r.GetDevices(false) // exclude archived
+	if err != nil {
+		return nil
+	}
+
+	result := make([]map[string]interface{}, len(devices))
+	for i, d := range devices {
+		result[i] = map[string]interface{}{
+			"mac":           d.Addr,
+			"name":          d.Name,
+			"label":         d.Label,
+			"manufacturer":  d.Manufacturer,
+			"device_type":   d.DeviceType,
+			"device_name":   d.DeviceName,
+			"mfr_id":        d.MfrID,
+			"person_id":     d.PersonID,
+			"person_name":   d.PersonName,
+			"rssi_min":      d.RSSIMin,
+			"rssi_max":      d.RSSIMax,
+			"rssi_avg":      d.RSSIAvg,
+			"rssi_count":    d.RSSICount(d.Addr),
+			"first_seen_at": d.FirstSeenAt.UnixMilli(),
+			"last_seen_at":  d.LastSeenAt.UnixMilli(),
+			"last_seen_node": d.LastSeenNode,
+			"is_wearable":   d.IsWearable,
+			"enabled":       d.Enabled,
+		}
+	}
+	return result
+}