feat: update core API, database layer, and worker modules

- Remove unused imports (n8n_search, universal_search, Client, Arc, etc.)
- Update API endpoints for identity, face recognition, search
- Fix postgres_db.rs search_videos parent_uuid column
- Add snapshot API and identity agent API
- Clean up backup files (.bak, .bak2)

src/processing/modules/asr.rs

@@ -0,0 +1,49 @@
+//! ASR (Automatic Speech Recognition) processing module
+
+use anyhow::Result;
+use momentry_core::ui::progress::{ProcessorType, ProgressState, ProgressUi};
+use momentry_core::OutputDir;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Process ASR module
+pub async fn process_asr_module(
+    asr_path: &Path,
+    video_path: &str,
+    uuid: &str,
+    progress_state: &Arc<Mutex<ProgressState>>,
+    ui: &Arc<Mutex<Option<ProgressUi>>>,
+) -> Result<()> {
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Asr).start(1);
+    }
+
+    let asr_result = momentry_core::core::processor::process_asr(
+        video_path,
+        asr_path.to_str().unwrap(),
+        Some(uuid),
+    )
+    .await?;
+
+    let asr_json = serde_json::to_string_pretty(&asr_result)?;
+    std::fs::write(asr_path, &asr_json)?;
+
+    let output_dir = OutputDir::new();
+    let _ = output_dir.backup_file(uuid, "asr.json");
+
+    println!("  ✓ ASR saved: {} segments", asr_result.segments.len());
+
+    {
+        let mut state = progress_state.lock().unwrap();
+        state
+            .get_processor(ProcessorType::Asr)
+            .complete(&format!("{} segments", asr_result.segments.len()));
+    }
+
+    if let Some(ref mut ui) = *ui.lock().unwrap() {
+        let _ = ui.render();
+    }
+
+    Ok(())
+}

src/processing/modules/asrx.rs

@@ -0,0 +1,49 @@
+//! ASRX (Extended ASR) processing module
+
+use anyhow::Result;
+use momentry_core::ui::progress::{ProcessorType, ProgressState, ProgressUi};
+use momentry_core::OutputDir;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Process ASRX module
+pub async fn process_asrx_module(
+    asrx_path: &Path,
+    video_path: &str,
+    uuid: &str,
+    progress_state: &Arc<Mutex<ProgressState>>,
+    ui: &Arc<Mutex<Option<ProgressUi>>>,
+) -> Result<()> {
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Asrx).start(1);
+    }
+
+    let asrx_result = momentry_core::core::processor::process_asrx(
+        video_path,
+        asrx_path.to_str().unwrap(),
+        Some(uuid),
+    )
+    .await?;
+
+    let asrx_json = serde_json::to_string_pretty(&asrx_result)?;
+    std::fs::write(asrx_path, &asrx_json)?;
+
+    let output_dir = OutputDir::new();
+    let _ = output_dir.backup_file(uuid, "asrx.json");
+
+    println!("  ✓ ASRX saved: {} segments", asrx_result.segments.len());
+
+    {
+        let mut state = progress_state.lock().unwrap();
+        state
+            .get_processor(ProcessorType::Asrx)
+            .complete(&format!("{} segments", asrx_result.segments.len()));
+    }
+
+    if let Some(ref mut ui) = *ui.lock().unwrap() {
+        let _ = ui.render();
+    }
+
+    Ok(())
+}

src/processing/modules/caption.rs

@@ -0,0 +1,49 @@
+//! Caption generation processing module
+
+use anyhow::Result;
+use momentry_core::ui::progress::{ProcessorType, ProgressState, ProgressUi};
+use momentry_core::OutputDir;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Process Caption module
+pub async fn process_caption_module(
+    caption_path: &Path,
+    video_path: &str,
+    uuid: &str,
+    progress_state: &Arc<Mutex<ProgressState>>,
+    ui: &Arc<Mutex<Option<ProgressUi>>>,
+) -> Result<()> {
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Caption).start(1);
+    }
+
+    let caption_result = momentry_core::core::processor::process_caption(
+        video_path,
+        caption_path.to_str().unwrap(),
+        Some(uuid),
+    )
+    .await?;
+
+    let caption_json = serde_json::to_string_pretty(&caption_result)?;
+    std::fs::write(caption_path, &caption_json)?;
+
+    let output_dir = OutputDir::new();
+    let _ = output_dir.backup_file(uuid, "caption.json");
+
+    println!("  ✓ Caption saved: {} frames", caption_result.total_frames);
+
+    {
+        let mut state = progress_state.lock().unwrap();
+        state
+            .get_processor(ProcessorType::Caption)
+            .complete(&format!("{} frames", caption_result.total_frames));
+    }
+
+    if let Some(ref mut ui) = *ui.lock().unwrap() {
+        let _ = ui.render();
+    }
+
+    Ok(())
+}

