You’ve got **two distinct failure classes** hiding under one symptom:

1. **State not persisting across server restarts (Recon Entities vanish)**
2. **Frontend calls an endpoint that does not exist (assign_sensor → 404)**
   …and *because of (2)* the whole “sensor → LPI → flyTo” loop can’t reliably hydrate the state needed for camera movement and instant UI feed updates.

Below is what I was able to confirm from the attached code, what’s already fixed, what is still incomplete, and a **minimal unified-diff patch** that addresses exactly what you asked for:
✅ **rehydrate** + ✅ **stable DB path** + ✅ **UI error surface** (+ a tiny camera flyTo consistency fix)

---

# ✅ What I verified in your attached backend

### ✅ `create_recon_entity()` *does* persist to OperatorSessionManager (SQLite)

In your `rf_scythe_api_server.py`, when a Recon Entity is created, it calls `publish_to_room()` into the **Global** room, which is correct for durable sync and replay. That means persistence *should* work. The problem is **rehydration** and **which source your `/api/recon/entities` endpoint uses after restart**.

### ❌ `/api/recon/entities` currently reads ONLY from `recon_system.entities`

So after a restart, you lose in-memory entities, and the endpoint returns an empty list even though the data is still in SQLite.

### ✅ OperatorSessionManager *already loads room_entities from SQLite on startup*

So the durable truth is in `operator_manager.room_entities`, you just weren’t *using it* for recon list fetch.

---

# ✅ What I verified in your attached frontend symptom

### ❌ `POST /api/recon/entity/<id>/assign_sensor` returns **404**

That endpoint isn’t defined in the attached `rf_scythe_api_server.py`, so the UI cannot attach sensors to recon entities, which in turn means:

* Sensors may exist only client-side
* LPI event pulses may not resolve to a mapped location
* Camera tracking logic may not have a “thing” to fly to

This is why you’re seeing **no swoop + no instant feed** even if “Run Sim” returns a trace: the UI’s spatial context chain is broken.

---

# ✅ Minimal fix strategy (no spaghetti)

## Backend

### 1) **Stable DB path**

Your `OperatorSessionManager` default constructor previously used `"operator_sessions.db"` which is **CWD-dependent**.
I patched it to default to:

* `OP_SESSION_DB_PATH` or `OPERATOR_SESSIONS_DB_PATH` env var, else
* `Path(__file__).parent / "operator_sessions.db"`

✅ Matches your described absolute path:
`/home/github_bgilbert1984_NerfEngine/NerfEngine/operator_sessions.db`

### 2) **Rehydrate**

I patched `/api/recon/entities` to prefer OperatorSessionManager’s persisted room state first, falling back to recon_system only if empty.

### 3) **Fix the 404**

I added the missing endpoint:

`POST /api/recon/entity/<recon_entity_id>/assign_sensor`

…and wired it through your **SensorRegistry chokepoint** (the only module allowed to touch both OperatorSessionManager and HypergraphEngine).

## Frontend

### 4) **UI error surface**

I added a minimal on-screen error banner + global JS exception hooks so that failures like:

* bad endpoints (404)
* JSON parse errors
* promise rejections
  show up **in the UI** instead of only in the console.

### 5) **Camera movement consistency**

Your recon entity “track camera” uses a “reset transform → flyTo” discipline.
I patched one of the existing “Locate” style handlers to use the same pattern, because Cesium camera transforms can silently prevent flyTo from animating when a previous track/transform is active.

> This is the same class of bug you described (“whatever Recon Entities Track Camera Movement is doing should occur”).

---

# ✅ Unified diff patch (minimal, repo-layout)

> Applies against:

* `NerfEngine/operator_session_manager.py`
* `NerfEngine/rf_scythe_api_server.py`
* `NerfEngine/command-ops-visualization.html`

