Refactor GPT sync in client.js: extract _syncGptFromDetections and add final sync on job completion

frontend/js/api/client.js

@@ -90,10 +90,85 @@ APP.api.client.cancelBackendJob = async function (jobId, reason) {
     }
 };
 
+/**
+ * Sync GPT enrichment data from polled first_frame_detections into state.detections.
+ * Returns true if any card was updated and needs re-render.
+ */
+APP.api.client._syncGptFromDetections = function (rawDets, logLabel) {
+    const { state } = APP.core;
+    const { log } = APP.ui.logging;
+    let needsRender = false;
+
+    // Phase A: Sync assessment status, relevance fields
+    for (const rd of rawDets) {
+        const tid = rd.track_id || `T${String(rawDets.indexOf(rd) + 1).padStart(2, "0")}`;
+        const existing = (state.detections || []).find(d => d.id === tid);
+        if (existing) {
+            if (rd.assessment_status && existing.assessment_status !== rd.assessment_status) {
+                existing.assessment_status = rd.assessment_status;
+                needsRender = true;
+            }
+            if (rd.mission_relevant !== undefined && rd.mission_relevant !== null) {
+                existing.mission_relevant = rd.mission_relevant;
+            }
+            if (rd.relevance_reason) {
+                existing.relevance_reason = rd.relevance_reason;
+            }
+        }
+    }
+
+    // Phase B: Full GPT feature merge (gated on gpt_raw)
+    const hasGptData = rawDets.some(d => d.gpt_raw);
+    if (hasGptData) {
+        state.hf.firstFrameDetections = rawDets;
+        for (const rd of rawDets) {
+            const tid = rd.track_id || `T${String(rawDets.indexOf(rd) + 1).padStart(2, "0")}`;
+            const existing = (state.detections || []).find(d => d.id === tid);
+            if (existing && rd.gpt_raw) {
+                const g = rd.gpt_raw;
+                const rangeStr = g.range_estimate && g.range_estimate !== "Unknown"
+                    ? g.range_estimate + " (est.)" : "Unknown";
+                existing.features = {
+                    "Type": g.object_type || "Unknown",
+                    "Size": g.size || "Unknown",
+                    "Threat Lvl": (g.threat_level || g.threat_level_score || "?") + "/10",
+                    "Status": g.threat_classification || "?",
+                    "Weapons": (g.visible_weapons || []).join(", ") || "None Visible",
+                    "Readiness": g.weapon_readiness || "Unknown",
+                    "Motion": g.motion_status || "Unknown",
+                    "Range": rangeStr,
+                    "Bearing": g.bearing || "Unknown",
+                    "Intent": g.tactical_intent || "Unknown",
+                };
+                const dynFeats = g.dynamic_features || [];
+                for (const feat of dynFeats) {
+                    if (feat && feat.key && feat.value) {
+                        existing.features[feat.key] = feat.value;
+                    }
+                }
+                existing.threat_level_score = rd.threat_level_score || g.threat_level_score || 0;
+                existing.threat_classification = rd.threat_classification || g.threat_classification || "Unknown";
+                existing.weapon_readiness = rd.weapon_readiness || g.weapon_readiness || "Unknown";
+                existing.gpt_distance_m = rd.gpt_distance_m || null;
+                existing.gpt_direction = rd.gpt_direction || null;
+                needsRender = true;
+            }
+        }
+        log(`Track cards updated with GPT assessment${logLabel ? " (" + logLabel + ")" : ""}`, "g");
+    }
+
+    if (needsRender && APP.ui && APP.ui.cards && APP.ui.cards.renderFrameTrackList) {
+        APP.ui.cards.renderFrameTrackList();
+    }
+
+    return needsRender;
+};
+
 APP.api.client.pollAsyncJob = async function () {
     const { state } = APP.core;
     const { log, setHfStatus } = APP.ui.logging;
     const { fetchProcessedVideo, fetchDepthVideo, fetchDepthFirstFrame } = APP.core.video;
+    const syncGpt = APP.api.client._syncGptFromDetections;
 
     const pollInterval = 3000; // 3 seconds
     const maxAttempts = 200;   // 10 minutes max
@@ -128,6 +203,14 @@ APP.api.client.pollAsyncJob = async function () {
                     log(`✓ Backend job ${completedJobId.substring(0, 8)}: completed successfully`, "g");
                     setHfStatus("job completed, fetching video...");
 
+                    // Final GPT sync — enrichment may have completed during
+                    // processing but the poll never landed on a "processing"
+                    // cycle that picked it up (common for segmentation mode
+                    // where _enrich_first_frame_gpt is skipped).
+                    if (status.first_frame_detections && status.first_frame_detections.length > 0) {
+                        syncGpt(status.first_frame_detections, "final sync");
+                    }
+
                     try {
                         await fetchProcessedVideo();
                         await fetchDepthVideo();
@@ -161,70 +244,7 @@ APP.api.client.pollAsyncJob = async function () {
 
                     // Check if GPT enrichment has updated first-frame detections
                     if (status.first_frame_detections && status.first_frame_detections.length > 0) {
-                        const rawDets = status.first_frame_detections;
-                        let needsRender = false;
-
-                        // Phase A: Always sync assessment status fields (not gated on gpt_raw)
-                        for (const rd of rawDets) {
-                            const tid = rd.track_id || `T${String(rawDets.indexOf(rd) + 1).padStart(2, "0")}`;
-                            const existing = (state.detections || []).find(d => d.id === tid);
-                            if (existing) {
-                                if (rd.assessment_status && existing.assessment_status !== rd.assessment_status) {
-                                    existing.assessment_status = rd.assessment_status;
-                                    needsRender = true;
-                                }
-                                if (rd.mission_relevant !== undefined && rd.mission_relevant !== null) {
-                                    existing.mission_relevant = rd.mission_relevant;
-                                }
-                                if (rd.relevance_reason) {
-                                    existing.relevance_reason = rd.relevance_reason;
-                                }
-                            }
-                        }
-
-                        // Phase B: One-shot GPT feature merge (gated on gpt_raw + _gptEnriched flag)
-                        const hasGptData = rawDets.some(d => d.gpt_raw);
-                        if (hasGptData) {
-                            state.hf.firstFrameDetections = rawDets;
-                            for (const rd of rawDets) {
-                                const tid = rd.track_id || `T${String(rawDets.indexOf(rd) + 1).padStart(2, "0")}`;
-                                const existing = (state.detections || []).find(d => d.id === tid);
-                                if (existing && rd.gpt_raw) {
-                                    const g = rd.gpt_raw;
-                                    const rangeStr = g.range_estimate && g.range_estimate !== "Unknown"
-                                        ? g.range_estimate + " (est.)" : "Unknown";
-                                    existing.features = {
-                                        "Type": g.object_type || "Unknown",
-                                        "Size": g.size || "Unknown",
-                                        "Threat Lvl": (g.threat_level || g.threat_level_score || "?") + "/10",
-                                        "Status": g.threat_classification || "?",
-                                        "Weapons": (g.visible_weapons || []).join(", ") || "None Visible",
-                                        "Readiness": g.weapon_readiness || "Unknown",
-                                        "Motion": g.motion_status || "Unknown",
-                                        "Range": rangeStr,
-                                        "Bearing": g.bearing || "Unknown",
-                                        "Intent": g.tactical_intent || "Unknown",
-                                    };
-                                    const dynFeats = g.dynamic_features || [];
-                                    for (const feat of dynFeats) {
-                                        if (feat && feat.key && feat.value) {
-                                            existing.features[feat.key] = feat.value;
-                                        }
-                                    }
-                                    existing.threat_level_score = rd.threat_level_score || g.threat_level_score || 0;
-                                    existing.threat_classification = rd.threat_classification || g.threat_classification || "Unknown";
-                                    existing.weapon_readiness = rd.weapon_readiness || g.weapon_readiness || "Unknown";
-                                    existing.gpt_distance_m = rd.gpt_distance_m || null;
-                                    existing.gpt_direction = rd.gpt_direction || null;
-                                    needsRender = true;
-                                }
-                            }
-                            log("Track cards updated with GPT assessment", "g");
-                        }
-
-                        if (needsRender && APP.ui && APP.ui.cards && APP.ui.cards.renderFrameTrackList) {
-                            APP.ui.cards.renderFrameTrackList();
-                        }
+                        syncGpt(status.first_frame_detections);
                     }
                 }