claude-mpm 5.1.8__py3-none-any.whl → 5.4.22__py3-none-any.whl

claude_mpm/cli/startup.py

@@ -14,6 +14,52 @@ import warnings
 from pathlib import Path
 
 
+def sync_hooks_on_startup(quiet: bool = False) -> bool:
+    """Ensure hooks are up-to-date on startup.
+
+    WHY: Users can have stale hook configurations in settings.json that cause errors.
+    Reinstalling hooks ensures the hook format matches the current code.
+
+    DESIGN DECISION: Shows brief status message on success for user awareness.
+    Failures are logged but don't prevent startup to ensure claude-mpm remains functional.
+
+    Args:
+        quiet: If True, suppress all output (used internally)
+
+    Returns:
+        bool: True if hooks were synced successfully, False otherwise
+    """
+    try:
+        from ..hooks.claude_hooks.installer import HookInstaller
+
+        installer = HookInstaller()
+
+        # Show brief status (hooks sync is fast)
+        if not quiet:
+            print("Syncing Claude Code hooks...", end=" ", flush=True)
+
+        # Reinstall hooks (force=True ensures update)
+        success = installer.install_hooks(force=True)
+
+        if not quiet:
+            if success:
+                print("✓")
+            else:
+                print("(skipped)")
+
+        return success
+
+    except Exception as e:
+        if not quiet:
+            print("(error)")
+        # Log but don't fail startup
+        from ..core.logger import get_logger
+
+        logger = get_logger("startup")
+        logger.warning(f"Hook sync failed (non-fatal): {e}")
+        return False
+
+
 def check_legacy_cache() -> None:
     """Check for legacy cache/agents/ directory and warn user.
 
@@ -221,78 +267,157 @@ def discover_and_link_runtime_skills():
 
 def deploy_output_style_on_startup():
     """
-    Deploy claude-mpm output style to Claude Code on CLI startup.
+    Deploy claude-mpm output styles to PROJECT-LEVEL directory on CLI startup.
+
+    WHY: Automatically deploy output styles to ensure consistent, professional
+    communication without emojis and exclamation points. Styles are project-specific
+    to allow different projects to have different communication styles.
 
