@@ -941,6 +941,15 @@ def uninstall(ctx, packages, dry_run):
                         shutil.rmtree(package_path)
                         _rich_info(f"✓ Removed {package} from apm_modules/")
                         removed_from_modules += 1
+                        
+                        # Cleanup empty parent directories up to apm_modules/
+                        parent = package_path.parent
+                        while parent != apm_modules_dir and parent.exists():
+                            if not any(parent.iterdir()):
+                                parent.rmdir()
+                                parent = parent.parent
+                            else:
+                                break
                     except Exception as e:
                         _rich_error(
                             f"✗ Failed to remove {package} from apm_modules/: {e}"
 
@@ -59,7 +59,9 @@ class ClaudeFormatter:
     Generates CLAUDE.md files following Claude's Memory format with:
     - @import syntax for dependencies
     - Grouped project standards from instructions
-    - Workflows section for agents/roles
+    
+    Note: Agents/workflows are handled separately as .github/agents/ files,
+    not included in CLAUDE.md (same as AGENTS.md behavior).
     """
 
     def __init__(self, base_dir: str = "."):
@@ -306,30 +308,9 @@ def _generate_claude_content(
                         sections.append(content)
                         sections.append("")
 
-        # Workflows section (agents/roles - only for root)
-        if placement.agents:
-            sections.append("# Workflows")
-            sections.append("")
-            
-            for agent in placement.agents:
-                # Agent name as heading
-                sections.append(f"## {agent.name}")
-                if agent.description:
-                    sections.append(f"*{agent.description}*")
-                sections.append("")
-                
-                # Agent content
-                content = agent.content.strip()
-                if content:
-                    try:
-                        rel_path = agent.file_path.relative_to(self.base_dir)
-                    except ValueError:
-                        rel_path = agent.file_path
-                    
-                    sections.append(f"<!-- Source: {rel_path} -->")
-                    sections.append(content)
-                    sections.append(f"<!-- End source: {rel_path} -->")
-                    sections.append("")
+        # Note: CLAUDE.md only contains instructions (Project Standards).
+        # Agents/workflows are NOT included - they go to .github/agents/ as separate files.
+        # This matches AGENTS.md behavior which also only contains instructions.
 
         # Footer
         sections.append("---")
@@ -355,14 +336,12 @@ def _compile_stats(
         """
         total_instructions = sum(len(p.instructions) for p in placements)
         total_patterns = sum(len(p.coverage_patterns) for p in placements)
-        total_agents = sum(len(p.agents) for p in placements)
         total_deps = sum(len(p.dependencies) for p in placements)
 
         return {
             "claude_files_generated": len(placements),
             "total_instructions_placed": total_instructions,
             "total_patterns_covered": total_patterns,
-            "total_agents_included": total_agents,
             "total_dependencies": total_deps,
             "primitives_found": primitives.count(),
         }
 
@@ -514,6 +514,110 @@ def _generate_skill_file(self, package_info, primitives: dict, skill_dir: Path)
 
         return files_copied
 
+    def _integrate_native_claude_skill(
+        self, package_info, project_root: Path, source_skill_md: Path
+    ) -> SkillIntegrationResult:
+        """Copy a native Claude Skill (with existing SKILL.md) to .claude/skills/.
+        
+        For packages that already have a SKILL.md at their root (like those from
+        awesome-claude-skills), we copy the entire skill folder rather than 
+        regenerating from .apm/ primitives.
+        
+        The skill folder name is the source folder name (e.g., `mcp-builder`).
+        
+        We add APM tracking metadata to the copied SKILL.md so sync_integration
+        can properly identify and clean up orphaned skills.
+        
+        Args:
+            package_info: PackageInfo object with package metadata
+            project_root: Root directory of the project
+            source_skill_md: Path to the source SKILL.md file
+            
+        Returns:
+            SkillIntegrationResult: Results of the integration operation
+        """
+        package_path = package_info.install_path
+        
+        # Use the source folder name as the skill name
+        # e.g., apm_modules/ComposioHQ/awesome-claude-skills/mcp-builder → mcp-builder
+        skill_name = package_path.name
+        
+        skill_dir = project_root / ".claude" / "skills" / skill_name
+        target_skill_md = skill_dir / "SKILL.md"
+        
+        # Check if we need to update
+        skill_created = False
+        skill_updated = False
+        skill_skipped = False
+        
+        if target_skill_md.exists():
+            # Check existing metadata for version/commit changes
+            existing_metadata = self._parse_skill_metadata(target_skill_md)
+            current_version = package_info.package.version
+            current_commit = (
+                package_info.resolved_reference.resolved_commit
+                if package_info.resolved_reference
+                else "unknown"
+            )
+            
+            if (existing_metadata.get('Version') == current_version and
+                existing_metadata.get('Commit') == current_commit):
+                skill_skipped = True
+            else:
+                skill_updated = True
+        else:
+            skill_created = True
+        
+        files_copied = 0
+        
+        if skill_created or skill_updated:
+            # Remove existing skill directory if updating
+            if skill_dir.exists():
+                shutil.rmtree(skill_dir)
+            
+            # Copy the entire package directory to the skill location
+            shutil.copytree(package_path, skill_dir)
+            
+            # Add APM tracking metadata to the SKILL.md for orphan detection
+            self._add_apm_metadata_to_skill(target_skill_md, package_info)
+            
+            # Count files copied
+            files_copied = sum(1 for _ in skill_dir.rglob('*') if _.is_file())
+        
+        return SkillIntegrationResult(
+            skill_created=skill_created,
+            skill_updated=skill_updated,
+            skill_skipped=skill_skipped,
+            skill_path=target_skill_md if (skill_created or skill_updated) else None,
+            references_copied=files_copied,
+            links_resolved=0
+        )
+    
+    def _add_apm_metadata_to_skill(self, skill_path: Path, package_info) -> None:
+        """Add APM tracking metadata to a SKILL.md file.
+        
+        This ensures sync_integration can identify APM-managed skills for cleanup.
+        """
+        post = frontmatter.load(skill_path)
+        
+        # Add nested metadata for APM tracking
+        if 'metadata' not in post.metadata:
+            post.metadata['metadata'] = {}
+        
+        post.metadata['metadata']['apm_package'] = package_info.get_canonical_dependency_string()
+        post.metadata['metadata']['apm_version'] = package_info.package.version
+        post.metadata['metadata']['apm_commit'] = (
+            package_info.resolved_reference.resolved_commit
+            if package_info.resolved_reference
+            else "unknown"
+        )
+        post.metadata['metadata']['apm_installed_at'] = (
+            package_info.installed_at or datetime.now().isoformat()
+        )
+        
+        with open(skill_path, 'w', encoding='utf-8') as f:
+            f.write(frontmatter.dumps(post))
+
     def integrate_package_skill(self, package_info, project_root: Path) -> SkillIntegrationResult:
         """Generate SKILL.md for a package in .claude/skills/ directory.
         
@@ -554,7 +658,12 @@ def integrate_package_skill(self, package_info, project_root: Path) -> SkillInte
 
         package_path = package_info.install_path
 
-        # Discover all primitives
+        # Check if this is a native Claude Skill (already has SKILL.md at root)
+        source_skill_md = package_path / "SKILL.md"
+        if source_skill_md.exists():
+            return self._integrate_native_claude_skill(package_info, project_root, source_skill_md)
+        
+        # Discover all primitives for APM packages without SKILL.md
         instruction_files = self.find_instruction_files(package_path)
         agent_files = self.find_agent_files(package_path)
         context_files = self.find_context_files(package_path)
@@ -582,11 +691,9 @@ def integrate_package_skill(self, package_info, project_root: Path) -> SkillInte
             )
 
         # Determine target paths - write to .claude/skills/{skill-name}/
-        # Use skill_name_from_dependency for unique, consistent names:
-        # - owner/repo → owner-repo
-        # - owner/repo/skill → owner-repo-skill
-        canonical_dep = package_info.get_canonical_dependency_string()
-        skill_name = skill_name_from_dependency(canonical_dep)
+        # Use the install folder name for simplicity and consistency
+        # e.g., apm_modules/danielmeppiel/design-guidelines → design-guidelines
+        skill_name = package_path.name
         skill_dir = project_root / ".claude" / "skills" / skill_name
         skill_dir.mkdir(parents=True, exist_ok=True)
 
@@ -632,6 +739,7 @@ def sync_integration(self, apm_package, project_root: Path) -> Dict[str, int]:
         """Sync .claude/skills/ with currently installed packages.
         
         Removes skill directories for packages that are no longer installed.
+        Uses apm_package metadata in SKILL.md to identify APM-managed skills.
         
         Args:
             apm_package: APMPackage with current dependencies
@@ -644,27 +752,24 @@ def sync_integration(self, apm_package, project_root: Path) -> Dict[str, int]:
         if not skills_dir.exists():
             return {'files_removed': 0, 'errors': 0}
 
-        # Get list of currently installed package skill names
-        # Use skill_name_from_dependency to match how integrate_package_skill names them
-        installed_skill_names = set()
+        # Get canonical dependency strings for all installed packages
+        installed_packages = set()
         for dep in apm_package.get_apm_dependencies():
-            skill_name = skill_name_from_dependency(dep.get_canonical_dependency_string())
-            installed_skill_names.add(skill_name)
+            installed_packages.add(dep.get_canonical_dependency_string())
 
-        # Find orphaned skill directories (those with -apm suffix pattern or all if needed)
+        # Find orphaned skill directories by checking apm_package metadata
         files_removed = 0
         errors = 0
 
         for skill_subdir in skills_dir.iterdir():
             if skill_subdir.is_dir():
-                # Check if this skill came from APM (has apm_package in metadata)
                 skill_md = skill_subdir / "SKILL.md"
                 if skill_md.exists():
                     try:
                         metadata = self._parse_skill_metadata(skill_md)
-                        if metadata.get('Package'):  # Has APM metadata
-                            skill_name = skill_subdir.name
-                            if skill_name not in installed_skill_names:
+                        apm_package_ref = metadata.get('Package')
+                        if apm_package_ref:  # This is an APM-managed skill
+                            if apm_package_ref not in installed_packages:
                                 # Remove orphaned skill directory
                                 shutil.rmtree(skill_subdir)
                                 files_removed += 1
 
@@ -257,8 +257,12 @@ def test_no_dependencies_section_when_no_apm_modules(self, tmp_path):
         assert deps == []
 
 
-class TestAgentsAndWorkflows:
-    """Tests for agents/workflows inclusion in CLAUDE.md."""
+class TestAgentsExcludedFromClaudeMd:
+    """Tests verifying agents/workflows are NOT included in CLAUDE.md.
+    
+    Agents are handled separately via .github/agents/ files and .claude/skills/
+    folders - they should NOT be embedded in CLAUDE.md (same as AGENTS.md).
+    """
 
     @pytest.fixture
     def temp_project(self):
@@ -267,8 +271,8 @@ def temp_project(self):
         yield Path(temp_dir).resolve()
         shutil.rmtree(temp_dir, ignore_errors=True)
 
-    def test_agents_included_in_workflows_section(self, temp_project):
-        """Test that agents/chatmodes are included in Workflows section."""
+    def test_agents_not_in_claude_md(self, temp_project):
+        """Test that agents/chatmodes are NOT included in CLAUDE.md."""
         formatter = ClaudeFormatter(str(temp_project))
         primitives = PrimitiveCollection()
 
@@ -298,13 +302,14 @@ def test_agents_included_in_workflows_section(self, temp_project):
 
         content = result.content_map[formatter.base_dir / "CLAUDE.md"]
 
-        assert "# Workflows" in content
-        assert "## code-reviewer" in content
-        assert "*Expert code reviewer*" in content
-        assert "You are an expert code reviewer." in content
+        # Workflows section should NOT exist - agents go to .github/agents/
+        assert "# Workflows" not in content
+        assert "## code-reviewer" not in content
+        # Instructions should still be there
+        assert "Test content" in content
 
-    def test_agents_only_in_root_claude_md(self, temp_project):
-        """Test that agents are only included in root CLAUDE.md."""
+    def test_claude_md_only_contains_instructions(self, temp_project):
+        """Test that CLAUDE.md only contains instructions, not agents."""
         formatter = ClaudeFormatter(str(temp_project))
         primitives = PrimitiveCollection()
 
@@ -319,35 +324,30 @@ def test_agents_only_in_root_claude_md(self, temp_project):
         primitives.add_primitive(chatmode)
 
         instruction = Instruction(
-            name="test",
-            file_path=temp_project / "test.instructions.md",
-            description="Test",
-            apply_to="src/**/*.py",
-            content="Test content",
+            name="python-standards",
+            file_path=temp_project / "python.instructions.md",
+            description="Python standards",
+            apply_to="**/*.py",
+            content="Use type hints for all functions.",
             author="test"
         )
         primitives.add_primitive(instruction)
 
-        # Create subdirectory placement using resolved paths
-        src_dir = formatter.base_dir / "src"
-        src_dir.mkdir(exist_ok=True)
-        
-        placement_map = {
-            formatter.base_dir: [instruction],
-            src_dir: [instruction]
-        }
+        placement_map = {formatter.base_dir: [instruction]}
         result = formatter.format_distributed(primitives, placement_map)
 
-        # Root should have workflows
-        root_content = result.content_map[formatter.base_dir / "CLAUDE.md"]
-        assert "# Workflows" in root_content
+        content = result.content_map[formatter.base_dir / "CLAUDE.md"]
+        
+        # Should have instructions
+        assert "Use type hints for all functions." in content
+        assert "**/*.py" in content
 
-        # Subdirectory should not have workflows
-        src_content = result.content_map[src_dir / "CLAUDE.md"]
-        assert "# Workflows" not in src_content
+        # Should NOT have agent content
+        assert "You are a reviewer." not in content
+        assert "Workflows" not in content
 
-    def test_multiple_agents_included(self, temp_project):
-        """Test that multiple agents are all included."""
+    def test_multiple_chatmodes_excluded(self, temp_project):
+        """Test that multiple chatmodes are all excluded from CLAUDE.md."""
         formatter = ClaudeFormatter(str(temp_project))
         primitives = PrimitiveCollection()
 
@@ -375,7 +375,7 @@ def test_multiple_agents_included(self, temp_project):
             file_path=temp_project / "test.instructions.md",
             description="Test",
             apply_to="**/*.py",
-            content="Test",
+            content="Test instruction content",
             author="test"
         )
         primitives.add_primitive(instruction)
@@ -385,10 +385,14 @@ def test_multiple_agents_included(self, temp_project):
 
         content = result.content_map[formatter.base_dir / "CLAUDE.md"]
 
-        assert "## reviewer" in content
-        assert "## architect" in content
-        assert "Review code." in content
-        assert "Design systems." in content
+        # Agents should NOT be in CLAUDE.md
+        assert "## reviewer" not in content
+        assert "## architect" not in content
+        assert "Review code." not in content
+        assert "Design systems." not in content
+        
+        # But instructions should be there
+        assert "Test instruction content" in content
 
 
 class TestGenerateCommands:
 
@@ -134,10 +134,9 @@ def teardown_method(self):
     def _get_skill_path(self, package_info) -> Path:
         """Get the expected skill directory path for a package.
         
-        Uses skill_name_from_dependency to match the actual integrate_package_skill behavior.
+        Uses the install folder name for simplicity and consistency.
         """
-        canonical = package_info.get_canonical_dependency_string()
-        skill_name = skill_name_from_dependency(canonical)
+        skill_name = package_info.install_path.name
         return self.project_root / ".claude" / "skills" / skill_name
 
     # ========== should_integrate tests ==========