claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/cli/commands/configure.py

@@ -12,148 +12,30 @@ DESIGN DECISIONS:
 """
 
 import json
-import os
-import sys
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from rich.box import ROUNDED
-from rich.columns import Columns
 from rich.console import Console
-from rich.panel import Panel
 from rich.prompt import Confirm, Prompt
-from rich.syntax import Syntax
-from rich.table import Table
 from rich.text import Text
 
+from ...core.config import Config
 from ...services.version_service import VersionService
 from ...utils.console import console as default_console
 from ..shared import BaseCommand, CommandResult
-
-
-class AgentConfig:
-    """Simple agent configuration model."""
-
-    def __init__(
-        self, name: str, description: str = "", dependencies: List[str] = None
-    ):
-        self.name = name
-        self.description = description
-        self.dependencies = dependencies or []
-
-
-class SimpleAgentManager:
-    """Simple agent state management that discovers real agents from templates."""
-
-    def __init__(self, config_dir: Path):
-        self.config_dir = config_dir
-        self.config_file = config_dir / "agent_states.json"
-        self.config_dir.mkdir(parents=True, exist_ok=True)
-        self._load_states()
-        # Path to agent templates directory
-        self.templates_dir = (
-            Path(__file__).parent.parent.parent / "agents" / "templates"
-        )
-
-    def _load_states(self):
-        """Load agent states from file."""
-        if self.config_file.exists():
-            with open(self.config_file) as f:
-                self.states = json.load(f)
-        else:
-            self.states = {}
-
-    def _save_states(self):
-        """Save agent states to file."""
-        with open(self.config_file, "w") as f:
-            json.dump(self.states, f, indent=2)
-
-    def is_agent_enabled(self, agent_name: str) -> bool:
-        """Check if an agent is enabled."""
-        return self.states.get(agent_name, {}).get("enabled", True)
-
-    def set_agent_enabled(self, agent_name: str, enabled: bool):
-        """Set agent enabled state."""
-        if agent_name not in self.states:
-            self.states[agent_name] = {}
-        self.states[agent_name]["enabled"] = enabled
-        self._save_states()
-
-    def discover_agents(self) -> List[AgentConfig]:
-        """Discover available agents from template JSON files."""
-        agents = []
-
-        # Scan templates directory for JSON files
-        if not self.templates_dir.exists():
-            # Fallback to a minimal set if templates dir doesn't exist
-            return [
-                AgentConfig("engineer", "Engineering agent (templates not found)", []),
-                AgentConfig("research", "Research agent (templates not found)", []),
-            ]
-
-        try:
-            # Read all JSON template files
-            for template_file in sorted(self.templates_dir.glob("*.json")):
-                # Skip backup files
-                if "backup" in template_file.name.lower():
-                    continue
-
-                try:
-                    with open(template_file) as f:
-                        template_data = json.load(f)
-
-                    # Extract agent information from template
-                    agent_id = template_data.get("agent_id", template_file.stem)
-
-                    # Get metadata for display info
-                    metadata = template_data.get("metadata", {})
-                    name = metadata.get("name", agent_id)
-                    description = metadata.get(
-                        "description", "No description available"
-                    )
-
-                    # Extract capabilities/tools as dependencies for display
-                    capabilities = template_data.get("capabilities", {})
-                    tools = capabilities.get("tools", [])
-                    # Show first few tools as "dependencies" for UI purposes
-                    display_tools = tools[:3] if len(tools) > 3 else tools
-
-                    # Normalize agent ID (remove -agent suffix if present, replace underscores)
-                    normalized_id = agent_id.replace("-agent", "").replace("_", "-")
-
-                    agents.append(
-                        AgentConfig(
-                            name=normalized_id,
-                            description=(
-                                description[:80] + "..."
-                                if len(description) > 80
-                                else description
-                            ),
-                            dependencies=display_tools,
-                        )
-                    )
-
-                except (json.JSONDecodeError, KeyError):
-                    # Skip malformed templates
-                    continue
-
-        except Exception as e:
-            # If there's an error reading templates, return a minimal set
-            return [
-                AgentConfig("engineer", f"Error loading templates: {e!s}", []),
-                AgentConfig("research", "Research agent", []),
-            ]
-
-        # Sort agents by name for consistent display
-        agents.sort(key=lambda a: a.name)
-
-        return (
-            agents
-            if agents
-            else [
-                AgentConfig("engineer", "No agents found in templates", []),
-            ]
-        )
+from .agent_state_manager import SimpleAgentManager
+from .configure_agent_display import AgentDisplay
+from .configure_behavior_manager import BehaviorManager
+from .configure_hook_manager import HookManager
+from .configure_models import AgentConfig
+from .configure_navigation import ConfigNavigation
+from .configure_persistence import ConfigPersistence
+from .configure_startup_manager import StartupManager
+from .configure_template_editor import TemplateEditor
+from .configure_validators import (
+    parse_id_selection,
+    validate_args as validate_configure_args,
+)
 
 
 class ConfigureCommand(BaseCommand):
@@ -166,24 +48,88 @@ class ConfigureCommand(BaseCommand):
         self.current_scope = "project"
         self.project_dir = Path.cwd()
         self.agent_manager = None
+        self.hook_manager = HookManager(self.console)
+        self.behavior_manager = None  # Initialized when scope is set
+        self._agent_display = None  # Lazy-initialized
+        self._persistence = None  # Lazy-initialized
+        self._navigation = None  # Lazy-initialized
+        self._template_editor = None  # Lazy-initialized
+        self._startup_manager = None  # Lazy-initialized
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
-        # Check for conflicting direct navigation options
-        nav_options = [
-            getattr(args, "agents", False),
-            getattr(args, "templates", False),
-            getattr(args, "behaviors", False),
-            getattr(args, "version_info", False),
-        ]
-        if sum(nav_options) > 1:
-            return "Only one direct navigation option can be specified at a time"
-
-        # Check for conflicting non-interactive options
-        if getattr(args, "enable_agent", None) and getattr(args, "disable_agent", None):
-            return "Cannot enable and disable agents at the same time"
-
-        return None
+        return validate_configure_args(args)
+
+    @property
+    def agent_display(self) -> AgentDisplay:
+        """Lazy-initialize agent display handler."""
+        if self._agent_display is None:
+            if self.agent_manager is None:
+                raise RuntimeError(
+                    "agent_manager must be initialized before agent_display"
+                )
+            self._agent_display = AgentDisplay(
+                self.console,
+                self.agent_manager,
+                self._get_agent_template_path,
+                self._display_header,
+            )
+        return self._agent_display
+
+    @property
+    def persistence(self) -> ConfigPersistence:
+        """Lazy-initialize persistence handler."""
+        if self._persistence is None:
+            # Note: agent_manager might be None for version_info calls
+            self._persistence = ConfigPersistence(
+                self.console,
+                self.version_service,
+                self.agent_manager,  # Can be None for version operations
+                self._get_agent_template_path,
+                self._display_header,
+                self.current_scope,
+                self.project_dir,
+            )
+        return self._persistence
+
+    @property
+    def navigation(self) -> ConfigNavigation:
+        """Lazy-initialize navigation handler."""
+        if self._navigation is None:
+            self._navigation = ConfigNavigation(self.console, self.project_dir)
+            # Sync scope from main command
+            self._navigation.current_scope = self.current_scope
+        return self._navigation
+
+    @property
+    def template_editor(self) -> TemplateEditor:
+        """Lazy-initialize template editor."""
+        if self._template_editor is None:
+            if self.agent_manager is None:
+                raise RuntimeError(
+                    "agent_manager must be initialized before template_editor"
+                )
+            self._template_editor = TemplateEditor(
+                self.console, self.agent_manager, self.current_scope, self.project_dir
+            )
+        return self._template_editor
+
+    @property
+    def startup_manager(self) -> StartupManager:
+        """Lazy-initialize startup manager."""
+        if self._startup_manager is None:
+            if self.agent_manager is None:
+                raise RuntimeError(
+                    "agent_manager must be initialized before startup_manager"
+                )
+            self._startup_manager = StartupManager(
+                self.agent_manager,
+                self.console,
+                self.current_scope,
+                self.project_dir,
+                self._display_header,
+            )
+        return self._startup_manager
 
     def run(self, args) -> CommandResult:
         """Execute the configure command."""
@@ -192,12 +138,15 @@ class ConfigureCommand(BaseCommand):
         if getattr(args, "project_dir", None):
             self.project_dir = Path(args.project_dir)
 
-        # Initialize agent manager with appropriate config directory
+        # Initialize agent manager and behavior manager with appropriate config directory
         if self.current_scope == "project":
             config_dir = self.project_dir / ".claude-mpm"
         else:
             config_dir = Path.home() / ".claude-mpm"
         self.agent_manager = SimpleAgentManager(config_dir)
+        self.behavior_manager = BehaviorManager(
+            config_dir, self.current_scope, self.console
+        )
 
         # Disable colors if requested
         if getattr(args, "no_colors", False):
@@ -222,6 +171,16 @@ class ConfigureCommand(BaseCommand):
         if getattr(args, "version_info", False):
             return self._show_version_info()
 
+        # Handle hook installation
+        if getattr(args, "install_hooks", False):
+            return self._install_hooks(force=getattr(args, "force", False))
+
+        if getattr(args, "verify_hooks", False):
+            return self._verify_hooks()
+
+        if getattr(args, "uninstall_hooks", False):
+            return self._uninstall_hooks()
+
         # Handle direct navigation options
         if getattr(args, "agents", False):
             return self._run_agent_management()
@@ -232,39 +191,15 @@ class ConfigureCommand(BaseCommand):
         if getattr(args, "behaviors", False):
             return self._run_behavior_management()
 
+        if getattr(args, "startup", False):
+            return self._run_startup_configuration()
+
         # Launch interactive TUI
         return self._run_interactive_tui(args)
 
     def _run_interactive_tui(self, args) -> CommandResult:
-        """Run the main interactive TUI."""
-        # Check if we can use the modern Textual TUI
-        use_textual = getattr(args, "use_textual", True)
-        force_rich = getattr(args, "force_rich", False)
-
-        if use_textual and not force_rich:
-            try:
-                # Try to import and use Textual TUI
-                from .configure_tui import can_use_tui, launch_tui
-
-                if can_use_tui():
-                    self.console.print(
-                        "[cyan]Launching full-screen configuration interface...[/cyan]"
-                    )
-                    return launch_tui(self.current_scope, self.project_dir)
-                # Fall back to Rich TUI if terminal doesn't support full-screen
-                self.console.print(
-                    "[yellow]Terminal doesn't support full-screen mode. Using menu interface.[/yellow]"
-                )
-            except ImportError:
-                # Textual not available, fall back to Rich
-                self.console.print(
-                    "[yellow]Textual not installed. Using menu interface.[/yellow]"
-                )
-                self.console.print(
-                    "[dim]Install textual for a better experience: pip install textual[/dim]"
-                )
-
-        # Original Rich-based TUI
+        """Run the main interactive menu interface."""
+        # Rich-based menu interface
         try:
             self.console.clear()
 
@@ -276,13 +211,49 @@ class ConfigureCommand(BaseCommand):
                 if choice == "1":
                     self._manage_agents()
                 elif choice == "2":
-                    self._edit_templates()
+                    self._manage_skills()
                 elif choice == "3":
-                    self._manage_behaviors()
+                    self._edit_templates()
                 elif choice == "4":
-                    self._switch_scope()
+                    self._manage_behaviors()
                 elif choice == "5":
+                    # If user saves and wants to proceed to startup, exit the configurator
+                    if self._manage_startup_configuration():
+                        self.console.print(
+                            "\n[green]Configuration saved. Exiting configurator...[/green]"
+                        )
+                        break
+                elif choice == "6":
+                    self._switch_scope()
+                elif choice == "7":
                     self._show_version_info_interactive()
+                elif choice == "l":
+                    # Check for pending agent changes
+                    if self.agent_manager and self.agent_manager.has_pending_changes():
+                        should_save = Confirm.ask(
+                            "[yellow]You have unsaved agent changes. Save them before launching?[/yellow]",
+                            default=True,
+                        )
+                        if should_save:
+                            self.agent_manager.commit_deferred_changes()
+                            self.console.print("[green]✓ Agent changes saved[/green]")
+                        else:
+                            self.agent_manager.discard_deferred_changes()
+                            self.console.print(
+                                "[yellow]⚠ Agent changes discarded[/yellow]"
+                            )
+
+                    # Save all configuration
+                    self.console.print("\n[cyan]Saving configuration...[/cyan]")
+                    if self._save_all_configuration():
+                        # Launch Claude MPM (this will replace the process if successful)
+                        self._launch_claude_mpm()
+                        # If execvp fails, we'll return here and break
+                        break
+                    self.console.print(
+                        "[red]✗ Failed to save configuration. Not launching.[/red]"
+                    )
+                    Prompt.ask("\nPress Enter to continue")
                 elif choice == "q":
                     self.console.print(
                         "\n[green]Configuration complete. Goodbye![/green]"
@@ -302,57 +273,15 @@ class ConfigureCommand(BaseCommand):
 
     def _display_header(self) -> None:
         """Display the TUI header."""
-        self.console.clear()
-
-        # Create header panel
-        header_text = Text()
-        header_text.append("Claude MPM ", style="bold cyan")
-        header_text.append("Configuration Interface", style="bold white")
-
-        scope_text = Text(f"Scope: {self.current_scope.upper()}", style="yellow")
-        dir_text = Text(f"Directory: {self.project_dir}", style="dim")
-
-        header_content = Columns([header_text], align="center")
-        subtitle_content = f"{scope_text} | {dir_text}"
-
-        header_panel = Panel(
-            header_content,
-            subtitle=subtitle_content,
-            box=ROUNDED,
-            style="blue",
-            padding=(1, 2),
-        )
-
-        self.console.print(header_panel)
-        self.console.print()
+        # Sync scope to navigation before display
+        self.navigation.current_scope = self.current_scope
+        self.navigation.display_header()
 
     def _show_main_menu(self) -> str:
         """Show the main menu and get user choice."""
-        menu_items = [
-            ("1", "Agent Management", "Enable/disable agents and customize settings"),
-            ("2", "Template Editing", "Edit agent JSON templates"),
-            ("3", "Behavior Files", "Manage identity and workflow configurations"),
-            ("4", "Switch Scope", f"Current: {self.current_scope}"),
-            ("5", "Version Info", "Display MPM and Claude versions"),
-            ("q", "Quit", "Exit configuration interface"),
-        ]
-
-        table = Table(show_header=False, box=None, padding=(0, 2))
-        table.add_column("Key", style="cyan", width=3)
-        table.add_column("Option", style="bold white", width=20)
-        table.add_column("Description", style="dim")
-
-        for key, option, desc in menu_items:
-            table.add_row(f"[{key}]", option, desc)
-
-        menu_panel = Panel(
-            table, title="[bold]Main Menu[/bold]", box=ROUNDED, style="green"
-        )
-
-        self.console.print(menu_panel)
-        self.console.print()
-
-        return Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="q")
+        # Sync scope to navigation before display
+        self.navigation.current_scope = self.current_scope
+        return self.navigation.show_main_menu()
 
     def _manage_agents(self) -> None:
         """Agent management interface."""
@@ -366,22 +295,41 @@ class ConfigureCommand(BaseCommand):
 
             # Show agent menu
             self.console.print("\n[bold]Agent Management Options:[/bold]")
-            self.console.print("  [cyan][e][/cyan] Enable an agent")
-            self.console.print("  [cyan][d][/cyan] Disable an agent")
-            self.console.print("  [cyan][c][/cyan] Customize agent template")
-            self.console.print("  [cyan][v][/cyan] View agent details")
-            self.console.print("  [cyan][r][/cyan] Reset agent to defaults")
-            self.console.print("  [cyan][b][/cyan] Back to main menu")
+
+            # Use Text objects to properly display shortcuts with styling
+            text_t = Text("  ")
+            text_t.append("[t]", style="bold blue")
+            text_t.append(" Toggle agents (enable/disable multiple)")
+            self.console.print(text_t)
+
+            text_c = Text("  ")
+            text_c.append("[c]", style="bold blue")
+            text_c.append(" Customize agent template")
+            self.console.print(text_c)
+
+            text_v = Text("  ")
+            text_v.append("[v]", style="bold blue")
+            text_v.append(" View agent details")
+            self.console.print(text_v)
+
+            text_r = Text("  ")
+            text_r.append("[r]", style="bold blue")
+            text_r.append(" Reset agent to defaults")
+            self.console.print(text_r)
+
+            text_b = Text("  ")
+            text_b.append("[b]", style="bold blue")
+            text_b.append(" Back to main menu")
+            self.console.print(text_b)
+
             self.console.print()
 
-            choice = Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="b")
+            choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="b")
 
             if choice == "b":
                 break
-            if choice == "e":
-                self._enable_agent_interactive(agents)
-            elif choice == "d":
-                self._disable_agent_interactive(agents)
+            if choice == "t":
+                self._toggle_agents_interactive(agents)
             elif choice == "c":
                 self._customize_agent_template(agents)
             elif choice == "v":
@@ -394,663 +342,366 @@ class ConfigureCommand(BaseCommand):
 
     def _display_agents_table(self, agents: List[AgentConfig]) -> None:
         """Display a table of available agents."""
-        table = Table(
-            title=f"Available Agents ({len(agents)} total)",
-            box=ROUNDED,
-            show_lines=True,
-        )
+        self.agent_display.display_agents_table(agents)
 
-        table.add_column("ID", style="dim", width=3)
-        table.add_column("Name", style="cyan", width=22)
-        table.add_column("Status", width=12)
-        table.add_column("Description", style="white", width=45)
-        table.add_column("Model/Tools", style="dim", width=20)
-
-        for idx, agent in enumerate(agents, 1):
-            # Check if agent is enabled
-            is_enabled = self.agent_manager.is_agent_enabled(agent.name)
-            status = (
-                "[green]✓ Enabled[/green]" if is_enabled else "[red]✗ Disabled[/red]"
-            )
+    def _display_agents_with_pending_states(self, agents: List[AgentConfig]) -> None:
+        """Display agents table with pending state indicators."""
+        self.agent_display.display_agents_with_pending_states(agents)
 
-            # Format tools/dependencies - show first 2 tools
-            tools_display = ""
-            if agent.dependencies:
-                if len(agent.dependencies) > 2:
-                    tools_display = f"{', '.join(agent.dependencies[:2])}..."
-                else:
-                    tools_display = ", ".join(agent.dependencies)
-            else:
-                # Try to get model from template
-                try:
-                    template_path = self._get_agent_template_path(agent.name)
-                    if template_path.exists():
-                        with open(template_path) as f:
-                            template = json.load(f)
-                        model = template.get("capabilities", {}).get("model", "default")
-                        tools_display = f"Model: {model}"
-                    else:
-                        tools_display = "Default"
-                except:
-                    tools_display = "Default"
-
-            # Truncate description for table display
-            desc_display = (
-                agent.description[:42] + "..."
-                if len(agent.description) > 42
-                else agent.description
-            )
-
-            table.add_row(str(idx), agent.name, status, desc_display, tools_display)
+    def _toggle_agents_interactive(self, agents: List[AgentConfig]) -> None:
+        """Interactive multi-agent enable/disable with batch save."""
 
-        self.console.print(table)
+        # Initialize pending states from current states
+        for agent in agents:
+            current_state = self.agent_manager.is_agent_enabled(agent.name)
+            self.agent_manager.set_agent_enabled_deferred(agent.name, current_state)
 
-    def _enable_agent_interactive(self, agents: List[AgentConfig]) -> None:
-        """Interactive agent enabling."""
-        agent_id = Prompt.ask("Enter agent ID to enable (or 'all' for all agents)")
+        while True:
+            # Display table with pending states
+            self._display_agents_with_pending_states(agents)
+
+            # Show menu
+            self.console.print("\n[bold]Toggle Agent Status:[/bold]")
+            text_toggle = Text("  ")
+            text_toggle.append("[t]", style="bold blue")
+            text_toggle.append(" Enter agent IDs to toggle (e.g., '1,3,5' or '1-4')")
+            self.console.print(text_toggle)
+
+            text_all = Text("  ")
+            text_all.append("[a]", style="bold blue")
+            text_all.append(" Enable all agents")
+            self.console.print(text_all)
+
+            text_none = Text("  ")
+            text_none.append("[n]", style="bold blue")
+            text_none.append(" Disable all agents")
+            self.console.print(text_none)
+
+            text_save = Text("  ")
+            text_save.append("[s]", style="bold green")
+            text_save.append(" Save changes and return")
+            self.console.print(text_save)
+
+            text_cancel = Text("  ")
+            text_cancel.append("[c]", style="bold magenta")
+            text_cancel.append(" Cancel (discard changes)")
+            self.console.print(text_cancel)
+
+            choice = (
+                Prompt.ask("[bold blue]Select an option[/bold blue]", default="s")
+                .strip()
+                .lower()
+            )
 
-        if agent_id.lower() == "all":
-            if Confirm.ask("[yellow]Enable ALL agents?[/yellow]"):
-                for agent in agents:
-                    self.agent_manager.set_agent_enabled(agent.name, True)
-                self.console.print("[green]All agents enabled successfully![/green]")
-        else:
-            try:
-                idx = int(agent_id) - 1
-                if 0 <= idx < len(agents):
-                    agent = agents[idx]
-                    self.agent_manager.set_agent_enabled(agent.name, True)
-                    self.console.print(
-                        f"[green]Agent '{agent.name}' enabled successfully![/green]"
-                    )
+            if choice == "s":
+                if self.agent_manager.has_pending_changes():
+                    self.agent_manager.commit_deferred_changes()
+                    self.console.print("[green]✓ Changes saved successfully![/green]")
                 else:
-                    self.console.print("[red]Invalid agent ID.[/red]")
-            except ValueError:
-                self.console.print("[red]Invalid input. Please enter a number.[/red]")
-
-        Prompt.ask("Press Enter to continue")
-
-    def _disable_agent_interactive(self, agents: List[AgentConfig]) -> None:
-        """Interactive agent disabling."""
-        agent_id = Prompt.ask("Enter agent ID to disable (or 'all' for all agents)")
-
-        if agent_id.lower() == "all":
-            if Confirm.ask("[yellow]Disable ALL agents?[/yellow]"):
+                    self.console.print("[yellow]No changes to save.[/yellow]")
+                Prompt.ask("Press Enter to continue")
+                break
+            if choice == "c":
+                self.agent_manager.discard_deferred_changes()
+                self.console.print("[yellow]Changes discarded.[/yellow]")
+                Prompt.ask("Press Enter to continue")
+                break
+            if choice == "a":
                 for agent in agents:
-                    self.agent_manager.set_agent_enabled(agent.name, False)
-                self.console.print("[green]All agents disabled successfully![/green]")
-        else:
-            try:
-                idx = int(agent_id) - 1
-                if 0 <= idx < len(agents):
-                    agent = agents[idx]
-                    self.agent_manager.set_agent_enabled(agent.name, False)
-                    self.console.print(
-                        f"[green]Agent '{agent.name}' disabled successfully![/green]"
-                    )
-                else:
-                    self.console.print("[red]Invalid agent ID.[/red]")
-            except ValueError:
-                self.console.print("[red]Invalid input. Please enter a number.[/red]")
-
-        Prompt.ask("Press Enter to continue")
+                    self.agent_manager.set_agent_enabled_deferred(agent.name, True)
+            elif choice == "n":
+                for agent in agents:
+                    self.agent_manager.set_agent_enabled_deferred(agent.name, False)
+            elif choice == "t" or choice.replace(",", "").replace("-", "").isdigit():
+                selected_ids = self._parse_id_selection(
+                    choice if choice != "t" else Prompt.ask("Enter IDs"), len(agents)
+                )
+                for idx in selected_ids:
+                    if 1 <= idx <= len(agents):
+                        agent = agents[idx - 1]
+                        current = self.agent_manager.get_pending_state(agent.name)
+                        self.agent_manager.set_agent_enabled_deferred(
+                            agent.name, not current
+                        )
 
     def _customize_agent_template(self, agents: List[AgentConfig]) -> None:
         """Customize agent JSON template."""
-        agent_id = Prompt.ask("Enter agent ID to customize")
-
-        try:
-            idx = int(agent_id) - 1
-            if 0 <= idx < len(agents):
-                agent = agents[idx]
-                self._edit_agent_template(agent)
-            else:
-                self.console.print("[red]Invalid agent ID.[/red]")
-                Prompt.ask("Press Enter to continue")
-        except ValueError:
-            self.console.print("[red]Invalid input. Please enter a number.[/red]")
-            Prompt.ask("Press Enter to continue")
+        self.template_editor.customize_agent_template(agents)
 
     def _edit_agent_template(self, agent: AgentConfig) -> None:
         """Edit an agent's JSON template."""
