claude-mpm 5.4.54__tar.gz → 5.4.56__tar.gz

{claude_mpm-5.4.54/src/claude_mpm.egg-info → claude_mpm-5.4.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 5.4.54
+Version: 5.4.56
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-5.4.54 → claude_mpm-5.4.56}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "5.4.54"
+version = "5.4.56"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -189,7 +189,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "5.4.54"
+version = "5.4.56"
 version_files = [ "VERSION", "src/claude_mpm/VERSION", "package.json:version",]
 tag_format = "v$version"
 update_changelog_on_bump = true

claude_mpm-5.4.56/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+5.4.56

{claude_mpm-5.4.54 → claude_mpm-5.4.56}/src/claude_mpm/cli/startup.py

@@ -990,160 +990,188 @@ def sync_remote_skills_on_startup():
 
         # Phase 2: Scan agents and save to configuration.yaml
         # This step populates configuration.yaml with agent-referenced skills
-        if results["synced_count"] > 0:
-            agents_dir = Path.cwd() / ".claude" / "agents"
-
-            # Scan agents for skill requirements
-            agent_skills = get_required_skills_from_agents(agents_dir)
-
-            # Save to project-level configuration.yaml
-            project_config_path = Path.cwd() / ".claude-mpm" / "configuration.yaml"
-            save_agent_skills_to_config(list(agent_skills), project_config_path)
-
-            # Phase 3: Resolve which skills to deploy (user_defined or agent_referenced)
-            skills_to_deploy, skill_source = get_skills_to_deploy(project_config_path)
-
-            # Phase 4: Apply profile filtering if active
-            if active_profile and profile_manager.active_profile:
-                # Filter skills based on profile
-                if skills_to_deploy:
-                    # Filter the resolved skill list
-                    original_count = len(skills_to_deploy)
-                    filtered_skills = [
-                        skill
-                        for skill in skills_to_deploy
-                        if profile_manager.is_skill_enabled(skill)
-                    ]
-                    filtered_count = original_count - len(filtered_skills)
-
-                    # SAFEGUARD: Warn if all skills were filtered out (misconfiguration)
-                    if not filtered_skills and original_count > 0:
-                        logger.warning(
-                            f"Profile '{active_profile}' filtered ALL {original_count} skills. "
-                            f"This may indicate a naming mismatch in the profile."
-                        )
-                    elif filtered_count > 0:
-                        logger.info(
-                            f"Profile '{active_profile}' filtered {filtered_count} skills "
-                            f"({len(filtered_skills)} remaining)"
-                        )
+        # CRITICAL: Always scan agents to populate agent_referenced, even when using cached skills.
+        # Without this, skill_filter=None causes ALL skills to deploy and NO cleanup to run.
+        agents_dir = Path.cwd() / ".claude" / "agents"
+
+        # Scan agents for skill requirements (ALWAYS run to ensure cleanup works)
+        agent_skills = get_required_skills_from_agents(agents_dir)
+        logger.info(
+            f"Agent scan found {len(agent_skills)} unique skills across deployed agents"
+        )
 
-                    skills_to_deploy = filtered_skills
-                    skill_source = f"{skill_source} + profile filtered"
-                else:
-                    # No explicit skill list - filter from all available
-                    all_skills = manager.get_all_skills()
-                    filtered_skills = [
-                        skill["name"]
-                        for skill in all_skills
-                        if profile_manager.is_skill_enabled(skill["name"])
-                    ]
-                    skills_to_deploy = filtered_skills
-                    skill_source = "profile filtered"
-                    logger.info(
-                        f"Profile '{active_profile}': "
-                        f"{len(filtered_skills)} skills enabled from {len(all_skills)} available"
-                    )
+        # Save to project-level configuration.yaml
+        project_config_path = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+        save_agent_skills_to_config(list(agent_skills), project_config_path)
+        logger.debug(
+            f"Saved {len(agent_skills)} agent-referenced skills to {project_config_path}"
+        )
 
-            # Get all skills to determine counts
-            all_skills = manager.get_all_skills()
-            total_skill_count = len(all_skills)
+        # Phase 3: Resolve which skills to deploy (user_defined or agent_referenced)
+        skills_to_deploy, skill_source = get_skills_to_deploy(project_config_path)
 
