feat(multiplayer): Phase 4 prediction correctness + two input-death fixes

Closes Phase 4's outstanding action-sequence-correctness invariant, then
fixes two server-side bugs an adversarial review of that work uncovered.
Server simulation, bot observations, collision resources and tick rate are
unchanged: the server_physics_parity trace is byte-for-byte identical to
HEAD across 360 ticks including both ships' full observation vectors.

4.11 - prediction history filed under the ISSUING sequence

_send_local_input filed each post-step predicted state under the timeline's
estimate of the sequence the server would consume this tick, trailing
issuance by input_lead. The body had integrated the intent issued under
_input_seq, so predicted[S] held "state after the intent from now" while
the server's authority for S is "state after action(S)". They agree only
while the stick is still. Filing under _input_seq costs nothing: which
action the ship uses is decided in LocalNetShipController.get_action() and
is untouched.

Every prior Phase 4 gate held its input steady, and a steady input cannot
falsify a sequence label - the 60s runs honestly reported marker=0/3784.
New --exercise-input-transitions role toggles thrust every 6 ticks; it is
the only gate that can catch a label regression. Verified non-vacuous: the
old label fails it at 50%.

4.12 - issued-but-unsimulated sequences, and the release path

An attack (delta > 1) issues and sends several sequences for one local
physics step. Those gap sequences had no recorded prediction, so a server
ack of one reported missing_not_recorded - indistinguishable from ring
loss, costing a teleport and resync suppression several times a minute.
They are now recorded stateless via record_unsimulated() and answered with
a new "skip" decision mode. Free-flight hard snaps: 25/8/4 -> 0/0/0.

A release (delta == 0) re-recorded at the unchanged _input_seq, filing the
current intent under a sequence that went out carrying a different action;
LocalInputTimeline deliberately refuses to mutate an issued sequence, so
the ring contradicted the wire. Recording is now skipped on release ticks.

4.13 - two Phase 3 bugs silently killing player input

(a) InputJitterBuffer.consume() advanced last_applied_seq on every tick
including a starve. Since ingest() discards seq <= last_applied_seq, one
starve on a sequence the client had not sent yet stranded the stream one
ahead of arrivals permanently - both sides advancing in lockstep, every
honest packet discarded on arrival. The client's own input_lead release is
enough to trigger it, so input died for ~30 ticks roughly every 6.5s on a
clean LAN. Now only gives up on a sequence once strictly newer data proves
it lost. Silent-client stall and ring-overflow resync are unchanged.

(b) The seq-range guard bounded incoming seq against highest_ingested_seq,
which only advances inside ingest(), which that guard gates. After a ~2s
host hitch every packet was rejected forever with no diagnostic (600+
consecutive rejections reproduced via SIGSTOP). Third iteration of this
guard; each previous version bounded against a value only the accepted
path could advance. Adds an escape after 10 consecutive rejections, which
grants an attacker nothing the rate limiter does not already bound.

(c) The transitions gate reported PASS at 3.76% while input was completely
dead, because suppression stops _record_metrics - a worse outage yields
fewer samples and a LOWER rate. Now scales the required sample count with
run length and asserts the wire's server_stalled bit. Reverting both fixes
makes it fail at samples 292/600, server_stalled=true, input_lead=12.

Fixing (a) also explained a residual the review had already traced: 151 of
151 action-marker mismatches were the server repeating a stale action on a
starve, not a prediction defect. Marker is now 0.00% in all three
conditions (was 1.7-2.5%), and free-flight p99 improved to
0.141/0.168/0.154m from 0.170/0.176/0.184m.

Two pre-existing test defects fixed alongside: the ball gate asserted
RTT-masking on a link with no RTT (flaked 2 in 5; now asserted only at
rtt >= 20ms, 5/5 under latency), and the two-bot CI compared scores across
a 3-5s window (now polls the scores the server actually held; note
score_changed is emitted only on the client path).

QA: 72 unit tests; 60s free-flight at LAN/80+-20ms/5% loss; transition
gate in all three; 2.0s and 3.5s host-freeze recovery; ball contact x5;
two-bot CI x3; all three abuse roles; net/match_net/clock/lobby smokes.