-        self.console.clear()
-        self.console.print(f"[bold]Editing template for: {agent.name}[/bold]\n")
-
-        # Get current template
-        template_path = self._get_agent_template_path(agent.name)
-
-        if template_path.exists():
-            with open(template_path) as f:
-                template = json.load(f)
-            is_system = str(template_path).startswith(
-                str(self.agent_manager.templates_dir)
-            )
-        else:
-            # Create a minimal template structure based on system templates
-            template = {
-                "schema_version": "1.2.0",
-                "agent_id": agent.name,
-                "agent_version": "1.0.0",
-                "agent_type": agent.name.replace("-", "_"),
-                "metadata": {
-                    "name": agent.name.replace("-", " ").title() + " Agent",
-                    "description": agent.description,
-                    "tags": [agent.name],
-                    "author": "Custom",
-                    "created_at": "",
-                    "updated_at": "",
-                },
-                "capabilities": {
-                    "model": "opus",
-                    "tools": (
-                        agent.dependencies
-                        if agent.dependencies
-                        else ["Read", "Write", "Edit", "Bash"]
-                    ),
-                },
-                "instructions": {
-                    "base_template": "BASE_AGENT_TEMPLATE.md",
-                    "custom_instructions": "",
-                },
-            }
-            is_system = False
-
-        # Display current template
-        if is_system:
-            self.console.print(
-                "[yellow]Viewing SYSTEM template (read-only). Customization will create a local copy.[/yellow]\n"
-            )
-
-        self.console.print("[bold]Current Template:[/bold]")
-        # Truncate for display if too large
-        display_template = template.copy()
-        if "instructions" in display_template and isinstance(
-            display_template["instructions"], dict
-        ):
-            if (
-                "custom_instructions" in display_template["instructions"]
-                and len(str(display_template["instructions"]["custom_instructions"]))
-                > 200
-            ):
-                display_template["instructions"]["custom_instructions"] = (
-                    display_template["instructions"]["custom_instructions"][:200]
-                    + "..."
-                )
-
-        json_str = json.dumps(display_template, indent=2)
-        # Limit display to first 50 lines for readability
-        lines = json_str.split("\n")
-        if len(lines) > 50:
-            json_str = "\n".join(lines[:50]) + "\n... (truncated for display)"
-
-        syntax = Syntax(json_str, "json", theme="monokai", line_numbers=True)
-        self.console.print(syntax)
-        self.console.print()
-
-        # Editing options
-        self.console.print("[bold]Editing Options:[/bold]")
-        if not is_system:
-            self.console.print("  [cyan][1][/cyan] Edit in external editor")
-            self.console.print("  [cyan][2][/cyan] Add/modify a field")
-            self.console.print("  [cyan][3][/cyan] Remove a field")
-            self.console.print("  [cyan][4][/cyan] Reset to defaults")
-        else:
-            self.console.print("  [cyan][1][/cyan] Create customized copy")
-            self.console.print("  [cyan][2][/cyan] View full template")
-        self.console.print("  [cyan][b][/cyan] Back")
-        self.console.print()
-
-        choice = Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="b")
-
-        if is_system:
-            if choice == "1":
-                # Create a customized copy
-                self._create_custom_template_copy(agent, template)
-            elif choice == "2":
-                # View full template
-                self._view_full_template(template)
-        elif choice == "1":
-            self._edit_in_external_editor(template_path, template)
-        elif choice == "2":
-            self._modify_template_field(template, template_path)
-        elif choice == "3":
-            self._remove_template_field(template, template_path)
-        elif choice == "4":
-            self._reset_template(agent, template_path)
-
-        if choice != "b":
-            Prompt.ask("Press Enter to continue")
+        self.template_editor.edit_agent_template(agent)
 
     def _get_agent_template_path(self, agent_name: str) -> Path:
         """Get the path to an agent's template file."""
