feat(simulation): sprint 9 gauntlet — test infrastructure and first 3 rooms

Add Gauntlet test world with 3 rooms (Inventory Warehouse, Occlusion
Corridor, Pause Chamber) + Central Hub, room constants module, room
reset trigger mechanism, Layer 3 subprocess integration test, golden
file comparison engine and test suite, and content runtime validation.

Tickets: #482, #484, #485, #487, #488, #489, #490

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

server/tests/content_loading.rs

@@ -3,6 +3,9 @@
 //! Tests the full pipeline: discover content → deserialize YAML → spawn ECS entities.
 //! Uses real content files from content/ directory for structural content,
 //! and a test fixture for isolated NPC profile spawning.
+//!
+//! Also includes runtime validation (#489): boot the full plugin stack with real
+//! content, tick 10 times over TCP, and assert a valid ObserverSnapshot.
 
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
@@ -416,3 +419,130 @@ fn spawn_real_content_with_relationships_and_secrets() {
         .expect("Nils should have Want");
     assert_eq!(nils_want.primary, npc::WantKind::Power);
 }
+
+// -----------------------------------------------------------------------
+// Test: Runtime validation — boot + tick 10 + snapshot (#489)
+//
+// Smoke test for production content. Boots the full plugin stack with real
+// content over TCP, ticks 10 times, and asserts a valid ObserverSnapshot.
+// Catches runtime panics from broken entity references, missing components,
+// or content schema issues that pass YAML validation but fail at tick time.
+// -----------------------------------------------------------------------
+
+#[test]
+fn content_runtime_boot_tick_10_snapshot() {
+    use settled_reach_server::bridge::framing::{read_framed, write_framed};
+    use settled_reach_server::bridge::tcp::TcpBridge;
+    use settled_reach_server::bridge::types::*;
+    use settled_reach_server::bridge::{BridgePlugin, BridgeResource};
+    use settled_reach_server::knowledge::KnowledgeGraph;
+    use settled_reach_server::perception::cognitive_delay::CognitiveDelay;
+    use settled_reach_server::perception::vision_cone::Facing;
+    use settled_reach_server::simulation::interaction::NearbyInteractionBuffer;
+    use settled_reach_server::simulation::listening::ListeningFocus;
+    use settled_reach_server::simulation::monologue::{
+        MonologueBuffer, MonologueState, SprintAnomalyQueue,
+    };
+    use settled_reach_server::simulation::movement::{PlayerCharacter, TilePosition, WalkabilityMap};
+    use settled_reach_server::simulation::stance::{MovementProfile, PlayerMoveCooldown};
+    use std::io::{BufReader, BufWriter};
+    use std::net::{TcpListener, TcpStream};
+    use std::thread;
+
+    let root = content_root();
+    if !root.join("content.yaml").exists() {
+        eprintln!("Skipping: content directory not found at {:?}", root);
+        return;
+    }
+
+    let listener = TcpListener::bind("127.0.0.1:0").expect("bind listener");
+    let server_addr = listener.local_addr().expect("get local addr");
+
+    // Server thread: full plugin stack with real content
+    let server_handle = thread::spawn(move || {
+        let bridge = TcpBridge::accept_on(listener).expect("accept connection");
+
+        let mut app = App::new();
+        app.add_plugins(SimulationPlugin);
+        app.add_plugins(BridgePlugin);
+        app.add_plugins(settled_reach_server::knowledge::KnowledgePlugin);
+        app.add_plugins(settled_reach_server::npc::NpcPlugin);
+        app.insert_resource(ContentConfig {
+            content_root: root,
+            ..Default::default()
+        });
+        app.add_plugins(ContentPlugin);
+        app.insert_resource(BridgeResource::new(bridge));
+        app.insert_resource(WalkabilityMap::new(32, 32, 1));
+
+        // Spawn player with all required observer pipeline components
+        let profile = MovementProfile::smuggler();
+        app.world_mut().spawn((
+            PlayerCharacter,
+            TilePosition::new(16, 16, 0),
+            Facing::default(),
+            KnowledgeGraph::new(),
+            NearbyInteractionBuffer::default(),
+            MonologueState::default(),
+            MonologueBuffer::default(),
+            SprintAnomalyQueue::default(),
+            CognitiveDelay::default(),
+            ListeningFocus::new(TilePosition::new(16, 16, 0)),
+            profile,
+            profile.initial_stance(),
+            PlayerMoveCooldown::default(),
+        ));
+
+        // Tick 10 times — any panic here means content has a runtime bug
+        for _ in 0..10 {
+            app.update();
+        }
+    });
+
+    // Client: connect and receive 10 snapshots
+    let stream = TcpStream::connect(server_addr).expect("client connect");
+    let mut reader = BufReader::new(stream.try_clone().expect("clone for reader"));
+    let mut writer = BufWriter::new(stream);
+
+    let mut last_snapshot = None;
+    for tick in 0..10 {
+        let payload = read_framed(&mut reader)
+            .unwrap_or_else(|e| panic!("read error at tick {}: {}", tick, e))
+            .unwrap_or_else(|| panic!("unexpected EOF at tick {}", tick));
+
+        let snapshot: ObserverSnapshot = rmp_serde::from_slice(&payload)
+            .unwrap_or_else(|e| panic!("deserialization error at tick {}: {}", tick, e));
+
+        last_snapshot = Some(snapshot);
+
+        // Send empty input for next tick
+        let empty: Vec<PlayerInput> = vec![];
+        let input_payload = rmp_serde::to_vec(&empty).expect("serialize empty input");
+        if let Err(_) = write_framed(&mut writer, &input_payload) {
+            // Server may have shut down after tick 10 — that's fine
+            break;
+        }
+    }
+
+    drop(reader);
+    drop(writer);
+
+    // Server thread must not have panicked
+    server_handle
+        .join()
+        .expect("server thread panicked — content triggered a runtime error during tick processing");
+
+    // Validate final snapshot
+    let snapshot = last_snapshot.expect("should have received at least one snapshot");
+    assert_eq!(
+        snapshot.version, PROTOCOL_VERSION,
+        "snapshot protocol version mismatch"
+    );
+    // Content-spawned NPCs should be visible (they all spawn at 0,0,0 by default)
+    // The player is at 16,16 — content NPCs are far away but the player entity itself
+    // should always be in the snapshot
+    assert!(
+        !snapshot.entities.is_empty(),
+        "snapshot should contain at least the player entity"
+    );
+}