DeepLabCut · C-Achard · Jul 9, 2026 · Jul 9, 2026 · Jul 9, 2026 · Jul 10, 2026
diff --git a/dlclivegui/config.py b/dlclivegui/config.py
@@ -38,6 +38,8 @@
 DLC_DO_LOG_TIMING: bool = False
 ### Trigger debug logging
 DEBUG_TRIGGER_LOGS = False
+### Extra logs for DLC lifecycle (model loading, etc)
+DLC_LIFECYCLE_EXTRA_LOGS: bool = False
 # MAIN_WINDOW_DO_LOG_TIMING: bool = False
 #### Backends
 BASLER_DO_LOG_TIMING: bool = False

diff --git a/dlclivegui/gui/main_window.py b/dlclivegui/gui/main_window.py
@@ -65,8 +65,11 @@
 )
 
 from ..processors.processor_utils import (
+    create_spec_from_scan,
     default_processors_dir,
     instantiate_from_scan,
+    log_processor_context,
+    processor_builds_in_worker,
     scan_processor_folder,
     scan_processor_package,
 )
@@ -156,6 +159,8 @@ def __init__(self, config: ApplicationSettings | None = None):
         self._raw_frame: np.ndarray | None = None
         self._last_pose: PoseResult | None = None
         self._dlc_active: bool = False
+        self._processor_recording_context: dict | None = None
+        self._processor_recording_started_notified = False
         self._pending_recording_after_preview = False
         self._active_camera_settings: CameraSettings | None = None
         self._last_drop_warning = 0.0
@@ -935,7 +940,7 @@ def _apply_config(self, config: ApplicationSettings, *, restore_local_prefs: boo
             color_ui.set_bbox_combo_from_bgr(self.bbox_color_combo, self._bbox_color)
 
         # Processor
-        ## Allow processor control checkbox state
+        ## Use custom processor checkbox state
         if hasattr(self, "use_custom_proc_checkbox"):
             self.use_custom_proc_checkbox.setChecked(self._settings_store.get_processor_control_enabled(default=False))
 
@@ -1852,6 +1857,10 @@ def _start_multi_camera_recording(self) -> None:
         if run_dir is None:
             self._show_error("Failed to start recording.")
             return
+
+        self._processor_recording_context = self._build_processor_recording_context(run_dir)
+        self._processor_recording_started_notified = False
+        self._notify_processor_recording_started(self._processor_recording_context)
         self.multi_camera_controller.set_recording_sink(self._rec_manager.write_frame)
         self.multi_camera_controller.set_recording_frame_do_emit(True)
 
@@ -1898,7 +1907,152 @@ def worker():
             daemon=True,
         ).start()
 