src/processing/modules/cut.rs

@@ -0,0 +1,49 @@
+//! CUT (Scene Cut Detection) processing module
+
+use anyhow::Result;
+use momentry_core::ui::progress::{ProcessorType, ProgressState, ProgressUi};
+use momentry_core::OutputDir;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Process CUT module
+pub async fn process_cut_module(
+    cut_path: &Path,
+    video_path: &str,
+    uuid: &str,
+    progress_state: &Arc<Mutex<ProgressState>>,
+    ui: &Arc<Mutex<Option<ProgressUi>>>,
+) -> Result<()> {
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Cut).start(1);
+    }
+
+    let cut_result = momentry_core::core::processor::process_cut(
+        video_path,
+        cut_path.to_str().unwrap(),
+        Some(uuid),
+    )
+    .await?;
+
+    let cut_json = serde_json::to_string_pretty(&cut_result)?;
+    std::fs::write(cut_path, &cut_json)?;
+
+    let output_dir = OutputDir::new();
+    let _ = output_dir.backup_file(uuid, "cut.json");
+
+    println!("  ✓ CUT saved: {} scenes", cut_result.scenes.len());
+
+    {
+        let mut state = progress_state.lock().unwrap();
+        state
+            .get_processor(ProcessorType::Cut)
+            .complete(&format!("{} scenes", cut_result.scenes.len()));
+    }
+
+    if let Some(ref mut ui) = *ui.lock().unwrap() {
+        let _ = ui.render();
+    }
+
+    Ok(())
+}

src/processing/modules/face.rs

@@ -0,0 +1,49 @@
+//! Face detection and recognition processing module
+
+use anyhow::Result;
+use momentry_core::ui::progress::{ProcessorType, ProgressState, ProgressUi};
+use momentry_core::OutputDir;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Process Face module
+pub async fn process_face_module(
+    face_path: &Path,
+    video_path: &str,
+    uuid: &str,
+    progress_state: &Arc<Mutex<ProgressState>>,
+    ui: &Arc<Mutex<Option<ProgressUi>>>,
+) -> Result<()> {
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Face).start(1);
+    }
+
+    let face_result = momentry_core::core::processor::process_face(
+        video_path,
+        face_path.to_str().unwrap(),
+        Some(uuid),
+    )
+    .await?;
+
+    let face_json = serde_json::to_string_pretty(&face_result)?;
+    std::fs::write(face_path, &face_json)?;
+
+    let output_dir = OutputDir::new();
+    let _ = output_dir.backup_file(uuid, "face.json");
+
+    println!("  ✓ Face saved: {} frames", face_result.frames.len());
+
+    {
+        let mut state = progress_state.lock().unwrap();
+        state
+            .get_processor(ProcessorType::Face)
+            .complete(&format!("{} frames", face_result.frames.len()));
+    }
+
+    if let Some(ref mut ui) = *ui.lock().unwrap() {
+        let _ = ui.render();
+    }
+
+    Ok(())
+}

src/processing/modules/mod.rs

@@ -0,0 +1,21 @@
+//! Video processing modules
+
+pub mod asr;
+pub mod asrx;
+pub mod caption;
+pub mod cut;
+pub mod face;
+pub mod ocr;
+pub mod pose;
+pub mod story;
+pub mod yolo;
+
+pub use asr::*;
+pub use asrx::*;
+pub use caption::*;
+pub use cut::*;
+pub use face::*;
+pub use ocr::*;
+pub use pose::*;
+pub use story::*;
+pub use yolo::*;

src/processing/modules/ocr.rs

@@ -0,0 +1,52 @@
+//! OCR (Optical Character Recognition) processing module
+
+use anyhow::Result;
+use momentry_core::ui::progress::{ProcessorType, ProgressState, ProgressUi};
+use momentry_core::OutputDir;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Process OCR module
+pub async fn process_ocr_module(
+    ocr_path: &Path,
+    video_path: &str,
+    uuid: &str,
+    progress_state: &Arc<Mutex<ProgressState>>,
+    ui: &Arc<Mutex<Option<ProgressUi>>>,
+) -> Result<()> {
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Ocr).start(1);
+    }
+
+    let ocr_result = momentry_core::core::processor::process_ocr(
+        video_path,
+        ocr_path.to_str().unwrap(),
+        Some(uuid),
+    )
+    .await?;
+
+    let ocr_json = serde_json::to_string_pretty(&ocr_result)?;
+    std::fs::write(ocr_path, &ocr_json)?;
+
+    let output_dir = OutputDir::new();
+    let _ = output_dir.backup_file(uuid, "ocr.json");
+
+    println!(
+        "  ✓ OCR saved: {} frames with text",
+        ocr_result.frames.len()
+    );
+
+    {
+        let mut state = progress_state.lock().unwrap();
+        state
+            .get_processor(ProcessorType::Ocr)
+            .complete(&format!("{} frames", ocr_result.frames.len()));
+    }
+
+    if let Some(ref mut ui) = *ui.lock().unwrap() {
+        let _ = ui.render();
+    }
+
+    Ok(())
+}

