claude-mpm 5.4.65__py3-none-any.whl → 5.6.10__py3-none-any.whl

claude_mpm/cli/startup.py

@@ -161,7 +161,25 @@ def setup_early_environment(argv):
     # CRITICAL: Suppress ALL logging by default
     # This catches all loggers (claude_mpm.*, service.*, framework_loader, etc.)
     # This will be overridden by setup_mcp_server_logging() based on user preference
-    logging.getLogger().setLevel(logging.CRITICAL + 1)  # Root logger catches everything
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.CRITICAL + 1)  # Root logger catches everything
+    root_logger.handlers = []  # Remove any handlers
+
+    # Also suppress common module loggers explicitly to prevent handler leakage
+    for logger_name in [
+        "claude_mpm",
+        "path_resolver",
+        "file_loader",
+        "framework_loader",
+        "service",
+        "instruction_loader",
+        "agent_loader",
+        "startup",
+    ]:
+        module_logger = logging.getLogger(logger_name)
+        module_logger.setLevel(logging.CRITICAL + 1)
+        module_logger.handlers = []
+        module_logger.propagate = False
 
     # Process argv
     if argv is None:
@@ -191,7 +209,8 @@ def should_skip_background_services(args, processed_argv):
     skip_commands = ["--version", "-v", "--help", "-h"]
     return any(cmd in (processed_argv or sys.argv[1:]) for cmd in skip_commands) or (
         hasattr(args, "command")
-        and args.command in ["info", "doctor", "config", "mcp", "configure"]
+        and args.command
+        in ["info", "doctor", "config", "mcp", "configure", "hook-errors", "autotodos"]
     )
 
 
@@ -234,7 +253,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
 
@@ -308,68 +327,60 @@ def deploy_output_style_on_startup():
     communication without emojis and exclamation points. Styles are project-specific
     to allow different projects to have different communication styles.
 
-    DESIGN DECISION: This is non-blocking and idempotent. Deploys to project-level
-    directory (.claude/settings/output-styles/) instead of user-level to maintain
-    project isolation.
+    DESIGN DECISION: This is non-blocking and idempotent. Deploys to user-level
+    directory (~/.claude/output-styles/) which is the official Claude Code location
+    for custom output styles.
 
-    Deploys two styles:
-    - claude-mpm-style.md (professional mode)
-    - claude-mpm-teach.md (teaching mode)
+    Deploys all styles:
+    - claude-mpm.md (professional mode)
+    - claude-mpm-teacher.md (teaching mode)
+    - claude-mpm-research.md (research mode - for codebase analysis)
     """
     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/settings/output-styles/
-        user_home = Path.home()
-        output_styles_dir = user_home / ".claude" / "settings" / "output-styles"
-        professional_target = output_styles_dir / "claude-mpm-style.md"
-        teacher_target = output_styles_dir / "claude-mpm-teach.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()
 
-        if professional_up_to_date and teacher_up_to_date:
+        # 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
+
+        # 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
@@ -458,7 +469,7 @@ def _cleanup_orphaned_agents(deploy_target: Path, deployed_agents: list[str]) ->
     return removed_count
 
 
-def sync_remote_agents_on_startup():
+def sync_remote_agents_on_startup(force_sync: bool = False):
     """
     Synchronize agent templates from remote sources on startup.
 
@@ -476,6 +487,9 @@ def sync_remote_agents_on_startup():
     3. Cleanup orphaned agents (ours but no longer deployed) - Phase 3
     4. Cleanup legacy agent cache directories (after sync/deployment) - Phase 4
     5. Log deployment results
