@blueharford/scrypted-spatial-awareness 0.6.31 → 0.6.33

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"
@@ -37324,7 +37453,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 +37538,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 +37560,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 +37587,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') {
@@ -37502,19 +37644,30 @@ class TrackingEngine {
         this.lastLlmCallTime = Date.now();
     }
     /** Check and record LLM call - returns false if rate limited */
-    tryLlmCall() {
+    tryLlmCall(silent = false) {
         if (!this.isLlmCallAllowed()) {
-            this.console.log('[LLM] Rate limited, skipping LLM call');
+            // Only log once per rate limit window, not every call
+            if (!silent && !this.rateLimitLogged) {
+                const remaining = Math.ceil((this.config.llmDebounceInterval || 30000) - (Date.now() - this.lastLlmCallTime)) / 1000;
+                this.console.log(`[LLM] Rate limited, ${remaining.toFixed(0)}s until next call allowed`);
+                this.rateLimitLogged = true;
+            }
             return false;
         }
+        this.rateLimitLogged = false;
         this.recordLlmCall();
         return true;
     }
+    /** Track if we've already logged rate limit message */
+    rateLimitLogged = false;
     /** 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 {
+            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');
@@ -37522,11 +37675,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
@@ -37583,6 +37734,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) {
@@ -37607,25 +37760,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
@@ -37664,58 +37836,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') {
@@ -37790,6 +37995,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) {
@@ -37833,6 +38040,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,
@@ -37842,7 +38050,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);
@@ -37859,6 +38068,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
@@ -37868,9 +38078,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;
@@ -39355,6 +39574,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',
@@ -39362,6 +39588,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',
@@ -39373,7 +39613,7 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         llmDebounceInterval: {
             title: 'LLM Rate Limit (seconds)',
             type: 'number',
-            defaultValue: 30,
+            defaultValue: 5,
             description: 'Minimum time between LLM calls to prevent API rate limiting. Increase if you get rate limit errors. (0 = no limit)',
             group: 'AI & Spatial Reasoning',
         },
@@ -39554,6 +39794,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() {
@@ -39582,23 +39823,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));
@@ -39611,10 +39854,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
@@ -39659,6 +39902,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);
@@ -39951,6 +40200,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') {
@@ -39963,6 +40215,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');
@@ -42026,6 +42283,8 @@ class TrackingState {
     changeCallbacks = [];
     storage;
     console;
+    persistTimer = null;
+    persistDebounceMs = 2000;
     constructor(storage, console) {
         this.storage = storage;
         this.console = console;
@@ -42055,7 +42314,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) {
@@ -42069,7 +42328,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) */
@@ -42085,7 +42344,7 @@ class TrackingState {
         }
         this.objectsByCamera.get(segment.toCameraId).add(globalId);
         this.notifyChange();
-        this.persistState();
+        this.schedulePersist();
         return true;
     }
     /** Get object by global ID */
@@ -42130,7 +42389,7 @@ class TrackingState {
                 set.delete(globalId);
             }
             this.notifyChange();
-            this.persistState();
+            this.schedulePersist();
         }
     }
     /** Mark object as lost (not seen for too long) */
@@ -42144,7 +42403,7 @@ class TrackingState {
                 set.delete(globalId);
             }
             this.notifyChange();
-            this.persistState();
+            this.schedulePersist();
         }
     }
     /** Update object to pending state (waiting for correlation) */
@@ -42200,6 +42459,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');