@blueharford/scrypted-spatial-awareness 0.2.1 → 0.3.0

package/out/main.nodejs.js

@@ -35645,6 +35645,18 @@ class TrackingEngine {
     objectLastAlertTime = new Map();
     /** Callback for topology changes (e.g., landmark suggestions) */
     onTopologyChange;
+    // ==================== LLM Debouncing ====================
+    /** Last time LLM was called */
+    lastLlmCallTime = 0;
+    /** Queue of pending LLM requests (we only keep latest) */
+    llmDebounceTimer = null;
+    // ==================== Transit Time Learning ====================
+    /** Observed transit times for learning */
+    observedTransits = new Map();
+    /** Connection suggestions based on observed patterns */
+    connectionSuggestions = new Map();
+    /** Minimum observations before suggesting a connection */
+    MIN_OBSERVATIONS_FOR_SUGGESTION = 3;
     constructor(topology, state, alertManager, config, console) {
         this.topology = topology;
         this.state = state;
@@ -35776,9 +35788,28 @@ class TrackingEngine {
     recordAlertTime(globalId) {
         this.objectLastAlertTime.set(globalId, Date.now());
     }
-    /** Get spatial reasoning result for movement (uses RAG + LLM) */
+    /** Check if LLM call is allowed (rate limiting) */
+    isLlmCallAllowed() {
+        const debounceInterval = this.config.llmDebounceInterval || 0;
+        if (debounceInterval <= 0)
+            return true;
+        const timeSinceLastCall = Date.now() - this.lastLlmCallTime;
+        return timeSinceLastCall >= debounceInterval;
+    }
+    /** Record that an LLM call was made */
+    recordLlmCall() {
+        this.lastLlmCallTime = Date.now();
+    }
+    /** Get spatial reasoning result for movement (uses RAG + LLM) with debouncing and fallback */
     async getSpatialDescription(tracked, fromCameraId, toCameraId, transitTime, currentCameraId) {
+        const fallbackEnabled = this.config.llmFallbackEnabled ?? true;
+        const fallbackTimeout = this.config.llmFallbackTimeout ?? 3000;
         try {
+            // Check rate limiting - if not allowed, return null to use basic description
+            if (!this.isLlmCallAllowed()) {
+                this.console.log('LLM rate-limited, using basic notification');
+                return null;
+            }
             // Get snapshot from camera for LLM analysis (if LLM is enabled)
             let mediaObject;
             if (this.config.useLlmDescriptions) {
@@ -35787,9 +35818,28 @@ class TrackingEngine {
                     mediaObject = await camera.takePicture();
                 }
             }
+            // Record that we're making an LLM call
+            this.recordLlmCall();
             // Use spatial reasoning engine for rich context-aware description
-            const result = await this.spatialReasoning.generateMovementDescription(tracked, fromCameraId, toCameraId, transitTime, mediaObject);
-            // Optionally trigger landmark learning
+            // Apply timeout if fallback is enabled
+            let result;
+            if (fallbackEnabled && mediaObject) {
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error('LLM timeout')), fallbackTimeout);
+                });
+                const descriptionPromise = this.spatialReasoning.generateMovementDescription(tracked, fromCameraId, toCameraId, transitTime, mediaObject);
+                try {
+                    result = await Promise.race([descriptionPromise, timeoutPromise]);
+                }
+                catch (timeoutError) {
+                    this.console.log('LLM timed out, using basic notification');
+                    return null;
+                }
+            }
+            else {
+                result = await this.spatialReasoning.generateMovementDescription(tracked, fromCameraId, toCameraId, transitTime, mediaObject);
+            }
+            // Optionally trigger landmark learning (background, non-blocking)
             if (this.config.enableLandmarkLearning && mediaObject) {
                 this.tryLearnLandmark(currentCameraId, mediaObject, tracked.className);
             }
@@ -35837,6 +35887,8 @@ class TrackingEngine {
                     transitDuration,
                     correlationConfidence: correlation.confidence,
                 });