Phase 4 sign-off still pending a human playtest at ~100ms RTT - the
milestone asks how it feels, which no gate here answers.

Game/tests/cases/test_adaptive_input_depth_controller.gd

@@ -0,0 +1,31 @@
+extends "res://tests/test_case.gd"
+
+const AdaptiveInputDepthController = preload("res://scripts/adaptive_input_depth_controller.gd")
+
+
+func test_starts_safe_and_enters_zero_only_after_sustained_clean_samples() -> void:
+	var policy := AdaptiveInputDepthController.new()
+	assert_eq(policy.target_depth, 1, "starts at one buffered tick")
+	for _i in AdaptiveInputDepthController.REQUIRED_STABLE_TICKS - 1:
+		assert_eq(policy.update(8.0, 2.0, 0), 1, "does not enter zero before enough stable observations")
+	assert_eq(policy.update(8.0, 2.0, 0), 0, "enters zero after the stable observation threshold")
+
+
+func test_starvation_exits_zero_immediately_and_enforces_cooldown() -> void:
+	var policy := AdaptiveInputDepthController.new()
+	for _i in AdaptiveInputDepthController.REQUIRED_STABLE_TICKS:
+		policy.update(8.0, 2.0, 0)
+	assert_eq(policy.target_depth, 0, "precondition: clean link entered zero")
+	assert_eq(policy.update(8.0, 2.0, -2), 1, "starvation sentinel immediately restores one tick")
+	for _i in AdaptiveInputDepthController.REENTRY_COOLDOWN_TICKS:
+		assert_eq(policy.update(8.0, 2.0, 0), 1, "cooldown prevents immediate zero-depth re-entry")
+	for _i in AdaptiveInputDepthController.REQUIRED_STABLE_TICKS:
+		policy.update(8.0, 2.0, 0)
+	assert_eq(policy.target_depth, 0, "zero-depth can re-enter only after cooldown plus a fresh stable window")
+
+
+func test_high_jitter_exits_zero_immediately() -> void:
+	var policy := AdaptiveInputDepthController.new()
+	for _i in AdaptiveInputDepthController.REQUIRED_STABLE_TICKS:
+		policy.update(8.0, 2.0, 0)
+	assert_eq(policy.update(8.0, 5.1, 0), 1, "jitter above exit threshold restores safe depth immediately")

Game/tests/cases/test_adaptive_input_depth_controller.gd.uid

@@ -0,0 +1 @@
+uid://crkx670s4ma3j

Game/tests/cases/test_input_jitter_buffer.gd

@@ -93,14 +93,22 @@ func test_ring_wraparound_does_not_confuse_a_stale_slot_with_a_fresh_one() -> vo
 	buf.ingest(0, [_action(0.0)])
 	buf.consume()
 
-	# Advance last_applied_seq well past one full lap of the ring (32
-	# entries) purely via starvation, with nothing re-ingested — every
-	# ring slot's stored seq is now far behind "expected" at each step, so
-	# none of them should ever be misread as valid.
+	# Advance last_applied_seq well past one full lap of the ring (32 entries)
+	# so every stored slot tag is far behind "expected" and none may be
+	# misread as valid.
+	#
+	# This used to drive that purely by starvation with nothing re-ingested.
+	# It can't any more, and shouldn't: starvation only gives up on a sequence
+	# once strictly newer data proves it lost, because advancing past a
+	# sequence the client has not sent yet permanently strands the stream (see
+	# test_starving_ahead_of_the_client_does_not_permanently_discard_its_input).
+	# Drive it the way the real failure does instead — the client's epoch runs
+	# ahead while the intervening packets are lost.
+	var far := InputJitterBuffer.RING_SIZE * 3
+	buf.ingest(far, [_action(0.1)])
 	for i in InputJitterBuffer.RING_SIZE * 2:
 		buf.consume()
-	assert_eq(buf.last_applied_seq, InputJitterBuffer.RING_SIZE * 2, "advanced purely by starvation")
-	assert_true(buf.stalled, "long starvation run ends stalled")
+	assert_true(buf.last_applied_seq > InputJitterBuffer.RING_SIZE, "advanced past a full lap of the ring")
 
 	# Now a fresh packet lands at the seq the ring slot for "expected" was
 	# LAST used for, one full lap ago — if slot-tagging didn't work, this
