fix: honor Komodo health and prefer fresh telemetry across fleet status

src/lib/server/fleet/status-evidence.ts

@@ -1,28 +1,43 @@
 import { db } from '../db/index.js';
-import { parseGameEvent } from '../../telemetry.js';
+import { parseGameEvent, type GameTelemetry } from '../../telemetry.js';
 import { ONLINE_MAX_MS } from '../../server-freshness.js';
 import { rconGetPlayerCount, rconStatusResult } from '../integrations/rcon.js';
 
 export interface TelemetryEvidence { players: number; map: string; receivedAt: string }
 
-/** Only validated, recently received reports can establish current game state. */
-export function telemetryEvidence(server: string, after?: string | null): TelemetryEvidence | null {
+/** Reports from before the latest lifecycle submission describe the old process. */
+export function latestGameSubmission(server: string): string | null {
+    return (db().prepare(`SELECT MAX(at) AS at FROM (
+        SELECT submitted_at AS at FROM server_deployments WHERE server=? AND action IN ('create','start','restart','rebuild')
+        UNION ALL SELECT requested_at AS at FROM restart_rollout WHERE server=?)`).get(server, server) as { at: string | null }).at;
+}
+
+export function telemetryReport(server: string): GameTelemetry | null {
     const row = db().prepare('SELECT received_at, payload FROM server_telemetry WHERE server = ?').get(server) as
         { received_at: string; payload: string | null } | undefined;
     if (!row?.payload) return null;
-    const received = Date.parse(row.received_at);
+    try {
+        const saved = JSON.parse(row.payload) as GameTelemetry;
+        const event = parseGameEvent(saved);
+        return event.server === server ? { ...event, receivedAt: row.received_at, timing: saved.timing } : null;
+    } catch { return null; }
+}
+
+/** Only validated, recently received reports can establish current game state. */
+export function telemetryEvidence(server: string, after: string | null = latestGameSubmission(server)): TelemetryEvidence | null {
+    const report = telemetryReport(server);
+    if (!report) return null;
+    const received = Date.parse(report.receivedAt);
     const age = Date.now() - received;
     if (!Number.isFinite(age) || age < 0 || age > ONLINE_MAX_MS) return null;
     if (after && (!Number.isFinite(Date.parse(after)) || received <= Date.parse(after))) return null;
-    try {
-        const event = parseGameEvent(JSON.parse(row.payload));
-        if (event.server !== server) return null;
-        return { players: event.players.length, map: event.map, receivedAt: row.received_at };
-    } catch { return null; }
+    return { players: report.players.length, map: report.map, receivedAt: report.receivedAt };
 }
 
 /** Positive occupancy from either source always vetoes an empty-server claim. */
 export async function probePlayerCount(server: string): Promise<number | null> {
+    const occupied = telemetryEvidence(server);
+    if (occupied && occupied.players > 0) return occupied.players;
     const players = await rconGetPlayerCount(server).catch(() => null);
     // Read after the network request: a player may join while RCON is pending.
     const telemetry = telemetryEvidence(server);
@@ -35,10 +50,14 @@ export async function probePlayerCount(server: string): Promise<number | null> {
 export async function probeServerStatus(server: string, after?: string | null): Promise<
     { ok: true; players: number; map: string | null; source: 'rcon' | 'telemetry' } | { ok: false; reason: string }
 > {
+    const current = telemetryEvidence(server, after);
+    if (current) return { ok: true, ...current, source: 'telemetry' };
     let reason = 'RCON unavailable';
     try {
         const rcon = await rconStatusResult(server);
-        if (rcon.ok) return { ok: true, players: Math.max(rcon.status.players, telemetryEvidence(server, after)?.players ?? 0), map: rcon.status.map, source: 'rcon' };
+        const latest = telemetryEvidence(server, after);
+        if (latest) return { ok: true, ...latest, source: 'telemetry' };
+        if (rcon.ok) return { ok: true, players: rcon.status.players, map: rcon.status.map, source: 'rcon' };
         reason = rcon.reason;
     } catch (err) { reason = (err as Error).message; }
     const telemetry = telemetryEvidence(server, after);