agentops-cockpit 0.9.5__py3-none-any.whl → 0.9.8__py3-none-any.whl

agent_ops_cockpit/ops/policy_engine.py

@@ -1,12 +1,27 @@
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
 import json
 import os
 import re
 from typing import Dict, Any
 from rich.console import Console
-
 console = Console()
 
 class PolicyViolation(Exception):
+
     def __init__(self, category: str, message: str):
         self.category = category
         self.message = message
@@ -17,69 +32,54 @@ class GuardrailPolicyEngine:
     Enforces declarative guardrails and cost policies as defined in policies.json.
     Aligned with RFC go/orcas-rfc-307 (Declarative Agent Policy Enforcement).
     """
-    
-    def __init__(self, policy_path: str = None):
+
+    def __init__(self, policy_path: str=None):
         if not policy_path:
-            policy_path = os.path.join(os.path.dirname(__file__), "policies.json")
-        
+            policy_path = os.path.join(os.path.dirname(__file__), 'policies.json')
         self.policy_path = policy_path
         self.policy = self._load_policy()
 
     def _load_policy(self) -> Dict[str, Any]:
         if not os.path.exists(self.policy_path):
             return {}
-        with open(self.policy_path, "r") as f:
+        with open(self.policy_path, 'r') as f:
             return json.load(f)
 
     def validate_input(self, prompt: str):
         """Step 1: Input Sanitization (Length & Length Limits)"""
-        max_len = self.policy.get("security", {}).get("max_prompt_length", 5000)
+        max_len = self.policy.get('security', {}).get('max_prompt_length', 5000)
         if len(prompt) > max_len:
-            raise PolicyViolation("SECURITY", f"Prompt exceeds maximum allowed length ({max_len} chars).")
-
-        # Step 2: Forbidden Topics Check
-        forbidden = self.policy.get("security", {}).get("forbidden_topics", [])
+            raise PolicyViolation('SECURITY', f'Prompt exceeds maximum allowed length ({max_len} chars).')
+        forbidden = self.policy.get('security', {}).get('forbidden_topics', [])
         for topic in forbidden:
-            if re.search(r'\b' + re.escape(topic) + r'\b', prompt.lower()):
-                raise PolicyViolation("GOVERNANCE", f"Input contains forbidden topic: '{topic}'.")
+            if re.search('\\b' + re.escape(topic) + '\\b', prompt.lower()):
+                raise PolicyViolation('GOVERNANCE', f"Input contains forbidden topic: '{topic}'.")
 
     def check_tool_permission(self, tool_name: str) -> bool:
         """Step 3: Tool Usage Policies (HITL Enforcement)"""
-        require_hitl = self.policy.get("compliance", {}).get("require_hitl_for_tools", [])
+        require_hitl = self.policy.get('compliance', {}).get('require_hitl_for_tools', [])
         if tool_name in require_hitl:
             console.print(f"⚠️ [bold yellow]HITL REQUIRED:[/bold yellow] Tool '{tool_name}' requires manual approval.")
-            return False # Indicates approval needed
+            return False
         return True
 
-    def enforce_cost_limits(self, estimated_tokens: int, accumulated_cost: float = 0.0):
+    def enforce_cost_limits(self, estimated_tokens: int, accumulated_cost: float=0.0):
         """Step 4: Resource Consumption Limits"""
-        limits = self.policy.get("cost_control", {})
-        
-        # Token Limit
-        max_tokens = limits.get("max_tokens_per_turn", 4096)
+        limits = self.policy.get('cost_control', {})
+        max_tokens = limits.get('max_tokens_per_turn', 4096)
         if estimated_tokens > max_tokens:
-             raise PolicyViolation("FINOPS", f"Turn exceeds token limit ({estimated_tokens} > {max_tokens}).")
-        
-        # Budget Limit
-        max_budget = limits.get("max_cost_per_session_usd", 1.0)
+            raise PolicyViolation('FINOPS', f'Turn exceeds token limit ({estimated_tokens} > {max_tokens}).')
+        max_budget = limits.get('max_cost_per_session_usd', 1.0)
         if accumulated_cost >= max_budget:
-             raise PolicyViolation("FINOPS", f"Session budget exceeded (${accumulated_cost} >= ${max_budget}).")
+            raise PolicyViolation('FINOPS', f'Session budget exceeded (${accumulated_cost} >= ${max_budget}).')
 
     def get_audit_report(self) -> Dict[str, Any]:
         """Provides a summary for the Cockpit Orchestrator"""
-        return {
-            "policy_active": bool(self.policy),
-            "forbidden_topics_count": len(self.policy.get("security", {}).get("forbidden_topics", [])),
-            "hitl_tools": self.policy.get("compliance", {}).get("require_hitl_for_tools", []),
-            "token_threshold": self.policy.get("cost_control", {}).get("max_tokens_per_turn")
-        }
-
-if __name__ == "__main__":
-    # Quick Test
+        return {'policy_active': bool(self.policy), 'forbidden_topics_count': len(self.policy.get('security', {}).get('forbidden_topics', [])), 'hitl_tools': self.policy.get('compliance', {}).get('require_hitl_for_tools', []), 'token_threshold': self.policy.get('cost_control', {}).get('max_tokens_per_turn')}
+if __name__ == '__main__':
     engine = GuardrailPolicyEngine()
     try:
-        # Output citation for evidence bridge
-        print(f"SOURCE: Declarative Guardrails | https://cloud.google.com/architecture/framework/security | Google Cloud Governance Best Practices: Input Sanitization & Tool HITL")
-        engine.validate_input("Tell me about medical advice for drugs.")
+        print(f'SOURCE: Declarative Guardrails | https://cloud.google.com/architecture/framework/security | Google Cloud Governance Best Practices: Input Sanitization & Tool HITL')
+        engine.validate_input('Tell me about medical advice for drugs.')
     except PolicyViolation as e:
-        print(f"Caught Expected Violation: {e.category} - {e.message}")
+        print(f'Caught Expected Violation: {e.category} - {e.message}')

agent_ops_cockpit/ops/reliability.py

@@ -1,70 +1,139 @@
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
+import os
 import subprocess
 import sys
 import typer
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-
-app = typer.Typer(help="Reliability Audit: Manage unit tests and regression suites.")
+app = typer.Typer(help='Reliability Audit: Manage unit tests and regression suites.')
 console = Console()
 
 @app.command()
-def audit(
-    quick: bool = typer.Option(False, "--quick", "-q", help="Run only essential unit tests for faster feedback")
-):
+def audit(quick: bool=typer.Option(False, '--quick', '-q', help='Run only essential unit tests for faster feedback'), path: str=typer.Option('.', '--path', '-p', help='Path to the agent project to audit'), smoke: bool=typer.Option(False, '--smoke', help='Run full End-to-End Persona Smoke Tests')):
     """Run reliability checks (Unit tests + Regression Suite)."""
-    title = "🛡️ RELIABILITY AUDIT (QUICK)" if quick else "🛡️ RELIABILITY AUDIT"
-    console.print(Panel.fit(f"[bold green]{title}[/bold green]", border_style="green"))
-    
-    # 1. Run Pytest for Unit Tests
-    console.print("🧪 [bold]Running Unit Tests (pytest)...[/bold]")
-    import os
+    return run_reliability_audit(quick, path, smoke)
+
+def run_reliability_audit(quick: bool=False, path: str='.', smoke: bool=False):
+    if smoke:
+        run_smoke_test()
+        return
+    title = '🛡️ RELIABILITY AUDIT (QUICK)' if quick else '🛡️ RELIABILITY AUDIT'
+    console.print(Panel.fit(f'[bold green]{title}[/bold green]', border_style='green'))
+    console.print(f'🧪 [bold]Running Unit Tests (pytest) in {path}...[/bold]')
     env = os.environ.copy()
-    env["PYTHONPATH"] = f"src{os.pathsep}{env.get('PYTHONPATH', '')}"
-    unit_result = subprocess.run(
-        [sys.executable, "-m", "pytest", "src/agent_ops_cockpit/tests"],
-        capture_output=True,
-        text=True,
-        env=env
-    )
-    
-    # 2. Check Regression Coverage
-    # In a real tool, we would check if a mapping file exists
-    console.print("📈 [bold]Verifying Regression Suite Coverage...[/bold]")
-    
-    table = Table(title="🛡️ Reliability Status")
-    table.add_column("Check", style="cyan")
-    table.add_column("Status", style="bold")
-    table.add_column("Details", style="dim")
-    
-    unit_status = "[green]PASSED[/green]" if unit_result.returncode == 0 else "[red]FAILED[/red]"
-    table.add_row("Core Unit Tests", unit_status, f"{len(unit_result.stdout.splitlines())} tests executed")
-    
-    # Contract Testing (Real Heuristic)
+    env['PYTHONPATH'] = f"{path}{os.pathsep}{env.get('PYTHONPATH', '')}:src"
+    unit_result = subprocess.run([sys.executable, '-m', 'pytest', path], capture_output=True, text=True, env=env)
+    console.print('📈 [bold]Verifying Regression Suite Coverage...[/bold]')
+    table = Table(title='🛡️ Reliability Status')
+    table.add_column('Check', style='cyan')
+    table.add_column('Status', style='bold')
+    table.add_column('Details', style='dim')
+    unit_status = '[green]PASSED[/green]' if unit_result.returncode == 0 else '[red]FAILED[/red]'
+    if 'no tests ran' in unit_result.stdout.lower() or 'collected 0 items' in unit_result.stdout.lower():
+        unit_status = '[yellow]SKIPPED[/yellow]'
+        details = 'No tests found in target path'
+    else:
+        details = f'{len(unit_result.stdout.splitlines())} lines of output'
+    table.add_row('Core Unit Tests', unit_status, details)
     has_renderer = False
     has_schema = False
-    for root, _, files in os.walk("src/agent_ops_cockpit"):
-        for file in files:
-            if file.endswith(".py"):
-                with open(os.path.join(root, file), 'r') as f:
-                    content = f.read()
-                    if "A2UIRenderer" in content: has_renderer = True
-                    if "response_schema" in content or "BaseModel" in content: has_schema = True
-
-    contract_status = "[green]VERIFIED[/green]" if (has_renderer and has_schema) else "[yellow]GAP DETECTED[/yellow]"
-    table.add_row("Contract Compliance (A2UI)", contract_status, "Verified Engine-to-Face protocol" if has_renderer else "Missing A2UIRenderer registration")
-    
-    table.add_row("Regression Golden Set", "[green]FOUND[/green]", "50 baseline scenarios active")
+    from agent_ops_cockpit.ops.discovery import DiscoveryEngine
+    discovery = DiscoveryEngine(path)
     
+    for file_path in discovery.walk(path):
+        if file_path.endswith(('.py', '.ts', '.tsx')):
+            try:
+                with open(file_path, 'r', errors="ignore") as f:
+                    content = f.read()
+                    if 'A2UIRenderer' in content:
+                        has_renderer = True
+                    if 'response_schema' in content or 'BaseModel' in content or 'output_schema' in content:
+                        has_schema = True
+            except Exception:
+                pass
+    contract_status = '[green]VERIFIED[/green]' if has_renderer and has_schema else '[yellow]GAP DETECTED[/yellow]'
+    table.add_row('Contract Compliance (A2UI)', contract_status, 'Verified Engine-to-Face protocol' if has_renderer else 'Missing A2UIRenderer registration')
+    table.add_row('Regression Golden Set', '[green]FOUND[/green]', '50 baseline scenarios active')
     console.print(table)
-    
-    if unit_result.returncode != 0:
-        console.print("\n[red]❌ Unit test failures detected. Fix them before production deployment.[/red]")
-        console.print(f"```\n{unit_result.stdout}\n```")
-        raise typer.Exit(code=1)
+    if unit_result.returncode != 0 and unit_status != '[yellow]SKIPPED[/yellow]':
+        console.print('\n[red]❌ Unit test failures detected. Fix them before production deployment.[/red]')
+        console.print(f'```\n{unit_result.stdout}\n```')
     else:
-        console.print("\n✅ [bold green]System is stable. Quality regression coverage is 100%.[/bold green]")
+        console.print('\n✅ [bold green]System check complete.[/bold green]')
+
+def run_tests():
+    """Wrapper for main.py to run standard reliability audit."""
+    run_reliability_audit(quick=True)
 
+def run_regression_suite():
+    """Full Regression Suite: Unit Tests + Smoke Tests."""
+    console.print(Panel.fit('🚀 [bold green]LAUNCHING FULL REGRESSION SUITE[/bold green]', border_style='green'))
+    run_tests()
+    console.print('\n')
+    run_smoke_test()
+
+def run_smoke_test():
+    """Run E2E Persona Journeys (Smoke Tests) for pipes validation."""
+    console.print(Panel.fit('🧪 [bold blue]AGENTOPS COCKPIT: E2E REGRESSION SMOKE TEST[/bold blue]', border_style='blue'))
+    table = Table(title='🕹️ Persona Journey Pipes Status', show_header=True, header_style='bold magenta')
+    table.add_column('Persona', style='cyan')
+    table.add_column('Pipe / Journey', style='magenta')
+    table.add_column('Verification Logic', style='dim')
+    table.add_column('Status', style='bold')
+    console.print('👨\u200d💻 [bold]Testing Developer Persona: uvx scaffold -> A2UI -> Dry Deployment...[/bold]')
+    dev_status = '[green]PASSED[/green]'
+    dev_notes = 'Structure Verified'
+    try:
+        if not (os.path.isdir('src/a2ui') and os.path.isdir('src/agent_ops_cockpit')):
+            dev_status = '[red]FAILED[/red]'
+            dev_notes = 'Trinity Pillars Missing'
+        else:
+            env = os.environ.copy()
+            env['PYTHONPATH'] = f".{os.pathsep}{env.get('PYTHONPATH', '')}:src"
+            deploy_result = subprocess.run([sys.executable, '-m', 'agent_ops_cockpit.cli.main', 'deploy', '--dry-run'], capture_output=True, text=True, env=env)
+            if deploy_result.returncode != 0:
+                dev_status = '[red]FAILED[/red]'
+                dev_notes = 'Deployment Dry-Run Failed'
+                console.print(f'[red]Deployment Error:[/red] {deploy_result.stderr}')
+    except Exception as e:
+        dev_status = '[red]FAILED[/red]'
+        dev_notes = str(e)
+    table.add_row('The Builder (Dev)', 'agent-ops deploy --dry-run', dev_notes, dev_status)
+    console.print('🏛️ [bold]Testing Architect Persona: Google Well-Architected Review...[/bold]')
+    arch_status = '[green]PASSED[/green]'
+    from agent_ops_cockpit.ops.frameworks import detect_framework
+    fw = detect_framework('.')
+    if not fw:
+        arch_status = '[red]FAILED[/red]'
+    table.add_row('The Strategist (Arch)', 'make arch-review', 'Framework Detection', arch_status)
+    console.print('🚩 [bold]Testing Security Persona: Red Team & Secret Scanning...[/bold]')
+    sec_status = '[green]PASSED[/green]'
+    if not os.path.exists('src/agent_ops_cockpit/ops/secret_scanner.py'):
+        sec_status = '[red]FAILED[/red]'
+    table.add_row('The Guardian (Sec)', 'make red-team && secrets', 'Vulnerability Heuristics', sec_status)
+    console.print('⚖️ [bold]Testing Governance Persona: Master Audit & Policy Engine...[/bold]')
+    gov_status = '[green]PASSED[/green]'
+    if not os.path.exists('src/agent_ops_cockpit/ops/policy_engine.py'):
+        gov_status = '[red]FAILED[/red]'
+    table.add_row('The Controller (Gov)', 'make audit-all', 'Policy Compliance Pipe', gov_status)
+    console.print('📊 [bold]Testing Product Persona: ROI & UX Auditor...[/bold]')
+    prod_status = '[green]PASSED[/green]'
+    if not os.path.exists('src/agent_ops_cockpit/ops/cost_optimizer.py'):
+        prod_status = '[red]FAILED[/red]'
+    table.add_row('The Visionary (Prod)', 'make ui-audit --roi', 'Cost/UX Optimization', prod_status)
+    console.print(table)
+    results = [dev_status, arch_status, sec_status, gov_status, prod_status]
+    if '[red]FAILED[/red]' in results:
+        console.print('\n❌ [bold red]Regression Smoke Test Failed. Some Persona pipes are broken.[/bold red]')
+        sys.exit(1)
+    else:
+        console.print('\n✨ [bold green]E2E Persona Regression Smoke Test PASSED.[/bold green]')
+@app.command()
+def version():
+    """Show the version of the audit module."""
+    console.print('[bold cyan]v1.3.0[/bold cyan]')
 
-if __name__ == "__main__":
-    app()
+if __name__ == '__main__':
+    app()

agent_ops_cockpit/ops/remediator.py

@@ -0,0 +1,54 @@
+import ast
+from typing import List
+from .auditors.base import AuditFinding
+
+class CodeRemediator:
+    """
+    Phase 4: The 'Closer' - Automated Remediation Engine.
+    Transforms AST based on audit findings to inject best practices.
+    """
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        with open(file_path, 'r') as f:
+            self.content = f.read()
+        self.tree = ast.parse(self.content)
+
+    def apply_resiliency(self, finding: AuditFinding):
+        """Injects @retry and imports if missing."""
+        has_tenacity = "tenacity" in self.content
+        
+        class RetryInjector(ast.NodeTransformer):
+            def visit_FunctionDef(self, node):
+                if node.lineno == finding.line_number or any(f.title == finding.title for f in []): # Match by line or title
+                    # Add @retry(wait=wait_exponential(...))
+                    retry_decorator = ast.parse("retry(wait=wait_exponential(multiplier=1, min=4, max=10), stop=stop_after_attempt(3))").body[0].value
+                    node.decorator_list.append(retry_decorator)
+                return node
+            
+            def visit_AsyncFunctionDef(self, node):
+                return self.visit_FunctionDef(node)
+
+        self.tree = RetryInjector().visit(self.tree)
+        
+        if not has_tenacity:
+             # Prepend imports
+             import_node = ast.parse("from tenacity import retry, wait_exponential, stop_after_attempt\n").body[0]
+             self.tree.body.insert(0, import_node)
+
+    def apply_timeouts(self, finding: AuditFinding):
+        """Adds timeout=10 to async calls."""
+        class TimeoutInjector(ast.NodeTransformer):
+            def visit_Call(self, node):
+                if node.lineno == finding.line_number:
+                    # Add timeout=10 keyword
+                    node.keywords.append(ast.keyword(arg='timeout', value=ast.Constant(value=10)))
+                return node
+        
+        self.tree = TimeoutInjector().visit(self.tree)
+
+    def save(self):
+        """Saves the transformed AST back to the file using native ast.unparse."""
+        new_code = ast.unparse(self.tree)
+        with open(self.file_path, 'w') as f:
+            f.write(new_code)
+        return True

agent_ops_cockpit/ops/secret_scanner.py

@@ -16,8 +16,9 @@ SECRET_PATTERNS = {
     "Anthropic API Key": r"sk-ant-[a-zA-Z0-9]{20,}",
     "Azure OpenAI Key": r"[0-9a-f]{32}",
     "Generic Bearer Token": r"Bearer\s+[0-9a-zA-Z._-]{20,}",
-    "Hardcoded API Variable": r"(?i)(api_key|app_secret|client_secret|access_token)\s*=\s*['\"][0-9a-zA-Z_-]{16,}['\"]",
     "GCP Service Account": r"\"type\":\s*\"service_account\"",
+    "Placeholder Credential": r"(?i)['\"](REPLACE_ME|INSERT_YOUR_KEY|YOUR_API_KEY|TODO_SET_KEY)['\"]",
+    "Hardcoded API Variable": r"(?i)(api_key|client_secret|token)\s*=\s*['\"][a-zA-Z0-9_-]{10,}['\"]",
 }
 
 @app.command()
@@ -27,31 +28,37 @@ def scan(path: str = typer.Argument(".", help="Directory to scan for secrets")):
     """
     console.print(Panel.fit("🔍 [bold yellow]SECRET SCANNER: CREDENTIAL LEAK DETECTION[/bold yellow]", border_style="yellow"))
     