+    def _get_dlc_processor_instance(self):
+        """Return the active custom DLC processor instance, if available."""
+        processor = getattr(self._dlc, "_processor", None)
+
+        if processor is not None:
+            return processor
+
+        # Fallback: if DLCLive owns it internally.
+        dlc_obj = getattr(self._dlc, "_dlc", None)
+        if dlc_obj is not None:
+            return getattr(dlc_obj, "processor", None)
+
+        return None
+
+    def _save_processor_data_if_available(self) -> None:
+        """Best-effort generic processor save.
+
+        The GUI intentionally does not pass a path here. This lets custom processors
+        use their own save_path / filename / internal policy.
+
+        Expected processor contract:
+            processor.save() -> int | bool | None
+
+        Return values are only logged; failure should not crash the GUI.
+        """
+        processor = self._get_dlc_processor_instance()
+
+        if processor is None:
+            logger.debug("Processor save skipped: no processor instance available.")
+            return
+
+        save = getattr(processor, "save", None)
+        if not callable(save):
+            logger.debug("Processor save skipped: processor has no callable save().")
+            return
+
+        try:
+            result = save()
+            logger.info("Processor save() completed with result: %r", result)
+        except Exception:
+            logger.exception("Processor save() failed.")
+
+    def _notify_processor_recording_started(self, context: dict) -> bool:
+        processor = self._get_dlc_processor_instance()
+        if processor is None:
+            return False
+
+        hook = getattr(processor, "on_recording_started", None)
+        if not callable(hook):
+            return False
+
+        try:
+            hook(context)
+            self._processor_recording_started_notified = True
+            logger.info("Notified processor recording started: %s", context)
+            return True
+        except Exception:
+            logger.exception("Processor on_recording_started hook failed")
+            return False
+
+    def _build_processor_recording_context(self, run_dir) -> dict:
+        run_dir = Path(run_dir) if run_dir is not None else None
+
+        file_context = {}
+        try:
+            file_context = self._rec_manager.get_recording_file_context()
+        except Exception:
+            logger.exception("Failed to get recording file context from RecordingManager")
+            file_context = {}
+
+        if run_dir is None:
+            run_dir = file_context.get("run_dir", None)
+        if run_dir is not None:
+            run_dir = Path(run_dir)
+
+        session_name = ""
+        if hasattr(self, "session_name_edit"):
+            session_name = self.session_name_edit.text().strip()
+
+        filename = ""
+        if hasattr(self, "filename_edit"):
+            filename = self.filename_edit.text().strip()
+
+        filename_stem = Path(filename or session_name or "recording").stem
+
+        ctx = {
+            "run_dir": run_dir,
+            "session_name": session_name,
+            "filename": filename,
+            "filename_stem": filename_stem,
+            "processor_base_path": run_dir / filename_stem if run_dir is not None else None,
+        }
+        ctx.update(file_context)
+        return ctx
+
+    def _final_processor_recording_context(self) -> dict:
+        cached = self._processor_recording_context
+
+        run_dir = None
+        if cached is not None:
+            run_dir = cached.get("run_dir")
+        if run_dir is None:
+            run_dir = getattr(self._rec_manager, "run_dir", None)
+
+        context = self._build_processor_recording_context(run_dir)
+        if cached is not None:
+            context.update(cached)
+
+        try:
+            final_file_context = self._rec_manager.get_recording_file_context()
+        except Exception:
+            logger.exception("Failed to get finalized recording file context")
+            final_file_context = {}
+
+        context.update(final_file_context)
+        return context
+
+    def _notify_processor_recording_stopped(self) -> None:
+        processor = self._get_dlc_processor_instance()
+        if processor is None:
+            return
+
+        hook = getattr(processor, "on_recording_stopped", None)
+        if not callable(hook):
+            return
+
+        try:
+            context = self._final_processor_recording_context()
+            hook(context)
+            logger.info("Notified processor recording stopped")
+        except Exception:
+            logger.exception("Processor on_recording_stopped hook failed")
+
+    def _finalize_processor_recording(self) -> None:
+        """Notify the processor and save its recording data."""
+        try:
+            self._notify_processor_recording_stopped()
+            self._save_processor_data_if_available()
+        finally:
+            self._processor_recording_context = None
+            self._processor_recording_started_notified = False
+
     def _on_recording_stopped_async(self) -> None:
+        if self._processor_recording_context is not None:
+            self._finalize_processor_recording()
+
         self._recording_stopping = False
         self.start_record_button.setEnabled(True)
         self.stop_record_button.setEnabled(False)
@@ -2021,34 +2175,63 @@ def _stop_preview(self) -> None:
     def _configure_dlc(self) -> bool:
         try:
             settings = self._dlc_settings_from_ui()
-        except (ValueError, RuntimeError, json.JSONDecodeError) as exc:
+        except (
+            ValueError,
+            RuntimeError,
+            json.JSONDecodeError,
+        ) as exc:
             self._show_error(f"Invalid DLCLive settings: {exc}")
             return False
+
         if not settings.model_path:
             self._show_error("Please select a DLCLive model before starting inference.")
             return False
 
-        # Instantiate processor if selected
         processor = None
+        processor_spec = None
         selected_key = self.processor_combo.currentData()
 
         self._settings_store.set_processor_key(selected_key)
 
         if self._custom_processor_enabled():
             try:
