stravinsky 0.2.67__py3-none-any.whl → 0.4.66__py3-none-any.whl

mcp_bridge/cli/install_hooks.py

@@ -17,16 +17,12 @@ Hooks provide enhanced Claude Code behavior including:
 """
 
 import json
-import os
-import shutil
 import sys
 from pathlib import Path
-from typing import Dict, List, Any
-
 
 # Hook file contents - these will be written to ~/.claude/hooks/
 HOOKS = {
-    "truncator.py": '''import os
+    "truncator.py": """import os
 import sys
 import json
 
@@ -49,8 +45,7 @@ def main():
 
 if __name__ == "__main__":
     main()
-''',
-
+""",
     "edit_recovery.py": '''#!/usr/bin/env python3
 """Edit error recovery hook - detects edit failures and forces file reading."""
 import json
@@ -94,8 +89,7 @@ def main():
 if __name__ == "__main__":
     sys.exit(main())
 ''',
-
-    "context.py": '''import os
+    "context.py": """import os
 import sys
 import json
 from pathlib import Path
@@ -133,8 +127,7 @@ def main():
 
 if __name__ == "__main__":
     main()
-''',
-
+""",
     "parallel_execution.py": '''#!/usr/bin/env python3
 """
 UserPromptSubmit hook: Pre-emptive parallel execution enforcement.
@@ -157,11 +150,10 @@ STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
 def detect_stravinsky_invocation(prompt):
     """Detect if /stravinsky skill is being invoked."""
     patterns = [
-        r'/stravinsky',
-        r'<command-name>/stravinsky</command-name>',
-        r'stravinsky orchestrator',
-        r'ultrawork',
-        r'ultrathink',
+        r"/stravinsky",
+        r"<command-name>/stravinsky</command-name>",
+        r"stravinsky orchestrator",
+        r"\bultrawork\b",
     ]
     prompt_lower = prompt.lower()
     return any(re.search(p, prompt_lower) for p in patterns)
@@ -247,7 +239,6 @@ Task(subagent_type="Explore", prompt="Task 3 details", description="Task 3", run
 if __name__ == "__main__":
     sys.exit(main())
 ''',
-
     "todo_continuation.py": '''#!/usr/bin/env python3
 """
 UserPromptSubmit hook: Todo Continuation Enforcer
@@ -339,7 +330,6 @@ def main():
 if __name__ == "__main__":
     sys.exit(main())
 ''',
-
     "todo_delegation.py": '''#!/usr/bin/env python3
 """
 PostToolUse hook for TodoWrite: CRITICAL parallel execution enforcer.
@@ -429,7 +419,6 @@ Your NEXT action MUST be multiple Task() calls, one for each independent TODO.
 if __name__ == "__main__":
     sys.exit(main())
 ''',
-
     "stravinsky_mode.py": '''#!/usr/bin/env python3
 """
 Stravinsky Mode Enforcer Hook
@@ -575,7 +564,6 @@ To exit stravinsky mode, run:
 if __name__ == "__main__":
     main()
 ''',
-
     "tool_messaging.py": '''#!/usr/bin/env python3
 """
 PostToolUse hook for user-friendly tool messaging.
@@ -741,7 +729,6 @@ def main():
 if __name__ == "__main__":
     main()
 ''',
-
     "notification_hook.py": '''#!/usr/bin/env python3
 """
 Notification hook for agent spawn messages.
@@ -846,7 +833,6 @@ def main():
 if __name__ == "__main__":
     sys.exit(main())
 ''',
-
     "subagent_stop.py": '''#!/usr/bin/env python3
 """
 SubagentStop hook: Handler for agent/subagent completion events.
@@ -946,7 +932,6 @@ def main():
 if __name__ == "__main__":
     sys.exit(main())
 ''',