-    WHY: Automatically deploy and activate the output style to ensure consistent,
-    professional communication without emojis and exclamation points. This ensures
-    the style is available even when using Claude Code directly (not via chat command).
+    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. It uses OutputStyleManager
-    which handles version detection, file deployment, and settings activation.
-    Only works for Claude Code >= 1.0.83.
+    Deploys two styles:
+    - claude-mpm-style.md (professional mode)
+    - claude-mpm-teacher.md (teaching mode)
     """
     try:
+        import shutil
         from pathlib import Path
 
-        from ..core.output_style_manager import OutputStyleManager
-
-        # Create OutputStyleManager instance
-        output_style_manager = OutputStyleManager()
-
-        # Check if Claude Code supports output styles
-        if not output_style_manager.supports_output_styles():
-            # Silently skip - version too old or Claude not installed
-            return
-
-        # Check if already deployed and active
-        settings_file = Path.home() / ".claude" / "settings.json"
-        output_style_file = Path.home() / ".claude" / "output-styles" / "claude-mpm.md"
-
-        already_configured = False
-        if settings_file.exists() and output_style_file.exists():
-            try:
-                import json
-
-                # Check if file has content (bug fix: was skipping empty files)
-                if output_style_file.stat().st_size == 0:
-                    # File is empty, need to redeploy with content
-                    pass  # Fall through to deployment below
-                else:
-                    # File has content, check if already active
-                    settings = json.loads(settings_file.read_text())
-                    if settings.get("activeOutputStyle") == "claude-mpm":
-                        # Already deployed and active with content
-                        already_configured = True
-            except Exception:
-                pass  # Continue with deployment if we can't read settings
+        # 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 (PROJECT-LEVEL, not user-level)
+        project_dir = Path.cwd()
+        output_styles_dir = project_dir / ".claude" / "settings" / "output-styles"
+        professional_target = output_styles_dir / "claude-mpm-style.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 (both files exist and have content)
+        already_deployed = (
+            professional_target.exists()
+            and teacher_target.exists()
+            and professional_target.stat().st_size > 0
+            and teacher_target.stat().st_size > 0
+        )
 
-        if already_configured:
-            # Show feedback that output style is ready
-            print("✓ Output style configured", flush=True)
+        if already_deployed:
+            # Show feedback that output styles are ready
+            print("✓ Output styles ready", flush=True)
             return
 
-        # Read OUTPUT_STYLE.md content
-        output_style_path = Path(__file__).parent.parent / "agents" / "OUTPUT_STYLE.md"
+        # Deploy both styles
+        deployed_count = 0
+        if professional_source.exists():
+            shutil.copy2(professional_source, professional_target)
+            deployed_count += 1
 
-        if not output_style_path.exists():
-            # No output style file to deploy
-            return
+        if teacher_source.exists():
+            shutil.copy2(teacher_source, teacher_target)
+            deployed_count += 1
 
-        output_style_content = output_style_path.read_text()
+        if deployed_count > 0:
+            print(f"✓ Output styles deployed ({deployed_count} styles)", flush=True)
+        else:
+            # Source files missing - log but don't fail
+            from ..core.logger import get_logger
 
-        # Deploy the output style (deploys file and activates it)
-        output_style_manager.deploy_output_style(output_style_content)
-        print("✓ Output style configured", flush=True)
+            logger = get_logger("cli")
+            logger.debug("Output style source files not found")
 
     except Exception as e:
         # Non-critical - log but don't fail startup
         from ..core.logger import get_logger
 
         logger = get_logger("cli")
-        logger.debug(f"Failed to deploy output style: {e}")
+        logger.debug(f"Failed to deploy output styles: {e}")
         # Continue execution - output style deployment shouldn't block startup
 
 
+def _cleanup_orphaned_agents(deploy_target: Path, deployed_agents: list[str]) -> int:
+    """Remove agents that are managed by claude-mpm but no longer deployed.
+
+    WHY: When agent configurations change, old agents should be removed to avoid
+    confusion and stale agent references. Only removes claude-mpm managed agents,
+    leaving user-created agents untouched.
+
+    SAFETY: Only removes files with claude-mpm ownership markers in frontmatter.
+    Files without frontmatter or without ownership indicators are preserved.
+
+    Args:
+        deploy_target: Path to .claude/agents/ directory
+        deployed_agents: List of agent filenames that should remain
+
+    Returns:
+        Number of agents removed
+    """
+    import re
+
+    import yaml
+
+    from ..core.logger import get_logger
+
+    logger = get_logger("cli")
+    removed_count = 0
+    deployed_set = set(deployed_agents)
+
+    if not deploy_target.exists():
+        return 0
+
+    # Scan all .md files in agents directory
+    for agent_file in deploy_target.glob("*.md"):
+        # Skip hidden files
+        if agent_file.name.startswith("."):
+            continue
+
+        # Skip if this agent should remain deployed
+        if agent_file.name in deployed_set:
+            continue
+
+        # Check if this is a claude-mpm managed agent
+        try:
+            content = agent_file.read_text(encoding="utf-8")
+
+            # Parse YAML frontmatter
+            if content.startswith("---"):
+                match = re.match(r"^---\n(.*?)\n---", content, re.DOTALL)
+                if match:
+                    frontmatter = yaml.safe_load(match.group(1))
+
+                    # Check ownership indicators
+                    is_ours = False
+                    if frontmatter:
+                        author = frontmatter.get("author", "")
+                        source = frontmatter.get("source", "")
+                        agent_id = frontmatter.get("agent_id", "")
+
+                        # It's ours if it has any of these markers
+                        if (
+                            "Claude MPM" in str(author)
+                            or source == "remote"
+                            or agent_id
+                        ):
+                            is_ours = True
+
+                    if is_ours:
+                        # Safe to remove - it's our agent but not deployed
+                        agent_file.unlink()
+                        removed_count += 1
+                        logger.info(f"Removed orphaned agent: {agent_file.name}")
+
+        except Exception as e:
+            logger.debug(f"Could not check agent {agent_file.name}: {e}")
+            # Don't remove if we can't verify ownership
+
+    return removed_count
+
+
 def sync_remote_agents_on_startup():
     """
     Synchronize agent templates from remote sources on startup.
@@ -308,7 +433,8 @@ def sync_remote_agents_on_startup():
     Workflow:
     1. Sync all enabled Git sources (download/cache files) - Phase 1 progress bar
     2. Deploy agents to ~/.claude/agents/ - Phase 2 progress bar