@@ -151,3 +159,76 @@ func test_ring_overflow_resyncs_to_fresh_data_instead_of_starving_forever() -> v
 	# Normal sequential consumption resumes correctly from the resync point.
 	var next := buf.consume()
 	assert_almost_eq(next.thrust.z, float(expected_resync_seq + 1) * 0.01, 0.0001, "next tick continues in order from the resync point")
+
+
+# --- Starvation must not strand the stream (adversarial review, B2) ---------
+# consume() used to advance last_applied_seq on EVERY tick including a starve.
+# Because ingest() discards anything `seq <= last_applied_seq`, one starve on a
+# sequence the client had not sent yet left the server permanently one ahead of
+# arrivals: both sides then advance one per tick, the gap never closes, and
+# every honest packet is discarded on arrival. Reproduced on a clean LAN — the
+# client's own input_lead release (delta == 0, which issues no new sequence for
+# one tick) was enough to trigger it, roughly every 6.5s of ordinary play.
+
+func _thrust(value: float) -> ShipAction:
+	var a := ShipAction.new()
+	a.thrust = Vector3(0.0, 0.0, value)
+	return a
+
+
+func test_starving_ahead_of_the_client_does_not_permanently_discard_its_input() -> void:
+	var buffer := InputJitterBuffer.new()
+	buffer.ingest(1, [_thrust(1.0)])
+	assert_almost_eq(buffer.consume().thrust.z, 1.0, 0.001, "seq 1 applies normally")
+
+	# The client issues NO new sequence this tick (an input_lead release), so
+	# nothing newer than seq 1 exists. The server must keep expecting seq 2
+	# rather than consuming — and discarding — it.
+	assert_almost_eq(buffer.consume().thrust.z, 1.0, 0.001, "a starve repeats the last action")
+	assert_eq(buffer.last_applied_seq, 1, "and does NOT advance past a sequence the client has not sent")
+
+	# The client's next real packet must still be accepted and applied.
+	buffer.ingest(2, [_thrust(-1.0)])
+	assert_almost_eq(buffer.consume().thrust.z, -1.0, 0.001, "the next honest input is still applied, not discarded")
+
+
+func test_sustained_release_pattern_does_not_black_out_input() -> void:
+	# The full B2 shape: client and server both advance one per tick, but the
+	# client duplicates one sequence (a release). Pre-fix, every packet from
+	# this point on was discarded and the ship froze for 30 ticks.
+	var buffer := InputJitterBuffer.new()
+	buffer.ingest(1, [_thrust(1.0)])
+	buffer.consume()
+	buffer.consume()   # release tick: server starves
+
+	var applied_real_input := 0
+	for seq in range(2, 40):
+		buffer.ingest(seq, [_thrust(1.0)])
+		if absf(buffer.consume().thrust.z - 1.0) < 0.001:
+			applied_real_input += 1
+	assert_true(applied_real_input >= 35, "input keeps flowing after a release (applied %d/38)" % applied_real_input)
+	assert_true(not buffer.stalled, "and the buffer never reports a stall")
+
+
+func test_a_genuinely_lost_packet_is_still_skipped_rather_than_waited_on() -> void:
+	# The control for the two tests above: holding must not become "wait
+	# forever". When strictly newer data has arrived, the missing sequence is
+	# provably lost or reordered and must be given up on immediately.
+	var buffer := InputJitterBuffer.new()
+	buffer.ingest(1, [_thrust(1.0)])
+	buffer.consume()
+	buffer.ingest(3, [_thrust(-1.0)])   # seq 2 never arrives; 3 does
+	buffer.consume()                     # starves on 2, but 3 is newer -> skip it
+	assert_eq(buffer.last_applied_seq, 2, "a lost sequence is skipped once newer data exists")
+	assert_almost_eq(buffer.consume().thrust.z, -1.0, 0.001, "and the newer sequence applies on the next tick")
+
+
+func test_a_silent_client_still_zeroes_and_stalls_on_schedule() -> void:
+	# The other control: holding must not defeat the disconnect behaviour.
+	var buffer := InputJitterBuffer.new()
+	buffer.ingest(1, [_thrust(1.0)])
+	buffer.consume()
+	for i in InputJitterBuffer.STARVE_ZERO_TICKS + 2:
+		buffer.consume()
+	assert_true(buffer.stalled, "a silent client still stalls")
+	assert_almost_eq(buffer.last_action.thrust.z, 0.0, 0.001, "and its ship still stops")