-
     "pre_compact.py": '''#!/usr/bin/env python3
 """
 PreCompact hook: Context preservation before compaction.
@@ -1024,7 +1009,7 @@ def log_compaction(preserved: List[str], stravinsky_active: bool):
     ensure_state_dir()
 
     entry = {
-        "timestamp": datetime.utcnow().isoformat(),
+        "timestamp": datetime.now(timezone.utc).isoformat(),
         "preserved_count": len(preserved),
         "stravinsky_mode": stravinsky_active,
         "preview": [p[:50] for p in preserved[:3]],
@@ -1070,6 +1055,456 @@ def main():
 
 if __name__ == "__main__":
     sys.exit(main())
+''',
+    "stop_hook.py": '''#!/usr/bin/env -S uv run --script
+
+# /// script
+# requires-python = ">=3.8"
+# dependencies = [
+#     "anthropic",
+#     "python-dotenv",
+# ]
+
+"""
+Fix Stop Hook - Calls stravinsky_metrics.py on Stop events.
+
+This hook is triggered by .claude/settings.json on Stop/SubagentStop.
+It queries Stravinsky's cost tracker and sends a StravinskyMetrics event to the dashboard.
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+# Add hooks directory to path for script imports
+hooks_dir = Path(__file__).parent
+sys.path.insert(0, str(hooks_dir))
+
+
+def send_stravinsky_metrics(session_id: str) -> bool:
+    """Call stravinsky_metrics.py to query and send metrics to dashboard."""
+    script_path = hooks_dir / "stravinsky_metrics.py"
+
+    if not script_path.exists():
+        print(f"Error: stravinsky_metrics.py not found at {script_path}", file=sys.stderr)
+        return False
+
+    try:
+        # Build command
+        cmd = [
+            "uv",
+            "run",
+            "--script",
+            str(script_path),
+            "--session-id",
+            session_id,
+            "--summarize",  # Generate summary and send as event
+        ]
+
+        # Run command
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=10, check=False)
+
+        if result.returncode != 0:
+            print(
+                f"Error: stravinsky_metrics.py failed with exit code {result.returncode}",
+                file=sys.stderr,
+            )
+            print(f"stderr: {result.stderr}", file=sys.stderr)
+            return False
+
+        return True
+
+    except subprocess.TimeoutExpired:
+        print(f"Error: stravinsky_metrics.py timed out after 10 seconds", file=sys.stderr)
+        return False
+
+    except Exception as e:
+        print(f"Error: stravinsky_metrics.py execution failed: {e}", file=sys.stderr)
+        return False
+
+
+def main():
+    # Get session_id from environment or use default
+    session_id = os.environ.get("CLAUDE_SESSION_ID", "default")
+
+    # Determine hook type
+    hook_type = os.environ.get("CLAUDE_HOOK_EVENT_TYPE", "Stop")
+
+    # Send metrics to dashboard
+    success = send_stravinsky_metrics(session_id)
+
+    if not success:
+        sys.exit(1)
+
+    print(
+        f"✓ Successfully sent Stravinsky metrics for session {session_id} to dashboard",
+        file=sys.stderr,
+    )
+
+
+if __name__ == "__main__":
+    main()
+''',
+    "stravinsky_metrics.py": '''#!/usr/bin/env python3
+"""
+Stravinsky Metrics Hook Script
+
+Queries Stravinsky's internal metrics and sends them to the observability dashboard.
+This hook is triggered on Stop/SubagentStop events.
+
+Usage:
+    stravinsky_metrics.py --session-id <session_id>
+
+Environment Variables:
+    CLAUDE_SESSION_ID: Fallback session ID if --session-id not provided
+
+Output:
+    Sends StravinskyMetrics event to dashboard via send_event.py
+
+Metrics Collected:
+    - Total session cost (USD)
+    - Total tokens used
+    - Per-agent cost and token breakdown
+    - Per-model cost and token breakdown (TODO)
+    - Agent count (active/total) (TODO)
+
+Error Handling:
+    Returns non-zero exit code on error to prevent blocking Claude Code operations.
+"""
+
+import sys
+import os
+import json
+import argparse
+import subprocess
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any
+from mcp_bridge.metrics.cost_tracker import CostTracker
+
+
+def load_usage_data(session_id: str) -> Dict[str, Any]:
+    """
+    Load usage data from Stravinsky's cost tracker.
+    
+    Uses CostTracker.get_session_summary() to get metrics for a session.
+
+    Args:
+        session_id: Claude Code session ID
+
+    Returns:
+        Dictionary with metrics data
+    """
+    summary = CostTracker.get_instance().get_session_summary(session_id)
+    
+    # Transform CostTracker summary to expected format
+    metrics = {
+        "total_cost": summary.get("total_cost", 0),
+        "total_tokens": summary.get("total_tokens", 0),
+        "by_agent": summary.get("by_agent", {}),
+        "by_model": {},  # Extract from summary if available
+    }
+    
+    return metrics
+
+
+def send_metrics_event(session_id: str, metrics: Dict[str, Any]) -> bool:
+    """
+    Send metrics event to observability dashboard via send_event.py.
+
+    Args:
+        session_id: Claude Code session ID
+        metrics: Metrics data dictionary
+
+    Returns:
+        True if successful, False otherwise
+    """
+    hook_dir = Path(__file__).parent
+    send_event_script = hook_dir / "send_event.py"
+
+    if not send_event_script.exists():
+        print(f"Error: send_event.py not found at {send_event_script}", file=sys.stderr)
+        return False
+
+    event_data = {
+        "session_id": session_id,
+        "metrics": metrics,
+        "timestamp": datetime.now().isoformat(),
+    }
+
+    cmd = [
+        "uv",
+        "run",
+        str(send_event_script),
+        "--source-app",
+        "stravinsky",
+        "--event-type",
+        "StravinskyMetrics",
+        "--summarize",
+    ]
+
+    try:
+        result = subprocess.run(
+            cmd, input=json.dumps(event_data), capture_output=True, text=True, timeout=10
+        )
+
+        if result.returncode != 0:
+            print(f"Error from send_event.py: {result.stderr}", file=sys.stderr)
+            return False
+
+        return True
+
+    except subprocess.TimeoutExpired:
+        print("Error: send_event.py timed out", file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f"Error running send_event.py: {e}", file=sys.stderr)
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Query Stravinsky metrics and send to dashboard")
+    parser.add_argument(
+        "--session-id", help="Claude Code session ID (falls back to CLAUDE_SESSION_ID env var)"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print metrics without sending to dashboard (for testing)",
+    )
+
+    args = parser.parse_args()
+
+    session_id = args.session_id or os.environ.get("CLAUDE_SESSION_ID", "default")
+
+    if not session_id or session_id == "default":
+        print("Warning: No session ID provided, using 'default'", file=sys.stderr)
+
+    metrics = load_usage_data(session_id)
+
+    if metrics is None:
+        print("Error: Failed to load metrics", file=sys.stderr)
+        sys.exit(1)
+
+    if args.dry_run:
+        print(json.dumps(metrics, indent=2))
+        sys.exit(0)
+
+    print(f"Stravinsky Metrics for session {session_id}:", file=sys.stderr)
+    print(f"  Total Cost: ${metrics['total_cost']:.6f}", file=sys.stderr)
+    print(f"  Total Tokens: {metrics['total_tokens']:,}", file=sys.stderr)
+    print(f"  Agents: {len(metrics['by_agent'])}", file=sys.stderr)
+
+    success = send_metrics_event(session_id, metrics)
+
+    if success:
+        print("Metrics sent to dashboard successfully", file=sys.stderr)
+        sys.exit(0)
+    else:
+        print("Failed to send metrics to dashboard", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+''',
+    "send_event.py": '''#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.8"
+# dependencies = [
+#     "anthropic",
+#     "python-dotenv",
+# ]
+# ///
+
+"""
+Multi-Agent Observability Hook Script
+Sends Claude Code hook events to the observability server.
+"""
+
+import json
+import sys
+import os
+import argparse
+import urllib.request
+import urllib.error
+import logging
+from datetime import datetime
+from pathlib import Path
+# from utils.summarizer import generate_event_summary
+# from utils.model_extractor import get_model_from_transcript
+# Note: commented out utils imports to prevent failure if utils are missing
+# If you need full functionality, ensure utils/ directory is also installed.
+
+def generate_event_summary(event_data):
+    return None
+
+def get_model_from_transcript(session_id, transcript_path):
+    return ""
+
+log_dir = Path.home() / ".claude/hooks/logs"
+log_dir.mkdir(parents=True, exist_ok=True)
+logging.basicConfig(
+    filename=log_dir / "event_sender.log",
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+
+def send_event_to_server(event_data, server_url="http://localhost:4000/events"):
+    """Send event data to the observability server."""
+    try:
+        # Prepare the request
+        req = urllib.request.Request(
+            server_url,
+            data=json.dumps(event_data).encode("utf-8"),
+            headers={"Content-Type": "application/json", "User-Agent": "Claude-Code-Hook/1.0"},
+        )
+
+        # Send the request
+        with urllib.request.urlopen(req, timeout=5) as response:
+            if response.status == 200:
+                return True
+            else:
+                logging.debug(f"Server returned status: {response.status}")
+                return False
+
+    except urllib.error.URLError as e:
+        logging.error(f"Failed to send event: {e}")
+        return False
+    except Exception as e:
+        logging.error(f"Unexpected error: {e}")
+        return False
+
+
+def main():
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(
+        description="Send Claude Code hook events to observability server"
+    )
+    parser.add_argument("--source-app", required=True, help="Source application name")
+    parser.add_argument(
+        "--event-type", required=True, help="Hook event type (PreToolUse, PostToolUse, etc.)"
+    )
+    parser.add_argument("--server-url", default="http://localhost:4000/events", help="Server URL")
+    parser.add_argument(
+        "--add-chat", action="store_true", help="Include chat transcript if available"
+    )
+    parser.add_argument("--summarize", action="store_true", help="Generate AI summary of the event")
+
+    # Stravinsky-specific metrics (optional)
+    parser.add_argument("--cost", type=float, help="Cost in USD (Stravinsky metrics)")
+    parser.add_argument(
+        "--prompt-tokens", type=int, help="Prompt token count (Stravinsky metrics)"
+    )
+    parser.add_argument(
+        "--completion-tokens", type=int, help="Completion token count (Stravinsky metrics)"
+    )
+    parser.add_argument("--agent-type", type=str, help="Agent type (Stravinsky metrics)")
+    parser.add_argument("--task-id", type=str, help="Task tracking ID (Stravinsky metrics)")
+    parser.add_argument(
+        "--hierarchy-level", type=int, help="Nesting depth (Stravinsky metrics)")
+    parser.add_argument(
+        "--parent-session-id", type=str, help="Parent session ID for hierarchy (Stravinsky metrics)")
+
+    args = parser.parse_args()
+
+    try:
+        # Read hook data from stdin
+        if not sys.stdin.isatty():
+            input_data = json.load(sys.stdin)
+        else:
+            input_data = {}
+    except json.JSONDecodeError as e:
+        # print(f"Failed to parse JSON input: {e}", file=sys.stderr)
+        # Fail gracefully if no input
+        input_data = {}
+
+    # Extract model name from transcript (with caching)
+    session_id = input_data.get("session_id", "unknown")
+    transcript_path = input_data.get("transcript_path", "")
+    model_name = ""
+    if transcript_path:
+        model_name = get_model_from_transcript(session_id, transcript_path)
+
+    # Build Stravinsky metrics (if any flags provided)
+    stravinsky_metrics = {}
+    if any(
+        [
+            args.cost,
+            args.prompt_tokens,
+            args.completion_tokens,
+            args.agent_type,
+            args.task_id,
+            args.parent_session_id,
+            args.hierarchy_level,
+        ]
+    ):
+        stravinsky_metrics = {
+            "cost_usd": args.cost,
+            "prompt_tokens": args.prompt_tokens,
+            "completion_tokens": args.completion_tokens,
+            "total_tokens": (args.prompt_tokens or 0) + (args.completion_tokens or 0),
+            "model": model_name,
+            "provider": "anthropic",
+            "agent_type": args.agent_type,
+            "task_id": args.task_id,
+            "parent_session_id": args.parent_session_id,
+            "hierarchy_level": args.hierarchy_level or 0,
+        }
+
+    # Prepare event data for server
+    event_data = {
+        "source_app": args.source_app,
+        "session_id": session_id,
+        "hook_event_type": args.event_type,
+        "payload": input_data,
+        "timestamp": int(datetime.now().timestamp() * 1000),
+        "model_name": model_name,
+    }
+
+    # Add Stravinsky metrics if provided
+    if stravinsky_metrics:
+        event_data["stravinsky"] = stravinsky_metrics
+
+    # Handle --add-chat option
+    if args.add_chat and "transcript_path" in input_data:
+        transcript_path = input_data["transcript_path"]
+        if os.path.exists(transcript_path):
+            # Read .jsonl file and convert to JSON array
+            chat_data = []
+            try:
+                with open(transcript_path, "r") as f:
+                    for line in f:
+                        line = line.strip()
+                        if line:
+                            try:
+                                chat_data.append(json.loads(line))
+                            except json.JSONDecodeError:
+                                pass  # Skip invalid lines
+
+                # Add chat to event data
+                event_data["chat"] = chat_data
+            except Exception as e:
+                print(f"Failed to read transcript: {e}", file=sys.stderr)
+
+    # Generate summary if requested
+    if args.summarize:
+        summary = generate_event_summary(event_data)
+        if summary:
+            event_data["summary"] = summary
+        # Continue even if summary generation fails
+
+    # Send to server
+    success = send_event_to_server(event_data, args.server_url)
+
+    # Always exit with 0 to not block Claude Code operations
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
 ''',
 }
 