-                processor = instantiate_from_scan(
-                    self._scanned_processors,
-                    selected_key,
+                processor_info = self._scanned_processors[selected_key]
+                processor_class = processor_info["class"]
+                processor_name = processor_info.get(
+                    "name",
+                    processor_class.__name__,
                 )
-                processor_name = self._scanned_processors[selected_key]["name"]
+
+                if processor_builds_in_worker(processor_class):
+                    processor_spec = create_spec_from_scan(
+                        self._scanned_processors,
+                        selected_key,
+                    )
+
+                    log_processor_context(
+                        f"MainWindow._configure_dlc - SPEC: {processor_class.__name__}",
+                        logger,
+                    )
+                else:
+                    processor = instantiate_from_scan(
+                        self._scanned_processors,
+                        selected_key,
+                    )
+
+                    log_processor_context(
+                        f"MainWindow._configure_dlc - INSTANCE: {type(processor).__name__}",
+                        logger,
+                    )
+
                 self.statusBar().showMessage(
                     f"Loaded processor: {processor_name}",
                     3000,
                 )
+
             except Exception as exc:
-                error_msg = f"Failed to instantiate processor: {exc}"
+                error_msg = f"Failed to configure processor: {exc}"
                 self._show_error(error_msg)
-                logger.error(error_msg)
+                logger.exception(error_msg)
                 return False
 
         elif selected_key is not None:
@@ -2057,7 +2240,11 @@ def _configure_dlc(self) -> bool:
                 3000,
             )
 
-        self._dlc.configure(settings, processor=processor)
+        self._dlc.configure(
+            settings,
+            processor=processor,
+            processor_spec=processor_spec,
+        )
         self._model_path_store.save_if_valid(settings.model_path)
         return True
 
@@ -2192,20 +2379,6 @@ def _update_metrics(self) -> None:
             else:
                 self.recording_stats_label.setText(self._last_recorder_summary)
 
-    def _on_processor_selection_changed(
-        self,
-        _index: int,
-    ) -> None:
-        """Enable custom processing when a processor is selected."""
-        has_selection = self.processor_combo.currentData() is not None
-        self.processor_toggle_row.setVisible(has_selection)
-
-        self.use_custom_proc_checkbox.blockSignals(True)
-        self.use_custom_proc_checkbox.setChecked(has_selection)
-        self.use_custom_proc_checkbox.blockSignals(False)
-
-        self._update_processor_status()
-
     def _update_processor_status(self) -> None:
         """Update processor connection and recording status, handle auto-recording."""
         if not self._custom_processor_enabled():
@@ -2299,7 +2472,7 @@ def _stop_inference(self, show_message: bool = True) -> None:
         was_active = self._dlc_active
         self._dlc_active = False
         self._dlc_initialized = False
-        self._dlc.reset()
+        self._dlc.reset(reset_processor_plugin=True)
         self._last_pose = None
         self._last_processor_vid_recording = False
         self._auto_record_session_name = None
@@ -2442,6 +2615,9 @@ def _on_bbox_changed(self, _value: int = 0) -> None:
     def _on_dlc_initialised(self, success: bool) -> None:
         if success:
             self._dlc_initialized = True
+            if self._processor_recording_context is not None and not self._processor_recording_started_notified:
+                self._notify_processor_recording_started(self._processor_recording_context)
+
             # Update button to show running state
             self.start_inference_button.setText("DLCLive running!")
             self.start_inference_button.setStyleSheet("background-color: #4CAF50; color: white;")
@@ -2508,9 +2684,12 @@ def closeEvent(self, event: QCloseEvent) -> None:  # pragma: no cover - GUI beha
             self.multi_camera_controller.set_recording_frame_do_emit(False)
         except Exception:
             logger.exception("Failed to disable recording frame emission during shutdown")
+
         while not self._rec_manager.stop_all():
             logger.info("Retrying recorder stop during shutdown...")
             time.sleep(RECORD_STOP_RETRY_INTERVAL)
+        if self._processor_recording_context is not None:
+            self._finalize_processor_recording()
 
         # Close the camera dialog if open (ensures its worker thread is canceled)
         if getattr(self, "_cam_dialog", None) is not None and self._cam_dialog.isVisible():
@@ -2544,7 +2723,7 @@ def closeEvent(self, event: QCloseEvent) -> None:  # pragma: no cover - GUI beha
 
         # Remember processor-control checkbox state on exit
         if hasattr(self, "use_custom_proc_checkbox"):
-            self._settings_store.set_processor_control_enabled(self.use_custom_proc_checkbox.isChecked())
+            self._settings_store.set_processor_control_enabled(self._custom_processor_enabled())
 
         if hasattr(self, "filename_edit"):
             self._settings_store.set_rec_filename(self.filename_edit.text().strip())