Game/tests/cases/test_input_jitter_buffer.gd.uid

@@ -0,0 +1 @@
+uid://cl18xku0mr8d0

Game/tests/cases/test_input_lead_controller.gd

@@ -21,6 +21,13 @@ func test_healthy_depth_is_a_normal_tick_and_no_immediate_release() -> void:
 	assert_eq(c.lead, InputLeadController.LEAD_MIN, "release needs 2s clean, not 10 ticks")
 
 
+func test_zero_target_treats_an_empty_clean_link_buffer_as_healthy() -> void:
+	var c := InputLeadController.new()
+	for i in 10:
+		assert_eq(c.update(0, 0), 1, "adaptive zero-depth target does not attack on a clean empty buffer")
+	assert_eq(c.lead, InputLeadController.LEAD_MIN, "clean-link target preserves the minimum lead")
+
+
 # §3.3: "on any starve, increase by up to 3 immediately" — but debounced by
 # MIN_CHANGE_INTERVAL_TICKS so it isn't literally same-tick.
 func test_starve_triggers_fast_attack_after_debounce_floor() -> void:

Game/tests/cases/test_input_lead_controller.gd.uid

@@ -0,0 +1 @@
+uid://cpbo0x2qjjgs6

Game/tests/cases/test_local_input_timeline.gd

@@ -0,0 +1,44 @@
+extends "res://tests/test_case.gd"
+
+const LocalInputTimeline = preload("res://scripts/local_input_timeline.gd")
+const ShipAction = preload("res://scripts/ship_action.gd")
+
+
+func _action(z: float) -> ShipAction:
+	var result := ShipAction.new()
+	result.thrust.z = z
+	return result
+
+
+func test_attack_gap_is_materialized_as_repeat_last_actions() -> void:
+	var timeline := LocalInputTimeline.new()
+	timeline.configure_initial_delay(1)
+	timeline.issue(1, _action(0.25))
+	timeline.issue(4, _action(0.75))
+	assert_eq(timeline.latest_issued_seq, 5, "attack advances the outgoing sequence by the requested lead delta")
+	var packet := timeline.packet_actions(4)
+	assert_eq(packet.size(), 4, "redundancy packet carries contiguous actions across the attack gap")
+	assert_almost_eq(packet[0].thrust.z, 0.75, 0.001, "newest attack action is preserved")
+	assert_almost_eq(packet[1].thrust.z, 0.25, 0.001, "gap is repeat-last, matching server consumption")
+	assert_almost_eq(packet[3].thrust.z, 0.25, 0.001, "all attack-gap entries are materialized")
+
+
+func test_release_retransmits_immutable_sequence_and_carries_new_intent_forward() -> void:
+	var timeline := LocalInputTimeline.new()
+	timeline.configure_initial_delay(1)
+	timeline.issue(1, _action(0.2))
+	timeline.issue(0, _action(0.9))
+	assert_eq(timeline.latest_issued_seq, 1, "release does not relabel an issued action")
+	assert_almost_eq(timeline.packet_actions(4)[0].thrust.z, 0.2, 0.001, "release retransmits immutable issued data")
+	timeline.issue(1, _action(0.9))
+	assert_almost_eq(timeline.packet_actions(4)[0].thrust.z, 0.9, 0.001, "new intent appears on the next unique sequence")
+
+
+func test_consumption_repeats_last_through_unissued_delay_slots() -> void:
+	var timeline := LocalInputTimeline.new()
+	timeline.configure_initial_delay(3)
+	timeline.issue(1, _action(0.6))
+	assert_almost_eq(timeline.consume()["action"].thrust.z, 0.0, 0.001, "initial delay begins at neutral action")
+	assert_almost_eq(timeline.consume()["action"].thrust.z, 0.0, 0.001, "delay repeats last action")
+	assert_almost_eq(timeline.consume()["action"].thrust.z, 0.0, 0.001, "sequence zero remains neutral")
+	assert_almost_eq(timeline.consume()["action"].thrust.z, 0.6, 0.001, "issued command applies at its scheduled sequence")