-        # First check for custom template in project/user config
-        if self.current_scope == "project":
-            config_dir = self.project_dir / ".claude-mpm" / "agents"
-        else:
-            config_dir = Path.home() / ".claude-mpm" / "agents"
-
-        config_dir.mkdir(parents=True, exist_ok=True)
-        custom_template = config_dir / f"{agent_name}.json"
-
-        # If custom template exists, return it
-        if custom_template.exists():
-            return custom_template
-
-        # Otherwise, look for the system template
-        # Handle various naming conventions
-        possible_names = [
-            f"{agent_name}.json",
-            f"{agent_name.replace('-', '_')}.json",
-            f"{agent_name}-agent.json",
-            f"{agent_name.replace('-', '_')}_agent.json",
-        ]
-
-        for name in possible_names:
-            system_template = self.agent_manager.templates_dir / name
-            if system_template.exists():
-                return system_template
-
-        # Return the custom template path for new templates
-        return custom_template
+        return self.template_editor.get_agent_template_path(agent_name)
 
     def _edit_in_external_editor(self, template_path: Path, template: Dict) -> None:
         """Open template in external editor."""
-        import subprocess
-        import tempfile
-
-        # Write current template to temp file
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
-            json.dump(template, f, indent=2)
-            temp_path = f.name
-
-        # Get editor from environment
-        editor = os.environ.get("EDITOR", "nano")
-
-        try:
-            # Open in editor
-            subprocess.call([editor, temp_path])
-
-            # Read back the edited content
-            with open(temp_path) as f:
-                new_template = json.load(f)
-
-            # Save to actual template path
-            with open(template_path, "w") as f:
-                json.dump(new_template, f, indent=2)
-
-            self.console.print("[green]Template updated successfully![/green]")
-
-        except Exception as e:
-            self.console.print(f"[red]Error editing template: {e}[/red]")
-        finally:
-            # Clean up temp file
-            Path(temp_path).unlink(missing_ok=True)
+        self.template_editor.edit_in_external_editor(template_path, template)
 
     def _modify_template_field(self, template: Dict, template_path: Path) -> None:
         """Add or modify a field in the template."""
