claude-mpm 5.6.3__py3-none-any.whl → 5.6.16__py3-none-any.whl

claude_mpm/services/skills/selective_skill_deployer.py

@@ -50,6 +50,22 @@ logger = get_logger(__name__)
 # Deployment tracking index file
 DEPLOYED_INDEX_FILE = ".mpm-deployed-skills.json"
 
+# Core PM skills that should always be deployed
+# These are referenced in PM_INSTRUCTIONS.md with [SKILL: name] markers
+# Without these skills, PM only sees placeholders, not actual content
+PM_CORE_SKILLS = {
+    "mpm-delegation-patterns",
+    "mpm-verification-protocols",
+    "mpm-tool-usage-guide",
+    "mpm-git-file-tracking",
+    "mpm-pr-workflow",
+    "mpm-ticketing-integration",
+    "mpm-teaching-mode",
+    "mpm-bug-reporting",
+    "mpm-circuit-breaker-enforcement",
+    "mpm-session-management",
+}
+
 # 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
@@ -376,6 +392,18 @@ def get_required_skills_from_agents(agents_dir: Path) -> Set[str]:
             "(converted slashes to dashes)"
         )
 
+    # Always include PM core skills to ensure PM_INSTRUCTIONS.md markers are resolved
+    # These skills are referenced in PM_INSTRUCTIONS.md and must be deployed
+    # for PM to see actual content instead of [SKILL: name] placeholders
+    before_pm_skills = len(normalized_skills)
+    normalized_skills = normalized_skills | PM_CORE_SKILLS
+    pm_skills_added = len(normalized_skills) - before_pm_skills
+
+    if pm_skills_added > 0:
+        logger.info(
+            f"Added {pm_skills_added} PM core skills to ensure PM_INSTRUCTIONS.md markers resolve"
+        )
+
     return normalized_skills
 
 

claude_mpm/services/skills/skill_discovery_service.py

@@ -188,6 +188,15 @@ class SkillDiscoveryService:
             f"and {len(legacy_md_files)} legacy .md files in {self.skills_dir}"
         )
 
+        # Log first few file paths for debugging
+        if all_skill_files:
+            sample_files = [
+                str(f.relative_to(self.skills_dir)) for f in all_skill_files[:5]
+            ]
+            self.logger.debug(f"Sample skill files: {sample_files}")
+        else:
+            self.logger.debug(f"No SKILL.md or .md files found in {self.skills_dir}")
+
         # Track deployment names to detect collisions
         deployment_names = {}
 
@@ -226,7 +235,14 @@ class SkillDiscoveryService:
             except Exception as e:
                 self.logger.warning(f"Failed to parse skill {skill_file}: {e}")
 
-        self.logger.info(f"Discovered {len(skills)} skills from {self.skills_dir.name}")
+        # Summary logging
+        parsed_count = len(skills)
+        failed_count = len(all_skill_files) - parsed_count
+        self.logger.info(
+            f"Discovered {parsed_count} skills from {self.skills_dir.name} "
+            f"({len(all_skill_files)} files found, {failed_count} failed to parse)"
+        )
+
         return skills
 
     def _parse_skill_file(self, skill_file: Path) -> Optional[Dict[str, Any]]:

claude_mpm/services/skills_deployer.py

@@ -28,7 +28,7 @@ References:
 import json
 import platform
 import shutil
-import subprocess
+import subprocess  # nosec B404 - subprocess needed for safe git operations
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -653,7 +653,7 @@ class SkillsDeployerService(LoggerMixin):
                     f"Updating existing collection '{collection_name}' at {target_dir}"
                 )
                 try:
