claude-mpm 5.4.96__py3-none-any.whl → 5.6.17__py3-none-any.whl

claude_mpm/cli/commands/hook_errors.py

@@ -57,33 +57,33 @@ def list_errors(format, hook_type):
 
     if not errors:
         if hook_type:
-            click.echo(f"No errors recorded for hook type: {hook_type}")
+            click.echo(f"No errors recorded for hook type: {hook_type}", err=True)
         else:
-            click.echo("No errors recorded. Hook system is healthy! ✅")
+            click.echo("No errors recorded. Hook system is healthy! ✅", err=True)
         return
 
     if format == "json":
         # JSON output
-        click.echo(json.dumps(errors, indent=2))
+        click.echo(json.dumps(errors, indent=2), err=True)
     else:
         # Table output
-        click.echo("\n" + "=" * 80)
-        click.echo("Hook Error Memory Report")
-        click.echo("=" * 80)
+        click.echo("\n" + "=" * 80, err=True)
+        click.echo("Hook Error Memory Report", err=True)
+        click.echo("=" * 80, err=True)
 
         for key, data in errors.items():
-            click.echo(f"\n🔴 Error: {data['type']}")
-            click.echo(f"   Hook Type: {data['hook_type']}")
-            click.echo(f"   Details: {data['details']}")
-            click.echo(f"   Match: {data['match']}")
-            click.echo(f"   Count: {data['count']} occurrences")
-            click.echo(f"   First Seen: {data['first_seen']}")
-            click.echo(f"   Last Seen: {data['last_seen']}")
+            click.echo(f"\n🔴 Error: {data['type']}", err=True)
+            click.echo(f"   Hook Type: {data['hook_type']}", err=True)
+            click.echo(f"   Details: {data['details']}", err=True)
+            click.echo(f"   Match: {data['match']}", err=True)
+            click.echo(f"   Count: {data['count']} occurrences", err=True)
+            click.echo(f"   First Seen: {data['first_seen']}", err=True)
+            click.echo(f"   Last Seen: {data['last_seen']}", err=True)
 
-        click.echo("\n" + "=" * 80)
-        click.echo(f"Total unique errors: {len(errors)}")
-        click.echo(f"Memory file: {error_memory.memory_file}")
-        click.echo("\nTo clear errors: claude-mpm hook-errors clear")
+        click.echo("\n" + "=" * 80, err=True)
+        click.echo(f"Total unique errors: {len(errors)}", err=True)
+        click.echo(f"Memory file: {error_memory.memory_file}", err=True)
+        click.echo("\nTo clear errors: claude-mpm hook-errors clear", err=True)
 
 
 @hook_errors_group.command(name="summary")
@@ -99,28 +99,28 @@ def show_summary():
     summary = error_memory.get_error_summary()
 
     if summary["total_errors"] == 0:
-        click.echo("No errors recorded. Hook system is healthy! ✅")
+        click.echo("No errors recorded. Hook system is healthy! ✅", err=True)
         return
 
-    click.echo("\n" + "=" * 80)
-    click.echo("Hook Error Summary")
-    click.echo("=" * 80)
-    click.echo("\n📊 Statistics:")
-    click.echo(f"   Total Errors: {summary['total_errors']}")
-    click.echo(f"   Unique Errors: {summary['unique_errors']}")
+    click.echo("\n" + "=" * 80, err=True)
+    click.echo("Hook Error Summary", err=True)
+    click.echo("=" * 80, err=True)
+    click.echo("\n📊 Statistics:", err=True)
+    click.echo(f"   Total Errors: {summary['total_errors']}", err=True)
+    click.echo(f"   Unique Errors: {summary['unique_errors']}", err=True)
 
     if summary["errors_by_type"]:
-        click.echo("\n🔍 Errors by Type:")
+        click.echo("\n🔍 Errors by Type:", err=True)
         for error_type, count in summary["errors_by_type"].items():