-        field_name = Prompt.ask(
-            "Enter field name (use dot notation for nested, e.g., 'config.timeout')"
-        )
-        field_value = Prompt.ask("Enter field value (JSON format)")
-
-        try:
-            # Parse the value as JSON
-            value = json.loads(field_value)
-
-            # Navigate to the field location
-            parts = field_name.split(".")
-            current = template
-
-            for part in parts[:-1]:
-                if part not in current:
-                    current[part] = {}
-                current = current[part]
-
-            # Set the value
-            current[parts[-1]] = value
-
-            # Save the template
-            with open(template_path, "w") as f:
-                json.dump(template, f, indent=2)
-
-            self.console.print(
-                f"[green]Field '{field_name}' updated successfully![/green]"
-            )
-
-        except json.JSONDecodeError:
-            self.console.print("[red]Invalid JSON value. Please try again.[/red]")
-        except Exception as e:
-            self.console.print(f"[red]Error updating field: {e}[/red]")
+        self.template_editor.modify_template_field(template, template_path)
 
     def _remove_template_field(self, template: Dict, template_path: Path) -> None:
         """Remove a field from the template."""
-        field_name = Prompt.ask(
-            "Enter field name to remove (use dot notation for nested)"
-        )
-
-        try:
-            # Navigate to the field location
-            parts = field_name.split(".")
-            current = template
-
-            for part in parts[:-1]:
-                if part not in current:
-                    raise KeyError(f"Field '{field_name}' not found")
-                current = current[part]
-
-            # Remove the field
-            if parts[-1] in current:
-                del current[parts[-1]]
-
-                # Save the template
-                with open(template_path, "w") as f:
-                    json.dump(template, f, indent=2)
-
-                self.console.print(
-                    f"[green]Field '{field_name}' removed successfully![/green]"
-                )
-            else:
-                self.console.print(f"[red]Field '{field_name}' not found.[/red]")
-
-        except Exception as e:
-            self.console.print(f"[red]Error removing field: {e}[/red]")
+        self.template_editor.remove_template_field(template, template_path)
 
     def _reset_template(self, agent: AgentConfig, template_path: Path) -> None:
         """Reset template to defaults."""
