@blueharford/scrypted-spatial-awareness 0.1.15 → 0.2.0

package/out/main.nodejs.js

@@ -35006,6 +35006,575 @@ class ObjectCorrelator {
 exports.ObjectCorrelator = ObjectCorrelator;
 
 
+/***/ },
+
+/***/ "./src/core/spatial-reasoning.ts"
+/*!***************************************!*\
+  !*** ./src/core/spatial-reasoning.ts ***!
+  \***************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+/**
+ * Spatial Reasoning Engine
+ * 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;
+    };
+})();
+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 topology_1 = __webpack_require__(/*! ../models/topology */ "./src/models/topology.ts");
+const { systemManager } = sdk_1.default;
+class SpatialReasoningEngine {
+    config;
+    console;
+    topology = null;
+    llmDevice = null;
+    contextChunks = [];
+    topologyContextCache = null;
+    contextCacheTime = 0;
+    landmarkSuggestions = new Map();
+    constructor(config, console) {
+        this.config = config;
+        this.console = console;
+    }
+    /** Update the topology and rebuild context */
+    updateTopology(topology) {
+        this.topology = topology;
+        this.rebuildContextChunks();
+        this.topologyContextCache = null;
+        this.contextCacheTime = 0;
+    }
+    /** Build context chunks for RAG retrieval */
+    rebuildContextChunks() {
+        if (!this.topology)
+            return;
+        this.contextChunks = [];
+        // Property context
+        if (this.topology.property) {
+            this.contextChunks.push({
+                id: 'property',
+                type: 'property',
+                content: this.buildPropertyContext(),
+                metadata: { ...this.topology.property },
+            });
+        }
+        // Camera contexts
+        for (const camera of this.topology.cameras) {
+            this.contextChunks.push({
+                id: `camera_${camera.deviceId}`,
+                type: 'camera',
+                content: this.buildCameraContext(camera),
+                metadata: {
+                    deviceId: camera.deviceId,
+                    name: camera.name,
+                    isEntryPoint: camera.isEntryPoint,
+                    isExitPoint: camera.isExitPoint,
+                },
+            });
+        }
+        // Landmark contexts
+        for (const landmark of this.topology.landmarks) {
+            this.contextChunks.push({
+                id: `landmark_${landmark.id}`,
+                type: 'landmark',
+                content: this.buildLandmarkContext(landmark),
+                metadata: {
+                    id: landmark.id,
+                    name: landmark.name,
+                    type: landmark.type,
+                    isEntryPoint: landmark.isEntryPoint,
+                    isExitPoint: landmark.isExitPoint,
+                },
+            });
+        }
+        // Connection contexts
+        for (const connection of this.topology.connections) {
+            this.contextChunks.push({
+                id: `connection_${connection.id}`,
+                type: 'connection',
+                content: this.buildConnectionContext(connection),
+                metadata: {
+                    id: connection.id,
+                    fromCameraId: connection.fromCameraId,
+                    toCameraId: connection.toCameraId,
+                },
+            });
+        }
+        this.console.log(`Built ${this.contextChunks.length} context chunks for spatial reasoning`);
+    }
+    /** Build property context string */
+    buildPropertyContext() {
+        if (!this.topology?.property)
+            return '';
+        const p = this.topology.property;
+        const parts = [];
+        if (p.propertyType)
+            parts.push(`Property type: ${p.propertyType}`);
+        if (p.description)
+            parts.push(p.description);
+        if (p.frontFacing)
+            parts.push(`Front faces ${p.frontFacing}`);
+        if (p.features?.length)
+            parts.push(`Features: ${p.features.join(', ')}`);
+        return parts.join('. ');
+    }
+    /** Build camera context string */
+    buildCameraContext(camera) {
+        const parts = [`Camera: ${camera.name}`];
+        if (camera.context?.mountLocation) {
+            parts.push(`Mounted at: ${camera.context.mountLocation}`);
+        }
+        if (camera.context?.coverageDescription) {
+            parts.push(`Coverage: ${camera.context.coverageDescription}`);
+        }
+        if (camera.context?.mountHeight) {
+            parts.push(`Height: ${camera.context.mountHeight} feet`);
+        }
+        if (camera.isEntryPoint)
+            parts.push('Watches property entry point');
+        if (camera.isExitPoint)
+            parts.push('Watches property exit point');
+        // Visible landmarks
+        if (this.topology && camera.context?.visibleLandmarks?.length) {
+            const landmarkNames = camera.context.visibleLandmarks
+                .map(id => (0, topology_1.findLandmark)(this.topology, id)?.name)
+                .filter(Boolean);
+            if (landmarkNames.length) {
+                parts.push(`Can see: ${landmarkNames.join(', ')}`);
+            }
+        }
+        return parts.join('. ');
+    }
+    /** Build landmark context string */
+    buildLandmarkContext(landmark) {
+        const parts = [`${landmark.name} (${landmark.type})`];
+        if (landmark.description)
+            parts.push(landmark.description);
+        if (landmark.isEntryPoint)
+            parts.push('Property entry point');
+        if (landmark.isExitPoint)
+            parts.push('Property exit point');
+        // Adjacent landmarks
+        if (this.topology && landmark.adjacentTo?.length) {
+            const adjacentNames = landmark.adjacentTo
+                .map(id => (0, topology_1.findLandmark)(this.topology, id)?.name)
+                .filter(Boolean);
+            if (adjacentNames.length) {
+                parts.push(`Adjacent to: ${adjacentNames.join(', ')}`);
+            }
+        }
+        return parts.join('. ');
+    }
+    /** Build connection context string */
+    buildConnectionContext(connection) {
+        if (!this.topology)
+            return '';
+        const fromCamera = (0, topology_1.findCamera)(this.topology, connection.fromCameraId);
+        const toCamera = (0, topology_1.findCamera)(this.topology, connection.toCameraId);
+        if (!fromCamera || !toCamera)
+            return '';
+        const parts = [
+            `Path from ${fromCamera.name} to ${toCamera.name}`,
+        ];
+        if (connection.name)
+            parts.push(`Called: ${connection.name}`);
+        const transitSecs = Math.round(connection.transitTime.typical / 1000);
+        parts.push(`Typical transit: ${transitSecs} seconds`);
+        if (connection.bidirectional)
+            parts.push('Bidirectional path');
+        // Path landmarks
+        if (connection.pathLandmarks?.length) {
+            const landmarkNames = connection.pathLandmarks
+                .map((id) => (0, topology_1.findLandmark)(this.topology, id)?.name)
+                .filter(Boolean);
+            if (landmarkNames.length) {
+                parts.push(`Passes: ${landmarkNames.join(' → ')}`);
+            }
+        }
+        return parts.join('. ');
+    }
+    /** Get cached or generate topology description */
+    getTopologyContext() {
+        const now = Date.now();
+        if (this.topologyContextCache && (now - this.contextCacheTime) < this.config.contextCacheTtl) {
+            return this.topologyContextCache;
+        }
+        if (!this.topology)
+            return '';
+        this.topologyContextCache = (0, topology_1.generateTopologyDescription)(this.topology);
+        this.contextCacheTime = now;
+        return this.topologyContextCache;
+    }
+    /** Retrieve relevant context chunks for a movement query */
+    retrieveRelevantContext(fromCameraId, toCameraId) {
+        const relevant = [];
+        // Always include property context
+        const propertyChunk = this.contextChunks.find(c => c.type === 'property');
+        if (propertyChunk)
+            relevant.push(propertyChunk);
+        // Include both camera contexts
+        const fromChunk = this.contextChunks.find(c => c.id === `camera_${fromCameraId}`);
+        const toChunk = this.contextChunks.find(c => c.id === `camera_${toCameraId}`);
+        if (fromChunk)
+            relevant.push(fromChunk);
+        if (toChunk)
+            relevant.push(toChunk);
+        // Include direct connection if exists
+        const connectionChunk = this.contextChunks.find(c => c.type === 'connection' &&
+            ((c.metadata.fromCameraId === fromCameraId && c.metadata.toCameraId === toCameraId) ||
+                (c.metadata.fromCameraId === toCameraId && c.metadata.toCameraId === fromCameraId)));
+        if (connectionChunk)
+            relevant.push(connectionChunk);
+        // Include visible landmarks from both cameras
+        if (this.topology) {
+            const fromLandmarks = (0, topology_1.getLandmarksVisibleFromCamera)(this.topology, fromCameraId);
+            const toLandmarks = (0, topology_1.getLandmarksVisibleFromCamera)(this.topology, toCameraId);
+            const allLandmarkIds = new Set([
+                ...fromLandmarks.map(l => l.id),
+                ...toLandmarks.map(l => l.id),
+            ]);
+            for (const landmarkId of allLandmarkIds) {
+                const chunk = this.contextChunks.find(c => c.id === `landmark_${landmarkId}`);
+                if (chunk)
+                    relevant.push(chunk);
+            }
+        }
+        return relevant;
+    }
+    /** Find or initialize LLM device */
+    async findLlmDevice() {
+        if (this.llmDevice)
+            return this.llmDevice;
+        try {
+            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;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            this.console.warn('Error finding LLM device:', e);
+        }
+        return null;
+    }
+    /** Generate rich movement description using LLM */
+    async generateMovementDescription(tracked, fromCameraId, toCameraId, transitTime, mediaObject) {
+        if (!this.topology) {
+            return {
+                description: `${tracked.className} moving between cameras`,
+                involvedLandmarks: [],
+                confidence: 0.5,
+                usedLlm: false,
+            };
+        }
+        const fromCamera = (0, topology_1.findCamera)(this.topology, fromCameraId);
+        const toCamera = (0, topology_1.findCamera)(this.topology, toCameraId);
+        if (!fromCamera || !toCamera) {
+            return {
+                description: `${tracked.className} moving between cameras`,
+                involvedLandmarks: [],
+                confidence: 0.5,
+                usedLlm: false,
+            };
+        }
+        // Get involved landmarks
+        const fromLandmarks = (0, topology_1.getLandmarksVisibleFromCamera)(this.topology, fromCameraId);
+        const toLandmarks = (0, topology_1.getLandmarksVisibleFromCamera)(this.topology, toCameraId);
+        const allLandmarks = [...new Set([...fromLandmarks, ...toLandmarks])];
+        // Build basic description without LLM
+        let basicDescription = this.buildBasicDescription(tracked, fromCamera, toCamera, transitTime, fromLandmarks, toLandmarks);
+        // Try LLM for enhanced description
+        if (this.config.enableLlm && mediaObject) {
+            const llmDescription = await this.getLlmEnhancedDescription(tracked, fromCamera, toCamera, transitTime, fromLandmarks, toLandmarks, mediaObject);
+            if (llmDescription) {
+                return {
+                    description: llmDescription,
+                    involvedLandmarks: allLandmarks,
+                    pathDescription: this.buildPathDescription(fromCamera, toCamera),
+                    confidence: 0.9,
+                    usedLlm: true,
+                };
+            }
+        }
+        return {
+            description: basicDescription,
+            involvedLandmarks: allLandmarks,
+            pathDescription: this.buildPathDescription(fromCamera, toCamera),
+            confidence: 0.7,
+            usedLlm: false,
+        };
+    }
+    /** Build basic movement description without LLM */
+    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}`;
+        }
+        else if (fromCamera.context?.coverageDescription) {
+            origin = fromCamera.context.coverageDescription.split('.')[0];
+        }
+        // Build destination description
+        let destination = toCamera.name;
+        if (toLandmarks.length > 0) {
+            const nearLandmark = toLandmarks[0];
+            destination = `towards ${nearLandmark.name}`;
+        }
+        else if (toCamera.context?.coverageDescription) {
+            destination = `towards ${toCamera.context.coverageDescription.split('.')[0]}`;
+        }
+        // Build transit string
+        const transitStr = transitSecs > 0 ? ` (${transitSecs}s)` : '';
+        return `${objectType} moving from ${origin} ${destination}${transitStr}`;
+    }
+    /** Build path description from connection */
+    buildPathDescription(fromCamera, toCamera) {
+        if (!this.topology)
+            return undefined;
+        const connection = (0, topology_1.findConnection)(this.topology, fromCamera.deviceId, toCamera.deviceId);
+        if (!connection)
+            return undefined;
+        if (connection.pathLandmarks?.length) {
+            const landmarkNames = connection.pathLandmarks
+                .map(id => (0, topology_1.findLandmark)(this.topology, id)?.name)
+                .filter(Boolean);
+            if (landmarkNames.length) {
+                return `Via ${landmarkNames.join(' → ')}`;
+            }
+        }
+        return connection.name || undefined;
+    }
+    /** Get LLM-enhanced description */
+    async getLlmEnhancedDescription(tracked, fromCamera, toCamera, transitTime, fromLandmarks, toLandmarks, mediaObject) {
+        const llm = await this.findLlmDevice();
+        if (!llm)
+            return null;
+        try {
+            // Retrieve relevant context for RAG
+            const relevantChunks = this.retrieveRelevantContext(fromCamera.deviceId, toCamera.deviceId);
+            // Build RAG context
+            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 }
+            });
+            // Extract description from result
+            if (result.detections?.[0]?.label) {
+                return result.detections[0].label;
+            }
+            return null;
+        }
+        catch (e) {
+            this.console.warn('LLM description generation failed:', e);
+            return null;
+        }
+    }
+    /** Build LLM prompt with RAG context */
+    buildLlmPrompt(tracked, fromCamera, toCamera, transitTime, fromLandmarks, toLandmarks, ragContext) {
+        const transitSecs = Math.round(transitTime / 1000);
+        return `You are a security camera system describing movement on a property.
+
+PROPERTY CONTEXT:
+${ragContext}
+
+CURRENT EVENT:
+- Object type: ${tracked.className}
+- Moving from: ${fromCamera.name}${fromLandmarks.length ? ` (near ${fromLandmarks.map(l => l.name).join(', ')})` : ''}
+- Moving to: ${toCamera.name}${toLandmarks.length ? ` (near ${toLandmarks.map(l => l.name).join(', ')})` : ''}
+- Transit time: ${transitSecs} seconds
+
+INSTRUCTIONS:
+Generate a single, concise sentence describing this movement. Include:
+1. Description of the ${tracked.className} (if person: gender, clothing; if vehicle: color, type)
+2. Where they came from (using landmark names if available)
+3. Where they're heading (using landmark names if available)
+
+Examples of good descriptions:
+- "Man in blue jacket walking from the driveway towards the front door"
+- "Black SUV pulling into the driveway from the street"
+- "Woman with dog walking from the backyard towards the side gate"
+- "Delivery person approaching the front porch from the mailbox"
+
+Generate ONLY the description, nothing else:`;
+    }
+    /** Suggest a new landmark based on AI analysis */
+    async suggestLandmark(cameraId, mediaObject, objectClass, position) {
+        if (!this.config.enableLandmarkLearning)
+            return null;
+        const llm = await this.findLlmDevice();
+        if (!llm)
+            return null;
+        try {
+            const prompt = `Analyze this security camera image. A ${objectClass} was detected.
+
+Looking at the surroundings and environment, identify any notable landmarks or features visible that could help describe this location. Consider:
+- Structures (house, garage, shed, porch)
+- Features (mailbox, tree, pool, garden)
+- Access points (driveway, walkway, gate, door)
+- Boundaries (fence, wall, hedge)
+
+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 }
+            });
+            if (result.detections?.[0]?.label) {
+                try {
+                    const parsed = JSON.parse(result.detections[0].label);
+                    if (parsed.name && parsed.type) {
+                        const suggestionId = `suggest_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                        const suggestion = {
+                            id: suggestionId,
+                            landmark: {
+                                id: `landmark_${Date.now()}`,
+                                name: parsed.name,
+                                type: parsed.type,
+                                position,
+                                description: parsed.description,
+                                aiSuggested: true,
+                                aiConfidence: 0.7,
+                                visibleFromCameras: [cameraId],
+                            },
+                            detectedByCameras: [cameraId],
+                            timestamp: Date.now(),
+                            detectionCount: 1,
+                            status: 'pending',
+                        };
+                        // Store suggestion
+                        const existingKey = this.findSimilarSuggestion(parsed.name, position);
+                        if (existingKey) {
+                            // Increment count for similar suggestion
+                            const existing = this.landmarkSuggestions.get(existingKey);
+                            existing.detectionCount++;
+                            existing.landmark.aiConfidence = Math.min(0.95, existing.landmark.aiConfidence + 0.05);
+                            if (!existing.detectedByCameras.includes(cameraId)) {
+                                existing.detectedByCameras.push(cameraId);
+                            }
+                            return existing;
+                        }
+                        else {
+                            this.landmarkSuggestions.set(suggestionId, suggestion);
+                            return suggestion;
+                        }
+                    }
+                }
+                catch (parseError) {
+                    // LLM didn't return valid JSON
+                }
+            }
+            return null;
+        }
+        catch (e) {
+            this.console.warn('Landmark suggestion failed:', e);
+            return null;
+        }
+    }
+    /** Find similar existing suggestion by name proximity and position */
+    findSimilarSuggestion(name, position) {
+        const nameLower = name.toLowerCase();
+        const POSITION_THRESHOLD = 100; // pixels
+        for (const [key, suggestion] of this.landmarkSuggestions) {
+            if (suggestion.status !== 'pending')
+                continue;
+            const suggestionName = suggestion.landmark.name.toLowerCase();
+            const distance = Math.sqrt(Math.pow(suggestion.landmark.position.x - position.x, 2) +
+                Math.pow(suggestion.landmark.position.y - position.y, 2));
+            // Similar name and nearby position
+            if ((suggestionName.includes(nameLower) || nameLower.includes(suggestionName)) &&
+                distance < POSITION_THRESHOLD) {
+                return key;
+            }
+        }
+        return null;
+    }
+    /** Get pending landmark suggestions above confidence threshold */
+    getPendingSuggestions() {
+        return Array.from(this.landmarkSuggestions.values())
+            .filter(s => s.status === 'pending' &&
+            s.landmark.aiConfidence >= this.config.landmarkConfidenceThreshold)
+            .sort((a, b) => b.detectionCount - a.detectionCount);
+    }
+    /** Accept a landmark suggestion */
+    acceptSuggestion(suggestionId) {
+        const suggestion = this.landmarkSuggestions.get(suggestionId);
+        if (!suggestion)
+            return null;
+        suggestion.status = 'accepted';
+        const landmark = { ...suggestion.landmark };
+        landmark.aiSuggested = false; // Mark as confirmed
+        this.landmarkSuggestions.delete(suggestionId);
+        return landmark;
+    }
+    /** Reject a landmark suggestion */
+    rejectSuggestion(suggestionId) {
+        const suggestion = this.landmarkSuggestions.get(suggestionId);
+        if (!suggestion)
+            return false;
+        suggestion.status = 'rejected';
+        this.landmarkSuggestions.delete(suggestionId);
+        return true;
+    }
+    /** Utility to capitalize first letter */
+    capitalizeFirst(str) {
+        return str ? str.charAt(0).toUpperCase() + str.slice(1) : 'Object';
+    }
+    /** Get landmark templates for UI */
+    getLandmarkTemplates() {
+        return topology_1.LANDMARK_TEMPLATES;
+    }
+}
+exports.SpatialReasoningEngine = SpatialReasoningEngine;
+
+
 /***/ },
 
 /***/ "./src/core/tracking-engine.ts"
@@ -35059,6 +35628,7 @@ const sdk_1 = __importStar(__webpack_require__(/*! @scrypted/sdk */ "./node_modu
 const topology_1 = __webpack_require__(/*! ../models/topology */ "./src/models/topology.ts");
 const tracked_object_1 = __webpack_require__(/*! ../models/tracked-object */ "./src/models/tracked-object.ts");
 const object_correlator_1 = __webpack_require__(/*! ./object-correlator */ "./src/core/object-correlator.ts");
+const spatial_reasoning_1 = __webpack_require__(/*! ./spatial-reasoning */ "./src/core/spatial-reasoning.ts");
 const { systemManager } = sdk_1.default;
 class TrackingEngine {
     topology;
@@ -35067,9 +35637,14 @@ class TrackingEngine {
     config;
     console;
     correlator;
+    spatialReasoning;
     listeners = new Map();
     pendingTimers = new Map();
     lostCheckInterval = null;
+    /** Track last alert time per object to enforce cooldown */
+    objectLastAlertTime = new Map();
+    /** Callback for topology changes (e.g., landmark suggestions) */
+    onTopologyChange;
     constructor(topology, state, alertManager, config, console) {
         this.topology = topology;
         this.state = state;
@@ -35077,6 +35652,19 @@ class TrackingEngine {
         this.config = config;
         this.console = console;
         this.correlator = new object_correlator_1.ObjectCorrelator(topology, config);
+        // Initialize spatial reasoning engine
+        const spatialConfig = {
+            enableLlm: config.useLlmDescriptions,
+            enableLandmarkLearning: config.enableLandmarkLearning ?? true,
+            landmarkConfidenceThreshold: config.landmarkConfidenceThreshold ?? 0.7,
+            contextCacheTtl: 60000, // 1 minute cache
+        };
+        this.spatialReasoning = new spatial_reasoning_1.SpatialReasoningEngine(spatialConfig, console);
+        this.spatialReasoning.updateTopology(topology);
+    }
+    /** Set callback for topology changes */
+    setTopologyChangeCallback(callback) {
+        this.onTopologyChange = callback;
     }
     /** Start listening to all cameras in topology */
     async startTracking() {
@@ -35172,6 +35760,61 @@ class TrackingEngine {
             await this.processSighting(sighting, camera.isEntryPoint, camera.isExitPoint);
         }
     }
+    /** Check if object passes loitering threshold */
+    passesLoiteringThreshold(tracked) {
+        const visibleDuration = tracked.lastSeen - tracked.firstSeen;
+        return visibleDuration >= this.config.loiteringThreshold;
+    }
+    /** Check if object is in alert cooldown */
+    isInAlertCooldown(globalId) {
+        const lastAlertTime = this.objectLastAlertTime.get(globalId);
+        if (!lastAlertTime)
+            return false;
+        return (Date.now() - lastAlertTime) < this.config.objectAlertCooldown;
+    }
+    /** Record that we alerted for this object */
+    recordAlertTime(globalId) {
+        this.objectLastAlertTime.set(globalId, Date.now());
+    }
+    /** Get spatial reasoning result for movement (uses RAG + LLM) */
+    async getSpatialDescription(tracked, fromCameraId, toCameraId, transitTime, currentCameraId) {
+        try {
+            // 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();
+                }
+            }
+            // Use spatial reasoning engine for rich context-aware description
+            const result = await this.spatialReasoning.generateMovementDescription(tracked, fromCameraId, toCameraId, transitTime, mediaObject);
+            // Optionally trigger landmark learning
+            if (this.config.enableLandmarkLearning && mediaObject) {
+                this.tryLearnLandmark(currentCameraId, mediaObject, tracked.className);
+            }
+            return result;
+        }
+        catch (e) {
+            this.console.warn('Spatial reasoning failed:', e);
+            return null;
+        }
+    }
+    /** Try to learn new landmarks from detections (background task) */
+    async tryLearnLandmark(cameraId, mediaObject, objectClass) {
+        try {
+            // Position is approximate - could be improved with object position from detection
+            const position = { x: 50, y: 50 };
+            const suggestion = await this.spatialReasoning.suggestLandmark(cameraId, mediaObject, objectClass, position);
+            if (suggestion) {
+                this.console.log(`AI suggested landmark: ${suggestion.landmark.name} ` +
+                    `(${suggestion.landmark.type}, confidence: ${suggestion.landmark.aiConfidence?.toFixed(2)})`);
+            }
+        }
+        catch (e) {
+            // Landmark learning is best-effort, don't log errors
+        }
+    }
     /** Process a single sighting */
     async processSighting(sighting, isEntryPoint, isExitPoint) {
         // Try to correlate with existing tracked objects
@@ -35197,17 +35840,27 @@ class TrackingEngine {
                 this.console.log(`Object ${tracked.globalId.slice(0, 8)} transited: ` +
                     `${lastSighting.cameraName} → ${sighting.cameraName} ` +
                     `(confidence: ${(correlation.confidence * 100).toFixed(0)}%)`);
-                // 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: sighting.detection.label,
-                    detectionId: sighting.detectionId,
-                });
+                // 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);
+                }
             }
             // Add sighting to tracked object
             this.state.addSighting(tracked.globalId, sighting);
@@ -35231,14 +35884,21 @@ class TrackingEngine {
             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
-            if (isEntryPoint) {
+            // 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);
                 await this.alertManager.checkAndAlert('property_entry', tracked, {
                     cameraId: sighting.cameraId,
                     cameraName: sighting.cameraName,
                     objectClass: sighting.detection.className,
-                    objectLabel: sighting.detection.label,
+                    objectLabel: spatialResult?.description || sighting.detection.label,
                     detectionId: sighting.detectionId,
+                    involvedLandmarks: spatialResult?.involvedLandmarks?.map(l => l.name),
+                    usedLlm: spatialResult?.usedLlm,
                 });
+                this.recordAlertTime(globalId);
             }
         }
     }
@@ -35319,6 +35979,39 @@ class TrackingEngine {
     updateTopology(topology) {
         this.topology = topology;
         this.correlator = new object_correlator_1.ObjectCorrelator(topology, this.config);
+        this.spatialReasoning.updateTopology(topology);
+    }
+    /** Get pending landmark suggestions */
+    getPendingLandmarkSuggestions() {
+        return this.spatialReasoning.getPendingSuggestions();
+    }
+    /** Accept a landmark suggestion, adding it to topology */
+    acceptLandmarkSuggestion(suggestionId) {
+        const landmark = this.spatialReasoning.acceptSuggestion(suggestionId);
+        if (landmark && this.topology) {
+            // Add the accepted landmark to topology
+            if (!this.topology.landmarks) {
+                this.topology.landmarks = [];
+            }
+            this.topology.landmarks.push(landmark);
+            // Notify about topology change
+            if (this.onTopologyChange) {
+                this.onTopologyChange(this.topology);
+            }
+        }
+        return landmark;
+    }
+    /** Reject a landmark suggestion */
+    rejectLandmarkSuggestion(suggestionId) {
+        return this.spatialReasoning.rejectSuggestion(suggestionId);
+    }
+    /** Get landmark templates for UI */
+    getLandmarkTemplates() {
+        return this.spatialReasoning.getLandmarkTemplates();
+    }
+    /** Get the spatial reasoning engine for direct access */
+    getSpatialReasoningEngine() {
+        return this.spatialReasoning;
     }
     /** Get current topology */
     getTopology() {
@@ -36091,6 +36784,42 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             description: 'Use visual embeddings for object correlation (requires compatible detectors)',
             group: 'Tracking',
         },
+        loiteringThreshold: {
+            title: 'Loitering Threshold (seconds)',
+            type: 'number',
+            defaultValue: 3,
+            description: 'Object must be visible for this duration before triggering movement alerts',
+            group: 'Tracking',
+        },
+        objectAlertCooldown: {
+            title: 'Per-Object Alert Cooldown (seconds)',
+            type: 'number',
+            defaultValue: 30,
+            description: 'Minimum time between alerts for the same tracked object',
+            group: 'Tracking',
+        },
+        // LLM Integration
+        useLlmDescriptions: {
+            title: 'Use LLM for Rich Descriptions',
+            type: 'boolean',
+            defaultValue: true,
+            description: 'Use LLM plugin (if installed) to generate descriptive alerts like "Man walking from garage towards front door"',
+            group: 'AI & Spatial Reasoning',
+        },
+        enableLandmarkLearning: {
+            title: 'Learn Landmarks from AI',
+            type: 'boolean',
+            defaultValue: true,
+            description: 'Allow AI to suggest new landmarks based on detected objects and camera context',
+            group: 'AI & Spatial Reasoning',
+        },
+        landmarkConfidenceThreshold: {
+            title: 'Landmark Suggestion Confidence',
+            type: 'number',
+            defaultValue: 0.7,
+            description: 'Minimum AI confidence (0-1) to suggest a landmark',
+            group: 'AI & Spatial Reasoning',
+        },
         // MQTT Settings
         enableMqtt: {
             title: 'Enable MQTT',
@@ -36233,8 +36962,18 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             correlationThreshold: this.storageSettings.values.correlationThreshold || 0.6,
             lostTimeout: (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,
+            useLlmDescriptions: this.storageSettings.values.useLlmDescriptions ?? true,
+            enableLandmarkLearning: this.storageSettings.values.enableLandmarkLearning ?? true,
+            landmarkConfidenceThreshold: this.storageSettings.values.landmarkConfidenceThreshold ?? 0.7,
         };
         this.trackingEngine = new tracking_engine_1.TrackingEngine(topology, this.trackingState, this.alertManager, config, this.console);
+        // Set up callback to save topology changes (e.g., from accepted landmark suggestions)
+        this.trackingEngine.setTopologyChangeCallback((updatedTopology) => {
+            this.storage.setItem('topology', JSON.stringify(updatedTopology));
+            this.console.log('Topology auto-saved after change');
+        });
         await this.trackingEngine.startTracking();
         this.console.log('Tracking engine started');
     }
@@ -36471,7 +37210,12 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             key === 'correlationWindow' ||
             key === 'correlationThreshold' ||
             key === 'lostTimeout' ||
-            key === 'useVisualMatching') {
+            key === 'useVisualMatching' ||
+            key === 'loiteringThreshold' ||
+            key === 'objectAlertCooldown' ||
+            key === 'useLlmDescriptions' ||
+            key === 'enableLandmarkLearning' ||
+            key === 'landmarkConfidenceThreshold') {
             const topologyJson = this.storage.getItem('topology');
             if (topologyJson) {
                 try {
@@ -36523,6 +37267,28 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             if (path.endsWith('/api/floor-plan')) {
                 return this.handleFloorPlanRequest(request, response);
             }
+            if (path.endsWith('/api/landmarks')) {
+                return this.handleLandmarksRequest(request, response);
+            }
+            if (path.match(/\/api\/landmarks\/[\w-]+$/)) {
+                const landmarkId = path.split('/').pop();
+                return this.handleLandmarkRequest(landmarkId, request, response);
+            }
+            if (path.endsWith('/api/landmark-suggestions')) {
+                return this.handleLandmarkSuggestionsRequest(request, response);
+            }
+            if (path.match(/\/api\/landmark-suggestions\/[\w-]+\/(accept|reject)$/)) {
+                const parts = path.split('/');
+                const action = parts.pop();
+                const suggestionId = parts.pop();
+                return this.handleSuggestionActionRequest(suggestionId, action, response);
+            }
+            if (path.endsWith('/api/landmark-templates')) {
+                return this.handleLandmarkTemplatesRequest(response);
+            }
+            if (path.endsWith('/api/infer-relationships')) {
+                return this.handleInferRelationshipsRequest(response);
+            }
             // UI Routes
             if (path.endsWith('/ui/editor') || path.endsWith('/ui/editor/')) {
                 return this.serveEditorUI(response);
@@ -36704,6 +37470,202 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             }
         }
     }
+    handleLandmarksRequest(request, response) {
+        const topology = this.getTopology();
+        if (!topology) {
+            response.send(JSON.stringify({ landmarks: [] }), {
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        if (request.method === 'GET') {
+            response.send(JSON.stringify({
+                landmarks: topology.landmarks || [],
+            }), {
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        else if (request.method === 'POST') {
+            try {
+                const landmark = JSON.parse(request.body);
+                if (!landmark.id) {
+                    landmark.id = `landmark_${Date.now()}`;
+                }
+                if (!topology.landmarks) {
+                    topology.landmarks = [];
+                }
+                topology.landmarks.push(landmark);
+                this.storage.setItem('topology', JSON.stringify(topology));
+                if (this.trackingEngine) {
+                    this.trackingEngine.updateTopology(topology);
+                }
+                response.send(JSON.stringify({ success: true, landmark }), {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            catch (e) {
+                response.send(JSON.stringify({ error: 'Invalid landmark data' }), {
+                    code: 400,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        }
+    }
+    handleLandmarkRequest(landmarkId, request, response) {
+        const topology = this.getTopology();
+        if (!topology) {
+            response.send(JSON.stringify({ error: 'No topology configured' }), {
+                code: 404,
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        const landmarkIndex = topology.landmarks?.findIndex(l => l.id === landmarkId) ?? -1;
+        if (request.method === 'GET') {
+            const landmark = topology.landmarks?.[landmarkIndex];
+            if (landmark) {
+                response.send(JSON.stringify(landmark), {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            else {
+                response.send(JSON.stringify({ error: 'Landmark not found' }), {
+                    code: 404,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        }
+        else if (request.method === 'PUT') {
+            try {
+                const updates = JSON.parse(request.body);
+                if (landmarkIndex >= 0) {
+                    topology.landmarks[landmarkIndex] = {
+                        ...topology.landmarks[landmarkIndex],
+                        ...updates,
+                        id: landmarkId, // Preserve ID
+                    };
+                    this.storage.setItem('topology', JSON.stringify(topology));
+                    if (this.trackingEngine) {
+                        this.trackingEngine.updateTopology(topology);
+                    }
+                    response.send(JSON.stringify({ success: true, landmark: topology.landmarks[landmarkIndex] }), {
+                        headers: { 'Content-Type': 'application/json' },
+                    });
+                }
+                else {
+                    response.send(JSON.stringify({ error: 'Landmark not found' }), {
+                        code: 404,
+                        headers: { 'Content-Type': 'application/json' },
+                    });
+                }
+            }
+            catch (e) {
+                response.send(JSON.stringify({ error: 'Invalid landmark data' }), {
+                    code: 400,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        }
+        else if (request.method === 'DELETE') {
+            if (landmarkIndex >= 0) {
+                topology.landmarks.splice(landmarkIndex, 1);
+                this.storage.setItem('topology', JSON.stringify(topology));
+                if (this.trackingEngine) {
+                    this.trackingEngine.updateTopology(topology);
+                }
+                response.send(JSON.stringify({ success: true }), {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            else {
+                response.send(JSON.stringify({ error: 'Landmark not found' }), {
+                    code: 404,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        }
+    }
+    handleLandmarkSuggestionsRequest(request, response) {
+        if (!this.trackingEngine) {
+            response.send(JSON.stringify({ suggestions: [] }), {
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        const suggestions = this.trackingEngine.getPendingLandmarkSuggestions();
+        response.send(JSON.stringify({
+            suggestions,
+            count: suggestions.length,
+        }), {
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    handleSuggestionActionRequest(suggestionId, action, response) {
+        if (!this.trackingEngine) {
+            response.send(JSON.stringify({ error: 'Tracking engine not running' }), {
+                code: 500,
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        if (action === 'accept') {
+            const landmark = this.trackingEngine.acceptLandmarkSuggestion(suggestionId);
+            if (landmark) {
+                response.send(JSON.stringify({ success: true, landmark }), {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            else {
+                response.send(JSON.stringify({ error: 'Suggestion not found' }), {
+                    code: 404,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        }
+        else if (action === 'reject') {
+            const success = this.trackingEngine.rejectLandmarkSuggestion(suggestionId);
+            if (success) {
+                response.send(JSON.stringify({ success: true }), {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            else {
+                response.send(JSON.stringify({ error: 'Suggestion not found' }), {
+                    code: 404,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        }
+        else {
+            response.send(JSON.stringify({ error: 'Invalid action' }), {
+                code: 400,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+    }
+    handleLandmarkTemplatesRequest(response) {
+        response.send(JSON.stringify({
+            templates: topology_1.LANDMARK_TEMPLATES,
+        }), {
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    handleInferRelationshipsRequest(response) {
+        const topology = this.getTopology();
+        if (!topology) {
+            response.send(JSON.stringify({ relationships: [] }), {
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        const inferred = (0, topology_1.inferRelationships)(topology);
+        response.send(JSON.stringify({
+            relationships: inferred,
+            count: inferred.length,
+        }), {
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
     serveEditorUI(response) {
         response.send(editor_html_1.EDITOR_HTML, {
             headers: { 'Content-Type': 'text/html' },
@@ -36882,9 +37844,22 @@ function generateAlertMessage(type, details) {
         case 'property_exit':
             return `${objectDesc} exited property via ${details.cameraName || 'unknown camera'}`;
         case 'movement':
+            // If we have a rich description from LLM/RAG, use it
+            if (details.objectLabel && details.usedLlm) {
+                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)` : '';
-            return `${objectDesc} moving from ${details.fromCameraName || 'unknown'} towards ${details.toCameraName || 'unknown'}${transitStr}`;
+            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}`;
         case 'unusual_path':
             return `${objectDesc} took unusual path: ${details.actualPath || 'unknown'}`;
         case 'dwell_time':
@@ -36932,21 +37907,44 @@ function createAlert(type, trackedObjectId, details, severity = 'info', ruleId)
 
 /**
  * Camera Topology Models
- * Defines the spatial relationships between cameras in the NVR system
+ * Defines the spatial relationships between cameras, landmarks, and zones
  */
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.LANDMARK_TEMPLATES = void 0;
 exports.createEmptyTopology = createEmptyTopology;
 exports.findCamera = findCamera;
+exports.findLandmark = findLandmark;
 exports.findConnectionsFrom = findConnectionsFrom;
 exports.findConnection = findConnection;
 exports.getEntryPoints = getEntryPoints;
 exports.getExitPoints = getExitPoints;
+exports.getLandmarksVisibleFromCamera = getLandmarksVisibleFromCamera;
+exports.getCamerasWithLandmarkVisibility = getCamerasWithLandmarkVisibility;
+exports.getAdjacentLandmarks = getAdjacentLandmarks;
+exports.calculateDistance = calculateDistance;
+exports.inferRelationships = inferRelationships;
+exports.generateTopologyDescription = generateTopologyDescription;
+exports.generateMovementContext = generateMovementContext;
+/** Common landmark templates for quick setup */
+exports.LANDMARK_TEMPLATES = [
+    { type: 'structure', suggestions: ['House', 'Garage', 'Shed', 'Porch', 'Deck', 'Patio', 'Gazebo', 'Pool House'] },
+    { type: 'feature', suggestions: ['Mailbox', 'Tree', 'Firepit', 'Pool', 'Hot Tub', 'Garden', 'Fountain', 'Flagpole'] },
+    { type: 'boundary', suggestions: ['Front Fence', 'Back Fence', 'Side Fence', 'Hedge', 'Wall', 'Property Line'] },
+    { type: 'access', suggestions: ['Driveway', 'Front Walkway', 'Back Walkway', 'Front Door', 'Back Door', 'Side Door', 'Gate', 'Stairs'] },
+    { type: 'vehicle', suggestions: ['Car Parking', 'Boat', 'RV Pad', 'Motorcycle Spot'] },
+    { type: 'neighbor', suggestions: ["Neighbor's House", "Neighbor's Driveway", "Neighbor's Yard"] },
+    { type: 'zone', suggestions: ['Front Yard', 'Back Yard', 'Side Yard', 'Courtyard'] },
+    { type: 'street', suggestions: ['Street', 'Sidewalk', 'Alley', 'Cul-de-sac'] },
+];
+// ==================== Helper Functions ====================
 /** Creates an empty topology */
 function createEmptyTopology() {
     return {
-        version: '1.0',
+        version: '2.0',
         cameras: [],
         connections: [],
+        landmarks: [],
+        relationships: [],
         globalZones: [],
     };
 }
@@ -36954,6 +37952,10 @@ function createEmptyTopology() {
 function findCamera(topology, deviceId) {
     return topology.cameras.find(c => c.deviceId === deviceId);
 }
+/** Finds a landmark by ID */
+function findLandmark(topology, landmarkId) {
+    return topology.landmarks.find(l => l.id === landmarkId);
+}
 /** Finds connections from a camera */
 function findConnectionsFrom(topology, cameraId) {
     return topology.connections.filter(c => c.fromCameraId === cameraId ||
@@ -36961,8 +37963,8 @@ function findConnectionsFrom(topology, cameraId) {
 }
 /** Finds a connection between two cameras */
 function findConnection(topology, fromCameraId, toCameraId) {
-    return topology.connections.find(c => (c.fromCameraId === fromCameraId && c.toCameraId === toCameraId) ||
-        (c.bidirectional && c.fromCameraId === toCameraId && c.toCameraId === fromCameraId));
+    return topology.connections.filter(c => (c.fromCameraId === fromCameraId && c.toCameraId === toCameraId) ||
+        (c.bidirectional && c.fromCameraId === toCameraId && c.toCameraId === fromCameraId))[0];
 }
 /** Gets all entry point cameras */
 function getEntryPoints(topology) {
@@ -36972,6 +37974,171 @@ function getEntryPoints(topology) {
 function getExitPoints(topology) {
     return topology.cameras.filter(c => c.isExitPoint);
 }
+/** Gets landmarks visible from a camera */
+function getLandmarksVisibleFromCamera(topology, cameraId) {
+    const camera = findCamera(topology, cameraId);
+    if (!camera?.context?.visibleLandmarks)
+        return [];
+    return camera.context.visibleLandmarks
+        .map(id => findLandmark(topology, id))
+        .filter((l) => l !== undefined);
+}
+/** Gets cameras that can see a landmark */
+function getCamerasWithLandmarkVisibility(topology, landmarkId) {
+    return topology.cameras.filter(c => c.context?.visibleLandmarks?.includes(landmarkId));
+}
+/** Gets adjacent landmarks */
+function getAdjacentLandmarks(topology, landmarkId) {
+    const landmark = findLandmark(topology, landmarkId);
+    if (!landmark?.adjacentTo)
+        return [];
+    return landmark.adjacentTo
+        .map(id => findLandmark(topology, id))
+        .filter((l) => l !== undefined);
+}
+/** Calculates distance between two floor plan positions */
+function calculateDistance(posA, posB) {
+    const dx = posB.x - posA.x;
+    const dy = posB.y - posA.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+/** Auto-infers relationships based on positions and proximity */
+function inferRelationships(topology, proximityThreshold = 50) {
+    const relationships = [];
+    const entities = [];
+    // Collect all positioned entities
+    for (const camera of topology.cameras) {
+        if (camera.floorPlanPosition) {
+            entities.push({ id: camera.deviceId, position: camera.floorPlanPosition, type: 'camera' });
+        }
+    }
+    for (const landmark of topology.landmarks) {
+        entities.push({ id: landmark.id, position: landmark.position, type: 'landmark' });
+    }
+    // Find adjacent entities based on proximity
+    for (let i = 0; i < entities.length; i++) {
+        for (let j = i + 1; j < entities.length; j++) {
+            const distance = calculateDistance(entities[i].position, entities[j].position);
+            if (distance <= proximityThreshold) {
+                relationships.push({
+                    id: `auto_${entities[i].id}_${entities[j].id}`,
+                    type: distance <= proximityThreshold / 2 ? 'adjacent' : 'near',
+                    entityA: entities[i].id,
+                    entityB: entities[j].id,
+                    autoInferred: true,
+                });
+            }
+        }
+    }
+    return relationships;
+}
+/** Generates a natural language description of the topology for LLM context */
+function generateTopologyDescription(topology) {
+    const lines = [];
+    // Property description
+    if (topology.property?.description) {
+        lines.push(`Property: ${topology.property.description}`);
+    }
+    if (topology.property?.frontFacing) {
+        lines.push(`Front of property faces ${topology.property.frontFacing}.`);
+    }
+    // Landmarks
+    if (topology.landmarks.length > 0) {
+        lines.push('\nLandmarks on property:');
+        for (const landmark of topology.landmarks) {
+            let desc = `- ${landmark.name} (${landmark.type})`;
+            if (landmark.description)
+                desc += `: ${landmark.description}`;
+            if (landmark.isEntryPoint)
+                desc += ' [Entry point]';
+            if (landmark.isExitPoint)
+                desc += ' [Exit point]';
+            lines.push(desc);
+        }
+    }
+    // Cameras
+    if (topology.cameras.length > 0) {
+        lines.push('\nCamera coverage:');
+        for (const camera of topology.cameras) {
+            let desc = `- ${camera.name}`;
+            if (camera.context?.mountLocation)
+                desc += ` (mounted at ${camera.context.mountLocation})`;
+            if (camera.context?.coverageDescription)
+                desc += `: ${camera.context.coverageDescription}`;
+            if (camera.isEntryPoint)
+                desc += ' [Watches entry point]';
+            if (camera.isExitPoint)
+                desc += ' [Watches exit point]';
+            // List visible landmarks
+            if (camera.context?.visibleLandmarks && camera.context.visibleLandmarks.length > 0) {
+                const landmarkNames = camera.context.visibleLandmarks
+                    .map(id => findLandmark(topology, id)?.name)
+                    .filter(Boolean);
+                if (landmarkNames.length > 0) {
+                    desc += ` Can see: ${landmarkNames.join(', ')}`;
+                }
+            }
+            lines.push(desc);
+        }
+    }
+    // Connections/paths
+    if (topology.connections.length > 0) {
+        lines.push('\nMovement paths:');
+        for (const conn of topology.connections) {
+            const fromCam = findCamera(topology, conn.fromCameraId);
+            const toCam = findCamera(topology, conn.toCameraId);
+            if (fromCam && toCam) {
+                let desc = `- ${fromCam.name} → ${toCam.name}`;
+                if (conn.name)
+                    desc += ` (${conn.name})`;
+                desc += ` [${conn.transitTime.min / 1000}-${conn.transitTime.max / 1000}s transit]`;
+                if (conn.bidirectional)
+                    desc += ' [bidirectional]';
+                lines.push(desc);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+/** Generates context for a specific movement between cameras */
+function generateMovementContext(topology, fromCameraId, toCameraId, objectClass) {
+    const fromCamera = findCamera(topology, fromCameraId);
+    const toCamera = findCamera(topology, toCameraId);
+    const connection = findConnection(topology, fromCameraId, toCameraId);
+    if (!fromCamera || !toCamera) {
+        return `${objectClass} moving between cameras`;
+    }
+    const lines = [];
+    // Source context
+    lines.push(`Origin: ${fromCamera.name}`);
+    if (fromCamera.context?.coverageDescription) {
+        lines.push(`  Coverage: ${fromCamera.context.coverageDescription}`);
+    }
+    // Destination context
+    lines.push(`Destination: ${toCamera.name}`);
+    if (toCamera.context?.coverageDescription) {
+        lines.push(`  Coverage: ${toCamera.context.coverageDescription}`);
+    }
+    // Path context
+    if (connection) {
+        if (connection.name)
+            lines.push(`Path: ${connection.name}`);
+        if (connection.pathLandmarks && connection.pathLandmarks.length > 0) {
+            const landmarkNames = connection.pathLandmarks
+                .map(id => findLandmark(topology, id)?.name)
+                .filter(Boolean);
+            if (landmarkNames.length > 0) {
+                lines.push(`Passing: ${landmarkNames.join(' → ')}`);
+            }
+        }
+    }
+    // Nearby landmarks at destination
+    const destLandmarks = getLandmarksVisibleFromCamera(topology, toCameraId);
+    if (destLandmarks.length > 0) {
+        lines.push(`Near: ${destLandmarks.map(l => l.name).join(', ')}`);
+    }
+    return lines.join('\n');
+}
 
 
 /***/ },
@@ -37432,6 +38599,22 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
             <div class="connection-item" style="color: #666; text-align: center; cursor: default;">No connections configured</div>
           </div>
         </div>
+        <div class="section">
+          <div class="section-title">
+            <span>Landmarks</span>
+            <button class="btn btn-small" onclick="openAddLandmarkModal()">+ Add</button>
+          </div>
+          <div id="landmark-list">
+            <div class="landmark-item" style="color: #666; text-align: center; cursor: default; padding: 8px;">No landmarks configured</div>
+          </div>
+        </div>
+        <div class="section" id="suggestions-section" style="display: none;">
+          <div class="section-title">
+            <span>AI Suggestions</span>
+            <button class="btn btn-small" onclick="loadSuggestions()">Refresh</button>
+          </div>
+          <div id="suggestions-list"></div>
+        </div>
       </div>
     </div>
     <div class="editor">
@@ -37445,6 +38628,7 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
           <button class="btn" id="tool-wall" onclick="setTool('wall')">Draw Wall</button>
           <button class="btn" id="tool-room" onclick="setTool('room')">Draw Room</button>
           <button class="btn" id="tool-camera" onclick="setTool('camera')">Place Camera</button>
+          <button class="btn" id="tool-landmark" onclick="setTool('landmark')">Place Landmark</button>
           <button class="btn" id="tool-connect" onclick="setTool('connect')">Connect</button>
         </div>
         <div class="toolbar-group">
@@ -37472,7 +38656,7 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
           <span id="status-text">Ready</span>
         </div>
         <div>
-          <span id="camera-count">0</span> cameras | <span id="connection-count">0</span> connections
+          <span id="camera-count">0</span> cameras | <span id="connection-count">0</span> connections | <span id="landmark-count">0</span> landmarks
         </div>
       </div>
     </div>
@@ -37566,12 +38750,61 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
     </div>
   </div>
 
+  <div class="modal-overlay" id="add-landmark-modal">
+    <div class="modal">
+      <h2>Add Landmark</h2>
+      <div class="form-group">
+        <label>Landmark Type</label>
+        <select id="landmark-type-select" onchange="updateLandmarkSuggestions()">
+          <option value="structure">Structure (House, Garage, Shed)</option>
+          <option value="feature">Feature (Mailbox, Tree, Pool)</option>
+          <option value="boundary">Boundary (Fence, Wall, Hedge)</option>
+          <option value="access">Access (Driveway, Walkway, Gate)</option>
+          <option value="vehicle">Vehicle (Parking, Boat, RV)</option>
+          <option value="neighbor">Neighbor (House, Driveway)</option>
+          <option value="zone">Zone (Front Yard, Back Yard)</option>
+          <option value="street">Street (Street, Sidewalk, Alley)</option>
+        </select>
+      </div>
+      <div class="form-group">
+        <label>Quick Templates</label>
+        <div id="landmark-templates" style="display: flex; flex-wrap: wrap; gap: 5px;"></div>
+      </div>
+      <div class="form-group">
+        <label>Name</label>
+        <input type="text" id="landmark-name-input" placeholder="e.g., Front Porch, Red Shed">
+      </div>
+      <div class="form-group">
+        <label>Description (optional)</label>
+        <input type="text" id="landmark-desc-input" placeholder="Brief description for AI context">
+      </div>
+      <div class="form-group">
+        <label class="checkbox-group">
+          <input type="checkbox" id="landmark-entry-checkbox">
+          Entry Point (people can enter property here)
+        </label>
+      </div>
+      <div class="form-group">
+        <label class="checkbox-group">
+          <input type="checkbox" id="landmark-exit-checkbox">
+          Exit Point (people can exit property here)
+        </label>
+      </div>
+      <div class="modal-actions">
+        <button class="btn" onclick="closeModal('add-landmark-modal')">Cancel</button>
+        <button class="btn btn-primary" onclick="addLandmark()">Add Landmark</button>
+      </div>
+    </div>
+  </div>
+
   <script>
-    let topology = { version: '1.0', cameras: [], connections: [], globalZones: [], floorPlan: null, drawings: [] };
+    let topology = { version: '2.0', cameras: [], connections: [], globalZones: [], landmarks: [], relationships: [], floorPlan: null, drawings: [] };
     let selectedItem = null;
     let currentTool = 'select';
     let floorPlanImage = null;
     let availableCameras = [];
+    let landmarkTemplates = [];
+    let pendingSuggestions = [];
     let isDrawing = false;
     let drawStart = null;
     let currentDrawing = null;
@@ -37582,6 +38815,8 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
     async function init() {
       await loadTopology();
       await loadAvailableCameras();
+      await loadLandmarkTemplates();
+      await loadSuggestions();
       resizeCanvas();
       render();
       updateUI();
@@ -37617,6 +38852,192 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       updateCameraSelects();
     }
 
+    async function loadLandmarkTemplates() {
+      try {
+        const response = await fetch('../api/landmark-templates');
+        if (response.ok) {
+          const data = await response.json();
+          landmarkTemplates = data.templates || [];
+        }
+      } catch (e) { console.error('Failed to load landmark templates:', e); }
+    }
+
+    async function loadSuggestions() {
+      try {
+        const response = await fetch('../api/landmark-suggestions');
+        if (response.ok) {
+          const data = await response.json();
+          pendingSuggestions = data.suggestions || [];
+          updateSuggestionsUI();
+        }
+      } catch (e) { console.error('Failed to load suggestions:', e); }
+    }
+
+    function updateSuggestionsUI() {
+      const section = document.getElementById('suggestions-section');
+      const list = document.getElementById('suggestions-list');
+      if (pendingSuggestions.length === 0) {
+        section.style.display = 'none';
+        return;
+      }
+      section.style.display = 'block';
+      list.innerHTML = pendingSuggestions.map(s =>
+        '<div class="camera-item" style="display: flex; justify-content: space-between; align-items: center;">' +
+        '<div><div class="camera-name">' + s.landmark.name + '</div>' +
+        '<div class="camera-info">' + s.landmark.type + ' - ' + Math.round((s.landmark.aiConfidence || 0) * 100) + '% confidence</div></div>' +
+        '<div style="display: flex; gap: 5px;">' +
+        '<button class="btn btn-small btn-primary" onclick="acceptSuggestion(\\'' + s.id + '\\')">Accept</button>' +
+        '<button class="btn btn-small" onclick="rejectSuggestion(\\'' + s.id + '\\')">Reject</button>' +
+        '</div></div>'
+      ).join('');
+    }
+
+    async function acceptSuggestion(id) {
+      try {
+        const response = await fetch('../api/landmark-suggestions/' + id + '/accept', { method: 'POST' });
+        if (response.ok) {
+          const data = await response.json();
+          if (data.landmark) {
+            topology.landmarks.push(data.landmark);
+            updateUI();
+            render();
+          }
+          await loadSuggestions();
+          setStatus('Landmark accepted', 'success');
+        }
+      } catch (e) { console.error('Failed to accept suggestion:', e); }
+    }
+
+    async function rejectSuggestion(id) {
+      try {
+        await fetch('../api/landmark-suggestions/' + id + '/reject', { method: 'POST' });
+        await loadSuggestions();
+        setStatus('Suggestion rejected', 'success');
+      } catch (e) { console.error('Failed to reject suggestion:', e); }
+    }
+
+    function openAddLandmarkModal() {
+      updateLandmarkSuggestions();
+      document.getElementById('add-landmark-modal').classList.add('active');
+    }
+
+    function updateLandmarkSuggestions() {
+      const type = document.getElementById('landmark-type-select').value;
+      const template = landmarkTemplates.find(t => t.type === type);
+      const container = document.getElementById('landmark-templates');
+      if (template) {
+        container.innerHTML = template.suggestions.map(s =>
+          '<button class="btn btn-small" onclick="setLandmarkName(\\'' + s + '\\')" style="margin: 2px;">' + s + '</button>'
+        ).join('');
+      } else {
+        container.innerHTML = '<span style="color: #666; font-size: 12px;">No templates for this type</span>';
+      }
+    }
+
+    function setLandmarkName(name) {
+      document.getElementById('landmark-name-input').value = name;
+    }
+
+    function addLandmark() {
+      const name = document.getElementById('landmark-name-input').value;
+      if (!name) { alert('Please enter a landmark name'); return; }
+      const type = document.getElementById('landmark-type-select').value;
+      const description = document.getElementById('landmark-desc-input').value;
+      const isEntry = document.getElementById('landmark-entry-checkbox').checked;
+      const isExit = document.getElementById('landmark-exit-checkbox').checked;
+      const pos = topology._pendingLandmarkPos || { x: canvas.width / 2 + Math.random() * 100 - 50, y: canvas.height / 2 + Math.random() * 100 - 50 };
+      delete topology._pendingLandmarkPos;
+      const landmark = {
+        id: 'landmark_' + Date.now(),
+        name,
+        type,
+        position: pos,
+        description: description || undefined,
+        isEntryPoint: isEntry,
+        isExitPoint: isExit,
+        visibleFromCameras: [],
+      };
+      if (!topology.landmarks) topology.landmarks = [];
+      topology.landmarks.push(landmark);
+      closeModal('add-landmark-modal');
+      document.getElementById('landmark-name-input').value = '';
+      document.getElementById('landmark-desc-input').value = '';
+      document.getElementById('landmark-entry-checkbox').checked = false;
+      document.getElementById('landmark-exit-checkbox').checked = false;
+      updateUI();
+      render();
+    }
+
+    function selectLandmark(id) {
+      selectedItem = { type: 'landmark', id };
+      const landmark = topology.landmarks.find(l => l.id === id);
+      showLandmarkProperties(landmark);
+      updateUI();
+      render();
+    }
+
+    function showLandmarkProperties(landmark) {
+      const panel = document.getElementById('properties-panel');
+      const cameraOptions = topology.cameras.map(c =>
+        '<label class="checkbox-group" style="margin-bottom: 5px;"><input type="checkbox" ' +
+        ((landmark.visibleFromCameras || []).includes(c.deviceId) ? 'checked' : '') +
+        ' onchange="toggleLandmarkCamera(\\'' + landmark.id + '\\', \\'' + c.deviceId + '\\', this.checked)">' +
+        c.name + '</label>'
+      ).join('');
+      panel.innerHTML = '<h3>Landmark Properties</h3>' +
+        '<div class="form-group"><label>Name</label><input type="text" value="' + landmark.name + '" onchange="updateLandmarkName(\\'' + landmark.id + '\\', this.value)"></div>' +
+        '<div class="form-group"><label>Type</label><select onchange="updateLandmarkType(\\'' + landmark.id + '\\', this.value)">' +
+        '<option value="structure"' + (landmark.type === 'structure' ? ' selected' : '') + '>Structure</option>' +
+        '<option value="feature"' + (landmark.type === 'feature' ? ' selected' : '') + '>Feature</option>' +
+        '<option value="boundary"' + (landmark.type === 'boundary' ? ' selected' : '') + '>Boundary</option>' +
+        '<option value="access"' + (landmark.type === 'access' ? ' selected' : '') + '>Access</option>' +
+        '<option value="vehicle"' + (landmark.type === 'vehicle' ? ' selected' : '') + '>Vehicle</option>' +
+        '<option value="neighbor"' + (landmark.type === 'neighbor' ? ' selected' : '') + '>Neighbor</option>' +
+        '<option value="zone"' + (landmark.type === 'zone' ? ' selected' : '') + '>Zone</option>' +
+        '<option value="street"' + (landmark.type === 'street' ? ' selected' : '') + '>Street</option>' +
+        '</select></div>' +
+        '<div class="form-group"><label>Description</label><input type="text" value="' + (landmark.description || '') + '" onchange="updateLandmarkDesc(\\'' + landmark.id + '\\', this.value)"></div>' +
+        '<div class="form-group"><label class="checkbox-group"><input type="checkbox" ' + (landmark.isEntryPoint ? 'checked' : '') + ' onchange="updateLandmarkEntry(\\'' + landmark.id + '\\', this.checked)">Entry Point</label></div>' +
+        '<div class="form-group"><label class="checkbox-group"><input type="checkbox" ' + (landmark.isExitPoint ? 'checked' : '') + ' onchange="updateLandmarkExit(\\'' + landmark.id + '\\', this.checked)">Exit Point</label></div>' +
+        '<div class="form-group"><label>Visible from Cameras</label>' + (cameraOptions || '<span style="color:#666;font-size:12px;">Add cameras first</span>') + '</div>' +
+        '<div class="form-group"><button class="btn" style="width: 100%; background: #f44336;" onclick="deleteLandmark(\\'' + landmark.id + '\\')">Delete Landmark</button></div>';
+    }
+
+    function updateLandmarkName(id, value) { const l = topology.landmarks.find(x => x.id === id); if (l) l.name = value; updateUI(); }
+    function updateLandmarkType(id, value) { const l = topology.landmarks.find(x => x.id === id); if (l) l.type = value; render(); }
+    function updateLandmarkDesc(id, value) { const l = topology.landmarks.find(x => x.id === id); if (l) l.description = value || undefined; }
+    function updateLandmarkEntry(id, value) { const l = topology.landmarks.find(x => x.id === id); if (l) l.isEntryPoint = value; }
+    function updateLandmarkExit(id, value) { const l = topology.landmarks.find(x => x.id === id); if (l) l.isExitPoint = value; }
+    function toggleLandmarkCamera(landmarkId, cameraId, visible) {
+      const l = topology.landmarks.find(x => x.id === landmarkId);
+      if (!l) return;
+      if (!l.visibleFromCameras) l.visibleFromCameras = [];
+      if (visible && !l.visibleFromCameras.includes(cameraId)) {
+        l.visibleFromCameras.push(cameraId);
+      } else if (!visible) {
+        l.visibleFromCameras = l.visibleFromCameras.filter(id => id !== cameraId);
+      }
+      // Also update camera's visibleLandmarks
+      const camera = topology.cameras.find(c => c.deviceId === cameraId);
+      if (camera) {
+        if (!camera.context) camera.context = {};
+        if (!camera.context.visibleLandmarks) camera.context.visibleLandmarks = [];
+        if (visible && !camera.context.visibleLandmarks.includes(landmarkId)) {
+          camera.context.visibleLandmarks.push(landmarkId);
+        } else if (!visible) {
+          camera.context.visibleLandmarks = camera.context.visibleLandmarks.filter(id => id !== landmarkId);
+        }
+      }
+    }
+    function deleteLandmark(id) {
+      if (!confirm('Delete this landmark?')) return;
+      topology.landmarks = topology.landmarks.filter(l => l.id !== id);
+      selectedItem = null;
+      document.getElementById('properties-panel').innerHTML = '<h3>Properties</h3><p style="color: #666;">Select an item to edit.</p>';
+      updateUI();
+      render();
+    }
+
     async function saveTopology() {
       try {
         setStatus('Saving...', 'warning');
@@ -37704,6 +39125,10 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
           ctx.strokeRect(currentDrawing.x, currentDrawing.y, currentDrawing.width, currentDrawing.height);
         }
       }
+      // Draw landmarks first (below cameras and connections)
+      for (const landmark of (topology.landmarks || [])) {
+        if (landmark.position) { drawLandmark(landmark); }
+      }
       for (const conn of topology.connections) {
         const fromCam = topology.cameras.find(c => c.deviceId === conn.fromCameraId);
         const toCam = topology.cameras.find(c => c.deviceId === conn.toCameraId);
@@ -37716,6 +39141,46 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       }
     }
 
+    function drawLandmark(landmark) {
+      const pos = landmark.position;
+      const isSelected = selectedItem?.type === 'landmark' && selectedItem?.id === landmark.id;
+      // Color by type
+      const colors = {
+        structure: '#8b5cf6', // purple
+        feature: '#10b981', // green
+        boundary: '#f59e0b', // amber
+        access: '#3b82f6', // blue
+        vehicle: '#6366f1', // indigo
+        neighbor: '#ec4899', // pink
+        zone: '#14b8a6', // teal
+        street: '#6b7280', // gray
+      };
+      const color = colors[landmark.type] || '#888';
+      // Draw landmark marker
+      ctx.beginPath();
+      ctx.moveTo(pos.x, pos.y - 15);
+      ctx.lineTo(pos.x + 12, pos.y + 8);
+      ctx.lineTo(pos.x - 12, pos.y + 8);
+      ctx.closePath();
+      ctx.fillStyle = isSelected ? '#e94560' : color;
+      ctx.fill();
+      ctx.strokeStyle = '#fff';
+      ctx.lineWidth = 2;
+      ctx.stroke();
+      // Entry/exit indicators
+      if (landmark.isEntryPoint || landmark.isExitPoint) {
+        ctx.beginPath();
+        ctx.arc(pos.x, pos.y - 20, 5, 0, Math.PI * 2);
+        ctx.fillStyle = landmark.isEntryPoint ? '#4caf50' : '#ff9800';
+        ctx.fill();
+      }
+      // Label
+      ctx.fillStyle = '#fff';
+      ctx.font = '11px sans-serif';
+      ctx.textAlign = 'center';
+      ctx.fillText(landmark.name, pos.x, pos.y + 25);
+    }
+
     function drawCamera(camera) {
       const pos = camera.floorPlanPosition;
       const isSelected = selectedItem?.type === 'camera' && selectedItem?.id === camera.deviceId;
@@ -37882,8 +39347,17 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       } else {
         connectionList.innerHTML = topology.connections.map(c => '<div class="connection-item ' + (selectedItem?.type === 'connection' && selectedItem?.id === c.id ? 'selected' : '') + '" onclick="selectConnection(\\'' + c.id + '\\')"><div class="camera-name">' + c.name + '</div><div class="camera-info">' + (c.transitTime.typical / 1000) + 's typical ' + (c.bidirectional ? '<->' : '->') + '</div></div>').join('');
       }
+      // Landmark list
+      const landmarkList = document.getElementById('landmark-list');
+      const landmarks = topology.landmarks || [];
+      if (landmarks.length === 0) {
+        landmarkList.innerHTML = '<div class="landmark-item" style="color: #666; text-align: center; cursor: default; padding: 8px;">No landmarks configured</div>';
+      } else {
+        landmarkList.innerHTML = landmarks.map(l => '<div class="camera-item ' + (selectedItem?.type === 'landmark' && selectedItem?.id === l.id ? 'selected' : '') + '" onclick="selectLandmark(\\'' + l.id + '\\')"><div class="camera-name">' + l.name + '</div><div class="camera-info">' + l.type + (l.isEntryPoint ? ' | Entry' : '') + (l.isExitPoint ? ' | Exit' : '') + '</div></div>').join('');
+      }
       document.getElementById('camera-count').textContent = topology.cameras.length;
       document.getElementById('connection-count').textContent = topology.connections.length;
+      document.getElementById('landmark-count').textContent = landmarks.length;
     }
 
     function selectCamera(deviceId) {
@@ -37954,10 +39428,18 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       const y = e.clientY - rect.top;
 
       if (currentTool === 'select') {
+        // Check cameras first
         for (const camera of topology.cameras) {
           if (camera.floorPlanPosition) {
             const dist = Math.hypot(x - camera.floorPlanPosition.x, y - camera.floorPlanPosition.y);
-            if (dist < 25) { selectCamera(camera.deviceId); dragging = camera; return; }
+            if (dist < 25) { selectCamera(camera.deviceId); dragging = { type: 'camera', item: camera }; return; }
+          }
+        }
+        // Check landmarks
+        for (const landmark of (topology.landmarks || [])) {
+          if (landmark.position) {
+            const dist = Math.hypot(x - landmark.position.x, y - landmark.position.y);
+            if (dist < 20) { selectLandmark(landmark.id); dragging = { type: 'landmark', item: landmark }; return; }
           }
         }
       } else if (currentTool === 'wall') {
@@ -37970,8 +39452,10 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
         currentDrawing = { type: 'room', x: x, y: y, width: 0, height: 0 };
       } else if (currentTool === 'camera') {
         openAddCameraModal();
-        // Will position camera at click location after adding
         topology._pendingCameraPos = { x, y };
+      } else if (currentTool === 'landmark') {
+        openAddLandmarkModal();
+        topology._pendingLandmarkPos = { x, y };
       }
     });
 
@@ -37981,8 +39465,13 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       const y = e.clientY - rect.top;
 
       if (dragging) {
-        dragging.floorPlanPosition.x = x;
-        dragging.floorPlanPosition.y = y;
+        if (dragging.type === 'camera') {
+          dragging.item.floorPlanPosition.x = x;
+          dragging.item.floorPlanPosition.y = y;
+        } else if (dragging.type === 'landmark') {
+          dragging.item.position.x = x;
+          dragging.item.position.y = y;
+        }
         render();
       } else if (isDrawing && currentDrawing) {
         if (currentDrawing.type === 'wall') {