claude-comms 1.0.45 → 2.0.0

package/.claude/commands/uat-refine.md

@@ -1,121 +0,0 @@
-Primary ⚙️Orchestrator Assignment Orchestration
-
-You are Primary ⚙️Orchestrator.
-
-
-ULTRATHINK about your CRITICAL ORCHESTRATION PROTOCOLS, and apply ⚡ORCHESTRATION untiil complete solution is delivered for your ASSIGNMENT:
-[ASSIGNMENT]
-#$ARGUMENTS
-
-[/ASSIGNMENT]
-
-
-
-# ⚡ORCHESTRATION
-## EXECUTION SEQUENCE
-You must manage and maintain Todos dynamically, refine Todos after every decision, and when new information presents itself.
-Populate your initial Todos with your step by step WORKFLOW:
-
-[WORKFLOW]
-PLAN: ULTRATHINK about the UI/UX pages, features, user flows involved and the dependencies between. Break down ASSIGNMENT into dependency sequenced test scenarios batches.
-ENABLE: ensure the dev server is running. you may need to kill an old process and start it again `.agents/repo.md`
-
-For each test scenario batch sequence:
-1. FEEDBACK: Launch a batch of multiple UAT agents and a support designer. Each UAT agent in the batch should be given a focused test scenario or portion of the app to review. they must visually inspect the UI/UX and provide feedback on: design allignment, expected functionality, issues encountered, error logs. These UAT agents are proxy for the user. Their perspecttive matters!
-2. IMPLEMENT: Launch a blended Implementation batch of engineers + codex consultants + gemini consultants  to implement changes based on UAT FEEDBACK.
-3. REQUEST APPROVAL: Task a batch of one or more (depending on the number of impacted areas/changes) UAT agents. Each UAT agent in this batch should manually execute one of the test scenarios/areas impacted, and provide their assessment of changes, design allignment, expected functionality.
- - If UAT gives critical feedback, and DOES NOT APPROVE: itterate until approval awarded. 
- - When all UAT agents in the batch give signoff approval for deployment, continue to the next to the next batch of test scenarios
-[/WORKFLOW]
-
-
-## 🎯 CRITICAL EXECUTION RULES
-
-### Dependency Laws
-⚡ **ALWAYS** Take UAT feedback seriously. They are the user's representitive.
-⚡ **ALWAYS** Add new todos if Approval is not awarded.
-⚡ **ALWAYS** blend consultants + engineers for implementation/refinement tasks
-
-
-
-### Agent Instructions Template
-```
-"Your name is [FirstNameLastName]. 
-Your Team Role is [Support/Implementation/Review+Refine/AssessingOnly]
-
-SCOPE: [Phase-level (phase-id: XX-Name)]
-
-YOUR TASK:
-[Specific task description]
-
-CONSTRAINTS:
-[Any dependencies, interfaces, or requirements]
-
-SUCCESS CRITERIA:
-[What constitutes completion]
-
-FILES TO READ FIRST:
-- [filepath1] - [one sentence description]
-- [filepath2] - [one sentence description]
-
-TEAM COLLABORATION:
-- Leverage your Team for [what]
-- Support your Team with [what]
-- Coordinate with your Team on [shared concern]
-
-
-⭐*The successful delivery of your assigned task, contributes to the high level Assignment:*⭐
-[Your full ASSIGNMENT]
-
-⭐Ensure you are alligned with this North Star objective*⭐
-
-
-[FirstNameLastName], adopt 🤝 TEAMWORK to achieve maximum value delivered."
-```
-
-*Remember:*
-An agent has no inherit knowledge of previous batch agents. They can only collaborate within thier batch. 
-Don't refer to prior batch agents by name. Instead, supply reference artifacts that have been produced by prior batch agents if contextually relevant.
-
-
-### Batch Composition Goals
-- **Minimum**: 5 agents per batch
-- **Target**: 8-10 agents including support roles
-- **Include**: roughly equal number of gemini, codex, and engineer implementers, and a support architect for guidance/coordination.
-- **Follow with**: Verification batch always
-
-### Phase Management
-**New Feature Indicators**: Major functionality, no thread context
-→ Create phase-id: `XX-DescriptiveName` (e.g., `03-UserAuth`)
-
-**Continuation Indicators**: Bug fix, refinement, existing thread
-→ Use existing phase or project-level(for project level scope)
-
-
-## Consultant Agent
-Consultants come in two variants: Codex and Gemini. leverage them both liberally to diversify.
-For implementation batches, distribute the tasks across engineers, codex consultants, and gemini consultants. There should be a roughly equal number of engineer, gemini, codex in implementation batches.
-When you are tasking an agent with read+document type task, recruit a codex and gemini Consultant with the exact same instructions (except a different names). Include the consultants in the same batch. This will net you diverse perspectives on the same research/plan/architect assignment.
-
-
-
-
-## 🔴 FINAL DIRECTIVES
-
-**DO NOT STOP** until assignment is complete and verified
-
-**Think about dependencies** - logical, functional, file, verification, knowledge
-
-**Maximize parallelization** - more agents, clear file ownership
-
-**Phase-id format**: `XX-DescriptiveName` for new features
-
----
-
-## 🚨 CRITICAL: Response Protocol
-
-### NEVER respond with status updates
-### ONLY respond when assignment is COMPLETE and VERIFIED
-### Continue orchestrating batches until DONE
-
-**Begin orchestrating this Assignment NOW!**

