claude-mpm 4.21.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

claude_mpm/cli/startup.py

@@ -19,23 +19,34 @@ def setup_early_environment(argv):
     WHY: Some commands need special environment handling before any logging
     or service initialization occurs.
 
+    CRITICAL: Suppress ALL logging by default until setup_mcp_server_logging()
+    configures the user's preference. This prevents early loggers (like
+    ProjectInitializer and service.* loggers) from logging at INFO level before
+    we know the user's logging preference.
+
     Args:
         argv: Command line arguments
 
     Returns:
         Processed argv list
     """
+    import logging
+
     # Disable telemetry and set cleanup flags early
     os.environ.setdefault("DISABLE_TELEMETRY", "1")
     os.environ.setdefault("CLAUDE_MPM_SKIP_CLEANUP", "0")
 
-    # EARLY CHECK: Suppress logging for configure command
+    # 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
+
+    # Process argv
     if argv is None:
         argv = sys.argv[1:]
-    if "configure" in argv or (len(argv) > 0 and argv[0] == "configure"):
-        import logging
 
-        logging.getLogger("claude_mpm").setLevel(logging.WARNING)
+    # EARLY CHECK: Additional suppression for configure command
+    if "configure" in argv or (len(argv) > 0 and argv[0] == "configure"):
         os.environ["CLAUDE_MPM_SKIP_CLEANUP"] = "1"
 
     return argv
@@ -86,7 +97,7 @@ def deploy_bundled_skills():
     WHY: Automatically deploy skills from the bundled/ directory to .claude/skills/
     to ensure skills are available for agents without manual intervention.
 
-    DESIGN DECISION: Deployment happens silently on startup with logging only.
+    DESIGN DECISION: Deployment happens with minimal feedback (checkmark on success).
     Failures are logged but don't block startup to ensure claude-mpm remains
     functional even if skills deployment fails. Respects auto_deploy config setting.
     """
@@ -117,9 +128,13 @@ def deploy_bundled_skills():
         logger = get_logger("cli")
 
         if deployment_result.get("deployed"):