-            click.echo(f"   {error_type}: {count}")
+            click.echo(f"   {error_type}: {count}", err=True)
 
     if summary["errors_by_hook"]:
-        click.echo("\n🎣 Errors by Hook Type:")
+        click.echo("\n🎣 Errors by Hook Type:", err=True)
         for hook_type, count in summary["errors_by_hook"].items():
-            click.echo(f"   {hook_type}: {count}")
+            click.echo(f"   {hook_type}: {count}", err=True)
 
-    click.echo(f"\n📁 Memory File: {summary['memory_file']}")
-    click.echo("\nFor detailed list: claude-mpm hook-errors list")
+    click.echo(f"\n📁 Memory File: {summary['memory_file']}", err=True)
+    click.echo("\nFor detailed list: claude-mpm hook-errors list", err=True)
 
 
 @hook_errors_group.command(name="clear")
@@ -158,21 +158,21 @@ def clear_errors(hook_type, yes):
         scope = "all hook types"
 
     if count == 0:
-        click.echo(f"No errors to clear {scope}.")
+        click.echo(f"No errors to clear {scope}.", err=True)
         return
 
     # Confirm if not using -y flag
     if not yes:
         message = f"Clear {count} error(s) {scope}?"
         if not click.confirm(message):
-            click.echo("Cancelled.")
+            click.echo("Cancelled.", err=True)
             return
 
     # Clear errors
     error_memory.clear_errors(hook_type)
 
-    click.echo(f"✅ Cleared {count} error(s) {scope}.")
-    click.echo("\nHooks will be retried on next execution.")
+    click.echo(f"✅ Cleared {count} error(s) {scope}.", err=True)
+    click.echo("\nHooks will be retried on next execution.", err=True)
 
 
 @hook_errors_group.command(name="diagnose")
@@ -201,19 +201,19 @@ def diagnose_errors(hook_type):
 
     if not errors:
         if hook_type:
-            click.echo(f"No errors to diagnose for hook type: {hook_type}")
+            click.echo(f"No errors to diagnose for hook type: {hook_type}", err=True)
         else:
-            click.echo("No errors to diagnose. Hook system is healthy! ✅")
+            click.echo("No errors to diagnose. Hook system is healthy! ✅", err=True)
         return
 
-    click.echo("\n" + "=" * 80)
-    click.echo("Hook Error Diagnostics")
-    click.echo("=" * 80)
+    click.echo("\n" + "=" * 80, err=True)
+    click.echo("Hook Error Diagnostics", err=True)
+    click.echo("=" * 80, err=True)
 
     for key, data in errors.items():
-        click.echo(f"\n🔴 Error: {data['type']}")
-        click.echo(f"   Hook: {data['hook_type']}")
-        click.echo(f"   Count: {data['count']} failures")
+        click.echo(f"\n🔴 Error: {data['type']}", err=True)
+        click.echo(f"   Hook: {data['hook_type']}", err=True)
+        click.echo(f"   Count: {data['count']} failures", err=True)
 
         # Generate and show fix suggestion
         error_info = {
@@ -223,13 +223,13 @@ def diagnose_errors(hook_type):
         }
         suggestion = error_memory.suggest_fix(error_info)
 
-        click.echo("\n" + "-" * 80)
-        click.echo(suggestion)
-        click.echo("-" * 80)
+        click.echo("\n" + "-" * 80, err=True)
+        click.echo(suggestion, err=True)
+        click.echo("-" * 80, err=True)
 
-    click.echo("\n" + "=" * 80)
-    click.echo("After fixing issues, clear errors to retry:")
-    click.echo("  claude-mpm hook-errors clear")
+    click.echo("\n" + "=" * 80, err=True)
+    click.echo("After fixing issues, clear errors to retry:", err=True)
+    click.echo("  claude-mpm hook-errors clear", err=True)
 
 
 @hook_errors_group.command(name="status")