+                // Record for transit time learning
+                this.recordObservedTransit(lastSighting.cameraId, sighting.cameraId, transitDuration);
                 this.console.log(`Object ${tracked.globalId.slice(0, 8)} transited: ` +
                     `${lastSighting.cameraName} → ${sighting.cameraName} ` +
                     `(confidence: ${(correlation.confidence * 100).toFixed(0)}%)`);
@@ -36025,6 +36077,211 @@ class TrackingEngine {
     getTrackedObject(globalId) {
         return this.state.getObject(globalId);
     }
+    // ==================== Transit Time Learning ====================
+    /** Record an observed transit time for learning */
+    recordObservedTransit(fromCameraId, toCameraId, transitTime) {
+        if (!this.config.enableTransitTimeLearning)
+            return;
+        const key = `${fromCameraId}->${toCameraId}`;
+        const observation = {
+            fromCameraId,
+            toCameraId,
+            transitTime,
+            timestamp: Date.now(),
+        };
+        // Add to observations
+        if (!this.observedTransits.has(key)) {
+            this.observedTransits.set(key, []);
+        }
+        const observations = this.observedTransits.get(key);
+        observations.push(observation);
+        // Keep only last 100 observations per connection
+        if (observations.length > 100) {
+            observations.shift();
+        }
+        // Check if we should update existing connection
+        const existingConnection = (0, topology_1.findConnection)(this.topology, fromCameraId, toCameraId);
+        if (existingConnection) {
+            this.maybeUpdateConnectionTransitTime(existingConnection, observations);
+        }
+        else if (this.config.enableConnectionSuggestions) {
+            // No existing connection - suggest one
+            this.maybeCreateConnectionSuggestion(fromCameraId, toCameraId, observations);
+        }
+    }
+    /** Update an existing connection's transit time based on observations */
+    maybeUpdateConnectionTransitTime(connection, observations) {
+        if (observations.length < 5)
+            return; // Need minimum observations
+        const times = observations.map(o => o.transitTime).sort((a, b) => a - b);
+        // Calculate percentiles
+        const newMin = times[Math.floor(times.length * 0.1)];
+        const newTypical = times[Math.floor(times.length * 0.5)];
+        const newMax = times[Math.floor(times.length * 0.9)];
+        // Only update if significantly different (>20% change)
+        const currentTypical = connection.transitTime.typical;
+        const percentChange = Math.abs(newTypical - currentTypical) / currentTypical;
+        if (percentChange > 0.2 && observations.length >= 10) {
+            this.console.log(`Updating transit time for ${connection.name}: ` +
+                `${Math.round(currentTypical / 1000)}s → ${Math.round(newTypical / 1000)}s (based on ${observations.length} observations)`);
+            connection.transitTime = {
+                min: newMin,
+                typical: newTypical,
+                max: newMax,
+            };
+            // Notify about topology change
+            if (this.onTopologyChange) {
+                this.onTopologyChange(this.topology);
+            }
+        }
+    }
+    /** Create or update a connection suggestion based on observations */
+    maybeCreateConnectionSuggestion(fromCameraId, toCameraId, observations) {
+        if (observations.length < this.MIN_OBSERVATIONS_FOR_SUGGESTION)
+            return;
+        const fromCamera = (0, topology_1.findCamera)(this.topology, fromCameraId);
+        const toCamera = (0, topology_1.findCamera)(this.topology, toCameraId);
+        if (!fromCamera || !toCamera)
+            return;
+        const key = `${fromCameraId}->${toCameraId}`;
+        const times = observations.map(o => o.transitTime).sort((a, b) => a - b);
+        // Calculate transit time suggestion
+        const suggestedMin = times[Math.floor(times.length * 0.1)] || times[0];
+        const suggestedTypical = times[Math.floor(times.length * 0.5)] || times[0];
+        const suggestedMax = times[Math.floor(times.length * 0.9)] || times[times.length - 1];
+        // Calculate confidence based on consistency and count
+        const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
+        const variance = times.reduce((sum, t) => sum + Math.pow(t - avgTime, 2), 0) / times.length;
+        const stdDev = Math.sqrt(variance);
+        const coefficientOfVariation = stdDev / avgTime;
+        // Higher confidence with more observations and lower variance
+        const countFactor = Math.min(observations.length / 10, 1);
+        const consistencyFactor = Math.max(0, 1 - coefficientOfVariation);
+        const confidence = (countFactor * 0.6 + consistencyFactor * 0.4);
+        const suggestion = {
+            id: `suggest_${key}`,
+            fromCameraId,
+            fromCameraName: fromCamera.name,
+            toCameraId,
+            toCameraName: toCamera.name,
+            observedTransits: observations.slice(-10), // Keep last 10
+            suggestedTransitTime: {
+                min: suggestedMin,
+                typical: suggestedTypical,
+                max: suggestedMax,
+            },
+            confidence,
+            timestamp: Date.now(),
+        };
+        this.connectionSuggestions.set(key, suggestion);
+        if (observations.length === this.MIN_OBSERVATIONS_FOR_SUGGESTION) {
+            this.console.log(`New connection suggested: ${fromCamera.name} → ${toCamera.name} ` +
+                `(typical: ${Math.round(suggestedTypical / 1000)}s, confidence: ${Math.round(confidence * 100)}%)`);
+        }
+    }
+    /** Get pending connection suggestions */
+    getConnectionSuggestions() {
+        return Array.from(this.connectionSuggestions.values())
+            .filter(s => s.confidence >= 0.5) // Only suggest with reasonable confidence
+            .sort((a, b) => b.confidence - a.confidence);
+    }
+    /** Accept a connection suggestion, adding it to topology */
+    acceptConnectionSuggestion(suggestionId) {
+        const key = suggestionId.replace('suggest_', '');
+        const suggestion = this.connectionSuggestions.get(key);
+        if (!suggestion)
+            return null;
+        const fromCamera = (0, topology_1.findCamera)(this.topology, suggestion.fromCameraId);
+        const toCamera = (0, topology_1.findCamera)(this.topology, suggestion.toCameraId);
+        if (!fromCamera || !toCamera)
+            return null;
+        const connection = {
+            id: `conn-${Date.now()}`,
+            fromCameraId: suggestion.fromCameraId,
+            toCameraId: suggestion.toCameraId,
+            name: `${fromCamera.name} to ${toCamera.name}`,
+            exitZone: [],
+            entryZone: [],
+            transitTime: suggestion.suggestedTransitTime,
+            bidirectional: true, // Default to bidirectional
+        };
+        this.topology.connections.push(connection);
+        this.connectionSuggestions.delete(key);
+        // Notify about topology change
+        if (this.onTopologyChange) {
+            this.onTopologyChange(this.topology);
+        }
+        this.console.log(`Connection accepted: ${connection.name}`);
+        return connection;
+    }
+    /** Reject a connection suggestion */
+    rejectConnectionSuggestion(suggestionId) {
+        const key = suggestionId.replace('suggest_', '');
+        if (!this.connectionSuggestions.has(key))
+            return false;
+        this.connectionSuggestions.delete(key);
+        // Also clear observations so it doesn't get re-suggested immediately
+        this.observedTransits.delete(key);
+        return true;
+    }
+    // ==================== Live Tracking State ====================
+    /** Get current state of all tracked objects for live overlay */
+    getLiveTrackingState() {
+        const activeObjects = this.state.getActiveObjects();
+        const objects = activeObjects.map(tracked => {
+            const lastSighting = (0, tracked_object_1.getLastSighting)(tracked);
+            const camera = lastSighting ? (0, topology_1.findCamera)(this.topology, lastSighting.cameraId) : null;
+            return {
+                globalId: tracked.globalId,
+                className: tracked.className,
+                label: tracked.label,
+                lastCameraId: lastSighting?.cameraId || '',
+                lastCameraName: lastSighting?.cameraName || '',
+                lastSeen: tracked.lastSeen,
+                state: tracked.state,
+                cameraPosition: camera?.floorPlanPosition,
+            };
+        });
+        return {
+            objects,
+            timestamp: Date.now(),
+        };
+    }
+    /** Get journey path for visualization */
+    getJourneyPath(globalId) {
+        const tracked = this.state.getObject(globalId);
+        if (!tracked)
+            return null;
+        const segments = tracked.journey.map(j => {
+            const fromCamera = (0, topology_1.findCamera)(this.topology, j.fromCameraId);
+            const toCamera = (0, topology_1.findCamera)(this.topology, j.toCameraId);
+            return {
+                fromCamera: {
+                    id: j.fromCameraId,
+                    name: j.fromCameraName,
+                    position: fromCamera?.floorPlanPosition,
+                },
+                toCamera: {
+                    id: j.toCameraId,
+                    name: j.toCameraName,
+                    position: toCamera?.floorPlanPosition,
+                },
+                transitTime: j.transitDuration,
+                timestamp: j.entryTime,
+            };
+        });
+        const lastSighting = (0, tracked_object_1.getLastSighting)(tracked);
+        let currentLocation;
+        if (lastSighting) {
+            const camera = (0, topology_1.findCamera)(this.topology, lastSighting.cameraId);
+            currentLocation = {
+                cameraId: lastSighting.cameraId,
+                cameraName: lastSighting.cameraName,
+                position: camera?.floorPlanPosition,
+            };
+        }
+        return { segments, currentLocation };
+    }
 }
 exports.TrackingEngine = TrackingEngine;
 
