test(simulation): sprint 10 — replay loading, content scaling, serialization v9, observer tests

#483: Replay loading in test-client — JSONL file loading, tick-scheduled
PlayerInput sending, 13 unit tests, 3 sample replay files.
#500: Content scaling test — baseline + extra NPC comparative, tick budget
assertion (D-026), determinism check across content packs.
#514: Serialization tests for protocol v9 — blocked_entities roundtrip,
backward compat (v5→v9, v8→v9), regenerated msgpack fixtures.
Observer perception tests for confrontation + walk-away mechanics.

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

server/src/perception/observer/tests.rs

@@ -2030,3 +2030,213 @@ fn no_cognitive_delay_component_means_empty_pending_recognitions() {
         "no CognitiveDelay component should produce empty pending_recognitions"
     );
 }
+
+// -----------------------------------------------------------------------
+// blocked_entities debug field tests (#514)
+// -----------------------------------------------------------------------
+
+#[test]
+fn blocked_entities_empty_when_all_visible() {
+    let mut world = setup_world(32, 32);
+    let mut registry = EntityRegistry::new(0);
+
+    let npc = world
+        .spawn((crate::npc::Npc, TilePosition::new(16, 14, 0)))
+        .id();
+    registry.register(npc);
+
+    let player = world
+        .spawn((
+            PlayerCharacter,
+            TilePosition::new(16, 16, 0),
+            Facing(FacingDirection::North),
+            KnowledgeGraph::new(),
+            NearbyInteractionBuffer::default(),
+            MonologueBuffer::default(),
+        ))
+        .id();
+    registry.register(player);
+    world.insert_resource(registry);
+
+    run_observer_pipeline(&mut world);
+
+    let buffer = world.resource::<SnapshotBuffer>();
+    let snapshot = buffer.snapshot.as_ref().unwrap();
+    assert!(
+        snapshot.blocked_entities.is_empty(),
+        "no blocked entities when NPC is in LOS"
+    );
+}
+
+#[test]
+fn npc_behind_wall_appears_in_blocked_entities() {
+    let mut world = setup_world(32, 32);
+    let mut registry = EntityRegistry::new(0);
+
+    // Wall between player and NPC
+    world
+        .resource_mut::<WalkabilityMap>()
+        .set_walkable(&TilePosition::new(16, 14, 0), false);
+
+    // NPC behind the wall
+    let npc = world
+        .spawn((crate::npc::Npc, TilePosition::new(16, 12, 0)))
+        .id();
+    let npc_sid = registry.register(npc);
+
+    let player = world
+        .spawn((
+            PlayerCharacter,
+            TilePosition::new(16, 16, 0),
+            Facing(FacingDirection::North),
+            KnowledgeGraph::new(),
+            NearbyInteractionBuffer::default(),
+            MonologueBuffer::default(),
+        ))
+        .id();
+    registry.register(player);
+    world.insert_resource(registry);
+
+    run_observer_pipeline(&mut world);
+
+    let buffer = world.resource::<SnapshotBuffer>();
+    let snapshot = buffer.snapshot.as_ref().unwrap();
+    assert!(
+        snapshot.blocked_entities.contains(&npc_sid.0),
+        "NPC behind wall should appear in blocked_entities"
+    );
+    // Not in visible entities
+    let npc_visible = snapshot
+        .entities
+        .iter()
+        .any(|e| e.entity_id == npc_sid.0);
+    assert!(!npc_visible, "NPC should not be in visible entities");
+}
+
+#[test]
+fn npc_behind_player_appears_in_blocked_entities() {
+    let mut world = setup_world(32, 32);
+    let mut registry = EntityRegistry::new(0);
+
+    // NPC far behind player (south, outside vision cone)
+    let npc = world
+        .spawn((crate::npc::Npc, TilePosition::new(16, 26, 0)))
+        .id();
+    let npc_sid = registry.register(npc);
+
+    let player = world
+        .spawn((
+            PlayerCharacter,
+            TilePosition::new(16, 16, 0),
+            Facing(FacingDirection::North),
+            KnowledgeGraph::new(),
+            NearbyInteractionBuffer::default(),
+            MonologueBuffer::default(),
+        ))
+        .id();
+    registry.register(player);
+    world.insert_resource(registry);
+
+    run_observer_pipeline(&mut world);
+
+    let buffer = world.resource::<SnapshotBuffer>();
+    let snapshot = buffer.snapshot.as_ref().unwrap();
+    assert!(
+        snapshot.blocked_entities.contains(&npc_sid.0),
+        "NPC in blind spot should appear in blocked_entities"
+    );
+}
+
+#[test]
+fn different_z_level_not_in_blocked_entities() {
+    let mut world = setup_world(32, 32);
+    let mut registry = EntityRegistry::new(0);
+
+    // NPC on a different z-level
+    let npc = world
+        .spawn((crate::npc::Npc, TilePosition::new(16, 14, 1)))
+        .id();
+    let npc_sid = registry.register(npc);
+
+    let player = world
+        .spawn((
+            PlayerCharacter,
+            TilePosition::new(16, 16, 0),
+            Facing::default(),
+            KnowledgeGraph::new(),
+            NearbyInteractionBuffer::default(),
+            MonologueBuffer::default(),
+        ))
+        .id();
+    registry.register(player);
+    world.insert_resource(registry);
+
+    run_observer_pipeline(&mut world);
+
+    let buffer = world.resource::<SnapshotBuffer>();
+    let snapshot = buffer.snapshot.as_ref().unwrap();
+    assert!(
+        !snapshot.blocked_entities.contains(&npc_sid.0),
+        "NPC on different z-level should NOT be in blocked_entities"
+    );
+}
+
+#[test]
+fn blocked_entities_sorted_ascending() {
+    // Multiple blocked NPCs should appear in ascending entity_id order
+    let mut world = setup_world(32, 32);
+    let mut registry = EntityRegistry::new(0);
+
+    // Wall blocks north
+    world
+        .resource_mut::<WalkabilityMap>()
+        .set_walkable(&TilePosition::new(16, 14, 0), false);
+
+    // Two NPCs behind wall + one behind player
+    let npc_a = world
+        .spawn((crate::npc::Npc, TilePosition::new(16, 12, 0)))
+        .id();
+    let npc_a_sid = registry.register(npc_a);
+
+    let npc_b = world
+        .spawn((crate::npc::Npc, TilePosition::new(16, 10, 0)))
+        .id();
+    let npc_b_sid = registry.register(npc_b);
+
+    let npc_c = world
+        .spawn((crate::npc::Npc, TilePosition::new(16, 26, 0)))
+        .id();
+    let npc_c_sid = registry.register(npc_c);
+
+    let player = world
+        .spawn((
+            PlayerCharacter,
+            TilePosition::new(16, 16, 0),
+            Facing(FacingDirection::North),
+            KnowledgeGraph::new(),
+            NearbyInteractionBuffer::default(),
+            MonologueBuffer::default(),
+        ))
+        .id();
+    registry.register(player);
+    world.insert_resource(registry);
+
+    run_observer_pipeline(&mut world);
+
+    let buffer = world.resource::<SnapshotBuffer>();
+    let snapshot = buffer.snapshot.as_ref().unwrap();
+
+    assert!(snapshot.blocked_entities.len() >= 3);
+    // Must be sorted ascending (BTreeSet guarantee)
+    for i in 1..snapshot.blocked_entities.len() {
+        assert!(
+            snapshot.blocked_entities[i - 1] < snapshot.blocked_entities[i],
+            "blocked_entities not sorted: {:?}",
+            snapshot.blocked_entities
+        );
+    }
+    // All three NPCs should be present
+    assert!(snapshot.blocked_entities.contains(&npc_a_sid.0));
+    assert!(snapshot.blocked_entities.contains(&npc_b_sid.0));
+    assert!(snapshot.blocked_entities.contains(&npc_c_sid.0));
+}