-        if Confirm.ask(f"[yellow]Reset '{agent.name}' template to defaults?[/yellow]"):
-            # Remove custom template file
-            template_path.unlink(missing_ok=True)
-            self.console.print(
-                f"[green]Template for '{agent.name}' reset to defaults![/green]"
-            )
+        self.template_editor.reset_template(agent, template_path)
 
     def _create_custom_template_copy(self, agent: AgentConfig, template: Dict) -> None:
         """Create a customized copy of a system template."""
-        if self.current_scope == "project":
-            config_dir = self.project_dir / ".claude-mpm" / "agents"
-        else:
-            config_dir = Path.home() / ".claude-mpm" / "agents"
+        self.template_editor.create_custom_template_copy(agent, template)
 
-        config_dir.mkdir(parents=True, exist_ok=True)
-        custom_path = config_dir / f"{agent.name}.json"
+    def _view_full_template(self, template: Dict) -> None:
+        """View the full template without truncation."""
+        self.template_editor.view_full_template(template)
 
-        if custom_path.exists():
-            if not Confirm.ask(
-                "[yellow]Custom template already exists. Overwrite?[/yellow]"
-            ):
-                return
+    def _reset_agent_defaults(self, agents: List[AgentConfig]) -> None:
+        """Reset an agent to default enabled state and remove custom template."""
+        self.template_editor.reset_agent_defaults(agents)
 
-        # Save the template copy
-        with open(custom_path, "w") as f:
-            json.dump(template, f, indent=2)
+    def _edit_templates(self) -> None:
+        """Template editing interface."""
+        self.template_editor.edit_templates_interface()
 
-        self.console.print(f"[green]Created custom template at: {custom_path}[/green]")
-        self.console.print("[green]You can now edit this template.[/green]")
+    def _manage_behaviors(self) -> None:
+        """Behavior file management interface."""
+        # Note: BehaviorManager handles its own loop and clears screen
+        # but doesn't display our header. We'll need to update BehaviorManager
+        # to accept a header callback in the future. For now, just delegate.
+        self.behavior_manager.manage_behaviors()
 
