@blueharford/scrypted-spatial-awareness 0.4.7 → 0.4.8-beta.1

package/out/main.nodejs.js

@@ -34499,25 +34499,31 @@ class AlertManager {
     getNotificationTitle(alert) {
         const prefix = alert.severity === 'critical' ? '🚨 ' :
             alert.severity === 'warning' ? '⚠️ ' : '';
+        // Use object class in title
+        const objectType = alert.details.objectClass
+            ? alert.details.objectClass.charAt(0).toUpperCase() + alert.details.objectClass.slice(1)
+            : 'Object';
         switch (alert.type) {
             case 'property_entry':
-                return `${prefix}🚶 Entry Detected`;
+                return `${prefix}${objectType} Arrived`;
             case 'property_exit':
-                return `${prefix}🚶 Exit Detected`;
+                return `${prefix}${objectType} Left`;
             case 'movement':
-                return `${prefix}🚶 Movement Detected`;
+                // Include destination in title
+                const dest = alert.details.toCameraName || 'area';
+                return `${prefix}${objectType} → ${dest}`;
             case 'unusual_path':
-                return `${prefix}Unusual Path`;
+                return `${prefix}Unusual Route`;
             case 'dwell_time':
-                return `${prefix}⏱️ Extended Presence`;
+                return `${prefix}${objectType} Lingering`;
             case 'restricted_zone':
-                return `${prefix}Restricted Zone Alert`;
+                return `${prefix}Restricted Zone!`;
             case 'lost_tracking':
-                return `${prefix}Lost Tracking`;
+                return `${prefix}${objectType} Lost`;
             case 'reappearance':
-                return `${prefix}Object Reappeared`;
+                return `${prefix}${objectType} Reappeared`;
             default:
-                return `${prefix}Spatial Awareness Alert`;
+                return `${prefix}Spatial Alert`;
         }
     }
     /**
@@ -34751,8 +34757,20 @@ class ObjectCorrelator {
                 candidates.push(candidate);
             }
         }
-        if (candidates.length === 0)
+        if (candidates.length === 0) {
+            // No candidates above threshold - try to find best match with relaxed criteria
+            // This helps when there's only one object of this class active
+            const sameClassObjects = activeObjects.filter(o => o.className === sighting.detection.className);
+            if (sameClassObjects.length === 1) {
+                // Only one object of this class - likely the same one
+                const candidate = await this.evaluateCandidate(sameClassObjects[0], sighting);
+                // Accept with lower threshold if timing is reasonable
+                if (candidate.confidence >= 0.3 && candidate.factors.timing > 0) {
+                    return candidate;
+                }
+            }
             return null;
+        }
         // Sort by confidence (highest first)
         candidates.sort((a, b) => b.confidence - a.confidence);
         // Return best match
@@ -34815,14 +34833,32 @@ class ObjectCorrelator {
         if (lastSighting.cameraId === sighting.cameraId) {
             return 1.0;
         }
+        // Calculate transit time first
+        const transitTime = sighting.timestamp - lastSighting.timestamp;
         // Find connection between cameras
         const connection = (0, topology_1.findConnection)(this.topology, lastSighting.cameraId, sighting.cameraId);
         if (!connection) {
-            // No defined connection - low score but not zero
-            // (allows for uncharted paths)
-            return 0.2;
+            // No defined connection - still allow correlation based on reasonable timing
+            // Allow up to 5 minutes transit between any cameras (property could be large)
+            const MAX_UNCHARTED_TRANSIT = 300000; // 5 minutes
+            if (transitTime > 0 && transitTime < MAX_UNCHARTED_TRANSIT) {
+                // Score based on how reasonable the timing is
+                // Give higher base score for reasonable transits (encourages matching)
+                if (transitTime < 60000) {
+                    // Under 1 minute - very likely same object
+                    return 0.9;
+                }
+                else if (transitTime < 120000) {
+                    // Under 2 minutes - probably same object
+                    return 0.7;
+                }
+                else {
+                    // 2-5 minutes - possible but less certain
+                    return Math.max(0.4, 0.7 - (transitTime - 120000) / 180000 * 0.3);
+                }
+            }
+            return 0.3; // Even long transits get some credit
         }
-        const transitTime = sighting.timestamp - lastSighting.timestamp;
         const { min, typical, max } = connection.transitTime;
         // Way outside range
         if (transitTime < min * 0.5 || transitTime > max * 2) {
@@ -34878,7 +34914,8 @@ class ObjectCorrelator {
         // Find connection
         const connection = (0, topology_1.findConnection)(this.topology, lastSighting.cameraId, sighting.cameraId);
         if (!connection) {
-            return 0.3; // No connection defined
+            // No connection defined - give neutral score (don't penalize)
+            return 0.5;
         }
         let score = 0;
         // Check if last detection was in/near exit zone
@@ -35021,42 +35058,12 @@ exports.ObjectCorrelator = ObjectCorrelator;
  * Uses RAG (Retrieval Augmented Generation) to provide rich contextual understanding
  * of movement across the property topology
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.SpatialReasoningEngine = void 0;
-const sdk_1 = __importStar(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
+const sdk_1 = __importDefault(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
 const topology_1 = __webpack_require__(/*! ../models/topology */ "./src/models/topology.ts");
 const { systemManager } = sdk_1.default;
 class SpatialReasoningEngine {
@@ -35276,29 +35283,185 @@ class SpatialReasoningEngine {
         }
         return relevant;
     }