server/tests/bridge_ipc.rs

@@ -59,6 +59,7 @@ fn snapshot_roundtrip_over_unix_socket() {
             current_monologue: None,
             pending_recognitions: vec![],
             dialogue_response: None,
+            blocked_entities: vec![],
         };
 
         bridge

server/tests/bridge_tcp.rs

@@ -45,6 +45,7 @@ fn snapshot_roundtrip_over_tcp() {
             current_monologue: None,
             pending_recognitions: vec![],
             dialogue_response: None,
+            blocked_entities: vec![],
         };
 
         bridge

server/tests/content_scaling.rs

@@ -0,0 +1,257 @@
+//! Content scaling test (#500, D-026).
+//!
+//! Verifies that adding extra NPCs doesn't degrade tick timing beyond
+//! acceptable bounds. Runs the Gauntlet baseline, then adds additional
+//! NPCs and compares:
+//!   1. Tick timing stays within D-026 budget (100ms)
+//!   2. Baseline entities still behave identically (deterministic)
+//!
+//! Run with: cargo test --test content_scaling -- --nocapture
+
+use bevy_app::prelude::*;
+use std::time::Instant;
+
+use settled_reach_server::bridge::types::*;
+use settled_reach_server::bridge::BridgePlugin;
+use settled_reach_server::knowledge::registry::{EntityRegistry, StableEntityId};
+use settled_reach_server::knowledge::KnowledgePlugin;
+use settled_reach_server::npc::{Contentment, Npc, NpcPlugin, ToleranceThreshold, Want, WantKind};
+use settled_reach_server::simulation::interaction::Interactable;
+use settled_reach_server::simulation::movement::TilePosition;
+use settled_reach_server::simulation::path_follow::MovementSpeed;
+use settled_reach_server::simulation::SimulationPlugin;
+
+/// Number of ticks to run for timing measurements.
+const TIMING_TICKS: usize = 50;
+
+/// D-026 budget: 100ms per tick maximum.
+const MAX_TICK_MS: f64 = 100.0;
+
+/// Extra NPC counts for scaling tiers.
+const EXTRA_NPC_COUNTS: &[usize] = &[0, 15, 50];
+
+/// Set up a Gauntlet world and return the app.
+fn setup_baseline() -> App {
+    let mut app = App::new();
+    app.add_plugins(SimulationPlugin);
+    app.add_plugins(BridgePlugin);
+    app.add_plugins(KnowledgePlugin);
+    app.add_plugins(NpcPlugin);
+
+    #[cfg(feature = "gauntlet")]
+    settled_reach_server::test_world::setup_gauntlet(&mut app);
+
+    app
+}
+
+/// Spawn N extra NPCs spread across the Gauntlet hub area.
+/// NPCs are placed in a grid starting at (40, 48) to stay within walkable space.
+fn spawn_extra_npcs(app: &mut App, count: usize) {
+    // Remove registry from world so we can mutate it while also spawning entities.
+    let mut registry = app
+        .world_mut()
+        .remove_resource::<EntityRegistry>()
+        .expect("EntityRegistry should exist after setup_gauntlet");
+    let cols = 10;
+
+    for i in 0..count {
+        let x = 40 + (i % cols) as i32;
+        let y = 48 + (i / cols) as i32;
+        let pos = TilePosition::new(x, y, 0);
+
+        let entity = app
+            .world_mut()
+            .spawn((
+                Npc,
+                Interactable,
+                pos,
+                Want {
+                    primary: WantKind::Safety,
+                    intensity: 5,
+                    description: format!("extra_npc_{}", i),
+                },
+                Contentment { level: 0 },
+                ToleranceThreshold {
+                    current_stress: 0,
+                    threshold: 50,
+                },
+                MovementSpeed::default(),
+            ))
+            .id();
+        let sid = registry.register(entity);
+        app.world_mut()
+            .entity_mut(entity)
+            .insert(StableEntityId(sid));
+    }
+
+    app.insert_resource(registry);
+}
+
+/// Tick the app N times and return average milliseconds per tick.
+fn measure_tick_timing(app: &mut App, ticks: usize) -> f64 {
+    // Warm-up tick (first tick has startup overhead)
+    app.update();
+
+    let start = Instant::now();
+    for _ in 0..ticks {
+        app.update();
+    }
+    let elapsed = start.elapsed();
+    elapsed.as_secs_f64() * 1000.0 / ticks as f64
+}
+
+/// Collect snapshot entity IDs from the VisibilityGeometry and entity count.
+fn count_entities(app: &App) -> usize {
+    let registry = app.world().resource::<EntityRegistry>();
+    registry.len() as usize
+}
+
+/// Baseline tick timing: Gauntlet with default entities stays within D-026 budget.
+#[test]
+#[cfg(feature = "gauntlet")]
+fn baseline_tick_timing_within_budget() {
+    let mut app = setup_baseline();
+    let entity_count = count_entities(&app);
+    let avg_ms = measure_tick_timing(&mut app, TIMING_TICKS);
+
+    eprintln!(
+        "Baseline: {} entities, avg {:.3}ms/tick over {} ticks",
+        entity_count, avg_ms, TIMING_TICKS
+    );
+
+    assert!(
+        avg_ms < MAX_TICK_MS,
+        "Baseline tick timing ({:.3}ms) exceeds D-026 budget ({}ms)",
+        avg_ms,
+        MAX_TICK_MS
+    );
+}
+
+/// Scaling test: adding NPCs keeps tick timing within D-026 budget.
+/// Tests 0 (baseline), 15, and 50 extra NPCs.
+#[test]
+#[cfg(feature = "gauntlet")]
+fn scaling_tick_timing_within_budget() {
+    let mut results: Vec<(usize, usize, f64)> = Vec::new();
+
+    for &extra_count in EXTRA_NPC_COUNTS {
+        let mut app = setup_baseline();
+        if extra_count > 0 {
+            spawn_extra_npcs(&mut app, extra_count);
+        }
+        let total_entities = count_entities(&app);
+        let avg_ms = measure_tick_timing(&mut app, TIMING_TICKS);
+        results.push((extra_count, total_entities, avg_ms));
+    }
+
+    eprintln!("\n=== Content Scaling Results (D-026: {}ms budget) ===", MAX_TICK_MS);
+    eprintln!("{:<12} {:<10} {:<15}", "Extra NPCs", "Total", "Avg ms/tick");
+    eprintln!("{:-<37}", "");
+    for &(extra, total, avg_ms) in &results {
+        let status = if avg_ms < MAX_TICK_MS { "OK" } else { "OVER" };
+        eprintln!("{:<12} {:<10} {:<15.3} {}", extra, total, avg_ms, status);
+    }
+
+    // Assert all tiers stay within budget
+    for &(extra, _total, avg_ms) in &results {
+        assert!(
+            avg_ms < MAX_TICK_MS,
+            "Tick timing with +{} NPCs ({:.3}ms) exceeds D-026 budget ({}ms)",
+            extra,
+            avg_ms,
+            MAX_TICK_MS
+        );
+    }
+
+    // Assert scaling is reasonable: +50 NPCs shouldn't more than 5x the baseline
+    if results.len() >= 2 {
+        let baseline_ms = results[0].2;
+        let max_extra_ms = results.last().unwrap().2;
+        let scaling_factor = max_extra_ms / baseline_ms;
+        eprintln!(
+            "\nScaling factor (baseline → +{} NPCs): {:.2}x",
+            results.last().unwrap().0,
+            scaling_factor
+        );
+        assert!(
+            scaling_factor < 5.0,
+            "Scaling factor {:.2}x exceeds 5x threshold — possible O(n^2) regression",
+            scaling_factor
+        );
+    }
+}
+
+/// Determinism test: baseline entities produce identical snapshots regardless
+/// of extra NPCs being present. The original Gauntlet entities (StableId 0-51)
+/// should have the same positions and visibility after the same number of ticks.
+#[test]
+#[cfg(feature = "gauntlet")]
+fn extra_npcs_dont_affect_baseline_behavior() {
+    // Run baseline
+    let mut baseline_app = setup_baseline();
+    for _ in 0..10 {
+        baseline_app.update();
+    }
+    let baseline_buffer = baseline_app
+        .world()
+        .resource::<SnapshotBuffer>()
+        .snapshot
+        .clone();
+
+    // Run with extra NPCs
+    let mut scaled_app = setup_baseline();
+    spawn_extra_npcs(&mut scaled_app, 15);
+    for _ in 0..10 {
+        scaled_app.update();
+    }
+    let scaled_buffer = scaled_app
+        .world()
+        .resource::<SnapshotBuffer>()
+        .snapshot
+        .clone();
+
+    let baseline_snap = baseline_buffer.expect("baseline should produce a snapshot");
+    let scaled_snap = scaled_buffer.expect("scaled should produce a snapshot");
+
+    // Same tick
+    assert_eq!(baseline_snap.tick, scaled_snap.tick, "tick count should match");
+
+    // Same game time
+    assert_eq!(
+        baseline_snap.game_time.time_of_day, scaled_snap.game_time.time_of_day,
+        "game time should match"
+    );
+
+    // Player position should be identical
+    let baseline_player = baseline_snap.entities.iter().find(|e| e.kind == EntityKind::Player);
+    let scaled_player = scaled_snap.entities.iter().find(|e| e.kind == EntityKind::Player);
+    assert!(baseline_player.is_some(), "baseline should have player");
+    assert!(scaled_player.is_some(), "scaled should have player");
+
+    let bp = baseline_player.unwrap();
+    let sp = scaled_player.unwrap();
+    assert_eq!(bp.x, sp.x, "player x should match");
+    assert_eq!(bp.y, sp.y, "player y should match");
+
+    // Original entities (entity_id <= 51) visible in baseline should still be
+    // visible in scaled run. Extra NPCs may add to the visible set, but
+    // shouldn't remove baseline visibility.
+    let baseline_original_ids: Vec<u64> = baseline_snap
+        .entities
+        .iter()
+        .filter(|e| e.entity_id <= 51)
+        .map(|e| e.entity_id)
+        .collect();
+
+    let scaled_original_ids: Vec<u64> = scaled_snap
+        .entities
+        .iter()
+        .filter(|e| e.entity_id <= 51)
+        .map(|e| e.entity_id)
+        .collect();
+
+    assert_eq!(
+        baseline_original_ids, scaled_original_ids,
+        "Original Gauntlet entities (id<=51) should be identical in both runs"
+    );
+}