+
+    Args:
+        force_sync: Force download even if cache is fresh (bypasses ETag).
     """
     # DEPRECATED: Legacy warning - no-op function, kept for compatibility
     check_legacy_cache()
@@ -486,7 +500,6 @@ def sync_remote_agents_on_startup():
         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
@@ -511,7 +524,7 @@ def sync_remote_agents_on_startup():
                 )
 
         # Phase 1: Sync files from Git sources
-        result = sync_agents_on_startup()
+        result = sync_agents_on_startup(force_refresh=force_sync)
 
         # Only proceed with deployment if sync was enabled and ran
         if result.get("enabled") and result.get("sources_synced", 0) > 0:
@@ -534,305 +547,89 @@ def sync_remote_agents_on_startup():
                 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
+                )
+
+                # Display results with progress bar
+                total_operations = (
+                    len(agent_result.deployed)
+                    + len(agent_result.removed)
+                    + len(agent_result.unchanged)
+                )
 
-                    # Create progress bar with actual configured agent count (not raw file count)
+                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}"
-                        )
+                    for error in errors_to_display:
+                        print(f"   - {error}")
 
-                        # Display errors to user with clear formatting
-                        print("\n⚠️  Agent Deployment Errors:")
+                    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)")
 
-                        # Show first 10 errors to avoid overwhelming output
-                        max_errors_to_show = 10
-                        errors_to_display = deploy_errors[:max_errors_to_show]
-
-                        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
@@ -857,11 +654,11 @@ def sync_remote_agents_on_startup():
         # Cleanup legacy cache even if sync failed
         try:
             cleanup_legacy_agent_cache()
-        except Exception:
+        except Exception:  # nosec B110
             pass  # Ignore cleanup errors
 
 
-def sync_remote_skills_on_startup():
+def sync_remote_skills_on_startup(force_sync: bool = False):
     """
     Synchronize skill templates from remote sources on startup.
 
@@ -879,6 +676,9 @@ def sync_remote_skills_on_startup():
     4. Apply profile filtering if active
     5. Deploy resolved skills to ~/.claude/skills/ - Phase 2 progress bar
     6. Log deployment results with source indication
+
+    Args:
+        force_sync: Force download even if cache is fresh (bypasses ETag).
     """
     try:
         from pathlib import Path
@@ -984,7 +784,7 @@ def sync_remote_skills_on_startup():
 
         # Sync all sources with progress callback
         results = manager.sync_all_sources(
-            force=False, progress_callback=sync_progress.update
+            force=force_sync, progress_callback=sync_progress.update
         )
 
         # Finish sync progress bar with clear breakdown
@@ -1093,7 +893,7 @@ def sync_remote_skills_on_startup():
             # Deploy to project-local directory with cleanup
             deployment_result = manager.deploy_skills(
                 target_dir=Path.cwd() / ".claude" / "skills",
-                force=False,
+                force=force_sync,
                 # 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"
@@ -1358,33 +1158,70 @@ def show_skill_summary():
 
 
 def verify_and_show_pm_skills():
-    """Verify PM skills and display status.
+    """Verify PM skills and display status with enhanced validation.
+
+    WHY: PM skills are CRITICAL for PM agent operation. PM must KNOW if
+    framework knowledge is unavailable at startup. Enhanced validation
+    checks all required skills exist, are not corrupted, and auto-repairs
+    if needed.
 
-    WHY: PM skills are essential for PM agent operation.
-    Shows deployment status and auto-deploys if missing.
+    Shows deployment status:
+    - "✓ PM skills: 8/8 verified" if all required skills are valid
+    - "⚠ PM skills: 2 missing, auto-repairing..." if issues detected
+    - Non-blocking but visible warning if auto-repair fails
     """
     try:
         from pathlib import Path
 
-        from ..services.pm_skills_deployer import PMSkillsDeployerService
+        from ..services.pm_skills_deployer import (
+            REQUIRED_PM_SKILLS,
+            PMSkillsDeployerService,
+        )
 
         deployer = PMSkillsDeployerService()
         project_dir = Path.cwd()
 
-        result = deployer.verify_pm_skills(project_dir)
+        # Verify with auto-repair enabled
+        result = deployer.verify_pm_skills(project_dir, auto_repair=True)
 
         if result.verified:
-            # Show verified status
-            print(f"✓ PM skills: {result.skill_count} verified", flush=True)
+            # Show verified status with count
+            total_required = len(REQUIRED_PM_SKILLS)
+            print(
+                f"✓ PM skills: {total_required}/{total_required} verified", flush=True
+            )
         else:
-            # Auto-deploy if missing
-            print("Deploying PM skills...", end="", flush=True)
-            deploy_result = deployer.deploy_pm_skills(project_dir)
-            if deploy_result.success:
-                total = len(deploy_result.deployed) + len(deploy_result.skipped)
-                print(f"\r✓ PM skills: {total} deployed" + " " * 20, flush=True)
+            # Show warning with details
+            missing_count = len(result.missing_skills)
+            corrupted_count = len(result.corrupted_skills)
+
+            # Build status message
+            issues = []
+            if missing_count > 0:
+                issues.append(f"{missing_count} missing")
+            if corrupted_count > 0:
+                issues.append(f"{corrupted_count} corrupted")
+
+            status = ", ".join(issues)
+
+            # Check if auto-repair was attempted
+            if "Auto-repaired" in result.message:
+                # Auto-repair succeeded
+                total_required = len(REQUIRED_PM_SKILLS)
+                print(
+                    f"✓ PM skills: {total_required}/{total_required} verified (auto-repaired)",
+                    flush=True,
+                )
             else:
-                print("\r⚠ PM skills: deployment failed" + " " * 20, flush=True)
+                # Auto-repair failed or not attempted
+                print(f"⚠ PM skills: {status}", flush=True)
+
+                # Log warnings for debugging
+                from ..core.logger import get_logger
+
+                logger = get_logger("cli")
+                for warning in result.warnings:
+                    logger.warning(f"PM skills: {warning}")
 
     except ImportError:
         # PM skills deployer not available - skip silently
@@ -1419,7 +1256,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
 
@@ -1437,7 +1274,7 @@ def auto_install_chrome_devtools_on_startup():
         # Continue execution - chrome-devtools installation failure shouldn't block startup
 
 
-def run_background_services():
+def run_background_services(force_sync: bool = False):
     """
     Initialize all background services on startup.
 
@@ -1448,6 +1285,9 @@ def run_background_services():
     explicitly requests them via agent-manager commands. This prevents unwanted
     file creation in project .claude/ directories.
     See: SystemInstructionsDeployer and agent_deployment.py line 504-509
+
+    Args:
+        force_sync: Force download even if cache is fresh (bypasses ETag).
     """
     # Sync hooks early to ensure up-to-date configuration
     # RATIONALE: Hooks should be synced before other services to fix stale configs
@@ -1458,7 +1298,9 @@ def run_background_services():
     check_mcp_auto_configuration()
     verify_mcp_gateway_startup()
     check_for_updates_async()
-    sync_remote_agents_on_startup()  # Sync agents from remote sources
+    sync_remote_agents_on_startup(
+        force_sync=force_sync
+    )  # Sync agents from remote sources
     show_agent_summary()  # Display agent counts after deployment
 
     # Skills deployment order (precedence: remote > bundled)
@@ -1467,7 +1309,9 @@ def run_background_services():
     # 3. Discover and link runtime skills (user-added skills)
     # This ensures remote skills take precedence over bundled skills when names conflict
     deploy_bundled_skills()  # Base layer: package-bundled skills
-    sync_remote_skills_on_startup()  # Override layer: Git-based skills (takes precedence)
+    sync_remote_skills_on_startup(
+        force_sync=force_sync
+    )  # Override layer: Git-based skills (takes precedence)
     discover_and_link_runtime_skills()  # Discovery: user-added skills
     show_skill_summary()  # Display skill counts after deployment
     verify_and_show_pm_skills()  # PM skills verification and status
@@ -1667,7 +1511,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()
@@ -1761,7 +1605,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
@@ -1776,7 +1620,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()