-    /** Find or initialize LLM device */
+    llmSearched = false;
+    llmProvider = null;
+    /** Find or initialize LLM device - looks for ChatCompletion interface from @scrypted/llm plugin */
     async findLlmDevice() {
         if (this.llmDevice)
             return this.llmDevice;
+        if (this.llmSearched)
+            return null; // Already searched and found nothing
+        this.llmSearched = true;
         try {
+            // Look for devices with ChatCompletion interface (the correct interface for @scrypted/llm)
             for (const id of Object.keys(systemManager.getSystemState())) {
                 const device = systemManager.getDeviceById(id);
-                if (device?.interfaces?.includes(sdk_1.ScryptedInterface.ObjectDetection)) {
-                    const name = device.name?.toLowerCase() || '';
-                    if (name.includes('llm') || name.includes('gpt') || name.includes('claude') ||
-                        name.includes('ollama') || name.includes('gemini')) {
-                        this.llmDevice = device;
-                        this.console.log(`Found LLM device: ${device.name}`);
-                        return this.llmDevice;
+                if (!device)
+                    continue;
+                // Check if this device has ChatCompletion interface
+                // The @scrypted/llm plugin exposes ChatCompletion, not ObjectDetection
+                if (device.interfaces?.includes('ChatCompletion')) {
+                    const deviceName = device.name?.toLowerCase() || '';
+                    const pluginId = device.pluginId?.toLowerCase() || '';
+                    // Identify the provider type for logging
+                    let providerType = 'Unknown';
+                    if (pluginId.includes('@scrypted/llm') || pluginId.includes('llm')) {
+                        providerType = 'Scrypted LLM';
                     }
+                    if (deviceName.includes('openai') || deviceName.includes('gpt')) {
+                        providerType = 'OpenAI';
+                    }
+                    else if (deviceName.includes('anthropic') || deviceName.includes('claude')) {
+                        providerType = 'Anthropic';
+                    }
+                    else if (deviceName.includes('ollama')) {
+                        providerType = 'Ollama';
+                    }
+                    else if (deviceName.includes('gemini') || deviceName.includes('google')) {
+                        providerType = 'Google';
+                    }
+                    else if (deviceName.includes('llama')) {
+                        providerType = 'llama.cpp';
+                    }
+                    this.llmDevice = device;
+                    this.llmProvider = `${providerType} (${device.name})`;
+                    this.console.log(`[LLM] Connected to ${providerType}: ${device.name}`);
+                    this.console.log(`[LLM] Plugin: ${pluginId || 'N/A'}`);
+                    this.console.log(`[LLM] Interfaces: ${device.interfaces?.join(', ')}`);
+                    return this.llmDevice;
                 }
             }
+            // If we get here, no LLM plugin found
+            this.console.warn('[LLM] No ChatCompletion device found. Install @scrypted/llm for enhanced descriptions.');
+            this.console.warn('[LLM] Falling back to rule-based descriptions using topology data.');
         }
         catch (e) {
-            this.console.warn('Error finding LLM device:', e);
+            this.console.error('[LLM] Error searching for LLM device:', e);
         }
         return null;
     }
+    /** Get the current LLM provider name */
+    getLlmProvider() {
+        return this.llmProvider;
+    }
+    /** Check if LLM is available */
+    isLlmAvailable() {
+        return this.llmDevice !== null;
+    }
+    /** Generate entry description when object enters property */
+    generateEntryDescription(tracked, cameraId) {
+        if (!this.topology) {
+            return {
+                description: `${this.capitalizeFirst(tracked.className)} entered property`,
+                involvedLandmarks: [],
+                confidence: 0.5,
+                usedLlm: false,
+            };
+        }
+        const camera = (0, topology_1.findCamera)(this.topology, cameraId);
+        if (!camera) {
+            return {
+                description: `${this.capitalizeFirst(tracked.className)} entered property`,
+                involvedLandmarks: [],
+                confidence: 0.5,
+                usedLlm: false,
+            };
+        }
+        const landmarks = (0, topology_1.getLandmarksVisibleFromCamera)(this.topology, cameraId);
+        const objectType = this.capitalizeFirst(tracked.className);
+        // Build entry description using topology context
+        const location = this.describeLocation(camera, landmarks, 'to');
+        // Check if we can determine where they came from (e.g., street, neighbor)
+        const entryLandmark = landmarks.find(l => l.isEntryPoint);
+        const streetLandmark = landmarks.find(l => l.type === 'street');
+        const neighborLandmark = landmarks.find(l => l.type === 'neighbor');
+        let source = '';
+        if (streetLandmark) {
+            source = ` from ${streetLandmark.name}`;
+        }
+        else if (neighborLandmark) {
+            source = ` from ${neighborLandmark.name}`;
+        }
+        return {
+            description: `${objectType} arrived at ${location}${source}`,
+            involvedLandmarks: landmarks,
+            confidence: 0.8,
+            usedLlm: false,
+        };
+    }
+    /** Generate exit description when object leaves property */
+    generateExitDescription(tracked, cameraId) {
+        if (!this.topology) {
+            return {
+                description: `${this.capitalizeFirst(tracked.className)} left property`,
+                involvedLandmarks: [],
+                confidence: 0.5,
+                usedLlm: false,
+            };
+        }
+        const camera = (0, topology_1.findCamera)(this.topology, cameraId);
+        if (!camera) {
+            return {
+                description: `${this.capitalizeFirst(tracked.className)} left property`,
+                involvedLandmarks: [],
+                confidence: 0.5,
+                usedLlm: false,
+            };
+        }
+        const landmarks = (0, topology_1.getLandmarksVisibleFromCamera)(this.topology, cameraId);
+        const objectType = this.capitalizeFirst(tracked.className);
+        // Build exit description
+        const location = this.describeLocation(camera, landmarks, 'from');
+        // Check for exit point landmarks
+        const exitLandmark = landmarks.find(l => l.isExitPoint);
+        const streetLandmark = landmarks.find(l => l.type === 'street');
+        let destination = '';
+        if (streetLandmark) {
+            destination = ` towards ${streetLandmark.name}`;
+        }
+        else if (exitLandmark) {
+            destination = ` via ${exitLandmark.name}`;
+        }
+        // Include time on property if available
+        const dwellTime = Math.round((tracked.lastSeen - tracked.firstSeen) / 1000);
+        let timeContext = '';
+        if (dwellTime > 60) {
+            timeContext = ` after ${Math.round(dwellTime / 60)}m on property`;
+        }
+        else if (dwellTime > 10) {
+            timeContext = ` after ${dwellTime}s`;
+        }
+        // Summarize journey if they visited multiple cameras (use landmarks from topology)
+        let journeyContext = '';
+        if (tracked.journey.length > 0 && this.topology) {
+            const visitedLandmarks = [];
+            // Get landmarks from entry camera
+            if (tracked.entryCamera) {
+                const entryLandmarks = (0, topology_1.getLandmarksVisibleFromCamera)(this.topology, tracked.entryCamera);
+                const entryLandmark = entryLandmarks.find(l => l.isEntryPoint || l.type === 'access') || entryLandmarks[0];
+                if (entryLandmark) {
+                    visitedLandmarks.push(entryLandmark.name);
+                }
+            }
+            // Get landmarks from journey segments
+            for (const segment of tracked.journey) {
+                const segmentLandmarks = (0, topology_1.getLandmarksVisibleFromCamera)(this.topology, segment.toCameraId);
+                const segmentLandmark = segmentLandmarks.find(l => !visitedLandmarks.includes(l.name) && (l.type === 'access' || l.type === 'zone' || l.type === 'structure'));
+                if (segmentLandmark && !visitedLandmarks.includes(segmentLandmark.name)) {
+                    visitedLandmarks.push(segmentLandmark.name);
+                }
+            }
+            if (visitedLandmarks.length > 1) {
+                journeyContext = ` — visited ${visitedLandmarks.join(' → ')}`;
+            }
+        }
+        return {
+            description: `${objectType} left ${location}${destination}${timeContext}${journeyContext}`,
+            involvedLandmarks: landmarks,
+            confidence: 0.8,
+            usedLlm: false,
+        };
+    }
     /** Generate rich movement description using LLM */
     async generateMovementDescription(tracked, fromCameraId, toCameraId, transitTime, mediaObject) {
         if (!this.topology) {
@@ -35350,27 +35513,78 @@ class SpatialReasoningEngine {
     buildBasicDescription(tracked, fromCamera, toCamera, transitTime, fromLandmarks, toLandmarks) {
         const objectType = this.capitalizeFirst(tracked.className);
         const transitSecs = Math.round(transitTime / 1000);
-        // Build origin description
-        let origin = fromCamera.name;
-        if (fromLandmarks.length > 0) {
-            const nearLandmark = fromLandmarks[0];
-            origin = `near ${nearLandmark.name}`;
+        // Get connection for path context
+        const connection = this.topology ? (0, topology_1.findConnection)(this.topology, fromCamera.deviceId, toCamera.deviceId) : null;
+        // Build origin description using landmarks, camera context, or camera name
+        let origin = this.describeLocation(fromCamera, fromLandmarks, 'from');
+        // Build destination description
+        let destination = this.describeLocation(toCamera, toLandmarks, 'to');
+        // Check if we have a named path/connection
+        let pathContext = '';
+        if (connection?.name) {
+            pathContext = ` via ${connection.name}`;
+        }
+        else if (connection?.pathLandmarks?.length && this.topology) {
+            const pathNames = connection.pathLandmarks
+                .map(id => (0, topology_1.findLandmark)(this.topology, id)?.name)
+                .filter(Boolean);
+            if (pathNames.length > 0) {
+                pathContext = ` past ${pathNames.join(' and ')}`;
+            }
+        }
+        // Include journey context if this is not the first camera
+        let journeyContext = '';
+        if (tracked.journey.length > 0) {
+            const totalTime = Math.round((Date.now() - tracked.firstSeen) / 1000);
+            if (totalTime > 60) {
+                journeyContext = ` (${Math.round(totalTime / 60)}m on property)`;
+            }
         }
-        else if (fromCamera.context?.coverageDescription) {
-            origin = fromCamera.context.coverageDescription.split('.')[0];
+        // Determine movement verb based on transit time and object type
+        const verb = this.getMovementVerb(tracked.className, transitSecs);
+        return `${objectType} ${verb} ${origin} heading ${destination}${pathContext}${journeyContext}`;
+    }
+    /** Describe a location using landmarks, camera context, or camera name */
+    describeLocation(camera, landmarks, direction) {
+        // Priority 1: Use entry/exit landmarks
+        const entryExitLandmark = landmarks.find(l => (direction === 'from' && l.isExitPoint) || (direction === 'to' && l.isEntryPoint));
+        if (entryExitLandmark) {
+            return direction === 'from' ? `the ${entryExitLandmark.name}` : `the ${entryExitLandmark.name}`;
         }
-        // Build destination description
-        let destination = toCamera.name;
-        if (toLandmarks.length > 0) {
-            const nearLandmark = toLandmarks[0];
-            destination = `towards ${nearLandmark.name}`;
+        // Priority 2: Use access landmarks (driveway, walkway, etc.)
+        const accessLandmark = landmarks.find(l => l.type === 'access');
+        if (accessLandmark) {
+            return `the ${accessLandmark.name}`;
         }
-        else if (toCamera.context?.coverageDescription) {
-            destination = `towards ${toCamera.context.coverageDescription.split('.')[0]}`;
+        // Priority 3: Use zone landmarks (front yard, back yard)
+        const zoneLandmark = landmarks.find(l => l.type === 'zone');
+        if (zoneLandmark) {
+            return `the ${zoneLandmark.name}`;
         }
-        // Build transit string
-        const transitStr = transitSecs > 0 ? ` (${transitSecs}s)` : '';
-        return `${objectType} moving from ${origin} ${destination}${transitStr}`;
+        // Priority 4: Use any landmark
+        if (landmarks.length > 0) {
+            return `near ${landmarks[0].name}`;
+        }
+        // Priority 5: Use camera coverage description
+        if (camera.context?.coverageDescription) {
+            const desc = camera.context.coverageDescription.split('.')[0].toLowerCase();
+            return `the ${desc}`;
+        }
+        // Fallback: Generic description (no camera name inference - use topology for context)
+        return direction === 'from' ? 'property' : 'property';
+    }
+    /** Get appropriate movement verb based on context */
+    getMovementVerb(className, transitSecs) {
+        if (className === 'car' || className === 'vehicle' || className === 'truck') {
+            return transitSecs < 10 ? 'driving from' : 'moved from';
+        }
+        if (transitSecs < 5) {
+            return 'walking from';
+        }
+        if (transitSecs < 30) {
+            return 'moved from';
+        }
+        return 'traveled from';
     }
     /** Build path description from connection */
     buildPathDescription(fromCamera, toCamera) {
@@ -35389,10 +35603,10 @@ class SpatialReasoningEngine {
         }
         return connection.name || undefined;
     }
-    /** Get LLM-enhanced description */
+    /** Get LLM-enhanced description using ChatCompletion interface */
     async getLlmEnhancedDescription(tracked, fromCamera, toCamera, transitTime, fromLandmarks, toLandmarks, mediaObject) {
         const llm = await this.findLlmDevice();
-        if (!llm)
+        if (!llm || !llm.getChatCompletion)
             return null;
         try {
             // Retrieve relevant context for RAG
@@ -35401,13 +35615,21 @@ class SpatialReasoningEngine {
             const ragContext = relevantChunks.map(c => c.content).join('\n\n');
             // Build the prompt
             const prompt = this.buildLlmPrompt(tracked, fromCamera, toCamera, transitTime, fromLandmarks, toLandmarks, ragContext);
-            // Call LLM
-            const result = await llm.detectObjects(mediaObject, {
-                settings: { prompt }
+            // Call LLM using ChatCompletion interface
+            const result = await llm.getChatCompletion({
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+                max_tokens: 150,
+                temperature: 0.7,
             });
-            // Extract description from result
-            if (result.detections?.[0]?.label) {
-                return result.detections[0].label;
+            // Extract description from ChatCompletion result
+            const content = result?.choices?.[0]?.message?.content;
+            if (content && typeof content === 'string') {
+                return content.trim();
             }
             return null;
         }
@@ -35444,12 +35666,12 @@ Examples of good descriptions:
 
 Generate ONLY the description, nothing else:`;
     }
-    /** Suggest a new landmark based on AI analysis */
+    /** Suggest a new landmark based on AI analysis using ChatCompletion */
     async suggestLandmark(cameraId, mediaObject, objectClass, position) {
         if (!this.config.enableLandmarkLearning)
             return null;
         const llm = await this.findLlmDevice();
-        if (!llm)
+        if (!llm || !llm.getChatCompletion)
             return null;
         try {
             const prompt = `Analyze this security camera image. A ${objectClass} was detected.
@@ -35464,12 +35686,21 @@ If you can identify a clear landmark feature, respond with ONLY a JSON object:
 {"name": "Landmark Name", "type": "structure|feature|boundary|access|vehicle|neighbor|zone|street", "description": "Brief description"}
 
 If no clear landmark is identifiable, respond with: {"name": null}`;
-            const result = await llm.detectObjects(mediaObject, {
-                settings: { prompt }
+            // Call LLM using ChatCompletion interface
+            const result = await llm.getChatCompletion({
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+                max_tokens: 100,
+                temperature: 0.3,
             });
-            if (result.detections?.[0]?.label) {
+            const content = result?.choices?.[0]?.message?.content;
+            if (content && typeof content === 'string') {
                 try {
-                    const parsed = JSON.parse(result.detections[0].label);
+                    const parsed = JSON.parse(content.trim());
                     if (parsed.name && parsed.type) {
                         const suggestionId = `suggest_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
                         const suggestion = {
@@ -35947,24 +36178,52 @@ class TrackingEngine {
             const tracked = this.state.createObject(globalId, sighting, isEntryPoint);
             this.console.log(`New ${sighting.detection.className} detected on ${sighting.cameraName} ` +
                 `(ID: ${globalId.slice(0, 8)})`);
-            // Generate entry alert if this is an entry point
-            // Entry alerts also respect loitering threshold and cooldown
-            if (isEntryPoint && this.passesLoiteringThreshold(tracked) && !this.isInAlertCooldown(globalId)) {
-                // Get spatial reasoning for entry event
-                const spatialResult = await this.getSpatialDescription(tracked, 'outside', // Virtual "outside" location for entry
-                sighting.cameraId, 0, sighting.cameraId);
+            // Schedule loitering check - alert after object passes loitering threshold
+            // This ensures we don't miss alerts for brief appearances while still filtering noise
+            this.scheduleLoiteringAlert(globalId, sighting, isEntryPoint);
+        }
+    }
+    /** Schedule an alert after loitering threshold passes */
+    scheduleLoiteringAlert(globalId, sighting, isEntryPoint) {
+        // 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;
+            // Generate spatial description
+            const spatialResult = this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId);
+            if (isEntryPoint) {
+                // Entry point - generate property entry alert
                 await this.alertManager.checkAndAlert('property_entry', tracked, {
                     cameraId: sighting.cameraId,
                     cameraName: sighting.cameraName,
                     objectClass: sighting.detection.className,
-                    objectLabel: spatialResult?.description || sighting.detection.label,
+                    objectLabel: spatialResult.description,
                     detectionId: sighting.detectionId,
-                    involvedLandmarks: spatialResult?.involvedLandmarks?.map(l => l.name),
-                    usedLlm: spatialResult?.usedLlm,
+                    involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
+                    usedLlm: spatialResult.usedLlm,
                 });
-                this.recordAlertTime(globalId);
             }
-        }
+            else {
+                // Non-entry point - still alert about activity using movement alert type
+                // This notifies about any activity around the property using topology context
+                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, // Use spatial reasoning description (topology-based)
+                    detectionId: sighting.detectionId,
+                    involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
+                    usedLlm: spatialResult.usedLlm,
+                });
+            }
+            this.recordAlertTime(globalId);
+        }, this.config.loiteringThreshold);
     }
     /** Attempt to correlate a sighting with existing tracked objects */
     async correlateDetection(sighting) {
@@ -36010,12 +36269,16 @@ class TrackingEngine {
             const current = this.state.getObject(tracked.globalId);
             if (current && current.state === 'pending') {
                 this.state.markExited(tracked.globalId, sighting.cameraId, sighting.cameraName);
-                this.console.log(`Object ${tracked.globalId.slice(0, 8)} exited via ${sighting.cameraName}`);
+                // Generate rich exit description using topology context
+                const spatialResult = this.spatialReasoning.generateExitDescription(current, sighting.cameraId);
+                this.console.log(`Object ${tracked.globalId.slice(0, 8)} exited: ${spatialResult.description}`);
                 await this.alertManager.checkAndAlert('property_exit', current, {
                     cameraId: sighting.cameraId,
                     cameraName: sighting.cameraName,
                     objectClass: current.className,
-                    objectLabel: current.label,
+                    objectLabel: spatialResult.description,
+                    involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
+                    usedLlm: spatialResult.usedLlm,
                 });
             }
             this.pendingTimers.delete(tracked.globalId);
@@ -37450,6 +37713,8 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.SpatialAwarenessPlugin = void 0;
 const sdk_1 = __importStar(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
 const storage_settings_1 = __webpack_require__(/*! @scrypted/sdk/storage-settings */ "./node_modules/@scrypted/sdk/dist/src/storage-settings.js");
+const fs = __importStar(__webpack_require__(/*! fs */ "fs"));
+const path = __importStar(__webpack_require__(/*! path */ "path"));
 const topology_1 = __webpack_require__(/*! ./models/topology */ "./src/models/topology.ts");
 const alert_1 = __webpack_require__(/*! ./models/alert */ "./src/models/alert.ts");
 const tracking_state_1 = __webpack_require__(/*! ./state/tracking-state */ "./src/state/tracking-state.ts");
@@ -37460,7 +37725,7 @@ const tracking_zone_1 = __webpack_require__(/*! ./devices/tracking-zone */ "./sr
 const mqtt_publisher_1 = __webpack_require__(/*! ./integrations/mqtt-publisher */ "./src/integrations/mqtt-publisher.ts");
 const editor_html_1 = __webpack_require__(/*! ./ui/editor-html */ "./src/ui/editor-html.ts");
 const training_html_1 = __webpack_require__(/*! ./ui/training-html */ "./src/ui/training-html.ts");
-const { deviceManager, systemManager } = sdk_1.default;
+const { deviceManager, systemManager, mediaManager } = sdk_1.default;
 const TRACKING_ZONE_PREFIX = 'tracking-zone:';
 const GLOBAL_TRACKER_ID = 'global-tracker';
 class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
@@ -37494,8 +37759,8 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         correlationThreshold: {
             title: 'Correlation Confidence Threshold',
             type: 'number',
-            defaultValue: 0.6,
-            description: 'Minimum confidence (0-1) for automatic object correlation',
+            defaultValue: 0.35,
+            description: 'Minimum confidence (0-1) for automatic object correlation. Lower values allow more matches.',
             group: 'Tracking',
         },
         lostTimeout: {
@@ -37722,7 +37987,7 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         }
         const config = {
             correlationWindow: (this.storageSettings.values.correlationWindow || 30) * 1000,
-            correlationThreshold: this.storageSettings.values.correlationThreshold || 0.6,
+            correlationThreshold: this.storageSettings.values.correlationThreshold || 0.35,
             lostTimeout: (this.storageSettings.values.lostTimeout || 300) * 1000,
             useVisualMatching: this.storageSettings.values.useVisualMatching ?? true,
             loiteringThreshold: (this.storageSettings.values.loiteringThreshold || 3) * 1000,
@@ -38373,15 +38638,37 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             });
         }
     }
-    handleFloorPlanRequest(request, response) {
+    async getFloorPlanPath() {
+        // Use mediaManager.getFilesPath() for proper persistent storage
+        const filesPath = await mediaManager.getFilesPath();
+        this.console.log('Files path from mediaManager:', filesPath);
+        // Ensure directory exists
+        if (!fs.existsSync(filesPath)) {
+            fs.mkdirSync(filesPath, { recursive: true });
+        }
+        return path.join(filesPath, 'floorplan.jpg');
+    }
+    async handleFloorPlanRequest(request, response) {
         if (request.method === 'GET') {
-            const imageData = this.storage.getItem('floorPlanImage');
-            if (imageData) {
-                response.send(JSON.stringify({ imageData }), {
-                    headers: { 'Content-Type': 'application/json' },
-                });
+            try {
+                const floorPlanPath = await this.getFloorPlanPath();
+                this.console.log('Loading floor plan from:', floorPlanPath, 'exists:', fs.existsSync(floorPlanPath));
+                if (fs.existsSync(floorPlanPath)) {
+                    const imageBuffer = fs.readFileSync(floorPlanPath);
+                    const imageData = 'data:image/jpeg;base64,' + imageBuffer.toString('base64');
+                    this.console.log('Floor plan loaded, size:', imageBuffer.length);
+                    response.send(JSON.stringify({ imageData }), {
+                        headers: { 'Content-Type': 'application/json' },
+                    });
+                }
+                else {
+                    response.send(JSON.stringify({ imageData: null }), {
+                        headers: { 'Content-Type': 'application/json' },
+                    });
+                }
             }
-            else {
+            catch (e) {
+                this.console.error('Failed to read floor plan:', e);
                 response.send(JSON.stringify({ imageData: null }), {
                     headers: { 'Content-Type': 'application/json' },
                 });
@@ -38390,14 +38677,21 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         else if (request.method === 'POST') {
             try {
                 const body = JSON.parse(request.body);
-                this.storage.setItem('floorPlanImage', body.imageData);
+                const imageData = body.imageData;
+                // Extract base64 data (remove data:image/xxx;base64, prefix)
+                const base64Data = imageData.replace(/^data:image\/\w+;base64,/, '');
+                const imageBuffer = Buffer.from(base64Data, 'base64');
+                const floorPlanPath = await this.getFloorPlanPath();
+                fs.writeFileSync(floorPlanPath, imageBuffer);
+                this.console.log('Floor plan saved to:', floorPlanPath, 'size:', imageBuffer.length);
                 response.send(JSON.stringify({ success: true }), {
                     headers: { 'Content-Type': 'application/json' },
                 });
             }
             catch (e) {
-                response.send(JSON.stringify({ error: 'Invalid request body' }), {
-                    code: 400,
+                this.console.error('Failed to save floor plan:', e);
+                response.send(JSON.stringify({ error: 'Failed to save floor plan' }), {
+                    code: 500,
                     headers: { 'Content-Type': 'application/json' },
                 });
             }
@@ -39031,26 +39325,53 @@ function generateAlertMessage(type, details) {
         : capitalize(details.objectClass || '');
     switch (type) {
         case 'property_entry':
-            return `${objectDesc} entered property via ${details.cameraName || 'unknown camera'}`;
+            // Use the rich description from spatial reasoning if available
+            if (details.objectLabel && details.objectLabel !== details.objectClass) {
+                return details.objectLabel;
+            }
+            // Fallback to basic description
+            if (details.involvedLandmarks && details.involvedLandmarks.length > 0) {
+                return `${objectDesc} entered property near ${details.involvedLandmarks[0]}`;
+            }
+            return `${objectDesc} entered property at ${details.cameraName || 'entrance'}`;
         case 'property_exit':
-            return `${objectDesc} exited property via ${details.cameraName || 'unknown camera'}`;
+            // Use the rich description from spatial reasoning if available
+            if (details.objectLabel && details.objectLabel !== details.objectClass) {
+                return details.objectLabel;
+            }
+            // Fallback to basic description
+            if (details.involvedLandmarks && details.involvedLandmarks.length > 0) {
+                return `${objectDesc} left property via ${details.involvedLandmarks[0]}`;
+            }
+            return `${objectDesc} left property`;
         case 'movement':
-            // If we have a rich description from LLM/RAG, use it
-            if (details.objectLabel && details.usedLlm) {
+            // If objectLabel contains a full description, use it directly
+            if (details.objectLabel && details.objectLabel !== details.objectClass) {
+                // Check if this is a cross-camera movement or initial detection
+                if (details.fromCameraId && details.fromCameraId !== details.toCameraId && details.transitTime) {
+                    const transitSecs = Math.round(details.transitTime / 1000);
+                    const transitStr = transitSecs > 0 ? ` (${transitSecs}s)` : '';
+                    const pathContext = details.pathDescription ? ` via ${details.pathDescription}` : '';
+                    return `${details.objectLabel}${pathContext}${transitStr}`;
+                }
+                // Initial detection - use the label directly
+                return details.objectLabel;
+            }
+            // Cross-camera movement with basic info
+            if (details.fromCameraId && details.fromCameraId !== details.toCameraId) {
                 const transitSecs = details.transitTime ? Math.round(details.transitTime / 1000) : 0;
-                const transitStr = transitSecs > 0 ? ` (${transitSecs}s)` : '';
-                // Include path/landmark context if available
-                const pathContext = details.pathDescription ? ` via ${details.pathDescription}` : '';
-                return `${details.objectLabel}${pathContext}${transitStr}`;
-            }
-            // Fallback to basic message with landmark info
-            const transitSecs = details.transitTime ? Math.round(details.transitTime / 1000) : 0;
-            const transitStr = transitSecs > 0 ? ` (${transitSecs}s transit)` : '';
-            let movementDesc = `${objectDesc} moving from ${details.fromCameraName || 'unknown'} towards ${details.toCameraName || 'unknown'}`;
+                const transitStr = transitSecs > 0 ? ` (${transitSecs}s transit)` : '';
+                let movementDesc = `${objectDesc} moving from ${details.fromCameraName || 'unknown'} towards ${details.toCameraName || 'unknown'}`;
+                if (details.involvedLandmarks && details.involvedLandmarks.length > 0) {
+                    movementDesc += ` near ${details.involvedLandmarks.join(', ')}`;
+                }
+                return `${movementDesc}${transitStr}`;
+            }
+            // Initial detection without full label
             if (details.involvedLandmarks && details.involvedLandmarks.length > 0) {
-                movementDesc += ` near ${details.involvedLandmarks.join(', ')}`;
+                return `${objectDesc} detected near ${details.involvedLandmarks[0]}`;
             }
-            return `${movementDesc}${transitStr}`;
+            return `${objectDesc} detected at ${details.cameraName || 'camera'}`;
         case 'unusual_path':
             return `${objectDesc} took unusual path: ${details.actualPath || 'unknown'}`;
         case 'dwell_time':
@@ -40120,10 +40441,27 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
         if (response.ok) {
           topology = await response.json();
           if (!topology.drawings) topology.drawings = [];
+          // Load floor plan from separate storage (handles legacy imageData in topology too)
           if (topology.floorPlan?.imageData) {
+            // Legacy: imageData was stored in topology
             await loadFloorPlanImage(topology.floorPlan.imageData);
           } else if (topology.floorPlan?.type === 'blank') {
             blankCanvasMode = true;
+          } else {
+            // Always try to load from floor-plan endpoint (handles uploaded and missing cases)
+            try {
+              const fpResponse = await fetch('../api/floor-plan');
+              if (fpResponse.ok) {
+                const fpData = await fpResponse.json();
+                if (fpData.imageData) {
+                  await loadFloorPlanImage(fpData.imageData);
+                  // Update topology reference if not set
+                  if (!topology.floorPlan || topology.floorPlan.type !== 'uploaded') {
+                    topology.floorPlan = { type: 'uploaded', width: floorPlanImage.width, height: floorPlanImage.height };
+                  }
+                }
+              }
+            } catch (err) { console.error('Failed to load floor plan:', err); }
           }
         }
       } catch (e) { console.error('Failed to load topology:', e); }
@@ -40747,16 +41085,84 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
 
     function uploadFloorPlan() { document.getElementById('upload-modal').classList.add('active'); }
 
+    // Compress and resize image to avoid 413 errors (Scrypted has ~50KB limit)
+    function compressImage(img, maxSize = 800, quality = 0.5) {
+      return new Promise((resolve) => {
+        const canvas = document.createElement('canvas');
+        let width = img.width;
+        let height = img.height;
+
+        // Always resize to fit within maxSize
+        if (width > maxSize || height > maxSize) {
+          if (width > height) {
+            height = Math.round(height * maxSize / width);
+            width = maxSize;
+          } else {
+            width = Math.round(width * maxSize / height);
+            height = maxSize;
+          }
+        }
+
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, 0, 0, width, height);
+
+        // Convert to JPEG with aggressive compression
+        let compressed = canvas.toDataURL('image/jpeg', quality);
+        console.log('Compressed image from', img.width, 'x', img.height, 'to', width, 'x', height, 'size:', Math.round(compressed.length / 1024), 'KB');
+
+        // If still too large, compress more
+        let q = quality;
+        while (compressed.length > 50000 && q > 0.1) {
+          q -= 0.1;
+          compressed = canvas.toDataURL('image/jpeg', q);
+          console.log('Re-compressed at quality', q.toFixed(1), 'size:', Math.round(compressed.length / 1024), 'KB');
+        }
+
+        resolve(compressed);
+      });
+    }
+
     async function handleFloorPlanUpload(event) {
       const file = event.target.files[0];
       if (!file) return;
       const reader = new FileReader();
       reader.onload = async (e) => {
-        const imageData = e.target.result;
-        await loadFloorPlanImage(imageData);
-        topology.floorPlan = { imageData, width: floorPlanImage.width, height: floorPlanImage.height };
-        closeModal('upload-modal');
-        render();
+        const originalData = e.target.result;
+
+        // Load image to get dimensions
+        const img = new Image();
+        img.onload = async () => {
+          // Compress image to reduce size
+          const imageData = await compressImage(img);
+          await loadFloorPlanImage(imageData);
+
+          // Store floor plan separately via API
+          try {
+            setStatus('Uploading floor plan...', 'warning');
+            const response = await fetch('../api/floor-plan', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ imageData })
+            });
+            if (response.ok) {
+              setStatus('Floor plan saved', 'success');
+            } else {
+              setStatus('Failed to save floor plan: ' + response.status, 'error');
+              console.error('Floor plan upload failed:', response.status, response.statusText);
+            }
+          } catch (err) {
+            console.error('Failed to save floor plan:', err);
+            setStatus('Failed to save floor plan', 'error');
+          }
+
+          // Store reference in topology (without the large imageData)
+          topology.floorPlan = { type: 'uploaded', width: floorPlanImage.width, height: floorPlanImage.height };
+          closeModal('upload-modal');
+          render();
+        };
+        img.src = originalData;
       };
       reader.readAsDataURL(file);
     }
@@ -40916,7 +41322,7 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
     function updateConnectionName(id, value) { const conn = topology.connections.find(c => c.id === id); if (conn) conn.name = value; updateUI(); }
     function updateTransitTime(id, field, value) { const conn = topology.connections.find(c => c.id === id); if (conn) conn.transitTime[field] = parseInt(value) * 1000; }
     function updateConnectionBidi(id, value) { const conn = topology.connections.find(c => c.id === id); if (conn) conn.bidirectional = value; render(); }
-    function deleteCamera(id) { if (!confirm('Delete this camera?')) return; topology.cameras = topology.cameras.filter(c => c.deviceId !== id); topology.connections = topology.connections.filter(c => c.fromCameraId !== id && c.toCameraId !== id); selectedItem = null; document.getElementById('properties-panel').innerHTML = '<h3>Properties</h3><p style="color: #666;">Select a camera or connection.</p>'; updateUI(); render(); }
+    function deleteCamera(id) { if (!confirm('Delete this camera?')) return; topology.cameras = topology.cameras.filter(c => c.deviceId !== id); topology.connections = topology.connections.filter(c => c.fromCameraId !== id && c.toCameraId !== id); selectedItem = null; document.getElementById('properties-panel').innerHTML = '<h3>Properties</h3><p style="color: #666;">Select a camera or connection.</p>'; updateCameraSelects(); updateUI(); render(); }
     function deleteConnection(id) { if (!confirm('Delete this connection?')) return; topology.connections = topology.connections.filter(c => c.id !== id); selectedItem = null; document.getElementById('properties-panel').innerHTML = '<h3>Properties</h3><p style="color: #666;">Select a camera or connection.</p>'; updateUI(); render(); }
     function setTool(tool) {
       currentTool = tool;
@@ -42192,6 +42598,17 @@ module.exports = require("os");
 
 /***/ },
 
+/***/ "path"
+/*!***********************!*\
+  !*** external "path" ***!
+  \***********************/
+(module) {
+
+"use strict";
+module.exports = require("path");
+
+/***/ },
+
 /***/ "stream"
 /*!*************************!*\
   !*** external "stream" ***!