server/tests/gen_fixtures.rs

@@ -35,6 +35,7 @@ fn fixture_snapshot(tick: u64, entities: Vec<VisibleEntity>) -> ObserverSnapshot
         current_monologue: None,
         pending_recognitions: vec![],
         dialogue_response: None,
+        blocked_entities: vec![],
     }
 }
 
@@ -204,6 +205,7 @@ fn generate_msgpack_fixtures() {
         current_monologue: None,
         pending_recognitions: vec![],
         dialogue_response: None,
+        blocked_entities: vec![],
     };
     write_fixture(
         "snapshot_v2_full",

server/tests/golden/proof_room_tick_10.json

@@ -1,4 +1,7 @@
 {
+  "blocked_entities": [
+    2
+  ],
   "current_monologue": null,
   "dialogue_response": null,
   "entities": [
@@ -62,7 +65,7 @@
   "player_inventory": [],
   "player_stance": "Sprint",
   "tick": 8,
-  "version": 8,
+  "version": 9,
   "visible_tiles": [
     {
       "tile_kind": "Wall",

server/tests/serialization.rs

@@ -24,6 +24,7 @@ fn test_snapshot(tick: u64, entities: Vec<VisibleEntity>) -> ObserverSnapshot {
         current_monologue: None,
         pending_recognitions: vec![],
         dialogue_response: None,
+        blocked_entities: vec![],
     }
 }
 
@@ -250,6 +251,7 @@ fn snapshot_v2_fields_roundtrip() {
         current_monologue: None,
         pending_recognitions: vec![],
         dialogue_response: None,
+        blocked_entities: vec![],
     };
 
     let bytes = rmp_serde::to_vec_named(&snapshot).expect("serialize");
@@ -304,7 +306,7 @@ fn protocol_version_constant_matches_snapshot() {
     let snapshot = test_snapshot(0, vec![]);
     assert_eq!(snapshot.version, PROTOCOL_VERSION);
     assert_eq!(
-        PROTOCOL_VERSION, 8,
+        PROTOCOL_VERSION, 9,
         "bump this assertion when protocol version changes"
     );
 }
@@ -342,6 +344,7 @@ fn all_facing_direction_variants_roundtrip() {
             current_monologue: None,
             pending_recognitions: vec![],
             dialogue_response: None,
+            blocked_entities: vec![],
         };
         let bytes = rmp_serde::to_vec_named(&snapshot).expect("serialize");
         let decoded: ObserverSnapshot = rmp_serde::from_slice(&bytes).expect("deserialize");
@@ -469,6 +472,10 @@ fn v5_payload_deserializes_into_v6_struct() {
         decoded.pending_recognitions.is_empty(),
         "missing pending_recognitions should default to empty"
     );
+    assert!(
+        decoded.blocked_entities.is_empty(),
+        "missing blocked_entities should default to empty"
+    );
 }
 
 /// Full 9-slot inventory roundtrip (D-065: 3x3 grid = 9 slots universal)
@@ -1095,6 +1102,90 @@ fn gdscript_generated_fixtures_deserialize() {
     eprintln!("Verified {} GDScript-generated fixtures", count);
 }
 
+/// blocked_entities Vec<u64> round-trips through MessagePack (#514).
+/// Guards the debug field survives serialization.
+#[test]
+fn blocked_entities_roundtrip() {
+    let mut snapshot = test_snapshot(0, vec![]);
+    snapshot.blocked_entities = vec![42, 99, 1024];
+
+    let bytes = rmp_serde::to_vec_named(&snapshot).expect("serialize");
+    let decoded: ObserverSnapshot = rmp_serde::from_slice(&bytes).expect("deserialize");
+
+    assert_eq!(
+        decoded.blocked_entities,
+        vec![42, 99, 1024],
+        "blocked_entities should survive roundtrip"
+    );
+}
+
+/// Empty blocked_entities round-trips correctly (#514).
+#[test]
+fn blocked_entities_empty_roundtrip() {
+    let snapshot = test_snapshot(0, vec![]);
+    assert!(snapshot.blocked_entities.is_empty());
+
+    let bytes = rmp_serde::to_vec_named(&snapshot).expect("serialize");
+    let decoded: ObserverSnapshot = rmp_serde::from_slice(&bytes).expect("deserialize");
+
+    assert!(
+        decoded.blocked_entities.is_empty(),
+        "empty blocked_entities should survive roundtrip"
+    );
+}
+
+/// v8 payloads (without blocked_entities) must deserialize into the v9 struct
+/// via #[serde(default)]. Guards backwards compat during migration (#514).
+#[test]
+fn v8_payload_deserializes_into_v9_struct() {
+    #[derive(serde::Serialize)]
+    struct ObserverSnapshotV8 {
+        version: u8,
+        tick: u64,
+        game_time: GameTime,
+        player_facing: FacingDirection,
+        player_stance: MovementStance,
+        player_inventory: Vec<InventoryItem>,
+        entities: Vec<VisibleEntity>,
+        visible_tiles: Vec<VisibleTile>,
+        nearby_interactions: Vec<NearbyInteraction>,
+        current_monologue: Option<MonologueEvent>,
+        pending_recognitions: Vec<PendingRecognitionWire>,
+        dialogue_response: Option<DialogueResponseEvent>,
+    }
+
+    let v8 = ObserverSnapshotV8 {
+        version: 8,
+        tick: 100,
+        game_time: GameTime {
+            day: 0,
+            time_of_day: 0,
+            day_phase: DayPhase::Morning,
+            tick_rate: TickRate::Full,
+        },
+        player_facing: FacingDirection::North,
+        player_stance: MovementStance::Walk,
+        player_inventory: vec![],
+        entities: vec![],
+        visible_tiles: vec![],
+        nearby_interactions: vec![],
+        current_monologue: None,
+        pending_recognitions: vec![],
+        dialogue_response: None,
+    };
+
+    let bytes = rmp_serde::to_vec_named(&v8).expect("serialize v8");
+    let decoded: ObserverSnapshot = rmp_serde::from_slice(&bytes)
+        .expect("v8 payload should deserialize into v9 struct via serde(default)");
+
+    assert_eq!(decoded.version, 8, "version field preserved from v8");
+    assert_eq!(decoded.tick, 100);
+    assert!(
+        decoded.blocked_entities.is_empty(),
+        "missing blocked_entities should default to empty"
+    );
+}
+
 /// NearbyInteraction.object_type round-trips through MessagePack (#422).
 /// Verifies object_type=Some(Container) survives the wire.
 #[test]