@@ -244,27 +244,27 @@ def show_status():
     error_memory = get_hook_error_memory()
     summary = error_memory.get_error_summary()
 
-    click.echo("\n📊 Hook Error Memory Status")
-    click.echo("=" * 80)
+    click.echo("\n📊 Hook Error Memory Status", err=True)
+    click.echo("=" * 80, err=True)
 
     if summary["total_errors"] == 0:
-        click.echo("✅ Status: Healthy (no errors recorded)")
+        click.echo("✅ Status: Healthy (no errors recorded)", err=True)
     else:
-        click.echo(f"⚠️  Status: {summary['total_errors']} error(s) recorded")
-        click.echo(f"   Unique errors: {summary['unique_errors']}")
+        click.echo(f"⚠️  Status: {summary['total_errors']} error(s) recorded", err=True)
+        click.echo(f"   Unique errors: {summary['unique_errors']}", err=True)
 
         # Show which hooks are affected
         if summary["errors_by_hook"]:
             affected_hooks = list(summary["errors_by_hook"].keys())
-            click.echo(f"   Affected hooks: {', '.join(affected_hooks)}")
+            click.echo(f"   Affected hooks: {', '.join(affected_hooks)}", err=True)
 
-    click.echo(f"\n📁 Memory file: {summary['memory_file']}")
-    click.echo(f"   Exists: {Path(summary['memory_file']).exists()}")
+    click.echo(f"\n📁 Memory file: {summary['memory_file']}", err=True)
+    click.echo(f"   Exists: {Path(summary['memory_file']).exists()}", err=True)
 
-    click.echo("\nCommands:")
-    click.echo("  claude-mpm hook-errors list      # View detailed errors")
-    click.echo("  claude-mpm hook-errors diagnose  # Get fix suggestions")
-    click.echo("  claude-mpm hook-errors clear     # Clear and retry")
+    click.echo("\nCommands:", err=True)
+    click.echo("  claude-mpm hook-errors list      # View detailed errors", err=True)
+    click.echo("  claude-mpm hook-errors diagnose  # Get fix suggestions", err=True)
+    click.echo("  claude-mpm hook-errors clear     # Clear and retry", err=True)
 
 
 # Register the command group

claude_mpm/cli/commands/run.py