+    from agent_ops_cockpit.ops.discovery import DiscoveryEngine
+    discovery = DiscoveryEngine(path)
+    
     findings = []
     
-    for root, dirs, files in os.walk(path):
-        # Skip virtual environments, git, and tests
-        if any(skip in root.lower() for skip in [".venv", ".git", "tests", "test_", "node_modules"]):
+    for file_path in discovery.walk(path):
+        # Filter by relevant extensions
+        if not file_path.endswith((".py", ".env", ".ts", ".js", ".json", ".yaml", ".yml")):
             continue
             
-        for file in files:
-            if file.endswith((".py", ".env", ".ts", ".js", ".json", ".yaml", ".yml")):
-                file_path = os.path.join(root, file)
-                try:
-                    with open(file_path, "r", errors="ignore") as f:
-                        lines = f.readlines()
-                        for i, line in enumerate(lines):
-                            for secret_name, pattern in SECRET_PATTERNS.items():
-                                match = re.search(pattern, line)
-                                if match:
-                                    findings.append({
-                                        "file": os.path.relpath(file_path, path),
-                                        "line": i + 1,
-                                        "type": secret_name,
-                                        "content": line.strip()[:50] + "..."
-                                    })
-                except Exception:
-                    continue
+        is_lib = discovery.is_library_file(file_path)
+        
+        try:
+            with open(file_path, "r", errors="ignore") as f:
+                lines = f.readlines()
+                for i, line in enumerate(lines):
+                    for secret_name, pattern in SECRET_PATTERNS.items():
+                        match = re.search(pattern, line)
+                        if match:
+                            # Library Isolation: Skip hits in known libraries to reduce false positives
+                            if is_lib:
+                                continue
+                                
+                            findings.append({
+                                "file": os.path.relpath(file_path, path),
+                                "line": i + 1,
+                                "type": secret_name,
+                                "content": line.strip()[:50] + "..."
+                            })
+        except Exception:
+            continue
 
     table = Table(title="🛡️ Security Findings: Hardcoded Secrets")
     table.add_column("File", style="cyan")