-            # Determine skill count based on resolution
-            skill_count = (
-                len(skills_to_deploy) if skills_to_deploy else total_skill_count
+        # CRITICAL DEBUG: Log deployment resolution to diagnose cleanup issues
+        if skills_to_deploy:
+            logger.info(
+                f"Resolved {len(skills_to_deploy)} skills from {skill_source} (cleanup will run)"
+            )
+        else:
+            logger.warning(
+                f"No skills resolved from {skill_source} - will deploy ALL skills WITHOUT cleanup! "
+                f"This may indicate agent_referenced is empty in configuration.yaml."
             )
 
-            if skill_count > 0:
-                # Deploy skills with resolved filter
-                # Deploy to BOTH project directory (for local dev) AND global directory (for Claude Code)
+        # Phase 4: Apply profile filtering if active
+        if active_profile and profile_manager.active_profile:
+            # Filter skills based on profile
+            if skills_to_deploy:
+                # Filter the resolved skill list
+                original_count = len(skills_to_deploy)
+                filtered_skills = [
+                    skill
+                    for skill in skills_to_deploy
+                    if profile_manager.is_skill_enabled(skill)
+                ]
+                filtered_count = original_count - len(filtered_skills)
+
+                # SAFEGUARD: Warn if all skills were filtered out (misconfiguration)
+                if not filtered_skills and original_count > 0:
+                    logger.warning(
+                        f"Profile '{active_profile}' filtered ALL {original_count} skills. "
+                        f"This may indicate a naming mismatch in the profile."
+                    )
+                elif filtered_count > 0:
+                    logger.info(
+                        f"Profile '{active_profile}' filtered {filtered_count} skills "
+                        f"({len(filtered_skills)} remaining)"
+                    )
 
-                # 1. Deploy to project-local directory
-                deployment_result = manager.deploy_skills(
-                    target_dir=Path.cwd() / ".claude" / "skills",
-                    force=False,
-                    skill_filter=set(skills_to_deploy) if skills_to_deploy else None,
+                skills_to_deploy = filtered_skills
+                skill_source = f"{skill_source} + profile filtered"
+            else:
+                # No explicit skill list - filter from all available
+                all_skills = manager.get_all_skills()
+                filtered_skills = [
+                    skill["name"]
+                    for skill in all_skills
+                    if profile_manager.is_skill_enabled(skill["name"])
+                ]
+                skills_to_deploy = filtered_skills
+                skill_source = "profile filtered"
+                logger.info(
+                    f"Profile '{active_profile}': "
+                    f"{len(filtered_skills)} skills enabled from {len(all_skills)} available"
                 )
 
-                # 2. Deploy to global directory (this is where Claude Code reads from)
-                # Also cleans up orphaned skills via _cleanup_unfiltered_skills()
-                manager.deploy_skills(
-                    target_dir=Path.home() / ".claude" / "skills",
-                    force=False,
-                    skill_filter=set(skills_to_deploy) if skills_to_deploy else None,
-                )
+        # Get all skills to determine counts
+        all_skills = manager.get_all_skills()
+        total_skill_count = len(all_skills)
 
-                # Get actual counts from deployment result (use project-local for display)
-                deployed = deployment_result.get("deployed_count", 0)
-                skipped = deployment_result.get("skipped_count", 0)
-                filtered = deployment_result.get("filtered_count", 0)
-                total_available = deployed + skipped
+        # Determine skill count based on resolution
+        skill_count = (
+            len(skills_to_deploy) if skills_to_deploy else total_skill_count
+        )
 
-                # Only show progress bar if there are skills to deploy
-                if total_available > 0:
-                    deploy_progress = ProgressBar(
-                        total=total_available,
-                        prefix="Deploying skill directories",
-                        show_percentage=True,
-                        show_counter=True,
-                    )
-                    # Update progress bar to completion
-                    deploy_progress.update(total_available)
-                else:
-                    # No skills to deploy - create dummy progress for message only
-                    deploy_progress = ProgressBar(
-                        total=1,
-                        prefix="Deploying skill directories",
-                        show_percentage=False,
-                        show_counter=False,
-                    )
-                    deploy_progress.update(1)
+        if skill_count > 0:
+            # Deploy skills with resolved filter
+            # Deploy ONLY to project directory (not user-level)
+            # DESIGN DECISION: Project-level deployment keeps skills isolated per project,
+            # avoiding pollution of user's global ~/.claude/skills/ directory.
+
+            # Deploy to project-local directory with cleanup
+            deployment_result = manager.deploy_skills(
+                target_dir=Path.cwd() / ".claude" / "skills",
+                force=False,
+                skill_filter=set(skills_to_deploy) if skills_to_deploy else None,
+            )
 
-                # Show total available skills (deployed + already existing)
-                # Include source indication (user_defined vs agent_referenced)
-                # Note: total_skill_count is from cache, total_available is what's deployed/needed
-                source_label = (
-                    "user override" if skill_source == "user_defined" else "from agents"
+            # REMOVED: User-level deployment (lines 1068-1074)
+            # Reason: Skills should be project-specific, not user-global.
+            # Claude Code can read from project-level .claude/skills/ directory.
+
+            # Get actual counts from deployment result (use project-local for display)
+            deployed = deployment_result.get("deployed_count", 0)
+            skipped = deployment_result.get("skipped_count", 0)
+            filtered = deployment_result.get("filtered_count", 0)
+            removed = deployment_result.get("removed_count", 0)
+            total_available = deployed + skipped
+
+            # Only show progress bar if there are skills to deploy
+            if total_available > 0:
+                deploy_progress = ProgressBar(
+                    total=total_available,
+                    prefix="Deploying skill directories",
+                    show_percentage=True,
+                    show_counter=True,
                 )
+                # Update progress bar to completion
+                deploy_progress.update(total_available)
+            else:
+                # No skills to deploy - create dummy progress for message only
+                deploy_progress = ProgressBar(
+                    total=1,
+                    prefix="Deploying skill directories",
+                    show_percentage=False,
+                    show_counter=False,
+                )
+                deploy_progress.update(1)
+
+            # Show total available skills (deployed + already existing)
+            # Include source indication (user_defined vs agent_referenced)
+            # Note: total_skill_count is from cache, total_available is what's deployed/needed
+            source_label = (
+                "user override" if skill_source == "user_defined" else "from agents"
+            )
 
+            # Build finish message with cleanup info
+            if deployed > 0 or removed > 0:
+                parts = []
                 if deployed > 0:
-                    if filtered > 0:
-                        deploy_progress.finish(
-                            f"Complete: {deployed} new, {skipped} unchanged "
-                            f"({total_available} {source_label}, {filtered} files in cache)"
-                        )
-                    else:
-                        deploy_progress.finish(
-                            f"Complete: {deployed} new, {skipped} unchanged "
-                            f"({total_available} skills {source_label} from {total_skill_count} files in cache)"
-                        )
-                elif filtered > 0:
-                    # Skills filtered means agents require fewer skills than available
+                    parts.append(f"{deployed} new")
+                if skipped > 0:
+                    parts.append(f"{skipped} unchanged")
+                if removed > 0:
+                    parts.append(f"{removed} removed")
+
+                status = ", ".join(parts)
+
+                if filtered > 0:
                     deploy_progress.finish(
-                        f"No skills needed ({source_label}, {total_skill_count} files in cache)"
+                        f"Complete: {status} ({total_available} {source_label}, {filtered} files in cache)"
                     )
                 else:
                     deploy_progress.finish(
-                        f"Complete: {total_available} skills {source_label} "
-                        f"({total_skill_count} files in cache)"
+                        f"Complete: {status} ({total_available} skills {source_label} from {total_skill_count} files in cache)"
                     )
+            elif filtered > 0:
+                # Skills filtered means agents require fewer skills than available
+                deploy_progress.finish(
+                    f"No skills needed ({source_label}, {total_skill_count} files in cache)"
+                )
+            else:
+                # No changes - all skills already deployed
+                msg = f"Complete: {total_available} skills {source_label}"
+                if removed > 0:
+                    msg += f", {removed} removed"
+                msg += f" ({total_skill_count} files in cache)"
+                deploy_progress.finish(msg)
+
+            # Log deployment errors if any
+            from ..core.logger import get_logger
 
-                # Log deployment errors if any
-                from ..core.logger import get_logger
-
-                logger = get_logger("cli")
+            logger = get_logger("cli")
 
-                errors = deployment_result.get("errors", [])
-                if errors:
-                    logger.warning(
-                        f"Skill deployment completed with {len(errors)} errors: {errors}"
-                    )
+            errors = deployment_result.get("errors", [])
+            if errors:
+                logger.warning(
+                    f"Skill deployment completed with {len(errors)} errors: {errors}"
+                )
 
-                # Log sync errors if any
-                if results["failed_count"] > 0:
-                    logger.warning(
-                        f"Skill sync completed with {results['failed_count']} failures"
-                    )
+            # Log sync errors if any
+            if results["failed_count"] > 0:
+                logger.warning(
+                    f"Skill sync completed with {results['failed_count']} failures"
+                )
 
     except Exception as e:
         # Non-critical - log but don't fail startup
@@ -1243,61 +1271,64 @@ def show_skill_summary():
     Display skill availability summary on startup.
 
     WHY: Users should see at a glance how many skills are deployed and available
-    from collections, similar to the agent summary.
+    from cache, similar to the agent summary showing "X deployed / Y cached".
+
+    DESIGN DECISION: Fast, non-blocking check that counts skills from:
+    - Deployed skills: PROJECT-level .claude/skills/ directory
+    - Cached skills: ~/.claude-mpm/cache/skills/ directory (from remote sources)
 
-    DESIGN DECISION: Fast, non-blocking check that counts skills from deployment
-    directory and collection repos. Shows "X installed (Y available)" format.
+    Shows format: "✓ Skills: X deployed / Y cached"
     Failures are silent to avoid blocking startup.
     """
     try:
         from pathlib import Path
 
-        # Count deployed skills (installed)
-        skills_dir = Path.home() / ".claude" / "skills"
-        installed_count = 0
-        if skills_dir.exists():
+        # Count deployed skills (PROJECT-level, not user-level)
+        project_skills_dir = Path.cwd() / ".claude" / "skills"
+        deployed_count = 0
+        if project_skills_dir.exists():
             # Count directories with SKILL.md (excludes collection repos)
             # Exclude collection directories (obra-superpowers, etc.)
             skill_dirs = [
                 d
-                for d in skills_dir.iterdir()
+                for d in project_skills_dir.iterdir()
                 if d.is_dir()
                 and (d / "SKILL.md").exists()
                 and not (d / ".git").exists()  # Exclude collection repos
             ]
-            installed_count = len(skill_dirs)
+            deployed_count = len(skill_dirs)
 
-        # Count available skills in collections
-        available_count = 0
-        if skills_dir.exists():
-            # Scan all collection directories (those with .git)
-            for collection_dir in skills_dir.iterdir():
-                if (
-                    not collection_dir.is_dir()
-                    or not (collection_dir / ".git").exists()
-                ):
+        # Count cached skills (from remote sources, not deployed yet)
+        # This matches the agent summary pattern: deployed vs cached
+        cache_dir = Path.home() / ".claude-mpm" / "cache" / "skills"
+        cached_count = 0
+        if cache_dir.exists():
+            # Scan all repository directories in cache
+            # Cache structure: ~/.claude-mpm/cache/skills/{owner}/{repo}/...
+            for repo_dir in cache_dir.rglob("*"):
+                if not repo_dir.is_dir():
                     continue
 
-                # Count skill directories in this collection
+                # Count skill directories (those with SKILL.md)
                 # Skills can be nested in: skills/category/skill-name/SKILL.md
                 # or in flat structure: skill-name/SKILL.md
-                for root, dirs, files in os.walk(collection_dir):
+                for root, dirs, files in os.walk(repo_dir):
                     if "SKILL.md" in files:
-                        # Exclude build artifacts and hidden directories (within the collection)
-                        # Get relative path from collection_dir to avoid excluding based on .claude parent
+                        # Exclude build artifacts and hidden directories
                         root_path = Path(root)
-                        relative_parts = root_path.relative_to(collection_dir).parts
                         if not any(
                             part.startswith(".")
                             or part in ["dist", "build", "__pycache__"]
-                            for part in relative_parts
+                            for part in root_path.parts
                         ):
-                            available_count += 1
+                            cached_count += 1
 
-        # Display summary if we have skills
-        if installed_count > 0 or available_count > 0:
+        # Display summary using agent summary format: "X deployed / Y cached"
+        # Only show non-deployed cached skills (subtract deployed from cached)
+        non_deployed_cached = max(0, cached_count - deployed_count)
+        if deployed_count > 0 or non_deployed_cached > 0:
             print(
-                f"✓ Skills: {installed_count} installed ({available_count} available)",
+                f"✓ Skills: {deployed_count} deployed / {non_deployed_cached} cached",
                 flush=True,
             )
 

{claude_mpm-5.4.54 → claude_mpm-5.4.56}/src/claude_mpm/services/skills/git_skill_source_manager.py

@@ -991,12 +991,17 @@ class GitSkillSourceManager:
         progress_callback=None,
         skill_filter: Optional[Set[str]] = None,
     ) -> Dict[str, Any]:
-        """Deploy skills from cache to target directory with flat structure.
+        """Deploy skills from cache to target directory with flat structure and automatic cleanup.
 
         Flattens nested Git repository structure into Claude Code compatible
         flat directory structure. Each skill directory is copied with a
         hyphen-separated name derived from its path.
 
+        CRITICAL: When skill_filter is provided (agent-referenced skills), this function:
+        1. Deploys ONLY the filtered skills
+        2. REMOVES orphaned skills (deployed but not in filter)
+        3. Returns removed_count and removed_skills in result
+
         Transformation Example:
             Cache: collaboration/dispatching-parallel-agents/SKILL.md
             Deploy: collaboration-dispatching-parallel-agents/SKILL.md
@@ -1006,8 +1011,8 @@ class GitSkillSourceManager:
             force: Overwrite existing skills
             progress_callback: Optional callback(increment: int) called for each skill deployed
             skill_filter: Optional set of skill names to deploy (selective deployment).
-                         If None, deploys all skills. If provided, only deploys skills
-                         whose name matches an entry in the filter set.
+                         If None, deploys ALL skills WITHOUT cleanup.
+                         If provided, deploys ONLY filtered skills AND removes orphans.
 
         Returns:
             Dict with deployment results:
@@ -1018,7 +1023,9 @@ class GitSkillSourceManager:
                 "deployed_skills": List[str],
                 "skipped_skills": List[str],
                 "errors": List[str],
-                "filtered_count": int  # Number of skills filtered out
+                "filtered_count": int,  # Number of skills filtered out
+                "removed_count": int,   # Number of orphaned skills removed
+                "removed_skills": List[str]  # Names of removed orphaned skills
             }
 
         Example:
@@ -1026,10 +1033,10 @@ class GitSkillSourceManager:
             >>> result = manager.deploy_skills()
             >>> print(f"Deployed {result['deployed_count']} skills")
 
-            # Selective deployment based on agent requirements:
+            # Selective deployment based on agent requirements (with cleanup):
             >>> required = {"typescript-core", "react-patterns"}
             >>> result = manager.deploy_skills(skill_filter=required)
-            >>> print(f"Deployed {result['deployed_count']} of {len(required)} required skills")
+            >>> print(f"Deployed {result['deployed_count']}, removed {result['removed_count']} orphans")
         """
         if target_dir is None:
             target_dir = Path.home() / ".claude" / "skills"
@@ -1040,6 +1047,7 @@ class GitSkillSourceManager:
         skipped = []
         errors = []
         filtered_count = 0
+        removed_skills = []  # Track removed orphaned skills
 
         # Get all skills from all sources
         all_skills = self.get_all_skills()
@@ -1082,11 +1090,12 @@ class GitSkillSourceManager:
             )
 
             # Cleanup: Remove skills from target directory that aren't in the filtered set
-            # This ensures only the skills in the profile are deployed
+            # This ensures only agent-referenced skills remain deployed
             removed_skills = self._cleanup_unfiltered_skills(target_dir, all_skills)
             if removed_skills:
                 self.logger.info(
-                    f"Removed {len(removed_skills)} skills not in profile filter: {removed_skills}"
+                    f"Removed {len(removed_skills)} orphaned skills not referenced by agents: {removed_skills[:10]}"
+                    + (f" (and {len(removed_skills) - 10} more)" if len(removed_skills) > 10 else "")
                 )
 
         self.logger.info(
@@ -1130,6 +1139,7 @@ class GitSkillSourceManager:
         self.logger.info(
             f"Deployment complete: {len(deployed)} deployed, "
             f"{len(skipped)} skipped, {len(errors)} errors"
+            + (f", {len(removed_skills)} removed" if removed_skills else "")
         )
 
         return {
@@ -1140,6 +1150,8 @@ class GitSkillSourceManager:
             "skipped_skills": skipped,
             "errors": errors,
             "filtered_count": filtered_count,
+            "removed_count": len(removed_skills),
+            "removed_skills": removed_skills,
         }
 
     def _cleanup_unfiltered_skills(

{claude_mpm-5.4.54 → claude_mpm-5.4.56/src/claude_mpm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 5.4.54
+Version: 5.4.56
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-5.4.54 → claude_mpm-5.4.56}/src/claude_mpm.egg-info/SOURCES.txt

@@ -349,6 +349,7 @@ src/claude_mpm/hooks/claude_hooks/__pycache__/__init__.cpython-311.pyc
 src/claude_mpm/hooks/claude_hooks/__pycache__/correlation_manager.cpython-311.pyc
 src/claude_mpm/hooks/claude_hooks/__pycache__/event_handlers.cpython-311.pyc
 src/claude_mpm/hooks/claude_hooks/__pycache__/hook_handler.cpython-311.pyc
+src/claude_mpm/hooks/claude_hooks/__pycache__/installer.cpython-311.pyc
 src/claude_mpm/hooks/claude_hooks/__pycache__/memory_integration.cpython-311.pyc
 src/claude_mpm/hooks/claude_hooks/__pycache__/response_tracking.cpython-311.pyc
 src/claude_mpm/hooks/claude_hooks/__pycache__/tool_analysis.cpython-311.pyc

claude_mpm-5.4.54/src/claude_mpm/VERSION

@@ -1 +0,0 @@
-5.4.54