claude-mpm 5.4.55__tar.gz → 5.4.60__tar.gz

{claude_mpm-5.4.55/src/claude_mpm.egg-info → claude_mpm-5.4.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 5.4.55
+Version: 5.4.60
 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.55 → claude_mpm-5.4.60}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "5.4.55"
+version = "5.4.60"
 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.55"
+version = "5.4.60"
 version_files = [ "VERSION", "src/claude_mpm/VERSION", "package.json:version",]
 tag_format = "v$version"
 update_changelog_on_bump = true

claude_mpm-5.4.60/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+5.4.60

{claude_mpm-5.4.55 → claude_mpm-5.4.60}/src/claude_mpm/cli/startup.py

@@ -990,22 +990,37 @@ def sync_remote_skills_on_startup():
 
         # Phase 2: Scan agents and save to configuration.yaml
         # This step populates configuration.yaml with agent-referenced skills
-        # BUGFIX: Removed `if results["synced_count"] > 0` condition to ensure
-        # agent_referenced is always populated, even when using cached skills.
-        # Previous behavior: If skills were cached, agent scan was skipped,
-        # leaving agent_referenced: [] empty, which prevented cleanup.
+        # 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, not just on sync)
+        # 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"
+        )
 
         # 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}"
+        )
 
         # Phase 3: Resolve which skills to deploy (user_defined or agent_referenced)
         skills_to_deploy, skill_source = get_skills_to_deploy(project_config_path)
 
+        # 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."
+            )
+
         # Phase 4: Apply profile filtering if active
         if active_profile and profile_manager.active_profile:
             # Filter skills based on profile
@@ -1067,7 +1082,10 @@ def sync_remote_skills_on_startup():
             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,
+                # CRITICAL FIX: Empty list should mean "deploy no skills", not "deploy all"
+                # When skills_to_deploy is [], we want skill_filter=set() NOT skill_filter=None
+                # None means "no filtering" (deploy all), empty set means "filter to nothing"
+                skill_filter=set(skills_to_deploy) if skills_to_deploy is not None else None,
             )
 
             # REMOVED: User-level deployment (lines 1068-1074)
@@ -1078,6 +1096,7 @@ def sync_remote_skills_on_startup():
             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
@@ -1107,16 +1126,25 @@ def sync_remote_skills_on_startup():
                 "user override" if skill_source == "user_defined" else "from agents"
             )
 
-            if deployed > 0:
+            # Build finish message with cleanup info
+            if deployed > 0 or removed > 0:
+                parts = []
+                if deployed > 0:
+                    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"Complete: {deployed} new, {skipped} unchanged "
-                        f"({total_available} {source_label}, {filtered} files in cache)"
+                        f"Complete: {status} ({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)"
+                        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
@@ -1124,10 +1152,12 @@ def sync_remote_skills_on_startup():
                     f"No skills needed ({source_label}, {total_skill_count} files in cache)"
                 )
             else:
-                deploy_progress.finish(
-                    f"Complete: {total_available} skills {source_label} "
-                    f"({total_skill_count} files in cache)"
-                )
+                # 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
@@ -1244,61 +1274,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.55 → claude_mpm-5.4.60}/src/claude_mpm/services/agents/deployment/agent_template_builder.py

@@ -586,6 +586,14 @@ class AgentTemplateBuilder:
             tags_str = ",".join(metadata["tags"])
             frontmatter_lines.append(f"tags: {tags_str}")
 