-    3. Log deployment results
+    3. Cleanup orphaned agents (ours but no longer deployed) - Phase 3
+    4. Log deployment results
     """
     # Check for legacy cache and warn user if found
     check_legacy_cache()
@@ -386,6 +512,7 @@ def sync_remote_agents_on_startup():
                     # 1. Must have "/agents/" in path (from git repos)
                     # 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
@@ -396,44 +523,98 @@ def sync_remote_agents_on_startup():
                             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:
-                    # Create progress bar for deployment phase
-                    deploy_progress = ProgressBar(
-                        total=agent_count,
-                        prefix="Deploying agents",
-                        show_percentage=True,
-                        show_counter=True,
-                    )
-
-                    # Deploy agents with progress callback
-                    deploy_target = Path.home() / ".claude" / "agents"
+                    # 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
                     )
 
-                    # Update progress bar (single increment since deploy_agents is batch)
-                    deploy_progress.update(agent_count)
-
-                    # Finish deployment progress bar
+                    # 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_available = deployed + updated + 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
+
+                    # Create progress bar with actual configured agent count (not raw file count)
+                    deploy_progress = ProgressBar(
+                        total=total_configured if total_configured > 0 else 1,
+                        prefix="Deploying agents",
+                        show_percentage=True,
+                        show_counter=True,
+                    )
 
-                    # Show total available agents (deployed + updated + already existing)
+                    # 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
+                    )
+
+                    # Show total configured agents (deployed + updated + already existing)
+                    # Include repo 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} in repo)"
+                            )
+                        else:
+                            deploy_progress.finish(
+                                f"Complete: {deployed} new, {updated} updated, {skipped} unchanged "
+                                f"({total_configured} configured from {agent_count} in repo)"
+                            )
+                    elif removed > 0:
                         deploy_progress.finish(
-                            f"Complete: {deployed} deployed, {updated} updated, {skipped} already present ({total_available} total)"
+                            f"Complete: {total_configured} agents ready - all unchanged, "
+                            f"{removed} removed ({agent_count} available in repo)"
                         )
                     else:
                         deploy_progress.finish(
-                            f"Complete: {total_available} agents ready (all up-to-date)"
+                            f"Complete: {total_configured} agents ready - all unchanged "
+                            f"({agent_count} available in repo)"
                         )
 
                     # Display deployment errors to user (not just logs)
@@ -496,14 +677,21 @@ def sync_remote_skills_on_startup():
 
     Workflow:
     1. Sync all enabled Git sources (download/cache files) - Phase 1 progress bar
-    2. Deploy skills to ~/.claude/skills/ with flat structure - Phase 2 progress bar
-    3. Log deployment results
+    2. Scan deployed agents for skill requirements → save to configuration.yaml
+    3. Resolve which skills to deploy (user_defined vs agent_referenced)
+    4. Deploy resolved skills to ~/.claude/skills/ - Phase 2 progress bar
+    5. Log deployment results with source indication
     """
     try:
         from pathlib import Path
 
         from ..config.skill_sources import SkillSourceConfiguration
         from ..services.skills.git_skill_source_manager import GitSkillSourceManager
+        from ..services.skills.selective_skill_deployer import (
+            get_required_skills_from_agents,
+            get_skills_to_deploy,
+            save_agent_skills_to_config,
+        )
         from ..utils.progress import ProgressBar
 
         config = SkillSourceConfiguration()
@@ -523,6 +711,8 @@ def sync_remote_skills_on_startup():
 
         # Discover total file count across all sources
         total_file_count = 0
+        total_skill_dirs = 0  # Count actual skill directories (folders with SKILL.md)
+
         for source in enabled_sources:
             try:
                 # Parse GitHub URL
@@ -546,15 +736,26 @@ def sync_remote_skills_on_startup():
                     ]
                     total_file_count += len(relevant_files)
 
+                    # Count skill directories (unique directories containing SKILL.md)
+                    skill_dirs = set()
+                    for f in all_files:
+                        if f.endswith("/SKILL.md"):
+                            # Extract directory path
+                            skill_dir = "/".join(f.split("/")[:-1])
+                            skill_dirs.add(skill_dir)
+                    total_skill_dirs += len(skill_dirs)
+
             except Exception as e:
                 logger.debug(f"Failed to discover files for {source.id}: {e}")
                 # Use estimate if discovery fails
                 total_file_count += 150