Game/tests/cases/test_local_input_timeline.gd.uid

@@ -0,0 +1 @@
+uid://0njkbi808cgm

Game/tests/cases/test_local_prediction_history.gd

@@ -57,6 +57,38 @@ func test_record_and_lookup_do_not_alias_action_or_state() -> void:
 	assert_almost_eq((second_lookup["state"] as NetBodyState).position.x, 3.0, 0.0001, "lookup state cannot mutate ring")
 
 
+func test_overwrite_state_keeps_the_original_action() -> void:
+	var history := LocalPredictionHistory.new()
+	history.record(8, _action(0.25), _state(1.0))
+	var corrected := _state(9.0)
+	assert_true(history.overwrite_state(8, corrected), "an existing prediction can be backfilled after a snap")
+	assert_true(not history.overwrite_state(9, corrected), "backfill never invents an action for an unrecorded sequence")
+	var prediction := history.get_prediction(8)
+	assert_almost_eq((prediction["action"] as ShipAction).thrust.z, 0.25, 0.0001, "backfill preserves already-sent action")
+	assert_almost_eq((prediction["state"] as NetBodyState).position.x, 9.0, 0.0001, "backfill replaces only state")
+
+
+func test_rebase_carries_a_soft_correction_through_future_history_once() -> void:
+	var history := LocalPredictionHistory.new()
+	history.record(10, _action(0.1), _state(1.0))
+	history.record(11, _action(0.2), _state(2.0))
+	history.record(12, _action(0.3), _state(3.0))
+	var first_rotation := Quaternion(Vector3.UP, 0.25)
+	history.overwrite_state(10, _state(9.0))
+	history.rebase_state_range(11, 12, Vector3(0.5, -1.0, 0.25), first_rotation, Vector3(1.0, 0.0, 0.0), Vector3(0.0, 2.0, 0.0))
+	var after_first := history.get_prediction(12)
+	assert_almost_eq((after_first["state"] as NetBodyState).position.x, 3.5, 0.0001, "first correction reaches the future state")
+	assert_almost_eq((after_first["action"] as ShipAction).thrust.z, 0.3, 0.0001, "rebase never alters the paired input")
+
+	# The next acknowledgement compares to the rebased state, so only its new
+	# delta is transported. This trace catches the old bug where the first
+	# delta remained in history and was applied again on every snapshot.
+	history.rebase_state_range(12, 12, Vector3(-0.2, 0.0, 0.0), Quaternion.IDENTITY, Vector3.ZERO, Vector3.ZERO)
+	var after_second := history.get_prediction(12)
+	assert_almost_eq((after_second["state"] as NetBodyState).position.x, 3.3, 0.0001, "a second correction applies only its own delta")
+	assert_almost_eq((after_second["state"] as NetBodyState).linear_velocity.x, 7.0, 0.0001, "future velocity is rebased with the correction")
+
+
 func test_slot_tags_reject_wrapped_stale_predictions() -> void:
 	var history := LocalPredictionHistory.new()
 	history.record(1, _action(0.1), _state(1.0))
@@ -159,3 +191,70 @@ func test_stale_matched_comparison_does_not_clear_a_live_backlog() -> void:
 
 	history.compare_authoritative(far, _state(float(far)))
 	assert_true(not history.resync_required, "acknowledging the newest sequence does clear it")