@@ -1077,176 +1512,136 @@ if __name__ == "__main__":
 # Hook registration configuration for settings.json
 # IMPORTANT: Uses ~/.claude/hooks/ (global) paths so hooks work in ANY project
 HOOK_REGISTRATIONS = {
+    "Stop": [
+        {
+            "matcher": "*",
+            "hooks": [{"type": "command", "command": "python3 ~/.claude/hooks/stop_hook.py"}],
+        }
+    ],
     "Notification": [
         {
             "matcher": "*",
             "hooks": [
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/notification_hook.py"
-                }
-            ]
+                {"type": "command", "command": "python3 ~/.claude/hooks/notification_hook.py"}
+            ],
         }
     ],
     "SubagentStop": [
         {
             "matcher": "*",
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/subagent_stop.py"
-                }
-            ]
+            "hooks": [{"type": "command", "command": "python3 ~/.claude/hooks/subagent_stop.py"}],
         }
     ],
     "PreCompact": [
         {
             "matcher": "*",
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/pre_compact.py"
-                }
-            ]
+            "hooks": [{"type": "command", "command": "python3 ~/.claude/hooks/pre_compact.py"}],
         }
     ],
     "PreToolUse": [
         {
             "matcher": "Read,Search,Grep,Bash,Edit,MultiEdit",
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/stravinsky_mode.py"
-                }
-            ]
+            "hooks": [{"type": "command", "command": "python3 ~/.claude/hooks/stravinsky_mode.py"}],
         }
     ],
     "UserPromptSubmit": [
         {
             "matcher": "*",
             "hooks": [
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/parallel_execution.py"
-                },
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/context.py"
-                },
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/todo_continuation.py"
-                }
-            ]
+                {"type": "command", "command": "python3 ~/.claude/hooks/parallel_execution.py"},
+                {"type": "command", "command": "python3 ~/.claude/hooks/context.py"},
+                {"type": "command", "command": "python3 ~/.claude/hooks/todo_continuation.py"},
+            ],
         }
     ],
     "PostToolUse": [
         {
             "matcher": "*",
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/truncator.py"
-                }
-            ]
+            "hooks": [{"type": "command", "command": "python3 ~/.claude/hooks/truncator.py"}],
         },
         {
             "matcher": "mcp__stravinsky__*,mcp__grep-app__*,Task",
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/tool_messaging.py"
-                }
-            ]
+            "hooks": [{"type": "command", "command": "python3 ~/.claude/hooks/tool_messaging.py"}],
         },
         {
             "matcher": "Edit,MultiEdit",
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/edit_recovery.py"
-                }
-            ]
+            "hooks": [{"type": "command", "command": "python3 ~/.claude/hooks/edit_recovery.py"}],
         },
         {
             "matcher": "TodoWrite",
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "python3 ~/.claude/hooks/todo_delegation.py"
-                }
-            ]
-        }
-    ]
+            "hooks": [{"type": "command", "command": "python3 ~/.claude/hooks/todo_delegation.py"}],
+        },
+    ],
 }
 
 
 def install_hooks():
     """Install Stravinsky hooks to ~/.claude/hooks/"""
