fix: apply pattern matching to relative paths instead of absolute paths

Config file ignore/include patterns were not working correctly because
pattern matching was performed against absolute paths instead of
relative paths. This caused patterns like "agents/git-*" to never match
because they were compared against full filesystem paths like
"/home/user/project/agents/git-commit.md".

Changes:
- Move relative path calculation before pattern matching in orchestrator
- Apply pattern filters to relative paths (strip_prefix before matching)
- Add test case to verify wildcard patterns work with relative paths
- Update integration tests to use contains() instead of len() checks
  to handle additional patterns from global config

This ensures that pattern-based filtering works as users expect when
specifying relative paths in their configuration files.

Author: onsails

crates/ccsync-core/src/config/integration_tests.rs

@@ -33,8 +33,10 @@ include = true
     let _manager = ConfigManager::new();
     let config = ConfigManager::load(Some(&config_file)).unwrap();
 
-    assert_eq!(config.ignore.len(), 2);
-    assert_eq!(config.include.len(), 1);
+    // Check that expected patterns are present (may include additional patterns from global config)
+    assert!(config.ignore.contains(&"*.tmp".to_string()));
+    assert!(config.ignore.contains(&"*.log".to_string()));
+    assert!(config.include.contains(&"important.tmp".to_string()));
     assert!(config.follow_symlinks != Some(true));
     assert_eq!(config.rules.len(), 1);
     assert_eq!(config.rules[0].direction, Some(SyncDirection::ToLocal));

crates/ccsync-core/src/config/patterns.rs

@@ -99,4 +99,17 @@ mod tests {
         assert!(!matcher.should_include(&PathBuf::from("node_modules"), true));
         assert!(matcher.should_include(&PathBuf::from("src"), true));
     }
+
+    #[test]
+    fn test_relative_path_wildcards() {
+        let matcher = PatternMatcher::with_patterns(&["agents/git-*".to_string()], &[]).unwrap();
+
+        // Should match agents/git-* pattern
+        assert!(!matcher.should_include(&PathBuf::from("agents/git-commit.md"), false));
+        assert!(!matcher.should_include(&PathBuf::from("agents/git-helper.md"), false));
+
+        // Should NOT match agents/git-* pattern
+        assert!(matcher.should_include(&PathBuf::from("agents/other-agent.md"), false));
+        assert!(matcher.should_include(&PathBuf::from("skills/test.md"), false));
+    }
 }

crates/ccsync-core/src/sync.rs

@@ -260,4 +260,37 @@ mod integration_tests {
         assert!(summary.contains("✗ Completed with errors"));
         assert!(!result.is_success());
     }
+
+    #[test]
+    fn test_sync_pattern_matching_with_relative_paths() {
+        let (source_dir, dest_dir) = setup_test_dirs();
+
+        // Create multiple files with git-* pattern in agents/
+        create_test_file(source_dir.path(), "agents/git-commit.md", "git commit agent");
+        create_test_file(source_dir.path(), "agents/git-helper.md", "git helper agent");
+        create_test_file(source_dir.path(), "agents/other-agent.md", "other agent");
+        // Create a skill (skills/test-skill/SKILL.md is the expected structure)
+        create_test_file(source_dir.path(), "skills/test-skill/SKILL.md", "test skill");
+
+        // Configure to ignore agents/git-* pattern (relative path)
+        let mut config = Config::default();
+        config.ignore = vec!["agents/git-*".to_string()];
+
+        let engine = SyncEngine::new(config, SyncDirection::ToLocal).unwrap();
+        let result = engine.sync(source_dir.path(), dest_dir.path()).unwrap();
+
+        // Should create 2 files (other-agent.md and skills/test-skill/SKILL.md)
+        // Should skip 2 files (git-commit.md and git-helper.md)
+        assert_eq!(result.created, 2);
+        assert_eq!(result.skipped, 2);
+        assert!(result.is_success());
+
+        // Verify git-* files were NOT created
+        assert!(!dest_dir.path().join("agents/git-commit.md").exists());
+        assert!(!dest_dir.path().join("agents/git-helper.md").exists());
+
+        // Verify other files WERE created
+        assert!(dest_dir.path().join("agents/other-agent.md").exists());
+        assert!(dest_dir.path().join("skills/test-skill/SKILL.md").exists());
+    }
 }

crates/ccsync-core/src/sync/orchestrator.rs

@@ -83,21 +83,21 @@ impl SyncEngine {
         let conflict_strategy = self.get_conflict_strategy();
 
         for file in &scan_result.files {
-            // Apply pattern filter
+            // Get relative path first (needed for pattern matching)
+            let rel_path = file
+                .path
+                .strip_prefix(source_root)
+                .with_context(|| format!("Failed to strip prefix from {}", file.path.display()))?;
+
+            // Apply pattern filter to relative path
             let is_dir = file.path.is_dir();
             if let Some(ref matcher) = self.pattern_matcher
-                && !matcher.should_include(&file.path, is_dir)
+                && !matcher.should_include(rel_path, is_dir)
             {
                 result.skipped += 1;
                 continue;
             }
 
-            // Get relative path
-            let rel_path = file
-                .path
-                .strip_prefix(source_root)
-                .with_context(|| format!("Failed to strip prefix from {}", file.path.display()))?;
-
             let dest_path = dest_root.join(rel_path);
 
             // Compare files