-            logger.info(
-                f"Skills: Deployed {len(deployment_result['deployed'])} skill(s)"
-            )
+            # Show simple feedback for deployed skills
+            deployed_count = len(deployment_result["deployed"])
+            print(f"✓ Bundled skills ready ({deployed_count} deployed)", flush=True)
+            logger.info(f"Skills: Deployed {deployed_count} skill(s)")
+        elif not deployment_result.get("errors"):
+            # No deployment needed, skills already present
+            print("✓ Bundled skills ready", flush=True)
 
         if deployment_result.get("errors"):
             logger.warning(
@@ -142,7 +157,8 @@ def discover_and_link_runtime_skills():
     WHY: Automatically discover and link skills added to .claude/skills/
     without requiring manual configuration.
 
-    DESIGN DECISION: Failures are logged but don't block startup to ensure
+    DESIGN DECISION: Provides simple feedback on completion.
+    Failures are logged but don't block startup to ensure
     claude-mpm remains functional even if skills discovery fails.
     """
     try:
@@ -151,6 +167,8 @@ def discover_and_link_runtime_skills():
         )
 
         discover_skills()
+        # Show simple success feedback
+        print("✓ Runtime skills linked", flush=True)
     except Exception as e:
         # Import logger here to avoid circular imports
         from ..core.logger import get_logger
@@ -160,18 +178,431 @@ def discover_and_link_runtime_skills():
         # Continue execution - skills discovery failure shouldn't block startup
 
 
+def deploy_output_style_on_startup():
+    """
+    Deploy claude-mpm output style to Claude Code on CLI startup.
+
+    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. It uses OutputStyleManager
+    which handles version detection, file deployment, and settings activation.
+    Only works for Claude Code >= 1.0.83.
+    """
+    try:
+        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
+
+        if already_configured:
+            # Show feedback that output style is ready
+            print("✓ Output style configured", flush=True)
+            return
+
+        # Read OUTPUT_STYLE.md content
+        output_style_path = Path(__file__).parent.parent / "agents" / "OUTPUT_STYLE.md"
+
+        if not output_style_path.exists():
+            # No output style file to deploy
+            return
+
+        output_style_content = output_style_path.read_text()
+
+        # Deploy the output style (deploys file and activates it)
+        output_style_manager.deploy_output_style(output_style_content)
+        print("✓ Output style configured", flush=True)
+
+    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}")
+        # Continue execution - output style deployment shouldn't block startup
+
+
+def sync_remote_agents_on_startup():
+    """
+    Synchronize agent templates from remote sources on startup.
+
+    WHY: Ensures agents are up-to-date from remote Git sources (GitHub)
+    without manual intervention. Uses ETag-based caching for efficient
+    updates (95%+ bandwidth reduction).
+
+    DESIGN DECISION: Non-blocking synchronization that doesn't prevent
+    startup if network is unavailable. Failures are logged but don't
+    block startup to ensure claude-mpm remains functional.
+
+    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
+    """
+    try:
+        from ..services.agents.deployment.agent_deployment import AgentDeploymentService
+        from ..services.agents.startup_sync import sync_agents_on_startup
+        from ..utils.progress import ProgressBar
+
+        # Phase 1: Sync files from Git sources
+        result = sync_agents_on_startup()
+
+        # Only proceed with deployment if sync was enabled and ran
+        if result.get("enabled") and result.get("sources_synced", 0) > 0:
+            from ..core.logger import get_logger
+
+            logger = get_logger("cli")
+
+            downloaded = result.get("total_downloaded", 0)
+            cached = result.get("cache_hits", 0)
+            duration = result.get("duration_ms", 0)
+
+            if downloaded > 0 or cached > 0:
+                logger.debug(
+                    f"Agent sync: {downloaded} updated, {cached} cached ({duration}ms)"
+                )
+
+            # Log errors if any
+            errors = result.get("errors", [])
+            if errors:
+                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)
+            try:
+                # Initialize deployment service
+                deployment_service = AgentDeploymentService()
+
+                # Count agents in cache to show accurate progress
+                from pathlib import Path
+
+                cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+                agent_count = 0
+
+                if cache_dir.exists():
+                    # Count MD files in cache (agent markdown files from Git)
+                    # Only check root directory (avoid counting subdirectory duplicates)
+                    # Exclude PM templates and BASE-AGENT - only count deployable agents
+                    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",
+                    }
+                    agent_files = [
+                        f
+                        for f in cache_dir.glob("*.md")
+                        if f.name.lower() not in pm_templates
+                    ]
+                    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"
+                    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
+                    deployed = len(deployment_result.get("deployed", []))
+                    updated = len(deployment_result.get("updated", []))
+                    skipped = len(deployment_result.get("skipped", []))
+                    total_available = deployed + updated + skipped
+
+                    # Show total available agents (deployed + updated + already existing)
+                    if deployed > 0 or updated > 0:
+                        deploy_progress.finish(
+                            f"Complete: {deployed} deployed, {updated} updated, {skipped} already present ({total_available} total)"
+                        )
+                    else:
+                        deploy_progress.finish(
+                            f"Complete: {total_available} agents ready (all up-to-date)"
+                        )
+
+                    # 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:")
+
+                        # 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")
+
+            except Exception as e:
+                # Deployment failure shouldn't block startup
+                from ..core.logger import get_logger
+
+                logger = get_logger("cli")
+                logger.warning(f"Failed to deploy agents from cache: {e}")
+
+    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 sync remote agents: {e}")
+        # Continue execution - agent sync failure shouldn't block startup
+
+
+def sync_remote_skills_on_startup():
+    """
+    Synchronize skill templates from remote sources on startup.
+
+    WHY: Ensures skills are up-to-date from remote Git sources (GitHub)
+    without manual intervention. Provides consistency with agent syncing.
+
+    DESIGN DECISION: Non-blocking synchronization that doesn't prevent
+    startup if network is unavailable. Failures are logged but don't
+    block startup to ensure claude-mpm remains functional.
+
+    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
+    """
+    try:
+        from pathlib import Path
+
+        from ..config.skill_sources import SkillSourceConfiguration
+        from ..services.skills.git_skill_source_manager import GitSkillSourceManager
+        from ..utils.progress import ProgressBar
+
+        config = SkillSourceConfiguration()
+        manager = GitSkillSourceManager(config)
+
+        # Get enabled sources
+        enabled_sources = config.get_enabled_sources()
+        if not enabled_sources:
+            return  # No sources enabled, nothing to sync
+
+        # Phase 1: Sync files from Git sources
+        # We need to discover file count first to show accurate progress
+        # This requires pre-scanning repositories via GitHub API
+        from ..core.logger import get_logger
+
+        logger = get_logger("cli")
+
+        # Discover total file count across all sources
+        total_file_count = 0
+        for source in enabled_sources:
+            try:
+                # Parse GitHub URL
+                url_parts = (
+                    source.url.rstrip("/").replace(".git", "").split("github.com/")
+                )
+                if len(url_parts) == 2:
+                    repo_path = url_parts[1].strip("/")
+                    owner_repo = "/".join(repo_path.split("/")[:2])
+
+                    # Use Tree API to discover all files
+                    all_files = manager._discover_repository_files_via_tree_api(
+                        owner_repo, source.branch
+                    )
+
+                    # Count relevant files (markdown, JSON)
+                    relevant_files = [
+                        f
+                        for f in all_files
+                        if f.endswith(".md") or f.endswith(".json") or f == ".gitignore"
+                    ]
+                    total_file_count += len(relevant_files)
+
+            except Exception as e:
+                logger.debug(f"Failed to discover files for {source.id}: {e}")
+                # Use estimate if discovery fails
+                total_file_count += 150
+
+        # Create progress bar for sync phase with actual file count
+        sync_progress = ProgressBar(
+            total=total_file_count if total_file_count > 0 else 1,
+            prefix="Syncing skills",
+            show_percentage=True,
+            show_counter=True,
+        )
+
+        # Sync all sources with progress callback
+        results = manager.sync_all_sources(
+            force=False, progress_callback=sync_progress.update
+        )
+
+        # Finish sync progress bar with clear breakdown
+        downloaded = results["total_files_updated"]
+        cached = results["total_files_cached"]
+        total_files = downloaded + cached
+
+        if cached > 0:
+            sync_progress.finish(
+                f"Complete: {downloaded} downloaded, {cached} cached ({total_files} total)"
+            )
+        else:
+            # All new downloads (first sync)
+            sync_progress.finish(f"Complete: {downloaded} files downloaded")
+
+        # 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)
+        if results["synced_count"] > 0:
+            # Get all skills to determine deployment count
+            all_skills = manager.get_all_skills()
+            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,
+                )
+
+                # Deploy skills with progress callback
+                # 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,
+                )
+
+                # Finish deployment progress bar
+                deployed = deployment_result.get("deployed_count", 0)
+                skipped = deployment_result.get("skipped_count", 0)
+                total_available = deployed + skipped
+
+                # Show total available skills (deployed + already existing)
+                # This is more user-friendly than just showing newly deployed count
+                if deployed > 0:
+                    deploy_progress.finish(
+                        f"Complete: {deployed} deployed, {skipped} already present ({total_available} total)"
+                    )
+                else:
+                    deploy_progress.finish(
+                        f"Complete: {total_available} skills ready (all up-to-date)"
+                    )
+
+                # Log deployment errors if any
+                from ..core.logger import get_logger
+
+                logger = get_logger("cli")
+
+                errors = deployment_result.get("errors", [])
+                if errors:
+                    logger.warning(
+                        f"Skill deployment completed with {len(errors)} errors: {errors}"
+                    )
+
+                # Log sync errors if any
+                if results["failed_count"] > 0:
+                    logger.warning(
+                        f"Skill sync completed with {results['failed_count']} failures"
+                    )
+
+    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 sync remote skills: {e}")
+        # Continue execution - skill sync failure shouldn't block startup
+
+
 def run_background_services():
     """
     Initialize all background services on startup.
 
     WHY: Centralizes all startup service initialization for cleaner main().
+
+    NOTE: System instructions (PM_INSTRUCTIONS.md, WORKFLOW.md, MEMORY.md) and
+    templates do NOT deploy automatically on startup. They only deploy when user
+    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
     """
     initialize_project_registry()
     check_mcp_auto_configuration()
     verify_mcp_gateway_startup()
     check_for_updates_async()
-    deploy_bundled_skills()
-    discover_and_link_runtime_skills()
+    sync_remote_agents_on_startup()  # Sync agents from remote sources
+
+    # Skills deployment order (precedence: remote > bundled)
+    # 1. Deploy bundled skills first (base layer from package)
+    # 2. Sync and deploy remote skills (Git sources, can override bundled)
+    # 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)
+    discover_and_link_runtime_skills()  # Discovery: user-added skills
+
+    deploy_output_style_on_startup()
 
 
 def setup_mcp_server_logging(args):
@@ -247,12 +678,26 @@ def check_mcp_auto_configuration():
     user consent.
 
     DESIGN DECISION: This is blocking but quick - it only runs once and has
-    a 10-second timeout. We want to catch users on first run for the best
-    experience.
+    a 10-second timeout. Shows progress feedback during checks to avoid
+    appearing frozen.
+
+    OPTIMIZATION: Skip ALL MCP checks for doctor and configure commands to avoid
+    duplicate checks (doctor performs its own comprehensive check, configure
+    allows users to select services).
     """
+    # Skip MCP service checks for the doctor and configure commands
+    # The doctor command performs its own comprehensive MCP service check
+    # The configure command allows users to configure which services to enable
+    # Running both would cause duplicate checks and log messages (9 seconds apart)
+    if len(sys.argv) > 1 and sys.argv[1] in ("doctor", "configure"):
+        return
+
     try:
         from ..services.mcp_gateway.auto_configure import check_and_configure_mcp
 
+        # Show progress feedback - this operation can take 10+ seconds
+        print("Checking MCP configuration...", end="", flush=True)
+
         # This function handles all the logic:
         # - Checks if already configured
         # - Checks if pipx installation
@@ -261,20 +706,19 @@ def check_mcp_auto_configuration():
         # - Configures if user agrees
         check_and_configure_mcp()
 
+        # Clear the "Checking..." message by overwriting with spaces
+        print("\r" + " " * 30 + "\r", end="", flush=True)
+
     except Exception as e:
+        # Clear progress message on error
+        print("\r" + " " * 30 + "\r", end="", flush=True)
+
         # Non-critical - log but don't fail
         from ..core.logger import get_logger
 
         logger = get_logger("cli")
         logger.debug(f"MCP auto-configuration check failed: {e}")
 
-    # Skip MCP service fixes for the doctor and configure commands
-    # The doctor command performs its own comprehensive MCP service check
-    # The configure command allows users to configure which services to enable
-    # Running both would cause duplicate checks and log messages (9 seconds apart)
-    if len(sys.argv) > 1 and sys.argv[1] in ("doctor", "configure"):
-        return
-
     # Also ensure MCP services are properly configured in ~/.claude.json
     # This fixes incorrect paths and adds missing services
     try:
@@ -285,14 +729,16 @@ def check_mcp_auto_configuration():
         mcp_manager = MCPConfigManager()
 
         # Fix any corrupted installations first
-        fix_success, fix_message = mcp_manager.fix_mcp_service_issues()
+        _fix_success, fix_message = mcp_manager.fix_mcp_service_issues()
         if fix_message and "Fixed:" in fix_message:
             logger.info(f"MCP service fixes applied: {fix_message}")
+            print("✓ MCP services fixed", flush=True)
 
         # Ensure all services are configured correctly
-        config_success, config_message = mcp_manager.ensure_mcp_services_configured()
+        _config_success, config_message = mcp_manager.ensure_mcp_services_configured()
         if config_message and "Added MCP services" in config_message:
             logger.info(f"MCP services configured: {config_message}")
+            print("✓ MCP services configured", flush=True)
 
     except Exception as e:
         # Non-critical - log but don't fail
@@ -328,7 +774,6 @@ def verify_mcp_gateway_startup():
 
     try:
         import asyncio
-        import time
 
         from ..core.logger import get_logger
         from ..services.mcp_gateway.core.startup_verification import (
@@ -343,68 +788,14 @@ def verify_mcp_gateway_startup():
 
         # DISABLED: Pre-warming MCP servers can interfere with Claude Code's MCP management
         # This was causing issues with MCP server initialization and stderr handling
-        # def run_pre_warming():
-        #     loop = None
-        #     try:
-        #         start_time = time.time()
-        #         loop = asyncio.new_event_loop()
-        #         asyncio.set_event_loop(loop)
-        #
-        #         # Pre-warm MCP servers (especially vector search)
-        #         logger.info("Pre-warming MCP servers to eliminate startup delay...")
-        #         loop.run_until_complete(pre_warm_mcp_servers())
-        #
-        #         pre_warm_time = time.time() - start_time
-        #         if pre_warm_time > 1.0:
-        #             logger.info(f"MCP servers pre-warmed in {pre_warm_time:.2f}s")
-
-        # Dummy function to maintain structure
-        def run_pre_warming():
-            loop = None
-            try:
-                time.time()
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-
-                # Also run gateway verification if needed
-                if not gateway_configured:
-                    loop.run_until_complete(verify_mcp_gateway_on_startup())
-
-            except Exception as e:
-                # Non-blocking - log but don't fail
-                logger.debug(f"MCP pre-warming error (non-critical): {e}")
-            finally:
-                # Properly clean up event loop to prevent kqueue warnings
-                if loop is not None:
-                    try:
-                        # Cancel all running tasks
-                        pending = asyncio.all_tasks(loop)
-                        for task in pending:
-                            task.cancel()
-                        # Wait for tasks to complete cancellation
-                        if pending:
-                            loop.run_until_complete(
-                                asyncio.gather(*pending, return_exceptions=True)
-                            )
-                    except Exception:
-                        pass  # Ignore cleanup errors
-                    finally:
-                        loop.close()
-                        # Clear the event loop reference to help with cleanup
-                        asyncio.set_event_loop(None)
-
-        # Run pre-warming in background thread
-        import threading
-
-        pre_warm_thread = threading.Thread(target=run_pre_warming, daemon=True)
-        pre_warm_thread.start()
-
-        return
+        # Pre-warming functionality has been removed. Gateway verification only runs
+        # if MCP gateway is not already configured.
 
-        # Run detailed verification in background if not configured
+        # Run gateway verification in background if not configured
         if not gateway_configured:
-            # Note: We don't await this to avoid blocking startup
+
             def run_verification():
+                """Background thread to verify MCP gateway configuration."""
                 loop = None
                 try:
                     loop = asyncio.new_event_loop()
@@ -471,7 +862,7 @@ def check_for_updates_async():
 
     DESIGN DECISION: This is non-blocking and non-critical - failures are logged
     but don't prevent startup. Only runs for pip/pipx/npm installations, skips
-    editable/development installations.
+    editable/development installations. Respects user configuration settings.
     """
 
     def run_update_check():
@@ -480,11 +871,27 @@ def check_for_updates_async():
         try:
             import asyncio
 
+            from ..core.config import Config
             from ..core.logger import get_logger
             from ..services.self_upgrade_service import SelfUpgradeService
 
             logger = get_logger("upgrade_check")
 
+            # Load configuration
+            config = Config()
+            updates_config = config.get("updates", {})
+
+            # Check if update checking is enabled
+            if not updates_config.get("check_enabled", True):
+                logger.debug("Update checking disabled in configuration")
+                return
+
+            # Check frequency setting
+            frequency = updates_config.get("check_frequency", "daily")
+            if frequency == "never":
+                logger.debug("Update checking frequency set to 'never'")
+                return
+
             # Create new event loop for this thread
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
@@ -499,8 +906,16 @@ def check_for_updates_async():
                 logger.debug("Skipping version check for editable installation")
                 return
 
+            # Get configuration values
+            check_claude_code = updates_config.get("check_claude_code", True)
+            auto_upgrade = updates_config.get("auto_upgrade", False)
+
             # Check and prompt for upgrade if available (non-blocking)
-            loop.run_until_complete(upgrade_service.check_and_prompt_on_startup())
+            loop.run_until_complete(
+                upgrade_service.check_and_prompt_on_startup(
+                    auto_upgrade=auto_upgrade, check_claude_code=check_claude_code
+                )
+            )
 
         except Exception as e:
             # Non-critical - log but don't fail startup