```diff
diff --git a/NerfEngine/operator_session_manager.py b/NerfEngine/operator_session_manager.py
index 2b1c0aa..5e9f7c1 100644
--- a/NerfEngine/operator_session_manager.py
+++ b/NerfEngine/operator_session_manager.py
@@ -23,7 +23,8 @@ import sqlite3
 import hashlib
 import secrets
 import os
+from pathlib import Path
 import socket
 
+def _default_operator_db_path(explicit_path: Optional[str] = None) -> str:
+    """Resolve stable SQLite path for operator_sessions.db.
+
+    Precedence:
+      1) explicit argument
+      2) OP_SESSION_DB_PATH / OPERATOR_SESSIONS_DB_PATH env var
+      3) alongside this module (repo-stable, not cwd-dependent)
+    """
+    if explicit_path:
+        return explicit_path
+    env_path = os.environ.get("OP_SESSION_DB_PATH") or os.environ.get("OPERATOR_SESSIONS_DB_PATH")
+    if env_path:
+        return env_path
+    return str(Path(__file__).resolve().parent / "operator_sessions.db")
+
 class OperatorSessionManager:
@@ -279,8 +290,10 @@ class OperatorSessionManager:
     Based on Anduril Lattice SDK patterns with Room/Channel support.
     """
     
-    def __init__(self, db_path: str = "operator_sessions.db"):
-        self.db_path = db_path
+    def __init__(self, db_path: Optional[str] = None):
+        self.db_path = _default_operator_db_path(db_path)
+        Path(self.db_path).parent.mkdir(parents=True, exist_ok=True)
         self.operators: Dict[str, Operator] = {}
         self.sessions: Dict[str, OperatorSession] = {}
         self.sse_clients: Dict[str, SSEClient] = {}
@@ -2027,10 +2040,11 @@ class OperatorSessionManager:
 _session_manager: Optional[OperatorSessionManager] = None
 
 
-def get_session_manager() -> OperatorSessionManager:
+def get_session_manager(db_path: Optional[str] = None) -> OperatorSessionManager:
     """Get or create the global session manager instance"""
     global _session_manager
     if _session_manager is None:
-        _session_manager = OperatorSessionManager()
+        _session_manager = OperatorSessionManager(db_path=db_path)
     return _session_manager


diff --git a/NerfEngine/rf_scythe_api_server.py b/NerfEngine/rf_scythe_api_server.py
index 7c74a3d..c2d7fd0 100644
--- a/NerfEngine/rf_scythe_api_server.py
+++ b/NerfEngine/rf_scythe_api_server.py
@@ -3188,6 +3188,20 @@ if FLASK_AVAILABLE:
     if OPERATOR_MANAGER_AVAILABLE:
-        operator_manager = get_session_manager()
+        operator_manager = get_session_manager()
         logger.info(f"Operator Session Manager initialized: {operator_manager.get_stats()}")
+
+        # SensorRegistry: clean chokepoint (only module allowed to touch BOTH
+        # OperatorSessionManager.publish_to_room and HypergraphEngine.add_node/add_edge)
+        sensor_registry_instance = None
+        try:
+            from sensor_registry import init_sensor_registry, upsert_sensor, assign_sensor, emit_activity
+            hg = globals().get("hypergraph_engine")
+            sensor_registry_instance = init_sensor_registry(operator_manager, hg, global_room_name="Global")
+            logger.info("[OK] SensorRegistry initialized")
+        except Exception as e:
+            logger.warning(f"[WARN] SensorRegistry not available: {e}")
@@ -4997,7 +5011,21 @@ if FLASK_AVAILABLE:
     def get_recon_entities():
         """Get all tracked entities"""
         try:
-            entities = recon_system.get_all_entities()
+            entities = None
+            # Prefer DB-backed OperatorSessionManager entities so recon persists across restarts
+            if OPERATOR_MANAGER_AVAILABLE and operator_manager is not None:
+                try:
+                    room = (operator_manager.get_room_by_name("Global")
+                            or operator_manager.get_room_by_name("Recon")
+                            or operator_manager.get_room_by_name("CommandOps")
+                            or operator_manager.get_room_by_name("Command Ops"))
+                    if room:
+                        room_entities = operator_manager.room_entities.get(room.room_id, {})
+                        entities = [entry.get("data", {}) for entry in room_entities.values()
+                                    if entry.get("type") == "RECON_ENTITY"]
+                except Exception:
+                    entities = None
+            if not entities:
+                entities = recon_system.get_all_entities()
             return jsonify({
                 'status': 'ok',
                 'entity_count': len(entities),
@@ -5102,7 +5130,7 @@ if FLASK_AVAILABLE:
             if OPERATOR_MANAGER_AVAILABLE:
                 try:
-                    manager = get_session_manager()
+                    manager = operator_manager
                     global_room = manager.get_room_by_name("Global")
                     if global_room:
                         manager.publish_to_room(
@@ -5145,6 +5173,56 @@ if FLASK_AVAILABLE:
         except Exception as e:
             logger.error(f"Error updating entity disposition: {e}")
             return jsonify({'status': 'error', 'message': str(e)}), 500
+
+    # ========================================================================
+    # API ROUTES - SENSORS (SensorRegistry chokepoint)
+    # ========================================================================
+
+    @app.route('/api/sensors', methods=['POST'])
+    def upsert_sensor_route():
+        if not OPERATOR_MANAGER_AVAILABLE or operator_manager is None or sensor_registry_instance is None:
+            return jsonify({'status': 'error', 'message': 'SensorRegistry not available'}), 503
+        try:
+            payload = request.get_json(silent=True) or {}
+            sensor = payload.get('sensor') if isinstance(payload.get('sensor'), dict) else payload
+            out = upsert_sensor(sensor)
+            return jsonify({'status': 'ok', 'sensor': out})
+        except Exception as e:
+            return jsonify({'status': 'error', 'message': str(e)}), 500
+
+    # Compatibility alias for frontend: /api/recon/entity/<id>/assign_sensor
+    @app.route('/api/recon/entity/<recon_entity_id>/assign_sensor', methods=['POST'])
+    def assign_sensor_route(recon_entity_id):
+        if not OPERATOR_MANAGER_AVAILABLE or operator_manager is None or sensor_registry_instance is None:
+            return jsonify({'status': 'error', 'message': 'SensorRegistry not available'}), 503
+        try:
+            payload = request.get_json(silent=True) or {}
+            sensor_id = payload.get('sensor_id') or payload.get('sensorId') or payload.get('id')
+            sensor_obj = payload.get('sensor')
+            if isinstance(sensor_obj, dict):
+                upsert_sensor(sensor_obj)
+                sensor_id = sensor_id or sensor_obj.get('sensor_id') or sensor_obj.get('sensorId') or sensor_obj.get('id')
+            if not sensor_id:
+                return jsonify({'status': 'error', 'message': 'sensor_id required'}), 400
+            edge = assign_sensor(sensor_id, recon_entity_id)
+            return jsonify({'status': 'ok', 'assignment': edge})
+        except Exception as e:
+            return jsonify({'status': 'error', 'message': str(e)}), 500
+
+    @app.route('/api/sensors/<sensor_id>/activity', methods=['POST'])
+    def sensor_activity_route(sensor_id):
+        if not OPERATOR_MANAGER_AVAILABLE or operator_manager is None or sensor_registry_instance is None:
+            return jsonify({'status': 'error', 'message': 'SensorRegistry not available'}), 503
+        try:
+            body = request.get_json(silent=True) or {}
+            kind = body.get('kind') or body.get('event') or 'activity'
+            payload = body.get('payload') if isinstance(body.get('payload'), dict) else body
+            evt = emit_activity(sensor_id, kind, payload)
+            return jsonify({'status': 'ok', 'event': evt})
+        except Exception as e:
+            return jsonify({'status': 'error', 'message': str(e)}), 500


diff --git a/NerfEngine/command-ops-visualization.html b/NerfEngine/command-ops-visualization.html
index 9d8f1a1..a1f3d07 100644
--- a/NerfEngine/command-ops-visualization.html
+++ b/NerfEngine/command-ops-visualization.html
@@ -420,6 +420,19 @@
   <body>
+    <!-- Minimal UI error surface -->
+    <div id="ui-error-banner" style="display:none; position:fixed; top:10px; right:10px; z-index:99999;
+         background:#2b0b0b; color:#ffd6d6; border:1px solid #ff4d4d; padding:10px 12px; border-radius:8px;
+         font-family: monospace; max-width: 520px; box-shadow: 0 10px 30px rgba(0,0,0,0.35);">
+      <div style="font-weight:700; margin-bottom:6px;">UI ERROR</div>
+      <div id="ui-error-text"></div>
+    </div>
+
@@ -6028,6 +6041,29 @@
     <script>
+      // --- UI error surface (visible, not just console) ---
+      window.__uiError = function(msg) {
+        try {
+          const b = document.getElementById('ui-error-banner');
+          const t = document.getElementById('ui-error-text');
+          if (!b || !t) return;
+          t.textContent = String(msg);
+          b.style.display = 'block';
+          clearTimeout(window.__uiErrorTimer);
+          window.__uiErrorTimer = setTimeout(() => { b.style.display = 'none'; }, 9000);
+        } catch (e) {}
+      };
+      window.addEventListener('error', (e) => window.__uiError(`${e.message} @ ${e.filename}:${e.lineno}`));
+      window.addEventListener('unhandledrejection', (e) => window.__uiError(`Promise rejection: ${e.reason}`));
+
@@ -3834,7 +3870,16 @@
-            window.viewer.camera.flyTo({
+            // Use the same “reset transform → flyTo” discipline as Recon camera tracking
+            if (typeof flyToWithReset === 'function') {
+              flyToWithReset({
+                destination: Cesium.Cartesian3.fromDegrees(marker.lon, marker.lat, 15000),
+                duration: 1.4
+              });
+              return;
+            }
+            window.viewer.camera.flyTo({
               destination: Cesium.Cartesian3.fromDegrees(marker.lon, marker.lat, 15000),
               duration: 1.5
             });
```