-                    result = subprocess.run(
+                    result = subprocess.run(  # nosec B603 B607 - Safe: hardcoded git command
                         ["git", "pull"],
                         cwd=target_dir,
                         capture_output=True,
@@ -684,7 +684,7 @@ class SkillsDeployerService(LoggerMixin):
                 f"Installing new collection '{collection_name}' to {target_dir}"
             )
             try:
-                result = subprocess.run(
+                result = subprocess.run(  # nosec B603 B607 - Safe: hardcoded git command
                     ["git", "clone", repo_url, str(target_dir)],
                     capture_output=True,
                     text=True,
@@ -773,6 +773,32 @@ class SkillsDeployerService(LoggerMixin):
         if isinstance(skills_data, dict):
             flat_skills = []
 
+            # Define valid top-level categories
+            VALID_CATEGORIES = {"universal", "toolchains"}
+
+            # Check for unknown categories and warn user
+            unknown_categories = set(skills_data.keys()) - VALID_CATEGORIES
+            if unknown_categories:
+                # Count skills in unknown categories
+                skipped_count = 0
+                for cat in unknown_categories:
+                    cat_data = skills_data.get(cat, [])
+                    if isinstance(cat_data, list):
+                        skipped_count += len(cat_data)
+                    elif isinstance(cat_data, dict):
+                        # If it's a dict like toolchains, count nested skills
+                        for skills_list in cat_data.values():
+                            if isinstance(skills_list, list):
+                                skipped_count += len(skills_list)
+
+                self.logger.warning(
+                    f"Unknown categories in manifest will be skipped: "
+                    f"{', '.join(sorted(unknown_categories))} ({skipped_count} skills)"
+                )
+                self.logger.info(
+                    f"Valid top-level categories: {', '.join(sorted(VALID_CATEGORIES))}"
+                )
+
             # Add universal skills
             universal_skills = skills_data.get("universal", [])
             if isinstance(universal_skills, list):
@@ -1022,12 +1048,12 @@ class SkillsDeployerService(LoggerMixin):
         """
         try:
             if platform.system() == "Windows":
-                result = subprocess.run(
+                result = subprocess.run(  # nosec B603 B607 - Safe: hardcoded tasklist command
                     ["tasklist"], check=False, capture_output=True, text=True, timeout=5
                 )
                 return "claude" in result.stdout.lower()
             # macOS and Linux
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607 - Safe: hardcoded ps command
                 ["ps", "aux"], check=False, capture_output=True, text=True, timeout=5
             )
             # Look for "Claude Code" or "claude-code" process

claude_mpm/skills/__init__.py

@@ -24,7 +24,7 @@ Legacy System (maintained for compatibility):
 from .agent_skills_injector import AgentSkillsInjector
 
 # Legacy System (maintained for compatibility)
-from .registry import Skill, SkillsRegistry, get_registry
+from .registry import Skill, SkillsRegistry, get_registry, validate_agentskills_spec
 from .skill_manager import SkillManager
 from .skills_registry import SkillsRegistry as SkillsRegistryHelper
 from .skills_service import SkillsService
@@ -39,4 +39,5 @@ __all__ = [
     # New Skills Integration System
     "SkillsService",
     "get_registry",
+    "validate_agentskills_spec",
 ]

claude_mpm/skills/bundled/pm/mpm-session-pause/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: mpm-session-pause
+description: Pause session and save current work state for later resume
+user-invocable: true
+version: "1.0.0"
+category: mpm-command
+tags: [mpm-command, session, pm-recommended]
+---
+
+# /mpm-pause
+
+Pause the current session and save all work state for later resume.
+
+## What This Does
+
+When invoked, this skill:
+1. Captures current work state (todos, git status, context summary)
+2. Creates session file at `.claude-mpm/sessions/session-{timestamp}.md`
+3. Updates `.claude-mpm/sessions/LATEST-SESSION.txt` pointer
+4. Optionally commits session state to git
+5. Shows user the session file path for later resume
+
+## Usage
+
+```
+/mpm-pause [optional message describing current work]
+```
+
+**Examples:**
+```
+/mpm-pause
+/mpm-pause Working on authentication refactor, about to test login flow
+/mpm-pause Need to context switch to urgent bug fix
+```
+
+## Implementation
+
+**Execute the following Python code to pause the session:**
+
+```python
+from pathlib import Path
+from claude_mpm.services.cli.session_pause_manager import SessionPauseManager
+
+# Optional: Get message from user's command
+# If user provided message after /mpm-pause, extract it
+# Otherwise, message = None
+
+# Create session pause manager
+manager = SessionPauseManager(project_path=Path.cwd())
+
+# Create pause session
+session_id = manager.create_pause_session(
+    message=message,  # Optional context message
+    skip_commit=False,  # Will commit to git if in a repo
+    export_path=None,  # No additional export needed
+)
+
+# Report success to user
+print(f"✅ Session paused successfully!")
+print(f"")
+print(f"Session ID: {session_id}")
+print(f"Session files:")
+print(f"  - .claude-mpm/sessions/{session_id}.md (human-readable)")
+print(f"  - .claude-mpm/sessions/{session_id}.json (machine-readable)")
+print(f"  - .claude-mpm/sessions/{session_id}.yaml (config format)")
+print(f"")
+print(f"Quick resume:")
+print(f"  /mpm-resume")
+print(f"")
+print(f"View session context:")
+print(f"  cat .claude-mpm/sessions/LATEST-SESSION.txt")
+print(f"  cat .claude-mpm/sessions/{session_id}.md")
+```
+
+## What Gets Saved
+
+**Session State:**
+- Session ID and timestamp
+- Current working directory
+- Git branch, recent commits, and file status
+- Primary task and current phase
+- Context message (if provided)
+
+**Resume Instructions:**
+- Quick-start commands
+- Validation commands
+- Files to review
+
+**File Formats:**
+- `.md` - Human-readable markdown (for reading)
+- `.json` - Machine-readable (for tooling)
+- `.yaml` - Human-readable config (for editing)
+
+## Session File Location
+
+All session files are stored in:
+```
+.claude-mpm/sessions/
+├── LATEST-SESSION.txt          # Pointer to most recent session
+├── session-YYYYMMDD-HHMMSS.md
+├── session-YYYYMMDD-HHMMSS.json
+└── session-YYYYMMDD-HHMMSS.yaml
+```
+
+## Token Budget
+
+**Token usage:** ~5-10k tokens to execute (2-5% of context budget)
+
+**Benefit:** Saves all remaining context for future resume, allowing you to:
+- Context switch to urgent tasks
+- Take a break and resume later
+- Archive current work state before major changes
+
+## Resume Later
+
+To resume this session:
+```
+/mpm-resume
+```
+
+Or manually:
+```bash
+cat .claude-mpm/sessions/LATEST-SESSION.txt
+cat .claude-mpm/sessions/session-YYYYMMDD-HHMMSS.md
+```
+
+## Git Integration
+
+If in a git repository, the session will be automatically committed with message:
+```
+session: pause at YYYY-MM-DD HH:MM:SS
+
+Session ID: session-YYYYMMDD-HHMMSS
+Context: [your optional message]
+```
+
+## Use Cases
+
+**Context switching:**
+```
+/mpm-pause Switching to urgent production bug
+```
+
+**End of work session:**
+```
+/mpm-pause Completed API refactor, ready for testing tomorrow
+```
+
+**Before major changes:**
+```
+/mpm-pause Saving state before attempting risky refactor
+```
+
+**When approaching context limit:**
+```
+/mpm-pause Hit 150k tokens, starting fresh session
+```
+
+## Related Commands
+
+- `/mpm-resume` - Resume from most recent paused session
+- `/mpm-init resume` - Alternative resume command
+- See `docs/features/session-auto-resume.md` for auto-pause behavior
+
+## Notes
+
+- Session files are project-local (not synced across machines)
+- Git commit is optional (automatically skipped if not a repo)
+- LATEST-SESSION.txt always points to most recent session
+- Session format compatible with auto-pause feature (70% context trigger)