src/processing/modules/pose.rs

@@ -0,0 +1,50 @@
+//! Pose estimation processing module
+
+use anyhow::Result;
+use momentry_core::ui::progress::{ProcessorType, ProgressState, ProgressUi};
+use momentry_core::OutputDir;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Process Pose module
+pub async fn process_pose_module(
+    pose_path: &Path,
+    video_path: &str,
+    uuid: &str,
+    progress_state: &Arc<Mutex<ProgressState>>,
+    ui: &Arc<Mutex<Option<ProgressUi>>>,
+) -> Result<()> {
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Pose).start(1);
+    }
+
+    let pose_result = momentry_core::core::processor::process_pose(
+        video_path,
+        pose_path.to_str().unwrap(),
+        Some(uuid),
+    )
+    .await?;
+
+    let pose_json = serde_json::to_string_pretty(&pose_result)?;
+    std::fs::write(pose_path, &pose_json)?;
+
+    let output_dir = OutputDir::new();
+    let _ = output_dir.backup_file(uuid, "pose.json");
+
+    println!("  ✓ Pose saved: {} frames", pose_result.frames.len());
+
+    {
+        let mut state = progress_state.lock().unwrap();
+        state
+            .get_processor(ProcessorType::Pose)
+            .complete(&format!("{} frames", pose_result.frames.len()));
+        state.stop();
+    }
+
+    if let Some(ref mut ui) = *ui.lock().unwrap() {
+        let _ = ui.render();
+    }
+
+    Ok(())
+}

src/processing/modules/story.rs

@@ -0,0 +1,53 @@
+//! Story generation processing module
+
+use anyhow::Result;
+use momentry_core::ui::progress::{ProcessorType, ProgressState, ProgressUi};
+use momentry_core::OutputDir;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Process Story module
+pub async fn process_story_module(
+    story_path: &Path,
+    video_path: &str,
+    uuid: &str,
+    progress_state: &Arc<Mutex<ProgressState>>,
+    ui: &Arc<Mutex<Option<ProgressUi>>>,
+) -> Result<()> {
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Story).start(1);
+    }
+
+    let story_result = momentry_core::core::processor::process_story(
+        video_path,
+        story_path.to_str().unwrap(),
+        Some(uuid),
+    )
+    .await?;
+
+    let story_json = serde_json::to_string_pretty(&story_result)?;
+    std::fs::write(story_path, &story_json)?;
+
+    let output_dir = OutputDir::new();
+    let _ = output_dir.backup_file(uuid, "story.json");
+
+    println!(
+        "  ✓ Story saved: {} parent chunks, {} child chunks",
+        story_result.stats.total_parent_chunks, story_result.stats.total_child_chunks
+    );
+
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Story).complete(&format!(
+            "{} parents, {} children",
+            story_result.stats.total_parent_chunks, story_result.stats.total_child_chunks
+        ));
+    }
+
+    if let Some(ref mut ui) = *ui.lock().unwrap() {
+        let _ = ui.render();
+    }
+
+    Ok(())
+}

src/processing/modules/yolo.rs

@@ -0,0 +1,49 @@
+//! YOLO (Object Detection) processing module
+
+use anyhow::Result;
+use momentry_core::ui::progress::{ProcessorType, ProgressState, ProgressUi};
+use momentry_core::OutputDir;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+/// Process YOLO module
+pub async fn process_yolo_module(
+    yolo_path: &Path,
+    video_path: &str,
+    uuid: &str,
+    progress_state: &Arc<Mutex<ProgressState>>,
+    ui: &Arc<Mutex<Option<ProgressUi>>>,
+) -> Result<()> {
+    {
+        let mut state = progress_state.lock().unwrap();
+        state.get_processor(ProcessorType::Yolo).start(1);
+    }
+
+    let yolo_result = momentry_core::core::processor::process_yolo(
+        video_path,
+        yolo_path.to_str().unwrap(),
+        Some(uuid),
+    )
+    .await?;
+
+    let yolo_json = serde_json::to_string_pretty(&yolo_result)?;
+    std::fs::write(yolo_path, &yolo_json)?;
+
+    let output_dir = OutputDir::new();
+    let _ = output_dir.backup_file(uuid, "yolo.json");
+
+    println!("  ✓ YOLO saved: {} frames", yolo_result.frame_count);
+
+    {
+        let mut state = progress_state.lock().unwrap();
+        state
+            .get_processor(ProcessorType::Yolo)
+            .complete(&format!("{} frames", yolo_result.frame_count));
+    }
+
+    if let Some(ref mut ui) = *ui.lock().unwrap() {
+        let _ = ui.render();
+    }
+
+    Ok(())
+}