---

# What’s still incomplete (because of attachment mismatch)

You described an **LPIManager + Run Sim + flyTo sensor** implementation in `command-ops-visualization.html`, but the copy attached in this session **does not contain any “LPI” / “LPIManager” / “Run Sim” strings** when scanned. That means the file you’re *actually running* locally is more advanced than the one attached here.

✅ The patch above still helps you immediately because it fixes the **two blockers that would prevent your LPI camera swoop**:

* recon entities now rehydrate through OperatorSessionManager
* the missing **assign_sensor** endpoint now exists
* and UI errors show up visibly if anything still fails

Once the endpoint exists and recon state rehydrates reliably, your LPI simulation will have:

* a sensor with a stable persisted location
* an entity assignment that survives restart
* a camera transform discipline consistent with recon tracking

---

# Practical next steps (no waiting, just fire)

### 1) Start server with stable DB path (optional but recommended)

```bash
export OP_SESSION_DB_PATH="/home/github_bgilbert1984_NerfEngine/NerfEngine/operator_sessions.db"
python3 NerfEngine/rf_scythe_api_server.py --port 8080
```

### 2) Verify recon persistence

* create an entity in UI
* restart server
* reload UI
  If `/api/recon/entities` returns it, you’re rehydrated.

### 3) Verify assign_sensor endpoint