+        # CRITICAL: Preserve skills field from template for selective skill deployment
+        # Skills are used by startup.py to determine which skills to deploy
+        skills = template_data.get("skills", [])
+        if skills and isinstance(skills, list):
+            frontmatter_lines.append("skills:")
+            for skill in skills:
+                frontmatter_lines.append(f"- {skill}")
+
         frontmatter_lines.extend(
             [
                 "---",

{claude_mpm-5.4.55 → claude_mpm-5.4.60}/src/claude_mpm/services/agents/sources/git_source_sync_service.py

@@ -1118,14 +1118,17 @@ class GitSourceSyncService:
                 deploy_filename = Path(agent_path).name
                 deploy_file = deployment_dir / deploy_filename
 
-                # Check if update needed (compare modification times)
+                # Check if update needed (compare content, not just mtime)
+                # DESIGN: Use content hash comparison for reliable change detection
+                # Mtime comparison can fail when cache downloads have older timestamps
                 should_deploy = force
                 was_existing = deploy_file.exists()
 
                 if not force and was_existing:
-                    cache_mtime = cache_file.stat().st_mtime
-                    deploy_mtime = deploy_file.stat().st_mtime
-                    should_deploy = cache_mtime > deploy_mtime
+                    # Compare file contents using hash
+                    cache_content = cache_file.read_bytes()
+                    deploy_content = deploy_file.read_bytes()
+                    should_deploy = cache_content != deploy_content
 
                 if not should_deploy and was_existing:
                     results["skipped"].append(deploy_filename)

{claude_mpm-5.4.55 → claude_mpm-5.4.60}/src/claude_mpm/services/pm_skills_deployer.py

@@ -98,6 +98,7 @@ class VerificationResult:
         missing_skills: List of missing skill names
         outdated_skills: List of outdated skill names
         message: Summary message
+        skill_count: Total number of deployed skills
     """
 
     verified: bool
@@ -105,6 +106,7 @@ class VerificationResult:
     missing_skills: List[str]
     outdated_skills: List[str]
     message: str
+    skill_count: int = 0
 
 
 @dataclass
@@ -551,6 +553,7 @@ class PMSkillsDeployerService(LoggerMixin):
                 missing_skills=missing_skills,
                 outdated_skills=outdated_skills,
                 message="PM skills not deployed. Run 'claude-mpm init' to deploy.",
+                skill_count=0,
             )
 
         # Check each registered skill exists
@@ -610,6 +613,7 @@ class PMSkillsDeployerService(LoggerMixin):
             missing_skills=missing_skills,
             outdated_skills=outdated_skills,
             message=message,
+            skill_count=len(deployed_skills),
         )
 
     def get_deployed_skills(self, project_dir: Path) -> List[PMSkillInfo]:

{claude_mpm-5.4.55 → claude_mpm-5.4.60}/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.55 → claude_mpm-5.4.60}/src/claude_mpm/services/skills/selective_skill_deployer.py

@@ -51,6 +51,59 @@ logger = get_logger(__name__)
 # Deployment tracking index file
 DEPLOYED_INDEX_FILE = ".mpm-deployed-skills.json"
 
+# Core skills that are universally useful across all projects
+# These are deployed when skill mapping returns too many skills (>60)
+# Target: ~25-30 core skills for balanced functionality
+CORE_SKILLS = {
+    # Universal debugging and verification (4 skills)
+    "universal-debugging-systematic-debugging",
+    "universal-debugging-verification-before-completion",
+    "universal-verification-pre-merge",
+    "universal-verification-screenshot",
+
+    # Universal testing patterns (2 skills)
+    "universal-testing-test-driven-development",
+    "universal-testing-testing-anti-patterns",
+
+    # Universal architecture and design (1 skill)
+    "universal-architecture-software-patterns",
+
+    # Universal infrastructure (3 skills)
+    "universal-infrastructure-env-manager",
+    "universal-infrastructure-docker",
+    "universal-infrastructure-github-actions",
+
+    # Universal collaboration (1 skill)
+    "universal-collaboration-stacked-prs",
+
+    # Universal emergency/operations (1 skill)
+    "toolchains-universal-emergency-release",
+    "toolchains-universal-dependency-audit",
+
+    # Common language toolchains (6 skills)
+    "toolchains-typescript-core",
+    "toolchains-python-core",
+    "toolchains-javascript-tooling-biome",
+    "toolchains-python-tooling-mypy",
+    "toolchains-typescript-testing-vitest",
+    "toolchains-python-frameworks-flask",
+
+    # Common web frameworks (4 skills)
+    "toolchains-javascript-frameworks-nextjs",
+    "toolchains-nextjs-core",
+    "toolchains-typescript-frameworks-nodejs-backend",
+    "toolchains-javascript-frameworks-react-state-machine",
+
+    # Common testing tools (2 skills)
+    "toolchains-javascript-testing-playwright",
+    "toolchains-typescript-testing-jest",
+
+    # Common data/UI tools (3 skills)
+    "universal-data-xlsx",
+    "toolchains-ui-styling-tailwind",
+    "toolchains-ui-components-headlessui",
+}
+
 
 def parse_agent_frontmatter(agent_file: Path) -> Dict[str, Any]:
     """Parse YAML frontmatter from agent markdown file.
@@ -140,22 +193,14 @@ def get_skills_from_agent(frontmatter: Dict[str, Any]) -> Set[str]:
 def get_skills_from_mapping(agent_ids: List[str]) -> Set[str]:
     """Get skills for agents using SkillToAgentMapper inference.
 
-    Uses SkillToAgentMapper to find all skills associated with given agent IDs.
-    This provides pattern-based skill discovery beyond explicit frontmatter declarations.
-
-    CRITICAL DESIGN DECISION: This function ONLY returns skills for the DEPLOYED agents
-    provided in agent_ids. It does NOT return skills for all agents in the mapping
-    configuration (skill_to_agent_mapping.yaml lists 41 agents, but only 33 may be deployed).
+    DEPRECATED: This function is deprecated as of Phase 3 refactor.
+    Skills are now declared exclusively in agent frontmatter.
 
-    GENERIC AGENT HANDLING: The generic "engineer" agent is mapped to 100+ skills in the
-    configuration because it's designed as a fallback. To prevent over-deployment when
-    specialized agents exist, we skip "engineer" if specialized agents are present.
+    The static skill_to_agent_mapping.yaml is no longer used for skill deployment.
+    Each agent must declare its skills in frontmatter or it gets zero skills.
 
-    WHY THIS MATTERS:
-    - skill_to_agent_mapping.yaml lists ALL possible agents (41 total)
-    - User may only have 33 agents deployed in ~/.claude/agents/
-    - Without filtering, we'd deploy skills for all 41 agents (over-deployment)
-    - Solution: Only query skills for DEPLOYED agents (passed in agent_ids)
+    This function remains for backward compatibility but is NO LONGER CALLED
+    by get_required_skills_from_agents().
 
     Args:
         agent_ids: List of DEPLOYED agent identifiers (e.g., ["python-engineer", "typescript-engineer"])
@@ -163,67 +208,34 @@ def get_skills_from_mapping(agent_ids: List[str]) -> Set[str]:
 
     Returns:
         Set of unique skill names inferred from mapping configuration for DEPLOYED agents only
+        NOTE: This is now an empty set as the function is deprecated.
 
     Example:
-        >>> # DEPLOYED agents only (from ~/.claude/agents/)
+        >>> # DEPRECATED - use frontmatter instead
         >>> deployed_agent_ids = ["python-engineer", "typescript-engineer", "qa"]
-        >>> skills = get_skills_from_mapping(deployed_agent_ids)
-        >>> print(f"Found {len(skills)} skills for {len(deployed_agent_ids)} deployed agents")
+        >>> skills = get_skills_from_mapping(deployed_agent_ids)  # Returns empty set
     """
-    try:
-        mapper = SkillToAgentMapper()
-        all_skills = set()
-
-        # CRITICAL FIX: Skip generic "engineer" agent if specialized agents exist
-        # The "engineer" agent is mapped to ~107 skills (almost all skills) because
-        # it's a fallback agent. This causes over-deployment when you have specialized
-        # agents like "python-engineer", "typescript-engineer", etc.
-        #
-        # Solution: Filter out "engineer" from agent_ids if specialized agents exist
-        specialized_engineers = [
-            aid for aid in agent_ids if aid.endswith("-engineer") and aid != "engineer"
-        ]
-
-        # If specialized engineers exist, exclude generic "engineer" from skill mapping
-        # This prevents deploying 100+ skills when only a subset is needed
-        agents_to_query = agent_ids
-        if specialized_engineers and "engineer" in agent_ids:
-            agents_to_query = [aid for aid in agent_ids if aid != "engineer"]
-            logger.info(
-                f"Excluding generic 'engineer' agent from skill mapping "
-                f"(found {len(specialized_engineers)} specialized engineers: "
-                f"{', '.join(specialized_engineers[:5])}{'...' if len(specialized_engineers) > 5 else ''})"
-            )
-
-        # IMPORTANT: Only query skills for DEPLOYED agents (those in agent_ids)
-        # Do NOT query all agents from skill_to_agent_mapping.yaml (that's 41 agents)
-        for agent_id in agents_to_query:
-            agent_skills = mapper.get_skills_for_agent(agent_id)
-            if agent_skills:
-                all_skills.update(agent_skills)
-                logger.debug(f"Mapped {len(agent_skills)} skills to {agent_id}")
-
-        logger.info(
-            f"Mapped {len(all_skills)} unique skills for {len(agents_to_query)} deployed agents "
-            f"(out of {len(agent_ids)} total deployed, excluding generic 'engineer' if specialized exist)"
-        )
-        return all_skills
-
-    except Exception as e:
-        logger.warning(f"Failed to load SkillToAgentMapper: {e}")
-        logger.info("Falling back to frontmatter-only skill discovery")
-        return set()
+    # DEPRECATED: Return empty set
+    logger.warning(
+        "get_skills_from_mapping() is DEPRECATED and returns empty set. "
+        "Skills are now declared in agent frontmatter only. "
+        "Update your agents with 'skills:' field in frontmatter."
+    )
+    return set()
 
 
 def get_required_skills_from_agents(agents_dir: Path) -> Set[str]:
     """Extract all skills referenced by deployed agents.
 
-    Combines skills from two sources:
-    1. Explicit frontmatter declarations (skills: field in agent .md files)
-    2. SkillToAgentMapper inference (pattern-based skill discovery)
+    MAJOR CHANGE (Phase 3): Now ONLY uses frontmatter-declared skills.
+    The static skill_to_agent_mapping.yaml is DEPRECATED. Each agent must
+    declare its skills in frontmatter or it gets zero skills deployed.
 
-    This dual-source approach ensures agents get both explicitly declared skills
-    and skills inferred from their domain/toolchain patterns.
+    This change:
+    - Eliminates dual-source complexity (frontmatter + mapping)
+    - Makes skill requirements explicit per agent
+    - Enables per-agent customization via frontmatter
+    - Removes dependency on static YAML mapping
 
     Args:
         agents_dir: Path to deployed agents directory (e.g., .claude/agents/)
@@ -244,13 +256,11 @@ def get_required_skills_from_agents(agents_dir: Path) -> Set[str]:
     agent_files = list(agents_dir.glob("*.md"))
     logger.debug(f"Scanning {len(agent_files)} agent files in {agents_dir}")
 
-    # Source 1: Extract skills from frontmatter
+    # ONLY use frontmatter skills - no more mapping inference
     frontmatter_skills = set()
-    agent_ids = []
 
     for agent_file in agent_files:
         agent_id = agent_file.stem
-        agent_ids.append(agent_id)
 
         frontmatter = parse_agent_frontmatter(agent_file)
         agent_skills = get_skills_from_agent(frontmatter)
@@ -260,24 +270,23 @@ def get_required_skills_from_agents(agents_dir: Path) -> Set[str]:
             logger.debug(
                 f"Agent {agent_id}: {len(agent_skills)} skills from frontmatter"
             )
+        else:
+            logger.debug(f"Agent {agent_id}: No skills declared in frontmatter")
 
-    logger.info(f"Found {len(frontmatter_skills)} unique skills from frontmatter")
-
-    # Source 2: Get skills from SkillToAgentMapper
-    mapped_skills = get_skills_from_mapping(agent_ids)
-
-    # Combine both sources
-    required_skills = frontmatter_skills | mapped_skills
+    logger.info(
+        f"Found {len(frontmatter_skills)} unique skills from agent frontmatter "
+        f"(static mapping no longer used)"
+    )
 
     # Normalize skill paths: convert slashes to dashes for compatibility with deployment
-    # SkillToAgentMapper returns paths like "toolchains/python/frameworks/django"
-    # but deployment expects "toolchains-python-frameworks-django"
-    normalized_skills = {skill.replace("/", "-") for skill in required_skills}
+    # Some skills may use slash format, normalize to dashes
+    normalized_skills = {skill.replace("/", "-") for skill in frontmatter_skills}
 
-    logger.info(
-        f"Combined {len(frontmatter_skills)} frontmatter + {len(mapped_skills)} mapped "
-        f"= {len(required_skills)} total unique skills (normalized to {len(normalized_skills)})"
-    )
+    if normalized_skills != frontmatter_skills:
+        logger.debug(
+            f"Normalized {len(frontmatter_skills)} skills to {len(normalized_skills)} "
+            "(converted slashes to dashes)"
+        )
 
     return normalized_skills
 

{claude_mpm-5.4.55 → claude_mpm-5.4.60/src/claude_mpm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 5.4.55
+Version: 5.4.60
 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.55/src/claude_mpm/VERSION

@@ -1 +0,0 @@
-5.4.55