+
+
+# --- Unsimulated (attack-gap) sequences -------------------------------------
+# The input_lead controller's attack path issues and SENDS several sequences
+# for one local physics step. Those skipped sequences are genuinely outstanding
+# — the server will acknowledge them — but the client never computed a
+# post-step state for them. They must be distinguishable from real history
+# loss, because history loss is a hard-snap condition and this is not.
+
+func test_unsimulated_gap_is_not_reported_as_missing_history() -> void:
+	var history := LocalPredictionHistory.new()
+	history.record(10, _action(1.0), _state(1.0))
+	history.record_unsimulated(11, _action(1.0))
+	history.record_unsimulated(12, _action(1.0))
+	history.record(13, _action(2.0), _state(2.0))
+
+	var gap := history.compare_authoritative(11, _state(9.0))
+	assert_eq(gap["status"], "unsimulated_gap", "an issued-but-unsimulated seq reports its own status")
+	assert_eq(gap["seq"], 11, "the comparison still identifies the acknowledged sequence")
+	assert_true(gap.has("authoritative_state"), "authority is still handed back for diagnostics")
+	assert_true(not gap.has("position_error"), "no error can be computed without a predicted state")
+
+	var real := history.compare_authoritative(13, _state(2.0))
+	assert_eq(real["status"], "matched", "a genuinely simulated seq still reconciles normally")
+
+
+func test_unsimulated_gap_carries_the_action_that_went_on_the_wire() -> void:
+	var history := LocalPredictionHistory.new()
+	history.record_unsimulated(4, _action(0.75))
+	var gap := history.compare_authoritative(4, _state(0.0))
+	assert_almost_eq(gap["action"].thrust.z, 0.75, 0.001, "the filled repeat-last action is retained honestly")
+
+
+func test_unsimulated_slot_refuses_a_fabricated_state() -> void:
+	# §4.4 forbids manufacturing history. Writing a state into a slot the client
+	# never simulated would do exactly that, so both write paths must decline.
+	var history := LocalPredictionHistory.new()
+	history.record_unsimulated(7, _action(1.0))
+	assert_true(not history.overwrite_state(7, _state(5.0)), "overwrite_state declines an unsimulated slot")
+	assert_eq(history.compare_authoritative(7, _state(0.0))["status"], "unsimulated_gap", "the slot stays stateless")
+
+	history.rebase_state_range(7, 7, Vector3.ONE, Quaternion.IDENTITY, Vector3.ONE, Vector3.ONE)
+	assert_eq(history.compare_authoritative(7, _state(0.0))["status"], "unsimulated_gap", "rebase skips it rather than seeding a state")
+
+
+func test_rebase_skips_unsimulated_entries_without_stopping_at_them() -> void:
+	# A gap sitting between two real predictions must not truncate the rebase:
+	# the entries after it still describe the pre-correction trajectory.
+	var history := LocalPredictionHistory.new()
+	history.record(1, _action(1.0), _state(1.0))
+	history.record_unsimulated(2, _action(1.0))
+	history.record(3, _action(1.0), _state(1.0))
+
+	history.rebase_state_range(1, 3, Vector3(10.0, 0.0, 0.0), Quaternion.IDENTITY, Vector3.ZERO, Vector3.ZERO)
+	var after := history.get_prediction(3)
+	assert_almost_eq(after["state"].position.x, _state(1.0).position.x + 10.0, 0.001, "the entry past the gap was still rebased")
+
+
+func test_unsimulated_gap_still_advances_the_acknowledgement_clock() -> void:
+	# The gap sequence IS outstanding, so it must count toward the ring's
+	# unacknowledged-capacity bookkeeping exactly as a simulated one does —
+	# otherwise a burst of attacks would silently under-report the backlog.
+	var history := LocalPredictionHistory.new()
+	history.record(1, _action(1.0), _state(1.0))
+	history.record_unsimulated(200, _action(1.0))
+	assert_eq(history.newest_recorded_seq, 200, "an unsimulated record advances the newest-seq cursor")
+	assert_true(history.resync_required, "it also trips the same unacknowledged-capacity guard")

Game/tests/cases/test_local_prediction_history.gd.uid

@@ -0,0 +1 @@
+uid://deh3hsn12c4k2

Game/tests/cases/test_match_net.gd.uid

@@ -0,0 +1 @@
+uid://dcw2l88s5as1w

Game/tests/cases/test_net_codec.gd.uid

@@ -0,0 +1 @@
+uid://bul5evnyqmk2r

Game/tests/cases/test_net_interpolator.gd