@@ -78,5 +85,10 @@ def scan(path: str = typer.Argument(".", help="Directory to scan for secrets")):
     else:
         console.print("✅ [bold green]PASS:[/bold green] No hardcoded credentials detected in matched patterns.")
 
+@app.command()
+def version():
+    """Show the version of the Secret Scanner."""
+    console.print('[bold cyan]v1.3.0[/bold cyan]')
+
 if __name__ == "__main__":
     app()

agent_ops_cockpit/ops/swarm.py

@@ -1,9 +1,10 @@
+from tenacity import retry, wait_exponential, stop_after_attempt
+from tenacity import retry, wait_exponential, stop_after_attempt
 import asyncio
 from typing import List, Dict, Any, Optional
 from dataclasses import dataclass
 from rich.console import Console
 from rich.panel import Panel
-
 console = Console()
 
 @dataclass
@@ -17,55 +18,44 @@ class MultiAgentOrchestrator:
     """
     Standardizes Swarm/Coordinator patterns using the A2A spec.
     """
-    
+
     def __init__(self):
         self.agents: Dict[str, Any] = {}
         self.history: List[SwarmMessage] = []
 
     def register_agent(self, name: str, agent_func):
         self.agents[name] = agent_func
-        console.print(f"🤖 Agent [bold cyan]{name}[/bold cyan] registered in swarm.")
+        console.print(f'🤖 Agent [bold cyan]{name}[/bold cyan] registered in swarm.')
 
     async def dispatch(self, sender: str, recipient: str, message: str):
         """Dispatches a message with an A2A Reasoning Evidence Packet."""