package/.claude/hooks/comms/get_unread_messages.py

@@ -1,71 +0,0 @@
-#!/usr/bin/env python3
-
-import json
-import sys
-import requests
-import argparse
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-def get_unread_messages(subagent_name):
-    """
-    Get unread messages for a specific subagent.
-    
-    Args:
-        subagent_name: The name/nickname of the subagent requesting messages
-    
-    Returns:
-        List of unread messages with sender, message, and timestamp
-    """
-    try:
-        response = requests.post(
-            f'{get_server_url()}/subagents/unread',
-            json={
-                'subagent_name': subagent_name
-            },
-            timeout=5
-        )
-        
-        if response.status_code == 200:
-            data = response.json()
-            return data.get('messages', [])
-        else:
-            print(f"Error: Server returned status {response.status_code}", file=sys.stderr)
-            return []
-            
-    except requests.exceptions.ConnectionError:
-        print(f"Error: Could not connect to observability server at {get_server_url()}", file=sys.stderr)
-        return []
-    except requests.exceptions.Timeout:
-        print("Error: Request timed out", file=sys.stderr)
-        return []
-    except Exception as e:
-        print(f"Error: {str(e)}", file=sys.stderr)
-        return []
-
-def main():
-    parser = argparse.ArgumentParser(description='Get unread messages for a subagent')
-    parser.add_argument('--name', required=True, help='Subagent name/nickname')
-    parser.add_argument('--json', action='store_true', help='Output as JSON')
-    
-    args = parser.parse_args()
-    
-    messages = get_unread_messages(args.name)
-    
-    if args.json:
-        print(json.dumps(messages, indent=2))
-    else:
-        if not messages:
-            print("No unread messages")
-        else:
-            print(f"Found {len(messages)} unread message(s):")
-            print("-" * 50)
-            for msg in messages:
-                print(f"From: {msg['sender']}")
-                print(f"Time: {msg['created_at']}")
-                print(f"Message: {json.dumps(msg['message'], indent=2)}")
-                print("-" * 50)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/comms/register_subagent.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">=3.8"
-# dependencies = [
-#     "requests",
-# ]
-# ///
-
-import json
-import sys
-import requests
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-
-def main():
-    try:
-        # Read JSON input from stdin
-        input_data = json.load(sys.stdin)
-        
-        session_id = input_data.get('session_id', 'unknown')
-        
-        # Check if this is a Task tool use and register the subagent
-        tool_name = input_data.get('tool_name', '')
-        tool_input = input_data.get('tool_input', {})
-        
-        if tool_name == 'Task':
-            description = tool_input.get('description', '')
-            subagent_type = tool_input.get('subagent_type', '')
-            initial_prompt = tool_input.get('prompt', '')
-            
-            # Extract nickname from description (part before colon)
-            if ':' in description:
-                nickname = description.split(':')[0].strip()
-                
-                # Register the subagent with the server
-                try:
-                    response = requests.post(
-                        f'{get_server_url()}/subagents/register',
-                        json={
-                            'session_id': session_id,
-                            'name': nickname,
-                            'subagent_type': subagent_type
-                        },
-                        timeout=2
-                    )
-                    if response.status_code == 200:
-                        print(f"Registered subagent: {nickname} ({subagent_type})", file=sys.stderr)
-                        
-                        # Now update with initial prompt using PATCH endpoint
-                        if initial_prompt:
-                            prompt_response = requests.patch(
-                                f'{get_server_url()}/subagents/{session_id}/{nickname}',
-                                json={'initial_prompt': initial_prompt},
-                                timeout=2
-                            )
-                            if prompt_response.status_code == 200:
-                                print(f"Stored initial prompt for subagent: {nickname}", file=sys.stderr)
-                except Exception as e:
-                    # Silently fail if server is not available
-                    pass
-        
-        sys.exit(0)
-        
-    except json.JSONDecodeError:
-        # Gracefully handle JSON decode errors
-        sys.exit(0)
-    except Exception:
-        # Handle any other errors gracefully
-        sys.exit(0)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/comms/send_message.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-
-import json
-import sys
-import requests
-import argparse
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-def send_message(sender_name, message):
-    """
-    Send a message from a subagent to all other subagents.
-    
-    Args:
-        sender_name: The name/nickname of the sending subagent
-        message: The message to send (can be string or dict)
-    
-    Returns:
-        True if message was sent successfully, False otherwise
-    """
-    try:
-        # Parse message if it's a JSON string
-        if isinstance(message, str):
-            try:
-                message = json.loads(message)
-            except json.JSONDecodeError:
-                # Keep as string if not valid JSON
-                pass
-        
-        response = requests.post(
-            f'{get_server_url()}/subagents/message',
-            json={
-                'sender': sender_name,
-                'message': message
-            },
-            timeout=5
-        )
-        
-        if response.status_code == 200:
-            return True
-        else:
-            print(f"Error: Server returned status {response.status_code}", file=sys.stderr)
-            return False
-            
-    except requests.exceptions.ConnectionError:
-        print(f"Error: Could not connect to observability server at {get_server_url()}", file=sys.stderr)
-        return False
-    except requests.exceptions.Timeout:
-        print("Error: Request timed out", file=sys.stderr)
-        return False
-    except Exception as e:
-        print(f"Error: {str(e)}", file=sys.stderr)
-        return False
-
-def main():
-    parser = argparse.ArgumentParser(description='Send a message from a subagent')
-    parser.add_argument('--sender', required=True, help='Sender subagent name/nickname')
-    parser.add_argument('--message', required=True, help='Message to send (string or JSON)')
-    parser.add_argument('--type', help='Message type (optional)')
-    parser.add_argument('--data', help='Additional data (JSON format)')
-    
-    args = parser.parse_args()
-    
-    # Build message structure if type is provided
-    if args.type:
-        message = {
-            'type': args.type,
-            'content': args.message
-        }
-        if args.data:
-            try:
-                message['data'] = json.loads(args.data)
-            except json.JSONDecodeError:
-                message['data'] = args.data
-    else:
-        message = args.message
-    
-    success = send_message(args.sender, message)
-    
-    if success:
-        print("Message sent successfully")
-    else:
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/comms/update_subagent_completion.py