@@ -0,0 +1,24 @@
+extends "res://tests/test_case.gd"
+
+const NetInterpolator = preload("res://scripts/net_interpolator.gd")
+const NetBodyState = preload("res://scripts/net_body_state.gd")
+
+
+func test_extrapolation_integrates_angular_velocity() -> void:
+	var interpolator := NetInterpolator.new()
+	var first := NetBodyState.new()
+	first.angular_velocity = Vector3.UP * PI
+	interpolator.add_sample(1, first, 0)
+	var second := first.copy()
+	interpolator.add_sample(2, second, 0)
+	var result := interpolator.sample_at(2.0 + 0.1 * 1000.0 / NetInterpolator.TICK_MS)
+	assert_almost_eq(result.rotation.angle_to(Quaternion(Vector3.UP, PI * 0.1)), 0.0, 0.001, "present-time extrapolation advances rotation from angular velocity")
+
+
+func test_stale_pre_reset_packet_cannot_reopen_an_old_epoch() -> void:
+	var interpolator := NetInterpolator.new()
+	interpolator.add_sample(10, NetBodyState.new(), 0)
+	interpolator.add_sample(20, NetBodyState.new(), 1)
+	assert_eq(interpolator.reset_gen, 1, "newer reset establishes the new epoch")
+	assert_true(not interpolator.add_sample(15, NetBodyState.new(), 0), "late old-generation snapshot is rejected before reset handling")
+	assert_eq(interpolator.reset_gen, 1, "stale packet cannot flip reset generation back")

Game/tests/cases/test_net_interpolator.gd.uid

@@ -0,0 +1 @@
+uid://b6uev62y5va25

Game/tests/cases/test_net_ship_predictor.gd

