@blueharford/scrypted-spatial-awareness 0.6.32 → 0.6.34

package/out/main.nodejs.js

@@ -34385,13 +34385,23 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AlertManager = void 0;
-const sdk_1 = __importStar(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
 const alert_1 = __webpack_require__(/*! ../models/alert */ "./src/models/alert.ts");
-const { systemManager, mediaManager } = sdk_1.default;
+const alert_utils_1 = __webpack_require__(/*! ./alert-utils */ "./src/alerts/alert-utils.ts");
+let sdkModule = null;
+const getSdk = async () => {
+    if (!sdkModule) {
+        sdkModule = await Promise.resolve().then(() => __importStar(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js")));
+    }
+    return sdkModule;
+};
 class AlertManager {
     rules = [];
     recentAlerts = [];
     cooldowns = new Map();
+    activeAlerts = new Map();
+    activeAlertTtlMs = 10 * 60 * 1000;
+    notifyOnUpdates = false;
+    updateNotificationCooldownMs = 60000;
     console;
     storage;
     maxAlerts = 100;
@@ -34403,7 +34413,7 @@ class AlertManager {
     /**
      * Check if an alert should be generated and send it
      */
-    async checkAndAlert(type, tracked, details) {
+    async checkAndAlert(type, tracked, details, mediaObjectOverride) {
         // Find matching rule
         const rule = this.rules.find(r => r.type === type && r.enabled);
         if (!rule)
@@ -34420,16 +34430,22 @@ class AlertManager {
                 return null;
             }
         }
-        // Check cooldown
+        // Check conditions
+        if (!this.evaluateConditions(rule.conditions, tracked)) {
+            return null;
+        }
+        // Update existing movement alert if active (prevents alert spam)
+        if (type === 'movement') {
+            const updated = await this.updateActiveAlert(type, rule.id, tracked, details);
+            if (updated)
+                return updated;
+        }
+        // Check cooldown (only for new alerts)
         const cooldownKey = `${rule.id}:${tracked.globalId}`;
         const lastAlert = this.cooldowns.get(cooldownKey) || 0;
         if (rule.cooldown > 0 && Date.now() - lastAlert < rule.cooldown) {
             return null;
         }
-        // Check conditions
-        if (!this.evaluateConditions(rule.conditions, tracked)) {
-            return null;
-        }
         // Create alert
         // Note: details.objectLabel may contain LLM-generated description - preserve it if provided
         const fullDetails = {
@@ -34443,17 +34459,43 @@ class AlertManager {
         if (this.recentAlerts.length > this.maxAlerts) {
             this.recentAlerts.pop();
         }
+        if (type === 'movement') {
+            const key = (0, alert_utils_1.getActiveAlertKey)(type, rule.id, tracked.globalId);
+            this.activeAlerts.set(key, { alert, lastUpdate: Date.now(), lastNotified: alert.timestamp });
+        }
         // Update cooldown
         this.cooldowns.set(cooldownKey, Date.now());
         // Send notifications
-        await this.sendNotifications(alert, rule);
+        await this.sendNotifications(alert, rule, mediaObjectOverride);
         this.console.log(`Alert generated: [${alert.severity}] ${alert.message}`);
         return alert;
     }
+    async updateMovementAlert(tracked, details) {
+        const rule = this.rules.find(r => r.type === 'movement' && r.enabled);
+        if (!rule)
+            return null;
+        if (rule.objectClasses && rule.objectClasses.length > 0) {
+            if (!rule.objectClasses.includes(tracked.className)) {
+                return null;
+            }
+        }
+        if (rule.cameraIds && rule.cameraIds.length > 0 && details.cameraId) {
+            if (!rule.cameraIds.includes(details.cameraId)) {
+                return null;
+            }
+        }
+        if (!this.evaluateConditions(rule.conditions, tracked)) {
+            return null;
+        }
+        return this.updateActiveAlert('movement', rule.id, tracked, details);
+    }
     /**
      * Send notifications for an alert
      */
-    async sendNotifications(alert, rule) {
+    async sendNotifications(alert, rule, mediaObjectOverride) {
+        const sdkModule = await getSdk();
+        const { ScryptedInterface } = sdkModule;
+        const { systemManager } = sdkModule.default;
         const notifierIds = rule.notifiers.length > 0
             ? rule.notifiers
             : this.getDefaultNotifiers();
@@ -34464,17 +34506,19 @@ class AlertManager {
             return;
         }
         // Try to get a thumbnail from the camera
-        let mediaObject;
-        const cameraId = alert.details.toCameraId || alert.details.cameraId;
-        if (cameraId) {
-            try {
-                const camera = systemManager.getDeviceById(cameraId);
-                if (camera && camera.interfaces?.includes(sdk_1.ScryptedInterface.Camera)) {
-                    mediaObject = await camera.takePicture();
+        let mediaObject = mediaObjectOverride;
+        if (!mediaObject) {
+            const cameraId = alert.details.toCameraId || alert.details.cameraId;
+            if (cameraId) {
+                try {
+                    const camera = systemManager.getDeviceById(cameraId);
+                    if (camera && camera.interfaces?.includes(ScryptedInterface.Camera)) {
+                        mediaObject = await camera.takePicture();
+                    }
+                }
+                catch (e) {
+                    this.console.warn(`Failed to get thumbnail from camera ${cameraId}:`, e);
                 }
-            }
-            catch (e) {
-                this.console.warn(`Failed to get thumbnail from camera ${cameraId}:`, e);
             }
         }
         for (const notifierId of notifierIds) {
@@ -34500,6 +34544,57 @@ class AlertManager {
             }
         }
     }
+    clearActiveAlertsForObject(globalId) {
+        for (const [key, entry] of this.activeAlerts.entries()) {
+            if (entry.alert.trackedObjectId === globalId) {
+                this.activeAlerts.delete(key);
+            }
+        }
+    }
+    setUpdateNotificationOptions(enabled, cooldownMs) {
+        this.notifyOnUpdates = enabled;
+        this.updateNotificationCooldownMs = Math.max(0, cooldownMs);
+    }
+    async updateActiveAlert(type, ruleId, tracked, details) {
+        const key = (0, alert_utils_1.getActiveAlertKey)(type, ruleId, tracked.globalId);
+        const existing = this.activeAlerts.get(key);
+        if (!existing)
+            return null;
+        const now = Date.now();
+        if (now - existing.lastUpdate > this.activeAlertTtlMs) {
+            this.activeAlerts.delete(key);
+            return null;
+        }
+        const updatedDetails = {
+            ...existing.alert.details,
+            ...details,
+            objectClass: tracked.className,
+            objectLabel: details.objectLabel || tracked.label,
+        };
+        const shouldUpdate = (0, alert_utils_1.hasMeaningfulAlertChange)(existing.alert.details, updatedDetails);
+        if (!shouldUpdate)
+            return existing.alert;
+        existing.alert.details = updatedDetails;
+        existing.alert.message = (0, alert_1.generateAlertMessage)(type, updatedDetails);
+        existing.alert.timestamp = now;
+        existing.lastUpdate = now;
+        const idx = this.recentAlerts.findIndex(a => a.id === existing.alert.id);
+        if (idx >= 0) {
+            this.recentAlerts.splice(idx, 1);
+        }
+        this.recentAlerts.unshift(existing.alert);
+        if (this.recentAlerts.length > this.maxAlerts) {
+            this.recentAlerts.pop();
+        }
+        if (this.notifyOnUpdates) {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (rule && (0, alert_utils_1.shouldSendUpdateNotification)(this.notifyOnUpdates, existing.lastNotified, now, this.updateNotificationCooldownMs)) {
+                existing.lastNotified = now;
+                await this.sendNotifications(existing.alert, rule);
+            }
+        }
+        return existing.alert;
+    }
     /**
      * Get notification title based on alert type
      * For movement alerts with LLM descriptions, use the smart description as title
@@ -34750,6 +34845,40 @@ class AlertManager {
 exports.AlertManager = AlertManager;
 
 
+/***/ },
+
+/***/ "./src/alerts/alert-utils.ts"
+/*!***********************************!*\
+  !*** ./src/alerts/alert-utils.ts ***!
+  \***********************************/
+(__unused_webpack_module, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.hasMeaningfulAlertChange = hasMeaningfulAlertChange;
+exports.getActiveAlertKey = getActiveAlertKey;
+exports.shouldSendUpdateNotification = shouldSendUpdateNotification;
+function hasMeaningfulAlertChange(prev, next) {
+    return (prev.fromCameraId !== next.fromCameraId ||
+        prev.toCameraId !== next.toCameraId ||
+        prev.cameraId !== next.cameraId ||
+        prev.objectLabel !== next.objectLabel ||
+        prev.pathDescription !== next.pathDescription ||
+        JSON.stringify(prev.involvedLandmarks || []) !== JSON.stringify(next.involvedLandmarks || []));
+}
+function getActiveAlertKey(type, ruleId, trackedId) {
+    return `${type}:${ruleId}:${trackedId}`;
+}
+function shouldSendUpdateNotification(enabled, lastNotified, now, cooldownMs) {
+    if (!enabled)
+        return false;
+    if (cooldownMs <= 0)
+        return true;
+    return now - lastNotified >= cooldownMs;
+}
+
+
 /***/ },
 
 /***/ "./src/core/object-correlator.ts"
@@ -36468,6 +36597,12 @@ class TopologyDiscoveryEngine {
     getStatus() {
         return { ...this.status };
     }
+    /** Get list of LLMs excluded for lack of vision support */
+    getExcludedVisionLlmNames() {
+        return this.llmDevices
+            .filter(l => !l.visionCapable)
+            .map(l => l.name || l.id);
+    }
     /** Get pending suggestions */
     getPendingSuggestions() {
         return Array.from(this.suggestions.values())
@@ -36519,6 +36654,7 @@ class TopologyDiscoveryEngine {
                         providerType,
                         lastUsed: 0,
                         errorCount: 0,
+                        visionCapable: true,
                     });
                     this.console.log(`[Discovery] Found LLM: ${device.name}`);
                 }
@@ -36565,6 +36701,42 @@ class TopologyDiscoveryEngine {
         this.console.log(`[Discovery] Selected LLM: ${selected.name}`);
         return selected.device;
     }
+    /** Select an LLM device, excluding any IDs if provided */
+    async selectLlmDevice(excludeIds) {
+        await this.findAllLlmDevices();
+        if (this.llmDevices.length === 0)
+            return null;
+        let bestIndex = -1;
+        let bestScore = Infinity;
+        for (let i = 0; i < this.llmDevices.length; i++) {
+            const llm = this.llmDevices[i];
+            if (excludeIds.has(llm.id))
+                continue;
+            if (!llm.visionCapable)
+                continue;
+            const score = llm.lastUsed + (llm.errorCount * 60000);
+            if (score < bestScore) {
+                bestScore = score;
+                bestIndex = i;
+            }
+        }
+        if (bestIndex === -1)
+            return null;
+        const selected = this.llmDevices[bestIndex];
+        this.llmDevice = selected.device;
+        this.llmProviderType = selected.providerType;
+        selected.lastUsed = Date.now();
+        this.console.log(`[Discovery] Selected LLM: ${selected.name}`);
+        return selected.device;
+    }
+    isRetryableLlmError(error) {
+        const errorStr = String(error).toLowerCase();
+        return (errorStr.includes('404') ||
+            errorStr.includes('not found') ||
+            errorStr.includes('no such model') ||
+            errorStr.includes('model not found') ||
+            errorStr.includes('endpoint'));
+    }
     /** Mark an LLM as having an error */
     markLlmError(device) {
         const llm = this.llmDevices.find(l => l.device === device);
@@ -36614,45 +36786,51 @@ class TopologyDiscoveryEngine {
             potentialOverlaps: [],
             isValid: false,
         };
-        const llm = await this.findLlmDevice();
-        if (!llm?.getChatCompletion) {
-            analysis.error = 'No LLM device available';
-            return analysis;
-        }
         const imageData = await this.getCameraSnapshot(cameraId);
         if (!imageData) {
             analysis.error = 'Failed to capture camera snapshot';
             return analysis;
         }
-        // Try with detected provider format first, then fallback to alternates
-        // The order matters: try the most likely formats first
-        const formatsToTry = [];
-        // Start with detected format
-        formatsToTry.push(this.llmProviderType);
-        // Add fallbacks based on detected provider
-        if (this.llmProviderType === 'openai') {
-            formatsToTry.push('scrypted', 'anthropic');
-        }
-        else if (this.llmProviderType === 'anthropic') {
-            formatsToTry.push('scrypted', 'openai');
-        }
-        else if (this.llmProviderType === 'scrypted') {
-            formatsToTry.push('anthropic', 'openai');
-        }
-        else {
-            // Unknown - try all formats
-            formatsToTry.push('scrypted', 'anthropic', 'openai');
-        }
+        await this.findAllLlmDevices();
+        const excludeIds = new Set();
         let lastError = null;
-        for (const formatType of formatsToTry) {
-            try {
-                this.console.log(`[Discovery] Trying ${formatType} image format for ${cameraName}...`);
-                // Build prompt with camera context (height)
-                const cameraNode = this.topology ? (0, topology_1.findCamera)(this.topology, cameraId) : null;
-                const mountHeight = cameraNode?.context?.mountHeight || 8;
-                const cameraRange = cameraNode?.fov?.range || 80;
-                // Add camera-specific context to the prompt
-                const contextPrefix = `CAMERA INFORMATION:
+        const maxAttempts = Math.max(1, this.llmDevices.length || 1);
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const llm = await this.selectLlmDevice(excludeIds);
+            if (!llm?.getChatCompletion) {
+                analysis.error = 'No LLM device available';
+                return analysis;
+            }
+            let allFormatsVisionError = false;
+            // Try with detected provider format first, then fallback to alternates
+            // The order matters: try the most likely formats first
+            const formatsToTry = [];
+            // Start with detected format
+            formatsToTry.push(this.llmProviderType);
+            // Add fallbacks based on detected provider
+            if (this.llmProviderType === 'openai') {
+                formatsToTry.push('scrypted', 'anthropic');
+            }
+            else if (this.llmProviderType === 'anthropic') {
+                formatsToTry.push('scrypted', 'openai');
+            }
+            else if (this.llmProviderType === 'scrypted') {
+                formatsToTry.push('anthropic', 'openai');
+            }
+            else {
+                // Unknown - try all formats
+                formatsToTry.push('scrypted', 'anthropic', 'openai');
+            }
+            let visionFormatFailures = 0;
+            for (const formatType of formatsToTry) {
+                try {
+                    this.console.log(`[Discovery] Trying ${formatType} image format for ${cameraName}...`);
+                    // Build prompt with camera context (height)
+                    const cameraNode = this.topology ? (0, topology_1.findCamera)(this.topology, cameraId) : null;
+                    const mountHeight = cameraNode?.context?.mountHeight || 8;
+                    const cameraRange = cameraNode?.fov?.range || 80;
+                    // Add camera-specific context to the prompt
+                    const contextPrefix = `CAMERA INFORMATION:
 - Camera Name: ${cameraName}
 - Mount Height: ${mountHeight} feet above ground
 - Approximate viewing range: ${cameraRange} feet
@@ -36660,96 +36838,122 @@ class TopologyDiscoveryEngine {
 Use the mount height to help estimate distances - objects at ground level will appear at different angles depending on distance from a camera mounted at ${mountHeight} feet.
 
 `;
-                // Build multimodal message with provider-specific image format
-                const result = await llm.getChatCompletion({
-                    messages: [
-                        {
-                            role: 'user',
-                            content: [
-                                { type: 'text', text: contextPrefix + SCENE_ANALYSIS_PROMPT },
-                                (0, spatial_reasoning_1.buildImageContent)(imageData, formatType),
-                            ],
-                        },
-                    ],
-                    max_tokens: 4000, // Increased for detailed scene analysis
-                    temperature: 0.3,
-                });
-                const content = result?.choices?.[0]?.message?.content;
-                if (content && typeof content === 'string') {
-                    try {
-                        // Extract JSON from response (handle markdown code blocks)
-                        let jsonStr = content.trim();
-                        if (jsonStr.startsWith('```')) {
-                            jsonStr = jsonStr.replace(/```json?\n?/g, '').replace(/```$/g, '').trim();
-                        }
-                        // Try to recover truncated JSON
-                        const parsed = this.parseJsonWithRecovery(jsonStr, cameraName);
-                        // Map parsed data to our types
-                        if (Array.isArray(parsed.landmarks)) {
-                            analysis.landmarks = parsed.landmarks.map((l) => ({
-                                name: l.name || 'Unknown',
-                                type: this.mapLandmarkType(l.type),
-                                confidence: typeof l.confidence === 'number' ? l.confidence : 0.7,
-                                distance: this.mapDistance(l.distance),
-                                description: l.description || '',
-                                boundingBox: l.boundingBox,
-                            }));
-                        }
-                        if (Array.isArray(parsed.zones)) {
-                            analysis.zones = parsed.zones.map((z) => ({
-                                name: z.name || 'Unknown',
-                                type: this.mapZoneType(z.type),
-                                coverage: typeof z.coverage === 'number' ? z.coverage : 0.5,
-                                description: z.description || '',
-                                boundingBox: z.boundingBox,
-                                distance: this.mapDistance(z.distance), // Parse distance for zones too
-                            }));
-                        }
-                        if (parsed.edges && typeof parsed.edges === 'object') {
-                            analysis.edges = {
-                                top: parsed.edges.top || '',
-                                left: parsed.edges.left || '',
-                                right: parsed.edges.right || '',
-                                bottom: parsed.edges.bottom || '',
-                            };
-                        }
-                        if (parsed.orientation) {
-                            analysis.orientation = this.mapOrientation(parsed.orientation);
+                    // Build multimodal message with provider-specific image format
+                    const result = await llm.getChatCompletion({
+                        messages: [
+                            {
+                                role: 'user',
+                                content: [
+                                    { type: 'text', text: contextPrefix + SCENE_ANALYSIS_PROMPT },
+                                    (0, spatial_reasoning_1.buildImageContent)(imageData, formatType),
+                                ],
+                            },
+                        ],
+                        max_tokens: 4000, // Increased for detailed scene analysis
+                        temperature: 0.3,
+                    });
+                    const content = result?.choices?.[0]?.message?.content;
+                    if (content && typeof content === 'string') {
+                        try {
+                            // Extract JSON from response (handle markdown code blocks)
+                            let jsonStr = content.trim();
+                            if (jsonStr.startsWith('```')) {
+                                jsonStr = jsonStr.replace(/```json?\n?/g, '').replace(/```$/g, '').trim();
+                            }
+                            // Try to recover truncated JSON
+                            const parsed = this.parseJsonWithRecovery(jsonStr, cameraName);
+                            // Map parsed data to our types
+                            if (Array.isArray(parsed.landmarks)) {
+                                analysis.landmarks = parsed.landmarks.map((l) => ({
+                                    name: l.name || 'Unknown',
+                                    type: this.mapLandmarkType(l.type),
+                                    confidence: typeof l.confidence === 'number' ? l.confidence : 0.7,
+                                    distance: this.mapDistance(l.distance),
+                                    description: l.description || '',
+                                    boundingBox: l.boundingBox,
+                                }));
+                            }
+                            if (Array.isArray(parsed.zones)) {
+                                analysis.zones = parsed.zones.map((z) => ({
+                                    name: z.name || 'Unknown',
+                                    type: this.mapZoneType(z.type),
+                                    coverage: typeof z.coverage === 'number' ? z.coverage : 0.5,
+                                    description: z.description || '',
+                                    boundingBox: z.boundingBox,
+                                    distance: this.mapDistance(z.distance), // Parse distance for zones too
+                                }));
+                            }
+                            if (parsed.edges && typeof parsed.edges === 'object') {
+                                analysis.edges = {
+                                    top: parsed.edges.top || '',
+                                    left: parsed.edges.left || '',
+                                    right: parsed.edges.right || '',
+                                    bottom: parsed.edges.bottom || '',
+                                };
+                            }
+                            if (parsed.orientation) {
+                                analysis.orientation = this.mapOrientation(parsed.orientation);
+                            }
+                            analysis.isValid = true;
+                            this.console.log(`[Discovery] Analyzed ${cameraName}: ${analysis.landmarks.length} landmarks, ${analysis.zones.length} zones (using ${formatType} format)`);
+                            // Update the preferred format for future requests
+                            if (formatType !== this.llmProviderType) {
+                                this.console.log(`[Discovery] Switching to ${formatType} format for future requests`);
+                                this.llmProviderType = formatType;
+                            }
+                            // Success - exit the retry loop
+                            return analysis;
                         }
-                        analysis.isValid = true;
-                        this.console.log(`[Discovery] Analyzed ${cameraName}: ${analysis.landmarks.length} landmarks, ${analysis.zones.length} zones (using ${formatType} format)`);
-                        // Update the preferred format for future requests
-                        if (formatType !== this.llmProviderType) {
-                            this.console.log(`[Discovery] Switching to ${formatType} format for future requests`);
-                            this.llmProviderType = formatType;
+                        catch (parseError) {
+                            this.console.warn(`[Discovery] Failed to parse LLM response for ${cameraName}:`, parseError);
+                            analysis.error = 'Failed to parse LLM response';
+                            return analysis;
                         }
-                        // Success - exit the retry loop
-                        return analysis;
                     }
-                    catch (parseError) {
-                        this.console.warn(`[Discovery] Failed to parse LLM response for ${cameraName}:`, parseError);
-                        analysis.error = 'Failed to parse LLM response';
-                        return analysis;
+                }
+                catch (e) {
+                    lastError = e;
+                    // Check if this is a vision/multimodal format error
+                    if ((0, spatial_reasoning_1.isVisionFormatError)(e)) {
+                        this.console.warn(`[Discovery] ${formatType} format failed, trying fallback...`);
+                        visionFormatFailures++;
+                        continue; // Try next format
+                    }
+                    // Retry with a different LLM if error indicates bad endpoint/model
+                    if (this.isRetryableLlmError(e)) {
+                        this.console.warn(`[Discovery] LLM error for ${cameraName}, trying another provider...`);
+                        this.markLlmError(llm);
+                        const llmEntry = this.llmDevices.find(d => d.device === llm);
+                        if (llmEntry) {
+                            excludeIds.add(llmEntry.id);
+                        }
+                        break;
                     }
+                    // Not a format error - don't retry
+                    this.console.warn(`[Discovery] Scene analysis failed for ${cameraName}:`, e);
+                    break;
                 }
             }
-            catch (e) {
-                lastError = e;
-                // Check if this is a vision/multimodal format error
-                if ((0, spatial_reasoning_1.isVisionFormatError)(e)) {
-                    this.console.warn(`[Discovery] ${formatType} format failed, trying fallback...`);
-                    continue; // Try next format
-                }
-                // Not a format error - don't retry
-                this.console.warn(`[Discovery] Scene analysis failed for ${cameraName}:`, e);
-                break;
+            allFormatsVisionError = visionFormatFailures > 0 && visionFormatFailures === formatsToTry.length;
+            if (allFormatsVisionError) {
+                const llmEntry = this.llmDevices.find(d => d.device === llm);
+                if (llmEntry) {
+                    llmEntry.visionCapable = false;
+                    excludeIds.add(llmEntry.id);
+                    this.console.warn(`[Discovery] ${llmEntry.name} does not support vision. Excluding from discovery.`);
+                }
             }
         }
         // All formats failed
         if (lastError) {
             // Track error for load balancing
-            if (llm) {
-                this.markLlmError(llm);
+            // Note: llm may be null here if no device was available
+            if (lastError && !this.isRetryableLlmError(lastError)) {
+                // Best-effort error accounting for the most recent device
+                const lastDevice = this.llmDevice;
+                if (lastDevice) {
+                    this.markLlmError(lastDevice);
+                }
             }
             const errorStr = String(lastError);
             if ((0, spatial_reasoning_1.isVisionFormatError)(lastError)) {
@@ -37324,7 +37528,9 @@ class TrackingEngine {
     spatialReasoning;
     listeners = new Map();
     pendingTimers = new Map();
+    loiteringTimers = new Map();
     lostCheckInterval = null;
+    cleanupInterval = null;
     /** Track last alert time per object to enforce cooldown */
     objectLastAlertTime = new Map();
     /** Callback for topology changes (e.g., landmark suggestions) */
@@ -37407,6 +37613,9 @@ class TrackingEngine {
         this.lostCheckInterval = setInterval(() => {
             this.checkForLostObjects();
         }, 30000); // Check every 30 seconds
+        this.cleanupInterval = setInterval(() => {
+            this.state.cleanup();
+        }, 300000); // Cleanup every 5 minutes
         this.console.log(`Tracking engine started with ${this.listeners.size} cameras`);
     }
     /** Stop all camera listeners */
@@ -37426,11 +37635,19 @@ class TrackingEngine {
             clearTimeout(timer);
         }
         this.pendingTimers.clear();
+        for (const timer of this.loiteringTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.loiteringTimers.clear();
         // Stop lost check interval
         if (this.lostCheckInterval) {
             clearInterval(this.lostCheckInterval);
             this.lostCheckInterval = null;
         }
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
         this.console.log('Tracking engine stopped');
     }
     /** Handle detection event from a camera */
@@ -37445,7 +37662,7 @@ class TrackingEngine {
         const timestamp = detected.timestamp || Date.now();
         for (const detection of detected.detections) {
             // Skip low-confidence detections
-            if (detection.score < 0.5)
+            if (detection.score < this.config.minDetectionScore)
                 continue;
             // If in training mode, record trainer detections
             if (this.isTrainingActive() && detection.className === 'person') {
@@ -37523,6 +37740,9 @@ class TrackingEngine {
         const fallbackEnabled = this.config.llmFallbackEnabled ?? true;
         const fallbackTimeout = this.config.llmFallbackTimeout ?? 3000;
         try {
+            if (!this.config.useLlmDescriptions) {
+                return this.spatialReasoning.generateMovementDescription(tracked, fromCameraId, toCameraId, transitTime);
+            }
             // Check rate limiting - if not allowed, return null to use basic description
             if (!this.tryLlmCall()) {
                 this.console.log('[Movement] LLM rate-limited, using basic notification');
@@ -37530,11 +37750,9 @@ class TrackingEngine {
             }
             // Get snapshot from camera for LLM analysis (if LLM is enabled)
             let mediaObject;
-            if (this.config.useLlmDescriptions) {
-                const camera = systemManager.getDeviceById(currentCameraId);
-                if (camera?.interfaces?.includes(sdk_1.ScryptedInterface.Camera)) {
-                    mediaObject = await camera.takePicture();
-                }
+            const camera = systemManager.getDeviceById(currentCameraId);
+            if (camera?.interfaces?.includes(sdk_1.ScryptedInterface.Camera)) {
+                mediaObject = await camera.takePicture();
             }
             // Use spatial reasoning engine for rich context-aware description
             // Apply timeout if fallback is enabled
@@ -37591,6 +37809,8 @@ class TrackingEngine {
             // Check if this is a cross-camera transition
             const lastSighting = (0, tracked_object_1.getLastSighting)(tracked);
             if (lastSighting && lastSighting.cameraId !== sighting.cameraId) {
+                // Cancel any pending loitering alert if object already transitioned
+                this.clearLoiteringTimer(tracked.globalId);
                 const transitDuration = sighting.timestamp - lastSighting.timestamp;
                 // Update cached snapshot from new camera (object is now visible here)
                 if (this.config.useLlmDescriptions) {
@@ -37615,25 +37835,44 @@ class TrackingEngine {
                     `${lastSighting.cameraName} → ${sighting.cameraName} ` +
                     `(confidence: ${(correlation.confidence * 100).toFixed(0)}%)`);
                 // Check loitering threshold and per-object cooldown before alerting
-                if (this.passesLoiteringThreshold(tracked) && !this.isInAlertCooldown(tracked.globalId)) {
-                    // Get spatial reasoning result with RAG context
-                    const spatialResult = await this.getSpatialDescription(tracked, lastSighting.cameraId, sighting.cameraId, transitDuration, sighting.cameraId);
-                    // Generate movement alert for cross-camera transition
-                    await this.alertManager.checkAndAlert('movement', tracked, {
-                        fromCameraId: lastSighting.cameraId,
-                        fromCameraName: lastSighting.cameraName,
-                        toCameraId: sighting.cameraId,
-                        toCameraName: sighting.cameraName,
-                        transitTime: transitDuration,
-                        objectClass: sighting.detection.className,
-                        objectLabel: spatialResult?.description || sighting.detection.label,
-                        detectionId: sighting.detectionId,
-                        // Include spatial context for enriched alerts
-                        pathDescription: spatialResult?.pathDescription,
-                        involvedLandmarks: spatialResult?.involvedLandmarks?.map(l => l.name),
-                        usedLlm: spatialResult?.usedLlm,
-                    });
-                    this.recordAlertTime(tracked.globalId);
+                if (this.passesLoiteringThreshold(tracked)) {
+                    if (this.isInAlertCooldown(tracked.globalId)) {
+                        const spatialResult = await this.spatialReasoning.generateMovementDescription(tracked, lastSighting.cameraId, sighting.cameraId, transitDuration);
+                        await this.alertManager.updateMovementAlert(tracked, {
+                            fromCameraId: lastSighting.cameraId,
+                            fromCameraName: lastSighting.cameraName,
+                            toCameraId: sighting.cameraId,
+                            toCameraName: sighting.cameraName,
+                            transitTime: transitDuration,
+                            objectClass: sighting.detection.className,
+                            objectLabel: spatialResult.description || sighting.detection.label,
+                            detectionId: sighting.detectionId,
+                            pathDescription: spatialResult.pathDescription,
+                            involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
+                            usedLlm: spatialResult.usedLlm,
+                        });
+                    }
+                    else {
+                        // Get spatial reasoning result with RAG context
+                        const spatialResult = await this.getSpatialDescription(tracked, lastSighting.cameraId, sighting.cameraId, transitDuration, sighting.cameraId);
+                        // Generate movement alert for cross-camera transition
+                        const mediaObject = this.snapshotCache.get(tracked.globalId);
+                        await this.alertManager.checkAndAlert('movement', tracked, {
+                            fromCameraId: lastSighting.cameraId,
+                            fromCameraName: lastSighting.cameraName,
+                            toCameraId: sighting.cameraId,
+                            toCameraName: sighting.cameraName,
+                            transitTime: transitDuration,
+                            objectClass: sighting.detection.className,
+                            objectLabel: spatialResult?.description || sighting.detection.label,
+                            detectionId: sighting.detectionId,
+                            // Include spatial context for enriched alerts
+                            pathDescription: spatialResult?.pathDescription,
+                            involvedLandmarks: spatialResult?.involvedLandmarks?.map(l => l.name),
+                            usedLlm: spatialResult?.usedLlm,
+                        }, mediaObject);
+                        this.recordAlertTime(tracked.globalId);
+                    }
                 }
             }
             // Add sighting to tracked object
@@ -37672,58 +37911,91 @@ class TrackingEngine {
             });
         }
         // Check after loitering threshold if object is still being tracked
-        setTimeout(async () => {
-            const tracked = this.state.getObject(globalId);
-            if (!tracked || tracked.state !== 'active')
-                return;
-            // Check if we've already alerted for this object
-            if (this.isInAlertCooldown(globalId))
-                return;
-            // Use prefetched LLM result if available (started when snapshot was captured)
-            let spatialResult;
-            const pendingDescription = this.pendingDescriptions.get(globalId);
-            if (pendingDescription) {
-                this.console.log(`[Entry Alert] Using prefetched LLM result for ${globalId.slice(0, 8)}`);
-                try {
-                    spatialResult = await pendingDescription;
-                    this.console.log(`[Entry Alert] Prefetch result: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+        const existing = this.loiteringTimers.get(globalId);
+        if (existing) {
+            clearTimeout(existing);
+            this.loiteringTimers.delete(globalId);
+        }
+        const timer = setTimeout(async () => {
+            try {
+                const tracked = this.state.getObject(globalId);
+                if (!tracked || tracked.state !== 'active')
+                    return;
+                const lastSighting = (0, tracked_object_1.getLastSighting)(tracked);
+                if (!lastSighting || lastSighting.cameraId !== sighting.cameraId) {
+                    return;
                 }
-                catch (e) {
-                    this.console.warn(`[Entry Alert] Prefetch failed, using basic description: ${e}`);
-                    // Don't make another LLM call - use basic description (no mediaObject = no LLM)
-                    spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId);
+                const maxStaleMs = Math.max(10000, this.config.loiteringThreshold * 2);
+                if (Date.now() - lastSighting.timestamp > maxStaleMs) {
+                    return;
                 }
-                this.pendingDescriptions.delete(globalId);
-            }
-            else {
-                // No prefetch available - only call LLM if rate limit allows
-                if (this.tryLlmCall()) {
-                    this.console.log(`[Entry Alert] No prefetch, generating with LLM`);
-                    const mediaObject = this.snapshotCache.get(globalId);
-                    spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId, mediaObject);
-                    this.console.log(`[Entry Alert] Got description: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+                // Check if we've already alerted for this object
+                if (this.isInAlertCooldown(globalId)) {
+                    const spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId);
+                    await this.alertManager.updateMovementAlert(tracked, {
+                        cameraId: sighting.cameraId,
+                        cameraName: sighting.cameraName,
+                        toCameraId: sighting.cameraId,
+                        toCameraName: sighting.cameraName,
+                        objectClass: sighting.detection.className,
+                        objectLabel: spatialResult.description,
+                        detectionId: sighting.detectionId,
+                        involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
+                        usedLlm: spatialResult.usedLlm,
+                    });
+                    return;
+                }
+                // Use prefetched LLM result if available (started when snapshot was captured)
+                let spatialResult;
+                const pendingDescription = this.pendingDescriptions.get(globalId);
+                if (pendingDescription) {
+                    this.console.log(`[Entry Alert] Using prefetched LLM result for ${globalId.slice(0, 8)}`);
+                    try {
+                        spatialResult = await pendingDescription;
+                        this.console.log(`[Entry Alert] Prefetch result: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+                    }
+                    catch (e) {
+                        this.console.warn(`[Entry Alert] Prefetch failed, using basic description: ${e}`);
+                        // Don't make another LLM call - use basic description (no mediaObject = no LLM)
+                        spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId);
+                    }
+                    this.pendingDescriptions.delete(globalId);
                 }
                 else {
-                    // Rate limited - use basic description (no LLM)
-                    this.console.log(`[Entry Alert] Rate limited, using basic description`);
-                    spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId);
-                }
-            }
-            // Always use movement alert type for smart notifications with LLM descriptions
-            // The property_entry/property_exit types are legacy and disabled by default
-            await this.alertManager.checkAndAlert('movement', tracked, {
-                cameraId: sighting.cameraId,
-                cameraName: sighting.cameraName,
-                toCameraId: sighting.cameraId,
-                toCameraName: sighting.cameraName,
-                objectClass: sighting.detection.className,
-                objectLabel: spatialResult.description, // Smart LLM-generated description
-                detectionId: sighting.detectionId,
-                involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
-                usedLlm: spatialResult.usedLlm,
-            });
-            this.recordAlertTime(globalId);
+                    // No prefetch available - only call LLM if rate limit allows
+                    if (this.tryLlmCall()) {
+                        this.console.log(`[Entry Alert] No prefetch, generating with LLM`);
+                        const mediaObject = this.snapshotCache.get(globalId);
+                        spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId, mediaObject);
+                        this.console.log(`[Entry Alert] Got description: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+                    }
+                    else {
+                        // Rate limited - use basic description (no LLM)
+                        this.console.log(`[Entry Alert] Rate limited, using basic description`);
+                        spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId);
+                    }
+                }
+                // Always use movement alert type for smart notifications with LLM descriptions
+                // The property_entry/property_exit types are legacy and disabled by default
+                const mediaObject = this.snapshotCache.get(globalId);
+                await this.alertManager.checkAndAlert('movement', tracked, {
+                    cameraId: sighting.cameraId,
+                    cameraName: sighting.cameraName,
+                    toCameraId: sighting.cameraId,
+                    toCameraName: sighting.cameraName,
+                    objectClass: sighting.detection.className,
+                    objectLabel: spatialResult.description, // Smart LLM-generated description
+                    detectionId: sighting.detectionId,
+                    involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
+                    usedLlm: spatialResult.usedLlm,
+                }, mediaObject);
+                this.recordAlertTime(globalId);
+            }
+            finally {
+                this.loiteringTimers.delete(globalId);
+            }
         }, this.config.loiteringThreshold);
+        this.loiteringTimers.set(globalId, timer);
     }
     /** Capture and cache a snapshot for a tracked object, and start LLM analysis immediately */
     async captureAndCacheSnapshot(globalId, cameraId, eventType = 'entry') {
@@ -37798,6 +38070,8 @@ class TrackingEngine {
     handlePotentialExit(tracked, sighting) {
         // Mark as pending and set timer
         this.state.markPending(tracked.globalId);
+        // Cancel any pending loitering alert
+        this.clearLoiteringTimer(tracked.globalId);
         // Capture a fresh snapshot now while object is still visible (before they leave)
         // Also starts LLM analysis immediately in parallel
         if (this.config.useLlmDescriptions) {
@@ -37841,6 +38115,7 @@ class TrackingEngine {
                     }
                 }
                 // Use movement alert for exit too - smart notifications with LLM descriptions
+                const mediaObject = this.snapshotCache.get(tracked.globalId);
                 await this.alertManager.checkAndAlert('movement', current, {
                     cameraId: sighting.cameraId,
                     cameraName: sighting.cameraName,
@@ -37850,7 +38125,8 @@ class TrackingEngine {
                     objectLabel: spatialResult.description,
                     involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
                     usedLlm: spatialResult.usedLlm,
-                });
+                }, mediaObject);
+                this.alertManager.clearActiveAlertsForObject(tracked.globalId);
                 // Clean up cached snapshot and pending descriptions after exit alert
                 this.snapshotCache.delete(tracked.globalId);
                 this.pendingDescriptions.delete(tracked.globalId);
@@ -37867,6 +38143,7 @@ class TrackingEngine {
             const timeSinceSeen = now - tracked.lastSeen;
             if (timeSinceSeen > this.config.lostTimeout) {
                 this.state.markLost(tracked.globalId);
+                this.clearLoiteringTimer(tracked.globalId);
                 this.console.log(`Object ${tracked.globalId.slice(0, 8)} marked as lost ` +
                     `(not seen for ${Math.round(timeSinceSeen / 1000)}s)`);
                 // Clean up cached snapshot and pending descriptions
@@ -37876,9 +38153,18 @@ class TrackingEngine {
                     objectClass: tracked.className,
                     objectLabel: tracked.label,
                 });
+                this.alertManager.clearActiveAlertsForObject(tracked.globalId);
             }
         }
     }
+    /** Clear a pending loitering timer if present */
+    clearLoiteringTimer(globalId) {
+        const timer = this.loiteringTimers.get(globalId);
+        if (timer) {
+            clearTimeout(timer);
+            this.loiteringTimers.delete(globalId);
+        }
+    }
     /** Update topology configuration */
     updateTopology(topology) {
         this.topology = topology;
@@ -39363,6 +39649,13 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             description: 'Object must be visible for this duration before triggering movement alerts',
             group: 'Tracking',
         },
+        minDetectionScore: {
+            title: 'Minimum Detection Confidence',
+            type: 'number',
+            defaultValue: 0.5,
+            description: 'Minimum detection score (0-1) to consider for tracking',
+            group: 'Tracking',
+        },
         objectAlertCooldown: {
             title: 'Per-Object Alert Cooldown (seconds)',
             type: 'number',
@@ -39370,6 +39663,20 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             description: 'Minimum time between alerts for the same tracked object',
             group: 'Tracking',
         },
+        notifyOnAlertUpdates: {
+            title: 'Notify on Alert Updates',
+            type: 'boolean',
+            defaultValue: false,
+            description: 'Send notifications when an existing alert is updated (camera transitions, context changes)',
+            group: 'Tracking',
+        },
+        alertUpdateCooldown: {
+            title: 'Alert Update Cooldown (seconds)',
+            type: 'number',
+            defaultValue: 60,
+            description: 'Minimum time between update notifications for the same tracked object (0 = no limit)',
+            group: 'Tracking',
+        },
         // LLM Integration
         useLlmDescriptions: {
             title: 'Use LLM for Rich Descriptions',
@@ -39562,6 +39869,7 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         if (this.storageSettings.values.enableMqtt) {
             await this.initializeMqtt();
         }
+        this.applyAlertUpdateSettings();
         this.console.log('Spatial Awareness Plugin initialized');
     }
     async initializeMqtt() {
@@ -39590,23 +39898,25 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             await this.trackingEngine.stopTracking();
         }
         const config = {
-            correlationWindow: (this.storageSettings.values.correlationWindow || 30) * 1000,
-            correlationThreshold: this.storageSettings.values.correlationThreshold || 0.35,
-            lostTimeout: (this.storageSettings.values.lostTimeout || 300) * 1000,
+            correlationWindow: this.getNumberSetting(this.storageSettings.values.correlationWindow, 30) * 1000,
+            correlationThreshold: this.getNumberSetting(this.storageSettings.values.correlationThreshold, 0.35),
+            lostTimeout: this.getNumberSetting(this.storageSettings.values.lostTimeout, 300) * 1000,
             useVisualMatching: this.storageSettings.values.useVisualMatching ?? true,
-            loiteringThreshold: (this.storageSettings.values.loiteringThreshold || 3) * 1000,
-            objectAlertCooldown: (this.storageSettings.values.objectAlertCooldown || 30) * 1000,
+            loiteringThreshold: this.getNumberSetting(this.storageSettings.values.loiteringThreshold, 3) * 1000,
+            minDetectionScore: this.getNumberSetting(this.storageSettings.values.minDetectionScore, 0.5),
+            objectAlertCooldown: this.getNumberSetting(this.storageSettings.values.objectAlertCooldown, 30) * 1000,
             useLlmDescriptions: this.storageSettings.values.useLlmDescriptions ?? true,
             llmDeviceIds: this.parseLlmProviders(),
-            llmDebounceInterval: (this.storageSettings.values.llmDebounceInterval || 30) * 1000,
+            llmDebounceInterval: this.getNumberSetting(this.storageSettings.values.llmDebounceInterval, 5) * 1000,
             llmFallbackEnabled: this.storageSettings.values.llmFallbackEnabled ?? true,
-            llmFallbackTimeout: (this.storageSettings.values.llmFallbackTimeout || 3) * 1000,
+            llmFallbackTimeout: this.getNumberSetting(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,
+            landmarkConfidenceThreshold: this.getNumberSetting(this.storageSettings.values.landmarkConfidenceThreshold, 0.7),
         };
         this.trackingEngine = new tracking_engine_1.TrackingEngine(topology, this.trackingState, this.alertManager, config, this.console);
+        this.applyAlertUpdateSettings();
         // Set up callback to save topology changes (e.g., from accepted landmark suggestions)
         this.trackingEngine.setTopologyChangeCallback((updatedTopology) => {
             this.storage.setItem('topology', JSON.stringify(updatedTopology));
@@ -39619,10 +39929,10 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
     }
     async initializeDiscoveryEngine(topology) {
         const discoveryConfig = {
-            discoveryIntervalHours: this.storageSettings.values.discoveryIntervalHours ?? 0,
-            autoAcceptThreshold: this.storageSettings.values.autoAcceptThreshold ?? 0.85,
-            minLandmarkConfidence: this.storageSettings.values.minLandmarkConfidence ?? 0.6,
-            minConnectionConfidence: this.storageSettings.values.minConnectionConfidence ?? 0.5,
+            discoveryIntervalHours: this.getNumberSetting(this.storageSettings.values.discoveryIntervalHours, 0),
+            autoAcceptThreshold: this.getNumberSetting(this.storageSettings.values.autoAcceptThreshold, 0.85),
+            minLandmarkConfidence: this.getNumberSetting(this.storageSettings.values.minLandmarkConfidence, 0.6),
+            minConnectionConfidence: this.getNumberSetting(this.storageSettings.values.minConnectionConfidence, 0.5),
         };
         if (this.discoveryEngine) {
             // Update existing engine
@@ -39667,6 +39977,12 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         }
         return undefined;
     }
+    getNumberSetting(value, fallback) {
+        if (value === undefined || value === null)
+            return fallback;
+        const num = typeof value === 'string' ? Number(value) : value;
+        return Number.isFinite(num) ? num : fallback;
+    }
     // ==================== DeviceProvider Implementation ====================
     async getDevice(nativeId) {
         let device = this.devices.get(nativeId);
@@ -39925,6 +40241,19 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         addGroup('AI & Spatial Reasoning');
         // ==================== 8. Auto-Topology Discovery ====================
         addGroup('Auto-Topology Discovery');
+        if (this.discoveryEngine) {
+            const excluded = this.discoveryEngine.getExcludedVisionLlmNames();
+            if (excluded.length > 0) {
+                settings.push({
+                    key: 'excludedVisionLlms',
+                    title: 'Excluded LLMs (No Vision)',
+                    type: 'string',
+                    readonly: true,
+                    value: excluded.join(', '),
+                    group: 'Auto-Topology Discovery',
+                });
+            }
+        }
         // ==================== 9. MQTT Integration ====================
         addGroup('MQTT Integration');
         return settings;
@@ -39938,6 +40267,7 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             key === 'lostTimeout' ||
             key === 'useVisualMatching' ||
             key === 'loiteringThreshold' ||
+            key === 'minDetectionScore' ||
             key === 'objectAlertCooldown' ||
             key === 'useLlmDescriptions' ||
             key === 'llmDebounceInterval' ||
@@ -39959,6 +40289,9 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
                 }
             }
         }
+        if (key === 'notifyOnAlertUpdates' || key === 'alertUpdateCooldown') {
+            this.applyAlertUpdateSettings();
+        }
         // Handle MQTT setting changes
         if (key === 'enableMqtt' || key === 'mqttBroker' || key === 'mqttUsername' ||
             key === 'mqttPassword' || key === 'mqttBaseTopic') {
@@ -39971,6 +40304,11 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             }
         }
     }
+    applyAlertUpdateSettings() {
+        const enabled = this.storageSettings.values.notifyOnAlertUpdates ?? false;
+        const cooldownSeconds = this.getNumberSetting(this.storageSettings.values.alertUpdateCooldown, 60);
+        this.alertManager.setUpdateNotificationOptions(enabled, cooldownSeconds * 1000);
+    }
     // ==================== HttpRequestHandler Implementation ====================
     async onRequest(request, response) {
         const url = new URL(request.url, 'http://localhost');
@@ -40042,7 +40380,7 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             }
             // Training Mode endpoints
             if (path.endsWith('/api/training/start')) {
-                return this.handleTrainingStartRequest(request, response);
+                return await this.handleTrainingStartRequest(request, response);
             }
             if (path.endsWith('/api/training/pause')) {
                 return this.handleTrainingPauseRequest(response);
@@ -40612,13 +40950,23 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         }
     }
     // ==================== Training Mode Handlers ====================
-    handleTrainingStartRequest(request, response) {
+    async handleTrainingStartRequest(request, response) {
         if (!this.trackingEngine) {
-            response.send(JSON.stringify({ error: 'Tracking engine not running. Configure topology first.' }), {
-                code: 500,
-                headers: { 'Content-Type': 'application/json' },
-            });
-            return;
+            const topologyJson = this.storage.getItem('topology');
+            const topology = topologyJson ? JSON.parse(topologyJson) : (0, topology_1.createEmptyTopology)();
+            if (!topology.cameras?.length) {
+                const cameras = this.buildTopologyCamerasFromSettings();
+                if (cameras.length === 0) {
+                    response.send(JSON.stringify({ error: 'No cameras configured. Select tracked cameras first.' }), {
+                        code: 400,
+                        headers: { 'Content-Type': 'application/json' },
+                    });
+                    return;
+                }
+                topology.cameras = cameras;
+                this.storage.setItem('topology', JSON.stringify(topology));
+            }
+            await this.startTrackingEngine(topology);
         }
         try {
             let config;
@@ -41327,6 +41675,25 @@ Access the visual topology editor at \`/ui/editor\` to configure camera relation
         const topologyJson = this.storage.getItem('topology');
         return topologyJson ? JSON.parse(topologyJson) : null;
     }
+    buildTopologyCamerasFromSettings() {
+        const value = this.storageSettings.values.trackedCameras;
+        const cameraIds = Array.isArray(value)
+            ? value.filter(Boolean)
+            : typeof value === 'string' && value.length
+                ? [value]
+                : [];
+        return cameraIds.map((deviceId) => {
+            const device = systemManager.getDeviceById(deviceId);
+            return {
+                deviceId,
+                nativeId: device?.nativeId || deviceId,
+                name: device?.name || deviceId,
+                isEntryPoint: false,
+                isExitPoint: false,
+                trackClasses: [],
+            };
+        });
+    }
 }
 exports.SpatialAwarenessPlugin = SpatialAwarenessPlugin;
 exports["default"] = SpatialAwarenessPlugin;
@@ -42034,6 +42401,8 @@ class TrackingState {
     changeCallbacks = [];
     storage;
     console;
+    persistTimer = null;
+    persistDebounceMs = 2000;
     constructor(storage, console) {
         this.storage = storage;
         this.console = console;
@@ -42063,7 +42432,7 @@ class TrackingState {
         }
         this.objects.set(object.globalId, object);
         this.notifyChange();
-        this.persistState();
+        this.schedulePersist();
     }
     /** Add a new sighting to an existing tracked object */
     addSighting(globalId, sighting) {
@@ -42077,7 +42446,7 @@ class TrackingState {
         }
         this.objectsByCamera.get(sighting.cameraId).add(globalId);
         this.notifyChange();
-        this.persistState();
+        this.schedulePersist();
         return true;
     }
     /** Add a journey segment (cross-camera transition) */
@@ -42093,7 +42462,7 @@ class TrackingState {
         }
         this.objectsByCamera.get(segment.toCameraId).add(globalId);
         this.notifyChange();
-        this.persistState();
+        this.schedulePersist();
         return true;
     }
     /** Get object by global ID */
@@ -42138,7 +42507,7 @@ class TrackingState {
                 set.delete(globalId);
             }
             this.notifyChange();
-            this.persistState();
+            this.schedulePersist();
         }
     }
     /** Mark object as lost (not seen for too long) */
@@ -42152,7 +42521,7 @@ class TrackingState {
                 set.delete(globalId);
             }
             this.notifyChange();
-            this.persistState();
+            this.schedulePersist();
         }
     }
     /** Update object to pending state (waiting for correlation) */
@@ -42208,6 +42577,15 @@ class TrackingState {
             this.console.error('Failed to persist tracking state:', e);
         }
     }
+    schedulePersist() {
+        if (this.persistTimer) {
+            clearTimeout(this.persistTimer);
+        }
+        this.persistTimer = setTimeout(() => {
+            this.persistTimer = null;
+            this.persistState();
+        }, this.persistDebounceMs);
+    }
     loadPersistedState() {
         try {
             const json = this.storage.getItem('tracked-objects');