feat: progressive multi-round face matching + pending person API

- Identity agent: per-face max matching, multi-round with derived
  seeds from high-confidence faces, angle diversity filter (cosine sim < 0.90)
- Pending person API: POST /file/:file_uuid/pending-person
  + GET /file/:file_uuid/pending-persons with status=pending, source=manual
- Update API docs (07_identity.md)

src/api/processing.rs

@@ -59,6 +59,7 @@ struct JobDetailResponse {
     created_at: String,
     started_at: Option<String>,
     updated_at: Option<String>,
+    queue_position: Option<i32>,
 }
 
 #[derive(Debug, Serialize)]
@@ -286,6 +287,31 @@ async fn trigger_processing(
         tracing::error!("[TRIGGER] Failed to update monitor job for {}: {}", file_uuid, e);
         StatusCode::INTERNAL_SERVER_ERROR
     })?;
+    
+    // Update videos.processing_status to PROCESSING immediately
+    let processor_names_upper: Vec<String> = processors_to_run.iter().map(|p| p.to_uppercase()).collect();
+    let progress: serde_json::Map<String, serde_json::Value> = processors_to_run.iter().map(|p| {
+        (p.to_uppercase(), serde_json::json!({
+            "current_frame": 0, "total_frames": 0, "percentage": 0, "status": "pending"
+        }))
+    }).collect();
+    let status = serde_json::json!({
+        "phase": "PROCESSING",
+        "active_processors": processor_names_upper,
+        "total_frames": 0,
+        "progress": progress
+    });
+    sqlx::query(&format!(
+        "UPDATE {videos_table} SET processing_status = $1, updated_at = CURRENT_TIMESTAMP WHERE file_uuid = $2"
+    ))
+    .bind(&status)
+    .bind(&file_uuid)
+    .execute(state.db.pool())
+    .await
+    .map_err(|e| {
+        tracing::error!("[TRIGGER] Failed to update processing status for {}: {}", file_uuid, e);
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
 
     let processors_to_run_refs: Vec<&str> = processors_to_run.iter().map(|s| s.as_str()).collect();
 
@@ -531,6 +557,21 @@ async fn get_job(Path(uuid): Path<String>) -> Result<Json<JobDetailResponse>, St
         started_at,
         updated_at,
     ) = job.ok_or(StatusCode::NOT_FOUND)?;
+    
+    // Calculate queue position if status is 'pending'
+    let queue_position = if status == "pending" {
+        sqlx::query_scalar::<_, i64>(&format!(
+            "SELECT COUNT(*) + 1 FROM {} WHERE status = 'pending' AND created_at < (SELECT created_at FROM {} WHERE uuid = $1)",
+            jobs_table, jobs_table
+        ))
+        .bind(&uuid)
+        .fetch_one(pg.pool())
+        .await
+        .ok()
+        .map(|pos| pos as i32)
+    } else {
+        None
+    };
 
     Ok(Json(JobDetailResponse {
         id,
@@ -543,6 +584,7 @@ async fn get_job(Path(uuid): Path<String>) -> Result<Json<JobDetailResponse>, St
         created_at,
         started_at,
         updated_at,
+        queue_position,
     }))
 }
 
@@ -655,28 +697,27 @@ async fn get_processor_counts(
             }
 
 if let Ok(content) = std::fs::read_to_string(&json_path) {
-if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
-// CUT: prioritize scenes count over frame_count
-if proc_name == "cut" {
-frame_count = json
-.get("scenes")
-.and_then(|v| v.as_array())
-.map(|arr| arr.len() as u32);
-} else {
-// Standard frame_count field
-frame_count = json
-.get("frame_count")
-.and_then(|v| v.as_u64())
-.map(|v| v as u32);
-
-// YOLO: frames array
-if frame_count.is_none() {
-frame_count = json
-.get("frames")
-.and_then(|v| v.as_array())
-.map(|arr| arr.len() as u32);
-}
-}
+                if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
+                    // CUT: prioritize scenes count over frame_count
+                    if proc_name == "cut" {
+                        frame_count = json
+                            .get("scenes")
+                            .and_then(|v| v.as_array())
+                            .map(|arr| arr.len() as u32);
+                    } else if proc_name == "yolo" {
+                        // YOLO: use metadata.total_frames (avoids parsing huge frames array)
+                        frame_count = json
+                            .get("metadata")
+                            .and_then(|m| m.get("total_frames"))
+                            .and_then(|v| v.as_u64())
+                            .map(|v| v as u32);
+                    } else {
+                        // Standard frame_count field
+                        frame_count = json
+                            .get("frame_count")
+                            .and_then(|v| v.as_u64())
+                            .map(|v| v as u32);
+                    }
 
 segment_count = json
 .get("segments")
@@ -738,6 +779,7 @@ pub fn processing_routes() -> Router<AppState> {
         )
         .route("/api/v1/progress/:file_uuid", post(get_progress))
         .route("/api/v1/jobs", post(list_jobs))
+        .route("/api/v1/job/:uuid", get(get_job))
         .route("/api/v1/config/cache", post(cache_toggle))
         .route("/api/v1/config/auto-pipeline", post(auto_pipeline_toggle))
         .route(