fix(pm): preserve clone error chain instead of swallowing it

Previously clone_package_once() returned bool and used .ok()? to
discard the error from clone_package(). The caller in install.rs
could only bail with a generic "{name} clone failed" message,
losing the underlying IO error (e.g. NTFS hardlink failure on
Windows).

Now clone_package_once() returns Result<()> and the full error
chain propagates to the user. The warn log also uses {:#} to
print the complete error chain.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: elrrrrrrr

crates/pm/src/service/install.rs

@@ -136,13 +136,15 @@ pub async fn install_packages(
                         package.optional == Some(true) || package.dev_optional == Some(true);
 
                     let task = tokio::spawn(async move {
-                        if !clone_package_once(&name, &version, &resolved, &target_path).await {
+                        if let Err(e) =
+                            clone_package_once(&name, &version, &resolved, &target_path).await
+                        {
                             if is_optional {
                                 tracing::warn!("Optional dependency {name} failed (ignored)");
                                 PROGRESS_BAR.inc(1);
                                 return Ok(());
                             }
-                            anyhow::bail!("{name} clone failed");
+                            return Err(e);
                         }
                         PROGRESS_BAR.inc(1);
                         log_progress(&format!("{name} resolved"));

crates/pm/src/service/pipeline/worker.rs

@@ -59,7 +59,7 @@ pub fn start_workers(channels: PipelineChannels, cwd: PathBuf) -> PipelineHandle
                 if let Some(ref parent) = parent_path {
                     wait_clone_if_pending(&parent.to_string_lossy()).await;
                 }
-                clone_package_once(&name, &version, &tarball_url, &target).await;
+                let _ = clone_package_once(&name, &version, &tarball_url, &target).await;
             });
         }
     });

crates/pm/src/util/cloner.rs

@@ -41,7 +41,7 @@ pub async fn clone_package_once(
     version: &str,
     tarball_url: &str,
     target_path: &Path,
-) -> bool {
+) -> Result<()> {
     let key = target_path.to_string_lossy().to_string();
     let name = name.to_string();
     let version = version.to_string();
@@ -52,28 +52,40 @@ pub async fn clone_package_once(
     // so skip `find_real_src` which would incorrectly pick a subdirectory.
     let is_git = is_git_url(&tarball_url);
 
-    CLONE_CACHE
-        .get_or_init(key, || async move {
-            let cache_path = resolve_cache_path(&name, &version, &tarball_url).await?;
-            clone_package(&cache_path, &target_path, &name, &version, !is_git)
-                .await
-                .inspect_err(|e| {
-                    tracing::warn!(
-                        "Clone failed: {}@{} to {}: {}",
-                        name,
-                        version,
-                        target_path.display(),
-                        e
-                    )
-                })
-                .ok()?;
-
-            CLONE_COUNT.fetch_add(1, Ordering::Relaxed);
-            tracing::debug!("Cloned: {}@{} to {}", name, version, target_path.display());
-            Some(())
+    let target_display = target_path.display().to_string();
+
+    let ok = CLONE_CACHE
+        .get_or_init(key, || {
+            let name = name.clone();
+            let version = version.clone();
+            async move {
+                let cache_path = resolve_cache_path(&name, &version, &tarball_url).await?;
+                clone_package(&cache_path, &target_path, &name, &version, !is_git)
+                    .await
+                    .inspect_err(|e| {
+                        tracing::warn!(
+                            "Clone failed: {}@{} to {}: {:#}",
+                            name,
+                            version,
+                            target_path.display(),
+                            e
+                        )
+                    })
+                    .ok()?;
+
+                CLONE_COUNT.fetch_add(1, Ordering::Relaxed);
+                tracing::debug!("Cloned: {}@{} to {}", name, version, target_path.display());
+                Some(())
+            }
         })
         .await
-        .is_some()
+        .is_some();
+
+    if ok {
+        Ok(())
+    } else {
+        anyhow::bail!("Failed to clone {name}@{version} to {target_display}")
+    }
 }
 
 #[cfg(target_os = "macos")]