fix(plugins): address review feedback on unified loader

- Use copy_plugin helper for gain-native instead of raw cp + glob,
  ensuring consistent handling of versioned .so.* and plugin.yml.
- Log a warning when the native plugins directory cannot be read,
  matching the behavior of load_active_plugin_records.
- Distinguish 'already loaded' skips (debug level) from genuine load
  failures (warn level) to avoid misleading log output.
- Sort discovered library paths for deterministic load order.
- Add comment explaining the source-label heuristic.

Signed-off-by: StreamKit Devin <devin@streamkit.dev>
Co-Authored-By: Claudio Costa <cstcld91@gmail.com>

Author: streamkit-devin

apps/skit/src/plugins.rs

@@ -273,36 +273,54 @@ impl UnifiedPluginManager {
         let mut dir_bundle_libs: Vec<std::path::PathBuf> = Vec::new();
         let mut bare_libs: Vec<std::path::PathBuf> = Vec::new();
 
-        if let Ok(entries) = std::fs::read_dir(&self.native_directory) {
-            for entry in entries.flatten() {
-                let path = entry.path();
-
-                if path.is_dir() {
-                    // Scan one level of subdirectories for plugin libraries.
-                    if let Ok(sub_entries) = std::fs::read_dir(&path) {
-                        for sub_entry in sub_entries.flatten() {
-                            let sub_path = sub_entry.path();
-                            if Self::is_native_lib(&sub_path) {
-                                dir_bundle_libs.push(sub_path);
+        match std::fs::read_dir(&self.native_directory) {
+            Ok(entries) => {
+                for entry in entries.flatten() {
+                    let path = entry.path();
+
+                    if path.is_dir() {
+                        // Scan one level of subdirectories for plugin libraries.
+                        if let Ok(sub_entries) = std::fs::read_dir(&path) {
+                            for sub_entry in sub_entries.flatten() {
+                                let sub_path = sub_entry.path();
+                                if Self::is_native_lib(&sub_path) {
+                                    dir_bundle_libs.push(sub_path);
+                                }
                             }
                         }
+                        continue;
                     }
-                    continue;
-                }
 
-                if Self::is_native_lib(&path) {
-                    bare_libs.push(path);
+                    if Self::is_native_lib(&path) {
+                        bare_libs.push(path);
+                    }
                 }
-            }
+            },
+            Err(err) => {
+                warn!(
+                    error = %err,
+                    dir = %self.native_directory.display(),
+                    "Failed to read native plugins directory"
+                );
+            },
         }
 
+        // Sort for deterministic load order when multiple bundles or bare
+        // files provide the same plugin kind.
+        dir_bundle_libs.sort();
+        bare_libs.sort();
+
         // Load directory-bundle plugins first, then bare files.  Skip any
         // plugin whose kind is already loaded (from active records or an
         // earlier library in this phase).
         let mut summaries = Vec::new();
         for path in dir_bundle_libs.into_iter().chain(bare_libs) {
             match self.load_native_plugin(&path) {
                 Ok(summary) => {
+                    // Classify the source based on the library's parent
+                    // directory: if it is directly inside the native dir it
+                    // came from a bare flat file; otherwise it is nested
+                    // inside a subdirectory (directory-bundle layout).
                     let source = if path.parent() == Some(self.native_directory.as_path()) {
                         "bare-file"
                     } else {
@@ -317,7 +335,12 @@ impl UnifiedPluginManager {
                     summaries.push(summary);
                 },
                 Err(err) => {
-                    warn!(error = %err, file = ?path, "Failed to load native plugin from disk");
+                    let msg = err.to_string();
+                    if msg.contains("already loaded") || msg.contains("already registered") {
+                        debug!(file = ?path, "Skipping plugin (already loaded by higher-priority source)");
+                    } else {
+                        warn!(error = %err, file = ?path, "Failed to load native plugin from disk");
+                    }
                 },
             }
         }

justfile

@@ -1038,8 +1038,7 @@ copy-plugins-native:
     }
 
     # Examples (gain-native has its own target dir, not shared)
-    mkdir -p .plugins/native/gain-native
-    cp examples/plugins/gain-native/target/release/libgain_plugin_native.* .plugins/native/gain-native/ 2>/dev/null || true
+    copy_plugin "gain-native" "gain_plugin_native" "examples/plugins/gain-native/target"
 
     # Official native plugins (shared target dir).
     # For most plugins the lib stem matches the plugin id.