-    def _view_full_template(self, template: Dict) -> None:
-        """View the full template without truncation."""
-        self.console.clear()
-        self.console.print("[bold]Full Template View:[/bold]\n")
+    def _manage_skills(self) -> None:
+        """Skills management interface."""
+        from ...cli.interactive.skills_wizard import SkillsWizard
+        from ...skills.skill_manager import get_manager
 
-        json_str = json.dumps(template, indent=2)
-        syntax = Syntax(json_str, "json", theme="monokai", line_numbers=True)
+        wizard = SkillsWizard()
+        manager = get_manager()
 
-        # Use pager for long content
+        while True:
+            self.console.clear()
+            self._display_header()
 
-        with self.console.pager():
-            self.console.print(syntax)
+            self.console.print("\n[bold]Skills Management Options:[/bold]\n")
+            self.console.print("  [1] View Available Skills")
+            self.console.print("  [2] Configure Skills for Agents")
+            self.console.print("  [3] View Current Skill Mappings")
+            self.console.print("  [4] Auto-Link Skills to Agents")
+            self.console.print("  [b] Back to Main Menu")
+            self.console.print()
 
-    def _view_agent_details(self, agents: List[AgentConfig]) -> None:
-        """View detailed information about an agent."""
-        agent_id = Prompt.ask("Enter agent ID to view")
+            choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="b")
 
-        try:
-            idx = int(agent_id) - 1
-            if 0 <= idx < len(agents):
-                agent = agents[idx]
+            if choice == "1":
+                # View available skills
+                self.console.clear()
+                self._display_header()
+                wizard.list_available_skills()
+                Prompt.ask("\nPress Enter to continue")
 
+            elif choice == "2":
+                # Configure skills interactively
                 self.console.clear()
                 self._display_header()
 
-                # Try to load full template for more details
-                template_path = self._get_agent_template_path(agent.name)
-                extra_info = ""
+                # Get list of enabled agents
+                agents = self.agent_manager.discover_agents()
+                enabled_agents = [
+                    a.name
+                    for a in agents
+                    if self.agent_manager.get_pending_state(a.name)
+                ]
 
-                if template_path.exists():
-                    try:
-                        with open(template_path) as f:
-                            template = json.load(f)
+                if not enabled_agents:
+                    self.console.print(
+                        "[yellow]No agents are currently enabled.[/yellow]"
+                    )
+                    self.console.print(
+                        "Please enable agents first in Agent Management."
+                    )
+                    Prompt.ask("\nPress Enter to continue")
+                    continue
 
-                        # Extract additional information
-                        metadata = template.get("metadata", {})
-                        capabilities = template.get("capabilities", {})
+                # Run skills wizard
+                success, mapping = wizard.run_interactive_selection(enabled_agents)
 
-                        # Get full description if available
-                        full_desc = metadata.get("description", agent.description)
+                if success:
+                    # Save the configuration
+                    manager.save_mappings_to_config()
+                    self.console.print("\n[green]✓ Skills configuration saved![/green]")
+                else:
+                    self.console.print(
+                        "\n[yellow]Skills configuration cancelled.[/yellow]"
+                    )
 
-                        # Get model and tools
-                        model = capabilities.get("model", "default")
-                        tools = capabilities.get("tools", [])
+                Prompt.ask("\nPress Enter to continue")
 
-                        # Get tags
-                        tags = metadata.get("tags", [])
+            elif choice == "3":
+                # View current mappings
+                self.console.clear()
+                self._display_header()
 
-                        # Get version info
-                        agent_version = template.get("agent_version", "N/A")
-                        schema_version = template.get("schema_version", "N/A")
+                self.console.print("\n[bold]Current Skill Mappings:[/bold]\n")
 
-                        extra_info = f"""
-[bold]Full Description:[/bold]
-{full_desc}
+                mappings = manager.list_agent_skill_mappings()
+                if not mappings:
+                    self.console.print("[dim]No skill mappings configured yet.[/dim]")
+                else:
+                    from rich.table import Table
 
-[bold]Model:[/bold] {model}
-[bold]Agent Version:[/bold] {agent_version}
-[bold]Schema Version:[/bold] {schema_version}
-[bold]Tags:[/bold] {', '.join(tags) if tags else 'None'}
-[bold]Tools:[/bold] {', '.join(tools[:5]) if tools else 'None'}{'...' if len(tools) > 5 else ''}
-"""
-                    except:
-                        pass
-
-                # Create detail panel
-                detail_text = f"""
-[bold]Name:[/bold] {agent.name}
-[bold]Status:[/bold] {'[green]Enabled[/green]' if self.agent_manager.is_agent_enabled(agent.name) else '[red]Disabled[/red]'}
-[bold]Template Path:[/bold] {template_path}
-[bold]Is System Template:[/bold] {'Yes' if str(template_path).startswith(str(self.agent_manager.templates_dir)) else 'No (Custom)'}
-{extra_info}
-                """
-
-                panel = Panel(
-                    detail_text.strip(),
-                    title=f"[bold]{agent.name} Details[/bold]",
-                    box=ROUNDED,
-                    style="cyan",
-                )
+                    table = Table(show_header=True, header_style="bold cyan")
+                    table.add_column("Agent", style="yellow")
+                    table.add_column("Skills", style="green")
 
-                self.console.print(panel)
+                    for agent_id, skills in mappings.items():
+                        skills_str = (
+                            ", ".join(skills) if skills else "[dim](none)[/dim]"
+                        )
+                        table.add_row(agent_id, skills_str)
 
-            else:
-                self.console.print("[red]Invalid agent ID.[/red]")
+                    self.console.print(table)
 
-        except ValueError:
-            self.console.print("[red]Invalid input. Please enter a number.[/red]")
+                Prompt.ask("\nPress Enter to continue")
 
-        Prompt.ask("\nPress Enter to continue")
+            elif choice == "4":
+                # Auto-link skills
+                self.console.clear()
+                self._display_header()
 
-    def _edit_templates(self) -> None:
-        """Template editing interface."""
-        self.console.print("[yellow]Template editing interface - Coming soon![/yellow]")
-        Prompt.ask("Press Enter to continue")
+                self.console.print("\n[bold]Auto-Linking Skills to Agents...[/bold]\n")
 
-    def _manage_behaviors(self) -> None:
-        """Behavior file management interface."""
-        while True:
-            self.console.clear()
-            self._display_header()
+                # Get enabled agents
+                agents = self.agent_manager.discover_agents()
+                enabled_agents = [
+                    a.name
+                    for a in agents
+                    if self.agent_manager.get_pending_state(a.name)
+                ]
 
-            self.console.print("[bold]Behavior File Management[/bold]\n")
+                if not enabled_agents:
+                    self.console.print(
+                        "[yellow]No agents are currently enabled.[/yellow]"
+                    )
+                    self.console.print(
+                        "Please enable agents first in Agent Management."
+                    )
+                    Prompt.ask("\nPress Enter to continue")
+                    continue
 
-            # Display current behavior files
-            self._display_behavior_files()
+                # Auto-link
+                mapping = wizard._auto_link_skills(enabled_agents)
 