@@ -0,0 +1,108 @@
+extends "res://tests/test_case.gd"
+
+const NetShipPredictor = preload("res://scripts/net_ship_predictor.gd")
+const NetBodyState = preload("res://scripts/net_body_state.gd")
+const LocalPredictionHistory = preload("res://scripts/local_prediction_history.gd")
+
+
+func _authoritative() -> NetBodyState:
+	return NetBodyState.new()
+
+
+func _matched(position_error: float = 0.0, rotation_error_degrees: float = 0.0) -> Dictionary:
+	return {
+		"status": "matched",
+		"authoritative_state": _authoritative(),
+		"position_error_magnitude": position_error,
+		"rotation_error_degrees": rotation_error_degrees,
+	}
+
+
+func test_soft_correction_within_thresholds() -> void:
+	var decision := NetShipPredictor.decide(_matched(2.0, 60.0), false, false)
+	assert_eq(decision["mode"], "soft", "thresholds are strict greater-than, so exact boundary soft-corrects")
+	assert_eq(decision["reason"], "within_thresholds", "soft decision records why")
+
+
+func test_hard_correction_for_missing_prediction_or_reset() -> void:
+	var missing := NetShipPredictor.decide({"status": "missing_evicted", "authoritative_state": _authoritative()}, false, false)
+	assert_eq(missing["mode"], "hard", "an unavailable same-sequence prediction must snap")
+	assert_eq(missing["reason"], "missing_evicted", "missing cause remains inspectable")
+	var reset := NetShipPredictor.decide(_matched(), false, true)
+	assert_eq(reset["mode"], "hard", "a new reset generation never blends across a teleport")
+
+
+func test_hard_correction_for_flags_or_large_error() -> void:
+	var frozen_state := _matched()
+	(frozen_state["authoritative_state"] as NetBodyState).frozen = true
+	assert_eq(NetShipPredictor.decide(frozen_state, false, false)["reason"], "frozen_mismatch", "authority frozen flag wins over local simulation")
+	assert_eq(NetShipPredictor.decide(_matched(2.01), false, false)["reason"], "position_error", "position beyond 2m snaps")
+	assert_eq(NetShipPredictor.decide(_matched(0.0, 60.01), false, false)["reason"], "rotation_error", "rotation beyond 60 degrees snaps")
+
+
+func test_soft_correction_applies_past_authority_as_a_delta_to_current_pose() -> void:
+	var predicted := _authoritative()
+	predicted.position = Vector3(10.0, 0.0, 0.0)
+	var authoritative := _authoritative()
+	authoritative.position = Vector3(10.5, 0.0, 0.0)
+	var comparison := {
+		"predicted_state": predicted,
+		"authoritative_state": authoritative,
+	}
+	var current := Transform3D(Basis.IDENTITY, Vector3(14.0, 2.0, -3.0))
+	var corrected := NetShipPredictor.soft_corrected_transform(current, comparison)
+	assert_almost_eq(corrected.origin.x, 14.5, 0.0001, "the correction moves current state by the same-sequence error")
+	assert_almost_eq(corrected.origin.y, 2.0, 0.0001, "unrelated current coordinates are preserved")
+	assert_almost_eq(corrected.origin.z, -3.0, 0.0001, "soft correction does not rewind to the old authoritative pose")
+
+
+func test_missing_history_places_once_then_suppresses_old_acknowledgements() -> void:
+	var predictor := NetShipPredictor.new()
+	var ship := Ship.new()
+	var history := LocalPredictionHistory.new()
+	var missing := {"status": "missing_not_recorded", "seq": 4, "authoritative_state": _authoritative()}
+	assert_eq(predictor.reconcile(missing, ship, 0, 10, history)["mode"], "hard", "first unavailable acknowledgement performs one resync placement")
+	assert_eq(predictor.reconcile(missing, ship, 0, 11, history)["mode"], "suppressed", "older unavailable acknowledgements do not create a snap burst")
+	ship.free()
+
+
+func test_reset_preempts_missing_history_suppression() -> void:
+	var predictor := NetShipPredictor.new()
+	var ship := Ship.new()
+	var history := LocalPredictionHistory.new()
+	var missing := {"status": "missing_not_recorded", "seq": 4, "authoritative_state": _authoritative()}
+	predictor.reconcile(missing, ship, 0, 10, history)
+	assert_eq(predictor.reconcile(missing, ship, 0, 11, history)["mode"], "suppressed", "old missing acknowledgement is suppressed during recovery")
+	var reset_authority := _authoritative()
+	reset_authority.position = Vector3(7.0, 2.0, -3.0)
+	var reset_missing := {"status": "missing_not_recorded", "seq": 5, "authoritative_state": reset_authority}
+	var reset := predictor.reconcile(reset_missing, ship, 1, 12, history)
+	assert_eq(reset["reason"], "reset_gen", "a changed reset generation preempts recovery suppression")
+	ship.free()
+
+
+# An attack's skipped sequence is acknowledged by the server but was never
+# locally simulated. It is a routine product of this client's own lead control
+# — not history loss — so it must not be treated as a snap condition.
+
+func test_unsimulated_gap_is_skipped_not_snapped() -> void:
+	var decision := NetShipPredictor.decide({"status": "unsimulated_gap", "seq": 5, "authoritative_state": _authoritative()}, false, false)
+	assert_eq(decision["mode"], "skip", "an unsimulated gap is neither soft nor hard")
+	assert_eq(decision["reason"], "unsimulated_gap", "the reason names the real cause")
+
+
+func test_genuine_missing_history_is_still_a_hard_snap() -> void:
+	# The control for the test above: the two statuses must not have been
+	# collapsed together while making gaps benign.
+	for status in ["missing_not_recorded", "missing_evicted"]:
+		var decision := NetShipPredictor.decide({"status": status, "seq": 5, "authoritative_state": _authoritative()}, false, false)
+		assert_eq(decision["mode"], "hard", "%s must still hard-correct" % status)
+
+
+func test_a_reset_still_wins_over_an_unsimulated_gap() -> void:
+	# Ordering guard: reset_gen is an epoch boundary and outranks everything,
+	# including the new skip path — otherwise a gap landing on the reset
+	# snapshot would silently discard the epoch change.
+	var decision := NetShipPredictor.decide({"status": "unsimulated_gap", "seq": 5, "authoritative_state": _authoritative()}, false, true)
+	assert_eq(decision["mode"], "hard", "reset still takes precedence")
+	assert_eq(decision["reason"], "reset_gen", "and is still attributed to the reset")

Game/tests/cases/test_net_ship_predictor.gd.uid

@@ -0,0 +1 @@
+uid://luffsv8s5huc

Game/tests/cases/test_smoke.gd.uid

@@ -0,0 +1 @@
+uid://3ytp2tiefu6u