feat: trace quality agent selection report, identity clustering runner_v2 DB write, age/gender CoreML selection, updated experiment config UUID

src/api/media_api.rs

@@ -15,6 +15,10 @@ pub fn bbox_routes() -> Router<crate::api::server::AppState> {
             "/api/v1/file/:file_uuid/video/bbox",
             get(bbox_overlay_video),
         )
+        .route(
+            "/api/v1/file/:file_uuid/trace/:trace_id/video",
+            get(trace_video),
+        )
         .route("/api/v1/file/:file_uuid/video", get(stream_video))
         .route("/api/v1/file/:file_uuid/thumbnail", get(face_thumbnail))
 }
@@ -229,6 +233,100 @@ fn parse_range(range: &str, file_size: u64) -> (u64, u64) {
     (start.min(file_size - 1), end.min(file_size - 1))
 }
 
+async fn trace_video(
+    State(state): State<crate::api::server::AppState>,
+    Path((file_uuid, trace_id)): Path<(String, i32)>,
+    Query(params): Query<std::collections::HashMap<String, String>>,
+) -> Result<impl IntoResponse, StatusCode> {
+    use axum::http::header;
+
+    let videos_table = schema::table_name("videos");
+    let row: Option<(String,)> = sqlx::query_as(&format!(
+        "SELECT file_path FROM {} WHERE file_uuid = $1",
+        videos_table
+    ))
+    .bind(&file_uuid)
+    .fetch_optional(state.db.pool())
+    .await
+    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let (video_path,) = row.ok_or(StatusCode::NOT_FOUND)?;
+
+    let fps: f64 = sqlx::query_scalar(&format!(
+        "SELECT COALESCE(fps, 24.0) FROM {} WHERE file_uuid = $1",
+        videos_table
+    ))
+    .bind(&file_uuid)
+    .fetch_optional(state.db.pool())
+    .await
+    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+    .unwrap_or(24.0);
+
+    // Get all detections for this trace_id
+    let face_table = schema::table_name("face_detections");
+    let rows: Vec<(i32, i32, i32, i32, i32)> = sqlx::query_as(&format!(
+        "SELECT frame_number, x, y, width, height FROM {} WHERE file_uuid = $1 AND trace_id = $2 ORDER BY frame_number",
+        face_table
+    ))
+    .bind(&file_uuid).bind(trace_id)
+    .fetch_all(state.db.pool()).await
+    .unwrap_or_else(|e| { tracing::error!("trace query error: {}", e); vec![] });
+
+    if rows.is_empty() {
+        return Err(StatusCode::NOT_FOUND);
+    }
+
+    let first_frame = rows[0].0;
+    let last_frame = rows[rows.len() - 1].0;
+    let start_sec = first_frame as f64 / fps;
+    let padding = params.get("padding").and_then(|s| s.parse().ok()).unwrap_or(2.0);
+    let duration = (last_frame - first_frame) as f64 / fps + padding * 2.0;
+    let seek = (start_sec - padding).max(0.0);
+
+    // Build filters: per-frame bbox + text
+    let mut parts: Vec<String> = Vec::new();
+    for (frame, x, y, w, h) in &rows {
+        let offset = frame - first_frame + (padding * fps) as i32;
+        parts.push(format!(
+            "drawbox=x={}:y={}:w={}:h={}:color=red@0.8:thickness=8:enable='eq(n,{})'",
+            x, y, w, h, offset
+        ));
+        let label = format!("t{}", trace_id);
+        render_text(&mut parts, &label, *x + 6, *y + 6, Some(offset));
+    }
+
+    let vf = if parts.is_empty() {
+        "null".to_string()
+    } else {
+        parts.join(",")
+    };
+
+    let tmp = std::env::temp_dir().join(format!("trace_{}.mp4", uuid::Uuid::new_v4()));
+    let tmp_str = tmp.to_str().unwrap_or("").to_string();
+    let status = std::process::Command::new("ffmpeg")
+        .args([
+            "-ss", &seek.to_string(), "-i", &video_path,
+            "-t", &duration.to_string(), "-vf", &vf,
+            "-c:v", "libx264", "-preset", "ultrafast", "-crf", "28",
+            "-an", "-movflags", "+faststart", "-y", &tmp_str,
+        ])
+        .status()
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    if !status.success() {
+        let _ = std::fs::remove_file(&tmp);
+        return Err(StatusCode::INTERNAL_SERVER_ERROR);
+    }
+
+    let data = tokio::fs::read(&tmp)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let _ = std::fs::remove_file(&tmp);
+    Ok(Response::builder()
+        .header(header::CONTENT_TYPE, "video/mp4")
+        .header(header::CONTENT_LENGTH, data.len())
+        .body(Body::from(data))
+        .unwrap())
+}
+
 async fn stream_video(
     State(state): State<crate::api::server::AppState>,
     Path(file_uuid): Path<String>,