fix: Update test badge and fix Agent Orchestration Wizard

- Update TestsBadge to show accurate count (2,211 tests passing)
- Remove coverage percentage from badge
- Fix Agent Orchestration Wizard to work with text input
- Add _parse_agents_from_text() for demo mode

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: silversurfer562

empathy_software_plugin/wizards/agent_orchestration_wizard.py

@@ -40,24 +40,86 @@ def __init__(self):
         )
 
     def get_required_context(self) -> list[str]:
-        """Required context for analysis"""
+        """Required context for analysis (optional in demo mode)"""
         return [
             "agent_definitions",  # Agent classes/configs
             "orchestration_code",  # Code that coordinates agents
             "project_path",  # Project root
         ]
 
+    def _parse_agents_from_text(self, text: str) -> list[dict]:
+        """Parse agent definitions from natural language text input."""
+        import re
+
+        agents = []
+
+        # Look for patterns like "5 agents", "agents: X, Y, Z", numbered lists
+        # Pattern 1: "N agents" or "N specialized agents"
+        count_match = re.search(r"(\d+)\s+(?:specialized\s+)?agents?", text.lower())
+        if count_match:
+            count = int(count_match.group(1))
+            # Try to extract agent names from the text
+            # Look for colon-separated list: "agents: ingestion, validation, ..."
+            list_match = re.search(r":\s*([^.]+)", text)
+            if list_match:
+                names = [n.strip() for n in list_match.group(1).split(",")]
+                for name in names[:count]:
+                    agents.append({"name": name, "type": "specialized"})
+            else:
+                # Generate generic agent names
+                for i in range(count):
+                    agents.append({"name": f"Agent_{i+1}", "type": "specialized"})
+
+        # Pattern 2: Look for specific agent-like words
+        agent_keywords = [
+            "ingestion",
+            "validation",
+            "transformation",
+            "analysis",
+            "reporting",
+            "extraction",
+            "processing",
+            "routing",
+            "aggregation",
+            "monitoring",
+            "scheduler",
+            "executor",
+            "coordinator",
+            "supervisor",
+            "worker",
+        ]
+        for kw in agent_keywords:
+            if kw in text.lower() and not any(a["name"].lower() == kw for a in agents):
+                agents.append({"name": kw.title(), "type": "specialized"})
+
+        # Ensure at least 1 agent for demo
+        if not agents:
+            agents = [{"name": "DefaultAgent", "type": "generic"}]
+
+        return agents
+
     async def analyze(self, context: dict[str, Any]) -> dict[str, Any]:
         """
         Analyze agent orchestration patterns and predict coordination issues.
 
         In our experience: Multi-agent complexity sneaks up fast.
         By agent #7-10, you need formal orchestration or face refactoring.
+
+        Supports two modes:
+        - Structured: Pass agent_definitions, orchestration_code, project_path
+        - Demo/Text: Pass user_input with natural language description
         """
-        self.validate_context(context)
+        # Support text input mode (from web demo) or structured mode
+        user_input = context.get("user_input", "")
 
-        agents = context["agent_definitions"]
-        orchestration = context["orchestration_code"]
+        if "agent_definitions" not in context:
+            # Parse agents from text input for demo mode
+            agents = self._parse_agents_from_text(user_input)
+            orchestration = []  # No file analysis in demo mode
+        else:
+            self.validate_context(context)
+            agents = context["agent_definitions"]
+            orchestration = context["orchestration_code"]
 
         # Current issues
         issues = await self._analyze_orchestration_patterns(agents, orchestration)

website/components/TestsBadge.tsx

@@ -1,11 +1,9 @@
 interface TestsBadgeProps {
   tests?: number;
-  coverage?: number;
 }
 
 export default function TestsBadge({
-  tests = 1954,
-  coverage = 90.12
+  tests = 2211
 }: TestsBadgeProps) {
   return (
     <span className="inline-flex items-center gap-1.5 px-3 py-1.5 rounded-full text-sm font-medium bg-[#10B981] text-white">
@@ -24,7 +22,7 @@ export default function TestsBadge({
         <polyline points="20 6 9 17 4 12" />
       </svg>
       <span>
-        {tests.toLocaleString()} tests | {coverage.toFixed(0)}% coverage
+        {tests.toLocaleString()} tests passing
       </span>
     </span>
   );