+                total_skill_dirs += 50  # Estimate ~50 skills
 
         # Create progress bar for sync phase with actual file count
+        # Note: We sync files (md, json, etc.), but will deploy skill directories
         sync_progress = ProgressBar(
             total=total_file_count if total_file_count > 0 else 1,
-            prefix="Syncing skills",
+            prefix="Syncing skill files",
             show_percentage=True,
             show_counter=True,
         )
@@ -571,51 +772,100 @@ def sync_remote_skills_on_startup():
 
         if cached > 0:
             sync_progress.finish(
-                f"Complete: {downloaded} downloaded, {cached} cached ({total_files} total)"
+                f"Complete: {downloaded} downloaded, {cached} cached ({total_files} files, {total_skill_dirs} skills)"
             )
         else:
             # All new downloads (first sync)
-            sync_progress.finish(f"Complete: {downloaded} files downloaded")
+            sync_progress.finish(
+                f"Complete: {downloaded} files downloaded ({total_skill_dirs} skills)"
+            )
 
-        # Phase 2: Deploy skills to ~/.claude/skills/
-        # This flattens nested Git structure (e.g., collaboration/parallel-agents/SKILL.md)
-        # into flat deployment (e.g., collaboration-dispatching-parallel-agents/SKILL.md)
+        # Phase 2: Scan agents and save to configuration.yaml
+        # This step populates configuration.yaml with agent-referenced skills
         if results["synced_count"] > 0:
-            # Get all skills to determine deployment count
+            agents_dir = Path.cwd() / ".claude" / "agents"
+
+            # Scan agents for skill requirements
+            agent_skills = get_required_skills_from_agents(agents_dir)
+
+            # Save to project-level configuration.yaml
+            project_config_path = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+            save_agent_skills_to_config(list(agent_skills), project_config_path)
+
+            # Phase 3: Resolve which skills to deploy (user_defined or agent_referenced)
+            skills_to_deploy, skill_source = get_skills_to_deploy(project_config_path)
+
+            # Get all skills to determine counts
             all_skills = manager.get_all_skills()
-            skill_count = len(all_skills)
+            total_skill_count = len(all_skills)
 
-            if skill_count > 0:
-                # Create progress bar for deployment phase
-                deploy_progress = ProgressBar(
-                    total=skill_count,
-                    prefix="Deploying skill directories",
-                    show_percentage=True,
-                    show_counter=True,
-                )
+            # Determine skill count based on resolution
+            skill_count = (
+                len(skills_to_deploy) if skills_to_deploy else total_skill_count
+            )
 
-                # Deploy skills with progress callback
+            if skill_count > 0:
+                # Deploy skills with resolved filter
                 # Deploy to project directory (like agents), not user directory
                 deployment_result = manager.deploy_skills(
                     target_dir=Path.cwd() / ".claude" / "skills",
                     force=False,
-                    progress_callback=deploy_progress.update,
+                    skill_filter=set(skills_to_deploy) if skills_to_deploy else None,
                 )
 
-                # Finish deployment progress bar
+                # Get actual counts from deployment result
                 deployed = deployment_result.get("deployed_count", 0)
                 skipped = deployment_result.get("skipped_count", 0)
+                filtered = deployment_result.get("filtered_count", 0)
                 total_available = deployed + skipped
 
+                # Only show progress bar if there are skills to deploy
+                if total_available > 0:
+                    deploy_progress = ProgressBar(
+                        total=total_available,
+                        prefix="Deploying skill directories",
+                        show_percentage=True,
+                        show_counter=True,
+                    )
+                    # Update progress bar to completion
+                    deploy_progress.update(total_available)
+                else:
+                    # No skills to deploy - create dummy progress for message only
+                    deploy_progress = ProgressBar(
+                        total=1,
+                        prefix="Deploying skill directories",
+                        show_percentage=False,
+                        show_counter=False,
+                    )
+                    deploy_progress.update(1)
+
                 # Show total available skills (deployed + already existing)
-                # This is more user-friendly than just showing newly deployed count
+                # Include source indication (user_defined vs agent_referenced)
+                # Note: total_skill_count is from the repo, total_available is what's deployed/needed
+                source_label = (
+                    "user override" if skill_source == "user_defined" else "from agents"
+                )
+
                 if deployed > 0:
+                    if filtered > 0:
+                        deploy_progress.finish(
+                            f"Complete: {deployed} new, {skipped} unchanged "
+                            f"({total_available} {source_label}, {filtered} available in repo)"
+                        )
+                    else:
+                        deploy_progress.finish(
+                            f"Complete: {deployed} new, {skipped} unchanged "
+                            f"({total_available} skills {source_label} from {total_skill_count} in repo)"
+                        )
+                elif filtered > 0:
+                    # Skills filtered means agents require fewer skills than available
                     deploy_progress.finish(
-                        f"Complete: {deployed} deployed, {skipped} already present ({total_available} total)"
+                        f"No skills needed ({source_label}, {total_skill_count} available in repo)"
                     )
                 else:
                     deploy_progress.finish(
-                        f"Complete: {total_available} skills ready (all up-to-date)"
+                        f"Complete: {total_available} skills {source_label} "
+                        f"({total_skill_count} available in repo)"
                     )
 
                 # Log deployment errors if any
@@ -644,6 +894,202 @@ def sync_remote_skills_on_startup():
         # Continue execution - skill sync failure shouldn't block startup
 
 
+def show_agent_summary():
+    """
+    Display agent availability summary on startup.
+
+    WHY: Users should see at a glance how many agents are available and installed
+    without having to run /mpm-agents list.
+
+    DESIGN DECISION: Fast, non-blocking check that counts agents from the deployment
+    directory. Shows simple "X installed / Y available" format. Failures are silent
+    to avoid blocking startup.
+    """
+    try:
+        from pathlib import Path
+
+        # Count deployed agents (installed)
+        deploy_target = Path.cwd() / ".claude" / "agents"
+        installed_count = 0
+        if deploy_target.exists():
+            # Count .md files, excluding README and other docs
+            agent_files = [
+                f
+                for f in deploy_target.glob("*.md")
+                if not f.name.startswith(("README", "INSTRUCTIONS", "."))
+            ]
+            installed_count = len(agent_files)
+
+        # Count available agents in cache (from remote sources)
+        cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+        available_count = 0
+        if cache_dir.exists():
+            # Use same filtering logic as agent deployment (lines 486-533 in startup.py)
+            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",
+            }
+            doc_files = {
+                "readme.md",
+                "changelog.md",
+                "contributing.md",
+                "implementation-summary.md",
+                "reorganization-plan.md",
+                "auto-deploy-index.md",
+            }
+
+            # Find all markdown files in agents/ directories
+            all_md_files = list(cache_dir.rglob("*.md"))
+            agent_files = [
+                f
+                for f in all_md_files
+                if (
+                    "/agents/" in str(f)
+                    and f.name.lower() not in pm_templates
+                    and f.name.lower() not in doc_files
+                    and f.name.lower() != "base-agent.md"
+                    and not any(
+                        part in str(f).split("/")
+                        for part in ["dist", "build", ".cache"]
+                    )
+                )
+            ]
+            available_count = len(agent_files)
+
+        # Display summary if we have agents
+        if installed_count > 0 or available_count > 0:
+            print(
+                f"✓ Agents: {installed_count} installed / {available_count} available",
+                flush=True,
+            )
+
+    except Exception as e:
+        # Silent failure - agent summary is informational only
+        from ..core.logger import get_logger
+
+        logger = get_logger("cli")
+        logger.debug(f"Failed to generate agent summary: {e}")
+
+
+def show_skill_summary():
+    """
+    Display skill availability summary on startup.
+
+    WHY: Users should see at a glance how many skills are deployed and available
+    from collections, similar to the agent summary.
+
+    DESIGN DECISION: Fast, non-blocking check that counts skills from deployment
+    directory and collection repos. Shows "X installed (Y available)" format.
+    Failures are silent to avoid blocking startup.
+    """
+    try:
+        from pathlib import Path
+
+        # Count deployed skills (installed)
+        skills_dir = Path.home() / ".claude" / "skills"
+        installed_count = 0
+        if skills_dir.exists():
+            # Count directories with SKILL.md (excludes collection repos)
+            # Exclude collection directories (obra-superpowers, etc.)
+            skill_dirs = [
+                d
+                for d in skills_dir.iterdir()
+                if d.is_dir()
+                and (d / "SKILL.md").exists()
+                and not (d / ".git").exists()  # Exclude collection repos
+            ]
+            installed_count = len(skill_dirs)
+
+        # Count available skills in collections
+        available_count = 0
+        if skills_dir.exists():
+            # Scan all collection directories (those with .git)
+            for collection_dir in skills_dir.iterdir():
+                if (
+                    not collection_dir.is_dir()
+                    or not (collection_dir / ".git").exists()
+                ):
+                    continue
+
+                # Count skill directories in this collection
+                # Skills can be nested in: skills/category/skill-name/SKILL.md
+                # or in flat structure: skill-name/SKILL.md
+                for root, dirs, files in os.walk(collection_dir):
+                    if "SKILL.md" in files:
+                        # Exclude build artifacts and hidden directories (within the collection)
+                        # Get relative path from collection_dir to avoid excluding based on .claude parent
+                        root_path = Path(root)
+                        relative_parts = root_path.relative_to(collection_dir).parts
+                        if not any(
+                            part.startswith(".")
+                            or part in ["dist", "build", "__pycache__"]
+                            for part in relative_parts
+                        ):
+                            available_count += 1
+
+        # Display summary if we have skills
+        if installed_count > 0 or available_count > 0:
+            print(
+                f"✓ Skills: {installed_count} installed ({available_count} available)",
+                flush=True,
+            )
+
+    except Exception as e:
+        # Silent failure - skill summary is informational only
+        from ..core.logger import get_logger
+
+        logger = get_logger("cli")
+        logger.debug(f"Failed to generate skill summary: {e}")
+
+
+def auto_install_chrome_devtools_on_startup():
+    """
+    Automatically install chrome-devtools-mcp on startup if enabled.
+
+    WHY: Browser automation capabilities should be available out-of-the-box without
+    manual MCP server configuration. chrome-devtools-mcp provides powerful browser
+    interaction tools for Claude Code.
+
+    DESIGN DECISION: Non-blocking installation that doesn't prevent startup if it fails.
+    Respects user configuration setting (enabled by default). Only installs if not
+    already configured in Claude.
+    """
+    try:
+        # Check if auto-install is disabled in config
+        from ..config.config_loader import ConfigLoader
+
+        config_loader = ConfigLoader()
+        try:
+            config = config_loader.load_main_config()
+            chrome_devtools_config = config.get("chrome_devtools", {})
+            if not chrome_devtools_config.get("auto_install", True):
+                # Auto-install disabled, skip silently
+                return
+        except Exception:
+            # If config loading fails, assume auto-install is enabled (default)
+            pass
+
+        # Import and run chrome-devtools installation
+        from ..cli.chrome_devtools_installer import auto_install_chrome_devtools
+
+        auto_install_chrome_devtools(quiet=False)
+
+    except Exception as e:
+        # Import logger here to avoid circular imports
+        from ..core.logger import get_logger
+
+        logger = get_logger("cli")
+        logger.debug(f"Failed to auto-install chrome-devtools-mcp: {e}")
+        # Continue execution - chrome-devtools installation failure shouldn't block startup
+
+
 def run_background_services():
     """
     Initialize all background services on startup.
@@ -656,11 +1102,17 @@ def run_background_services():
     file creation in project .claude/ directories.
     See: SystemInstructionsDeployer and agent_deployment.py line 504-509
     """
+    # Sync hooks early to ensure up-to-date configuration
+    # RATIONALE: Hooks should be synced before other services to fix stale configs
+    # This is fast (<100ms) and non-blocking, so it doesn't delay startup
+    sync_hooks_on_startup()  # Shows "Syncing Claude Code hooks... ✓"
+
     initialize_project_registry()
     check_mcp_auto_configuration()
     verify_mcp_gateway_startup()
     check_for_updates_async()
     sync_remote_agents_on_startup()  # Sync agents from remote sources
+    show_agent_summary()  # Display agent counts after deployment
 
     # Skills deployment order (precedence: remote > bundled)
     # 1. Deploy bundled skills first (base layer from package)
@@ -670,9 +1122,13 @@ def run_background_services():
     deploy_bundled_skills()  # Base layer: package-bundled skills
     sync_remote_skills_on_startup()  # Override layer: Git-based skills (takes precedence)
     discover_and_link_runtime_skills()  # Discovery: user-added skills
+    show_skill_summary()  # Display skill counts after deployment
 
     deploy_output_style_on_startup()
 
+    # Auto-install chrome-devtools-mcp for browser automation
+    auto_install_chrome_devtools_on_startup()
+
 
 def setup_mcp_server_logging(args):
     """