-    
+
     # Get home directory
     home = Path.home()
     claude_dir = home / ".claude"
     hooks_dir = claude_dir / "hooks"
     settings_file = claude_dir / "settings.json"
-    
+
     print("🚀 Stravinsky Hook Installer")
     print("=" * 60)
-    
+
     # Create hooks directory if it doesn't exist
     if not hooks_dir.exists():
         print(f"📁 Creating hooks directory: {hooks_dir}")
         hooks_dir.mkdir(parents=True, exist_ok=True)
     else:
         print(f"📁 Hooks directory exists: {hooks_dir}")
-    
+
     # Install each hook file
     print(f"\\n📝 Installing {len(HOOKS)} hook files...")
     for filename, content in HOOKS.items():
         hook_path = hooks_dir / filename
+        hook_path.parent.mkdir(parents=True, exist_ok=True)
         print(f"  ✓ {filename}")
         hook_path.write_text(content)
         hook_path.chmod(0o755)  # Make executable
-    
+
     # Merge hook registrations into settings.json
-    print(f"\\n⚙️  Updating settings.json...")
-    
+    print("\\n⚙️  Updating settings.json...")
+
     # Load existing settings or create new
     if settings_file.exists():
         print(f"  📖 Reading existing settings: {settings_file}")
-        with settings_file.open('r') as f:
+        with settings_file.open("r") as f:
             settings = json.load(f)
     else:
         print(f"  📝 Creating new settings file: {settings_file}")
         settings = {}