@@ -36806,6 +37063,41 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             description: 'Use LLM plugin (if installed) to generate descriptive alerts like "Man walking from garage towards front door"',
             group: 'AI & Spatial Reasoning',
         },
+        llmDebounceInterval: {
+            title: 'LLM Rate Limit (seconds)',
+            type: 'number',
+            defaultValue: 10,
+            description: 'Minimum time between LLM calls to prevent API overload (0 = no limit)',
+            group: 'AI & Spatial Reasoning',
+        },
+        llmFallbackEnabled: {
+            title: 'Fallback to Basic Notifications',
+            type: 'boolean',
+            defaultValue: true,
+            description: 'When LLM is rate-limited or slow, fall back to basic notifications immediately',
+            group: 'AI & Spatial Reasoning',
+        },
+        llmFallbackTimeout: {
+            title: 'LLM Timeout (seconds)',
+            type: 'number',
+            defaultValue: 3,
+            description: 'Maximum time to wait for LLM response before falling back to basic notification',
+            group: 'AI & Spatial Reasoning',
+        },
+        enableTransitTimeLearning: {
+            title: 'Learn Transit Times',
+            type: 'boolean',
+            defaultValue: true,
+            description: 'Automatically adjust connection transit times based on observed movement patterns',
+            group: 'AI & Spatial Reasoning',
+        },
+        enableConnectionSuggestions: {
+            title: 'Suggest Camera Connections',
+            type: 'boolean',
+            defaultValue: true,
+            description: 'Automatically suggest new camera connections based on observed movement patterns',
+            group: 'AI & Spatial Reasoning',
+        },
         enableLandmarkLearning: {
             title: 'Learn Landmarks from AI',
             type: 'boolean',
@@ -36965,6 +37257,11 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             loiteringThreshold: (this.storageSettings.values.loiteringThreshold || 3) * 1000,
             objectAlertCooldown: (this.storageSettings.values.objectAlertCooldown || 30) * 1000,
             useLlmDescriptions: this.storageSettings.values.useLlmDescriptions ?? true,
+            llmDebounceInterval: (this.storageSettings.values.llmDebounceInterval || 10) * 1000,
+            llmFallbackEnabled: this.storageSettings.values.llmFallbackEnabled ?? true,
+            llmFallbackTimeout: (this.storageSettings.values.llmFallbackTimeout || 3) * 1000,
+            enableTransitTimeLearning: this.storageSettings.values.enableTransitTimeLearning ?? true,
+            enableConnectionSuggestions: this.storageSettings.values.enableConnectionSuggestions ?? true,
             enableLandmarkLearning: this.storageSettings.values.enableLandmarkLearning ?? true,
             landmarkConfidenceThreshold: this.storageSettings.values.landmarkConfidenceThreshold ?? 0.7,
         };