-            # Show behavior menu
-            self.console.print("\n[bold]Options:[/bold]")
-            self.console.print("  [cyan][1][/cyan] Edit identity configuration")
-            self.console.print("  [cyan][2][/cyan] Edit workflow configuration")
-            self.console.print("  [cyan][3][/cyan] Import behavior file")
-            self.console.print("  [cyan][4][/cyan] Export behavior file")
-            self.console.print("  [cyan][b][/cyan] Back to main menu")
-            self.console.print()
+                # Display preview
+                self.console.print("Auto-linked skills:\n")
+                for agent_id, skills in mapping.items():
+                    self.console.print(f"  [yellow]{agent_id}[/yellow]:")
+                    for skill in skills:
+                        self.console.print(f"    - {skill}")
 
-            choice = Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="b")
+                # Confirm
+                confirm = Confirm.ask("\nApply this configuration?", default=True)
 
-            if choice == "b":
+                if confirm:
+                    wizard._apply_skills_configuration(mapping)
+                    manager.save_mappings_to_config()
+                    self.console.print("\n[green]✓ Auto-linking complete![/green]")
+                else:
+                    self.console.print("\n[yellow]Auto-linking cancelled.[/yellow]")
+
+                Prompt.ask("\nPress Enter to continue")
+
+            elif choice == "b":
                 break
-            if choice == "1":
-                self._edit_identity_config()
-            elif choice == "2":
-                self._edit_workflow_config()
-            elif choice == "3":
-                self._import_behavior_file()
-            elif choice == "4":
-                self._export_behavior_file()
             else:
-                self.console.print("[red]Invalid choice.[/red]")
-                Prompt.ask("Press Enter to continue")
+                self.console.print("[red]Invalid choice. Please try again.[/red]")
+                Prompt.ask("\nPress Enter to continue")
 
     def _display_behavior_files(self) -> None:
         """Display current behavior files."""
-        if self.current_scope == "project":
-            config_dir = self.project_dir / ".claude-mpm" / "behaviors"
-        else:
-            config_dir = Path.home() / ".claude-mpm" / "behaviors"
-
-        config_dir.mkdir(parents=True, exist_ok=True)
-
-        table = Table(title="Behavior Files", box=ROUNDED)
-        table.add_column("File", style="cyan", width=30)
-        table.add_column("Size", style="dim", width=10)
-        table.add_column("Modified", style="white", width=20)
-
-        identity_file = config_dir / "identity.yaml"
-        workflow_file = config_dir / "workflow.yaml"
-
-        for file_path in [identity_file, workflow_file]:
-            if file_path.exists():
-                stat = file_path.stat()
-                size = f"{stat.st_size} bytes"
-                modified = f"{stat.st_mtime:.0f}"  # Simplified timestamp
-                table.add_row(file_path.name, size, modified)
-            else:
-                table.add_row(file_path.name, "[dim]Not found[/dim]", "-")
-
-        self.console.print(table)
+        self.behavior_manager.display_behavior_files()
 
     def _edit_identity_config(self) -> None:
         """Edit identity configuration."""
-        self.console.print(
-            "[yellow]Identity configuration editor - Coming soon![/yellow]"
-        )
-        Prompt.ask("Press Enter to continue")
+        self.behavior_manager.edit_identity_config()
 
     def _edit_workflow_config(self) -> None:
         """Edit workflow configuration."""
-        self.console.print(
-            "[yellow]Workflow configuration editor - Coming soon![/yellow]"
-        )
-        Prompt.ask("Press Enter to continue")
+        self.behavior_manager.edit_workflow_config()
 
     def _import_behavior_file(self) -> None:
         """Import a behavior file."""
-        file_path = Prompt.ask("Enter path to behavior file to import")
+        self.behavior_manager.import_behavior_file()
 
-        try:
-            source = Path(file_path)
-            if not source.exists():
-                self.console.print(f"[red]File not found: {file_path}[/red]")
-                return
-
-            # Determine target directory
-            if self.current_scope == "project":
-                config_dir = self.project_dir / ".claude-mpm" / "behaviors"
-            else:
-                config_dir = Path.home() / ".claude-mpm" / "behaviors"
+    def _export_behavior_file(self) -> None:
+        """Export a behavior file."""
+        self.behavior_manager.export_behavior_file()
 
-            config_dir.mkdir(parents=True, exist_ok=True)
+    def _manage_startup_configuration(self) -> bool:
+        """Manage startup configuration for MCP services and agents."""
+        return self.startup_manager.manage_startup_configuration()
 
-            # Copy file
-            import shutil
+    def _load_startup_configuration(self, config: Config) -> Dict:
+        """Load current startup configuration from config."""
+        return self.startup_manager.load_startup_configuration(config)
 
-            target = config_dir / source.name
-            shutil.copy2(source, target)
+    def _display_startup_configuration(self, startup_config: Dict) -> None:
+        """Display current startup configuration in a table."""
+        self.startup_manager.display_startup_configuration(startup_config)
 
-            self.console.print(f"[green]Successfully imported {source.name}![/green]")
+    def _configure_mcp_services(self, startup_config: Dict, config: Config) -> None:
+        """Configure which MCP services to enable at startup."""
+        self.startup_manager.configure_mcp_services(startup_config, config)
 
-        except Exception as e:
-            self.console.print(f"[red]Error importing file: {e}[/red]")
+    def _configure_hook_services(self, startup_config: Dict, config: Config) -> None:
+        """Configure which hook services to enable at startup."""
+        self.startup_manager.configure_hook_services(startup_config, config)
 
-        Prompt.ask("Press Enter to continue")
+    def _configure_system_agents(self, startup_config: Dict, config: Config) -> None:
+        """Configure which system agents to deploy at startup."""
+        self.startup_manager.configure_system_agents(startup_config, config)
 
-    def _export_behavior_file(self) -> None:
-        """Export a behavior file."""
-        self.console.print("[yellow]Behavior file export - Coming soon![/yellow]")
-        Prompt.ask("Press Enter to continue")
+    def _parse_id_selection(self, selection: str, max_id: int) -> List[int]:
+        """Parse ID selection string (e.g., '1,3,5' or '1-4')."""
+        return parse_id_selection(selection, max_id)
 
-    def _switch_scope(self) -> None:
-        """Switch between project and user scope."""
-        self.current_scope = "user" if self.current_scope == "project" else "project"
-        self.console.print(f"[green]Switched to {self.current_scope} scope[/green]")
-        Prompt.ask("Press Enter to continue")
+    def _enable_all_services(self, startup_config: Dict, config: Config) -> None:
+        """Enable all services and agents."""
+        self.startup_manager.enable_all_services(startup_config, config)
 
-    def _show_version_info_interactive(self) -> None:
-        """Show version information in interactive mode."""
-        self.console.clear()
-        self._display_header()
+    def _disable_all_services(self, startup_config: Dict, config: Config) -> None:
+        """Disable all services and agents."""
+        self.startup_manager.disable_all_services(startup_config, config)
 