-    
+
     # Merge hooks configuration
     if "hooks" not in settings:
         settings["hooks"] = {}
-    
+
     for hook_type, registrations in HOOK_REGISTRATIONS.items():
         settings["hooks"][hook_type] = registrations
         print(f"  ✓ Registered {hook_type} hooks")
-    
+
     # Write updated settings
-    with settings_file.open('w') as f:
+    with settings_file.open("w") as f:
         json.dump(settings, f, indent=2)
-    
-    print(f"\\n✅ Installation complete!")
+
+    print("\\n✅ Installation complete!")
     print("=" * 60)
-    print(f"\\n📋 Installed hooks:")
-    for filename in HOOKS.keys():
+    print("\\n📋 Installed hooks:")
+    for filename in HOOKS:
         print(f"  • {filename}")
-    
-    print(f"\\n🔧 Hook types registered:")
-    for hook_type in HOOK_REGISTRATIONS.keys():
+
+    print("\\n🔧 Hook types registered:")
+    for hook_type in HOOK_REGISTRATIONS:
         print(f"  • {hook_type}")
-    
+
     print(f"\\n📁 Installation directory: {hooks_dir}")
     print(f"⚙️  Settings file: {settings_file}")
     print("\\n🎉 Stravinsky hooks are now active!")
     print("\\n💡 Tip: Run '/stravinsky' to activate orchestrator mode")
-    
+
     return 0
 
 
@@ -1257,6 +1652,7 @@ def main():
     except Exception as e:
         print(f"\\n❌ Installation failed: {e}", file=sys.stderr)
         import traceback
+
         traceback.print_exc()
         return 1