@@ -1,126 +0,0 @@
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">=3.8"
-# dependencies = [
-#     "requests",
-# ]
-# ///
-
-import json
-import sys
-import requests
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-
-def main():
-    try:
-        # Read JSON input from stdin
-        input_data = json.load(sys.stdin)
-        
-        session_id = input_data.get('session_id', 'unknown')
-        
-        # Check if this is a Task tool use completion
-        tool_name = input_data.get('tool_name', '')
-        tool_input = input_data.get('tool_input', {})
-        tool_response = input_data.get('tool_response', {})
-        
-        if tool_name == 'Task':
-            description = tool_input.get('description', '')
-            
-            # Extract agent name from description (part before colon)
-            if ':' in description:
-                agent_name = description.split(':')[0].strip()
-                
-                # Extract completion metadata from tool_response
-                completion_metadata = {}
-                
-                # Get duration, tokens, and tool use count from tool_response
-                if 'totalDurationMs' in tool_response:
-                    completion_metadata['total_duration_ms'] = tool_response['totalDurationMs']
-                
-                if 'totalTokens' in tool_response:
-                    completion_metadata['total_tokens'] = tool_response['totalTokens']
-                
-                if 'totalToolUseCount' in tool_response:
-                    completion_metadata['total_tool_use_count'] = tool_response['totalToolUseCount']
-                
-                # Get usage details if available
-                usage = tool_response.get('usage', {})
-                if usage:
-                    if 'input_tokens' in usage:
-                        completion_metadata['input_tokens'] = usage['input_tokens']
-                    
-                    if 'output_tokens' in usage:
-                        completion_metadata['output_tokens'] = usage['output_tokens']
-                    
-                    if 'cache_creation_input_tokens' in usage:
-                        completion_metadata['cache_creation_input_tokens'] = usage['cache_creation_input_tokens']
-                    
-                    if 'cache_read_input_tokens' in usage:
-                        completion_metadata['cache_read_input_tokens'] = usage['cache_read_input_tokens']
-                
-                # Extract the agent's final response content
-                # The response content is typically in the main tool_response as text
-                final_response = ''
-                if 'content' in tool_response:
-                    # If content is a list (standard Claude format)
-                    if isinstance(tool_response['content'], list):
-                        text_blocks = [block.get('text', '') for block in tool_response['content'] if block.get('type') == 'text']
-                        final_response = '\n'.join(text_blocks)
-                    # If content is a string
-                    elif isinstance(tool_response['content'], str):
-                        final_response = tool_response['content']
-                elif 'text' in tool_response:
-                    # Alternative field name
-                    final_response = tool_response['text']
-                elif 'response' in tool_response:
-                    # Another possible field name
-                    final_response = tool_response['response']
-                
-                # Extract tool calls if available
-                tool_calls_data = []
-                if 'tool_calls' in tool_response:
-                    tool_calls_data = tool_response['tool_calls']
-                elif 'toolCalls' in tool_response:
-                    tool_calls_data = tool_response['toolCalls']
-                
-                # Update subagent completion status
-                try:
-                    response = requests.post(
-                        f'{get_server_url()}/subagents/update-completion',
-                        json={
-                            'session_id': session_id,
-                            'name': agent_name,
-                            'status': 'completed',
-                            'completed_at': None,  # Will be set to current time by server
-                            'completion_metadata': completion_metadata,
-                            'final_response': final_response,
-                            'tool_calls': tool_calls_data
-                        },
-                        timeout=2
-                    )
-                    if response.status_code == 200:
-                        print(f"Updated completion for subagent: {agent_name}", file=sys.stderr)
-                    elif response.status_code == 404:
-                        # Agent not found, silently ignore (might be a direct Task not created by subagent)
-                        pass
-                    else:
-                        # Other error, log but don't fail
-                        print(f"Failed to update completion for {agent_name}: {response.status_code}", file=sys.stderr)
-                except Exception as e:
-                    # Silently fail if server is not available
-                    pass
-        
-        sys.exit(0)
-        
-    except json.JSONDecodeError:
-        # Gracefully handle JSON decode errors
-        sys.exit(0)
-    except Exception:
-        # Handle any other errors gracefully
-        sys.exit(0)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/context/session_id.py