@@ -37214,6 +37511,11 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             key === 'loiteringThreshold' ||
             key === 'objectAlertCooldown' ||
             key === 'useLlmDescriptions' ||
+            key === 'llmDebounceInterval' ||
+            key === 'llmFallbackEnabled' ||
+            key === 'llmFallbackTimeout' ||
+            key === 'enableTransitTimeLearning' ||
+            key === 'enableConnectionSuggestions' ||
             key === 'enableLandmarkLearning' ||
             key === 'landmarkConfidenceThreshold') {
             const topologyJson = this.storage.getItem('topology');
@@ -37289,6 +37591,25 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             if (path.endsWith('/api/infer-relationships')) {
                 return this.handleInferRelationshipsRequest(response);
             }
+            // Connection suggestions
+            if (path.endsWith('/api/connection-suggestions')) {
+                return this.handleConnectionSuggestionsRequest(request, response);
+            }
+            if (path.match(/\/api\/connection-suggestions\/[\w->]+\/(accept|reject)$/)) {
+                const parts = path.split('/');
+                const action = parts.pop();
+                const suggestionId = parts.pop();
+                return this.handleConnectionSuggestionActionRequest(suggestionId, action, response);
+            }
+            // Live tracking state
+            if (path.endsWith('/api/live-tracking')) {
+                return this.handleLiveTrackingRequest(response);
+            }
+            // Journey visualization
+            if (path.match(/\/api\/journey-path\/[\w-]+$/)) {
+                const globalId = path.split('/').pop();
+                return this.handleJourneyPathRequest(globalId, response);
+            }
             // UI Routes
             if (path.endsWith('/ui/editor') || path.endsWith('/ui/editor/')) {
                 return this.serveEditorUI(response);
@@ -37299,14 +37620,18 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             // Default: return info page
             response.send(JSON.stringify({
                 name: 'Spatial Awareness Plugin',
-                version: '0.1.0',
+                version: '0.3.0',
                 endpoints: {
                     api: {
                         trackedObjects: '/api/tracked-objects',
                         journey: '/api/journey/{globalId}',
+                        journeyPath: '/api/journey-path/{globalId}',
                         topology: '/api/topology',
                         alerts: '/api/alerts',
                         floorPlan: '/api/floor-plan',
+                        liveTracking: '/api/live-tracking',
+                        connectionSuggestions: '/api/connection-suggestions',
+                        landmarkSuggestions: '/api/landmark-suggestions',
                     },
                     ui: {
                         editor: '/ui/editor',
@@ -37666,6 +37991,100 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             headers: { 'Content-Type': 'application/json' },
         });
     }
+    handleConnectionSuggestionsRequest(request, response) {
+        if (!this.trackingEngine) {
+            response.send(JSON.stringify({ suggestions: [] }), {
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        const suggestions = this.trackingEngine.getConnectionSuggestions();
+        response.send(JSON.stringify({
+            suggestions,
+            count: suggestions.length,
+        }), {
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    handleConnectionSuggestionActionRequest(suggestionId, action, response) {
+        if (!this.trackingEngine) {
+            response.send(JSON.stringify({ error: 'Tracking engine not running' }), {
+                code: 500,
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        if (action === 'accept') {
+            const connection = this.trackingEngine.acceptConnectionSuggestion(suggestionId);
+            if (connection) {
+                // Save updated topology
+                const topology = this.trackingEngine.getTopology();
+                this.storage.setItem('topology', JSON.stringify(topology));
+                response.send(JSON.stringify({ success: true, connection }), {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            else {
+                response.send(JSON.stringify({ error: 'Suggestion not found' }), {
+                    code: 404,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        }
+        else if (action === 'reject') {
+            const success = this.trackingEngine.rejectConnectionSuggestion(suggestionId);
+            if (success) {
+                response.send(JSON.stringify({ success: true }), {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            else {
+                response.send(JSON.stringify({ error: 'Suggestion not found' }), {
+                    code: 404,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        }
+        else {
+            response.send(JSON.stringify({ error: 'Invalid action' }), {
+                code: 400,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+    }
+    handleLiveTrackingRequest(response) {
+        if (!this.trackingEngine) {
+            response.send(JSON.stringify({ objects: [], timestamp: Date.now() }), {
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        const liveState = this.trackingEngine.getLiveTrackingState();
+        response.send(JSON.stringify(liveState), {
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    handleJourneyPathRequest(globalId, response) {
+        if (!this.trackingEngine) {
+            response.send(JSON.stringify({ error: 'Tracking engine not running' }), {
+                code: 500,
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        const journeyPath = this.trackingEngine.getJourneyPath(globalId);
+        if (journeyPath) {
+            response.send(JSON.stringify(journeyPath), {
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        else {
+            response.send(JSON.stringify({ error: 'Object not found' }), {
+                code: 404,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+    }
     serveEditorUI(response) {
         response.send(editor_html_1.EDITOR_HTML, {
             headers: { 'Content-Type': 'text/html' },
@@ -38615,6 +39034,23 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
           </div>
           <div id="suggestions-list"></div>
         </div>
+        <div class="section" id="connection-suggestions-section" style="display: none;">
+          <div class="section-title">
+            <span>Connection Suggestions</span>
+            <button class="btn btn-small" onclick="loadConnectionSuggestions()">Refresh</button>
+          </div>
+          <div id="connection-suggestions-list"></div>
+        </div>
+        <div class="section" id="live-tracking-section">
+          <div class="section-title">
+            <span>Live Tracking</span>
+            <label class="checkbox-group" style="font-size: 11px; font-weight: normal; text-transform: none;">
+              <input type="checkbox" id="live-tracking-toggle" onchange="toggleLiveTracking(this.checked)">
+              Enable
+            </label>
+          </div>
+          <div id="live-tracking-list" style="max-height: 150px; overflow-y: auto;"></div>
+        </div>
       </div>
     </div>
     <div class="editor">
@@ -38805,6 +39241,12 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
     let availableCameras = [];
     let landmarkTemplates = [];
     let pendingSuggestions = [];
+    let connectionSuggestions = [];
+    let liveTrackingData = { objects: [], timestamp: 0 };
+    let liveTrackingEnabled = false;
+    let liveTrackingInterval = null;
+    let selectedJourneyId = null;
+    let journeyPath = null;
     let isDrawing = false;
     let drawStart = null;
     let currentDrawing = null;
@@ -38817,6 +39259,7 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       await loadAvailableCameras();
       await loadLandmarkTemplates();
       await loadSuggestions();
+      await loadConnectionSuggestions();
       resizeCanvas();
       render();
       updateUI();
@@ -38916,6 +39359,132 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       } catch (e) { console.error('Failed to reject suggestion:', e); }
     }
 
+    // ==================== Connection Suggestions ====================
+    async function loadConnectionSuggestions() {
+      try {
+        const response = await fetch('../api/connection-suggestions');
+        if (response.ok) {
+          const data = await response.json();
+          connectionSuggestions = data.suggestions || [];
+          updateConnectionSuggestionsUI();
+        }
+      } catch (e) { console.error('Failed to load connection suggestions:', e); }
+    }
+
+    function updateConnectionSuggestionsUI() {
+      const section = document.getElementById('connection-suggestions-section');
+      const list = document.getElementById('connection-suggestions-list');
+      if (connectionSuggestions.length === 0) {
+        section.style.display = 'none';
+        return;
+      }
+      section.style.display = 'block';
+      list.innerHTML = connectionSuggestions.map(s =>
+        '<div class="camera-item" style="display: flex; justify-content: space-between; align-items: center;">' +
+        '<div><div class="camera-name">' + s.fromCameraName + ' → ' + s.toCameraName + '</div>' +
+        '<div class="camera-info">' + Math.round(s.suggestedTransitTime.typical / 1000) + 's typical, ' +
+        Math.round(s.confidence * 100) + '% confidence</div></div>' +
+        '<div style="display: flex; gap: 5px;">' +
+        '<button class="btn btn-small btn-primary" onclick="acceptConnectionSuggestion(\\'' + s.id + '\\')">Accept</button>' +
+        '<button class="btn btn-small" onclick="rejectConnectionSuggestion(\\'' + s.id + '\\')">Reject</button>' +
+        '</div></div>'
+      ).join('');
+    }
+
+    async function acceptConnectionSuggestion(id) {
+      try {
+        const response = await fetch('../api/connection-suggestions/' + encodeURIComponent(id) + '/accept', { method: 'POST' });
+        if (response.ok) {
+          const data = await response.json();
+          if (data.connection) {
+            topology.connections.push(data.connection);
+            updateUI();
+            render();
+          }
+          await loadConnectionSuggestions();
+          setStatus('Connection accepted', 'success');
+        }
+      } catch (e) { console.error('Failed to accept connection suggestion:', e); }
+    }
+
+    async function rejectConnectionSuggestion(id) {
+      try {
+        await fetch('../api/connection-suggestions/' + encodeURIComponent(id) + '/reject', { method: 'POST' });
+        await loadConnectionSuggestions();
+        setStatus('Connection suggestion rejected', 'success');
+      } catch (e) { console.error('Failed to reject connection suggestion:', e); }
+    }
+
+    // ==================== Live Tracking ====================
+    function toggleLiveTracking(enabled) {
+      liveTrackingEnabled = enabled;
+      if (enabled) {
+        loadLiveTracking();
+        liveTrackingInterval = setInterval(loadLiveTracking, 2000); // Poll every 2 seconds
+      } else {
+        if (liveTrackingInterval) {
+          clearInterval(liveTrackingInterval);
+          liveTrackingInterval = null;
+        }
+        liveTrackingData = { objects: [], timestamp: 0 };
+        selectedJourneyId = null;
+        journeyPath = null;
+        updateLiveTrackingUI();
+        render();
+      }
+    }
+
+    async function loadLiveTracking() {
+      try {
+        const response = await fetch('../api/live-tracking');
+        if (response.ok) {
+          liveTrackingData = await response.json();
+          updateLiveTrackingUI();
+          render();
+        }
+      } catch (e) { console.error('Failed to load live tracking:', e); }
+    }
+
+    function updateLiveTrackingUI() {
+      const list = document.getElementById('live-tracking-list');
+      if (liveTrackingData.objects.length === 0) {
+        list.innerHTML = '<div style="color: #666; font-size: 12px; text-align: center; padding: 10px;">No active objects</div>';
+        return;
+      }
+      list.innerHTML = liveTrackingData.objects.map(obj => {
+        const isSelected = selectedJourneyId === obj.globalId;
+        const ageSeconds = Math.round((Date.now() - obj.lastSeen) / 1000);
+        const ageStr = ageSeconds < 60 ? ageSeconds + 's ago' : Math.round(ageSeconds / 60) + 'm ago';
+        return '<div class="camera-item' + (isSelected ? ' selected' : '') + '" ' +
+          'onclick="selectTrackedObject(\\'' + obj.globalId + '\\')" ' +
+          'style="padding: 8px; cursor: pointer;">' +
+          '<div class="camera-name" style="font-size: 12px;">' +
+          (obj.className.charAt(0).toUpperCase() + obj.className.slice(1)) +
+          (obj.label ? ' (' + obj.label + ')' : '') + '</div>' +
+          '<div class="camera-info">' + obj.lastCameraName + ' • ' + ageStr + '</div>' +
+          '</div>';
+      }).join('');
+    }
+
+    async function selectTrackedObject(globalId) {
+      if (selectedJourneyId === globalId) {
+        // Deselect
+        selectedJourneyId = null;
+        journeyPath = null;
+      } else {
+        selectedJourneyId = globalId;
+        // Load journey path
+        try {
+          const response = await fetch('../api/journey-path/' + globalId);
+          if (response.ok) {
+            journeyPath = await response.json();
+          }
+        } catch (e) { console.error('Failed to load journey path:', e); }
+      }
+      updateLiveTrackingUI();
+      render();
+    }
+
     function openAddLandmarkModal() {
       updateLandmarkSuggestions();
       document.getElementById('add-landmark-modal').classList.add('active');
@@ -39139,6 +39708,112 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       for (const camera of topology.cameras) {
         if (camera.floorPlanPosition) { drawCamera(camera); }
       }
+
+      // Draw journey path if selected
+      if (journeyPath && journeyPath.segments.length > 0) {
+        drawJourneyPath();
+      }
+
+      // Draw live tracking objects
+      if (liveTrackingEnabled && liveTrackingData.objects.length > 0) {
+        drawLiveTrackingObjects();
+      }
+    }
+
+    function drawJourneyPath() {
+      if (!journeyPath) return;
+
+      ctx.strokeStyle = '#ff6b6b';
+      ctx.lineWidth = 3;
+      ctx.setLineDash([8, 4]);
+
+      // Draw path segments
+      for (const segment of journeyPath.segments) {
+        if (segment.fromCamera.position && segment.toCamera.position) {
+          ctx.beginPath();
+          ctx.moveTo(segment.fromCamera.position.x, segment.fromCamera.position.y);
+          ctx.lineTo(segment.toCamera.position.x, segment.toCamera.position.y);
+          ctx.stroke();
+
+          // Draw timestamp indicator
+          const midX = (segment.fromCamera.position.x + segment.toCamera.position.x) / 2;
+          const midY = (segment.fromCamera.position.y + segment.toCamera.position.y) / 2;
+          ctx.fillStyle = 'rgba(255, 107, 107, 0.9)';
+          ctx.beginPath();
+          ctx.arc(midX, midY, 4, 0, Math.PI * 2);
+          ctx.fill();
+        }
+      }
+
+      ctx.setLineDash([]);
+
+      // Draw current location indicator
+      if (journeyPath.currentLocation?.position) {
+        const pos = journeyPath.currentLocation.position;
+        // Pulsing dot effect
+        const pulse = (Date.now() % 1000) / 1000;
+        const radius = 10 + pulse * 5;
+        const alpha = 1 - pulse * 0.5;
+
+        ctx.beginPath();
+        ctx.arc(pos.x, pos.y, radius, 0, Math.PI * 2);
+        ctx.fillStyle = 'rgba(255, 107, 107, ' + alpha + ')';
+        ctx.fill();
+
+        ctx.beginPath();
+        ctx.arc(pos.x, pos.y, 6, 0, Math.PI * 2);
+        ctx.fillStyle = '#ff6b6b';
+        ctx.fill();
+        ctx.strokeStyle = '#fff';
+        ctx.lineWidth = 2;
+        ctx.stroke();
+      }
+    }
+
+    function drawLiveTrackingObjects() {
+      const objectColors = {
+        person: '#4caf50',
+        car: '#2196f3',
+        animal: '#ff9800',
+        default: '#9c27b0'
+      };
+
+      for (const obj of liveTrackingData.objects) {
+        if (!obj.cameraPosition) continue;
+
+        // Skip if this is the selected journey object (drawn separately with path)
+        if (obj.globalId === selectedJourneyId) continue;
+
+        const pos = obj.cameraPosition;
+        const color = objectColors[obj.className] || objectColors.default;
+        const ageSeconds = (Date.now() - obj.lastSeen) / 1000;
+
+        // Fade old objects
+        const alpha = Math.max(0.3, 1 - ageSeconds / 60);
+
+        // Draw object indicator
+        ctx.beginPath();
+        ctx.arc(pos.x, pos.y, 12, 0, Math.PI * 2);
+        ctx.fillStyle = color.replace(')', ', ' + alpha + ')').replace('rgb', 'rgba');
+        ctx.fill();
+        ctx.strokeStyle = 'rgba(255, 255, 255, ' + alpha + ')';
+        ctx.lineWidth = 2;
+        ctx.stroke();
+
+        // Draw class icon
+        ctx.fillStyle = 'rgba(255, 255, 255, ' + alpha + ')';
+        ctx.font = 'bold 10px sans-serif';
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'middle';
+        const icon = obj.className === 'person' ? 'P' : obj.className === 'car' ? 'C' : obj.className === 'animal' ? 'A' : '?';
+        ctx.fillText(icon, pos.x, pos.y);
+
+        // Draw label below
+        if (obj.label) {
+          ctx.font = '9px sans-serif';
+          ctx.fillText(obj.label.slice(0, 10), pos.x, pos.y + 20);
+        }
+      }
     }
 
     function drawLandmark(landmark) {