@@ -13,7 +13,7 @@ DESIGN DECISIONS:
 - Support multiple output formats (json, yaml, table, text)
 """
 
-import subprocess
+import subprocess  # nosec B404 - required for process management
 import sys
 from datetime import datetime, timezone
 from typing import Optional
@@ -489,6 +489,18 @@ class RunCommand(BaseCommand):
         if hasattr(args, "claude_args") and args.claude_args:
             claude_args.extend(args.claude_args)
 
+        # Add --resume if flag is set
+        if getattr(args, "resume", False) and "--resume" not in claude_args:
+            claude_args.insert(0, "--resume")
+
+        # Add --chrome if flag is set
+        if getattr(args, "chrome", False) and "--chrome" not in claude_args:
+            claude_args.insert(0, "--chrome")
+
+        # Add --no-chrome if flag is set
+        if getattr(args, "no_chrome", False) and "--no-chrome" not in claude_args:
+            claude_args.insert(0, "--no-chrome")
+
         # Create runner
         runner = ClaudeRunner(
             enable_tickets=enable_tickets,
@@ -553,7 +565,7 @@ class RunCommand(BaseCommand):
                 wrapper_path = get_scripts_dir() / "interactive_wrapper.py"
                 if wrapper_path.exists():
                     print("Starting interactive session with command interception...")
-                    subprocess.run([sys.executable, str(wrapper_path)], check=False)
+                    subprocess.run([sys.executable, str(wrapper_path)], check=False)  # nosec B603 - trusted internal paths
                 else:
                     self.logger.warning(
                         "Interactive wrapper not found, falling back to normal mode"
@@ -907,6 +919,26 @@ def run_session_legacy(args):
         else:
             logger.info("[INFO]️ --resume already in claude_args")
 
+    # Add --chrome to claude_args if the flag is set
+    chrome_flag_present = getattr(args, "chrome", False)
+    if chrome_flag_present:
+        logger.info("📌 --chrome flag detected in args")
+        if "--chrome" not in raw_claude_args:
+            raw_claude_args = ["--chrome", *raw_claude_args]
+            logger.info("✅ Added --chrome to claude_args")
+        else:
+            logger.info("ℹ️ --chrome already in claude_args")
+
+    # Add --no-chrome to claude_args if the flag is set
+    no_chrome_flag_present = getattr(args, "no_chrome", False)
+    if no_chrome_flag_present:
+        logger.info("📌 --no-chrome flag detected in args")
+        if "--no-chrome" not in raw_claude_args:
+            raw_claude_args = ["--no-chrome", *raw_claude_args]
+            logger.info("✅ Added --no-chrome to claude_args")
+        else:
+            logger.info("ℹ️ --no-chrome already in claude_args")
+
     # Filter out claude-mpm specific flags before passing to Claude CLI
     logger.debug(f"Pre-filter claude_args: {raw_claude_args}")
     claude_args = filter_claude_mpm_args(raw_claude_args)
@@ -1044,7 +1076,7 @@ def run_session_legacy(args):
         wrapper_path = get_scripts_dir() / "interactive_wrapper.py"
         if wrapper_path.exists():
             print("Starting interactive session with command interception...")
-            subprocess.run([sys.executable, str(wrapper_path)], check=False)
+            subprocess.run([sys.executable, str(wrapper_path)], check=False)  # nosec B603 - trusted internal paths
         else:
             logger.warning("Interactive wrapper not found, falling back to normal mode")
             runner.run_interactive(context)

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/executor.py

@@ -127,6 +127,14 @@ def execute_command(command: str, args) -> int:
         result = handle_verify(args)
         return result if result is not None else 0
 
+    # Handle commander command with lazy import
+    if command == "commander":
+        # Lazy import to avoid loading unless needed
+        from .commands.commander import handle_commander_command
+
+        result = handle_commander_command(args)
+        return result if result is not None else 0
+
     # Handle skill-source command with lazy import
     if command == "skill-source":
         # Lazy import to avoid loading unless needed
@@ -206,27 +214,33 @@ def execute_command(command: str, args) -> int:
             "status": show_status,
         }
 
-        # Get handler and invoke
+        # Get handler and call it with argument list (same pattern as autotodos)
         handler = handlers.get(subcommand)
         if handler:
-            # Build Click context programmatically
-            import click
-
-            ctx = click.Context(command=handler)
+            try:
+                # Build argument list for Click command based on subcommand
+                click_args = []
 
-            # Prepare keyword arguments from args
-            kwargs = {}
-            if hasattr(args, "format"):
-                kwargs["format"] = args.format
-            if hasattr(args, "hook_type"):
-                kwargs["hook_type"] = args.hook_type
-            if hasattr(args, "yes"):
-                kwargs["yes"] = args.yes
+                # list command: --format, --hook-type
+                if subcommand == "list":
+                    if hasattr(args, "format") and args.format:
+                        click_args.extend(["--format", args.format])
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.extend(["--hook-type", args.hook_type])
+                # clear command: --hook-type, -y
+                elif subcommand == "clear":
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.extend(["--hook-type", args.hook_type])
+                    if hasattr(args, "yes") and args.yes:
+                        click_args.append("-y")
+                # diagnose command: hook_type (positional argument)
+                elif subcommand == "diagnose":
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.append(args.hook_type)
+                # status and summary commands: no options
 
-            try:
-                # Invoke handler with arguments
-                with ctx:
-                    handler.invoke(ctx, **kwargs)
+                # Call Click command with argument list and standalone_mode=False
+                handler(click_args, standalone_mode=False)
                 return 0
             except SystemExit as e:
                 return e.code if e.code is not None else 0
@@ -346,6 +360,7 @@ def execute_command(command: str, args) -> int:
         CLICommands.SKILLS.value: manage_skills,
         "debug": manage_debug,  # Add debug command
         "mpm-init": None,  # Will be handled separately with lazy import
+        "commander": None,  # Will be handled separately with lazy import
     }
 
     # Execute command if found

claude_mpm/cli/parsers/base_parser.py

@@ -297,6 +297,16 @@ def add_top_level_run_arguments(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Force refresh agents and skills from remote repos, bypassing ETag cache",
     )
+    run_group.add_argument(
+        "--chrome",
+        action="store_true",
+        help="Enable Claude in Chrome integration (passed to Claude Code)",
+    )
+    run_group.add_argument(
+        "--no-chrome",
+        action="store_true",
+        help="Disable Claude in Chrome integration (passed to Claude Code)",
+    )
 
     # Dependency checking options (for backward compatibility at top level)
     dep_group_top = parser.add_argument_group(
@@ -492,6 +502,13 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .commander_parser import add_commander_subparser
+
+        add_commander_subparser(subparsers)
+    except ImportError:
+        pass
+
     # Add uninstall command parser
     try:
         from ..commands.uninstall import add_uninstall_parser

claude_mpm/cli/parsers/commander_parser.py

@@ -0,0 +1,116 @@
+"""
+Commander parser module for claude-mpm CLI.
+
+WHY: This module provides the commander subcommand for interactive instance management
+and chat interface.
+
+DESIGN DECISION: Uses subparser pattern consistent with other commands (run, agents, etc.)
+to provide a clean interface for Commander mode.
+"""
+
+import argparse
+from pathlib import Path
+
+
+def add_commander_subparser(subparsers: argparse._SubParsersAction) -> None:
+    """
+    Add commander subcommand parser.
+
+    WHY: Provides interactive mode for managing and chatting with multiple Claude instances.
+
+    Args:
+        subparsers: The subparsers object to add the commander parser to
+    """
+    commander_parser = subparsers.add_parser(
+        "commander",
+        help="Launch Commander multi-project orchestration (ALPHA)",
+        description="""
+Commander Mode - Multi-Project Orchestration (ALPHA)
+
+The commander subcommand auto-starts the Commander daemon (if not already running)
+and launches an interactive REPL for managing multiple Claude Code instances.
+
+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)
+    --name <name>         Specify instance name (default: dir name)
+  stop <name>           Stop an instance
+  connect <name>        Connect to an instance
+  disconnect            Disconnect from current instance
+  status                Show current session status
+  help                  Show help message
+  exit, quit, q         Exit Commander
+
+Natural Language:
+  When connected to an instance, any input that is not a built-in
+  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
+  > disconnect
+  > exit
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    # Optional: Port for internal services
+    commander_parser.add_argument(
+        "--port",
+        type=int,
+        default=8765,
+        help="Port for internal services (default: 8765)",
+    )
+
+    # Optional: State directory
+    commander_parser.add_argument(
+        "--state-dir",
+        type=Path,
+        help="Directory for state persistence (optional)",
+    )
+
+    # Debug mode
+    commander_parser.add_argument(
+        "--debug",
+        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/run_parser.py

@@ -85,6 +85,16 @@ def add_run_arguments(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Pass --resume flag to Claude Code to resume the last conversation",
     )
+    run_group.add_argument(
+        "--chrome",
+        action="store_true",
+        help="Enable Claude in Chrome integration (passed to Claude Code)",
+    )
+    run_group.add_argument(
+        "--no-chrome",
+        action="store_true",
+        help="Disable Claude in Chrome integration (passed to Claude Code)",
+    )
 
     # Dependency checking options
     dep_group = parser.add_argument_group("dependency options")

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(