fix: surface nested-glob walk errors

Make nested-glob traversal and clean report skipped WalkDir errors in verbose/debug output so filesystem issues are visible during review. Clarify that exclude patterns match directories too, which enables subtree pruning without requiring a trailing /**.

Author: yacosta738

src/config.rs

@@ -113,9 +113,11 @@ pub struct TargetConfig {
     pub pattern: Option<String>,
 
     /// Glob patterns that exclude paths from a `nested-glob` search.
-    /// Each pattern is matched against the path of a discovered file relative
-    /// to the search root.  Common defaults include `node_modules/**` and
-    /// `**/.git/**`.  Has no effect on other target types.
+    /// Each pattern is matched against discovered paths relative to the search
+    /// root, including both files and directories. Directory matches are used
+    /// to prune whole subtrees during traversal, so `node_modules`,
+    /// `node_modules/**`, `.git`, and `**/.git/**` all prevent descending into
+    /// those directories. Has no effect on other target types.
     #[serde(default)]
     pub exclude: Vec<String>,
 

src/linker.rs

@@ -611,7 +611,22 @@ impl Linker {
         while let Some(entry) = it.next() {
             let entry = match entry {
                 Ok(e) => e,
-                Err(_) => continue,
+                Err(err) => {
+                    if options.verbose {
+                        let path = err
+                            .path()
+                            .map(|p| p.display().to_string())
+                            .unwrap_or_else(|| "<unknown path>".to_string());
+                        println!(
+                            "  {} WalkDir error while scanning {}: {}",
+                            "!".yellow(),
+                            path,
+                            err
+                        );
+                    }
+                    tracing::debug!(error = %err, path = ?err.path(), "WalkDir entry skipped during nested-glob sync");
+                    continue;
+                }
             };
 
             // Compute path relative to search root
@@ -830,7 +845,22 @@ impl Linker {
                         while let Some(entry) = it.next() {
                             let entry = match entry {
                                 Ok(e) => e,
-                                Err(_) => continue,
+                                Err(err) => {
+                                    if options.verbose {
+                                        let path = err
+                                            .path()
+                                            .map(|p| p.display().to_string())
+                                            .unwrap_or_else(|| "<unknown path>".to_string());
+                                        println!(
+                                            "  {} WalkDir error while cleaning {}: {}",
+                                            "!".yellow(),
+                                            path,
+                                            err
+                                        );
+                                    }
+                                    tracing::debug!(error = %err, path = ?err.path(), "WalkDir entry skipped during nested-glob clean");
+                                    continue;
+                                }
                             };
 
                             let rel_path = match entry.path().strip_prefix(&search_root) {