-        console.print(f"\n📡 [dim]A2A Transmission:[/dim] [bold]{sender}[/bold] -> [bold]{recipient}[/bold]")
-        
-        # Simulated Evidence Packet for Governance
-        evidence = {
-            "assurance_score": 0.99,
-            "origin_vpc": "secure-engine-zone",
-            "pii_scrubbed": True
-        }
-        
+        console.print(f'\n📡 [dim]A2A Transmission:[/dim] [bold]{sender}[/bold] -> [bold]{recipient}[/bold]')
+        evidence = {'assurance_score': 0.99, 'origin_vpc': 'secure-engine-zone', 'pii_scrubbed': True}
         swarm_msg = SwarmMessage(sender, recipient, message, evidence)
         self.history.append(swarm_msg)
-        
         if recipient in self.agents:
             response = await self.agents[recipient](message, evidence)
             return response
         else:
-            return {"error": f"Agent {recipient} not found."}
+            return {'error': f'Agent {recipient} not found.'}
 
     def get_swarm_report(self):
-        console.print(Panel.fit("🐝 [bold]Swarm Orchestration Trace[/bold]", border_style="yellow"))
+        console.print(Panel.fit('🐝 [bold]Swarm Orchestration Trace[/bold]', border_style='yellow'))
         for msg in self.history:
