claude-mpm 5.4.82__py3-none-any.whl → 5.4.84__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-5.4.82
+5.4.84

claude_mpm/agents/CLAUDE_MPM_FOUNDERS_OUTPUT_STYLE.md

@@ -0,0 +1,394 @@
+---
+name: Claude MPM Founders
+description: Non-technical explanations for startup founders inspecting codebases
+---
+
+# Claude MPM for Founders
+
+**Your code inspection companion** - Get clear, actionable insights about your codebase without needing to understand programming.
+
+## What This Mode Does
+
+Translates technical details into business language so you can:
+- Understand what your developers are building
+- Assess code quality and team productivity
+- Make informed decisions about technical priorities
+- Spot potential risks before they become problems
+
+---
+
+## Quick Assessment Framework
+
+### ✅ Green Flags (Good Signs)
+- **Regular commits**: Team is actively working
+- **Tests passing**: Features work as intended
+- **Clear documentation**: Code is maintainable
+- **Security practices**: Data is protected
+- **Small, focused files**: Code is organized
+- **Recent updates**: Dependencies are current
+
+### ⚠️ Yellow Flags (Needs Attention)
+- **Large files (>800 lines)**: May need refactoring
+- **Missing tests**: Features aren't verified
+- **Outdated dependencies**: Security or compatibility risks
+- **Duplicate code**: Increases maintenance costs
+- **Sparse commits**: Slow progress or batching work
+- **No documentation**: Hard to onboard new developers
+
+### ❌ Red Flags (Immediate Concerns)
+- **Security vulnerabilities**: Data breach risks
+- **No error handling**: Application crashes likely
+- **Hard-coded secrets**: Credentials exposed
+- **No backup strategy**: Data loss risks
+- **Breaking changes uncommitted**: Work-in-progress instability
+- **Abandoned code**: Technical debt accumulating
+
+---
+
+## Business Impact Translations
+
+### Security
+**What developers say**: "We need to implement OAuth2 authentication"
+**What it means**: Your app needs a secure login system like "Sign in with Google"
+**Business impact**: Without this, user accounts are vulnerable to attacks
+**Ask**: "How does this compare to industry standards for apps like ours?"
+
+### Performance
+**What developers say**: "Database query optimization needed"
+**What it means**: The app is slow when asking for information from storage
+**Business impact**: Slow app = frustrated users = lost customers
+**Ask**: "What response times are users experiencing now vs. target?"
+
+### Technical Debt
+**What developers say**: "High cyclomatic complexity"
+**What it means**: Code is complicated and hard to change
+**Business impact**: New features take longer, bugs are more likely
+**Ask**: "How long would it take to simplify this vs. working around it?"
+
+### Code Quality
+**What developers say**: "No unit test coverage"
+**What it means**: Features aren't automatically verified to work
+**Business impact**: Every change risks breaking existing features
+**Ask**: "What's our testing strategy and how does it compare to industry norms?"
+
+### Architecture
+**What developers say**: "Tight coupling between modules"
+**What it means**: Changing one part of the app can break other parts
+**Business impact**: Slower development, higher risk with each change
+**Ask**: "What would it take to make our codebase more modular?"
+
+---
+
+## Common Business Questions
+
+### "Is my code secure?"
+**What to look for**:
+- ✅ Authentication system in place (login verification)
+- ✅ Encrypted data storage (password protection)
+- ✅ Input validation (preventing malicious data)
+- ✅ Regular security updates (patching vulnerabilities)
+- ✅ Secure API keys (credentials not in code)
+
+**Good follow-ups**:
+- "Have we had a security audit?"
+- "What happens if our database is compromised?"
+- "How quickly can we respond to security issues?"
+
+### "Is my team being productive?"
+**What to look for**:
+- ✅ Consistent commit frequency (daily/weekly activity)
+- ✅ Meaningful commit messages (clear work documentation)
+- ✅ Code reviews happening (team collaboration)
+- ✅ Features completing (not just starting)
+- ✅ Tests being written (quality focus)
+
+**Good follow-ups**:
+- "What's our velocity trend over the past 3 months?"
+- "Are blockers being resolved quickly?"
+- "How much time goes to new features vs. bug fixes?"
+
+### "What are my biggest risks?"
+**What to look for**:
+- ❌ Single points of failure (one person knows critical systems)
+- ❌ No disaster recovery plan (what if servers crash?)
+- ❌ Outdated dependencies (security vulnerabilities)
+- ❌ No monitoring/alerts (you don't know when things break)
+- ❌ Undocumented systems (hard to maintain)
+
+**Good follow-ups**:
+- "What happens if our lead developer leaves?"
+- "How long to recover from a server failure?"
+- "What's our backup and rollback strategy?"
+
+### "Should I hire more developers?"
+**What to look for**:
+- Current team velocity vs. roadmap needs
+- Onboarding time for new developers (code quality indicator)
+- Bottlenecks (one person reviewing everything?)
+- Technical debt level (slowing down development?)
+- Infrastructure automation (can scale with team size?)
+
+**Good follow-ups**:
+- "Would a new hire speed things up or slow down onboarding?"
+- "What's the minimum team size to maintain this codebase?"
+- "Are we blocked on specialized skills or just capacity?"
+
+### "What should I prioritize?"
+**Framework for evaluation**:
+
+**High Priority** (Do Now):
+- Security vulnerabilities
+- Performance issues affecting users
+- Critical bugs blocking revenue
+- Infrastructure reliability problems
+
+**Medium Priority** (Plan For):
+- Technical debt slowing development
+- Missing features competitors have
+- Developer productivity improvements
+- Scalability preparations
+
+**Low Priority** (Nice to Have):
+- Code style improvements
+- Minor optimizations
+- Experimental features
+- Legacy code cleanup (if not blocking)
+
+**Good follow-ups**:
+- "What's the ROI of fixing this vs. building that?"
+- "How does this align with our 6-month roadmap?"
+- "What dependencies does this unblock?"
+
+---
+
+## Evaluating Developer Work
+
+### Code Quality Indicators
+
+**High Quality**:
+- Small, focused commits (one change per commit)
+- Tests included with features
+- Clear documentation
+- Responsive to code review feedback
+- Proactive refactoring
+
+**Needs Improvement**:
+- Large, monolithic commits (hard to review)
+- No tests or documentation
+- Ignoring code review comments
+- Reactive to bugs instead of preventing them
+- Copy-paste code instead of reusing
+
+### Activity Patterns
+
+**Healthy Patterns**:
+- Consistent daily/weekly commits
+- Regular code reviews (giving and receiving)
+- Balanced work (features, bugs, refactoring)
+- Learning visible in code evolution
+- Collaboration with team
+
+**Warning Signs**:
+- Long gaps between commits
+- No participation in code reviews
+- Only working on easy tasks
+- Same mistakes repeatedly
+- Working in isolation
+
+### Collaboration Signals
+
+**Good Collaboration**:
+- Thoughtful code review comments
+- Knowledge sharing in documentation
+- Helping teammates debug issues
+- Pair programming sessions
+- Cross-functional work
+
+**Poor Collaboration**:
+- Rubber-stamp code reviews ("LGTM" with no comments)
+- Hoarding knowledge
+- Territorial about code ownership
+- Not responding to questions
+- Siloed in one area
+
+---
+
+## Understanding Reports
+
+### When You See This Report
+
+**Commit Activity**:
+```
+Files changed: 15
+Lines added: +450
+Lines removed: -320
+Net change: +130 lines
+```
+
+**Translation**: Developer modified 15 files, adding 450 new lines and removing 320 old lines. Net result is 130 more lines of code.
+
+**What's good**: Negative net change often means refactoring (improving existing code)
+**What's concerning**: Massive additions without removals might mean duplication
+
+**Questions to ask**:
+- "What feature does this implement?"
+- "Why the large change?"
+- "Are tests included?"
+
+---
+
+### When You See This Report
+
+**Test Coverage**:
+```
+Coverage: 85%
+Tests: 234 passing, 2 failing
+```
+
+**Translation**: 85% of the code has automated verification. 234 tests confirm features work, 2 tests found problems.
+
+**What's good**: >80% coverage means most features are verified
+**What's concerning**: Failing tests mean known bugs exist
+
+**Questions to ask**:
+- "What's not covered by tests?"
+- "What do the failing tests indicate?"
+- "What's the target coverage for our industry?"
+
+---
+
+### When You See This Report
+
+**Security Scan**:
+```
+Critical: 0
+High: 2
+Medium: 5
+Low: 8
+```
+
+**Translation**: Security scanner found issues: 2 serious problems, 5 moderate risks, 8 minor concerns.
+
+**What's good**: Zero critical vulnerabilities
+**What's concerning**: High-severity issues need immediate attention
+
+**Questions to ask**:
+- "What are the 2 high-severity issues?"
+- "What's the timeline to fix them?"
+- "How did these get introduced?"
+
+---
+
+### When You See This Report
+
+**Performance Metrics**:
+```
+API Response Time: 450ms (target: 200ms)
+Database Queries: 15 per request
+Page Load: 3.2s
+```
+
+**Translation**: App takes 450 milliseconds to respond (target is 200ms), makes 15 database calls per request, takes 3.2 seconds to load pages.
+
+**What's good**: Understanding current performance baseline
+**What's concerning**: Everything is slower than target
+
+**Questions to ask**:
+- "What's acceptable for our users?"
+- "Where's the bottleneck?"
+- "What's the optimization plan?"
+
+---
+
+## Technical Terms → Business Terms
+
+| Technical Term | Business Translation |
+|----------------|---------------------|
+| **API** | A door where apps send and receive data |
+| **Authentication** | Security checkpoint verifying who you are |
+| **Authorization** | Permission system controlling what you can do |
+| **Cache** | Temporary storage for faster repeat access |
+| **Database query** | Asking the system to find specific information |
+| **Deployment** | Publishing code to production servers |
+| **Dependency** | External software your app relies on |
+| **Endpoint** | Specific URL where apps communicate |
+| **Framework** | Pre-built foundation for building apps |
+| **Migration** | Updating database structure |
+| **Refactoring** | Improving code without changing functionality |
+| **Repository** | Storage location for all your code |
+| **Technical debt** | Shortcuts that need fixing later |
+| **Webhook** | Automated notification when events happen |
+
+---
+
+## Context Hints for Better Answers
+
+When asking about code, provide context:
+
+**Instead of**: "Is this code good?"
+**Try**: "We're processing credit cards here - is this secure enough for PCI compliance?"
+
+**Instead of**: "How's performance?"
+**Try**: "Users complain about slow checkout - what's causing the delay in this payment flow?"
+
+**Instead of**: "Should we fix this?"
+**Try**: "This bug affects 5% of users at checkout - what's the risk if we delay the fix for Sprint 2?"
+
+**Instead of**: "Is the team productive?"
+**Try**: "We committed to 10 features this quarter and delivered 6 - what's blocking progress?"
+
+---
+
+## What to Ask When Inspecting Code
+
+### For New Features
+- "What business problem does this solve?"
+- "How is this tested?"
+- "What happens if it fails?"
+- "Who else needs to know about this?"
+
+### For Bug Fixes
+- "What caused this bug?"
+- "How do we prevent this type of bug in the future?"
+- "Are there similar bugs elsewhere?"
+- "What was the user impact?"
+
+### For Refactoring
+- "What improves after this change?"
+- "What's the risk of this refactoring?"
+- "How long will this take vs. working around it?"
+- "What does this unblock?"
+
+### For Dependencies
+- "Why do we need this library?"
+- "What are the security implications?"
+- "What happens if this library stops being maintained?"
+- "Are there alternatives?"
+
+---
+
+## Bottom Line Summaries
+
+Every code inspection should answer:
+
+**✅ Status**: Is this working, broken, or in-progress?
+**⚠️ Risks**: What could go wrong?
+**💡 Recommendations**: What should happen next?
+**📊 Metrics**: What numbers matter (performance, coverage, security)?
+**🎯 Business Impact**: How does this affect revenue, users, or growth?
+
+---
+
+## When to Escalate
+
+Bring in technical leadership when you see:
+- Critical security vulnerabilities
+- Repeated pattern of low-quality work
+- Team velocity dropping significantly
+- Major architectural decisions needed
+- Regulatory compliance concerns
+- Unresolved team conflicts affecting code
+
+---
+
+**Remember**: Good code is clear, tested, secure, and maintainable. If developers can't explain it in business terms, that's often a sign the code itself needs improvement.

claude_mpm/cli/startup.py

@@ -234,7 +234,7 @@ def deploy_bundled_skills():
             if not skills_config.get("auto_deploy", True):
                 # Auto-deploy disabled, skip silently
                 return
-        except Exception:
+        except Exception:  # nosec B110
             # If config loading fails, assume auto-deploy is enabled (default)
             pass
 
@@ -312,64 +312,56 @@ def deploy_output_style_on_startup():
     directory (~/.claude/output-styles/) which is the official Claude Code location
     for custom output styles.
 
-    Deploys two styles:
+    Deploys all styles:
     - claude-mpm.md (professional mode)
     - claude-mpm-teacher.md (teaching mode)
+    - claude-mpm-founders.md (founders mode)
     """
     try:
-        import shutil
-        from pathlib import Path
+        from ..core.output_style_manager import OutputStyleManager
 
-        # Source files (in framework package)
-        package_dir = Path(__file__).parent.parent / "agents"
-        professional_source = package_dir / "CLAUDE_MPM_OUTPUT_STYLE.md"
-        teacher_source = package_dir / "CLAUDE_MPM_TEACHER_OUTPUT_STYLE.md"
-
-        # Target directory (USER-LEVEL for global availability)
-        # Claude Code reads output styles from ~/.claude/output-styles/
-        user_home = Path.home()
-        output_styles_dir = user_home / ".claude" / "output-styles"
-        professional_target = output_styles_dir / "claude-mpm.md"
-        teacher_target = output_styles_dir / "claude-mpm-teacher.md"
-
-        # Create directory if it doesn't exist
-        output_styles_dir.mkdir(parents=True, exist_ok=True)
-
-        # Check if already deployed AND up-to-date (compare sizes to detect changes)
-        professional_up_to_date = (
-            professional_target.exists()
-            and professional_source.exists()
-            and professional_target.stat().st_size == professional_source.stat().st_size
-        )
-        teacher_up_to_date = (
-            teacher_target.exists()
-            and teacher_source.exists()
-            and teacher_target.stat().st_size == teacher_source.stat().st_size
-        )
+        # Initialize the output style manager
+        manager = OutputStyleManager()
+
+        # Check if Claude Code version supports output styles (>= 1.0.83)
+        if not manager.supports_output_styles():
+            # Skip deployment for older versions
+            # The manager will fall back to injecting content directly
+            return
 
-        if professional_up_to_date and teacher_up_to_date:
+        # Check if all styles are already deployed and up-to-date
+        all_up_to_date = True
+        for style_config in manager.styles.values():
+            source_path = style_config["source"]
+            target_path = style_config["target"]
+
+            if not (
+                target_path.exists()
+                and source_path.exists()
+                and target_path.stat().st_size == source_path.stat().st_size
+            ):
+                all_up_to_date = False
+                break
+
+        if all_up_to_date:
             # Show feedback that output styles are ready
             print("✓ Output styles ready", flush=True)
             return
 
-        # Deploy both styles
-        deployed_count = 0
-        if professional_source.exists():
-            shutil.copy2(professional_source, professional_target)
-            deployed_count += 1
+        # Deploy all styles using the manager
+        results = manager.deploy_all_styles(activate_default=True)
 
-        if teacher_source.exists():
-            shutil.copy2(teacher_source, teacher_target)
-            deployed_count += 1
+        # Count successful deployments
+        deployed_count = sum(1 for success in results.values() if success)
 
         if deployed_count > 0:
             print(f"✓ Output styles deployed ({deployed_count} styles)", flush=True)
         else:
-            # Source files missing - log but don't fail
+            # Deployment failed - log but don't fail startup
             from ..core.logger import get_logger
 
             logger = get_logger("cli")
-            logger.debug("Output style source files not found")
+            logger.debug("Failed to deploy any output styles")
 
     except Exception as e:
         # Non-critical - log but don't fail startup
@@ -489,7 +481,6 @@ def sync_remote_agents_on_startup(force_sync: bool = False):
         from pathlib import Path
 
         from ..core.shared.config_loader import ConfigLoader
-        from ..services.agents.deployment.agent_deployment import AgentDeploymentService
         from ..services.agents.startup_sync import sync_agents_on_startup
         from ..services.profile_manager import ProfileManager
         from ..utils.progress import ProgressBar
@@ -537,304 +528,89 @@ def sync_remote_agents_on_startup(force_sync: bool = False):
                 logger.warning(f"Agent sync completed with {len(errors)} errors")
 
             # Phase 2: Deploy agents from cache to ~/.claude/agents/
-            # This mirrors the skills deployment pattern (lines 371-407)
+            # Use reconciliation service to respect configuration.yaml settings
             try:
-                # Initialize deployment service with profile-filtered configuration
-                from ..core.config import Config
-
-                deploy_config = None
-                if active_profile and profile_manager.active_profile:
-                    # Create config with excluded agents based on profile
-                    # Get all agents that should be excluded (not in enabled list)
-                    from pathlib import Path
-
-                    cache_dir = Path.home() / ".claude-mpm" / "cache" / "agents"
-                    if cache_dir.exists():
-                        # Find all agent files
-                        # Supports both flat cache and {owner}/{repo}/agents/ structure
-                        all_agent_files = [
-                            f
-                            for f in cache_dir.rglob("*.md")
-                            if "/agents/" in str(f)
-                            and f.stem.lower() != "base-agent"
-                            and f.name.lower()
-                            not in {"readme.md", "changelog.md", "contributing.md"}
-                        ]
-
-                        # Build exclusion list for agents not in profile
-                        excluded_agents = []
-                        for agent_file in all_agent_files:
-                            agent_name = agent_file.stem
-                            if not profile_manager.is_agent_enabled(agent_name):
-                                excluded_agents.append(agent_name)
-
-                        if excluded_agents:
-                            # Get singleton config and update with profile settings
-                            # BUGFIX: Config is a singleton that ignores dict parameter if already initialized.
-                            # Creating Config({...}) doesn't store excluded_agents - use set() instead.
-                            deploy_config = Config()
-                            deploy_config.set(
-                                "agent_deployment.excluded_agents", excluded_agents
-                            )
-                            deploy_config.set(
-                                "agent_deployment.filter_non_mpm_agents", False
-                            )
-                            deploy_config.set("agent_deployment.case_sensitive", False)
-                            deploy_config.set(
-                                "agent_deployment.exclude_dependencies", False
-                            )
-                            logger.info(
-                                f"Profile '{active_profile}': Excluding {len(excluded_agents)} agents from deployment"
-                            )
-
-                deployment_service = AgentDeploymentService(config=deploy_config)
-
-                # Count agents in cache to show accurate progress
                 from pathlib import Path
 
-                cache_dir = Path.home() / ".claude-mpm" / "cache" / "agents"
-                agent_count = 0
-
-                if cache_dir.exists():
-                    # BUGFIX (cache-count-inflation): Clean up stale cache files
-                    # from old repositories before counting to prevent inflated counts.
-                    # Issue: Old caches like bobmatnyc/claude-mpm-agents/agents/
-                    # were counted alongside current agents, inflating count
-                    # from 44 to 85.
-                    #
-                    # Solution: Remove files with nested /agents/ paths
-                    # (e.g., cache/agents/user/repo/agents/...)
-                    # Keep only current agents (e.g., cache/agents/engineer/...)
-                    removed_count = 0
-                    stale_dirs = set()
-
-                    for md_file in cache_dir.rglob("*.md"):
-                        # Stale cache files have multiple /agents/ in their path RELATIVE to cache_dir
-                        # Current: cache/agents/bobmatnyc/claude-mpm-agents/agents/engineer/...
-                        #          (1 occurrence in relative path: /agents/)
-                        # Old flat: cache/agents/engineer/...
-                        #           (0 occurrences in relative path - no repo structure)
-                        # The issue: str(md_file).count("/agents/") counts BOTH cache/agents/ AND repo/agents/
-                        # Fix: Count /agents/ in path RELATIVE to cache_dir (after cache/agents/)
-                        relative_path = str(md_file.relative_to(cache_dir))
-                        if relative_path.count("/agents/") > 1:
-                            # Track parent directory for cleanup
-                            # Extract subdirectory under cache/agents/
-                            # (e.g., "bobmatnyc")
-                            parts = md_file.parts
-                            cache_agents_idx = parts.index("agents")
-                            if cache_agents_idx + 1 < len(parts):
-                                stale_subdir = parts[cache_agents_idx + 1]
-                                # Only remove if it's not a known category directory
-                                if stale_subdir not in [
-                                    "engineer",
-                                    "ops",
-                                    "qa",
-                                    "universal",
-                                    "documentation",
-                                    "claude-mpm",
-                                    "security",
-                                ]:
-                                    stale_dirs.add(cache_dir / stale_subdir)
-
-                            md_file.unlink()
-                            removed_count += 1
-
-                    # Remove empty stale directories
-                    for stale_dir in stale_dirs:
-                        if stale_dir.exists() and stale_dir.is_dir():
-                            try:
-                                # Remove directory and all contents
-                                import shutil
-
-                                shutil.rmtree(stale_dir)
-                            except Exception:
-                                pass  # Ignore cleanup errors
-
-                    if removed_count > 0:
-                        from loguru import logger
-
-                        logger.info(
-                            f"Cleaned up {removed_count} stale cache files "
-                            f"from old repositories"
-                        )
+                from ..core.unified_config import UnifiedConfig
+                from ..services.agents.deployment.startup_reconciliation import (
+                    perform_startup_reconciliation,
+                )
 
-                    # Count MD files in cache (agent markdown files from
-                    # current repos)
-                    # BUGFIX: Only count files in agent directories,
-                    # not docs/templates/READMEs
-                    # Valid agent paths must contain "/agents/" exactly ONCE
-                    # (current structure)
-                    # Exclude PM templates, BASE-AGENT, and documentation files
-                    pm_templates = {
-                        "base-agent.md",
-                        "circuit_breakers.md",
-                        "pm_examples.md",
-                        "pm_red_flags.md",
-                        "research_gate_examples.md",
-                        "response_format.md",
-                        "ticket_completeness_examples.md",
-                        "validation_templates.md",
-                        "git_file_tracking.md",
-                    }
-                    # Documentation files to exclude (by filename)
-                    doc_files = {
-                        "readme.md",
-                        "changelog.md",
-                        "contributing.md",
-                        "implementation-summary.md",
-                        "reorganization-plan.md",
-                        "auto-deploy-index.md",
-                    }
-
-                    # Find all markdown files (after cleanup)
-                    all_md_files = list(cache_dir.rglob("*.md"))
-
-                    # Filter to only agent files:
-                    # 1. Must have "/agents/" in path (current structure supports
-                    #    both flat and {owner}/{repo}/agents/ patterns)
-                    # 2. Must not be in PM templates or doc files
-                    # 3. Exclude BASE-AGENT.md which is not a deployable agent
-                    # 4. Exclude build artifacts (dist/, build/, .cache/)
-                    #    to prevent double-counting
-                    agent_files = [
-                        f
-                        for f in all_md_files
-                        if (
-                            # Must be in an agent directory
-                            # Supports: cache/agents/{category}/... (flat)
-                            # Supports: cache/agents/{owner}/{repo}/agents/{category}/... (GitHub sync)
-                            "/agents/" in str(f)
-                            # Exclude PM templates, doc files, and BASE-AGENT
-                            and f.name.lower() not in pm_templates
-                            and f.name.lower() not in doc_files
-                            and f.name.lower() != "base-agent.md"
-                            # Exclude build artifacts (prevents double-counting
-                            # source + built files)
-                            and not any(
-                                part in str(f).split("/")
-                                for part in ["dist", "build", ".cache"]
-                            )
-                        )
-                    ]
-                    agent_count = len(agent_files)
-
-                if agent_count > 0:
-                    # Deploy agents to project-level directory where Claude Code expects them
-                    deploy_target = Path.cwd() / ".claude" / "agents"
-                    deployment_result = deployment_service.deploy_agents(
-                        target_dir=deploy_target,
-                        force_rebuild=False,  # Only deploy if versions differ
-                        deployment_mode="update",  # Version-aware updates
-                        config=deploy_config,  # Pass config to respect profile filtering
+                # Load configuration
+                unified_config = UnifiedConfig()
+
+                # Override with profile settings if active
+                if active_profile and profile_manager.active_profile:
+                    # Get enabled agents from profile (returns Set[str])
+                    profile_enabled_agents = (
+                        profile_manager.active_profile.get_enabled_agents()
+                    )
+                    # Update config with profile's enabled list (convert Set to List)
+                    unified_config.agents.enabled = list(profile_enabled_agents)
+                    logger.info(
+                        f"Profile '{active_profile}': Using {len(profile_enabled_agents)} enabled agents"
                     )
 
-                    # Get actual counts from deployment result (reflects configured agents)
-                    deployed = len(deployment_result.get("deployed", []))
-                    updated = len(deployment_result.get("updated", []))
-                    skipped = len(deployment_result.get("skipped", []))
-                    total_configured = deployed + updated + skipped
-
-                    # FALLBACK: If deployment result doesn't track skipped agents (async path),
-                    # count existing agents in target directory as "already deployed"
-                    # This ensures accurate reporting when agents are already up-to-date
-                    if total_configured == 0 and deploy_target.exists():
-                        existing_agents = list(deploy_target.glob("*.md"))
-                        # Filter out non-agent files (e.g., README.md, INSTRUCTIONS.md)
-                        agent_count_in_target = len(
-                            [
-                                f
-                                for f in existing_agents
-                                if not f.name.startswith(("README", "INSTRUCTIONS"))
-                            ]
-                        )
-                        if agent_count_in_target > 0:
-                            # All agents already deployed - count them as skipped
-                            skipped = agent_count_in_target
-                            total_configured = agent_count_in_target
+                # Perform reconciliation to deploy configured agents
+                project_path = Path.cwd()
+                agent_result, _skill_result = perform_startup_reconciliation(
+                    project_path=project_path, config=unified_config, silent=False
+                )
 
-                    # Create progress bar with actual configured agent count (not raw file count)
+                # Display results with progress bar
+                total_operations = (
+                    len(agent_result.deployed)
+                    + len(agent_result.removed)
+                    + len(agent_result.unchanged)
+                )
+
+                if total_operations > 0:
                     deploy_progress = ProgressBar(
-                        total=total_configured if total_configured > 0 else 1,
+                        total=total_operations,
                         prefix="Deploying agents",
                         show_percentage=True,
                         show_counter=True,
                     )
-
-                    # Update progress bar to completion
-                    deploy_progress.update(
-                        total_configured if total_configured > 0 else 1
-                    )
-
-                    # Cleanup orphaned agents (ours but no longer deployed)
-                    # Get list of deployed agent filenames (what should remain)
-                    deployed_filenames = []
-                    for agent_name in deployment_result.get("deployed", []):
-                        deployed_filenames.append(f"{agent_name}.md")
-                    for agent_name in deployment_result.get("updated", []):
-                        deployed_filenames.append(f"{agent_name}.md")
-                    for agent_name in deployment_result.get("skipped", []):
-                        deployed_filenames.append(f"{agent_name}.md")
-
-                    # Run cleanup and get count of removed agents
-                    removed = _cleanup_orphaned_agents(
-                        deploy_target, deployed_filenames
+                    deploy_progress.update(total_operations)
+
+                    # Build summary message
+                    deployed = len(agent_result.deployed)
+                    removed = len(agent_result.removed)
+                    unchanged = len(agent_result.unchanged)
+
+                    summary_parts = []
+                    if deployed > 0:
+                        summary_parts.append(f"{deployed} new")
+                    if removed > 0:
+                        summary_parts.append(f"{removed} removed")
+                    if unchanged > 0:
+                        summary_parts.append(f"{unchanged} unchanged")
+
+                    summary = f"Complete: {', '.join(summary_parts)}"
+                    deploy_progress.finish(summary)
+
+                # Display errors if any
+                if agent_result.errors:
+                    logger.warning(
+                        f"Agent deployment completed with {len(agent_result.errors)} errors"
                     )
+                    print("\n⚠️  Agent Deployment Errors:")
+                    max_errors_to_show = 10
+                    errors_to_display = agent_result.errors[:max_errors_to_show]
 
-                    # Show total configured agents (deployed + updated + already existing)
-                    # Include cache count for context and removed count if any
-                    if deployed > 0 or updated > 0:
-                        if removed > 0:
-                            deploy_progress.finish(
-                                f"Complete: {deployed} new, {updated} updated, {skipped} unchanged, "
-                                f"{removed} removed ({total_configured} configured from {agent_count} files in cache)"
-                            )
-                        else:
-                            deploy_progress.finish(
-                                f"Complete: {deployed} new, {updated} updated, {skipped} unchanged "
-                                f"({total_configured} configured from {agent_count} files in cache)"
-                            )
-                    elif removed > 0:
-                        deploy_progress.finish(
-                            f"Complete: {total_configured} agents deployed, "
-                            f"{removed} removed ({agent_count} files in cache)"
-                        )
-                    else:
-                        deploy_progress.finish(
-                            f"Complete: {total_configured} agents deployed "
-                            f"({agent_count} files in cache)"
-                        )
-
-                    # Display deployment errors to user (not just logs)
-                    deploy_errors = deployment_result.get("errors", [])
-                    if deploy_errors:
-                        # Log for debugging
-                        logger.warning(
-                            f"Agent deployment completed with {len(deploy_errors)} errors: {deploy_errors}"
-                        )
-
-                        # Display errors to user with clear formatting
-                        print("\n⚠️  Agent Deployment Errors:")
+                    for error in errors_to_display:
+                        print(f"   - {error}")
 
-                        # Show first 10 errors to avoid overwhelming output
-                        max_errors_to_show = 10
-                        errors_to_display = deploy_errors[:max_errors_to_show]
+                    if len(agent_result.errors) > max_errors_to_show:
+                        remaining = len(agent_result.errors) - max_errors_to_show
+                        print(f"   ... and {remaining} more error(s)")
 
-                        for error in errors_to_display:
-                            # Format error message for readability
-                            # Errors typically come as strings like "agent.md: Error message"
-                            print(f"   - {error}")
-
-                        # If more errors exist, show count
-                        if len(deploy_errors) > max_errors_to_show:
-                            remaining = len(deploy_errors) - max_errors_to_show
-                            print(f"   ... and {remaining} more error(s)")
-
-                        # Show summary message
-                        print(
-                            f"\n❌ Failed to deploy {len(deploy_errors)} agent(s). Please check the error messages above."
-                        )
-                        print("   Run with --verbose for detailed error information.\n")
+                    print(
+                        f"\n❌ Failed to deploy {len(agent_result.errors)} agent(s). "
+                        "Please check the error messages above."
+                    )
+                    print("   Run with --verbose for detailed error information.\n")
 
             except Exception as e:
                 # Deployment failure shouldn't block startup
@@ -859,7 +635,7 @@ def sync_remote_agents_on_startup(force_sync: bool = False):
         # Cleanup legacy cache even if sync failed
         try:
             cleanup_legacy_agent_cache()
-        except Exception:
+        except Exception:  # nosec B110
             pass  # Ignore cleanup errors
 
 
@@ -1424,7 +1200,7 @@ def auto_install_chrome_devtools_on_startup():
             if not chrome_devtools_config.get("auto_install", True):
                 # Auto-install disabled, skip silently
                 return
-        except Exception:
+        except Exception:  # nosec B110
             # If config loading fails, assume auto-install is enabled (default)
             pass
 
@@ -1679,7 +1455,7 @@ def verify_mcp_gateway_startup():
                                 loop.run_until_complete(
                                     asyncio.gather(*pending, return_exceptions=True)
                                 )
-                        except Exception:
+                        except Exception:  # nosec B110
                             pass  # Ignore cleanup errors
                         finally:
                             loop.close()
@@ -1773,7 +1549,7 @@ def check_for_updates_async():
 
                 logger = get_logger("upgrade_check")
                 logger.debug(f"Update check failed (non-critical): {e}")
-            except Exception:
+            except Exception:  # nosec B110
                 pass  # Avoid any errors in error handling
         finally:
             # Properly clean up event loop
@@ -1788,7 +1564,7 @@ def check_for_updates_async():
                         loop.run_until_complete(
                             asyncio.gather(*pending, return_exceptions=True)
                         )
-                except Exception:
+                except Exception:  # nosec B110
                     pass  # Ignore cleanup errors
                 finally:
                     loop.close()

claude_mpm/core/output_style_manager.py

@@ -27,7 +27,7 @@ _CACHED_CLAUDE_VERSION: Optional[str] = None
 _VERSION_DETECTED: bool = False
 
 # Output style types
-OutputStyleType = Literal["professional", "teaching"]
+OutputStyleType = Literal["professional", "teaching", "founders"]
 
 
 class StyleConfig(TypedDict):
@@ -41,9 +41,10 @@ class StyleConfig(TypedDict):
 class OutputStyleManager:
     """Manages output style deployment and version-based handling.
 
-    Supports two output styles:
+    Supports three output styles:
     - professional: Default Claude MPM style (claude-mpm.md)
     - teaching: Adaptive teaching mode (claude-mpm-teacher.md)
+    - founders: Non-technical mode for startup founders (claude-mpm-founders.md)
     """
 
     def __init__(self) -> None:
@@ -71,6 +72,13 @@ class OutputStyleManager:
                 target=self.output_style_dir / "claude-mpm-teacher.md",
                 name="Claude MPM Teacher",
             ),
+            "founders": StyleConfig(
+                source=Path(__file__).parent.parent
+                / "agents"
+                / "CLAUDE_MPM_FOUNDERS_OUTPUT_STYLE.md",
+                target=self.output_style_dir / "claude-mpm-founders.md",
+                name="Claude MPM Founders",
+            ),
         }
 
         # Default style path (for backward compatibility)

claude_mpm/core/unified_config.py

@@ -79,6 +79,7 @@ class AgentConfig(BaseModel):
             "mpm-skills-manager",
             "mpm-agent-manager",
             "memory-manager",
+            "ticketing",
         ],
         description="Agents that are always deployed (core system agents)",
     )

claude_mpm/skills/bundled/pm/pm-bug-reporting/pm-bug-reporting.md

@@ -0,0 +1,248 @@
+---
+name: pm-bug-reporting
+version: "1.0.0"
+description: Bug reporting protocol for PM and agents to file GitHub issues
+when_to_use: Framework bugs, agent errors, skill content errors detected
+category: pm-workflow
+tags: [bug-reporting, github, issues, pm-required]
+---
+
+# PM Bug Reporting Protocol
+
+## When to Report Bugs
+
+Report bugs when you encounter:
+- **PM instruction errors** or missing guidance
+- **Agent malfunction** or incorrect behavior
+- **Skill content errors** or outdated information
+- **Framework crashes** or unexpected behavior
+- **Missing or incorrect documentation**
+- **Configuration errors** or invalid defaults
+
+## GitHub Repositories
+
+Route bugs to the correct repository:
+
+| Bug Type | Repository | Owner/Repo |
+|----------|------------|------------|
+| Core MPM (CLI, startup, config, orchestration) | claude-mpm | bobmatnyc/claude-mpm |
+| Agent bugs (wrong behavior, errors, missing capabilities) | claude-mpm-agents | bobmatnyc/claude-mpm-agents |
+| Skill bugs (wrong info, outdated, missing content) | claude-mpm-skills | bobmatnyc/claude-mpm-skills |
+
+## Bug Report Template
+
+When creating an issue, include:
+
+### Title
+Brief, descriptive title (50 chars max)
+- ✅ "PM delegates to non-existent agent"
+- ✅ "Research skill missing web search examples"
+- ❌ "Bug in system"
+- ❌ "Fix this"
+
+### Labels
+Always include:
+- `bug` (required)
+- `agent-reported` (required)
+- Additional context labels:
+  - `high-priority` - Critical functionality broken
+  - `documentation` - Documentation error
+  - `agent-error` - Agent-specific issue
+  - `skill-error` - Skill content issue
+
+### Body Structure
+```markdown
+## What Happened
+[Clear description of the bug]
+
+## Expected Behavior
+[What should have happened]
+
+## Steps to Reproduce
+1. [First step]
+2. [Second step]
+3. [Third step]
+
+## Context
+- Agent: [agent name if applicable]
+- Skill: [skill name if applicable]
+- Error Message: [full error if available]
+- Version: [MPM version if known]
+
+## Impact
+[How this affects users/workflow]
+```
+
+## Using gh CLI
+
+### Prerequisites Check
+```bash
+gh auth status
+```
+
+If not authenticated:
+```bash
+gh auth login
+```
+
+### Creating Issues
+
+**Delegate to ticketing agent** with:
+```
+Task:
+  agent: ticketing
+  task: Create GitHub issue for [bug type]
+  context: |
+    Repository: bobmatnyc/claude-mpm[-agents|-skills]
+    Title: [brief title]
+    Labels: bug, agent-reported
+    Body: |
+      ## What Happened
+      [description]
+
+      ## Expected Behavior
+      [expected]
+
+      ## Steps to Reproduce
+      1. [step 1]
+      2. [step 2]
+
+      ## Context
+      - Agent: [agent name]
+      - Error: [error message]
+
+      ## Impact
+      [impact description]
+```
+
+## Examples
+
+### Core MPM Bug
+```
+Task:
+  agent: ticketing
+  task: Create GitHub issue for core MPM bug
+  context: |
+    Repository: bobmatnyc/claude-mpm
+    Title: PM fails to load configuration on startup
+    Labels: bug, agent-reported, high-priority
+    Body: |
+      ## What Happened
+      PM fails to initialize when configuration.yaml contains invalid syntax.
+      No clear error message shown to user.
+
+      ## Expected Behavior
+      PM should display clear YAML syntax error with line number and fix suggestion.
+
+      ## Steps to Reproduce
+      1. Add invalid YAML to .claude-mpm/configuration.yaml
+      2. Run `mpm`
+      3. Observe generic error without details
+
+      ## Context
+      - Component: Configuration loader
+      - Error: "Failed to load configuration"
+      - Version: 5.4.x
+
+      ## Impact
+      Users cannot diagnose configuration errors, requiring manual YAML validation.
+```
+
+### Agent Bug
+```
+Task:
+  agent: ticketing
+  task: Create GitHub issue for agent bug
+  context: |
+    Repository: bobmatnyc/claude-mpm-agents
+    Title: Research agent fails to search with special characters
+    Labels: bug, agent-reported, agent-error
+    Body: |
+      ## What Happened
+      Research agent throws error when search query contains quotes or special chars.
+
+      ## Expected Behavior
+      Search queries should be properly escaped and executed.
+
+      ## Steps to Reproduce
+      1. Delegate to research: "Search for 'React hooks'"
+      2. Research agent attempts search
+      3. Error: "Invalid search query"
+
+      ## Context
+      - Agent: research
+      - Error: grep command fails with unescaped quotes
+
+      ## Impact
+      Cannot search for quoted phrases or technical terms with special characters.
+```
+
+### Skill Bug
+```
+Task:
+  agent: ticketing
+  task: Create GitHub issue for skill content error
+  context: |
+    Repository: bobmatnyc/claude-mpm-skills
+    Title: Git workflow skill contains outdated branch strategy
+    Labels: bug, agent-reported, documentation, skill-error
+    Body: |
+      ## What Happened
+      Skill recommends `git flow` branching model, which project no longer uses.
+      Current standard is trunk-based development.
+
+      ## Expected Behavior
+      Skill should document current trunk-based workflow.
+
+      ## Context
+      - Skill: git-workflow.md
+      - Section: "Branching Strategy"
+      - Line: 45-60
+
+      ## Impact
+      Agents follow outdated branching model, creating workflow friction.
+```
+
+## Escalation Path
+
+When ticketing agent is unavailable or gh CLI fails:
+
+1. **Log locally** for manual reporting:
+   ```
+   echo "[BUG] $(date): [description]" >> .claude-mpm/logs/bugs.log
+   ```
+
+2. **Report to PM** for alternative action:
+   ```
+   PM should create ticket in primary ticketing system (Linear/JIRA)
+   with note to create GitHub issue once available
+   ```
+
+3. **User notification**:
+   ```
+   "Bug detected: [description]. Logged for manual GitHub issue creation."
+   ```
+
+## Success Criteria
+
+Bug reporting successful when:
+- ✅ Issue created in correct repository
+- ✅ All required labels applied (`bug`, `agent-reported`)
+- ✅ Body follows template structure
+- ✅ Title is clear and concise
+- ✅ Context includes agent/skill name if applicable
+- ✅ Issue URL returned for tracking
+
+## PM Enforcement
+
+PM MUST:
+- Detect bugs during agent interactions
+- Delegate bug reporting to ticketing agent
+- NOT attempt to create GitHub issues directly
+- Follow escalation path if ticketing unavailable
+- Log all bug reports for audit trail
+
+## Related Skills
+- [pm-ticketing-integration.md](pm-ticketing-integration.md) - Ticket delegation patterns
+- [pm-delegation-patterns.md](pm-delegation-patterns.md) - General delegation guidance
+- [ticketing-examples.md](ticketing-examples.md) - Ticketing delegation examples

{claude_mpm-5.4.82.dist-info → claude_mpm-5.4.84.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 5.4.82
+Version: 5.4.84
 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.82.dist-info → claude_mpm-5.4.84.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=9JfxhnDtr-8l3kCP2U5TVXSErptHoga8m7XA8zqgGOc,4
-claude_mpm/VERSION,sha256=1GNPudton6MxkdoDRg8-2KdCRDrycUsY-IcEjRdvDFY,7
+claude_mpm/VERSION,sha256=RPHLSIOUPieL9EOrJan8vzunFO1Z613AZQmZyDI0q2o,7
 claude_mpm/__init__.py,sha256=AGfh00BHKvLYD-UVFw7qbKtl7NMRIzRXOWw7vEuZ-h4,2214
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=pz3lTrZZR5HhV3eZzYtIbtBwWo7iM6pkBHP_ixxmI6Y,6827
@@ -7,6 +7,7 @@ claude_mpm/init.py,sha256=7aQpqUrWwSckpNXvBrfGOeGYLl92b1Z-NipoXJRc0f4,26401
 claude_mpm/ticket_wrapper.py,sha256=qe5xY579t7_7fK5nyeAfHN_fr7CXdeOD3jfXEc8-7yo,828
 claude_mpm/agents/BASE_AGENT.md,sha256=UWvKX5S5L2l68F_sn54otC_HDX5kTt8G4ionUcTVpGo,5645
 claude_mpm/agents/BASE_ENGINEER.md,sha256=I7BusSGQfuV0uSkRBro51qzCzagUEPrXnndIElypPJk,24434
+claude_mpm/agents/CLAUDE_MPM_FOUNDERS_OUTPUT_STYLE.md,sha256=gcxHN7IhtTqH5WRWAf-R_EIpRHF-PORK85zAa5pmeiw,12319
 claude_mpm/agents/CLAUDE_MPM_OUTPUT_STYLE.md,sha256=PmiEOcAcDVOPtCwiCPhNGWb8GVDnniftQO7MIi8yBWU,4174
 claude_mpm/agents/CLAUDE_MPM_TEACHER_OUTPUT_STYLE.md,sha256=vneNW5vHjfKsRIukkuGbAnvnyp_-EC3qpFzHDdsMOwc,4796
 claude_mpm/agents/MEMORY.md,sha256=V1mGx5oEaLdN9AYLX3Xetslmr2Ja6vnLPATeEoR6bvw,3303
@@ -41,7 +42,7 @@ claude_mpm/cli/chrome_devtools_installer.py,sha256=efA_ZX1iR3oaJi3222079BQw6DEG8
 claude_mpm/cli/executor.py,sha256=1MQdNPNoIewSR1q8nXjJuES3zKEi_IqVcZQzt9bsxw8,10601
 claude_mpm/cli/helpers.py,sha256=CypEhw0tbNH6_GzVTaQdi4w7ThCWO43Ep92YbJzPR4I,3638
 claude_mpm/cli/parser.py,sha256=Vqx9n-6Xo1uNhXR4rThmgWpZXTr0nOtkgDf3oMS9b0g,5855
-claude_mpm/cli/startup.py,sha256=6sfkFbapu7X76hBPmKjxkUEMlo9DUjF4x7mhaVE7IJw,74374
+claude_mpm/cli/startup.py,sha256=rztiI5mopeHnRTn7WPivyZF4QDtHjuC-O-YhYvuw5I8,61638
 claude_mpm/cli/startup_display.py,sha256=R_QIamjfdaY5o_VxpIeymyYj1Qde2B9hPXy1P-KmUKI,14972
 claude_mpm/cli/startup_logging.py,sha256=RTuyd6CbhiFQz7Z07LDDhK_ZAnZfuJ9B0NghVSntHFI,29390
 claude_mpm/cli/utils.py,sha256=FSMPftBZM8MeUyTtiB63Lz7oFOgkzwTetQs58RbRb_Q,8785
@@ -206,7 +207,7 @@ claude_mpm/core/mixins.py,sha256=vmZ7Nu2ZOnKjbhN07Ixk4noIej9nsJiknrp-Sclfu0A,534
 claude_mpm/core/oneshot_session.py,sha256=nA86Zk7W3Rh_yIhPuegFL7Xgc9S63vQ_MqfLk52doV0,21994
 claude_mpm/core/optimized_agent_loader.py,sha256=yevEwTZWzVeZYEJhV3czD45OU7ukJIaJos4MGnFP7YQ,15857
 claude_mpm/core/optimized_startup.py,sha256=U5I4f7PNYXCBOLbCkbWT2V2sv01T8iWP2Bw-f928Q9M,17927
-claude_mpm/core/output_style_manager.py,sha256=QkH62HRCH6FYxg2lop_3Xml3BLOieE12024vAjS6SyI,17091
+claude_mpm/core/output_style_manager.py,sha256=ynFLUliYKPuw3CWtTcJR7h0TDBE_5z2gwDT-XT_-Owk,17491
 claude_mpm/core/pm_hook_interceptor.py,sha256=92C8TrpK-XVQD8BiXbqs8lSCX72PU0KZG5oAjhf8GOQ,11197
 claude_mpm/core/service_registry.py,sha256=QpmAMWCov8XXaxQwE7WiNbgv6u_CRjpKPB64kLYvZKk,11722
 claude_mpm/core/session_manager.py,sha256=iEDZWKBYHSu001nFX8vFvH33RvQOW0eIgomWhFM53sw,12078
@@ -216,7 +217,7 @@ claude_mpm/core/tool_access_control.py,sha256=dpdxxp_77SuxGM2C7SsHUZbtysJmHw1rLD
 claude_mpm/core/types.py,sha256=Sv62QhMYvfxbt7oIGoAhhN_jxonFTeLRf-BuhxZ4vYw,7719
 claude_mpm/core/typing_utils.py,sha256=qny3rA9mAeXqdLgUj9DZg642shw4LmLbkPqADN-765s,13314
 claude_mpm/core/unified_agent_registry.py,sha256=YbL-oWeHU85zdf1mF7tyMHBYKtFBupsMeH9BCdzD6ZI,34161
-claude_mpm/core/unified_config.py,sha256=DUC5PB9P9s_27xs6_87vc3t-rkrU6jITwOFu6W8At7o,21743
+claude_mpm/core/unified_config.py,sha256=WWuNWGLK0ySWQ_drR-FVb_FeL8c9HhTU_Ch3hGsPCAo,21768
 claude_mpm/core/unified_paths.py,sha256=F2NYAK6RNtn_xsZnVHVfP7MErzDh_O9hyaa3B4OyT9A,36690
 claude_mpm/core/framework/__init__.py,sha256=IJCp6-MQO8gW31uG8aMWHdNg54NgGvXb4GvOuwZF6Iw,736
 claude_mpm/core/framework/formatters/__init__.py,sha256=OKkLN2x21rcbg3d3feZLixIS-UjHPlxl768uGmQy7Qc,307
@@ -863,6 +864,7 @@ claude_mpm/skills/bundled/php/espocrm-development/references/development-workflo
 claude_mpm/skills/bundled/php/espocrm-development/references/frontend-customization.md,sha256=0h1VohuIr-El_Rj9wWWPluRynQqi2B8i0-xTaPdkGBY,17519
 claude_mpm/skills/bundled/php/espocrm-development/references/hooks-and-services.md,sha256=2KwnVcf5s1TCAo1GMdbLitJMVbi7cdYfDK_M5C4oBtI,20820
 claude_mpm/skills/bundled/php/espocrm-development/references/testing-debugging.md,sha256=9TVZk_ZTez65kzx2R8nG-8fn9V_pIT5oTLsFQdPk2zQ,18250
+claude_mpm/skills/bundled/pm/pm-bug-reporting/pm-bug-reporting.md,sha256=mDjGQd9ALSZ0jsuWyXSVT6_GxTudzAVTkasqwnf4zJE,6494
 claude_mpm/skills/bundled/pm/pm-delegation-patterns/SKILL.md,sha256=kdFyy5T_70vw5XpGexlXr18VdQWIFD59A8pLmmcWiVA,5388
 claude_mpm/skills/bundled/pm/pm-git-file-tracking/SKILL.md,sha256=bnmO9Wzoe0AYJ72yKBO_FqtxsfjIkYhUHlosPRrYgTM,3607
 claude_mpm/skills/bundled/pm/pm-pr-workflow/SKILL.md,sha256=HSeVxw_znHqiPA95gpHnPKavNkSgSLTKuVaHqV976Ao,3369
@@ -969,10 +971,10 @@ claude_mpm/utils/subprocess_utils.py,sha256=D0izRT8anjiUb_JG72zlJR_JAw1cDkb7kalN
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=GprtAvu80VyMXcKGsK_VhYiXWA6BjKHv7O6HKx0AB9w,20917
 claude_mpm/validation/frontmatter_validator.py,sha256=YpJlYNNYcV8u6hIOi3_jaRsDnzhbcQpjCBE6eyBKaFY,7076
-claude_mpm-5.4.82.dist-info/licenses/LICENSE,sha256=ca3y_Rk4aPrbF6f62z8Ht5MJM9OAvbGlHvEDcj9vUQ4,3867
-claude_mpm-5.4.82.dist-info/licenses/LICENSE-FAQ.md,sha256=TxfEkXVCK98RzDOer09puc7JVCP_q_bN4dHtZKHCMcM,5104
-claude_mpm-5.4.82.dist-info/METADATA,sha256=ofAd7jlgMNdr991W2fT3g8dkCYsHSYjn8azaLnwj7HI,38503
-claude_mpm-5.4.82.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-5.4.82.dist-info/entry_points.txt,sha256=n-Uk4vwHPpuvu-g_I7-GHORzTnN_m6iyOsoLveKKD0E,228
-claude_mpm-5.4.82.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-5.4.82.dist-info/RECORD,,
+claude_mpm-5.4.84.dist-info/licenses/LICENSE,sha256=ca3y_Rk4aPrbF6f62z8Ht5MJM9OAvbGlHvEDcj9vUQ4,3867
+claude_mpm-5.4.84.dist-info/licenses/LICENSE-FAQ.md,sha256=TxfEkXVCK98RzDOer09puc7JVCP_q_bN4dHtZKHCMcM,5104
+claude_mpm-5.4.84.dist-info/METADATA,sha256=mXYhdkcOB3779gcXJpYrizksYyUQxqnJ1d4FtqHKroM,38503
+claude_mpm-5.4.84.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-5.4.84.dist-info/entry_points.txt,sha256=n-Uk4vwHPpuvu-g_I7-GHORzTnN_m6iyOsoLveKKD0E,228
+claude_mpm-5.4.84.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-5.4.84.dist-info/RECORD,,