@@ -1,35 +0,0 @@
-#!/usr/bin/env python3
-# UserPromptSubmit hook to inject context into the conversation
-
-import json
-import sys
-# NOTE: this ONLY works for userPromptSubmit hook, no other hooks are supported.
-def main():
-    try:
-        # Read JSON input from stdin
-        input_data = json.load(sys.stdin)
-        
-        # Extract the user's prompt
-
-        session_id = input_data.get('session_id', 'unknown')
-        
-        # Create additional context that will be injected
-        additional_context = "Your session_id is: {session_id}"
-        
-
-        output = {
-            "hookSpecificOutput": {
-                "hookEventName": "UserPromptSubmit",
-                "additionalContext": additional_context
-            }
-        }
-        print(json.dumps(output))
-        sys.exit(0)
-        
-    except Exception as e:
-        # On error, show to user but don't block
-        print(f"Error in UserPromptSubmit hook: {e}", file=sys.stderr)
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/observability/send_event.py

@@ -1,110 +0,0 @@
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">=3.8"
-# ///
-
-"""
-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
-from datetime import datetime
-
-# Add parent directory to path for imports
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-def send_event_to_server(event_data, server_url=None):
-    """Send event data to the observability server."""
-    if server_url is None:
-        server_url = f'{get_server_url()}/events'
-    
-    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:
-                print(f"Server returned status: {response.status}", file=sys.stderr)
-                return False
-                
-    except urllib.error.URLError as e:
-        print(f"Failed to send event: {e}", file=sys.stderr)
-        return False
-    except Exception as e:
-        print(f"Unexpected error: {e}", file=sys.stderr)
-        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('--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')
-    
-    args = parser.parse_args()
-    
-    try:
-        # Read hook data from stdin
-        input_data = json.load(sys.stdin)
-    except json.JSONDecodeError as e:
-        print(f"Failed to parse JSON input: {e}", file=sys.stderr)
-        sys.exit(1)
-    
-    # Prepare event data for server
-    event_data = {
-        'source_app': args.source_app,
-        'session_id': input_data.get('session_id', 'unknown'),
-        'hook_event_type': args.event_type,
-        'payload': input_data,
-        'timestamp': int(datetime.now().timestamp() * 1000)
-    }
-    
-    # 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)
-    
-    
-    # Send to server
-    server_url = f'{get_server_url()}/events'
-    success = send_event_to_server(event_data, server_url)
-    
-    # Always exit with 0 to not block Claude Code operations
-    sys.exit(0)
-
-if __name__ == '__main__':
-    main()