-            console.print(f"[blue]{msg.sender}[/blue] -> [green]{msg.recipient}[/green]: {msg.content}")
+            console.print(f'[blue]{msg.sender}[/blue] -> [green]{msg.recipient}[/green]: {msg.content}')
 
 def run_swarm_demo():
     orchestrator = MultiAgentOrchestrator()
-    
+
     async def researcher(query, evidence):
         return f"Research results for {query} (Evidence verified: {evidence['assurance_score']})"
-        
-    async def writer(query, evidence):
-        return f"Professional summary of {query}"
 
-    orchestrator.register_agent("Researcher", researcher)
-    orchestrator.register_agent("Writer", writer)
-    
+    async def writer(query, evidence):
+        return f'Professional summary of {query}'
+    orchestrator.register_agent('Researcher', researcher)
+    orchestrator.register_agent('Writer', writer)
     loop = asyncio.get_event_loop()
-    loop.run_until_complete(orchestrator.dispatch("Orchestrator", "Researcher", "Analyze market trends"))
+    loop.run_until_complete(orchestrator.dispatch('Orchestrator', 'Researcher', 'Analyze market trends'))
     orchestrator.get_swarm_report()
-
-if __name__ == "__main__":
-    run_swarm_demo()
+if __name__ == '__main__':
+    run_swarm_demo()