Implement MCP system, Event Bus, and Sub-Agents

## 1. MCP (Model Context Protocol) Implementation

### Registry (src/mcp/registry.py)
- Tool registration with JSON schemas
- Dynamic tool discovery
- Health tracking per tool
- Metrics collection (latency, error rates)
- @register_tool decorator for easy registration

### Server (src/mcp/server.py)
- MCPServer class implementing MCP protocol
- MCPHTTPServer for FastAPI integration
- Standard endpoints: list_tools, call_tool, get_schema

### Schemas (src/mcp/schemas/base.py)
- create_tool_schema() helper
- Common parameter types
- Standard return types

### Bootstrap (src/mcp/bootstrap.py)
- Automatic tool module loading
- Status reporting

## 2. MCP-Compliant Tools (src/tools/)

| Tool | Purpose | Category |
|------|---------|----------|
| web_search | DuckDuckGo search | research |
| read_file | File reading | files |
| write_file | File writing (confirmation) | files |
| list_directory | Directory listing | files |
| python | Python code execution | code |
| memory_search | Vector memory search | memory |

All tools have proper schemas, error handling, and MCP registration.

## 3. Event Bus (src/events/bus.py)

- Async publish/subscribe pattern
- Pattern matching with wildcards (agent.task.*)
- Event history tracking
- Concurrent handler execution
- Module-level singleton for system-wide use

## 4. Sub-Agents (src/agents/)

All agents inherit from BaseAgent with:
- Agno Agent integration
- MCP tool registry access
- Event bus connectivity
- Structured logging

### Agent Roster

| Agent | Role | Tools | Purpose |
|-------|------|-------|---------|
| Seer | Research | web_search, read_file, memory_search | Information gathering |
| Forge | Code | python, write_file, read_file | Code generation |
| Quill | Writing | write_file, read_file, memory_search | Content creation |
| Echo | Memory | memory_search, read_file, write_file | Context retrieval |
| Helm | Routing | memory_search | Task routing decisions |
| Timmy | Orchestrator | All tools | Coordination & user interface |

### Timmy Orchestrator
- Analyzes user requests
- Routes to appropriate sub-agent
- Handles direct queries
- Manages swarm coordination
- create_timmy_swarm() factory function

## 5. Integration

All components wired together:
- Tools auto-register on import
- Agents connect to event bus
- MCP server provides HTTP API
- Ready for dashboard integration

## Tests
- All 973 existing tests pass
- New components tested manually
- Import verification successful

Next steps: Cascade Router, Self-Upgrade Loop, Dashboard integration

src/agents/echo.py

@@ -0,0 +1,81 @@
+"""Echo Agent — Memory and context management.
+
+Capabilities:
+- Memory retrieval
+- Context synthesis
+- User profile management
+- Conversation history
+"""
+
+from typing import Any
+
+from agents.base import BaseAgent
+
+
+ECHO_SYSTEM_PROMPT = """You are Echo, a memory and context management specialist.
+
+Your role is to remember, retrieve, and synthesize information from the past.
+
+## Capabilities
+
+- Search past conversations
+- Retrieve user preferences
+- Synthesize context from multiple sources
+- Manage user profile
+
+## Guidelines
+
+1. **Be accurate** — Only state what we actually know
+2. **Be relevant** — Filter for context that matters now
+3. **Be concise** — Summarize, don't dump everything
+4. **Acknowledge uncertainty** — Say when memory is unclear
+
+## Tool Usage
+
+- Use memory_search to find relevant past context
+- Use read_file to access vault files
+- Use write_file to update user profile
+
+## Response Format
+
+Provide memory retrieval in this structure:
+- Direct answer (what we know)
+- Context (relevant past discussions)
+- Confidence (certain/likely/speculative)
+- Source (where this came from)
+
+You work for Timmy, the sovereign AI orchestrator. Be the keeper of institutional knowledge.
+"""
+
+
+class EchoAgent(BaseAgent):
+    """Memory and context specialist."""
+    
+    def __init__(self, agent_id: str = "echo") -> None:
+        super().__init__(
+            agent_id=agent_id,
+            name="Echo",
+            role="memory",
+            system_prompt=ECHO_SYSTEM_PROMPT,
+            tools=["memory_search", "read_file", "write_file"],
+        )
+    
+    async def execute_task(self, task_id: str, description: str, context: dict) -> Any:
+        """Execute a memory retrieval task."""
+        # Extract what to search for
+        prompt = f"Search memory and provide relevant context:\n\nTask: {description}\n\nSynthesize findings clearly."
+        
+        result = await self.run(prompt)
+        
+        return {
+            "task_id": task_id,
+            "agent": self.agent_id,
+            "result": result,
+            "status": "completed",
+        }
+    
+    async def recall(self, query: str, include_sources: bool = True) -> str:
+        """Quick memory recall."""
+        sources = "with sources" if include_sources else ""
+        prompt = f"Recall information about: {query} {sources}\n\nProvide relevant context from memory."
+        return await self.run(prompt)