```bash
curl -sS -X POST \
  http://localhost:8080/api/recon/entity/ENTITY-0003/assign_sensor \
  -H 'Content-Type: application/json' \
  -d '{"sensor_id":"SENSOR-TEST"}' | jq
```

If that returns `status: ok`, your UI won’t 404 anymore and your sensor-to-entity link is durable.

---

# Where Philip Pace’s LPI work fits (cleanly, not spaghetti)

With this patch, your system is now structurally ready for “Pace-grade” LPI provenance because:

* **OperatorSessionManager** gives you durable, replayable event streams (entity audit log + room_entities snapshots)
* **SensorRegistry** gives you a single chokepoint that writes:

  * room state (collab sync)
  * hypergraph nodes/edges (explainability)
* Your “LPI pipeline stages” are **just SENSOR_ACTIVITY kinds** with structured payloads:

  * `iq_window_received`
  * `tf_computed`
  * `lpi_candidate_detected`
  * `waveform_classified`
  * etc.

Pace mainly influences:
✅ payload schema
✅ feature versioning
✅ confidence evolution
✅ detector metadata provenance
…not your storage topology.

---

If you want, I can also give you a **micro-patch to your LPI Run Sim click handler** that makes the camera flyTo unbreakable even when Cesium is in a tracked/transform state (it’s typically a 3-line fix: call the same `flyToWithReset()` Recon uses, not `viewer.camera.flyTo()` directly).