-        # Get version information
-        mpm_version = self.version_service.get_version()
-        build_number = self.version_service.get_build_number()
+    def _reset_to_defaults(self, startup_config: Dict, config: Config) -> None:
+        """Reset startup configuration to defaults."""
+        self.startup_manager.reset_to_defaults(startup_config, config)
 
-        # Try to get Claude Code version
-        claude_version = "Unknown"
-        try:
-            import subprocess
+    def _save_startup_configuration(self, startup_config: Dict, config: Config) -> bool:
+        """Save startup configuration to config file and return whether to proceed to startup."""
+        return self.startup_manager.save_startup_configuration(startup_config, config)
 
-            result = subprocess.run(
-                ["claude", "--version"], capture_output=True, text=True, timeout=5, check=False
-            )
-            if result.returncode == 0:
-                claude_version = result.stdout.strip()
-        except:
-            pass
-
-        # Create version panel
-        version_text = f"""
-[bold cyan]Claude MPM[/bold cyan]
-Version: {mpm_version}
-Build: {build_number}
-
-[bold cyan]Claude Code[/bold cyan]
-Version: {claude_version}
-
-[bold cyan]Python[/bold cyan]
-Version: {sys.version.split()[0]}
-
-[bold cyan]Configuration[/bold cyan]
-Scope: {self.current_scope}
-Directory: {self.project_dir}
-        """
-
-        panel = Panel(
-            version_text.strip(),
-            title="[bold]Version Information[/bold]",
-            box=ROUNDED,
-            style="green",
-        )
+    def _save_all_configuration(self) -> bool:
+        """Save all configuration changes across all contexts."""
+        return self.startup_manager.save_all_configuration()
 
-        self.console.print(panel)
-        Prompt.ask("\nPress Enter to continue")
+    def _launch_claude_mpm(self) -> None:
+        """Launch Claude MPM run command, replacing current process."""
+        self.navigation.launch_claude_mpm()
+
+    def _switch_scope(self) -> None:
+        """Switch between project and user scope."""
+        self.navigation.switch_scope()
+        # Sync scope back from navigation
+        self.current_scope = self.navigation.current_scope
+
+    def _show_version_info_interactive(self) -> None:
+        """Show version information in interactive mode."""
+        self.persistence.show_version_info_interactive()
 
     # Non-interactive command methods
 
@@ -1092,88 +743,33 @@ Directory: {self.project_dir}
 
     def _export_config(self, file_path: str) -> CommandResult:
         """Export configuration to a file."""
-        try:
-            # Gather all configuration
-            config_data = {"scope": self.current_scope, "agents": {}, "behaviors": {}}
-
-            # Get agent states
-            agents = self.agent_manager.discover_agents()
-            for agent in agents:
-                config_data["agents"][agent.name] = {
-                    "enabled": self.agent_manager.is_agent_enabled(agent.name),
-                    "template_path": str(self._get_agent_template_path(agent.name)),
-                }
-
-            # Write to file
-            output_path = Path(file_path)
-            with open(output_path, "w") as f:
-                json.dump(config_data, f, indent=2)
-
-            return CommandResult.success_result(
-                f"Configuration exported to {output_path}"
-            )
-
-        except Exception as e:
-            return CommandResult.error_result(f"Failed to export configuration: {e}")
+        return self.persistence.export_config(file_path)
 
     def _import_config(self, file_path: str) -> CommandResult:
         """Import configuration from a file."""
-        try:
-            input_path = Path(file_path)
-            if not input_path.exists():
-                return CommandResult.error_result(f"File not found: {file_path}")
-
-            with open(input_path) as f:
-                config_data = json.load(f)
-
-            # Apply agent states
-            if "agents" in config_data:
-                for agent_name, agent_config in config_data["agents"].items():
-                    if "enabled" in agent_config:
-                        self.agent_manager.set_agent_enabled(
-                            agent_name, agent_config["enabled"]
-                        )
-
-            return CommandResult.success_result(
-                f"Configuration imported from {input_path}"
-            )
-
-        except Exception as e:
-            return CommandResult.error_result(f"Failed to import configuration: {e}")
+        return self.persistence.import_config(file_path)
 
     def _show_version_info(self) -> CommandResult:
         """Show version information in non-interactive mode."""
-        mpm_version = self.version_service.get_version()
-        build_number = self.version_service.get_build_number()
-
-        data = {
-            "mpm_version": mpm_version,
-            "build_number": build_number,
-            "python_version": sys.version.split()[0],
-        }
-
-        # Try to get Claude version
-        try:
-            import subprocess
-
-            result = subprocess.run(
-                ["claude", "--version"], capture_output=True, text=True, timeout=5, check=False
-            )
-            if result.returncode == 0:
-                data["claude_version"] = result.stdout.strip()
-        except:
-            data["claude_version"] = "Unknown"
-
-        # Print formatted output
-        self.console.print(
-            f"[bold]Claude MPM:[/bold] {mpm_version} (build {build_number})"
-        )
-        self.console.print(
-            f"[bold]Claude Code:[/bold] {data.get('claude_version', 'Unknown')}"
-        )
-        self.console.print(f"[bold]Python:[/bold] {data['python_version']}")
-
-        return CommandResult.success_result("Version information displayed", data=data)
+        return self.persistence.show_version_info()
+
+    def _install_hooks(self, force: bool = False) -> CommandResult:
+        """Install Claude MPM hooks for Claude Code integration."""
+        # Share logger with hook manager for consistent error logging
+        self.hook_manager.logger = self.logger
+        return self.hook_manager.install_hooks(force=force)
+
+    def _verify_hooks(self) -> CommandResult:
+        """Verify that Claude MPM hooks are properly installed."""
+        # Share logger with hook manager for consistent error logging
+        self.hook_manager.logger = self.logger
+        return self.hook_manager.verify_hooks()
+
+    def _uninstall_hooks(self) -> CommandResult:
+        """Uninstall Claude MPM hooks."""
+        # Share logger with hook manager for consistent error logging
+        self.hook_manager.logger = self.logger
+        return self.hook_manager.uninstall_hooks()
 
     def _run_agent_management(self) -> CommandResult:
         """Jump directly to agent management."""
@@ -1197,13 +793,21 @@ Directory: {self.project_dir}
 
     def _run_behavior_management(self) -> CommandResult:
         """Jump directly to behavior management."""
+        return self.behavior_manager.run_behavior_management()
+
+    def _run_startup_configuration(self) -> CommandResult:
+        """Jump directly to startup configuration."""
         try:
-            self._manage_behaviors()
-            return CommandResult.success_result("Behavior management completed")
+            proceed = self._manage_startup_configuration()
+            if proceed:
+                return CommandResult.success_result(
+                    "Startup configuration saved, proceeding to startup"
+                )
+            return CommandResult.success_result("Startup configuration completed")
         except KeyboardInterrupt:
-            return CommandResult.success_result("Behavior management cancelled")
+            return CommandResult.success_result("Startup configuration cancelled")
         except Exception as e:
-            return CommandResult.error_result(f"Behavior management failed: {e}")
+            return CommandResult.error_result(f"Startup configuration failed: {e}")
 
 
 def manage_configure(args) -> int: