claude-mpm 5.6.3__py3-none-any.whl → 5.6.16__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-5.6.3
+5.6.16

claude_mpm/agents/PM_INSTRUCTIONS.md

@@ -294,6 +294,8 @@ If you're about to run ANY other command, stop and delegate instead.
 - Grep (>1), Glob (investigation) → Delegate to research
 - `mcp__mcp-ticketer__*` → Delegate to ticketing
 - `mcp__chrome-devtools__*` → Delegate to web-qa
+- `mcp__claude-in-chrome__*` → Delegate to web-qa
+- `mcp__playwright__*` → Delegate to web-qa
 
 ## Agent Deployment Architecture
 
@@ -358,7 +360,7 @@ These are EXAMPLES of routing, not an exhaustive list. **Default to delegation f
 | **Research** | Understanding codebase, investigating approaches, analyzing files | Grep, Glob, Read multiple files, WebSearch | Investigation tools |
 | **Engineer** | Writing/modifying code, implementing features, refactoring | Edit, Write, codebase knowledge, testing workflows | - |
 | **Ops** (local-ops) | Deploying apps, managing infrastructure, starting servers, port/process management | Environment config, deployment procedures | Use `local-ops` for localhost/PM2/docker |
-| **QA** (web-qa, api-qa) | Testing implementations, verifying deployments, regression tests, browser testing | Playwright (web), fetch (APIs), verification protocols | For browser: use **web-qa** (never use chrome-devtools directly) |
+| **QA** (web-qa, api-qa) | Testing implementations, verifying deployments, regression tests, browser testing | Playwright (web), fetch (APIs), verification protocols | For browser: use **web-qa** (never use chrome-devtools, claude-in-chrome, or playwright directly) |
 | **Documentation** | Creating/updating docs, README, API docs, guides | Style consistency, organization standards | - |
 | **Ticketing** | ALL ticket operations (CRUD, search, hierarchy, comments) | Direct mcp-ticketer access | PM never uses `mcp__mcp-ticketer__*` directly |
 | **Version Control** | Creating PRs, managing branches, complex git ops | PR workflows, branch management | Check git user for main branch access (bobmatnyc@users.noreply.github.com only) |
@@ -728,7 +730,7 @@ Circuit breakers automatically detect and enforce delegation requirements. All c
 | 3 | Unverified Assertions | PM claiming status without agent evidence | Require verification evidence | [Details](#circuit-breaker-3-unverified-assertions) |
 | 4 | File Tracking | PM marking task complete without tracking new files | Run git tracking sequence | [Details](#circuit-breaker-4-file-tracking-enforcement) |
 | 5 | Delegation Chain | PM claiming completion without full workflow delegation | Execute missing phases | [Details](#circuit-breaker-5-delegation-chain) |
-| 6 | Forbidden Tool Usage | PM using ticketing/browser MCP tools directly | Delegate to specialist agent | [Details](#circuit-breaker-6-forbidden-tool-usage) |
+| 6 | Forbidden Tool Usage | PM using ticketing/browser MCP tools (ticketer, chrome-devtools, claude-in-chrome, playwright) directly | Delegate to specialist agent | [Details](#circuit-breaker-6-forbidden-tool-usage) |
 | 7 | Verification Commands | PM using curl/lsof/ps/wget/nc | Delegate to local-ops or QA | [Details](#circuit-breaker-7-verification-command-detection) |
 | 8 | QA Verification Gate | PM claiming work complete without QA delegation | BLOCK - Delegate to QA now | [Details](#circuit-breaker-8-qa-verification-gate) |
 | 9 | User Delegation | PM instructing user to run commands | Delegate to appropriate agent | [Details](#circuit-breaker-9-user-delegation-detection) |
@@ -747,6 +749,9 @@ Circuit breakers automatically detect and enforce delegation requirements. All c
 - "It works" / "It's deployed" → Circuit Breaker #3
 - Marks todo complete without `git status` → Circuit Breaker #4
 - Uses `mcp__mcp-ticketer__*` → Circuit Breaker #6
+- Uses `mcp__chrome-devtools__*` → Circuit Breaker #6
+- Uses `mcp__claude-in-chrome__*` → Circuit Breaker #6
+- Uses `mcp__playwright__*` → Circuit Breaker #6
 - Uses curl/lsof directly → Circuit Breaker #7
 - Claims complete without QA → Circuit Breaker #8
 - "You'll need to run..." → Circuit Breaker #9
@@ -782,7 +787,7 @@ When the user says "just do it" or "handle it", delegate to the full workflow pi
 
 When the user says "verify", "check", or "test", delegate to the QA agent with specific verification criteria.
 
-When the user mentions "browser", "screenshot", "click", "navigate", "DOM", "console errors", delegate to web-qa agent for browser testing (NEVER use chrome-devtools tools directly).
+When the user mentions "browser", "screenshot", "click", "navigate", "DOM", "console errors", "tabs", "window", delegate to web-qa agent for browser testing (NEVER use chrome-devtools, claude-in-chrome, or playwright tools directly).
 
 When the user mentions "localhost", "local server", or "PM2", delegate to **local-ops** as the primary choice for local development operations.
 

claude_mpm/cli/commands/commander.py

@@ -2,25 +2,129 @@
 
 import asyncio
 import logging
+import shutil
+import threading
+import time
+from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
+# ANSI colors
+CYAN = "\033[36m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+YELLOW = "\033[33m"
+GREEN = "\033[32m"
+RED = "\033[31m"
+RESET = "\033[0m"
+
+
+def _get_terminal_width() -> int:
+    """Get terminal width with reasonable bounds."""
+    try:
+        width = shutil.get_terminal_size().columns
+        return max(80, min(width, 120))
+    except Exception:
+        return 100
+
+
+def _get_version() -> str:
+    """Get Commander version."""
+    version_file = Path(__file__).parent.parent.parent / "VERSION"
+    if version_file.exists():
+        return version_file.read_text().strip()
+    return "unknown"
+
+
+def display_commander_banner():
+    """Display Commander-specific startup banner."""
+    width = _get_terminal_width()
+    version = _get_version()
+
+    # Commander ASCII art banner
+    banner = f"""
+{CYAN}╭{'─' * (width - 2)}╮{RESET}
+{CYAN}│{RESET}{BOLD}  ⚡ MPM Commander {RESET}{DIM}v{version}{RESET}{' ' * (width - 24 - len(version))}│
+{CYAN}│{RESET}{DIM}  Multi-Project AI Orchestration{RESET}{' ' * (width - 36)}│
+{CYAN}├{'─' * (width - 2)}┤{RESET}
+{CYAN}│{RESET}  {YELLOW}ALPHA{RESET} - APIs may change                                {' ' * (width - 55)}│
+{CYAN}╰{'─' * (width - 2)}╯{RESET}
+"""
+    print(banner)
+
+
+def _count_cached_agents() -> int:
+    """Count cached agents from ~/.claude-mpm/cache/agents/."""
+    try:
+        cache_agents_dir = Path.home() / ".claude-mpm" / "cache" / "agents"
+        if not cache_agents_dir.exists():
+            return 0
+        # Recursively find all .md files excluding base/README files
+        agent_files = [
+            f
+            for f in cache_agents_dir.rglob("*.md")
+            if f.is_file()
+            and not f.name.startswith(".")
+            and f.name not in ("README.md", "BASE-AGENT.md", "INSTRUCTIONS.md")
+        ]
+        return len(agent_files)
+    except Exception:
+        return 0
+
+
+def _count_cached_skills() -> int:
+    """Count cached skills from ~/.claude-mpm/cache/skills/."""
+    try:
+        cache_skills_dir = Path.home() / ".claude-mpm" / "cache" / "skills"
+        if not cache_skills_dir.exists():
+            return 0
+        # Recursively find all directories containing SKILL.md
+        skill_files = list(cache_skills_dir.rglob("SKILL.md"))
+        return len(skill_files)
+    except Exception:
+        return 0
+
+
+def load_agents_and_skills():
+    """Load agents and skills for Commander sessions."""
+    try:
+        print(f"{DIM}Loading agents...{RESET}", end=" ", flush=True)
+        agent_count = _count_cached_agents()
+        print(f"{GREEN}✓{RESET} {agent_count} agents")
+
+        print(f"{DIM}Loading skills...{RESET}", end=" ", flush=True)
+        skill_count = _count_cached_skills()
+        print(f"{GREEN}✓{RESET} {skill_count} skills")
+
+        return agent_count, skill_count
+    except Exception as e:
+        logger.warning(f"Could not load agents/skills: {e}")
+        print(f"{YELLOW}⚠{RESET} Could not load agents/skills")
+        return 0, 0
+
 
 def handle_commander_command(args) -> int:
-    """Handle the commander command.
+    """Handle the commander command with auto-starting daemon.
 
     Args:
         args: Parsed command line arguments with:
-            - port: Port for internal services (default: 8765)
+            - port: Port for daemon (default: 8765)
+            - host: Host for daemon (default: 127.0.0.1)
             - state_dir: Optional state directory path
             - debug: Enable debug logging
+            - no_chat: Start daemon only without interactive chat
+            - daemon_only: Alias for no_chat
 
     Returns:
         Exit code (0 for success, 1 for error)
     """
     try:
         # Import here to avoid circular dependencies
+        import requests
+
         from claude_mpm.commander.chat.cli import run_commander
+        from claude_mpm.commander.config import DaemonConfig
+        from claude_mpm.commander.daemon import main as daemon_main
 
         # Setup debug logging if requested
         if getattr(args, "debug", False):
@@ -29,11 +133,76 @@ def handle_commander_command(args) -> int:
                 format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
             )
 
+        # Display Commander banner
+        display_commander_banner()
+
+        # Load agents and skills
+        load_agents_and_skills()
+
+        print()  # Blank line after loading
+
         # Get arguments
         port = getattr(args, "port", 8765)
+        host = getattr(args, "host", "127.0.0.1")
         state_dir = getattr(args, "state_dir", None)
+        no_chat = getattr(args, "no_chat", False) or getattr(args, "daemon_only", False)
+
+        # Check if daemon already running
+        daemon_running = False
+        try:
+            resp = requests.get(f"http://{host}:{port}/api/health", timeout=1)
+            if resp.status_code == 200:
+                print(f"{GREEN}✓{RESET} Daemon already running on {host}:{port}")
+                daemon_running = True
+        except (requests.RequestException, requests.ConnectionError):
+            pass
+
+        # Start daemon if not running
+        if not daemon_running:
+            print(
+                f"{DIM}Starting daemon on {host}:{port}...{RESET}", end=" ", flush=True
+            )
+
+            # Create daemon config
+            config_kwargs = {"host": host, "port": port}
+            if state_dir:
+                config_kwargs["state_dir"] = state_dir
+            config = DaemonConfig(**config_kwargs)
+
+            # Start daemon in background thread
+            daemon_thread = threading.Thread(
+                target=lambda: asyncio.run(daemon_main(config)), daemon=True
+            )
+            daemon_thread.start()
+
+            # Wait for daemon to be ready (max 3 seconds)
+            for _ in range(30):
+                time.sleep(0.1)
+                try:
+                    resp = requests.get(f"http://{host}:{port}/api/health", timeout=1)
+                    if resp.status_code == 200:
+                        print(f"{GREEN}✓{RESET}")
+                        daemon_running = True
+                        break
+                except (requests.RequestException, requests.ConnectionError):
+                    pass
+            else:
+                print(f"{RED}✗{RESET} Failed (timeout)")
+                return 1
+
+        # If daemon-only mode, keep running until interrupted
+        if no_chat:
+            print(f"\n{CYAN}Daemon running.{RESET} API at http://{host}:{port}")
+            print(f"{DIM}Press Ctrl+C to stop{RESET}\n")
+            try:
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print(f"\n{DIM}Shutting down...{RESET}")
+                return 0
 
-        # Run commander
+        # Launch interactive chat
+        print(f"\n{CYAN}Entering Commander chat...{RESET}\n")
         asyncio.run(run_commander(port=port, state_dir=state_dir))
 
         return 0
@@ -43,4 +212,5 @@ def handle_commander_command(args) -> int:
         return 0
     except Exception as e:
         logger.error(f"Commander error: {e}", exc_info=True)
+        print(f"{RED}Error:{RESET} {e}")
         return 1

claude_mpm/cli/commands/skill_source.py

@@ -11,6 +11,7 @@ for better UX. Handles errors gracefully with actionable messages.
 
 import json
 import logging
+import os
 import re
 
 from ...config.skill_sources import SkillSource, SkillSourceConfiguration
@@ -20,6 +21,33 @@ from ...services.skills.skill_discovery_service import SkillDiscoveryService
 logger = logging.getLogger(__name__)
 
 
+def _get_github_token(source: SkillSource | None = None) -> str | None:
+    """Get GitHub token with source-specific override support.
+
+    Priority: source.token > GITHUB_TOKEN > GH_TOKEN
+
+    Args:
+        source: Optional SkillSource to check for per-source token
+
+    Returns:
+        GitHub token if found, None otherwise
+
+    Security Note:
+        Token is never logged or printed to avoid exposure.
+    """
+    # Priority 1: Per-source token (env var reference or direct)
+    if source and source.token:
+        if source.token.startswith("$"):
+            # Env var reference: $VAR_NAME -> os.environ.get("VAR_NAME")
+            env_var_name = source.token[1:]
+            return os.environ.get(env_var_name)
+        # Direct token (not recommended but supported)
+        return source.token
+
+    # Priority 2-3: Global environment variables
+    return os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+
+
 def _test_skill_repository_access(source: SkillSource) -> dict:
     """Test if skill repository is accessible via GitHub API.
 
@@ -58,7 +86,13 @@ def _test_skill_repository_access(source: SkillSource) -> dict:
         # Test GitHub API access
         api_url = f"https://api.github.com/repos/{owner_repo}"
 
-        response = requests.get(api_url, timeout=10)
+        # Build headers with authentication if token available
+        headers = {"Accept": "application/vnd.github+json"}
+        token = _get_github_token(source)
+        if token:
+            headers["Authorization"] = f"token {token}"
+
+        response = requests.get(api_url, headers=headers, timeout=10)
 
         if response.status_code == 200:
             return {"accessible": True, "error": None}
@@ -68,9 +102,14 @@ def _test_skill_repository_access(source: SkillSource) -> dict:
                 "error": f"Repository not found: {owner_repo}",
             }
         if response.status_code == 403:
+            error_msg = "Access denied (private repository or rate limit)"
+            if not token:
+                error_msg += (
+                    ". Try setting GITHUB_TOKEN environment variable for private repos"
+                )
             return {
                 "accessible": False,
-                "error": "Access denied (private repository or rate limit)",
+                "error": error_msg,
             }
         return {
             "accessible": False,
@@ -263,6 +302,15 @@ def handle_add_skill_source(args) -> int:
 
         # Create new source
         enabled = not args.disabled
+        token = getattr(args, "token", None)
+
+        # Security warning for direct tokens
+        if token and not token.startswith("$"):
+            print("⚠️  Warning: Direct token values in config are not recommended")
+            print("   Consider using environment variable reference instead:")
+            print("   --token $MY_PRIVATE_TOKEN")
+            print()
+
         source = SkillSource(
             id=source_id,
             type="git",
@@ -270,6 +318,7 @@ def handle_add_skill_source(args) -> int:
             branch=args.branch,
             priority=args.priority,
             enabled=enabled,
+            token=token,
         )
 
         # Determine if we should test

claude_mpm/cli/commands/skills.py

@@ -538,6 +538,7 @@ class SkillsManagementCommand(BaseCommand):
             toolchain = getattr(args, "toolchain", None)
             categories = getattr(args, "categories", None)
             force = getattr(args, "force", False)
+            deploy_all = getattr(args, "all", False)
 
             if collection:
                 console.print(
@@ -548,14 +549,15 @@ class SkillsManagementCommand(BaseCommand):
                     "\n[bold cyan]Deploying skills from default collection...[/bold cyan]\n"
                 )
 
-            # Selective deployment is ALWAYS enabled (deploy only agent-referenced skills)
-            # This ensures only skills linked to deployed agents are deployed
+            # Use selective deployment unless --all flag is provided
+            # Selective mode deploys only agent-referenced skills
+            # --all mode deploys all available skills from the collection
             result = self.skills_deployer.deploy_skills(
                 collection=collection,
                 toolchain=toolchain,
                 categories=categories,
                 force=force,
-                selective=True,  # Always use selective deployment
+                selective=not deploy_all,
             )
 
             # Display results

claude_mpm/cli/parsers/commander_parser.py

@@ -23,17 +23,21 @@ def add_commander_subparser(subparsers: argparse._SubParsersAction) -> None:
     """
     commander_parser = subparsers.add_parser(
         "commander",
-        help="Interactive Commander mode for managing multiple Claude instances",
+        help="Launch Commander multi-project orchestration (ALPHA)",
         description="""
-Commander Mode - Interactive Instance Management
+Commander Mode - Multi-Project Orchestration (ALPHA)
 
-Commander provides an interactive REPL interface for:
-- Starting and stopping Claude Code/MPM instances in tmux
-- Connecting to instances and sending natural language commands
-- Managing multiple concurrent projects
-- Viewing instance status and output
+The commander subcommand auto-starts the Commander daemon (if not already running)
+and launches an interactive REPL for managing multiple Claude Code instances.
 
-Commands:
+Commander provides:
+- Auto-starting daemon that manages project lifecycles
+- Interactive REPL for controlling instances
+- Tmux-based session management
+- Real-time output monitoring
+- REST API for external control (http://127.0.0.1:8765)
+
+REPL Commands:
   list, ls, instances   List active instances
   start <path>          Start new instance at path
     --framework <cc|mpm>  Specify framework (default: cc)
@@ -50,7 +54,16 @@ Natural Language:
   command will be sent to the connected instance as a message.
 
 Examples:
+  # Start daemon and launch interactive chat
   claude-mpm commander
+
+  # Start daemon only (no chat interface)
+  claude-mpm commander --daemon-only
+
+  # Use custom port
+  claude-mpm commander --port 9000
+
+  # In REPL:
   > start ~/myproject --framework cc --name myapp
   > connect myapp
   > Fix the authentication bug in login.py
@@ -81,3 +94,23 @@ Examples:
         action="store_true",
         help="Enable debug logging",
     )
+
+    # Daemon auto-start options
+    commander_parser.add_argument(
+        "--host",
+        type=str,
+        default="127.0.0.1",
+        help="Daemon host (default: 127.0.0.1)",
+    )
+
+    commander_parser.add_argument(
+        "--no-chat",
+        action="store_true",
+        help="Start daemon only without interactive chat",
+    )
+
+    commander_parser.add_argument(
+        "--daemon-only",
+        action="store_true",
+        help="Alias for --no-chat (start daemon only)",
+    )

claude_mpm/cli/parsers/skill_source_parser.py

@@ -76,6 +76,10 @@ def add_skill_source_subparser(subparsers) -> argparse.ArgumentParser:
         dest="skip_test",
         help="Skip immediate testing (not recommended)",
     )
+    add_parser.add_argument(
+        "--token",
+        help="GitHub token or env var reference (e.g., ghp_xxx or $PRIVATE_TOKEN)",
+    )
 
     # Remove repository
     remove_parser = skill_source_subparsers.add_parser(

claude_mpm/cli/parsers/skills_parser.py

@@ -167,6 +167,11 @@ def add_skills_subparser(subparsers) -> argparse.ArgumentParser:
         action="store_true",
         help="Force redeployment of already deployed skills",
     )
+    deploy_github_parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Deploy all available skills, not just agent-referenced ones",
+    )
 
     # List available GitHub skills
     list_available_parser = skills_subparsers.add_parser(

claude_mpm/cli/startup.py

@@ -210,7 +210,16 @@ def should_skip_background_services(args, processed_argv):
     return any(cmd in (processed_argv or sys.argv[1:]) for cmd in skip_commands) or (
         hasattr(args, "command")
         and args.command
-        in ["info", "doctor", "config", "mcp", "configure", "hook-errors", "autotodos"]
+        in [
+            "info",
+            "doctor",
+            "config",
+            "mcp",
+            "configure",
+            "hook-errors",
+            "autotodos",
+            "commander",
+        ]
     )
 
 

claude_mpm/cli/startup_display.py

@@ -540,7 +540,8 @@ def should_show_banner(args) -> bool:
         return False
 
     # Check for commands that should skip banner
-    skip_commands = {"info", "doctor", "config", "configure"}
+    # Commander has its own banner, so skip the main MPM banner
+    skip_commands = {"info", "doctor", "config", "configure", "commander"}
     if hasattr(args, "command") and args.command in skip_commands:
         return False
 

claude_mpm/commander/__init__.py

@@ -12,12 +12,18 @@ Key Components:
     - ProjectSession: Per-project lifecycle management
     - InstanceManager: Framework selection and instance lifecycle
     - Frameworks: Claude Code, MPM framework abstractions
+    - Memory: Conversation storage, semantic search, context compression
 
 Example:
     >>> from claude_mpm.commander import ProjectRegistry
     >>> registry = ProjectRegistry()
     >>> project = registry.register("/path/to/project")
     >>> registry.update_state(project.id, ProjectState.WORKING)
+
+    >>> # Memory integration
+    >>> from claude_mpm.commander.memory import MemoryIntegration
+    >>> memory = MemoryIntegration.create()
+    >>> await memory.capture_project_conversation(project)
 """
 
 from claude_mpm.commander.config import DaemonConfig

claude_mpm/commander/adapters/__init__.py

@@ -6,26 +6,55 @@ the TmuxOrchestrator to interface with various runtimes in a uniform way.
 Two types of adapters:
 - RuntimeAdapter: Synchronous parsing and state detection
 - CommunicationAdapter: Async I/O and state management
+
+Available Runtime Adapters:
+- ClaudeCodeAdapter: Vanilla Claude Code CLI
+- AuggieAdapter: Auggie with MCP support
+- CodexAdapter: Codex (limited features)
+- MPMAdapter: Full MPM with agents, hooks, skills, monitoring
+
+Registry:
+- AdapterRegistry: Centralized adapter management with auto-detection
 """
 
-from .base import Capability, ParsedResponse, RuntimeAdapter
+from .auggie import AuggieAdapter
+from .base import (
+    Capability,
+    ParsedResponse,
+    RuntimeAdapter,
+    RuntimeCapability,
+    RuntimeInfo,
+)
 from .claude_code import ClaudeCodeAdapter
+from .codex import CodexAdapter
 from .communication import (
     AdapterResponse,
     AdapterState,
     BaseCommunicationAdapter,
     ClaudeCodeCommunicationAdapter,
 )
+from .mpm import MPMAdapter
+from .registry import AdapterRegistry
+
+# Auto-register all adapters
+AdapterRegistry.register("claude-code", ClaudeCodeAdapter)
+AdapterRegistry.register("auggie", AuggieAdapter)
+AdapterRegistry.register("codex", CodexAdapter)
+AdapterRegistry.register("mpm", MPMAdapter)
 
 __all__ = [
-    # Communication adapters (async I/O)
+    "AdapterRegistry",
     "AdapterResponse",
     "AdapterState",
+    "AuggieAdapter",
     "BaseCommunicationAdapter",
-    # Runtime adapters (parsing)
     "Capability",
     "ClaudeCodeAdapter",
     "ClaudeCodeCommunicationAdapter",
+    "CodexAdapter",
+    "MPMAdapter",
     "ParsedResponse",
     "RuntimeAdapter",
+    "RuntimeCapability",
+    "RuntimeInfo",
 ]