v7.5.0 — Emergency Mode (capstone)

The feature that orchestrates the rest. NOMAD already had every
component you need for a live event — SITREP, watch rotation,
incidents, contacts, AI, Situation Room, proximity alerts — but
nothing that glued them together when the balloon went up.

Emergency Mode does.

Enter flow:
  - Sidebar "EMERGENCY" button (red, always visible) opens a modal
  - User types a brief reason (e.g. "Tornado warning")
  - On confirm: writes emergency_active=true to settings, creates a
    critical incident in the timeline, broadcasts SSE event to every
    open tab, Voice Copilot announces the activation via TTS

Active state:
  - Persistent red banner across every tab (fixed, top)
  - Live duration counter (updates every minute)
  - Body gets .emergency-mode class → 3px red glow inset on shell
  - Animated pulse on banner (respects prefers-reduced-motion)
  - Sidebar enter button hides
  - Banner survives page reloads (state read from settings on DOMContentLoaded)
  - Multi-tab safe — every open NOMAD window syncs via SSE

Exit flow:
  - Exit button opens a closeout modal with a free-form note
  - On confirm: clears state, writes an "Emergency mode exited (Xh):
    <reason>" incident with the closeout note appended, broadcasts
    SSE exit, TTS announces, banner dismisses
  - Closeout incident gives you an auditable after-action review
    entry without any separate form

All operations idempotent:
  - Entering while already active → returns existing state, no mutation
  - Exiting while inactive → no-op

Files:
  - web/blueprints/emergency.py (new) — 3 endpoints, settings-backed state
  - web/templates/index_partials/_shell.html — sidebar button, banner,
    enter + exit modals
  - web/templates/index_partials/js/_app_init_runtime.js — state apply,
    tick interval, enter/exit handlers
  - web/templates/index_partials/js/_app_shell_router.js — 6 shell
    actions
  - web/static/js/events.js — SSE subscriptions for cross-tab sync
  - web/blueprints/system.py — 4 new keys in SETTINGS_WHITELIST for
    config-restore round-trip safety
  - web/static/css/app/40_preparedness_media.css — banner, button,
    modal styling

9 new tests: status-default, enter-then-status, idempotent enter,
idempotent exit, enter-then-exit, creates-incident, creates-closeout-
incident, default-reason-if-blank, reason-truncated-to-500.

Tests: 870 passed (was 861).

This closes the 5-feature arc (v7.1 Voice Copilot, v7.2 Location-aware
SR, v7.3 Kit Builder, v7.4 Route Plan, v7.5 Emergency Mode). Each
feature stands alone but they compound: Emergency Mode uses the Voice
Copilot for audible announcements, the Situation Room proximity for
relevant context, and the Kit Builder's resource model lives nearby
for quick reference during a live event.

Author: FOSSFOREVER

README.md

@@ -1,7 +1,7 @@
 <div align="center">
 <img src="nomad-mark.png" width="140" height="140"/>
 
-# NOMAD Field Desk v7.4.0
+# NOMAD Field Desk v7.5.0
 
 ### Your Personal Intelligence & Preparedness Command Center
 

config.py

@@ -36,7 +36,7 @@ class Config:
     """Central configuration with environment variable overrides."""
 
     # --- App Identity ---
-    VERSION = os.environ.get('NOMAD_VERSION', '7.4.0')
+    VERSION = os.environ.get('NOMAD_VERSION', '7.5.0')
 
     # --- Upload / Content Limits ---
     MAX_CONTENT_LENGTH = int(os.environ.get('NOMAD_MAX_CONTENT_LENGTH', 100 * 1024 * 1024))  # 100 MB

installer.iss

@@ -1,8 +1,8 @@
 ; NOMAD Field Desk Inno Setup Script
-; AppVersion: 7.4.0
+; AppVersion: 7.5.0
 
 #define MyAppName "NOMAD Field Desk"
-#define MyAppVersion "7.4.0"
+#define MyAppVersion "7.5.0"
 #define MyAppPublisher "SysAdminDoc"
 #define MyAppURL "https://github.com/SysAdminDoc/project-nomad-desktop"
 #define MyAppSupportURL "https://github.com/SysAdminDoc/project-nomad-desktop/issues"

tests/test_emergency.py

@@ -0,0 +1,91 @@
+"""Tests for Emergency Mode (v7.5.0).
+
+Covers idempotency (enter-while-active, exit-while-inactive), state
+persistence across status/enter/exit cycles, and the incident side-
+effects that make the feature auditable.
+"""
+
+
+class TestEmergencyMode:
+    def test_status_defaults_inactive(self, client):
+        resp = client.get('/api/emergency/status')
+        assert resp.status_code == 200
+        data = resp.get_json()
+        assert data['active'] is False
+        assert data['started_at'] is None
+        assert data['reason'] == ''
+
+    def test_enter_then_status_shows_active(self, client):
+        resp = client.post('/api/emergency/enter', json={'reason': 'Severe weather'})
+        assert resp.status_code == 201
+        data = resp.get_json()
+        assert data['active'] is True
+        assert data['reason'] == 'Severe weather'
+        assert data['started_at'] is not None
+
+        # Status endpoint now reflects it
+        status = client.get('/api/emergency/status').get_json()
+        assert status['active'] is True
+        assert status['reason'] == 'Severe weather'
+        assert status['duration_hours'] is not None
+        assert status['duration_hours'] >= 0
+
+    def test_enter_when_already_active_is_idempotent(self, client):
+        client.post('/api/emergency/enter', json={'reason': 'First reason'})
+        resp = client.post('/api/emergency/enter', json={'reason': 'Second reason'})
+        # Doesn't 400 or 500, doesn't overwrite the existing state
+        assert resp.status_code == 200
+        data = resp.get_json()
+        assert data.get('already_active') is True
+        # Original reason preserved
+        assert data['reason'] == 'First reason'
+
+    def test_exit_when_not_active_is_idempotent(self, client):
+        resp = client.post('/api/emergency/exit', json={})
+        assert resp.status_code == 200
+        data = resp.get_json()
+        assert data['active'] is False
+        assert data.get('already_inactive') is True
+
+    def test_enter_then_exit(self, client):
+        client.post('/api/emergency/enter', json={'reason': 'Test'})
+        resp = client.post('/api/emergency/exit', json={'closeout_note': 'All clear'})
+        assert resp.status_code == 200
+        data = resp.get_json()
+        assert data['active'] is False
+        assert data['duration_hours'] is not None
+        # Status now reports inactive
+        status = client.get('/api/emergency/status').get_json()
+        assert status['active'] is False
+
+    def test_enter_creates_incident(self, client):
+        client.post('/api/emergency/enter', json={'reason': 'Tornado warning'})
+        # There should now be at least one critical incident
+        incidents = client.get('/api/incidents').get_json()
+        assert any(
+            i.get('severity') == 'critical' and 'Tornado warning' in (i.get('description') or '')
+            for i in incidents
+        ), 'Expected a critical incident for emergency entry'
+
+    def test_exit_creates_closeout_incident(self, client):
+        client.post('/api/emergency/enter', json={'reason': 'Fire'})
+        client.post('/api/emergency/exit', json={'closeout_note': 'Fire extinguished'})
+        incidents = client.get('/api/incidents').get_json()
+        closeouts = [
+            i for i in incidents
+            if 'exited' in (i.get('description') or '').lower()
+        ]
+        assert closeouts, 'Expected a closeout incident on exit'
+        assert any('Fire extinguished' in (i.get('description') or '') for i in closeouts)
+
+    def test_default_reason_if_blank(self, client):
+        resp = client.post('/api/emergency/enter', json={})
+        data = resp.get_json()
+        assert data['reason'] == 'Emergency'  # default
+
+    def test_reason_truncated_to_500(self, client):
+        """Reason longer than 500 chars should be truncated, not 500 error."""
+        long_reason = 'x' * 1000
+        resp = client.post('/api/emergency/enter', json={'reason': long_reason})
+        assert resp.status_code == 201
+        assert len(resp.get_json()['reason']) == 500

web/app.py

@@ -1281,6 +1281,10 @@ def api_offline_changes_since():
     from web.blueprints.kit_builder import kit_builder_bp
     app.register_blueprint(kit_builder_bp)
 
+    # ─── Emergency Mode (v7.5.0 — crisis orchestrator) ───────────────
+    from web.blueprints.emergency import emergency_bp
+    app.register_blueprint(emergency_bp)
+
     # ─── User Plugins ─────────────────────────────────────────────────
     from web.plugins import load_plugins
     load_plugins(app)

web/blueprints/emergency.py

@@ -0,0 +1,208 @@
+"""Emergency Mode — the "balloon went up" orchestrator (v7.5.0).
+
+NOMAD has every component you need in an active crisis (SITREP, watch
+rotation, incidents, contacts, AI, Situation Room alerts, proximity,
+etc.) but nothing that *orchestrates* them for a live event. The user
+shouldn't have to remember to start a watch schedule, log an incident,
+and generate a SITREP separately. Emergency Mode does it for you.
+
+Entering Emergency Mode:
+  1. Writes a persistent state flag to settings (emergency_active=true,
+     emergency_started_at, emergency_reason).
+  2. Auto-creates an incident log entry with severity=critical and the
+     user-supplied reason.
+  3. Broadcasts an SSE event so every open tab can enter red-mode UI
+     without polling.
+
+Exiting Emergency Mode:
+  1. Clears the state flags.
+  2. Appends a close-out incident log entry with total duration.
+  3. Broadcasts an SSE event so UI drops out of red mode.
+
+All operations are idempotent — entering while already active is a
+no-op (returns the existing state); exiting while inactive is a no-op.
+This matters because a page reload during active emergency mode must
+restore the banner without double-entering.
+"""
+
+import logging
+from datetime import datetime, timezone
+
+from flask import Blueprint, request, jsonify, current_app
+
+from db import db_session, log_activity
+
+emergency_bp = Blueprint('emergency', __name__)
+log = logging.getLogger('nomad.emergency')
+
+_STATE_KEYS = {
+    'emergency_active':     'False',
+    'emergency_started_at': '',
+    'emergency_reason':     '',
+    'emergency_incident_id': '',
+}
+
+
+def _read_state(db):
+    """Load the emergency state dict from settings. Missing keys default."""
+    keys = tuple(_STATE_KEYS.keys())
+    placeholders = ','.join('?' * len(keys))
+    rows = db.execute(
+        f'SELECT key, value FROM settings WHERE key IN ({placeholders})',
+        keys,
+    ).fetchall()
+    got = {r['key']: r['value'] for r in rows}
+    return {
+        'active': (got.get('emergency_active', 'False') or '').lower() == 'true',
+        'started_at': got.get('emergency_started_at') or None,
+        'reason': got.get('emergency_reason') or '',
+        'incident_id': _parse_int(got.get('emergency_incident_id')),
+    }
+
+
+def _write_state(db, **kwargs):
+    """Upsert any subset of the emergency_* settings keys."""
+    for key, val in kwargs.items():
+        full_key = f'emergency_{key}'
+        if full_key not in _STATE_KEYS:
+            continue
+        db.execute(
+            'INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)',
+            (full_key, str(val) if val is not None else ''),
+        )
+
+
+def _parse_int(v):
+    try: return int(v) if v not in (None, '') else None
+    except (TypeError, ValueError): return None
+
+
+def _duration_hours(started_iso):
+    """Hours (float) between started_iso and now. None on bad input."""
+    if not started_iso:
+        return None
+    try:
+        started = datetime.fromisoformat(started_iso.replace('Z', '+00:00'))
+    except (TypeError, ValueError):
+        return None
+    if started.tzinfo is None:
+        started = started.replace(tzinfo=timezone.utc)
+    return round((datetime.now(timezone.utc) - started).total_seconds() / 3600, 2)
+
+
+def _broadcast(event_type, payload):
+    """Fire an SSE event so every open tab syncs without polling."""
+    try:
+        from web.app import _broadcast_event  # circular-safe: only imported at call-time
+        _broadcast_event(event_type, payload)
+    except Exception:
+        # SSE is a nice-to-have; never let a broadcast error block state change
+        pass
+
+
+# ─── Routes ─────────────────────────────────────────────────────────
+
+@emergency_bp.route('/api/emergency/status')
+def api_emergency_status():
+    """Return the current emergency state + derived duration.
+
+    Also used on page load so every tab can pick up the banner after
+    a reload without separately querying settings.
+    """
+    with db_session() as db:
+        state = _read_state(db)
+    state['duration_hours'] = _duration_hours(state['started_at'])
+    return jsonify(state)
+
+
+@emergency_bp.route('/api/emergency/enter', methods=['POST'])
+def api_emergency_enter():
+    """Enter emergency mode. Idempotent — returns current state if
+    already active. Body: ``{reason}`` (optional, default 'Emergency').
+    """
+    data = request.get_json() or {}
+    reason = (data.get('reason') or 'Emergency').strip()[:500]
+    now_iso = datetime.now(timezone.utc).isoformat()
+
+    with db_session() as db:
+        state = _read_state(db)
+        if state['active']:
+            # Already active — return current state without mutation
+            state['duration_hours'] = _duration_hours(state['started_at'])
+            return jsonify({**state, 'already_active': True})
+
+        # Create a critical incident for the timeline
+        incident_id = None
+        try:
+            cur = db.execute(
+                'INSERT INTO incidents (severity, category, description) VALUES (?, ?, ?)',
+                ('critical', 'emergency', f'Emergency mode entered: {reason}'),
+            )
+            incident_id = cur.lastrowid
+        except Exception as e:
+            log.warning(f'Could not create incident on emergency enter: {e}')
+
+        _write_state(db,
+            active='True',
+            started_at=now_iso,
+            reason=reason,
+            incident_id=incident_id if incident_id is not None else '',
+        )
+        db.commit()
+        try:
+            log_activity('emergency_enter', f'Emergency mode activated: {reason}')
+        except Exception:
+            pass
+
+    _broadcast('emergency_enter', {'reason': reason, 'started_at': now_iso})
+    return jsonify({
+        'active': True,
+        'started_at': now_iso,
+        'reason': reason,
+        'incident_id': incident_id,
+        'duration_hours': 0.0,
+    }), 201
+
+
+@emergency_bp.route('/api/emergency/exit', methods=['POST'])
+def api_emergency_exit():
+    """Exit emergency mode. Idempotent — no-op if not currently active.
+    Body: ``{closeout_note}`` (optional) gets logged to the incident.
+    """
+    data = request.get_json() or {}
+    closeout = (data.get('closeout_note') or '').strip()[:2000]
+
+    with db_session() as db:
+        state = _read_state(db)
+        if not state['active']:
+            return jsonify({**state, 'already_inactive': True})
+
+        duration = _duration_hours(state['started_at'])
+        duration_str = f'{duration}h' if duration is not None else 'unknown duration'
+        exit_reason = state['reason'] or 'Emergency'
+
+        # Log the closeout as a second incident entry for the timeline
+        try:
+            msg = f'Emergency mode exited ({duration_str}): {exit_reason}'
+            if closeout:
+                msg += f' — {closeout}'
+            db.execute(
+                'INSERT INTO incidents (severity, category, description) VALUES (?, ?, ?)',
+                ('info', 'emergency', msg),
+            )
+        except Exception as e:
+            log.warning(f'Could not create incident on emergency exit: {e}')
+
+        _write_state(db, active='False', started_at='', reason='', incident_id='')
+        db.commit()
+        try:
+            log_activity('emergency_exit', f'Emergency mode deactivated ({duration_str})')
+        except Exception:
+            pass
+
+    _broadcast('emergency_exit', {'duration_hours': duration})
+    return jsonify({
+        'active': False,
+        'duration_hours': duration,
+        'reason': exit_reason,
+    })

web/blueprints/system.py

@@ -112,6 +112,11 @@ def api_settings():
     # the Situation Room "Proximity Board" to filter global feeds to threats
     # within a given distance of the user's location.
     'latitude', 'longitude', 'proximity_radius_km',
+    # Emergency Mode state — managed by /api/emergency/enter and /exit,
+    # whitelisted here so a factory-reset / config-restore round-trip
+    # can include them.
+    'emergency_active', 'emergency_started_at', 'emergency_reason',
+    'emergency_incident_id',
 }
 
 @system_bp.route('/api/settings', methods=['PUT'])