Update code

.kiro/specs/ai-financial-intelligence-system/.config.kiro

@@ -0,0 +1 @@
+{"specId": "6fa4d985-8691-4485-8edc-fea35099c0a4", "workflowType": "requirements-first", "specType": "feature"}

.kiro/specs/ai-financial-intelligence-system/design.md

@@ -0,0 +1,2715 @@
+# Design Document: MiroOrg v1.1
+
+## Overview
+
+MiroOrg v1.1 is a general intelligence operating system that orchestrates multiple specialist agents, runs simulations, supports pluggable domain packs, and autonomously improves itself over time. The system merges capabilities from miroorg-basic-v2 (base architecture), impact_ai (first domain pack), MiroFish (simulation lab), and public-apis (API discovery catalog) into a unified, production-ready platform.
+
+### Core Principles
+
+- **Modularity**: Clear separation between core platform, agent organization, domain packs, simulation lab, and autonomous learning
+- **Extensibility**: Domain packs can be added without modifying agent orchestration layer
+- **Provider Agnostic**: Abstract AI model providers (OpenRouter, Ollama, future OpenAI) behind unified interface
+- **Local-First**: Single-user local deployment with production-quality code structure
+- **Simulation-Ready**: Deep integration with MiroFish for scenario modeling and what-if analysis
+- **Self-Improving**: Autonomous learning from internet knowledge, past cases, and successful patterns without local model training
+- **Resource-Conscious**: Strict storage limits and lightweight background tasks suitable for 8GB/256GB laptop
+
+### System Context
+
+The system operates as a FastAPI backend with a Next.js frontend dashboard. All state is stored locally in JSON files. External services (MiroFish, Tavily, NewsAPI, Alpha Vantage) are accessed through adapter clients. The architecture supports both synchronous analysis and asynchronous simulation workflows.
+
+## Architecture
+
+### Five-Layer Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ Layer 5: Autonomous Knowledge Evolution (Self-Improvement) │
+│ - World knowledge ingestion (compressed summaries)          │
+│ - Experience learning from cases                            │
+│ - Prompt evolution and optimization                         │
+│ - Skill distillation from patterns                          │
+│ - Trust and freshness management                            │
+└─────────────────────────────────────────────────────────────┘
+                            ▲
+                            │
+┌─────────────────────────────────────────────────────────────┐
+│ Layer 4: Simulation Lab (MiroFish Integration)             │
+│ - Graph building, persona generation, simulation execution  │
+│ - Report generation, post-simulation chat                   │
+└─────────────────────────────────────────────────────────────┘
+                            ▲
+                            │
+┌─────────────────────────────────────────────────────────────┐
+│ Layer 3: Domain Packs (Pluggable Intelligence Modules)     │
+│ - Finance Pack: market data, news, entity/ticker detection │
+│ - Future: Policy, Cyber, Enterprise Ops, Research, Edu     │
+└─────────────────────────────────────────────────────────────┘
+                            ▲
+                            │
+┌─────────────────────────────────────────────────────────────┐
+│ Layer 2: Agent Organization (Multi-Agent Orchestration)    │
+│ - Switchboard: routing and classification                  │
+│ - Research: context gathering and entity extraction        │
+│ - Planner: action plan generation                          │
+│ - Verifier: credibility validation and uncertainty         │
+│ - Synthesizer: final response composition                  │
+└─────────────────────────────────────────────────────────────┘
+                            ▲
+                            │
+┌─────────────────────────────────────────────────────────────┐
+│ Layer 1: Core Platform (Infrastructure)                    │
+│ - FastAPI backend, Next.js frontend                        │
+│ - Config, health, memory, prompts, cases, logs             │
+│ - Provider abstraction layer                               │
+└─────────────────────────────────────────────────────────────┘
+```
+
+
+### Execution Flow
+
+```mermaid
+graph TD
+    A[User Input] --> B[Switchboard]
+    B --> C{Task Classification}
+    C -->|Simple| D[Solo Mode: Direct Response]
+    C -->|Medium| E[Standard Mode: Research + Planner]
+    C -->|Complex| F[Deep Mode: Full Pipeline]
+    C -->|Simulation| G[Simulation Mode: MiroFish]
+    
+    E --> H[Research Agent]
+    H --> I[Planner Agent]
+    I --> J[Synthesizer Agent]
+    
+    F --> K[Research Agent]
+    K --> L[Planner Agent]
+    L --> M[Verifier Agent]
+    M --> N[Synthesizer Agent]
+    
+    G --> O[MiroFish Client]
+    O --> P[Graph Building]
+    P --> Q[Simulation Execution]
+    Q --> R[Report Generation]
+    R --> S[Post-Simulation Chat]
+    
+    D --> T[Save Case]
+    J --> T
+    N --> T
+    S --> T
+    T --> U[Return Response]
+```
+
+### Repository Ownership
+
+- **Primary Repo**: miroorg-basic-v2 (canonical architecture)
+- **Domain Source**: impact_ai (reusable domain modules, not structural peer)
+- **Simulation Service**: MiroFish (separate service, accessed via adapter)
+- **API Catalog**: public-apis (discovery dataset, not runtime dependency)
+
+### Technology Stack
+
+- **Backend**: Python 3.10+, FastAPI, LangGraph, Pydantic, httpx
+- **Frontend**: Next.js 14+, React, TypeScript, Tailwind CSS
+- **Storage**: Local JSON files (cases, simulations, logs)
+- **AI Providers**: OpenRouter (primary), Ollama (fallback), future OpenAI
+- **External APIs**: Tavily, NewsAPI, Alpha Vantage, Jina Reader
+- **Simulation**: MiroFish (external service)
+
+## Components and Interfaces
+
+### Layer 1: Core Platform
+
+#### Provider Abstraction Layer
+
+**Purpose**: Unified interface for AI model providers with automatic fallback
+
+**Interface**:
+```python
+def call_model(
+    prompt: str,
+    mode: str = "chat",  # "chat" or "reasoner"
+    system_prompt: Optional[str] = None,
+    provider_override: Optional[str] = None,
+) -> str:
+    """
+    Call AI model with automatic provider fallback.
+    
+    Args:
+        prompt: User prompt or agent instruction
+        mode: "chat" for general tasks, "reasoner" for complex analysis
+        system_prompt: Optional system-level instructions
+        provider_override: Force specific provider (testing/debugging)
+    
+    Returns:
+        Model response text
+    
+    Raises:
+        LLMProviderError: When all providers fail
+    """
+```
+
+**Implementation Strategy**:
+- Current: `_call_openrouter()` and `_call_ollama()` in `backend/app/agents/_model.py`
+- Enhancement: Add `_call_openai()` for future OpenAI support
+- Fallback Logic: Try primary provider, catch exception, try fallback provider
+- Logging: Log provider selection, fallback events, and failures
+
+
+#### Configuration Management
+
+**Purpose**: Centralized environment-based configuration
+
+**File**: `backend/app/config.py`
+
+**Configuration Groups**:
+1. **App Settings**: VERSION, DIRS (prompts, data, memory, simulations, logs)
+2. **Provider Settings**: PRIMARY_PROVIDER, FALLBACK_PROVIDER, model names, API keys
+3. **External API Settings**: TAVILY_API_KEY, NEWSAPI_KEY, ALPHAVANTAGE_API_KEY, JINA_READER_BASE
+4. **MiroFish Settings**: ENABLED, API_BASE, TIMEOUT, endpoint paths
+5. **Simulation Settings**: TRIGGER_KEYWORDS (configurable list)
+
+**Enhancement Strategy**:
+- Add validation on startup for required keys
+- Add warnings for missing optional keys
+- Add feature flags for domain packs
+- Add logging configuration
+
+#### Memory and Storage
+
+**Purpose**: Local persistence for cases, simulations, and logs
+
+**Directory Structure**:
+```
+backend/app/data/
+├── memory/          # Case execution records (JSON)
+├── simulations/     # Simulation metadata (JSON)
+└── logs/            # Application logs (rotating)
+```
+
+**Case Storage Interface**:
+```python
+def save_case(case_id: str, payload: Dict[str, Any]) -> None
+def get_case(case_id: str) -> Optional[Dict[str, Any]]
+def list_cases(limit: Optional[int] = None) -> List[Dict[str, Any]]
+def delete_case(case_id: str) -> bool
+def memory_stats() -> Dict[str, Any]
+```
+
+**Simulation Storage Interface**:
+```python
+def save_simulation(simulation_id: str, record: Dict[str, Any]) -> None
+def get_simulation(simulation_id: str) -> Optional[Dict[str, Any]]
+def list_simulations(limit: Optional[int] = None) -> List[Dict[str, Any]]
+```
+
+**Case Schema**:
+```json
+{
+  "case_id": "uuid",
+  "user_input": "string",
+  "route": {
+    "task_family": "normal|simulation",
+    "domain_pack": "finance|general|policy|custom",
+    "complexity": "simple|medium|complex",
+    "execution_mode": "solo|standard|deep"
+  },
+  "outputs": [
+    {
+      "agent": "research|planner|verifier|synthesizer",
+      "summary": "string",
+      "details": {},
+      "confidence": 0.0
+    }
+  ],
+  "final_answer": "string",
+  "simulation_id": "optional uuid",
+  "created_at": "ISO timestamp",
+  "updated_at": "ISO timestamp"
+}
+```
+
+
+### Layer 2: Agent Organization
+
+#### Switchboard Agent
+
+**Purpose**: Classify tasks and route to appropriate execution mode
+
+**Current Implementation**: `backend/app/agents/switchboard.py`
+
+**Classification Dimensions**:
+1. **task_family**: "normal" or "simulation" (based on trigger keywords)
+2. **domain_pack**: "finance", "general", "policy", "custom" (future enhancement)
+3. **complexity**: "simple" (≤5 words), "medium" (≤25 words), "complex" (>25 words)
+4. **execution_mode**: "solo", "standard", "deep"
+
+**Routing Logic**:
+```python
+def decide_route(user_input: str) -> Dict[str, Any]:
+    """
+    Classify task and determine execution path.
+    
+    Returns:
+        {
+            "task_family": str,
+            "domain_pack": str,
+            "complexity": str,
+            "execution_mode": str,
+            "risk_level": str
+        }
+    """
+```
+
+**Enhancement Strategy**:
+- Add domain_pack detection (keywords: "stock", "market", "ticker" → finance)
+- Add entity extraction for domain routing
+- Add confidence scoring for routing decisions
+- Add routing decision logging
+
+**Execution Mode Mapping**:
+- **solo**: Simple queries, direct response, no multi-agent collaboration
+- **standard**: Medium complexity, Research → Planner → Synthesizer
+- **deep**: Complex queries, full pipeline with Verifier, optional simulation handoff
+
+#### Research Agent
+
+**Purpose**: Gather context, extract entities, fetch external information
+
+**Current Implementation**: `backend/app/agents/research.py`
+
+**Responsibilities**:
+1. Extract entities (companies, people, concepts)
+2. Extract tickers (stock symbols like $AAPL)
+3. Extract URLs for content reading
+4. Fetch external context (Tavily search, NewsAPI, Alpha Vantage, Jina Reader)
+5. Return structured facts, assumptions, open questions, useful signals
+
+**Interface**:
+```python
+def run_research(user_input: str, prompt_template: str) -> Dict[str, Any]:
+    """
+    Gather context and extract entities from user input.
+    
+    Returns:
+        {
+            "agent": "research",
+            "summary": str,
+            "details": {
+                "external_context_used": bool,
+                "entities": List[str],
+                "tickers": List[str],
+                "urls": List[str]
+            },
+            "confidence": float
+        }
+    """
+```
+
+**Enhancement Strategy**:
+- Integrate impact_ai entity_resolver.py for better entity extraction
+- Integrate impact_ai ticker_resolver.py for ticker normalization
+- Add structured entity extraction (not just text summary)
+- Add domain-specific context gathering (finance pack)
+- Add caching for repeated queries
+
+
+#### Planner Agent
+
+**Purpose**: Convert research into practical action plans
+
+**Current Implementation**: `backend/app/agents/planner.py`
+
+**Responsibilities**:
+1. Synthesize research findings into actionable recommendations
+2. Highlight dependencies and risks
+3. Suggest next steps
+4. Identify when simulation mode would be more appropriate
+
+**Interface**:
+```python
+def run_planner(
+    user_input: str,
+    research_summary: str,
+    prompt_template: str
+) -> Dict[str, Any]:
+    """
+    Generate action plan from research findings.
+    
+    Returns:
+        {
+            "agent": "planner",
+            "summary": str,
+            "details": {
+                "recommendations": List[str],
+                "risks": List[str],
+                "next_steps": List[str],
+                "simulation_suggested": bool
+            },
+            "confidence": float
+        }
+    """
+```
+
+**Enhancement Strategy**:
+- Add structured output parsing (recommendations, risks, next_steps)
+- Add simulation mode detection and suggestion
+- Add domain-specific planning (finance pack)
+- Update prompt to include domain intelligence instructions
+
+#### Verifier Agent
+
+**Purpose**: Validate credibility, detect rumors/scams, surface uncertainty
+
+**Current Implementation**: `backend/app/agents/verifier.py`
+
+**Responsibilities**:
+1. Test credibility of information sources
+2. Detect rumors and unsupported claims
+3. Detect scams and fraudulent information
+4. Identify contradictions in research and planning
+5. Force uncertainty to be made visible
+
+**Interface**:
+```python
+def run_verifier(
+    user_input: str,
+    research_summary: str,
+    planner_summary: str,
+    prompt_template: str
+) -> Dict[str, Any]:
+    """
+    Validate credibility and detect issues.
+    
+    Returns:
+        {
+            "agent": "verifier",
+            "summary": str,
+            "details": {
+                "credibility_score": float,
+                "rumors_detected": List[str],
+                "scams_detected": List[str],
+                "contradictions": List[str],
+                "uncertainty_areas": List[str]
+            },
+            "confidence": float
+        }
+    """
+```
+
+**Enhancement Strategy**:
+- Integrate impact_ai source_checker.py for source credibility scoring
+- Integrate impact_ai rumor_detector.py for rumor detection
+- Integrate impact_ai scam_detector.py for scam detection
+- Add structured output parsing
+- Update prompt with domain intelligence instructions
+- Only run in "deep" execution mode
+
+
+#### Synthesizer Agent
+
+**Purpose**: Combine outputs into final comprehensive response
+
+**Current Implementation**: `backend/app/agents/synthesizer.py`
+
+**Responsibilities**:
+1. Combine research, planning, and verification outputs
+2. State uncertainty honestly
+3. Recommend next actions
+4. Suggest simulation mode when scenario analysis is appropriate
+
+**Interface**:
+```python
+def run_synthesizer(
+    user_input: str,
+    research_summary: str,
+    planner_summary: str,
+    verifier_summary: str,
+    prompt_template: str
+) -> Dict[str, Any]:
+    """
+    Produce final comprehensive response.
+    
+    Returns:
+        {
+            "agent": "synthesizer",
+            "summary": str,
+            "details": {
+                "uncertainty_level": str,
+                "next_actions": List[str],
+                "simulation_recommended": bool
+            },
+            "confidence": float
+        }
+    """
+```
+
+**Enhancement Strategy**:
+- Add structured output parsing
+- Add uncertainty quantification
+- Add simulation mode recommendation logic
+- Update prompt with domain intelligence instructions
+
+### Layer 3: Domain Packs
+
+#### Domain Pack Architecture
+
+**Purpose**: Pluggable domain intelligence modules that extend agent capabilities
+
+**Design Pattern**:
+```
+backend/app/domain_packs/
+├── __init__.py
+├── base.py              # Abstract base class for domain packs
+├── finance/             # First domain pack (from impact_ai)
+│   ├── __init__.py
+│   ├── market_data.py   # Alpha Vantage integration
+│   ├── news.py          # NewsAPI integration
+│   ├── entity_resolver.py
+│   ├── ticker_resolver.py
+│   ├── source_checker.py
+│   ├── rumor_detector.py
+│   ├── scam_detector.py
+│   ├── stance_detector.py
+│   ├── event_analyzer.py
+│   └── prediction.py
+└── registry.py          # Domain pack registration and discovery
+```
+
+**Base Domain Pack Interface**:
+```python
+class DomainPack(ABC):
+    """Abstract base class for domain packs."""
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Domain pack identifier (e.g., 'finance', 'policy')."""
+        pass
+    
+    @property
+    @abstractmethod
+    def keywords(self) -> List[str]:
+        """Keywords for automatic domain detection."""
+        pass
+    
+    @abstractmethod
+    def enhance_research(self, user_input: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Enhance research agent with domain-specific context."""
+        pass
+    
+    @abstractmethod
+    def enhance_verification(self, claims: List[str], context: Dict[str, Any]) -> Dict[str, Any]:
+        """Enhance verifier agent with domain-specific checks."""
+        pass
+    
+    @abstractmethod
+    def get_capabilities(self) -> List[str]:
+        """List domain-specific capabilities."""
+        pass
+```
+
+
+#### Finance Domain Pack
+
+**Purpose**: Financial intelligence capabilities from impact_ai
+
+**Modules to Integrate**:
+
+1. **market_data.py**: Alpha Vantage client for stock quotes, historical data
+2. **news.py**: NewsAPI client for financial news
+3. **entity_resolver.py**: Extract and normalize company/organization names
+4. **ticker_resolver.py**: Resolve company names to stock tickers
+5. **source_checker.py**: Score credibility of financial news sources
+6. **rumor_detector.py**: Detect unverified market rumors
+7. **scam_detector.py**: Detect investment scams and fraud
+8. **stance_detector.py**: Analyze sentiment and stance in financial text
+9. **event_analyzer.py**: Analyze market events and their impacts
+10. **prediction.py**: Market prediction and scenario modeling
+
+**Integration Strategy**:
+- Refactor impact_ai modules to match service layer pattern
+- Consolidate overlapping clients (Alpha Vantage, NewsAPI) with existing external_sources.py
+- Expose capabilities through FinanceDomainPack class
+- Register pack in domain pack registry
+- Update agent prompts to include finance-specific instructions when pack is active
+
+**Finance Pack Interface**:
+```python
+class FinanceDomainPack(DomainPack):
+    name = "finance"
+    keywords = ["stock", "market", "ticker", "trading", "investment", "portfolio", 
+                "earnings", "dividend", "IPO", "SEC", "financial"]
+    
+    def enhance_research(self, user_input: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Add financial context:
+        - Extract tickers and resolve company names
+        - Fetch market quotes
+        - Fetch recent financial news
+        - Extract financial entities
+        """
+        
+    def enhance_verification(self, claims: List[str], context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Add financial verification:
+        - Check source credibility for financial news
+        - Detect market rumors
+        - Detect investment scams
+        - Analyze stance and sentiment
+        """
+```
+
+#### Domain Pack Registry
+
+**Purpose**: Centralized registration and discovery of domain packs
+
+**Interface**:
+```python
+class DomainPackRegistry:
+    def register(self, pack: DomainPack) -> None
+    def get_pack(self, name: str) -> Optional[DomainPack]
+    def detect_domain(self, user_input: str) -> Optional[str]
+    def list_packs(self) -> List[str]
+    def get_capabilities(self, domain: str) -> List[str]
+
+# Global registry instance
+domain_registry = DomainPackRegistry()
+domain_registry.register(FinanceDomainPack())
+```
+
+**Usage in Agents**:
+```python
+# In research agent
+domain = domain_registry.detect_domain(user_input)
+if domain:
+    pack = domain_registry.get_pack(domain)
+    enhanced_context = pack.enhance_research(user_input, base_context)
+```
+
+
+### Layer 4: Simulation Lab
+
+#### MiroFish Integration Architecture
+
+**Purpose**: External simulation service for scenario modeling and what-if analysis
+
+**Integration Pattern**: Adapter client (not direct merge)
+
+**Current Implementation**: `backend/app/services/mirofish_client.py`
+
+**MiroFish Capabilities**:
+1. **Graph Building**: Extract entities and relationships from seed text
+2. **Persona Generation**: Create realistic personas for simulation
+3. **Environment Setup**: Configure simulation parameters
+4. **Simulation Execution**: Run multi-agent scenario modeling
+5. **Report Generation**: Produce structured simulation reports
+6. **Post-Simulation Chat**: Deep interaction with simulation results
+
+**Client Interface**:
+```python
+def mirofish_health() -> Dict[str, Any]:
+    """Check MiroFish service availability."""
+
+def run_simulation(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Submit simulation request.
+    
+    Payload:
+        {
+            "title": str,
+            "seed_text": str,
+            "prediction_goal": str,
+            "mode": "standard|deep",
+            "metadata": {}
+        }
+    
+    Returns:
+        {
+            "simulation_id": str,
+            "status": "submitted|running|completed|failed",
+            "message": str
+        }
+    """
+
+def simulation_status(simulation_id: str) -> Dict[str, Any]:
+    """Get simulation execution status."""
+
+def simulation_report(simulation_id: str) -> Dict[str, Any]:
+    """Retrieve simulation report."""
+
+def simulation_chat(simulation_id: str, message: str) -> Dict[str, Any]:
+    """Ask questions about simulation results."""
+```
+
+**Router Implementation**: `backend/app/routers/simulation.py`
+
+**Endpoints**:
+- `GET /simulation/health`: MiroFish health check
+- `POST /simulation/run`: Submit simulation
+- `GET /simulation/{simulation_id}`: Get status
+- `GET /simulation/{simulation_id}/report`: Get report
+- `POST /simulation/{simulation_id}/chat`: Post-simulation chat
+
+**Error Handling**:
+- Graceful degradation when MiroFish is disabled
+- Descriptive error messages for connection failures
+- Local metadata storage even when remote service fails
+- Timeout configuration via environment variables
+
+**Frontend Integration Rule**: Frontend MUST only consume MiroOrg endpoints, never direct MiroFish calls
+
+
+#### Simulation Workflow Integration
+
+**Trigger Detection**: Switchboard detects simulation keywords and sets task_family="simulation"
+
+**Simulation Keywords** (configurable):
+- simulate, predict, model reaction, test scenarios, run digital twins
+- explore "what if" outcomes, forecast, scenario analysis
+- public opinion, policy impact, market impact, stakeholder reaction
+
+**Execution Flow**:
+1. User submits query with simulation keywords
+2. Switchboard classifies as task_family="simulation", execution_mode="deep"
+3. Research agent gathers context (optional)
+4. Planner agent structures simulation parameters (optional)
+5. System submits to MiroFish via `/simulation/run`
+6. System polls `/simulation/{id}` for status
+7. When complete, system retrieves report via `/simulation/{id}/report`
+8. Synthesizer agent summarizes simulation results
+9. User can ask follow-up questions via `/simulation/{id}/chat`
+
+**Case Linking**: Simulation metadata includes case_id, case metadata includes simulation_id
+
+### API Discovery Subsystem
+
+**Purpose**: Discover and classify free APIs from public-apis catalog for future connector expansion
+
+**Architecture**:
+```
+backend/app/services/api_discovery/
+├── __init__.py
+├── catalog_loader.py    # Load public-apis JSON data
+├── classifier.py        # Classify APIs by category and usefulness
+├── scorer.py            # Score APIs for integration priority
+└── metadata_store.py    # Store API metadata locally
+```
+
+**Catalog Loader**:
+```python
+def load_public_apis_catalog() -> List[Dict[str, Any]]:
+    """
+    Load public-apis catalog from GitHub or local cache.
+    
+    Returns:
+        List of API entries with:
+        - API name
+        - Description
+        - Auth type (apiKey, OAuth, None)
+        - HTTPS support
+        - CORS support
+        - Category
+        - Link
+    """
+```
+
+**Classifier**:
+```python
+def classify_api(api_entry: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Classify API by category and potential use cases.
+    
+    Categories:
+        - market_data: Stock, crypto, commodities
+        - news: News aggregation, RSS feeds
+        - social: Social media, sentiment
+        - government: Policy, regulations, open data
+        - weather: Weather, climate
+        - general: Utilities, reference data
+    """
+```
+
+**Scorer**:
+```python
+def score_api_usefulness(api_entry: Dict[str, Any]) -> float:
+    """
+    Score API for integration priority (0.0 - 1.0).
+    
+    Factors:
+        - Auth simplicity (no auth > apiKey > OAuth)
+        - HTTPS support (required)
+        - CORS support (preferred)
+        - Category relevance to domain packs
+        - Description quality
+    """
+```
+
+**Usage**: Discovery subsystem is for future expansion, not runtime dependency
+
+
+### Layer 5: Autonomous Knowledge Evolution
+
+**Purpose**: Self-improving intelligence system that learns from internet knowledge, past cases, prompt evolution, and skill distillation without local model training
+
+**Design Constraints**:
+- NO local model training or fine-tuning
+- NO large raw dataset storage
+- Store only compressed summaries (2-4KB per item)
+- Max knowledge cache: 200MB
+- Lightweight background tasks only
+- Battery-aware and resource-conscious
+- Suitable for 8GB/256GB laptop
+
+**Architecture**:
+```
+backend/app/services/learning/
+├── __init__.py
+├── knowledge_ingestor.py    # Ingest and compress external knowledge
+├── knowledge_store.py        # Store compressed knowledge items
+├── learning_engine.py        # Core learning logic and pattern detection
+├── prompt_optimizer.py       # Prompt evolution and testing
+├── skill_distiller.py        # Extract reusable skills from patterns
+├── trust_manager.py          # Source reliability tracking
+├── freshness_manager.py      # Information recency tracking
+└── scheduler.py              # Lightweight background task scheduler
+```
+
+**Data Directories**:
+```
+backend/app/data/
+├── knowledge/          # Compressed knowledge items (max 200MB)
+├── skills/             # Distilled reusable skills
+├── prompt_versions/    # Prompt version history
+└── learning/           # Learning metadata and statistics
+```
+
+#### Knowledge Ingestion
+
+**Purpose**: Continuously pull high-signal information and compress it
+
+**Knowledge Item Schema**:
+```python
+class KnowledgeItem(BaseModel):
+    id: str
+    title: str
+    summary: str  # 2-4KB compressed summary
+    entities: List[str]
+    claims: List[str]
+    source_url: str
+    source_type: str  # "news", "api", "search", "webpage"
+    trust_score: float  # 0.0 - 1.0
+    freshness_score: float  # 0.0 - 1.0
+    domain_pack: Optional[str]  # "finance", "policy", etc.
+    created_at: str
+    expires_at: str
+    metadata: Dict[str, Any]
+```
+
+**Ingestion Sources**:
+- Tavily search results
+- Jina Reader webpage summaries
+- NewsAPI articles
+- Alpha Vantage market data
+- Domain-specific APIs
+- Public-APIs catalog metadata
+
+**Ingestion Rules**:
+- Pull only during idle periods
+- Respect API rate limits
+- Compress immediately (no raw storage)
+- Extract entities, claims, and key facts
+- Score trust and freshness
+- Set expiration based on domain rules
+
+**Interface**:
+```python
+def ingest_from_search(query: str, max_items: int = 5) -> List[KnowledgeItem]:
+    """Ingest knowledge from search results."""
+
+def ingest_from_url(url: str) -> Optional[KnowledgeItem]:
+    """Ingest knowledge from specific URL."""
+
+def ingest_from_news(query: str, max_items: int = 5) -> List[KnowledgeItem]:
+    """Ingest knowledge from news sources."""
+
+def compress_content(raw_content: str, max_length: int = 4000) -> str:
+    """Compress raw content to summary."""
+```
+
+#### Knowledge Store
+
+**Purpose**: Store and retrieve compressed knowledge items
+
+**Storage Strategy**:
+- JSON files in `backend/app/data/knowledge/`
+- One file per knowledge item
+- Automatic cleanup of expired items
+- Hard limit: 200MB total storage
+- LRU eviction when limit reached
+
+**Interface**:
+```python
+def save_knowledge(item: KnowledgeItem) -> None
+def get_knowledge(item_id: str) -> Optional[KnowledgeItem]
+def search_knowledge(query: str, domain: Optional[str] = None) -> List[KnowledgeItem]
+def list_knowledge(limit: Optional[int] = None) -> List[KnowledgeItem]
+def delete_expired_knowledge() -> int
+def get_storage_stats() -> Dict[str, Any]
+```
+
+#### Experience Learning
+
+**Purpose**: Learn from every case execution to improve future performance
+
+**Case Learning Metadata**:
+```python
+class CaseLearning(BaseModel):
+    case_id: str
+    route_effectiveness: float  # Did routing work well?
+    prompt_performance: Dict[str, float]  # Which prompts worked?
+    provider_reliability: Dict[str, bool]  # Which providers succeeded?
+    source_usefulness: Dict[str, float]  # Which sources were valuable?
+    pattern_detected: Optional[str]  # Repeated pattern?
+    corrections_made: List[str]  # User corrections?
+    execution_time: float
+    created_at: str
+```
+
+**Learning Rules**:
+- Track every case execution
+- Store only metadata (not full case duplicate)
+- Detect repeated patterns across cases
+- Update trust scores based on verification outcomes
+- Identify successful routing strategies
+- Track prompt effectiveness
+
+**Interface**:
+```python
+def learn_from_case(case_id: str, case_data: Dict[str, Any]) -> CaseLearning
+def detect_patterns(min_occurrences: int = 3) -> List[Dict[str, Any]]
+def get_route_effectiveness(route_type: str) -> float
+def get_prompt_performance(prompt_name: str) -> float
+def recommend_improvements() -> List[str]
+```
+
+#### Prompt Evolution
+
+**Purpose**: Controlled evolution of agent prompts through testing and comparison
+
+**Prompt Version Schema**:
+```python
+class PromptVersion(BaseModel):
+    name: str  # "research", "planner", etc.
+    version: str  # "v1.0", "v1.1", etc.
+    content: str
+    status: str  # "active", "experimental", "archived"
+    win_rate: float  # Success rate in tests
+    test_count: int
+    last_tested: str
+    created_at: str
+    metadata: Dict[str, Any]
+```
+
+**Evolution Process**:
+1. Store current prompt as baseline version
+2. Generate improved variant (using provider API)
+3. Test variant on sampled tasks
+4. Compare outcomes using quality metrics
+5. Promote if better, archive if worse
+6. Never auto-promote without validation
+
+**Quality Metrics**:
+- Response relevance
+- Entity extraction accuracy
+- Credibility detection rate
+- User satisfaction (if available)
+- Execution time
+
+**Interface**:
+```python
+def create_prompt_variant(prompt_name: str, improvement_goal: str) -> PromptVersion
+def test_prompt_variant(variant: PromptVersion, test_cases: List[str]) -> float
+def compare_prompts(baseline: PromptVersion, variant: PromptVersion) -> Dict[str, Any]
+def promote_prompt(prompt_name: str, version: str) -> None
+def archive_prompt(prompt_name: str, version: str) -> None
+def get_prompt_history(prompt_name: str) -> List[PromptVersion]
+```
+
+#### Skill Distillation
+
+**Purpose**: Convert repeated successful patterns into reusable skills
+
+**Skill Schema**:
+```python
+class Skill(BaseModel):
+    name: str  # "financial_rumor_review", "policy_reaction_analysis"
+    description: str
+    trigger_patterns: List[str]  # Keywords that activate this skill
+    recommended_agents: List[str]  # Which agents to use
+    preferred_sources: List[str]  # Which sources to prioritize
+    prompt_overrides: Dict[str, str]  # Agent-specific prompt additions
+    success_rate: float
+    usage_count: int
+    created_at: str
+    last_used: str
+    metadata: Dict[str, Any]
+```
+
+**Distillation Process**:
+1. Detect repeated patterns (min 3 occurrences)
+2. Extract common elements (agents, sources, prompts)
+3. Create skill record
+4. Test skill on similar tasks
+5. Activate if success rate > 0.7
+
+**Skill Types**:
+- **financial_rumor_review**: Verify unverified market claims
+- **policy_reaction_analysis**: Analyze policy impact scenarios
+- **earnings_impact_brief**: Summarize earnings report impacts
+- **simulation_prep_pack**: Prepare simulation parameters
+
+**Interface**:
+```python
+def detect_skill_candidates(min_occurrences: int = 3) -> List[Dict[str, Any]]
+def distill_skill(pattern: Dict[str, Any]) -> Skill
+def test_skill(skill: Skill, test_cases: List[str]) -> float
+def activate_skill(skill_name: str) -> None
+def get_skill(skill_name: str) -> Optional[Skill]
+def list_skills() -> List[Skill]
+def apply_skill(skill_name: str, user_input: str) -> Dict[str, Any]
+```
+
+#### Trust Management
+
+**Purpose**: Track source reliability and learn which sources are trustworthy
+
+**Trust Score Schema**:
+```python
+class SourceTrust(BaseModel):
+    source_id: str  # URL domain or API name
+    source_type: str  # "news", "api", "website"
+    trust_score: float  # 0.0 - 1.0
+    verification_count: int
+    success_count: int
+    failure_count: int
+    last_verified: str
+    domain_pack: Optional[str]
+    metadata: Dict[str, Any]
+```
+
+**Trust Scoring Rules**:
+- Start with neutral score (0.5)
+- Increase on successful verification
+- Decrease on failed verification or detected misinformation
+- Weight recent verifications more heavily
+- Domain-specific trust (finance sources vs general sources)
+
+**Interface**:
+```python
+def get_trust_score(source_id: str) -> float
+def update_trust(source_id: str, verification_result: bool) -> None
+def list_trusted_sources(min_score: float = 0.7) -> List[SourceTrust]
+def list_untrusted_sources(max_score: float = 0.3) -> List[SourceTrust]
+def get_trust_stats() -> Dict[str, Any]
+```
+
+#### Freshness Management
+
+**Purpose**: Track information recency and identify stale knowledge
+
+**Freshness Score Schema**:
+```python
+class FreshnessScore(BaseModel):
+    item_id: str
+    freshness_score: float  # 0.0 - 1.0
+    created_at: str
+    last_updated: str
+    last_verified: str
+    update_frequency: str  # "hourly", "daily", "weekly", "static"
+    domain_pack: Optional[str]
+    metadata: Dict[str, Any]
+```
+
+**Freshness Rules**:
+- News: Degrades rapidly (hourly)
+- Market data: Degrades moderately (daily)
+- Policy info: Degrades slowly (weekly)
+- Reference data: Static (no degradation)
+- Recommend refresh when score < 0.5
+
+**Interface**:
+```python
+def calculate_freshness(item: KnowledgeItem) -> float
+def update_freshness(item_id: str) -> None
+def get_stale_items(max_score: float = 0.5) -> List[str]
+def recommend_refresh() -> List[str]
+def get_freshness_stats() -> Dict[str, Any]
+```
+
+#### Learning Scheduler
+
+**Purpose**: Lightweight background task scheduler with safeguards
+
+**Scheduler Rules**:
+- Run only when system is idle
+- Max one background job at a time
+- Small batch sizes (5-10 items per run)
+- Stop on provider errors or rate limits
+- Skip if battery low (<20%)
+- Skip if CPU usage high (>70%)
+- Respect API rate limits
+
+**Scheduled Tasks**:
+- Knowledge ingestion (every 6 hours)
+- Expired knowledge cleanup (daily)
+- Trust score updates (after each case)
+- Freshness score updates (hourly)
+- Pattern detection (daily)
+- Skill distillation (weekly)
+- Prompt optimization (weekly)
+
+**Interface**:
+```python
+def schedule_task(task_name: str, interval: str, func: Callable) -> None
+def run_once(task_name: str) -> Dict[str, Any]
+def get_scheduler_status() -> Dict[str, Any]
+def pause_scheduler() -> None
+def resume_scheduler() -> None
+def is_system_idle() -> bool
+def is_battery_ok() -> bool
+```
+
+#### Learning Engine
+
+**Purpose**: Core learning logic that coordinates all learning subsystems
+
+**Responsibilities**:
+- Inspect past cases for patterns
+- Trigger knowledge ingestion
+- Trigger skill distillation
+- Recommend prompt upgrades
+- Update trust and freshness scores
+- Generate learning insights
+
+**Interface**:
+```python
+def run_learning_cycle() -> Dict[str, Any]:
+    """Run one complete learning cycle."""
+
+def analyze_cases(limit: int = 100) -> Dict[str, Any]:
+    """Analyze recent cases for patterns."""
+
+def generate_insights() -> Dict[str, Any]:
+    """Generate learning insights and recommendations."""
+
+def get_learning_status() -> Dict[str, Any]:
+    """Get current learning system status."""
+```
+
+#### Integration with Existing Layers
+
+**With Cases**:
+- Learn from every case execution
+- Store case learning metadata
+- Detect patterns across cases
+
+**With Domain Packs**:
+- Domain-specific knowledge ingestion
+- Domain-specific trust scoring
+- Domain-specific freshness rules
+
+**With Simulation**:
+- Learn from simulation outcomes
+- Store simulation insights
+- Improve simulation parameter selection
+
+**With Prompts**:
+- Version all prompts
+- Test prompt variants
+- Promote better prompts
+
+**With Providers**:
+- Track provider reliability
+- Learn optimal provider selection
+- Adapt to provider failures
+
+
+## Data Models
+
+### Core Schemas
+
+**UserTask**:
+```python
+class UserTask(BaseModel):
+    user_input: str
+```
+
+**RouteDecision**:
+```python
+class RouteDecision(BaseModel):
+    task_family: Literal["normal", "simulation"]
+    domain_pack: str  # "finance", "general", "policy", "custom"
+    complexity: Literal["simple", "medium", "complex"]
+    execution_mode: Literal["solo", "standard", "deep"]
+    risk_level: str
+    confidence: float = 0.0
+```
+
+**AgentOutput**:
+```python
+class AgentOutput(BaseModel):
+    agent: str
+    summary: str
+    details: Dict[str, Any] = Field(default_factory=dict)
+    confidence: float = 0.0
+    timestamp: str
+```
+
+**CaseRecord**:
+```python
+class CaseRecord(BaseModel):
+    case_id: str
+    user_input: str
+    route: RouteDecision
+    outputs: List[AgentOutput]
+    final_answer: str
+    simulation_id: Optional[str] = None
+    created_at: str
+    updated_at: str
+```
+
+**SimulationRequest**:
+```python
+class SimulationRunRequest(BaseModel):
+    title: str
+    seed_text: str
+    prediction_goal: str
+    mode: str = "standard"
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+```
+
+**SimulationRecord**:
+```python
+class SimulationRecord(BaseModel):
+    simulation_id: str
+    status: Literal["submitted", "running", "completed", "failed"]
+    title: str
+    prediction_goal: str
+    remote_payload: Dict[str, Any]
+    report: Optional[Dict[str, Any]] = None
+    case_id: Optional[str] = None
+    created_at: str
+    updated_at: str
+```
+
+### Domain Pack Schemas
+
+**EntityExtraction**:
+```python
+class EntityExtraction(BaseModel):
+    entities: List[str]
+    tickers: List[str]
+    companies: List[str]
+    people: List[str]
+    locations: List[str]
+    confidence: float
+```
+
+**CredibilityScore**:
+```python
+class CredibilityScore(BaseModel):
+    source: str
+    score: float  # 0.0 - 1.0
+    factors: Dict[str, Any]
+    warnings: List[str]
+```
+
+**MarketQuote**:
+```python
+class MarketQuote(BaseModel):
+    symbol: str
+    price: float
+    change: float
+    change_percent: float
+    volume: int
+    timestamp: str
+```
+
+### Learning Layer Schemas
+
+**KnowledgeItem**:
+```python
+class KnowledgeItem(BaseModel):
+    id: str
+    title: str
+    summary: str  # 2-4KB compressed summary
+    entities: List[str]
+    claims: List[str]
+    source_url: str
+    source_type: Literal["news", "api", "search", "webpage"]
+    trust_score: float  # 0.0 - 1.0
+    freshness_score: float  # 0.0 - 1.0
+    domain_pack: Optional[str]
+    created_at: str
+    expires_at: str
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+```
+
+**CaseLearning**:
+```python
+class CaseLearning(BaseModel):
+    case_id: str
+    route_effectiveness: float
+    prompt_performance: Dict[str, float]
+    provider_reliability: Dict[str, bool]
+    source_usefulness: Dict[str, float]
+    pattern_detected: Optional[str]
+    corrections_made: List[str]
+    execution_time: float
+    created_at: str
+```
+
+**PromptVersion**:
+```python
+class PromptVersion(BaseModel):
+    name: str
+    version: str
+    content: str
+    status: Literal["active", "experimental", "archived"]
+    win_rate: float
+    test_count: int
+    last_tested: str
+    created_at: str
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+```
+
+**Skill**:
+```python
+class Skill(BaseModel):
+    name: str
+    description: str
+    trigger_patterns: List[str]
+    recommended_agents: List[str]
+    preferred_sources: List[str]
+    prompt_overrides: Dict[str, str]
+    success_rate: float
+    usage_count: int
+    created_at: str
+    last_used: str
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+```
+
+**SourceTrust**:
+```python
+class SourceTrust(BaseModel):
+    source_id: str
+    source_type: Literal["news", "api", "website"]
+    trust_score: float  # 0.0 - 1.0
+    verification_count: int
+    success_count: int
+    failure_count: int
+    last_verified: str
+    domain_pack: Optional[str]
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+```
+
+**FreshnessScore**:
+```python
+class FreshnessScore(BaseModel):
+    item_id: str
+    freshness_score: float  # 0.0 - 1.0
+    created_at: str
+    last_updated: str
+    last_verified: str
+    update_frequency: Literal["hourly", "daily", "weekly", "static"]
+    domain_pack: Optional[str]
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+```
+
+
+## Service Layer Organization
+
+### External Sources Service
+
+**Purpose**: Unified interface for external API integrations
+
+**Current Implementation**: `backend/app/services/external_sources.py`
+
+**Capabilities**:
+- URL extraction and content reading (Jina Reader)
+- Web search (Tavily)
+- News search (NewsAPI)
+- Market quotes (Alpha Vantage)
+- Ticker extraction from text
+
+**Enhancement Strategy**:
+- Consolidate with impact_ai Alpha Vantage and NewsAPI clients
+- Add connection pooling
+- Add request timeouts
+- Add caching for market quotes (5 minute TTL)
+- Add rate limiting
+
+### Agent Registry Service
+
+**Purpose**: Centralized agent registration and discovery
+
+**Current Implementation**: `backend/app/services/agent_registry.py`
+
+**Interface**:
+```python
+def list_agents() -> List[Dict[str, Any]]
+def get_agent(agent_name: str) -> Optional[Dict[str, Any]]
+def run_single_agent(agent: str, user_input: str, **context) -> Dict[str, Any]
+```
+
+**Enhancement Strategy**:
+- Add agent capability metadata
+- Add agent dependency tracking
+- Add agent health checks
+
+### Case Store Service
+
+**Purpose**: Local persistence for case execution records
+
+**Current Implementation**: `backend/app/services/case_store.py`
+
+**Interface**:
+```python
+def save_case(case_id: str, payload: Dict[str, Any]) -> None
+def get_case(case_id: str) -> Optional[Dict[str, Any]]
+def list_cases(limit: Optional[int] = None) -> List[Dict[str, Any]]
+def delete_case(case_id: str) -> bool
+def memory_stats() -> Dict[str, Any]
+```
+
+**Enhancement Strategy**:
+- Add case search by user_input
+- Add case filtering by route parameters
+- Add case export functionality
+
+### Simulation Store Service
+
+**Purpose**: Local persistence for simulation metadata
+
+**Current Implementation**: `backend/app/services/simulation_store.py`
+
+**Interface**:
+```python
+def save_simulation(simulation_id: str, record: Dict[str, Any]) -> None
+def get_simulation(simulation_id: str) -> Optional[Dict[str, Any]]
+def list_simulations(limit: Optional[int] = None) -> List[Dict[str, Any]]
+```
+
+### Prompt Store Service
+
+**Purpose**: Dynamic prompt management
+
+**Current Implementation**: `backend/app/services/prompt_store.py`
+
+**Interface**:
+```python
+def list_prompts() -> List[str]
+def get_prompt(name: str) -> Optional[Dict[str, Any]]
+def update_prompt(name: str, content: str) -> Dict[str, Any]
+```
+
+**Enhancement Strategy**:
+- Add prompt versioning
+- Add prompt validation
+- Add domain-specific prompt templates
+
+### Health Service
+
+**Purpose**: System health monitoring
+
+**Current Implementation**: `backend/app/services/health_service.py`
+
+**Interface**:
+```python
+def deep_health() -> Dict[str, Any]:
+    """
+    Comprehensive health check.
+    
+    Returns:
+        {
+            "status": "ok|degraded|error",
+            "version": str,
+            "checks": {
+                "providers": {...},
+                "external_apis": {...},
+                "mirofish": {...},
+                "storage": {...},
+                "domain_packs": {...}
+            }
+        }
+    """
+```
+
+
+## Frontend Architecture
+
+### Technology Stack
+
+- **Framework**: Next.js 14+ with App Router
+- **UI Library**: React 18+
+- **Styling**: Tailwind CSS
+- **State Management**: React hooks + Context API
+- **HTTP Client**: fetch API with error handling
+- **Type Safety**: TypeScript
+
+### Page Structure
+
+```
+frontend/src/app/
+├── layout.tsx           # Root layout with navigation
+├── page.tsx             # Main dashboard (landing)
+├── analyze/
+│   └── page.tsx         # Analyze mode interface
+├── cases/
+│   ├── page.tsx         # Case history list
+│   └── [id]/
+│       └── page.tsx     # Case detail view
+├── simulation/
+│   ├── page.tsx         # Simulation interface
+│   └── [id]/
+│       └── page.tsx     # Simulation detail and chat
+├── prompts/
+│   └── page.tsx         # Prompt lab
+└── config/
+    └── page.tsx         # System configuration view
+```
+
+### Component Architecture
+
+```
+frontend/src/components/
+├── layout/
+│   ├── Header.tsx
+│   ├── Navigation.tsx
+│   └── Footer.tsx
+├── analyze/
+│   ├── TaskInput.tsx
+│   ├── ModeSelector.tsx
+│   ├── ResultViewer.tsx
+│   └── AgentOutputPanel.tsx
+├── cases/
+│   ├── CaseList.tsx
+│   ├── CaseCard.tsx
+│   └── CaseDetail.tsx
+├── simulation/
+│   ├── SimulationForm.tsx
+│   ├── SimulationStatus.tsx
+│   ├── SimulationReport.tsx
+│   └── SimulationChat.tsx
+├── prompts/
+│   ├── PromptList.tsx
+│   └── PromptEditor.tsx
+└── common/
+    ├── Badge.tsx
+    ├── Card.tsx
+    ├── LoadingSpinner.tsx
+    └── ErrorMessage.tsx
+```
+
+### API Client
+
+```typescript
+// frontend/src/lib/api.ts
+export class MiroOrgClient {
+  private baseUrl: string;
+  
+  async runTask(input: string): Promise<CaseResult>
+  async getCase(caseId: string): Promise<Case>
+  async listCases(limit?: number): Promise<Case[]>
+  async deleteCase(caseId: string): Promise<void>
+  
+  async runSimulation(request: SimulationRequest): Promise<Simulation>
+  async getSimulation(id: string): Promise<Simulation>
+  async getSimulationReport(id: string): Promise<SimulationReport>
+  async chatWithSimulation(id: string, message: string): Promise<ChatResponse>
+  
+  async listPrompts(): Promise<string[]>
+  async getPrompt(name: string): Promise<Prompt>
+  async updatePrompt(name: string, content: string): Promise<Prompt>
+  
+  async getHealth(): Promise<HealthStatus>
+  async getConfig(): Promise<ConfigStatus>
+}
+```
+
+### Design System
+
+**Color Palette** (Dark Theme):
+- Background: `#0a0a0a`
+- Surface: `#1a1a1a`
+- Border: `#2a2a2a`
+- Primary: `#3b82f6` (blue)
+- Success: `#10b981` (green)
+- Warning: `#f59e0b` (amber)
+- Error: `#ef4444` (red)
+- Text Primary: `#f9fafb`
+- Text Secondary: `#9ca3af`
+
+**Typography**:
+- Font Family: Inter, system-ui, sans-serif
+- Headings: font-semibold
+- Body: font-normal
+- Code: font-mono
+
+**Spacing**: Tailwind default scale (4px base unit)
+
+**Animations**:
+- Fade in: 200ms ease-in
+- Slide in: 300ms ease-out
+- Hover transitions: 150ms ease-in-out
+
+
+## Correctness Properties
+
+A property is a characteristic or behavior that should hold true across all valid executions of a system—essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.
+
+### Property Reflection
+
+After analyzing all acceptance criteria, I identified the following redundancies and consolidations:
+
+**Redundancy Group 1: Configuration from Environment**
+- Requirements 1.8, 6.7 both test that configuration comes from environment variables
+- Consolidated into Property 1
+
+**Redundancy Group 2: Directory Storage Locations**
+- Requirements 10.9, 10.10, 10.11 all test file storage locations
+- Consolidated into Property 8
+
+**Redundancy Group 3: Logging Requirements**
+- Requirements 6.6, 9.4, 9.5, 9.6, 9.7 all test logging behavior
+- Consolidated into Property 11
+
+**Redundancy Group 4: Switchboard Complexity Mapping**
+- Requirements 4.2, 4.3, 4.4 all test complexity-to-execution-mode mapping
+- Consolidated into Property 3 (single comprehensive property)
+
+**Redundancy Group 5: Case Storage Fields**
+- Requirements 10.2, 10.7, 10.8 all test case record structure
+- Consolidated into Property 7
+
+**Redundancy Group 6: External API Integration**
+- Requirements 9.1, 9.9, 9.10 all test external API client behavior
+- Consolidated into Property 13
+
+**Redundancy Group 7: Error Handling**
+- Requirements 9.3, 9.8, 9.10 all test error response structure
+- Consolidated into Property 14
+
+After consolidation, 15 core properties remain that provide unique validation value.
+
+### Property 1: Configuration Environment Isolation
+
+For any configuration value (API keys, provider settings, feature flags), the system should load it from environment variables, not from hardcoded values in source code.
+
+**Validates: Requirements 1.8, 6.7**
+
+### Property 2: Switchboard Four-Dimensional Classification
+
+For any user input, the Switchboard routing decision should contain exactly four dimensions: task_family, domain_pack, complexity, and execution_mode.
+
+**Validates: Requirements 4.1**
+
+### Property 3: Complexity-to-Execution-Mode Mapping
+
+For any user input, the Switchboard should map complexity to execution_mode according to the rule: simple→solo, medium→standard, complex→deep.
+
+**Validates: Requirements 4.2, 4.3, 4.4**
+
+### Property 4: Simulation Keyword Triggering
+
+For any user input containing simulation trigger keywords (configurable via environment), the Switchboard should classify task_family as "simulation".
+
+**Validates: Requirements 4.5, 4.6**
+
+### Property 5: Provider Fallback Behavior
+
+For any model call, if the primary provider fails, the system should automatically attempt the fallback provider before raising an error.
+
+**Validates: Requirements 6.5**
+
+### Property 6: Case Persistence Round Trip
+
+For any case execution, saving the case and then retrieving it by case_id should return an equivalent case record with all required fields.
+
+**Validates: Requirements 10.1, 10.3**
+
+### Property 7: Case Record Structure Completeness
+
+For any stored case, the JSON record should contain all required fields: case_id, user_input, route (with four dimensions), outputs (list of agent outputs), final_answer, and timestamps.
+
+**Validates: Requirements 10.2, 10.7, 10.8**
+
+### Property 8: Data Directory Organization
+
+For any data persistence operation (cases, simulations, logs), the system should store files in the correct directory: cases in memory/, simulations in simulations/, logs in logs/.
+
+**Validates: Requirements 10.9, 10.10, 10.11**
+
+### Property 9: Directory Auto-Creation
+
+For any missing data directory (memory, simulations, logs), the system should automatically create it on startup or first use.
+
+**Validates: Requirements 10.12**
+
+### Property 10: MiroFish Adapter Isolation
+
+For any simulation operation, the system should route requests through the mirofish_client adapter, never allowing direct MiroFish API calls from other components.
+
+**Validates: Requirements 1.3, 3.4**
+
+### Property 11: Comprehensive Logging
+
+For any agent execution, provider call, external API call, or simulation request, the system should create a log entry with timestamp and relevant context.
+
+**Validates: Requirements 6.6, 9.4, 9.6, 9.7**
+
+### Property 12: Schema Validation
+
+For any API request, if the request body does not match the expected Pydantic schema, the system should return a 422 validation error with details about the validation failure.
+
+**Validates: Requirements 9.1, 9.2**
+
+### Property 13: External API Client Patterns
+
+For any external API client, the system should implement connection pooling, request timeouts, and error handling consistently.
+
+**Validates: Requirements 9.1, 9.9, 9.10**
+
+### Property 14: Error Response Sanitization
+
+For any error response, the system should return a structured error with appropriate HTTP status code and descriptive message, without exposing internal implementation details or raw exceptions.
+
+**Validates: Requirements 9.3, 9.8, 9.10**
+
+### Property 15: Domain Pack Extensibility
+
+For any new domain pack registration, the system should support it without requiring modifications to the agent organization layer (Switchboard, Research, Planner, Verifier, Synthesizer).
+
+**Validates: Requirements 2.5, 2.7**
+
+
+## Error Handling
+
+### Error Categories
+
+1. **Validation Errors** (HTTP 422)
+   - Invalid request schema
+   - Missing required fields
+   - Type mismatches
+
+2. **Client Errors** (HTTP 400)
+   - Feature disabled (e.g., MiroFish disabled)
+   - Invalid parameters
+   - Business logic violations
+
+3. **Not Found Errors** (HTTP 404)
+   - Case not found
+   - Agent not found
+   - Prompt not found
+   - Simulation not found
+
+4. **External Service Errors** (HTTP 502)
+   - Provider failures (OpenRouter, Ollama)
+   - External API failures (Tavily, NewsAPI, Alpha Vantage)
+   - MiroFish connection failures
+
+5. **Internal Errors** (HTTP 500)
+   - Unexpected exceptions
+   - Storage failures
+   - System errors
+
+### Error Response Schema
+
+```python
+class ErrorResponse(BaseModel):
+    error: str
+    detail: str
+    status_code: int
+    timestamp: str
+```
+
+### Error Handling Patterns
+
+**Provider Fallback**:
+```python
+try:
+    return call_primary_provider(prompt)
+except ProviderError as e:
+    logger.warning(f"Primary provider failed: {e}")
+    try:
+        return call_fallback_provider(prompt)
+    except ProviderError as fallback_error:
+        logger.error(f"Fallback provider failed: {fallback_error}")
+        raise LLMProviderError("All providers failed")
+```
+
+**External API Graceful Degradation**:
+```python
+try:
+    results = tavily_search(query)
+except Exception as e:
+    logger.warning(f"Tavily search failed: {e}")
+    results = []  # Continue with empty results
+```
+
+**MiroFish Error Handling**:
+```python
+if not MIROFISH_ENABLED:
+    raise HTTPException(
+        status_code=400,
+        detail="MiroFish integration is disabled"
+    )
+
+try:
+    result = mirofish_client.run_simulation(payload)
+except MiroFishError as e:
+    raise HTTPException(
+        status_code=502,
+        detail=f"MiroFish service error: {str(e)}"
+    )
+```
+
+### Logging Strategy
+
+**Log Levels**:
+- **DEBUG**: Detailed execution traces, variable values
+- **INFO**: Normal operations, agent executions, case saves
+- **WARNING**: Degraded functionality, fallback usage, missing optional features
+- **ERROR**: Failures that prevent operation completion
+- **CRITICAL**: System-wide failures
+
+**Log Format**:
+```
+[TIMESTAMP] [LEVEL] [MODULE] [CASE_ID] MESSAGE
+```
+
+**Log Rotation**:
+- Daily rotation
+- Keep 30 days of logs
+- Compress old logs
+- Max log file size: 100MB
+
+
+## Testing Strategy
+
+### Dual Testing Approach
+
+The system requires both unit tests and property-based tests for comprehensive coverage:
+
+- **Unit tests**: Verify specific examples, edge cases, and error conditions
+- **Property tests**: Verify universal properties across all inputs
+
+Both approaches are complementary and necessary. Unit tests catch concrete bugs in specific scenarios, while property tests verify general correctness across randomized inputs.
+
+### Unit Testing
+
+**Focus Areas**:
+1. Specific examples that demonstrate correct behavior
+2. Integration points between components
+3. Edge cases (empty inputs, missing fields, null values)
+4. Error conditions (provider failures, API timeouts, invalid schemas)
+
+**Unit Test Balance**:
+- Avoid writing too many unit tests for input variations
+- Property-based tests handle comprehensive input coverage
+- Unit tests should focus on specific scenarios and integration points
+
+**Example Unit Tests**:
+```python
+def test_switchboard_simple_query():
+    """Test that short queries route to solo mode."""
+    route = decide_route("Hello")
+    assert route["complexity"] == "simple"
+    assert route["execution_mode"] == "solo"
+
+def test_case_storage_missing_directory():
+    """Test that missing memory directory is created."""
+    # Remove directory if exists
+    # Save case
+    # Assert directory was created
+    # Assert case file exists
+
+def test_provider_fallback_on_primary_failure():
+    """Test that system falls back to secondary provider."""
+    # Mock primary provider to fail
+    # Call model
+    # Assert fallback provider was called
+    # Assert result is returned
+```
+
+### Property-Based Testing
+
+**Library**: pytest-hypothesis (Python), fast-check (TypeScript)
+
+**Configuration**: Minimum 100 iterations per property test
+
+**Property Test Structure**:
+```python
+from hypothesis import given, strategies as st
+
+@given(st.text(min_size=1, max_size=1000))
+def test_property_1_config_from_environment(user_input):
+    """
+    Property 1: Configuration Environment Isolation
+    
+    For any configuration value, the system should load it from 
+    environment variables, not from hardcoded values.
+    
+    Feature: ai-financial-intelligence-system, Property 1
+    """
+    # Test implementation
+```
+
+**Property Test Tags**: Each property test must include a comment tag:
+```
+Feature: {feature_name}, Property {number}: {property_text}
+```
+
+### Property Test Implementation Plan
+
+**Property 1: Configuration Environment Isolation**
+- Generate random config keys
+- Verify values come from os.environ
+- Verify no hardcoded API keys in code
+
+**Property 2: Switchboard Four-Dimensional Classification**
+- Generate random user inputs
+- Verify routing decision has all four dimensions
+- Verify all dimensions have valid values
+
+**Property 3: Complexity-to-Execution-Mode Mapping**
+- Generate inputs of varying lengths
+- Verify complexity classification
+- Verify execution_mode matches complexity
+
+**Property 4: Simulation Keyword Triggering**
+- Generate inputs with/without trigger keywords
+- Verify task_family classification
+- Verify keyword detection is case-insensitive
+
+**Property 5: Provider Fallback Behavior**
+- Generate random prompts
+- Mock primary provider failures
+- Verify fallback is attempted
+- Verify result is returned or error is raised
+
+**Property 6: Case Persistence Round Trip**
+- Generate random case data
+- Save case
+- Retrieve case
+- Verify equivalence
+
+**Property 7: Case Record Structure Completeness**
+- Generate random case executions
+- Save cases
+- Verify all required fields present
+- Verify field types match schema
+
+**Property 8: Data Directory Organization**
+- Generate random case/simulation/log data
+- Save to storage
+- Verify files in correct directories
+
+**Property 9: Directory Auto-Creation**
+- Remove directories
+- Trigger storage operations
+- Verify directories created
+
+**Property 10: MiroFish Adapter Isolation**
+- Scan codebase for direct MiroFish URLs
+- Verify all calls go through adapter
+- Verify frontend has no MiroFish URLs
+
+**Property 11: Comprehensive Logging**
+- Generate random operations
+- Execute operations
+- Verify log entries created
+- Verify log entries have required fields
+
+**Property 12: Schema Validation**
+- Generate invalid request bodies
+- Submit to endpoints
+- Verify 422 status code
+- Verify validation error details
+
+**Property 13: External API Client Patterns**
+- Inspect all external API clients
+- Verify timeout configuration
+- Verify connection pooling
+- Verify error handling
+
+**Property 14: Error Response Sanitization**
+- Generate various error conditions
+- Trigger errors
+- Verify error response structure
+- Verify no internal details exposed
+
+**Property 15: Domain Pack Extensibility**
+- Create mock domain pack
+- Register domain pack
+- Verify agents can use pack
+- Verify no agent code modifications needed
+
+### Integration Testing
+
+**Test Scenarios**:
+1. End-to-end case execution (user input → final answer)
+2. Simulation workflow (submission → status → report → chat)
+3. Provider fallback in real execution
+4. Domain pack enhancement in research agent
+5. Case storage and retrieval
+6. Prompt management workflow
+
+### Test Coverage Goals
+
+- **Critical paths**: 90%+ coverage
+- **Service layer**: 80%+ coverage
+- **Agent logic**: 70%+ coverage
+- **Overall**: 70%+ coverage
+
+### CI/CD Pipeline
+
+1. Linting (ruff, black, isort)
+2. Type checking (mypy)
+3. Unit tests
+4. Property tests
+5. Integration tests
+6. Coverage report
+
+
+## Implementation Phases
+
+### Phase 1: Backend Consolidation and Provider Enhancement
+
+**Goal**: Strengthen core platform and provider abstraction
+
+**Tasks**:
+1. Add OpenAI provider support to `backend/app/agents/_model.py`
+2. Enhance provider fallback logging
+3. Add provider health checks to `backend/app/services/health_service.py`
+4. Add configuration validation on startup in `backend/app/config.py`
+5. Add missing environment variables to `.env.example`
+6. Update `backend/requirements.txt` with any new dependencies
+
+**Files to Modify**:
+- `backend/app/agents/_model.py`
+- `backend/app/services/health_service.py`
+- `backend/app/config.py`
+- `backend/.env.example`
+- `backend/requirements.txt`
+
+**Verification**:
+- All three providers (OpenRouter, Ollama, OpenAI) work
+- Fallback behavior logs correctly
+- Health check reports provider status
+- Missing config keys log warnings
+
+### Phase 2: Domain Pack Architecture
+
+**Goal**: Create domain pack infrastructure and integrate finance pack
+
+**Tasks**:
+1. Create domain pack base architecture:
+   - `backend/app/domain_packs/__init__.py`
+   - `backend/app/domain_packs/base.py` (DomainPack abstract class)
+   - `backend/app/domain_packs/registry.py` (DomainPackRegistry)
+
+2. Create finance domain pack structure:
+   - `backend/app/domain_packs/finance/__init__.py`
+   - `backend/app/domain_packs/finance/pack.py` (FinanceDomainPack class)
+
+3. Port impact_ai modules to finance pack:
+   - `backend/app/domain_packs/finance/market_data.py` (from impact_ai alpha_vantage_client.py)
+   - `backend/app/domain_packs/finance/news.py` (from impact_ai news_api.py)
+   - `backend/app/domain_packs/finance/entity_resolver.py`
+   - `backend/app/domain_packs/finance/ticker_resolver.py`
+   - `backend/app/domain_packs/finance/source_checker.py`
+   - `backend/app/domain_packs/finance/rumor_detector.py`
+   - `backend/app/domain_packs/finance/scam_detector.py`
+   - `backend/app/domain_packs/finance/stance_detector.py`
+   - `backend/app/domain_packs/finance/event_analyzer.py`
+   - `backend/app/domain_packs/finance/prediction.py`
+
+4. Consolidate external API clients:
+   - Merge Alpha Vantage logic into `backend/app/services/external_sources.py`
+   - Merge NewsAPI logic into `backend/app/services/external_sources.py`
+   - Remove duplicates
+
+5. Register finance pack in global registry
+
+**Files to Create**:
+- `backend/app/domain_packs/__init__.py`
+- `backend/app/domain_packs/base.py`
+- `backend/app/domain_packs/registry.py`
+- `backend/app/domain_packs/finance/__init__.py`
+- `backend/app/domain_packs/finance/pack.py`
+- `backend/app/domain_packs/finance/market_data.py`
+- `backend/app/domain_packs/finance/news.py`
+- `backend/app/domain_packs/finance/entity_resolver.py`
+- `backend/app/domain_packs/finance/ticker_resolver.py`
+- `backend/app/domain_packs/finance/source_checker.py`
+- `backend/app/domain_packs/finance/rumor_detector.py`
+- `backend/app/domain_packs/finance/scam_detector.py`
+- `backend/app/domain_packs/finance/stance_detector.py`
+- `backend/app/domain_packs/finance/event_analyzer.py`
+- `backend/app/domain_packs/finance/prediction.py`
+
+**Files to Modify**:
+- `backend/app/services/external_sources.py`
+- `backend/app/config.py` (add finance pack config)
+
+**Verification**:
+- Finance pack is registered
+- Finance pack capabilities are accessible
+- Domain detection works for finance keywords
+- External API clients are consolidated
+
+### Phase 3: Agent Enhancement with Domain Intelligence
+
+**Goal**: Integrate domain pack capabilities into agents
+
+**Tasks**:
+1. Enhance Switchboard with domain detection:
+   - Modify `backend/app/agents/switchboard.py`
+   - Add domain_pack dimension to routing decision
+   - Use domain registry for keyword detection
+
+2. Enhance Research Agent with domain capabilities:
+   - Modify `backend/app/agents/research.py`
+   - Call domain pack enhance_research() when domain detected
+   - Add structured entity extraction
+   - Update `backend/app/prompts/research.txt` with domain instructions
+
+3. Enhance Verifier Agent with domain capabilities:
+   - Modify `backend/app/agents/verifier.py`
+   - Call domain pack enhance_verification() when domain detected
+   - Add structured credibility scoring
+   - Update `backend/app/prompts/verifier.txt` with domain instructions
+
+4. Enhance Planner Agent:
+   - Modify `backend/app/agents/planner.py`
+   - Add simulation mode suggestion logic
+   - Update `backend/app/prompts/planner.txt`
+
+5. Enhance Synthesizer Agent:
+   - Modify `backend/app/agents/synthesizer.py`
+   - Add uncertainty quantification
+   - Add simulation recommendation logic
+   - Update `backend/app/prompts/synthesizer.txt`
+
+6. Update graph execution:
+   - Modify `backend/app/graph.py`
+   - Pass domain pack context through pipeline
+
+**Files to Modify**:
+- `backend/app/agents/switchboard.py`
+- `backend/app/agents/research.py`
+- `backend/app/agents/verifier.py`
+- `backend/app/agents/planner.py`
+- `backend/app/agents/synthesizer.py`
+- `backend/app/graph.py`
+- `backend/app/prompts/research.txt`
+- `backend/app/prompts/verifier.txt`
+- `backend/app/prompts/planner.txt`
+- `backend/app/prompts/synthesizer.txt`
+
+**Verification**:
+- Switchboard detects finance domain
+- Research agent extracts entities and tickers
+- Verifier agent scores credibility
+- Agents suggest simulation mode when appropriate
+- Domain-enhanced execution produces better results
+
+### Phase 4: Simulation Integration Enhancement
+
+**Goal**: Improve simulation workflow and case linking
+
+**Tasks**:
+1. Enhance simulation router:
+   - Modify `backend/app/routers/simulation.py`
+   - Add case_id linking
+   - Improve error messages
+
+2. Enhance simulation store:
+   - Modify `backend/app/services/simulation_store.py`
+   - Add simulation search
+   - Add simulation filtering
+
+3. Update case storage for simulation linking:
+   - Modify `backend/app/services/case_store.py`
+   - Add simulation_id field to case records
+   - Add case-to-simulation lookup
+
+4. Add simulation workflow to graph:
+   - Modify `backend/app/graph.py`
+   - Add simulation handoff logic
+   - Add simulation result synthesis
+
+**Files to Modify**:
+- `backend/app/routers/simulation.py`
+- `backend/app/services/simulation_store.py`
+- `backend/app/services/case_store.py`
+- `backend/app/graph.py`
+- `backend/app/schemas.py` (add simulation-related schemas)
+
+**Verification**:
+- Simulation requests create linked cases
+- Cases with simulations show simulation_id
+- Simulation results are synthesized into final answer
+- Simulation workflow is seamless
+
+### Phase 5: API Discovery Subsystem
+
+**Goal**: Create API discovery infrastructure for future expansion
+
+**Tasks**:
+1. Create API discovery structure:
+   - `backend/app/services/api_discovery/__init__.py`
+   - `backend/app/services/api_discovery/catalog_loader.py`
+   - `backend/app/services/api_discovery/classifier.py`
+   - `backend/app/services/api_discovery/scorer.py`
+   - `backend/app/services/api_discovery/metadata_store.py`
+
+2. Implement catalog loader:
+   - Load public-apis JSON from GitHub or local cache
+   - Parse API entries
+
+3. Implement classifier:
+   - Classify APIs by category
+   - Map to domain packs
+
+4. Implement scorer:
+   - Score APIs by usefulness
+   - Consider auth, HTTPS, CORS
+
+5. Add discovery endpoints (optional):
+   - `GET /api-discovery/categories`
+   - `GET /api-discovery/search?category=X`
+   - `GET /api-discovery/top-scored`
+
+**Files to Create**:
+- `backend/app/services/api_discovery/__init__.py`
+- `backend/app/services/api_discovery/catalog_loader.py`
+- `backend/app/services/api_discovery/classifier.py`
+- `backend/app/services/api_discovery/scorer.py`
+- `backend/app/services/api_discovery/metadata_store.py`
+
+**Files to Modify** (optional):
+- `backend/app/main.py` (add discovery router)
+
+**Verification**:
+- Catalog loads successfully
+- APIs are classified correctly
+- Scoring produces reasonable priorities
+- Discovery is available for future connector development
+
+
+### Phase 6: Frontend Enhancement
+
+**Goal**: Evolve frontend from demo to product dashboard
+
+**Tasks**:
+1. Create layout and navigation:
+   - Modify `frontend/src/app/layout.tsx`
+   - Create `frontend/src/components/layout/Header.tsx`
+   - Create `frontend/src/components/layout/Navigation.tsx`
+
+2. Create main dashboard:
+   - Modify `frontend/src/app/page.tsx`
+   - Add quick stats, recent cases, system status
+
+3. Create Analyze page:
+   - Create `frontend/src/app/analyze/page.tsx`
+   - Create `frontend/src/components/analyze/TaskInput.tsx`
+   - Create `frontend/src/components/analyze/ModeSelector.tsx`
+   - Create `frontend/src/components/analyze/ResultViewer.tsx`
+   - Create `frontend/src/components/analyze/AgentOutputPanel.tsx`
+
+4. Create Cases page:
+   - Create `frontend/src/app/cases/page.tsx`
+   - Create `frontend/src/app/cases/[id]/page.tsx`
+   - Create `frontend/src/components/cases/CaseList.tsx`
+   - Create `frontend/src/components/cases/CaseCard.tsx`
+   - Create `frontend/src/components/cases/CaseDetail.tsx`
+
+5. Create Simulation page:
+   - Create `frontend/src/app/simulation/page.tsx`
+   - Create `frontend/src/app/simulation/[id]/page.tsx`
+   - Create `frontend/src/components/simulation/SimulationForm.tsx`
+   - Create `frontend/src/components/simulation/SimulationStatus.tsx`
+   - Create `frontend/src/components/simulation/SimulationReport.tsx`
+   - Create `frontend/src/components/simulation/SimulationChat.tsx`
+
+6. Create Prompt Lab page:
+   - Create `frontend/src/app/prompts/page.tsx`
+   - Create `frontend/src/components/prompts/PromptList.tsx`
+   - Create `frontend/src/components/prompts/PromptEditor.tsx`
+
+7. Create Config page:
+   - Create `frontend/src/app/config/page.tsx`
+
+8. Create API client:
+   - Create `frontend/src/lib/api.ts` (MiroOrgClient class)
+   - Create `frontend/src/lib/types.ts` (TypeScript types)
+
+9. Create common components:
+   - Create `frontend/src/components/common/Badge.tsx`
+   - Create `frontend/src/components/common/Card.tsx`
+   - Create `frontend/src/components/common/LoadingSpinner.tsx`
+   - Create `frontend/src/components/common/ErrorMessage.tsx`
+
+10. Update styling:
+    - Modify `frontend/src/app/globals.css`
+    - Implement dark theme
+    - Add animations
+
+**Files to Create**:
+- `frontend/src/components/layout/Header.tsx`
+- `frontend/src/components/layout/Navigation.tsx`
+- `frontend/src/app/analyze/page.tsx`
+- `frontend/src/components/analyze/TaskInput.tsx`
+- `frontend/src/components/analyze/ModeSelector.tsx`
+- `frontend/src/components/analyze/ResultViewer.tsx`
+- `frontend/src/components/analyze/AgentOutputPanel.tsx`
+- `frontend/src/app/cases/page.tsx`
+- `frontend/src/app/cases/[id]/page.tsx`
+- `frontend/src/components/cases/CaseList.tsx`
+- `frontend/src/components/cases/CaseCard.tsx`
+- `frontend/src/components/cases/CaseDetail.tsx`
+- `frontend/src/app/simulation/page.tsx`
+- `frontend/src/app/simulation/[id]/page.tsx`
+- `frontend/src/components/simulation/SimulationForm.tsx`
+- `frontend/src/components/simulation/SimulationStatus.tsx`
+- `frontend/src/components/simulation/SimulationReport.tsx`
+- `frontend/src/components/simulation/SimulationChat.tsx`
+- `frontend/src/app/prompts/page.tsx`
+- `frontend/src/components/prompts/PromptList.tsx`
+- `frontend/src/components/prompts/PromptEditor.tsx`
+- `frontend/src/app/config/page.tsx`
+- `frontend/src/lib/api.ts`
+- `frontend/src/lib/types.ts`
+- `frontend/src/components/common/Badge.tsx`
+- `frontend/src/components/common/Card.tsx`
+- `frontend/src/components/common/LoadingSpinner.tsx`
+- `frontend/src/components/common/ErrorMessage.tsx`
+
+**Files to Modify**:
+- `frontend/src/app/layout.tsx`
+- `frontend/src/app/page.tsx`
+- `frontend/src/app/globals.css`
+- `frontend/package.json` (add dependencies if needed)
+
+**Verification**:
+- All pages are accessible via navigation
+- Analyze workflow works end-to-end
+- Case history displays correctly
+- Simulation workflow works end-to-end
+- Prompt lab allows editing
+- Config page shows system status
+- UI is polished and professional
+
+### Phase 7: Testing and Documentation
+
+**Goal**: Comprehensive testing and documentation
+
+**Tasks**:
+1. Write unit tests:
+   - Test provider abstraction
+   - Test domain pack registry
+   - Test agent routing
+   - Test case storage
+   - Test simulation integration
+
+2. Write property-based tests:
+   - Implement all 15 properties from Correctness Properties section
+   - Configure 100+ iterations per test
+   - Add property tags
+
+3. Write integration tests:
+   - End-to-end case execution
+   - Simulation workflow
+   - Provider fallback
+   - Domain pack enhancement
+
+4. Update documentation:
+   - Update `README.md` with architecture overview
+   - Document four-layer architecture
+   - Document agent roles
+   - Document domain pack integration
+   - Document simulation integration
+   - Add setup instructions
+   - Add API endpoint documentation
+   - Add environment variable reference
+
+5. Create developer documentation:
+   - Create `ARCHITECTURE.md`
+   - Create `DOMAIN_PACKS.md`
+   - Create `TESTING.md`
+   - Create `DEPLOYMENT.md`
+
+**Files to Create**:
+- `backend/tests/test_providers.py`
+- `backend/tests/test_domain_packs.py`
+- `backend/tests/test_agents.py`
+- `backend/tests/test_storage.py`
+- `backend/tests/test_simulation.py`
+- `backend/tests/test_properties.py` (property-based tests)
+- `backend/tests/test_integration.py`
+- `ARCHITECTURE.md`
+- `DOMAIN_PACKS.md`
+- `TESTING.md`
+- `DEPLOYMENT.md`
+
+**Files to Modify**:
+- `README.md`
+
+**Verification**:
+- All tests pass
+- Coverage meets goals (70%+ overall)
+- Documentation is complete and accurate
+- Setup instructions work for new developers
+
+### Phase 8: Cleanup and Optimization
+
+**Goal**: Remove dead code, optimize performance, polish
+
+**Tasks**:
+1. Remove dead code:
+   - Remove unused imports
+   - Remove commented code
+   - Remove duplicate implementations
+
+2. Optimize performance:
+   - Add caching for market quotes (5 min TTL)
+   - Add connection pooling for external APIs
+   - Optimize database queries (if applicable)
+   - Add request timeouts
+
+3. Polish error messages:
+   - Review all error messages
+   - Ensure consistency
+   - Ensure clarity
+
+4. Polish logging:
+   - Review log levels
+   - Ensure consistency
+   - Add missing log entries
+
+5. Security review:
+   - Ensure no API keys in code
+   - Ensure error messages don't leak internals
+   - Ensure input validation is comprehensive
+
+6. Performance testing:
+   - Test response times
+   - Test under load
+   - Identify bottlenecks
+
+**Verification**:
+- No dead code remains
+- Performance meets requirements (5s simple, 30s complex)
+- Error messages are clear and consistent
+- Logging is comprehensive and useful
+- Security review passes
+- Performance testing passes
+
+### Phase 9: Autonomous Knowledge Evolution Layer
+
+**Goal**: Implement self-improving intelligence system that learns without local model training
+
+**Tasks**:
+1. Create learning subsystem structure:
+   - Create `backend/app/services/learning/__init__.py`
+   - Create `backend/app/services/learning/knowledge_ingestor.py`
+   - Create `backend/app/services/learning/knowledge_store.py`
+   - Create `backend/app/services/learning/learning_engine.py`
+   - Create `backend/app/services/learning/prompt_optimizer.py`
+   - Create `backend/app/services/learning/skill_distiller.py`
+   - Create `backend/app/services/learning/trust_manager.py`
+   - Create `backend/app/services/learning/freshness_manager.py`
+   - Create `backend/app/services/learning/scheduler.py`
+
+2. Create data directories:
+   - Create `backend/app/data/knowledge/`
+   - Create `backend/app/data/skills/`
+   - Create `backend/app/data/prompt_versions/`
+   - Create `backend/app/data/learning/`
+
+3. Implement knowledge ingestion:
+   - Implement ingest_from_search() using Tavily
+   - Implement ingest_from_url() using Jina Reader
+   - Implement ingest_from_news() using NewsAPI
+   - Implement compress_content() for summarization
+   - Add storage limit enforcement (200MB max)
+
+4. Implement knowledge store:
+   - Implement save_knowledge() with JSON storage
+   - Implement search_knowledge() with keyword matching
+   - Implement delete_expired_knowledge() with auto-cleanup
+   - Implement LRU eviction when storage limit reached
+
+5. Implement experience learning:
+   - Implement learn_from_case() to extract metadata
+   - Implement detect_patterns() for repeated patterns
+   - Implement get_route_effectiveness() for routing insights
+   - Implement get_prompt_performance() for prompt insights
+
+6. Implement prompt evolution:
+   - Implement create_prompt_variant() using provider API
+   - Implement test_prompt_variant() with quality metrics
+   - Implement compare_prompts() for A/B testing
+   - Implement promote_prompt() with validation
+
+7. Implement skill distillation:
+   - Implement detect_skill_candidates() from patterns
+   - Implement distill_skill() to create skill records
+   - Implement test_skill() for validation
+   - Implement apply_skill() for skill usage
+
+8. Implement trust and freshness management:
+   - Implement get_trust_score() and update_trust()
+   - Implement calculate_freshness() with domain rules
+   - Implement recommend_refresh() for stale items
+
+9. Implement learning scheduler:
+   - Implement schedule_task() with safeguards
+   - Implement is_system_idle() and is_battery_ok()
+   - Add scheduled tasks: ingestion, cleanup, pattern detection
+   - Add manual trigger via run_once()
+
+10. Add learning endpoints:
+    - Add GET /learning/status
+    - Add POST /learning/run-once
+    - Add GET /learning/insights
+    - Add GET /knowledge and GET /knowledge/{item_id}
+    - Add GET /knowledge/search
+    - Add GET /skills and GET /skills/{skill_name}
+    - Add POST /skills/distill
+    - Add GET /sources/trust and GET /sources/freshness
+    - Add GET /prompts/versions/{name}
+    - Add POST /prompts/optimize/{name}
+    - Add POST /prompts/promote/{name}/{version}
+
+11. Integrate with existing layers:
+    - Hook learn_from_case() into case save flow
+    - Hook knowledge search into research agent
+    - Hook skill application into agent execution
+    - Hook trust scores into source selection
+    - Hook prompt versions into prompt loading
+
+12. Add configuration:
+    - Add LEARNING_ENABLED flag
+    - Add KNOWLEDGE_MAX_SIZE_MB (default 200)
+    - Add LEARNING_SCHEDULE_INTERVAL
+    - Add LEARNING_BATCH_SIZE
+    - Add domain-specific expiration rules
+
+**Verification**:
+- Learning subsystem runs without stressing laptop
+- Knowledge cache stays under 200MB
+- Scheduler respects battery and CPU constraints
+- Trust scores improve source selection
+- Prompt evolution produces better prompts
+- Skills are distilled from repeated patterns
+- Learning endpoints return useful insights
+- System improves over time without manual intervention
+
+## Implementation Priority Summary
+
+1. **Phase 1**: Backend Consolidation and Provider Enhancement
+2. **Phase 2**: Domain Pack Architecture
+3. **Phase 3**: Agent Enhancement with Domain Intelligence
+4. **Phase 4**: Simulation Integration Enhancement
+5. **Phase 5**: API Discovery Subsystem
+6. **Phase 6**: Frontend Enhancement
+7. **Phase 7**: Testing and Documentation
+8. **Phase 8**: Cleanup and Optimization
+9. **Phase 9**: Autonomous Knowledge Evolution Layer
+
+Each phase builds on the previous, maintaining a runnable system at every step. The focus is on single-user local deployment with production-quality code structure, not enterprise features like auth, Kubernetes, or cloud deployment.
+
+
+## Design Decisions and Rationale
+
+### Why Five Layers?
+
+The five-layer architecture provides clear separation of concerns:
+- **Layer 1 (Core Platform)**: Infrastructure that any system needs
+- **Layer 2 (Agent Organization)**: Domain-agnostic orchestration
+- **Layer 3 (Domain Packs)**: Pluggable domain intelligence
+- **Layer 4 (Simulation Lab)**: External service for scenario modeling
+- **Layer 5 (Autonomous Knowledge Evolution)**: Self-improvement without local model training
+
+This separation allows the system to improve itself over time while maintaining clear boundaries between operational layers and learning layers.
+
+### Why Domain Packs Instead of Monolithic Agents?
+
+Domain packs provide:
+- **Modularity**: Finance intelligence can be developed independently
+- **Reusability**: Same pack can enhance multiple agents
+- **Extensibility**: New domains (policy, cyber) can be added without refactoring
+- **Testability**: Domain logic can be tested in isolation
+
+### Why Adapter Pattern for MiroFish?
+
+The adapter pattern provides:
+- **Loose Coupling**: MiroOrg doesn't depend on MiroFish internals
+- **Testability**: Adapter can be mocked for testing
+- **Flexibility**: MiroFish can be replaced or upgraded independently
+- **Error Isolation**: MiroFish failures don't crash MiroOrg
+
+### Why Local Storage Instead of Database?
+
+For single-user local deployment:
+- **Simplicity**: No database setup required
+- **Portability**: Data travels with the application
+- **Transparency**: JSON files are human-readable
+- **Offline**: Works without network connectivity
+
+Future versions can add database support without changing the service layer interface.
+
+### Why Provider Abstraction?
+
+Provider abstraction provides:
+- **Flexibility**: Switch providers without changing agent code
+- **Resilience**: Automatic fallback when primary fails
+- **Cost Optimization**: Use cheaper providers for simple tasks
+- **Future-Proofing**: New providers can be added easily
+
+### Why Property-Based Testing?
+
+Property-based testing provides:
+- **Comprehensive Coverage**: Tests thousands of input combinations
+- **Bug Discovery**: Finds edge cases developers miss
+- **Specification**: Properties serve as executable specifications
+- **Regression Prevention**: Random inputs catch regressions
+
+Combined with unit tests, property tests provide high confidence in correctness.
+
+### Why Autonomous Knowledge Evolution Instead of Local Model Training?
+
+The Autonomous Knowledge Evolution Layer provides system-level self-improvement without the resource requirements of local model training:
+
+**Resource Constraints**:
+- Local model training requires 40GB+ VRAM, terabytes of storage, and days of compute time
+- Autonomous learning requires only 200MB storage and lightweight background tasks
+- Suitable for 8GB/256GB laptop without stressing the system
+
+**Learning Approach**:
+- **NOT**: Training foundation models locally
+- **YES**: Learning from compressed knowledge, case patterns, prompt evolution, and skill distillation
+- **NOT**: Storing raw datasets
+- **YES**: Storing compressed summaries (2-4KB each)
+
+**Benefits**:
+- System improves from real-world usage
+- Learns which sources are trustworthy
+- Evolves prompts through controlled testing
+- Distills reusable skills from patterns
+- Adapts to user's domain and use cases
+- No manual intervention required
+
+**Safeguards**:
+- Strict storage limits (200MB max)
+- Battery-aware scheduling
+- CPU-conscious background tasks
+- Controlled prompt evolution (not autonomous chaos)
+- Manual override options
+
+This approach makes the system genuinely self-improving while respecting laptop constraints.
+
+## Security Considerations
+
+### API Key Management
+
+- All API keys loaded from environment variables
+- Never commit `.env` files
+- Never log API keys
+- Never expose keys in API responses
+- Validate keys on startup
+
+### Input Validation
+
+- All requests validated against Pydantic schemas
+- Reject invalid inputs with 422 status
+- Sanitize user input before external API calls
+- Prevent injection attacks
+
+### Error Message Sanitization
+
+- Never expose internal implementation details
+- Never expose stack traces to frontend
+- Never expose raw provider exceptions
+- Provide descriptive but safe error messages
+
+### External Service Isolation
+
+- All external calls have timeouts
+- All external failures are caught and handled
+- External failures don't crash the system
+- External services are optional (graceful degradation)
+
+## Performance Considerations
+
+### Response Time Targets
+
+- Simple queries: < 5 seconds
+- Medium queries: < 15 seconds
+- Complex queries: < 30 seconds
+- Simulation submission: < 5 seconds
+- Simulation completion: varies (minutes to hours)
+
+### Optimization Strategies
+
+- Connection pooling for external APIs
+- Caching for market quotes (5 min TTL)
+- Async/await for I/O-bound operations
+- Pagination for large result sets
+- Request timeouts to prevent hanging
+
+### Scalability Considerations
+
+Current design is single-user local deployment. Future scalability improvements:
+- Replace JSON storage with database
+- Add Redis for caching
+- Add message queue for async processing
+- Add horizontal scaling for agents
+- Add load balancing
+
+## Deployment Considerations
+
+### Local Development
+
+1. Clone repository
+2. Copy `.env.example` to `.env`
+3. Configure API keys
+4. Install Python dependencies: `pip install -r requirements.txt`
+5. Install Node dependencies: `cd frontend && npm install`
+6. Run backend: `cd backend && uvicorn app.main:app --reload`
+7. Run frontend: `cd frontend && npm run dev`
+8. Access at `http://localhost:3000`
+
+### Production Deployment (Future)
+
+- Use production ASGI server (gunicorn + uvicorn)
+- Use production Node server (Next.js production build)
+- Use reverse proxy (nginx)
+- Use process manager (systemd, supervisor)
+- Use HTTPS
+- Use environment-specific configs
+- Use log aggregation
+- Use monitoring and alerting
+
+## Conclusion
+
+This design provides a comprehensive blueprint for implementing MiroOrg v1.1 as a general intelligence operating system with pluggable domain packs, multi-agent orchestration, and simulation capabilities. The four-layer architecture ensures modularity and extensibility, while the provider abstraction and domain pack pattern enable flexibility and future growth.
+
+The implementation phases provide a clear roadmap from current state to production-ready system, maintaining a runnable system at every step. The testing strategy ensures correctness through both unit tests and property-based tests, while the error handling and security considerations ensure robustness and safety.
+
+The design is executable, with specific file targets, clear interfaces, and concrete implementation guidance. The system can be built incrementally, with each phase delivering value and maintaining backward compatibility.
+

.kiro/specs/ai-financial-intelligence-system/requirements.md

@@ -0,0 +1,473 @@
+# Requirements Document
+
+## Introduction
+
+This document specifies requirements for MiroOrg v1.1, a general intelligence operating system that orchestrates multiple specialist agents, runs simulations, supports pluggable domain packs, and autonomously improves itself over time. The system merges capabilities from miroorg-basic-v2 (base architecture), impact_ai (first domain pack), MiroFish (simulation lab), and public-apis (API discovery catalog) into a unified, production-ready platform. The architecture follows a five-layer design: Core Platform, Agent Organization, Domain Packs, Simulation Lab, and Autonomous Knowledge Evolution Layer.
+
+## Glossary
+
+- **System**: MiroOrg v1.1 - The general intelligence operating system
+- **Core_Platform**: Layer 1 - FastAPI backend, frontend dashboard, config, health, memory, prompts, cases, logs
+- **Agent_Organization**: Layer 2 - Multi-agent orchestration framework (Switchboard, Research, Planner, Verifier, Synthesizer)
+- **Domain_Packs**: Layer 3 - Pluggable domain intelligence modules (finance/news from impact_ai as first pack)
+- **Simulation_Lab**: Layer 4 - MiroFish integration for simulation, digital-world modeling, and scenario analysis
+- **Autonomous_Knowledge_Evolution_Layer**: Layer 5 - Self-improving intelligence system that learns from internet knowledge, past cases, prompt evolution, and skill distillation
+- **Knowledge_Item**: Compressed structured record of external information with summary, entities, trust score, and freshness score
+- **Skill**: Distilled reusable workflow pattern extracted from repeated successful case executions
+- **Trust_Score**: Measure of source reliability learned from verification outcomes (0.0 - 1.0)
+- **Freshness_Score**: Measure of information recency and relevance (0.0 - 1.0)
+- **Prompt_Version**: Versioned prompt with performance metadata (win_rate, status, last_tested)
+- **Switchboard**: Routing agent that classifies tasks by family, domain, complexity, and execution mode
+- **Research_Agent**: Agent responsible for gathering context, extracting entities, and fetching external information
+- **Planner_Agent**: Agent that converts research into practical action plans
+- **Verifier_Agent**: Agent that validates credibility, detects rumors/scams, and surfaces uncertainty
+- **Synthesizer_Agent**: Agent that produces final comprehensive responses with honest uncertainty
+- **Provider_Layer**: Abstraction for AI model providers (OpenRouter, Ollama, future OpenAI)
+- **Case**: A stored execution record containing inputs, routing decisions, agent outputs, and results
+- **MiroFish**: External simulation service for graph building, environment setup, simulation, report generation, and deep interaction
+- **Domain_Pack**: Pluggable module providing domain-specific intelligence (finance is first, others follow)
+- **API_Discovery**: Subsystem using public-apis catalog for discovering and classifying free APIs
+- **Ticker**: Stock market symbol (e.g., AAPL, TSLA)
+- **Entity**: Company, organization, person, or concept mentioned in text
+- **Source_Credibility**: Measure of trustworthiness for information sources
+- **Analyze_Mode**: Execution mode for summarization, research, and analysis tasks
+- **Organization_Mode**: Execution mode using multi-agent collaboration
+- **Simulation_Mode**: Execution mode for scenario forecasting and what-if modeling
+
+## Requirements
+
+### Requirement 1: Repository Ownership and Merge Strategy
+
+**User Story:** As a developer, I want clear repository ownership rules, so that I can merge codebases without architectural confusion.
+
+#### Acceptance Criteria
+
+1. THE System SHALL use miroorg-basic-v2 as the primary repo and canonical architecture
+2. THE System SHALL treat impact_ai as a source of reusable domain modules, not as an equal structural peer
+3. THE System SHALL integrate MiroFish as a separate service through a client adapter
+4. THE System SHALL treat public-apis/public-apis as a discovery dataset for future connector expansion, not as a runtime dependency
+5. WHEN overlapping logic exists between repos, THE System SHALL choose one canonical implementation and remove dead duplicates
+6. THE System SHALL preserve the existing miroorg-basic-v2 folder structure as the base architecture
+7. THE System SHALL maintain separate directories for agents, services, routers, prompts, and core configuration
+8. THE System SHALL use environment variables for all configuration and API keys
+
+### Requirement 2: Five-Layer Architecture
+
+**User Story:** As a system architect, I want a clear five-layer architecture, so that the system can scale across multiple domains, use cases, and autonomously improve over time.
+
+#### Acceptance Criteria
+
+1. THE System SHALL implement Layer 1 (Core Platform) with FastAPI backend, frontend dashboard, config, health, memory, prompts, cases, and logs
+2. THE System SHALL implement Layer 2 (Agent Organization) with Switchboard, Research Agent, Planner Agent, Verifier Agent, and Synthesizer Agent
+3. THE System SHALL implement Layer 3 (Domain Packs) with finance/news intelligence from impact_ai as the first pack
+4. THE System SHALL implement Layer 4 (Simulation Lab) with MiroFish integration for simulation and digital-world modeling
+5. THE System SHALL implement Layer 5 (Autonomous Knowledge Evolution Layer) with world knowledge ingestion, experience learning, prompt evolution, skill distillation, and trust management
+6. THE System SHALL support future domain packs (policy, cyber, enterprise ops, research, education) without changing Layer 2
+7. THE System SHALL support optional future agents (Risk, Market, Simulation, Compliance) in Layer 2
+8. THE System SHALL maintain clear separation between layers with well-defined interfaces
+
+### Requirement 3: Product Modes
+
+**User Story:** As a user, I want the system to support different execution modes, so that I can choose the appropriate approach for my task.
+
+#### Acceptance Criteria
+
+1. THE System SHALL support Analyze Mode for summarization, research, market/news analysis, entity/ticker detection, credibility/risk evaluation, and actionable recommendations
+2. THE System SHALL support Organization Mode for multi-agent debate, planning, verification, synthesis, and case memory workflows
+3. THE System SHALL support Simulation Mode for scenario forecasting, market reaction prediction, stakeholder reaction modeling, policy/narrative/reputation simulation, and post-simulation questioning
+4. WHEN Simulation Mode is used, THE System SHALL use MiroFish through adapter endpoints, not through frontend-direct calls
+5. THE System SHALL route tasks to the appropriate mode based on Switchboard classification
+
+### Requirement 4: Switchboard Routing and Classification
+
+**User Story:** As a user, I want intelligent task routing, so that my requests are handled by the appropriate execution path.
+
+#### Acceptance Criteria
+
+1. THE Switchboard SHALL classify every task using four dimensions: task_family (normal or simulation), domain_pack (finance, general, policy, custom), complexity (simple, medium, complex), and execution_mode (solo, standard, deep)
+2. WHEN complexity is simple, THE Switchboard SHALL route to solo execution mode (minimal path)
+3. WHEN complexity is medium, THE Switchboard SHALL route to standard execution mode (normal multi-agent path)
+4. WHEN complexity is complex, THE Switchboard SHALL route to deep execution mode (full multi-agent path with optional verifier and optional simulation handoff)
+5. WHEN user input contains simulation trigger keywords, THE Switchboard SHALL route to Simulation Mode
+6. THE System SHALL make simulation trigger keywords environment-configurable
+7. THE Switchboard SHALL detect keywords including: simulate, predict, model reaction, test scenarios, run digital twins, explore "what if" outcomes
+8. THE Switchboard SHALL include routing decision in case metadata
+
+### Requirement 5: Domain Engine Integration
+
+**User Story:** As a financial analyst, I want the system to leverage impact_ai's financial intelligence modules, so that I can perform sophisticated market and news analysis.
+
+#### Acceptance Criteria
+
+1. THE System SHALL integrate impact_ai as the first domain pack
+2. THE System SHALL inspect and reuse valuable modules including: alpha_vantage_client.py, news_api.py, brain.py, event_analyzer.py, ticker_resolver.py, source_checker.py, rumor_detector.py, scam_detector.py, stance_detector.py, prediction.py, market_data.py, entity_resolver.py
+3. THE System SHALL expose domain pack capabilities through the MiroOrg service layer, not as scattered utility scripts
+4. THE System SHALL consolidate overlapping external API clients (Alpha Vantage, NewsAPI) with existing external_sources.py
+5. WHEN integrating impact_ai modules, THE System SHALL refactor code to match the existing service layer pattern
+6. THE System SHALL design the architecture to support additional domain packs later without changing the agent organization layer
+7. THE System SHALL treat finance as the first deep pack, not the only pack
+
+### Requirement 6: Provider Abstraction Layer
+
+**User Story:** As a system administrator, I want a unified provider interface, so that I can switch between AI model providers without changing agent code.
+
+#### Acceptance Criteria
+
+1. THE System SHALL create a provider abstraction layer with a single call_model() interface
+2. THE System SHALL support OpenRouter as a primary provider
+3. THE System SHALL support Ollama as a fallback provider
+4. THE System SHALL support future OpenAI provider integration
+5. WHEN the primary provider fails, THE System SHALL automatically fall back to the secondary provider according to environment-configured policy
+6. THE System SHALL log provider selection and fallback events
+7. THE System SHALL expose provider configuration through environment variables
+8. THE System SHALL allow per-agent model selection (chat vs reasoner models)
+9. THE System SHALL support adaptive execution depth to reduce unnecessary external model usage on trivial tasks
+
+### Requirement 7: Enhanced Agent Intelligence
+
+**User Story:** As a user, I want agents to use domain intelligence capabilities, so that I receive accurate and credible analysis.
+
+#### Acceptance Criteria
+
+1. THE Research_Agent SHALL gather context from prompts, APIs, and domain services
+2. THE Research_Agent SHALL extract entities, tickers, and claims from user input
+3. THE Research_Agent SHALL fetch external information where allowed
+4. THE Research_Agent SHALL return structured facts, assumptions, open questions, and useful signals
+5. THE Planner_Agent SHALL convert research into a practical response or action plan
+6. THE Planner_Agent SHALL highlight dependencies, risks, and possible next steps
+7. THE Verifier_Agent SHALL test credibility of information
+8. THE Verifier_Agent SHALL detect rumors, scams, unsupported claims, and contradictions using source_checker, rumor_detector, and scam_detector
+9. THE Verifier_Agent SHALL force uncertainty to be made visible
+10. THE Synthesizer_Agent SHALL combine outputs into one final answer
+11. THE Synthesizer_Agent SHALL state uncertainty honestly
+12. THE Synthesizer_Agent SHALL recommend next actions
+13. THE Synthesizer_Agent SHALL suggest simulation mode when scenario analysis is more appropriate
+14. THE System SHALL preserve existing agent prompt files and update them with domain intelligence instructions
+15. THE System SHALL maintain agent modularity and separation of concerns
+
+### Requirement 9: External API Integration and Discovery
+
+**User Story:** As a developer, I want a structured approach to external API integration, so that I can easily add new connectors and discover useful APIs.
+
+#### Acceptance Criteria
+
+1. THE System SHALL support external API integrations through a dedicated services layer
+2. THE System SHALL include initial connector support for: market/news connectors from impact_ai, OpenRouter, Ollama, Tavily, Jina Reader, NewsAPI, Alpha Vantage
+3. THE System SHALL use public-apis/public-apis as an API discovery source for future connectors
+4. THE System SHALL implement an API discovery subsystem that classifies free APIs by category
+5. THE API discovery subsystem SHALL score candidate APIs for usefulness
+6. THE API discovery subsystem SHALL store metadata such as auth requirements, HTTPS support, and CORS configuration
+7. THE API discovery subsystem SHALL support future sandbox testing and promotion into connectors
+8. THE System SHALL treat public-apis as a discovery catalog, not as a runtime dependency
+9. THE System SHALL use connection pooling for external API clients
+10. THE System SHALL implement request timeouts for all external API calls
+
+### Requirement 10: Case Memory System
+
+**User Story:** As a user, I want all interactions stored, so that I can review past analyses and track system behavior.
+
+#### Acceptance Criteria
+
+1. THE System SHALL persist every case execution to local storage
+2. THE System SHALL store case_id, user_input, routing decision, agent outputs, final answer, and timestamps
+3. THE System SHALL support retrieving cases by case_id
+4. THE System SHALL support listing all cases with optional limit parameter
+5. THE System SHALL support deleting cases by case_id
+6. THE System SHALL provide memory statistics including total cases and storage size
+7. THE System SHALL use JSON format for case storage
+8. WHEN a simulation is executed, THE System SHALL link simulation_id to the case record
+9. THE System SHALL store cases in backend/app/data/memory directory
+10. THE System SHALL store simulations in backend/app/data/simulations directory
+11. THE System SHALL store logs in backend/app/data/logs directory
+12. THE System SHALL create data directories automatically if they do not exist
+
+### Requirement 8: Simulation Integration
+
+**User Story:** As a user, I want to run simulations and explore what-if scenarios, so that I can predict potential impacts and test hypotheses.
+
+#### Acceptance Criteria
+
+1. THE System SHALL integrate MiroFish as a separate backend service, not merged directly into the MiroOrg codebase
+2. THE System SHALL implement a mirofish_client service as an adapter
+3. THE System SHALL make MiroFish API paths configurable through environment variables
+4. THE System SHALL support MiroFish health check
+5. THE System SHALL support simulation submission with title and prediction_goal
+6. THE System SHALL support simulation status retrieval by simulation_id
+7. THE System SHALL support report retrieval by simulation_id
+8. THE System SHALL support post-simulation chat by simulation_id
+9. THE System SHALL use MiroFish for graph building, entity relationship extraction, persona generation, simulation, report generation, and deep interaction
+10. THE System SHALL store simulation metadata locally in simulations directory
+11. WHEN MiroFish is disabled, THE System SHALL return appropriate error messages for simulation requests
+12. THE System SHALL handle MiroFish connection failures gracefully with descriptive errors
+13. THE frontend SHALL only consume MiroOrg endpoints for simulation, never direct MiroFish calls
+
+### Requirement 11: API Endpoints
+
+**User Story:** As a frontend developer, I want comprehensive REST endpoints, so that I can build a rich user interface.
+
+#### Acceptance Criteria
+
+1. THE System SHALL preserve GET /health endpoint for basic health checks
+2. THE System SHALL preserve GET /health/deep endpoint for comprehensive health status
+3. THE System SHALL preserve GET /config/status endpoint for configuration visibility
+4. THE System SHALL preserve GET /agents endpoint for listing all agents
+5. THE System SHALL preserve GET /agents/{agent_name} endpoint for agent details
+6. THE System SHALL preserve POST /run endpoint for standard execution
+7. THE System SHALL preserve POST /run/debug endpoint for detailed execution traces
+8. THE System SHALL preserve POST /run/agent endpoint for single agent execution
+9. THE System SHALL preserve GET /cases endpoint for listing cases
+10. THE System SHALL preserve GET /cases/{case_id} endpoint for case details
+11. THE System SHALL preserve DELETE /cases/{case_id} endpoint for case deletion
+12. THE System SHALL preserve GET /memory/stats endpoint for memory statistics
+13. THE System SHALL preserve GET /prompts endpoint for listing prompts
+14. THE System SHALL preserve GET /prompts/{name} endpoint for prompt retrieval
+15. THE System SHALL preserve PUT /prompts/{name} endpoint for prompt updates
+16. THE System SHALL preserve GET /simulation/health endpoint for MiroFish health
+17. THE System SHALL preserve POST /simulation/run endpoint for simulation submission
+18. THE System SHALL preserve GET /simulation/{simulation_id} endpoint for simulation status
+19. THE System SHALL preserve GET /simulation/{simulation_id}/report endpoint for simulation reports
+20. THE System SHALL preserve POST /simulation/{simulation_id}/chat endpoint for simulation chat
+21. THE frontend SHALL only consume MiroOrg endpoints, even for simulation operations
+
+### Requirement 9: Error Handling and Logging
+
+**User Story:** As a developer, I want robust error handling and logging, so that I can diagnose issues and monitor system behavior.
+
+#### Acceptance Criteria
+
+1. THE System SHALL use typed Pydantic schemas for all request and response models
+2. THE System SHALL validate all incoming requests against schemas
+3. THE System SHALL return structured error responses with appropriate HTTP status codes
+4. THE System SHALL log all agent executions with case_id and timestamps
+5. THE System SHALL log provider selection and fallback events
+6. THE System SHALL log external API calls and failures
+7. THE System SHALL log simulation requests and responses
+8. WHEN an external service fails, THE System SHALL return descriptive error messages without exposing internal details
+9. THE System SHALL write logs to backend/app/data/logs directory with rotation
+10. THE System SHALL never expose raw provider exceptions to the frontend
+
+### Requirement 12: Frontend Enhancement
+
+**User Story:** As a user, I want a polished dashboard interface, so that I can interact with the system professionally.
+
+#### Acceptance Criteria
+
+1. THE System SHALL evolve the frontend from a demo page into a product dashboard
+2. THE System SHALL provide a Main Dashboard page
+3. THE System SHALL provide an Analyze tab for analysis tasks
+4. THE System SHALL provide a Cases/History tab for reviewing past executions
+5. THE System SHALL provide a Prompt Lab tab for prompt management
+6. THE System SHALL provide a Simulation tab for scenario modeling
+7. THE System SHALL provide an input task box
+8. THE System SHALL provide a mode selector for Analyze vs Simulation
+9. THE System SHALL provide a case output viewer
+10. THE System SHALL display route/debug badges
+11. THE System SHALL display agent output panels
+12. THE System SHALL display market context panel
+13. THE System SHALL display simulation status panel
+14. THE System SHALL display confidence badges
+15. THE System SHALL use a premium dark UI with card-based structure
+16. THE System SHALL include subtle animations and transitions
+17. THE System SHALL allow users to view case details including case_id and stored metadata
+18. THE System MAY reuse impact_ai UI ideas and data panels, but SHALL consolidate into the miroorg-basic-v2 app shell
+
+### Requirement 13: Configuration and Deployment
+
+**User Story:** As a system administrator, I want clear configuration and setup instructions, so that I can deploy the system reliably.
+
+#### Acceptance Criteria
+
+1. THE System SHALL provide a .env.example file with all required environment variables
+2. THE System SHALL document all environment variables in README.md
+3. THE System SHALL include setup instructions for local development
+4. THE System SHALL include instructions for running backend and frontend separately
+5. THE System SHALL specify Python version requirements (3.10+)
+6. THE System SHALL specify Node.js version requirements for frontend
+7. THE System SHALL include a requirements.txt with all Python dependencies
+8. THE System SHALL include a package.json with all Node.js dependencies
+9. THE System SHALL document API endpoint usage with examples
+10. THE System SHALL document the four-layer architecture in README.md
+11. THE System SHALL document agent roles and responsibilities
+12. THE System SHALL document simulation integration setup
+13. THE System SHALL document domain pack integration approach
+14. THE System SHALL keep the backend runnable locally at every phase
+
+### Requirement 14: Data Persistence and Storage
+
+**User Story:** As a user, I want my data stored locally, so that I can access historical analyses offline.
+
+#### Acceptance Criteria
+
+1. THE System SHALL store cases in backend/app/data/memory directory
+2. THE System SHALL store simulations in backend/app/data/simulations directory
+3. THE System SHALL store logs in backend/app/data/logs directory
+4. THE System SHALL use JSON format for case and simulation storage
+5. THE System SHALL create data directories automatically if they do not exist
+6. THE System SHALL include data directories in .gitignore to prevent committing user data
+7. THE System SHALL support exporting cases as JSON files
+8. WHEN storage operations fail, THE System SHALL log errors and return appropriate HTTP status codes
+9. EACH case SHALL store: case_id, input, route, agent outputs, final answer, timestamps, optional simulation_id
+10. EACH simulation SHALL store: simulation_id, remote payload, local metadata, status, report snapshot
+
+### Requirement 13: Security and Secrets Management
+
+**User Story:** As a security-conscious developer, I want proper secrets management, so that API keys are never exposed.
+
+#### Acceptance Criteria
+
+1. THE System SHALL load all API keys from environment variables
+2. THE System SHALL never commit .env files to version control
+3. THE System SHALL include .env in .gitignore
+4. THE System SHALL provide .env.example with placeholder values
+5. THE System SHALL validate required API keys on startup
+6. WHEN required API keys are missing, THE System SHALL log warnings and disable affected features
+7. THE System SHALL never expose API keys in API responses
+8. THE System SHALL never log API keys in plain text
+9. THE System SHALL use HTTPS for all external API calls
+10. THE System SHALL sanitize error messages to prevent information leakage
+
+### Requirement 14: Testing and Quality Assurance
+
+**User Story:** As a developer, I want the codebase to be testable, so that I can ensure reliability and catch regressions.
+
+#### Acceptance Criteria
+
+1. THE System SHALL maintain modular service layer for unit testing
+2. THE System SHALL use dependency injection for external services
+3. THE System SHALL provide mock implementations for external APIs in tests
+4. THE System SHALL validate all Pydantic schemas with test cases
+5. THE System SHALL test provider fallback behavior
+6. THE System SHALL test agent routing logic
+7. THE System SHALL test case storage and retrieval
+8. THE System SHALL test simulation integration error handling
+9. THE System SHALL maintain code coverage above 70% for critical paths
+10. THE System SHALL run linting and type checking in CI/CD pipeline
+
+### Requirement 15: Performance and Scalability
+
+**User Story:** As a user, I want fast response times, so that I can analyze information efficiently.
+
+#### Acceptance Criteria
+
+1. WHEN processing simple queries, THE System SHALL respond within 5 seconds
+2. WHEN processing complex queries, THE System SHALL respond within 30 seconds
+3. THE System SHALL use connection pooling for external API clients
+4. THE System SHALL implement request timeouts for all external API calls
+5. THE System SHALL cache market quotes for 5 minutes to reduce API calls
+6. THE System SHALL limit concurrent external API requests to prevent rate limiting
+7. THE System SHALL use async/await patterns for I/O-bound operations
+8. THE System SHALL implement pagination for case listing endpoints
+9. WHEN memory usage exceeds 1GB, THE System SHALL log warnings
+10. THE System SHALL support horizontal scaling by making state storage pluggable
+
+### Requirement 16: Implementation Priorities
+
+**User Story:** As a project manager, I want clear implementation priorities, so that the team can deliver value incrementally.
+
+#### Acceptance Criteria
+
+1. THE System SHALL implement in this order: backend consolidation, provider abstraction, impact_ai domain integration, simulation adapter, frontend enhancement, testing and cleanup
+2. THE System SHALL keep the backend runnable locally at every phase
+3. THE System SHALL NOT prioritize enterprise auth, Kubernetes, large-scale distributed infra, full cloud deployment, or advanced multi-user features in this phase
+4. THE System SHALL focus on single-user local deployment with production-quality code structure
+5. THE System SHALL use miroorg-basic-v2 as the base repo for all implementation work
+6. THE System SHALL port valuable impact_ai modules into the service/domain layer
+7. THE System SHALL integrate MiroFish through a clean adapter and router, never direct frontend calls
+8. THE System SHALL add API discovery scaffolding using public-apis as a catalog source
+9. THE System SHALL remove dead duplicates during consolidation
+
+### Requirement 17: Autonomous Knowledge Evolution Layer
+
+**User Story:** As a user, I want the system to improve itself over time by learning from internet knowledge, past cases, and successful patterns, so that it becomes smarter without requiring manual intervention or stressing my laptop.
+
+#### Acceptance Criteria
+
+1. THE System SHALL implement an Autonomous Knowledge Evolution Layer as Layer 5 in the architecture
+2. THE System SHALL NOT train foundation models locally or store large raw datasets
+3. THE System SHALL store only compressed summaries, extracted facts, source metadata, trust scores, and skill records
+4. THE System SHALL respect strict storage limits: max 200MB for knowledge cache, 2-4KB per article summary
+5. THE System SHALL auto-delete stale knowledge after configurable expiration period
+6. THE System SHALL run learning tasks only when system is idle and laptop is not stressed
+7. THE System SHALL stop learning tasks if battery is low or system resources are constrained
+
+#### World Knowledge Ingestion
+
+8. THE System SHALL continuously ingest high-signal information from Tavily, Jina Reader, NewsAPI, Alpha Vantage, and discovered APIs
+9. THE System SHALL compress external information into structured summaries with: title, summary, entities, source_url, source_type, trust_score, freshness_score, domain_pack, timestamps
+10. THE System SHALL NOT save raw webpage archives or full-page content
+11. THE System SHALL extract and store only: summaries, entities, claims, source metadata, freshness indicators, trust scores
+12. THE System SHALL respect API rate limits and avoid excessive external requests
+
+#### Experience Learning
+
+13. THE System SHALL learn from every case execution by tracking: route effectiveness, prompt performance, provider reliability, source usefulness, answer corrections, repeated patterns
+14. THE System SHALL store case learning metadata without duplicating full case records
+15. THE System SHALL identify patterns across multiple cases to inform future routing and agent decisions
+16. THE System SHALL update trust scores for sources based on verification outcomes
+
+#### Prompt Evolution
+
+17. THE System SHALL version all agent prompts with metadata: version, last_tested, win_rate, status (active/experimental/archived)
+18. THE System SHALL test improved prompt variants on sampled tasks
+19. THE System SHALL compare prompt outcomes using quality metrics
+20. THE System SHALL promote better-performing prompts to active status
+21. THE System SHALL archive underperforming prompt versions
+22. THE System SHALL NOT allow uncontrolled autonomous prompt changes without validation
+
+#### Skill Distillation
+
+23. WHEN the system solves similar problems repeatedly, THE System SHALL distill patterns into reusable skills
+24. EACH skill SHALL contain: name, trigger_patterns, recommended_agents, preferred_sources, prompt_overrides
+25. THE System SHALL store skills as structured records in backend/app/data/skills directory
+26. THE System SHALL make distilled skills available to agents for future similar tasks
+27. THE System SHALL support skill types including: financial_rumor_review, policy_reaction_analysis, earnings_impact_brief, simulation_prep_pack
+
+#### Trust and Freshness Management
+
+28. THE System SHALL maintain trust scores for all external sources (APIs, news outlets, websites)
+29. THE System SHALL track freshness scores to identify stale information
+30. THE System SHALL recommend source refresh when freshness degrades
+31. THE System SHALL learn which sources are reliable vs noisy over time
+32. THE System SHALL expire knowledge items based on domain-specific freshness rules
+
+#### Storage and Resource Management
+
+33. THE System SHALL store knowledge in backend/app/data/knowledge directory
+34. THE System SHALL store skills in backend/app/data/skills directory
+35. THE System SHALL store prompt versions in backend/app/data/prompt_versions directory
+36. THE System SHALL store learning metadata in backend/app/data/learning directory
+37. THE System SHALL compress old cases to save space
+38. THE System SHALL enforce hard storage limits and auto-cleanup policies
+39. THE System SHALL use external provider APIs for heavy reasoning, not local computation
+
+#### Learning Scheduler
+
+40. THE System SHALL implement a lightweight scheduler with safeguards: one background job at a time, small batch sizes, stop on errors, respect rate limits
+41. THE System SHALL schedule learning tasks during idle periods
+42. THE System SHALL NOT interfere with user-initiated operations
+43. THE System SHALL provide manual trigger option for immediate learning runs
+
+#### Integration with Existing Layers
+
+44. THE System SHALL integrate learning insights with normal MiroOrg case executions
+45. THE System SHALL integrate learning insights with domain pack intelligence
+46. THE System SHALL learn from MiroFish simulation results and outcomes
+47. THE System SHALL integrate with prompt management system
+48. THE System SHALL integrate with provider abstraction layer
+
+#### API Endpoints
+
+49. THE System SHALL provide GET /learning/status endpoint for learning system status
+50. THE System SHALL provide POST /learning/run-once endpoint for manual learning trigger
+51. THE System SHALL provide GET /learning/insights endpoint for learning statistics
+52. THE System SHALL provide GET /knowledge endpoint for listing knowledge items
+53. THE System SHALL provide GET /knowledge/{item_id} endpoint for knowledge details
+54. THE System SHALL provide GET /knowledge/search endpoint for knowledge search
+55. THE System SHALL provide GET /skills endpoint for listing distilled skills
+56. THE System SHALL provide GET /skills/{skill_name} endpoint for skill details
+57. THE System SHALL provide POST /skills/distill endpoint for manual skill distillation
+58. THE System SHALL provide GET /sources/trust endpoint for source trust scores
+59. THE System SHALL provide GET /sources/freshness endpoint for source freshness scores
+60. THE System SHALL provide GET /prompts/versions/{name} endpoint for prompt version history
+61. THE System SHALL provide POST /prompts/optimize/{name} endpoint for prompt optimization
+62. THE System SHALL provide POST /prompts/promote/{name}/{version} endpoint for promoting prompt versions

.kiro/specs/ai-financial-intelligence-system/tasks.md

@@ -0,0 +1,843 @@
+# Implementation Plan: AI Financial Intelligence System (MiroOrg v1.1)
+
+## Overview
+
+This implementation plan transforms MiroOrg into a general intelligence operating system that orchestrates multiple specialist agents, runs simulations, and supports pluggable domain packs. The system merges capabilities from miroorg-basic-v2 (base architecture), impact_ai (first domain pack), MiroFish (simulation lab), and public-apis (API discovery catalog) into a unified, production-ready platform.
+
+The implementation follows 9 phases, each building on the previous while maintaining a runnable system. The focus is on single-user local deployment with production-quality code structure.
+
+## Tasks
+
+### Phase 1: Backend Consolidation and Provider Enhancement
+
+- [x] 1. Strengthen core platform and provider abstraction
+  - [x] 1.1 Add OpenAI provider support to model abstraction layer
+    - Implement `_call_openai()` function in `backend/app/agents/_model.py`
+    - Add OpenAI API key configuration in `backend/app/config.py`
+    - Add OpenAI to provider fallback chain
+    - _Requirements: 6.2, 6.4_
+  
+  - [x] 1.2 Enhance provider fallback logging and health checks
+    - Add detailed logging for provider selection events in `backend/app/agents/_model.py`
+    - Add logging for fallback attempts and failures
+    - Implement provider health checks in `backend/app/services/health_service.py`
+    - Add provider status to deep health endpoint
+    - _Requirements: 6.5, 6.6, 9.4_
+  
+  - [x] 1.3 Add configuration validation on startup
+    - Implement config validation in `backend/app/config.py`
+    - Add warnings for missing optional API keys
+    - Add errors for missing required configuration
+    - Validate provider configuration completeness
+    - _Requirements: 1.8, 6.7, 13.5, 13.6_
+  
+  - [x] 1.4 Update environment configuration files
+    - Add OpenAI configuration to `backend/.env.example`
+    - Add domain pack feature flags
+    - Add simulation trigger keywords configuration
+    - Document all environment variables
+    - _Requirements: 1.8, 4.6, 13.1, 13.2_
+
+- [x] 2. Checkpoint - Verify provider abstraction
+  - Ensure all three providers (OpenRouter, Ollama, OpenAI) work correctly
+  - Verify fallback behavior with proper logging
+  - Verify health check reports provider status accurately
+  - Ask the user if questions arise
+
+### Phase 2: Domain Pack Architecture
+
+- [x] 3. Create domain pack base infrastructure
+  - [x] 3.1 Implement domain pack base architecture
+    - Create `backend/app/domain_packs/__init__.py`
+    - Create `backend/app/domain_packs/base.py` with DomainPack abstract base class
+    - Define abstract methods: name, keywords, enhance_research, enhance_verification, get_capabilities
+    - _Requirements: 2.3, 2.5, 2.7, 5.6_
+  
+  - [x] 3.2 Implement domain pack registry
+    - Create `backend/app/domain_packs/registry.py` with DomainPackRegistry class
+    - Implement register(), get_pack(), detect_domain(), list_packs(), get_capabilities()
+    - Create global registry instance
+    - _Requirements: 2.5, 5.6_
+  
+  - [x] 3.3 Create finance domain pack structure
+    - Create `backend/app/domain_packs/finance/__init__.py`
+    - Create `backend/app/domain_packs/finance/pack.py` with FinanceDomainPack class
+    - Implement name, keywords properties for finance domain
+    - _Requirements: 5.1, 5.2, 5.7_
+
+- [x] 4. Port impact_ai modules to finance domain pack
+  - [x] 4.1 Port market data and news modules
+    - Create `backend/app/domain_packs/finance/market_data.py` from impact_ai alpha_vantage_client.py
+    - Create `backend/app/domain_packs/finance/news.py` from impact_ai news_api.py
+    - Refactor to match service layer pattern
+    - _Requirements: 5.2, 5.5_
+  
+  - [x] 4.2 Port entity and ticker resolution modules
+    - Create `backend/app/domain_packs/finance/entity_resolver.py`
+    - Create `backend/app/domain_packs/finance/ticker_resolver.py`
+    - Implement entity extraction and normalization
+    - _Requirements: 5.2, 7.2_
+  
+  - [x] 4.3 Port credibility and detection modules
+    - Create `backend/app/domain_packs/finance/source_checker.py`
+    - Create `backend/app/domain_packs/finance/rumor_detector.py`
+    - Create `backend/app/domain_packs/finance/scam_detector.py`
+    - Implement credibility scoring and detection logic
+    - _Requirements: 5.2, 7.8_
+  
+  - [x] 4.4 Port analysis and prediction modules
+    - Create `backend/app/domain_packs/finance/stance_detector.py`
+    - Create `backend/app/domain_packs/finance/event_analyzer.py`
+    - Create `backend/app/domain_packs/finance/prediction.py`
+    - Implement sentiment analysis and prediction logic
+    - _Requirements: 5.2_
+
+- [x] 5. Consolidate external API clients
+  - [x] 5.1 Merge Alpha Vantage and NewsAPI clients
+    - Consolidate Alpha Vantage logic into `backend/app/services/external_sources.py`
+    - Consolidate NewsAPI logic into `backend/app/services/external_sources.py`
+    - Remove duplicate implementations
+    - Add connection pooling and timeouts
+    - _Requirements: 5.4, 9.9, 9.10, 15.3, 15.4_
+  
+  - [x] 5.2 Register finance pack and update configuration
+    - Register FinanceDomainPack in global registry
+    - Add finance pack configuration to `backend/app/config.py`
+    - Add feature flags for domain pack enablement
+    - _Requirements: 5.3, 5.6_
+
+- [x] 6. Checkpoint - Verify domain pack infrastructure
+  - Ensure finance pack is registered successfully
+  - Verify domain detection works for finance keywords
+  - Verify external API clients are consolidated
+  - Ask the user if questions arise
+
+### Phase 3: Agent Enhancement with Domain Intelligence
+
+- [ ] 7. Enhance Switchboard with domain detection
+  - [ ] 7.1 Add domain pack dimension to routing
+    - Modify `backend/app/agents/switchboard.py` to add domain_pack to routing decision
+    - Implement domain detection using domain registry
+    - Update RouteDecision schema in `backend/app/schemas.py`
+    - _Requirements: 4.1, 5.6_
+  
+  - [ ] 7.2 Implement complexity-based routing logic
+    - Ensure simple queries (≤5 words) route to solo mode
+    - Ensure medium queries (≤25 words) route to standard mode
+    - Ensure complex queries (>25 words) route to deep mode
+    - _Requirements: 4.2, 4.3, 4.4_
+  
+  - [ ] 7.3 Implement simulation keyword detection
+    - Add simulation trigger keyword detection
+    - Load keywords from environment configuration
+    - Set task_family="simulation" when keywords detected
+    - _Requirements: 4.5, 4.6, 4.7_
+
+- [ ] 8. Enhance Research Agent with domain capabilities
+  - [ ] 8.1 Integrate domain pack research enhancement
+    - Modify `backend/app/agents/research.py` to detect domain
+    - Call domain pack enhance_research() when domain detected
+    - Add structured entity extraction output
+    - _Requirements: 5.3, 7.1, 7.2, 7.3, 7.4_
+  
+  - [ ] 8.2 Update research agent prompt
+    - Update `backend/app/prompts/research.txt` with domain intelligence instructions
+    - Add instructions for entity and ticker extraction
+    - Add instructions for structured output
+    - _Requirements: 7.14_
+
+- [ ] 9. Enhance Verifier Agent with domain capabilities
+  - [ ] 9.1 Integrate domain pack verification enhancement
+    - Modify `backend/app/agents/verifier.py` to detect domain
+    - Call domain pack enhance_verification() when domain detected
+    - Add structured credibility scoring output
+    - _Requirements: 5.3, 7.7, 7.8, 7.9_
+  
+  - [ ] 9.2 Update verifier agent prompt
+    - Update `backend/app/prompts/verifier.txt` with domain intelligence instructions
+    - Add instructions for rumor and scam detection
+    - Add instructions for uncertainty surfacing
+    - _Requirements: 7.14_
+
+- [ ] 10. Enhance Planner and Synthesizer Agents
+  - [ ] 10.1 Add simulation mode suggestion to Planner
+    - Modify `backend/app/agents/planner.py` to detect simulation opportunities
+    - Add simulation_suggested field to output
+    - Update `backend/app/prompts/planner.txt` with simulation guidance
+    - _Requirements: 7.6, 7.14_
+  
+  - [ ] 10.2 Add uncertainty quantification to Synthesizer
+    - Modify `backend/app/agents/synthesizer.py` to quantify uncertainty
+    - Add simulation recommendation logic
+    - Update `backend/app/prompts/synthesizer.txt` with uncertainty instructions
+    - _Requirements: 7.11, 7.12, 7.13, 7.14_
+
+- [ ] 11. Update graph execution with domain context
+  - [ ] 11.1 Pass domain pack context through pipeline
+    - Modify `backend/app/graph.py` to detect domain early
+    - Pass domain context to all agents
+    - Ensure domain-enhanced execution flows correctly
+    - _Requirements: 2.5, 5.3, 7.15_
+
+- [ ] 12. Checkpoint - Verify agent enhancements
+  - Ensure Switchboard detects finance domain correctly
+  - Verify Research agent extracts entities and tickers
+  - Verify Verifier agent scores credibility
+  - Verify agents suggest simulation mode appropriately
+  - Ask the user if questions arise
+
+### Phase 4: Simulation Integration Enhancement
+
+- [ ] 13. Enhance simulation workflow and case linking
+  - [ ] 13.1 Add case linking to simulation router
+    - Modify `backend/app/routers/simulation.py` to link case_id
+    - Improve error messages for MiroFish failures
+    - Add better status reporting
+    - _Requirements: 8.1, 8.11, 8.12_
+  
+  - [ ] 13.2 Enhance simulation store with search and filtering
+    - Modify `backend/app/services/simulation_store.py`
+    - Add simulation search by title or prediction_goal
+    - Add simulation filtering by status
+    - _Requirements: 8.10_
+  
+  - [ ] 13.3 Update case storage for simulation linking
+    - Modify `backend/app/services/case_store.py` to add simulation_id field
+    - Add case-to-simulation lookup functionality
+    - Update CaseRecord schema in `backend/app/schemas.py`
+    - _Requirements: 10.8, 14.9_
+  
+  - [ ] 13.4 Add simulation workflow to graph execution
+    - Modify `backend/app/graph.py` to add simulation handoff logic
+    - Add simulation result synthesis
+    - Ensure simulation results flow into final answer
+    - _Requirements: 3.4, 8.13_
+
+- [ ] 14. Checkpoint - Verify simulation integration
+  - Ensure simulation requests create linked cases
+  - Verify cases with simulations show simulation_id
+  - Verify simulation results are synthesized correctly
+  - Ask the user if questions arise
+
+### Phase 5: API Discovery Subsystem
+
+- [ ] 15. Create API discovery infrastructure
+  - [ ] 15.1 Create API discovery structure
+    - Create `backend/app/services/api_discovery/__init__.py`
+    - Create `backend/app/services/api_discovery/catalog_loader.py`
+    - Create `backend/app/services/api_discovery/classifier.py`
+    - Create `backend/app/services/api_discovery/scorer.py`
+    - Create `backend/app/services/api_discovery/metadata_store.py`
+    - _Requirements: 9.3, 9.4_
+  
+  - [ ] 15.2 Implement catalog loader
+    - Implement load_public_apis_catalog() to fetch from GitHub or local cache
+    - Parse API entries with name, description, auth, HTTPS, CORS, category, link
+    - _Requirements: 9.3, 9.6_
+  
+  - [ ] 15.3 Implement API classifier and scorer
+    - Implement classify_api() to categorize APIs by domain
+    - Implement score_api_usefulness() to prioritize APIs for integration
+    - Consider auth simplicity, HTTPS, CORS, category relevance
+    - _Requirements: 9.5, 9.6_
+  
+  - [ ]* 15.4 Add optional discovery endpoints
+    - Add `GET /api-discovery/categories` endpoint
+    - Add `GET /api-discovery/search?category=X` endpoint
+    - Add `GET /api-discovery/top-scored` endpoint
+    - _Requirements: 9.4_
+
+- [ ] 16. Checkpoint - Verify API discovery
+  - Ensure catalog loads successfully
+  - Verify APIs are classified correctly
+  - Verify scoring produces reasonable priorities
+  - Ask the user if questions arise
+
+### Phase 6: Frontend Enhancement
+
+- [ ] 17. Create layout and navigation infrastructure
+  - [ ] 17.1 Create layout components
+    - Create `frontend/src/components/layout/Header.tsx` with branding and navigation
+    - Create `frontend/src/components/layout/Navigation.tsx` with tab navigation
+    - Modify `frontend/src/app/layout.tsx` to use new layout components
+    - _Requirements: 12.1, 12.2_
+  
+  - [ ] 17.2 Create common UI components
+    - Create `frontend/src/components/common/Badge.tsx` for status indicators
+    - Create `frontend/src/components/common/Card.tsx` for content containers
+    - Create `frontend/src/components/common/LoadingSpinner.tsx` for loading states
+    - Create `frontend/src/components/common/ErrorMessage.tsx` for error display
+    - _Requirements: 12.10, 12.11, 12.15_
+  
+  - [ ] 17.3 Create API client and type definitions
+    - Create `frontend/src/lib/api.ts` with MiroOrgClient class
+    - Implement methods for all backend endpoints
+    - Create `frontend/src/lib/types.ts` with TypeScript interfaces
+    - _Requirements: 11.21_
+
+- [ ] 18. Create Main Dashboard page
+  - [ ] 18.1 Implement dashboard with system overview
+    - Modify `frontend/src/app/page.tsx` to show quick stats
+    - Display recent cases summary
+    - Display system health status
+    - Add navigation to main features
+    - _Requirements: 12.2_
+
+- [ ] 19. Create Analyze page and components
+  - [ ] 19.1 Create Analyze page structure
+    - Create `frontend/src/app/analyze/page.tsx` with analysis interface
+    - Create `frontend/src/components/analyze/TaskInput.tsx` for user input
+    - Create `frontend/src/components/analyze/ModeSelector.tsx` for mode selection
+    - _Requirements: 12.3, 12.7, 12.8_
+  
+  - [ ] 19.2 Create result display components
+    - Create `frontend/src/components/analyze/ResultViewer.tsx` for final answers
+    - Create `frontend/src/components/analyze/AgentOutputPanel.tsx` for agent outputs
+    - Display route/debug badges and confidence indicators
+    - _Requirements: 12.9, 12.10, 12.11, 12.14_
+
+- [ ] 20. Create Cases page and components
+  - [ ] 20.1 Create Cases history interface
+    - Create `frontend/src/app/cases/page.tsx` with case list
+    - Create `frontend/src/components/cases/CaseList.tsx` for listing cases
+    - Create `frontend/src/components/cases/CaseCard.tsx` for case preview
+    - _Requirements: 12.4, 12.17_
+  
+  - [ ] 20.2 Create Case detail view
+    - Create `frontend/src/app/cases/[id]/page.tsx` for case details
+    - Create `frontend/src/components/cases/CaseDetail.tsx` for full case display
+    - Display case_id, routing decision, agent outputs, timestamps
+    - _Requirements: 12.17_
+
+- [ ] 21. Create Simulation page and components
+  - [ ] 21.1 Create Simulation submission interface
+    - Create `frontend/src/app/simulation/page.tsx` with simulation form
+    - Create `frontend/src/components/simulation/SimulationForm.tsx` for input
+    - Create `frontend/src/components/simulation/SimulationStatus.tsx` for status display
+    - _Requirements: 12.6, 12.13_
+  
+  - [ ] 21.2 Create Simulation detail and chat interface
+    - Create `frontend/src/app/simulation/[id]/page.tsx` for simulation details
+    - Create `frontend/src/components/simulation/SimulationReport.tsx` for report display
+    - Create `frontend/src/components/simulation/SimulationChat.tsx` for post-simulation chat
+    - _Requirements: 12.13_
+
+- [ ] 22. Create Prompt Lab and Config pages
+  - [ ] 22.1 Create Prompt Lab interface
+    - Create `frontend/src/app/prompts/page.tsx` with prompt management
+    - Create `frontend/src/components/prompts/PromptList.tsx` for listing prompts
+    - Create `frontend/src/components/prompts/PromptEditor.tsx` for editing
+    - _Requirements: 12.5_
+  
+  - [ ] 22.2 Create Config page
+    - Create `frontend/src/app/config/page.tsx` with system configuration view
+    - Display provider status, feature flags, health checks
+    - _Requirements: 12.1_
+
+- [ ] 23. Implement dark theme and styling
+  - [ ] 23.1 Update global styles with dark theme
+    - Modify `frontend/src/app/globals.css` with dark color palette
+    - Implement card-based structure with subtle borders
+    - Add animations and transitions
+    - Use Inter font family
+    - _Requirements: 12.15, 12.16_
+
+- [ ] 24. Checkpoint - Verify frontend functionality
+  - Ensure all pages are accessible via navigation
+  - Verify Analyze workflow works end-to-end
+  - Verify Case history displays correctly
+  - Verify Simulation workflow works end-to-end
+  - Verify Prompt lab allows editing
+  - Verify Config page shows system status
+  - Ask the user if questions arise
+
+### Phase 7: Testing and Documentation
+
+- [ ] 25. Write unit tests for core functionality
+  - [ ]* 25.1 Write provider abstraction tests
+    - Test OpenRouter, Ollama, OpenAI provider calls
+    - Test provider fallback behavior
+    - Test provider error handling
+    - _Requirements: 6.5, 6.6_
+  
+  - [ ]* 25.2 Write domain pack tests
+    - Test domain pack registration
+    - Test domain detection
+    - Test finance pack capabilities
+    - Test entity and ticker extraction
+    - _Requirements: 5.6, 7.2_
+  
+  - [ ]* 25.3 Write agent routing tests
+    - Test Switchboard classification logic
+    - Test complexity-to-execution-mode mapping
+    - Test simulation keyword detection
+    - Test domain detection
+    - _Requirements: 4.1, 4.2, 4.3, 4.4, 4.5_
+  
+  - [ ]* 25.4 Write storage tests
+    - Test case save and retrieve
+    - Test simulation save and retrieve
+    - Test directory auto-creation
+    - Test memory statistics
+    - _Requirements: 10.1, 10.3, 10.12_
+  
+  - [ ]* 25.5 Write simulation integration tests
+    - Test MiroFish client adapter
+    - Test simulation workflow
+    - Test case-simulation linking
+    - Test error handling for disabled MiroFish
+    - _Requirements: 8.1, 8.11, 8.12_
+
+- [ ] 26. Write property-based tests
+  - [ ]* 26.1 Write Property 1: Configuration Environment Isolation
+    - **Property 1: Configuration Environment Isolation**
+    - **Validates: Requirements 1.8, 6.7**
+    - Test that all configuration values come from environment variables
+    - Generate random config keys and verify no hardcoded values
+  
+  - [ ]* 26.2 Write Property 2: Switchboard Four-Dimensional Classification
+    - **Property 2: Switchboard Four-Dimensional Classification**
+    - **Validates: Requirements 4.1**
+    - Test that routing decisions contain all four dimensions
+    - Generate random user inputs and verify structure
+  
+  - [ ]* 26.3 Write Property 3: Complexity-to-Execution-Mode Mapping
+    - **Property 3: Complexity-to-Execution-Mode Mapping**
+    - **Validates: Requirements 4.2, 4.3, 4.4**
+    - Test that complexity maps correctly to execution mode
+    - Generate inputs of varying lengths and verify mapping
+  
+  - [ ]* 26.4 Write Property 4: Simulation Keyword Triggering
+    - **Property 4: Simulation Keyword Triggering**
+    - **Validates: Requirements 4.5, 4.6**
+    - Test that simulation keywords trigger correct classification
+    - Generate inputs with/without keywords and verify task_family
+  
+  - [ ]* 26.5 Write Property 5: Provider Fallback Behavior
+    - **Property 5: Provider Fallback Behavior**
+    - **Validates: Requirements 6.5**
+    - Test that provider fallback works correctly
+    - Mock primary provider failures and verify fallback
+  
+  - [ ]* 26.6 Write Property 6: Case Persistence Round Trip
+    - **Property 6: Case Persistence Round Trip**
+    - **Validates: Requirements 10.1, 10.3**
+    - Test that saved cases can be retrieved correctly
+    - Generate random case data and verify round trip
+  
+  - [ ]* 26.7 Write Property 7: Case Record Structure Completeness
+    - **Property 7: Case Record Structure Completeness**
+    - **Validates: Requirements 10.2, 10.7, 10.8**
+    - Test that case records contain all required fields
+    - Generate random cases and verify structure
+  
+  - [ ]* 26.8 Write Property 8: Data Directory Organization
+    - **Property 8: Data Directory Organization**
+    - **Validates: Requirements 10.9, 10.10, 10.11**
+    - Test that data is stored in correct directories
+    - Generate random data and verify file locations
+  
+  - [ ]* 26.9 Write Property 9: Directory Auto-Creation
+    - **Property 9: Directory Auto-Creation**
+    - **Validates: Requirements 10.12**
+    - Test that missing directories are created automatically
+    - Remove directories and verify auto-creation
+  
+  - [ ]* 26.10 Write Property 10: MiroFish Adapter Isolation
+    - **Property 10: MiroFish Adapter Isolation**
+    - **Validates: Requirements 1.3, 3.4**
+    - Test that all MiroFish calls go through adapter
+    - Scan codebase for direct MiroFish URLs
+  
+  - [ ]* 26.11 Write Property 11: Comprehensive Logging
+    - **Property 11: Comprehensive Logging**
+    - **Validates: Requirements 6.6, 9.4, 9.6, 9.7**
+    - Test that all operations create log entries
+    - Generate random operations and verify logging
+  
+  - [ ]* 26.12 Write Property 12: Schema Validation
+    - **Property 12: Schema Validation**
+    - **Validates: Requirements 9.1, 9.2**
+    - Test that invalid requests return 422 errors
+    - Generate invalid request bodies and verify errors
+  
+  - [ ]* 26.13 Write Property 13: External API Client Patterns
+    - **Property 13: External API Client Patterns**
+    - **Validates: Requirements 9.1, 9.9, 9.10**
+    - Test that external API clients use consistent patterns
+    - Verify connection pooling, timeouts, error handling
+  
+  - [ ]* 26.14 Write Property 14: Error Response Sanitization
+    - **Property 14: Error Response Sanitization**
+    - **Validates: Requirements 9.3, 9.8, 9.10**
+    - Test that error responses don't leak internals
+    - Generate various errors and verify sanitization
+  
+  - [ ]* 26.15 Write Property 15: Domain Pack Extensibility
+    - **Property 15: Domain Pack Extensibility**
+    - **Validates: Requirements 2.5, 2.7**
+    - Test that new domain packs don't require agent changes
+    - Create mock domain pack and verify integration
+
+- [ ] 27. Write integration tests
+  - [ ]* 27.1 Write end-to-end case execution test
+    - Test complete workflow from user input to final answer
+    - Verify all agents execute correctly
+    - Verify case is saved with correct structure
+    - _Requirements: 3.2_
+  
+  - [ ]* 27.2 Write simulation workflow test
+    - Test complete simulation workflow
+    - Verify submission, status, report, chat
+    - Verify case-simulation linking
+    - _Requirements: 3.3, 8.1_
+  
+  - [ ]* 27.3 Write provider fallback integration test
+    - Test fallback in real execution context
+    - Verify system continues working with fallback provider
+    - _Requirements: 6.5_
+  
+  - [ ]* 27.4 Write domain pack enhancement test
+    - Test domain-enhanced research and verification
+    - Verify finance pack capabilities are used
+    - _Requirements: 5.3, 7.1, 7.7_
+
+- [ ] 28. Create comprehensive documentation
+  - [ ] 28.1 Update main README
+    - Update `README.md` with architecture overview
+    - Document four-layer architecture
+    - Document agent roles and responsibilities
+    - Add setup instructions for local development
+    - Add environment variable reference
+    - _Requirements: 13.2, 13.3, 13.4, 13.10, 13.11, 13.12_
+  
+  - [ ] 28.2 Create architecture documentation
+    - Create `ARCHITECTURE.md` with detailed architecture description
+    - Document component interactions
+    - Document data flow
+    - _Requirements: 13.10_
+  
+  - [ ] 28.3 Create domain pack documentation
+    - Create `DOMAIN_PACKS.md` with domain pack integration guide
+    - Document how to create new domain packs
+    - Document finance pack capabilities
+    - _Requirements: 13.13_
+  
+  - [ ] 28.4 Create testing documentation
+    - Create `TESTING.md` with testing strategy and guidelines
+    - Document unit test patterns
+    - Document property-based test patterns
+    - Document integration test patterns
+    - _Requirements: 14.1, 14.2, 14.3_
+  
+  - [ ] 28.5 Create deployment documentation
+    - Create `DEPLOYMENT.md` with deployment instructions
+    - Document environment setup
+    - Document dependency installation
+    - Document running backend and frontend
+    - _Requirements: 13.4, 13.5, 13.6, 13.7, 13.8_
+
+- [ ] 29. Checkpoint - Verify testing and documentation
+  - Ensure all tests pass
+  - Verify coverage meets goals (70%+ overall)
+  - Verify documentation is complete and accurate
+  - Verify setup instructions work for new developers
+  - Ask the user if questions arise
+
+### Phase 8: Cleanup and Optimization
+
+- [ ] 30. Remove dead code and optimize performance
+  - [ ] 30.1 Clean up codebase
+    - Remove unused imports across all files
+    - Remove commented code
+    - Remove duplicate implementations
+    - _Requirements: 1.5_
+  
+  - [ ] 30.2 Optimize external API performance
+    - Add caching for market quotes with 5 minute TTL
+    - Verify connection pooling is implemented
+    - Verify request timeouts are configured
+    - Add rate limiting for external APIs
+    - _Requirements: 15.3, 15.4, 15.5, 15.6_
+  
+  - [ ] 30.3 Polish error messages and logging
+    - Review all error messages for clarity and consistency
+    - Review log levels for appropriateness
+    - Add missing log entries for key operations
+    - _Requirements: 9.3, 9.8_
+  
+  - [ ] 30.4 Security review
+    - Verify no API keys in source code
+    - Verify error messages don't leak internals
+    - Verify input validation is comprehensive
+    - Verify all external API calls use HTTPS
+    - _Requirements: 13.1, 13.2, 13.3, 13.7, 13.8, 13.9_
+  
+  - [ ]* 30.5 Performance testing
+    - Test response times for simple queries (target: <5s)
+    - Test response times for complex queries (target: <30s)
+    - Identify and address bottlenecks
+    - _Requirements: 15.1, 15.2_
+
+- [ ] 31. Final checkpoint - System verification
+  - Ensure no dead code remains
+  - Verify performance meets requirements
+  - Verify error messages are clear and consistent
+  - Verify logging is comprehensive
+  - Verify security review passes
+  - Ask the user if questions arise
+
+### Phase 9: Autonomous Knowledge Evolution Layer
+
+- [ ] 32. Create learning subsystem infrastructure
+  - [ ] 32.1 Create learning service structure
+    - Create `backend/app/services/learning/__init__.py`
+    - Create `backend/app/services/learning/knowledge_ingestor.py`
+    - Create `backend/app/services/learning/knowledge_store.py`
+    - Create `backend/app/services/learning/learning_engine.py`
+    - _Requirements: 17.1, 17.2, 17.3_
+  
+  - [ ] 32.2 Create additional learning services
+    - Create `backend/app/services/learning/prompt_optimizer.py`
+    - Create `backend/app/services/learning/skill_distiller.py`
+    - Create `backend/app/services/learning/trust_manager.py`
+    - Create `backend/app/services/learning/freshness_manager.py`
+    - Create `backend/app/services/learning/scheduler.py`
+    - _Requirements: 17.1, 17.17, 17.23, 17.28, 17.40_
+  
+  - [ ] 32.3 Create data directories
+    - Create `backend/app/data/knowledge/` directory
+    - Create `backend/app/data/skills/` directory
+    - Create `backend/app/data/prompt_versions/` directory
+    - Create `backend/app/data/learning/` directory
+    - _Requirements: 17.33, 17.34, 17.35, 17.36_
+
+- [ ] 33. Implement knowledge ingestion and storage
+  - [ ] 33.1 Implement knowledge ingestion
+    - Implement ingest_from_search() using Tavily API
+    - Implement ingest_from_url() using Jina Reader
+    - Implement ingest_from_news() using NewsAPI
+    - Implement compress_content() for summarization (2-4KB limit)
+    - _Requirements: 17.8, 17.9, 17.10, 17.11_
+  
+  - [ ] 33.2 Implement knowledge store
+    - Implement save_knowledge() with JSON storage
+    - Implement get_knowledge() and search_knowledge()
+    - Implement delete_expired_knowledge() with auto-cleanup
+    - Implement storage limit enforcement (200MB max)
+    - Implement LRU eviction when limit reached
+    - _Requirements: 17.4, 17.5, 17.33, 17.38_
+  
+  - [ ] 33.3 Add knowledge schemas
+    - Add KnowledgeItem schema to `backend/app/schemas.py`
+    - Add validation for summary length (2-4KB)
+    - Add trust_score and freshness_score fields
+    - _Requirements: 17.9_
+
+- [ ] 34. Implement experience learning
+  - [ ] 34.1 Implement case learning
+    - Implement learn_from_case() to extract metadata
+    - Implement detect_patterns() for repeated patterns
+    - Implement get_route_effectiveness() for routing insights
+    - Implement get_prompt_performance() for prompt insights
+    - _Requirements: 17.13, 17.14, 17.15, 17.16_
+  
+  - [ ] 34.2 Add case learning schemas
+    - Add CaseLearning schema to `backend/app/schemas.py`
+    - Add fields for route_effectiveness, prompt_performance, provider_reliability
+    - _Requirements: 17.13_
+  
+  - [ ] 34.3 Hook learning into case save flow
+    - Modify `backend/app/services/case_store.py` to call learn_from_case()
+    - Store case learning metadata separately
+    - _Requirements: 17.44_
+
+- [ ] 35. Implement prompt evolution
+  - [ ] 35.1 Implement prompt versioning
+    - Implement create_prompt_variant() using provider API
+    - Implement test_prompt_variant() with quality metrics
+    - Implement compare_prompts() for A/B testing
+    - Implement promote_prompt() with validation
+    - Implement archive_prompt() for old versions
+    - _Requirements: 17.17, 17.18, 17.19, 17.20, 17.21, 17.22_
+  
+  - [ ] 35.2 Add prompt version schemas
+    - Add PromptVersion schema to `backend/app/schemas.py`
+    - Add fields for version, status, win_rate, test_count
+    - _Requirements: 17.17_
+  
+  - [ ] 35.3 Integrate with prompt management
+    - Hook prompt versions into prompt loading
+    - Store prompt history in prompt_versions directory
+    - _Requirements: 17.47_
+
+- [ ] 36. Implement skill distillation
+  - [ ] 36.1 Implement skill detection and creation
+    - Implement detect_skill_candidates() from patterns
+    - Implement distill_skill() to create skill records
+    - Implement test_skill() for validation
+    - Implement apply_skill() for skill usage
+    - _Requirements: 17.23, 17.24, 17.25, 17.26, 17.27_
+  
+  - [ ] 36.2 Add skill schemas
+    - Add Skill schema to `backend/app/schemas.py`
+    - Add fields for trigger_patterns, recommended_agents, preferred_sources
+    - _Requirements: 17.24_
+  
+  - [ ] 36.3 Integrate skills with agents
+    - Hook skill application into agent execution
+    - Store skills in skills directory
+    - _Requirements: 17.45_
+
+- [ ] 37. Implement trust and freshness management
+  - [ ] 37.1 Implement trust management
+    - Implement get_trust_score() and update_trust()
+    - Implement list_trusted_sources() and list_untrusted_sources()
+    - Track verification outcomes
+    - _Requirements: 17.28, 17.29, 17.30, 17.31, 17.32_
+  
+  - [ ] 37.2 Implement freshness management
+    - Implement calculate_freshness() with domain-specific rules
+    - Implement update_freshness() and get_stale_items()
+    - Implement recommend_refresh() for stale items
+    - _Requirements: 17.28, 17.29, 17.30, 17.31_
+  
+  - [ ] 37.3 Add trust and freshness schemas
+    - Add SourceTrust schema to `backend/app/schemas.py`
+    - Add FreshnessScore schema to `backend/app/schemas.py`
+    - _Requirements: 17.28_
+  
+  - [ ] 37.4 Integrate with source selection
+    - Hook trust scores into research agent source selection
+    - Hook freshness scores into knowledge retrieval
+    - _Requirements: 17.46_
+
+- [ ] 38. Implement learning scheduler
+  - [ ] 38.1 Implement scheduler with safeguards
+    - Implement schedule_task() with interval configuration
+    - Implement is_system_idle() to check CPU usage
+    - Implement is_battery_ok() to check battery level
+    - Implement run_once() for manual triggers
+    - _Requirements: 17.40, 17.41, 17.42, 17.43_
+  
+  - [ ] 38.2 Add scheduled tasks
+    - Schedule knowledge ingestion (every 6 hours)
+    - Schedule expired knowledge cleanup (daily)
+    - Schedule pattern detection (daily)
+    - Schedule skill distillation (weekly)
+    - Schedule prompt optimization (weekly)
+    - _Requirements: 17.6, 17.7, 17.40_
+  
+  - [ ] 38.3 Add scheduler configuration
+    - Add LEARNING_ENABLED flag to config
+    - Add KNOWLEDGE_MAX_SIZE_MB (default 200)
+    - Add LEARNING_SCHEDULE_INTERVAL
+    - Add LEARNING_BATCH_SIZE
+    - Add domain-specific expiration rules
+    - _Requirements: 17.4, 17.5, 17.6, 17.7, 17.12_
+
+- [ ] 39. Add learning API endpoints
+  - [ ] 39.1 Add learning status endpoints
+    - Add GET /learning/status endpoint
+    - Add POST /learning/run-once endpoint
+    - Add GET /learning/insights endpoint
+    - _Requirements: 17.49, 17.50, 17.51_
+  
+  - [ ] 39.2 Add knowledge endpoints
+    - Add GET /knowledge endpoint for listing
+    - Add GET /knowledge/{item_id} endpoint for details
+    - Add GET /knowledge/search endpoint with query parameter
+    - _Requirements: 17.52, 17.53, 17.54_
+  
+  - [ ] 39.3 Add skill endpoints
+    - Add GET /skills endpoint for listing
+    - Add GET /skills/{skill_name} endpoint for details
+    - Add POST /skills/distill endpoint for manual distillation
+    - _Requirements: 17.55, 17.56, 17.57_
+  
+  - [ ] 39.4 Add trust and freshness endpoints
+    - Add GET /sources/trust endpoint
+    - Add GET /sources/freshness endpoint
+    - _Requirements: 17.58, 17.59_
+  
+  - [ ] 39.5 Add prompt evolution endpoints
+    - Add GET /prompts/versions/{name} endpoint
+    - Add POST /prompts/optimize/{name} endpoint
+    - Add POST /prompts/promote/{name}/{version} endpoint
+    - _Requirements: 17.60, 17.61, 17.62_
+
+- [ ] 40. Integrate learning layer with existing system
+  - [ ] 40.1 Integrate with case execution
+    - Hook learn_from_case() into case save flow
+    - Store case learning metadata
+    - _Requirements: 17.44_
+  
+  - [ ] 40.2 Integrate with research agent
+    - Hook knowledge search into research agent
+    - Use trust scores for source selection
+    - _Requirements: 17.45, 17.46_
+  
+  - [ ] 40.3 Integrate with simulation
+    - Learn from simulation outcomes
+    - Store simulation insights
+    - _Requirements: 17.46_
+  
+  - [ ] 40.4 Integrate with prompt management
+    - Hook prompt versions into prompt loading
+    - Track prompt performance
+    - _Requirements: 17.47_
+
+- [ ] 41. Test and verify learning layer
+  - [ ]* 41.1 Test knowledge ingestion
+    - Test ingest_from_search() with Tavily
+    - Test ingest_from_url() with Jina Reader
+    - Test compress_content() produces 2-4KB summaries
+    - Test storage limit enforcement (200MB)
+    - _Requirements: 17.4, 17.8, 17.9, 17.10_
+  
+  - [ ]* 41.2 Test experience learning
+    - Test learn_from_case() extracts metadata
+    - Test detect_patterns() finds repeated patterns
+    - Test trust score updates
+    - _Requirements: 17.13, 17.14, 17.15, 17.16_
+  
+  - [ ]* 41.3 Test prompt evolution
+    - Test create_prompt_variant() generates improvements
+    - Test test_prompt_variant() measures quality
+    - Test promote_prompt() validates before promotion
+    - _Requirements: 17.17, 17.18, 17.19, 17.20_
+  
+  - [ ]* 41.4 Test skill distillation
+    - Test detect_skill_candidates() finds patterns
+    - Test distill_skill() creates valid skills
+    - Test apply_skill() improves execution
+    - _Requirements: 17.23, 17.24, 17.25, 17.26_
+  
+  - [ ]* 41.5 Test scheduler safeguards
+    - Test is_system_idle() respects CPU limits
+    - Test is_battery_ok() respects battery level
+    - Test scheduler stops on errors
+    - Test scheduler respects rate limits
+    - _Requirements: 17.6, 17.7, 17.40, 17.41, 17.42_
+
+- [ ] 42. Final checkpoint - Learning layer verification
+  - Ensure learning subsystem runs without stressing laptop
+  - Verify knowledge cache stays under 200MB
+  - Verify scheduler respects battery and CPU constraints
+  - Verify trust scores improve source selection
+  - Verify prompt evolution produces better prompts
+  - Verify skills are distilled from repeated patterns
+  - Verify learning endpoints return useful insights
+  - Verify system improves over time
+  - Ask the user if questions arise
+
+## Notes
+
+- Tasks marked with `*` are optional and can be skipped for faster MVP delivery
+- Each task references specific requirements for traceability
+- Checkpoints ensure incremental validation and user feedback
+- Property tests validate universal correctness properties with 100+ iterations
+- Unit tests validate specific examples and edge cases
+- The system remains runnable after each phase
+- Focus is on single-user local deployment with production-quality code structure
+- No enterprise features (auth, Kubernetes, cloud deployment) in this phase

backend/.env.example

@@ -1,11 +1,19 @@
+# ========================================
+# MiroOrg v1.1 - AI Financial Intelligence System
+# Environment Configuration
+# ========================================
+
+# ---------- Application Version ----------
 APP_VERSION=0.3.0
 
 # ---------- Primary model routing ----------
+# PRIMARY_PROVIDER: The main LLM provider to use (openrouter, ollama, or openai)
+# FALLBACK_PROVIDER: The backup provider if primary fails (openrouter, ollama, or openai)
 PRIMARY_PROVIDER=openrouter
 FALLBACK_PROVIDER=ollama
 
 # ---------- OpenRouter ----------
-OPENROUTER_API_KEY=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
+OPENROUTER_API_KEY=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
 OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
 OPENROUTER_CHAT_MODEL=openrouter/free
 OPENROUTER_REASONER_MODEL=openrouter/free
@@ -13,18 +21,34 @@ OPENROUTER_SITE_URL=http://localhost:3000
 OPENROUTER_APP_NAME=MiroOrg Basic
 
 # ---------- Ollama ----------
+# Ollama provides local LLM inference
+# Install from: https://ollama.ai
 OLLAMA_ENABLED=true
 OLLAMA_BASE_URL=http://127.0.0.1:11434/api
 OLLAMA_CHAT_MODEL=qwen2.5:3b-instruct
 OLLAMA_REASONER_MODEL=qwen2.5:3b-instruct
 
+# ---------- OpenAI ----------
+# OpenAI provides GPT models
+# Get your API key from: https://platform.openai.com/api-keys
+OPENAI_API_KEY=
+OPENAI_BASE_URL=https://api.openai.com/v1
+OPENAI_CHAT_MODEL=gpt-4o-mini
+OPENAI_REASONER_MODEL=gpt-4o
+
 # ---------- External research APIs ----------
+# Tavily: AI-powered web search API - https://tavily.com
+# NewsAPI: News aggregation API - https://newsapi.org
+# Alpha Vantage: Financial data API - https://www.alphavantage.co
+# Jina Reader: Web content extraction - https://jina.ai
 TAVILY_API_KEY=
 NEWSAPI_KEY=
 ALPHAVANTAGE_API_KEY=
 JINA_READER_BASE=https://r.jina.ai/http://
 
 # ---------- MiroFish ----------
+# MiroFish is the simulation service for scenario modeling
+# Repository: https://github.com/yourusername/mirofish (update with actual URL)
 MIROFISH_ENABLED=true
 MIROFISH_API_BASE=http://127.0.0.1:5001
 MIROFISH_TIMEOUT_SECONDS=120
@@ -35,4 +59,10 @@ MIROFISH_REPORT_PATH=/simulation/{id}/report
 MIROFISH_CHAT_PATH=/simulation/{id}/chat
 
 # ---------- Routing ----------
-SIMULATION_TRIGGER_KEYWORDS=simulate,predict,what if,reaction,scenario,public opinion,policy impact,market impact,digital twin
+# Comma-separated list of keywords that trigger simulation mode
+# Examples: simulate, predict, what if, reaction, scenario, public opinion, policy impact, market impact, digital twin
+SIMULATION_TRIGGER_KEYWORDS=simulate,predict,what if,reaction,scenario,public opinion,policy impact,market impact,digital twin
+
+# ---------- Domain Packs ----------
+# Enable/disable domain packs (future feature)
+FINANCE_DOMAIN_PACK_ENABLED=true

backend/app/agents/_model.py

@@ -1,4 +1,5 @@
 from typing import Optional, List, Dict, Any
+import logging
 
 import httpx
 
@@ -15,8 +16,14 @@ from app.config import (
     OLLAMA_BASE_URL,
     OLLAMA_CHAT_MODEL,
     OLLAMA_REASONER_MODEL,
+    OPENAI_API_KEY,
+    OPENAI_BASE_URL,
+    OPENAI_CHAT_MODEL,
+    OPENAI_REASONER_MODEL,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class LLMProviderError(Exception):
     pass
@@ -30,6 +37,10 @@ def _pick_ollama_model(mode: str) -> str:
     return OLLAMA_REASONER_MODEL if mode == "reasoner" else OLLAMA_CHAT_MODEL
 
 
+def _pick_openai_model(mode: str) -> str:
+    return OPENAI_REASONER_MODEL if mode == "reasoner" else OPENAI_CHAT_MODEL
+
+
 def _build_messages(prompt: str, system_prompt: Optional[str] = None) -> List[Dict[str, str]]:
     messages: List[Dict[str, str]] = []
     if system_prompt:
@@ -87,6 +98,30 @@ def _call_ollama(prompt: str, mode: str = "chat", system_prompt: Optional[str] =
     return str(message.get("content", "")).strip()
 
 
+def _call_openai(prompt: str, mode: str = "chat", system_prompt: Optional[str] = None) -> str:
+    if not OPENAI_API_KEY:
+        raise LLMProviderError("OPENAI_API_KEY is missing.")
+
+    headers = {
+        "Authorization": f"Bearer {OPENAI_API_KEY}",
+        "Content-Type": "application/json",
+    }
+
+    payload = {
+        "model": _pick_openai_model(mode),
+        "messages": _build_messages(prompt, system_prompt=system_prompt),
+    }
+
+    with httpx.Client(timeout=90) as client:
+        response = client.post(f"{OPENAI_BASE_URL}/chat/completions", headers=headers, json=payload)
+
+    if response.status_code >= 400:
+        raise LLMProviderError(f"OpenAI error {response.status_code}: {response.text}")
+
+    data = response.json()
+    return data["choices"][0]["message"]["content"].strip()
+
+
 def call_model(
     prompt: str,
     mode: str = "chat",
@@ -94,26 +129,48 @@ def call_model(
     provider_override: Optional[str] = None,
 ) -> str:
     provider = (provider_override or PRIMARY_PROVIDER).lower()
+    logger.info(f"Calling model with provider={provider}, mode={mode}")
 
     try:
         if provider == "openrouter":
-            return _call_openrouter(prompt, mode=mode, system_prompt=system_prompt)
+            result = _call_openrouter(prompt, mode=mode, system_prompt=system_prompt)
+            logger.info(f"Provider {provider} succeeded")
+            return result
         if provider == "ollama":
-            return _call_ollama(prompt, mode=mode, system_prompt=system_prompt)
+            result = _call_ollama(prompt, mode=mode, system_prompt=system_prompt)
+            logger.info(f"Provider {provider} succeeded")
+            return result
+        if provider == "openai":
+            result = _call_openai(prompt, mode=mode, system_prompt=system_prompt)
+            logger.info(f"Provider {provider} succeeded")
+            return result
         raise LLMProviderError(f"Unsupported provider: {provider}")
     except Exception as primary_error:
+        logger.warning(f"Primary provider {provider} failed: {primary_error}")
         fallback = FALLBACK_PROVIDER.lower()
         if fallback == provider:
+            logger.error(f"No fallback available, primary provider {provider} failed")
             raise LLMProviderError(str(primary_error))
 
+        logger.info(f"Attempting fallback to provider={fallback}")
         try:
             if fallback == "ollama":
-                return _call_ollama(prompt, mode=mode, system_prompt=system_prompt)
+                result = _call_ollama(prompt, mode=mode, system_prompt=system_prompt)
+                logger.info(f"Fallback provider {fallback} succeeded")
+                return result
             if fallback == "openrouter":
-                return _call_openrouter(prompt, mode=mode, system_prompt=system_prompt)
+                result = _call_openrouter(prompt, mode=mode, system_prompt=system_prompt)
+                logger.info(f"Fallback provider {fallback} succeeded")
+                return result
+            if fallback == "openai":
+                result = _call_openai(prompt, mode=mode, system_prompt=system_prompt)
+                logger.info(f"Fallback provider {fallback} succeeded")
+                return result
         except Exception as fallback_error:
+            logger.error(f"Fallback provider {fallback} also failed: {fallback_error}")
             raise LLMProviderError(
                 f"Primary provider failed: {primary_error} | Fallback failed: {fallback_error}"
             )
 
+        logger.error(f"Primary provider {provider} failed with no valid fallback")
         raise LLMProviderError(str(primary_error))

backend/app/agents/switchboard.py

@@ -1,28 +1,58 @@
 from app.config import SIMULATION_TRIGGER_KEYWORDS
+from app.domain_packs.registry import get_registry
 
 
 def decide_route(user_input: str) -> dict:
+    """
+    Classify task and determine execution path.
+    
+    Classification dimensions:
+    1. task_family: "normal" or "simulation"
+    2. domain_pack: "finance", "general", "policy", "custom"
+    3. complexity: "simple" (≤5 words), "medium" (≤25 words), "complex" (>25 words)
+    4. execution_mode: "solo", "standard", "deep"
+    
+    Args:
+        user_input: The user's query
+        
+    Returns:
+        Dictionary with routing decision including all four dimensions
+    """
     text = user_input.strip()
     lower = text.lower()
     words = len(text.split())
 
+    # Dimension 1: Task family (simulation detection)
     task_family = "simulation" if any(k in lower for k in SIMULATION_TRIGGER_KEYWORDS) else "normal"
 
+    # Dimension 2: Domain pack detection
+    registry = get_registry()
+    detected_domain = registry.detect_domain(user_input)
+    domain_pack = detected_domain if detected_domain else "general"
+
+    # Dimension 3: Complexity based on word count
     if task_family == "simulation":
-        execution_mode = "deep"
         complexity = "complex"
     elif words <= 5:
-        execution_mode = "solo"
         complexity = "simple"
     elif words <= 25:
-        execution_mode = "standard"
         complexity = "medium"
     else:
-        execution_mode = "deep"
         complexity = "complex"
 
+    # Dimension 4: Execution mode based on complexity
+    if task_family == "simulation":
+        execution_mode = "deep"
+    elif complexity == "simple":
+        execution_mode = "solo"
+    elif complexity == "medium":
+        execution_mode = "standard"
+    else:
+        execution_mode = "deep"
+
     return {
         "task_family": task_family,
+        "domain_pack": domain_pack,
         "complexity": complexity,
         "execution_mode": execution_mode,
         "risk_level": "medium" if execution_mode == "deep" else "low",

backend/app/config.py

@@ -32,6 +32,11 @@ OLLAMA_BASE_URL = os.getenv("OLLAMA_BASE_URL", "http://127.0.0.1:11434/api")
 OLLAMA_CHAT_MODEL = os.getenv("OLLAMA_CHAT_MODEL", "qwen2.5:3b-instruct")
 OLLAMA_REASONER_MODEL = os.getenv("OLLAMA_REASONER_MODEL", "qwen2.5:3b-instruct")
 
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+OPENAI_CHAT_MODEL = os.getenv("OPENAI_CHAT_MODEL", "gpt-4o-mini")
+OPENAI_REASONER_MODEL = os.getenv("OPENAI_REASONER_MODEL", "gpt-4o")
+
 TAVILY_API_KEY = os.getenv("TAVILY_API_KEY", "")
 NEWSAPI_KEY = os.getenv("NEWSAPI_KEY", "")
 ALPHAVANTAGE_API_KEY = os.getenv("ALPHAVANTAGE_API_KEY", "")
@@ -54,3 +59,87 @@ SIMULATION_TRIGGER_KEYWORDS = [
     ).split(",")
     if item.strip()
 ]
+
+# Domain pack configuration
+FINANCE_DOMAIN_PACK_ENABLED = os.getenv("FINANCE_DOMAIN_PACK_ENABLED", "true").lower() == "true"
+
+
+# Configuration validation
+import logging
+import sys
+
+logger = logging.getLogger(__name__)
+
+
+def validate_config():
+    """Validate configuration on startup and log warnings/errors."""
+    errors = []
+    warnings = []
+    
+    # Validate primary provider configuration
+    primary = PRIMARY_PROVIDER.lower()
+    if primary not in ["openrouter", "ollama", "openai"]:
+        errors.append(f"PRIMARY_PROVIDER '{PRIMARY_PROVIDER}' is not supported. Must be one of: openrouter, ollama, openai")
+    
+    if primary == "openrouter" and not OPENROUTER_API_KEY:
+        errors.append("PRIMARY_PROVIDER is 'openrouter' but OPENROUTER_API_KEY is missing")
+    
+    if primary == "openai" and not OPENAI_API_KEY:
+        errors.append("PRIMARY_PROVIDER is 'openai' but OPENAI_API_KEY is missing")
+    
+    if primary == "ollama" and not OLLAMA_ENABLED:
+        errors.append("PRIMARY_PROVIDER is 'ollama' but OLLAMA_ENABLED is false")
+    
+    # Validate fallback provider configuration
+    fallback = FALLBACK_PROVIDER.lower()
+    if fallback not in ["openrouter", "ollama", "openai"]:
+        errors.append(f"FALLBACK_PROVIDER '{FALLBACK_PROVIDER}' is not supported. Must be one of: openrouter, ollama, openai")
+    
+    if fallback == "openrouter" and not OPENROUTER_API_KEY:
+        warnings.append("FALLBACK_PROVIDER is 'openrouter' but OPENROUTER_API_KEY is missing - fallback will fail")
+    
+    if fallback == "openai" and not OPENAI_API_KEY:
+        warnings.append("FALLBACK_PROVIDER is 'openai' but OPENAI_API_KEY is missing - fallback will fail")
+    
+    if fallback == "ollama" and not OLLAMA_ENABLED:
+        warnings.append("FALLBACK_PROVIDER is 'ollama' but OLLAMA_ENABLED is false - fallback will fail")
+    
+    # Validate optional API keys
+    if not TAVILY_API_KEY:
+        warnings.append("TAVILY_API_KEY is missing - web search functionality will be limited")
+    
+    if not NEWSAPI_KEY:
+        warnings.append("NEWSAPI_KEY is missing - news research functionality will be limited")
+    
+    if not ALPHAVANTAGE_API_KEY:
+        warnings.append("ALPHAVANTAGE_API_KEY is missing - financial data functionality will be limited")
+    
+    # Validate MiroFish configuration
+    if MIROFISH_ENABLED and not MIROFISH_API_BASE:
+        warnings.append("MIROFISH_ENABLED is true but MIROFISH_API_BASE is missing")
+    
+    # Validate data directories
+    try:
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
+        MEMORY_DIR.mkdir(parents=True, exist_ok=True)
+        SIMULATION_DIR.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        errors.append(f"Failed to create data directories: {e}")
+    
+    # Log results
+    if errors:
+        logger.error("Configuration validation failed with errors:")
+        for error in errors:
+            logger.error(f"  - {error}")
+        sys.exit(1)
+    
+    if warnings:
+        logger.warning("Configuration validation completed with warnings:")
+        for warning in warnings:
+            logger.warning(f"  - {warning}")
+    else:
+        logger.info("Configuration validation passed")
+
+
+# Run validation on import (startup)
+validate_config()

backend/app/domain_packs/__init__.py

@@ -0,0 +1,12 @@
+"""
+Domain Packs - Pluggable domain-specific intelligence modules.
+
+Domain packs extend the base MiroOrg system with specialized capabilities
+for specific domains (finance, healthcare, legal, etc.) without requiring
+changes to the core agent architecture.
+"""
+
+from app.domain_packs.base import DomainPack
+from app.domain_packs.registry import DomainPackRegistry, get_registry
+
+__all__ = ["DomainPack", "DomainPackRegistry", "get_registry"]

backend/app/domain_packs/base.py

@@ -0,0 +1,63 @@
+"""
+Base class for domain packs.
+
+Domain packs provide specialized capabilities for specific domains
+without requiring changes to core agents.
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+
+
+class DomainPack(ABC):
+    """Abstract base class for domain packs."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the domain pack name (e.g., 'finance', 'healthcare')."""
+        pass
+
+    @property
+    @abstractmethod
+    def keywords(self) -> List[str]:
+        """Return keywords that trigger this domain pack."""
+        pass
+
+    @abstractmethod
+    def enhance_research(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Enhance research phase with domain-specific capabilities.
+        
+        Args:
+            query: The user's query
+            context: Current research context
+            
+        Returns:
+            Enhanced context with domain-specific data
+        """
+        pass
+
+    @abstractmethod
+    def enhance_verification(self, claims: List[str], context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Enhance verification phase with domain-specific capabilities.
+        
+        Args:
+            claims: Claims to verify
+            context: Current verification context
+            
+        Returns:
+            Enhanced context with domain-specific verification
+        """
+        pass
+
+    @abstractmethod
+    def get_capabilities(self) -> Dict[str, Any]:
+        """
+        Return domain pack capabilities and metadata.
+        
+        Returns:
+            Dictionary describing pack capabilities
+        """
+        pass

backend/app/domain_packs/finance/__init__.py

@@ -0,0 +1,7 @@
+"""
+Finance domain pack - specialized capabilities for financial intelligence.
+"""
+
+from app.domain_packs.finance.pack import FinanceDomainPack
+
+__all__ = ["FinanceDomainPack"]

backend/app/domain_packs/finance/entity_resolver.py

@@ -0,0 +1,150 @@
+"""
+Entity resolver for finance domain pack.
+
+Extracts and normalizes financial entities (companies, people, organizations)
+from text.
+"""
+
+import re
+from typing import List, Dict, Any, Set
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Common financial entity patterns
+COMPANY_SUFFIXES = [
+    "Inc", "Corp", "Corporation", "Ltd", "Limited", "LLC", "LP", "LLP",
+    "Co", "Company", "Group", "Holdings", "Partners", "Capital", "Ventures",
+    "Technologies", "Systems", "Solutions", "Services", "Enterprises"
+]
+
+# Known major companies (expandable)
+KNOWN_COMPANIES = {
+    "apple": "Apple Inc.",
+    "microsoft": "Microsoft Corporation",
+    "google": "Alphabet Inc.",
+    "alphabet": "Alphabet Inc.",
+    "amazon": "Amazon.com Inc.",
+    "meta": "Meta Platforms Inc.",
+    "facebook": "Meta Platforms Inc.",
+    "tesla": "Tesla Inc.",
+    "nvidia": "NVIDIA Corporation",
+    "berkshire": "Berkshire Hathaway Inc.",
+    "jpmorgan": "JPMorgan Chase & Co.",
+    "visa": "Visa Inc.",
+    "walmart": "Walmart Inc.",
+    "exxon": "Exxon Mobil Corporation",
+    "johnson": "Johnson & Johnson",
+}
+
+
+def extract_entities(text: str) -> List[Dict[str, Any]]:
+    """
+    Extract financial entities from text.
+    
+    Args:
+        text: Input text
+        
+    Returns:
+        List of extracted entities with metadata
+    """
+    entities = []
+    seen: Set[str] = set()
+    
+    # Extract company names with suffixes
+    for suffix in COMPANY_SUFFIXES:
+        pattern = rf'\b([A-Z][a-zA-Z&\s]+)\s+{suffix}\b'
+        matches = re.finditer(pattern, text)
+        for match in matches:
+            full_name = match.group(0)
+            if full_name not in seen:
+                entities.append({
+                    "text": full_name,
+                    "type": "company",
+                    "confidence": 0.9,
+                    "source": "pattern_match"
+                })
+                seen.add(full_name)
+    
+    # Check for known companies
+    text_lower = text.lower()
+    for key, canonical_name in KNOWN_COMPANIES.items():
+        if key in text_lower and canonical_name not in seen:
+            entities.append({
+                "text": canonical_name,
+                "type": "company",
+                "confidence": 1.0,
+                "source": "known_entity"
+            })
+            seen.add(canonical_name)
+    
+    # Extract potential CEO/executive names (capitalized names near titles)
+    exec_pattern = r'\b(CEO|CFO|CTO|COO|President|Chairman|Director|Executive)\s+([A-Z][a-z]+\s+[A-Z][a-z]+)'
+    matches = re.finditer(exec_pattern, text)
+    for match in matches:
+        title = match.group(1)
+        name = match.group(2)
+        if name not in seen:
+            entities.append({
+                "text": name,
+                "type": "person",
+                "role": title,
+                "confidence": 0.8,
+                "source": "title_pattern"
+            })
+            seen.add(name)
+    
+    logger.info(f"Extracted {len(entities)} entities from text")
+    return entities
+
+
+def normalize_company_name(name: str) -> str:
+    """
+    Normalize company name to canonical form.
+    
+    Args:
+        name: Company name
+        
+    Returns:
+        Normalized company name
+    """
+    # Check known companies first
+    name_lower = name.lower()
+    for key, canonical in KNOWN_COMPANIES.items():
+        if key in name_lower:
+            return canonical
+    
+    # Otherwise return cleaned version
+    # Remove extra whitespace
+    normalized = " ".join(name.split())
+    
+    # Capitalize properly
+    words = normalized.split()
+    normalized = " ".join(
+        word.upper() if word.upper() in ["LLC", "LP", "LLP", "USA", "UK"] 
+        else word.capitalize() 
+        for word in words
+    )
+    
+    return normalized
+
+
+def resolve_entity(entity_text: str) -> Dict[str, Any]:
+    """
+    Resolve entity to canonical form with metadata.
+    
+    Args:
+        entity_text: Entity text to resolve
+        
+    Returns:
+        Dictionary with resolved entity information
+    """
+    normalized = normalize_company_name(entity_text)
+    
+    return {
+        "original": entity_text,
+        "normalized": normalized,
+        "type": "company" if any(suffix in normalized for suffix in COMPANY_SUFFIXES) else "unknown",
+        "confidence": 0.7,
+    }

backend/app/domain_packs/finance/event_analyzer.py

@@ -0,0 +1,212 @@
+"""
+Event analyzer for finance domain pack.
+
+Analyzes financial events and their potential market impact.
+"""
+
+from typing import Dict, Any, List
+import re
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Event categories and their typical impact
+EVENT_CATEGORIES = {
+    "earnings": {
+        "keywords": ["earnings", "quarterly results", "q1", "q2", "q3", "q4", "eps", "revenue"],
+        "typical_impact": "high",
+        "volatility": "high",
+    },
+    "merger_acquisition": {
+        "keywords": ["merger", "acquisition", "takeover", "buyout", "deal"],
+        "typical_impact": "very_high",
+        "volatility": "very_high",
+    },
+    "regulatory": {
+        "keywords": ["sec", "investigation", "lawsuit", "fine", "penalty", "regulation"],
+        "typical_impact": "high",
+        "volatility": "high",
+    },
+    "product_launch": {
+        "keywords": ["launch", "release", "unveil", "announce", "new product"],
+        "typical_impact": "medium",
+        "volatility": "medium",
+    },
+    "executive_change": {
+        "keywords": ["ceo", "cfo", "resign", "appoint", "hire", "fire", "step down"],
+        "typical_impact": "medium",
+        "volatility": "medium",
+    },
+    "guidance": {
+        "keywords": ["guidance", "forecast", "outlook", "projection", "estimate"],
+        "typical_impact": "high",
+        "volatility": "high",
+    },
+    "dividend": {
+        "keywords": ["dividend", "payout", "distribution", "yield"],
+        "typical_impact": "low",
+        "volatility": "low",
+    },
+    "fed_policy": {
+        "keywords": ["federal reserve", "fed", "interest rate", "monetary policy", "fomc"],
+        "typical_impact": "very_high",
+        "volatility": "very_high",
+    },
+}
+
+
+def detect_event_type(text: str) -> List[Dict[str, Any]]:
+    """
+    Detect financial event types in text.
+    
+    Args:
+        text: Text to analyze
+        
+    Returns:
+        List of detected event types with metadata
+    """
+    text_lower = text.lower()
+    detected_events = []
+    
+    for event_type, info in EVENT_CATEGORIES.items():
+        matches = []
+        for keyword in info["keywords"]:
+            if keyword in text_lower:
+                matches.append(keyword)
+        
+        if matches:
+            detected_events.append({
+                "event_type": event_type,
+                "matched_keywords": matches,
+                "typical_impact": info["typical_impact"],
+                "volatility": info["volatility"],
+                "confidence": min(len(matches) * 0.3, 1.0),
+            })
+    
+    logger.info(f"Detected {len(detected_events)} event types")
+    return detected_events
+
+
+def analyze_event_impact(text: str, event_types: List[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """
+    Analyze potential market impact of events.
+    
+    Args:
+        text: Text describing the event
+        event_types: Pre-detected event types (optional)
+        
+    Returns:
+        Impact analysis
+    """
+    if event_types is None:
+        event_types = detect_event_type(text)
+    
+    if not event_types:
+        return {
+            "impact_level": "unknown",
+            "volatility_level": "unknown",
+            "confidence": 0.0,
+        }
+    
+    # Aggregate impact levels
+    impact_scores = {
+        "very_high": 1.0,
+        "high": 0.75,
+        "medium": 0.5,
+        "low": 0.25,
+        "unknown": 0.0,
+    }
+    
+    impacts = [impact_scores.get(e["typical_impact"], 0.0) for e in event_types]
+    avg_impact = sum(impacts) / len(impacts) if impacts else 0.0
+    
+    # Determine impact level
+    if avg_impact >= 0.85:
+        impact_level = "very_high"
+    elif avg_impact >= 0.65:
+        impact_level = "high"
+    elif avg_impact >= 0.4:
+        impact_level = "medium"
+    else:
+        impact_level = "low"
+    
+    # Aggregate volatility
+    volatility_scores = {
+        "very_high": 1.0,
+        "high": 0.75,
+        "medium": 0.5,
+        "low": 0.25,
+        "unknown": 0.0,
+    }
+    
+    volatilities = [volatility_scores.get(e["volatility"], 0.0) for e in event_types]
+    avg_volatility = sum(volatilities) / len(volatilities) if volatilities else 0.0
+    
+    if avg_volatility >= 0.85:
+        volatility_level = "very_high"
+    elif avg_volatility >= 0.65:
+        volatility_level = "high"
+    elif avg_volatility >= 0.4:
+        volatility_level = "medium"
+    else:
+        volatility_level = "low"
+    
+    # Calculate confidence
+    confidences = [e["confidence"] for e in event_types]
+    avg_confidence = sum(confidences) / len(confidences) if confidences else 0.0
+    
+    return {
+        "impact_level": impact_level,
+        "volatility_level": volatility_level,
+        "confidence": avg_confidence,
+        "detected_events": event_types,
+        "event_count": len(event_types),
+    }
+
+
+def extract_event_timeline(text: str) -> List[Dict[str, Any]]:
+    """
+    Extract timeline information from event description.
+    
+    Args:
+        text: Text to analyze
+        
+    Returns:
+        List of timeline markers
+    """
+    timeline = []
+    
+    # Date patterns
+    date_patterns = [
+        r'\b(\d{1,2}/\d{1,2}/\d{2,4})\b',  # MM/DD/YYYY
+        r'\b(January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},?\s+\d{4}\b',
+        r'\b(Q[1-4]\s+\d{4})\b',  # Q1 2024
+    ]
+    
+    for pattern in date_patterns:
+        matches = re.finditer(pattern, text, re.IGNORECASE)
+        for match in matches:
+            timeline.append({
+                "date_text": match.group(0),
+                "position": match.start(),
+                "type": "date",
+            })
+    
+    # Time indicators
+    time_indicators = [
+        "today", "tomorrow", "yesterday", "next week", "next month",
+        "this quarter", "next quarter", "this year", "next year",
+        "upcoming", "soon", "recently", "last week", "last month",
+    ]
+    
+    text_lower = text.lower()
+    for indicator in time_indicators:
+        if indicator in text_lower:
+            timeline.append({
+                "date_text": indicator,
+                "type": "relative_time",
+            })
+    
+    logger.info(f"Extracted {len(timeline)} timeline markers")
+    return timeline

backend/app/domain_packs/finance/market_data.py

@@ -0,0 +1,123 @@
+"""
+Market data module for finance domain pack.
+
+Provides access to market quotes, historical data, and financial metrics
+via Alpha Vantage API.
+"""
+
+from typing import Dict, Any, Optional
+import logging
+
+import httpx
+
+from app.config import ALPHAVANTAGE_API_KEY
+
+logger = logging.getLogger(__name__)
+
+
+def get_quote(symbol: str) -> Dict[str, Any]:
+    """
+    Get real-time quote for a stock symbol.
+    
+    Args:
+        symbol: Stock ticker symbol (e.g., 'AAPL', 'TSLA')
+        
+    Returns:
+        Dictionary with quote data or empty dict if unavailable
+    """
+    if not ALPHAVANTAGE_API_KEY or not symbol:
+        logger.warning("Alpha Vantage API key missing or symbol empty")
+        return {}
+
+    try:
+        params = {
+            "function": "GLOBAL_QUOTE",
+            "symbol": symbol.upper(),
+            "apikey": ALPHAVANTAGE_API_KEY,
+        }
+        with httpx.Client(timeout=30) as client:
+            response = client.get("https://www.alphavantage.co/query", params=params)
+        
+        if response.status_code >= 400:
+            logger.error(f"Alpha Vantage API error {response.status_code}")
+            return {}
+        
+        data = response.json()
+        quote = data.get("Global Quote", {})
+        
+        if quote:
+            logger.info(f"Retrieved quote for {symbol}")
+        else:
+            logger.warning(f"No quote data for {symbol}")
+        
+        return quote
+    except Exception as e:
+        logger.error(f"Error fetching quote for {symbol}: {e}")
+        return {}
+
+
+def get_company_overview(symbol: str) -> Dict[str, Any]:
+    """
+    Get company overview and fundamental data.
+    
+    Args:
+        symbol: Stock ticker symbol
+        
+    Returns:
+        Dictionary with company data or empty dict if unavailable
+    """
+    if not ALPHAVANTAGE_API_KEY or not symbol:
+        return {}
+
+    try:
+        params = {
+            "function": "OVERVIEW",
+            "symbol": symbol.upper(),
+            "apikey": ALPHAVANTAGE_API_KEY,
+        }
+        with httpx.Client(timeout=30) as client:
+            response = client.get("https://www.alphavantage.co/query", params=params)
+        
+        if response.status_code >= 400:
+            return {}
+        
+        data = response.json()
+        logger.info(f"Retrieved company overview for {symbol}")
+        return data
+    except Exception as e:
+        logger.error(f"Error fetching company overview for {symbol}: {e}")
+        return {}
+
+
+def search_symbol(keywords: str) -> list[Dict[str, Any]]:
+    """
+    Search for stock symbols by company name or keywords.
+    
+    Args:
+        keywords: Search keywords
+        
+    Returns:
+        List of matching symbols with metadata
+    """
+    if not ALPHAVANTAGE_API_KEY or not keywords:
+        return []
+
+    try:
+        params = {
+            "function": "SYMBOL_SEARCH",
+            "keywords": keywords,
+            "apikey": ALPHAVANTAGE_API_KEY,
+        }
+        with httpx.Client(timeout=30) as client:
+            response = client.get("https://www.alphavantage.co/query", params=params)
+        
+        if response.status_code >= 400:
+            return []
+        
+        data = response.json()
+        matches = data.get("bestMatches", [])
+        logger.info(f"Found {len(matches)} symbol matches for '{keywords}'")
+        return matches
+    except Exception as e:
+        logger.error(f"Error searching symbols for '{keywords}': {e}")
+        return []

backend/app/domain_packs/finance/news.py

@@ -0,0 +1,144 @@
+"""
+News module for finance domain pack.
+
+Provides access to financial news via NewsAPI.
+"""
+
+from typing import List, Dict, Any
+from datetime import datetime, timedelta
+import logging
+
+import httpx
+
+from app.config import NEWSAPI_KEY
+
+logger = logging.getLogger(__name__)
+
+
+def search_news(
+    query: str,
+    page_size: int = 10,
+    language: str = "en",
+    sort_by: str = "publishedAt"
+) -> List[Dict[str, Any]]:
+    """
+    Search for news articles.
+    
+    Args:
+        query: Search query
+        page_size: Number of results (max 100)
+        language: Language code (default: 'en')
+        sort_by: Sort order ('publishedAt', 'relevancy', 'popularity')
+        
+    Returns:
+        List of news articles
+    """
+    if not NEWSAPI_KEY:
+        logger.warning("NewsAPI key missing")
+        return []
+
+    try:
+        params = {
+            "q": query,
+            "pageSize": min(page_size, 100),
+            "language": language,
+            "sortBy": sort_by,
+            "apiKey": NEWSAPI_KEY,
+        }
+        with httpx.Client(timeout=30) as client:
+            response = client.get("https://newsapi.org/v2/everything", params=params)
+        
+        if response.status_code >= 400:
+            logger.error(f"NewsAPI error {response.status_code}: {response.text}")
+            return []
+        
+        data = response.json()
+        articles = data.get("articles", [])
+        logger.info(f"Found {len(articles)} news articles for '{query}'")
+        return articles
+    except Exception as e:
+        logger.error(f"Error searching news for '{query}': {e}")
+        return []
+
+
+def get_top_headlines(
+    category: str = "business",
+    country: str = "us",
+    page_size: int = 10
+) -> List[Dict[str, Any]]:
+    """
+    Get top headlines by category.
+    
+    Args:
+        category: News category ('business', 'technology', etc.)
+        country: Country code (default: 'us')
+        page_size: Number of results (max 100)
+        
+    Returns:
+        List of top headline articles
+    """
+    if not NEWSAPI_KEY:
+        logger.warning("NewsAPI key missing")
+        return []
+
+    try:
+        params = {
+            "category": category,
+            "country": country,
+            "pageSize": min(page_size, 100),
+            "apiKey": NEWSAPI_KEY,
+        }
+        with httpx.Client(timeout=30) as client:
+            response = client.get("https://newsapi.org/v2/top-headlines", params=params)
+        
+        if response.status_code >= 400:
+            logger.error(f"NewsAPI error {response.status_code}")
+            return []
+        
+        data = response.json()
+        articles = data.get("articles", [])
+        logger.info(f"Retrieved {len(articles)} top headlines for {category}/{country}")
+        return articles
+    except Exception as e:
+        logger.error(f"Error fetching top headlines: {e}")
+        return []
+
+
+def get_company_news(company_name: str, days_back: int = 7) -> List[Dict[str, Any]]:
+    """
+    Get recent news about a specific company.
+    
+    Args:
+        company_name: Company name to search for
+        days_back: Number of days to look back (default: 7)
+        
+    Returns:
+        List of news articles about the company
+    """
+    if not NEWSAPI_KEY:
+        return []
+
+    try:
+        from_date = (datetime.now() - timedelta(days=days_back)).strftime("%Y-%m-%d")
+        
+        params = {
+            "q": company_name,
+            "from": from_date,
+            "sortBy": "publishedAt",
+            "language": "en",
+            "pageSize": 20,
+            "apiKey": NEWSAPI_KEY,
+        }
+        with httpx.Client(timeout=30) as client:
+            response = client.get("https://newsapi.org/v2/everything", params=params)
+        
+        if response.status_code >= 400:
+            return []
+        
+        data = response.json()
+        articles = data.get("articles", [])
+        logger.info(f"Found {len(articles)} articles about '{company_name}' in last {days_back} days")
+        return articles
+    except Exception as e:
+        logger.error(f"Error fetching company news for '{company_name}': {e}")
+        return []

backend/app/domain_packs/finance/pack.py

@@ -0,0 +1,122 @@
+"""
+Finance domain pack implementation.
+
+Provides specialized capabilities for financial intelligence including:
+- Market data integration
+- Entity and ticker resolution
+- Credibility scoring for financial sources
+- Rumor and scam detection
+- Sentiment analysis and predictions
+"""
+
+from typing import List, Dict, Any
+import logging
+
+from app.domain_packs.base import DomainPack
+
+logger = logging.getLogger(__name__)
+
+
+class FinanceDomainPack(DomainPack):
+    """Finance domain pack for financial intelligence."""
+
+    @property
+    def name(self) -> str:
+        return "finance"
+
+    @property
+    def keywords(self) -> List[str]:
+        return [
+            # Markets and trading
+            "stock", "stocks", "market", "markets", "trading", "trader",
+            "equity", "equities", "shares", "ticker", "nasdaq", "nyse",
+            "dow", "s&p", "index", "indices",
+            
+            # Financial instruments
+            "bond", "bonds", "derivative", "derivatives", "option", "options",
+            "futures", "etf", "mutual fund", "portfolio",
+            
+            # Companies and entities
+            "earnings", "revenue", "profit", "loss", "quarterly", "annual report",
+            "sec filing", "10-k", "10-q", "ipo", "merger", "acquisition",
+            
+            # Economic indicators
+            "fed", "federal reserve", "interest rate", "inflation", "gdp",
+            "unemployment", "jobs report", "cpi", "ppi",
+            
+            # Crypto (if applicable)
+            "bitcoin", "ethereum", "crypto", "cryptocurrency", "blockchain",
+            
+            # Financial news and events
+            "earnings call", "analyst", "rating", "upgrade", "downgrade",
+            "price target", "bull", "bear", "rally", "crash", "correction",
+            
+            # Risk and compliance
+            "fraud", "scam", "ponzi", "insider trading", "sec investigation",
+            "bankruptcy", "default", "credit rating",
+        ]
+
+    def enhance_research(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Enhance research with finance-specific capabilities.
+        
+        This will be implemented in Phase 2 Task 4 when we port impact_ai modules.
+        For now, return context unchanged.
+        """
+        logger.info(f"Finance pack enhancing research for query: {query[:100]}")
+        
+        # Placeholder - will be implemented with impact_ai modules
+        enhanced = context.copy()
+        enhanced["domain"] = "finance"
+        enhanced["finance_capabilities"] = [
+            "market_data",
+            "entity_resolution",
+            "ticker_resolution",
+            "credibility_scoring",
+            "rumor_detection",
+            "scam_detection",
+        ]
+        
+        return enhanced
+
+    def enhance_verification(self, claims: List[str], context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Enhance verification with finance-specific capabilities.
+        
+        This will be implemented in Phase 2 Task 4 when we port impact_ai modules.
+        For now, return context unchanged.
+        """
+        logger.info(f"Finance pack enhancing verification for {len(claims)} claims")
+        
+        # Placeholder - will be implemented with impact_ai modules
+        enhanced = context.copy()
+        enhanced["domain"] = "finance"
+        enhanced["verification_methods"] = [
+            "source_credibility_check",
+            "rumor_detection",
+            "scam_detection",
+            "cross_reference_market_data",
+        ]
+        
+        return enhanced
+
+    def get_capabilities(self) -> Dict[str, Any]:
+        """Return finance pack capabilities."""
+        return {
+            "name": self.name,
+            "version": "1.0.0",
+            "description": "Financial intelligence domain pack",
+            "features": [
+                "Market data integration (Alpha Vantage)",
+                "News aggregation (NewsAPI)",
+                "Entity and ticker resolution",
+                "Source credibility scoring",
+                "Rumor detection",
+                "Scam detection",
+                "Sentiment analysis",
+                "Event impact analysis",
+                "Price prediction support",
+            ],
+            "keywords_count": len(self.keywords),
+            "status": "active",
+        }

backend/app/domain_packs/finance/prediction.py

@@ -0,0 +1,200 @@
+"""
+Prediction support module for finance domain pack.
+
+Provides structured support for financial predictions and forecasts.
+Note: This module does NOT make actual predictions, but helps structure
+prediction-related analysis and uncertainty quantification.
+"""
+
+from typing import Dict, Any, List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def structure_prediction_context(
+    query: str,
+    entities: List[Dict[str, Any]],
+    events: List[Dict[str, Any]],
+    stance: Dict[str, Any],
+    sources: List[str]
+) -> Dict[str, Any]:
+    """
+    Structure context for prediction-related queries.
+    
+    Args:
+        query: User's prediction query
+        entities: Extracted entities
+        events: Detected events
+        stance: Market stance analysis
+        sources: Information sources
+        
+    Returns:
+        Structured prediction context
+    """
+    from app.domain_packs.finance.source_checker import aggregate_source_scores
+    
+    # Assess source credibility
+    source_assessment = aggregate_source_scores(sources)
+    
+    # Determine prediction type
+    query_lower = query.lower()
+    prediction_type = "unknown"
+    
+    if any(word in query_lower for word in ["price", "stock", "value", "worth"]):
+        prediction_type = "price_movement"
+    elif any(word in query_lower for word in ["earnings", "revenue", "profit"]):
+        prediction_type = "financial_performance"
+    elif any(word in query_lower for word in ["market", "sector", "industry"]):
+        prediction_type = "market_trend"
+    elif any(word in query_lower for word in ["merger", "acquisition", "deal"]):
+        prediction_type = "corporate_action"
+    
+    # Calculate uncertainty factors
+    uncertainty_factors = []
+    
+    if source_assessment["average_score"] < 0.7:
+        uncertainty_factors.append("low_source_credibility")
+    
+    if stance.get("confidence", 0) < 0.6:
+        uncertainty_factors.append("mixed_market_sentiment")
+    
+    if len(events) == 0:
+        uncertainty_factors.append("no_clear_catalysts")
+    
+    if len(entities) == 0:
+        uncertainty_factors.append("unclear_target_entities")
+    
+    uncertainty_level = "high" if len(uncertainty_factors) >= 3 else \
+                       "medium" if len(uncertainty_factors) >= 1 else \
+                       "low"
+    
+    return {
+        "prediction_type": prediction_type,
+        "target_entities": entities,
+        "relevant_events": events,
+        "market_stance": stance,
+        "source_credibility": source_assessment,
+        "uncertainty_level": uncertainty_level,
+        "uncertainty_factors": uncertainty_factors,
+        "recommendation": "high_confidence_analysis" if uncertainty_level == "low" else
+                         "moderate_confidence_analysis" if uncertainty_level == "medium" else
+                         "low_confidence_analysis",
+    }
+
+
+def quantify_prediction_uncertainty(
+    prediction_context: Dict[str, Any],
+    additional_factors: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Quantify uncertainty in prediction context.
+    
+    Args:
+        prediction_context: Structured prediction context
+        additional_factors: Additional uncertainty factors
+        
+    Returns:
+        Uncertainty quantification
+    """
+    base_uncertainty = 0.5  # Start with 50% uncertainty
+    
+    # Adjust based on source credibility
+    source_score = prediction_context.get("source_credibility", {}).get("average_score", 0.5)
+    base_uncertainty -= (source_score - 0.5) * 0.3
+    
+    # Adjust based on market stance confidence
+    stance_confidence = prediction_context.get("market_stance", {}).get("confidence", 0.5)
+    base_uncertainty -= (stance_confidence - 0.5) * 0.2
+    
+    # Adjust based on event clarity
+    event_count = len(prediction_context.get("relevant_events", []))
+    if event_count > 0:
+        base_uncertainty -= 0.1
+    
+    # Adjust based on entity clarity
+    entity_count = len(prediction_context.get("target_entities", []))
+    if entity_count > 0:
+        base_uncertainty -= 0.1
+    
+    # Apply additional factors
+    if additional_factors:
+        if additional_factors.get("high_volatility"):
+            base_uncertainty += 0.15
+        if additional_factors.get("conflicting_signals"):
+            base_uncertainty += 0.2
+        if additional_factors.get("limited_data"):
+            base_uncertainty += 0.15
+    
+    # Clamp to 0-1 range
+    uncertainty_score = max(0.0, min(1.0, base_uncertainty))
+    
+    confidence_score = 1.0 - uncertainty_score
+    
+    return {
+        "uncertainty_score": uncertainty_score,
+        "confidence_score": confidence_score,
+        "uncertainty_level": prediction_context.get("uncertainty_level", "unknown"),
+        "factors": prediction_context.get("uncertainty_factors", []),
+        "recommendation": "proceed_with_caution" if uncertainty_score >= 0.7 else
+                         "moderate_confidence" if uncertainty_score >= 0.4 else
+                         "reasonable_confidence",
+    }
+
+
+def suggest_simulation_scenarios(prediction_context: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Suggest simulation scenarios based on prediction context.
+    
+    Args:
+        prediction_context: Structured prediction context
+        
+    Returns:
+        List of suggested simulation scenarios
+    """
+    scenarios = []
+    
+    prediction_type = prediction_context.get("prediction_type", "unknown")
+    events = prediction_context.get("relevant_events", [])
+    
+    if prediction_type == "price_movement":
+        scenarios.append({
+            "scenario": "bull_case",
+            "description": "Optimistic price movement scenario",
+            "parameters": {"sentiment": "positive", "volatility": "moderate"},
+        })
+        scenarios.append({
+            "scenario": "bear_case",
+            "description": "Pessimistic price movement scenario",
+            "parameters": {"sentiment": "negative", "volatility": "moderate"},
+        })
+        scenarios.append({
+            "scenario": "base_case",
+            "description": "Neutral price movement scenario",
+            "parameters": {"sentiment": "neutral", "volatility": "low"},
+        })
+    
+    if prediction_type == "market_trend":
+        scenarios.append({
+            "scenario": "sector_rotation",
+            "description": "Capital flows between sectors",
+            "parameters": {"market_phase": "rotation"},
+        })
+    
+    # Add event-specific scenarios
+    for event in events:
+        event_type = event.get("event_type")
+        if event_type == "earnings":
+            scenarios.append({
+                "scenario": "earnings_beat",
+                "description": "Company beats earnings expectations",
+                "parameters": {"event": "earnings", "outcome": "positive"},
+            })
+            scenarios.append({
+                "scenario": "earnings_miss",
+                "description": "Company misses earnings expectations",
+                "parameters": {"event": "earnings", "outcome": "negative"},
+            })
+    
+    logger.info(f"Suggested {len(scenarios)} simulation scenarios")
+    return scenarios

backend/app/domain_packs/finance/rumor_detector.py

@@ -0,0 +1,138 @@
+"""
+Rumor detector for finance domain pack.
+
+Detects potential rumors and unverified claims in financial content.
+"""
+
+import re
+from typing import List, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Rumor indicator patterns
+RUMOR_INDICATORS = [
+    # Hedging language
+    r'\b(allegedly|reportedly|rumor|rumored|speculation|speculated|unconfirmed|unverified)\b',
+    r'\b(sources say|sources claim|insider|insiders|anonymous source)\b',
+    r'\b(could be|might be|may be|possibly|potentially)\b',
+    
+    # Vague attribution
+    r'\b(some say|people say|word is|buzz is|chatter|whispers)\b',
+    r'\b(according to rumors|according to speculation)\b',
+    
+    # Sensational language
+    r'\b(shocking|bombshell|explosive|leaked|secret)\b',
+]
+
+# Verification indicators (opposite of rumors)
+VERIFICATION_INDICATORS = [
+    r'\b(confirmed|verified|official|announced|disclosed|filed)\b',
+    r'\b(sec filing|press release|earnings report|official statement)\b',
+    r'\b(ceo said|cfo said|company announced)\b',
+]
+
+
+def detect_rumor_indicators(text: str) -> Dict[str, Any]:
+    """
+    Detect rumor indicators in text.
+    
+    Args:
+        text: Text to analyze
+        
+    Returns:
+        Dictionary with rumor detection results
+    """
+    text_lower = text.lower()
+    
+    # Count rumor indicators
+    rumor_matches = []
+    for pattern in RUMOR_INDICATORS:
+        matches = re.finditer(pattern, text_lower, re.IGNORECASE)
+        for match in matches:
+            rumor_matches.append({
+                "text": match.group(0),
+                "position": match.start(),
+                "type": "rumor_indicator",
+            })
+    
+    # Count verification indicators
+    verification_matches = []
+    for pattern in VERIFICATION_INDICATORS:
+        matches = re.finditer(pattern, text_lower, re.IGNORECASE)
+        for match in matches:
+            verification_matches.append({
+                "text": match.group(0),
+                "position": match.start(),
+                "type": "verification_indicator",
+            })
+    
+    # Calculate rumor score (0-1, higher = more likely rumor)
+    rumor_count = len(rumor_matches)
+    verification_count = len(verification_matches)
+    
+    if rumor_count == 0 and verification_count == 0:
+        rumor_score = 0.5  # Neutral
+    else:
+        # Score based on ratio
+        total = rumor_count + verification_count
+        rumor_score = rumor_count / total if total > 0 else 0.5
+    
+    # Adjust for absolute counts
+    if rumor_count >= 3:
+        rumor_score = min(rumor_score + 0.2, 1.0)
+    if verification_count >= 2:
+        rumor_score = max(rumor_score - 0.2, 0.0)
+    
+    assessment = "likely_rumor" if rumor_score >= 0.7 else \
+                 "possible_rumor" if rumor_score >= 0.5 else \
+                 "likely_verified"
+    
+    logger.info(f"Rumor detection: score={rumor_score:.2f}, assessment={assessment}")
+    
+    return {
+        "rumor_score": rumor_score,
+        "assessment": assessment,
+        "rumor_indicators": rumor_matches,
+        "verification_indicators": verification_matches,
+        "rumor_count": rumor_count,
+        "verification_count": verification_count,
+    }
+
+
+def check_claim_verification(claim: str, sources: List[str]) -> Dict[str, Any]:
+    """
+    Check if a claim is verified by credible sources.
+    
+    Args:
+        claim: Claim to verify
+        sources: List of source URLs
+        
+    Returns:
+        Verification assessment
+    """
+    from app.domain_packs.finance.source_checker import aggregate_source_scores
+    
+    # Detect rumor indicators in the claim itself
+    rumor_detection = detect_rumor_indicators(claim)
+    
+    # Check source credibility
+    source_assessment = aggregate_source_scores(sources)
+    
+    # Combine assessments
+    is_verified = (
+        rumor_detection["rumor_score"] < 0.5 and
+        source_assessment["average_score"] >= 0.7
+    )
+    
+    confidence = (1 - rumor_detection["rumor_score"]) * source_assessment["average_score"]
+    
+    return {
+        "claim": claim,
+        "is_verified": is_verified,
+        "confidence": confidence,
+        "rumor_detection": rumor_detection,
+        "source_assessment": source_assessment,
+        "recommendation": "trust" if is_verified else "verify_further" if confidence >= 0.5 else "skeptical",
+    }

backend/app/domain_packs/finance/scam_detector.py

@@ -0,0 +1,159 @@
+"""
+Scam detector for finance domain pack.
+
+Detects potential financial scams and fraudulent schemes.
+"""
+
+import re
+from typing import List, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Scam indicator patterns
+SCAM_PATTERNS = [
+    # Get-rich-quick schemes
+    r'\b(get rich quick|make money fast|guaranteed returns|no risk)\b',
+    r'\b(double your money|triple your investment|10x returns)\b',
+    r'\b(passive income|work from home|financial freedom)\b',
+    
+    # Pressure tactics
+    r'\b(act now|limited time|urgent|don\'t miss out|last chance)\b',
+    r'\b(exclusive offer|secret|insider tip|hidden opportunity)\b',
+    
+    # Unrealistic promises
+    r'\b(guaranteed profit|risk-free|100% return|never lose)\b',
+    r'\b(foolproof|can\'t lose|sure thing|no-brainer)\b',
+    
+    # Pyramid/MLM indicators
+    r'\b(recruit|downline|upline|multi-level|network marketing)\b',
+    r'\b(join my team|be your own boss|financial independence)\b',
+    
+    # Crypto scams
+    r'\b(airdrop|free crypto|token giveaway|pump and dump)\b',
+    r'\b(send.*receive back|double your bitcoin)\b',
+    
+    # Phishing/fraud
+    r'\b(verify your account|suspended account|unusual activity)\b',
+    r'\b(click here immediately|update payment|confirm identity)\b',
+]
+
+# Known scam keywords
+HIGH_RISK_KEYWORDS = [
+    "ponzi", "pyramid scheme", "advance fee", "419 scam",
+    "pump and dump", "rug pull", "exit scam", "phishing",
+]
+
+
+def detect_scam_indicators(text: str) -> Dict[str, Any]:
+    """
+    Detect scam indicators in text.
+    
+    Args:
+        text: Text to analyze
+        
+    Returns:
+        Dictionary with scam detection results
+    """
+    text_lower = text.lower()
+    
+    # Find pattern matches
+    matches = []
+    for pattern in SCAM_PATTERNS:
+        found = re.finditer(pattern, text_lower, re.IGNORECASE)
+        for match in found:
+            matches.append({
+                "text": match.group(0),
+                "position": match.start(),
+                "type": "scam_pattern",
+            })
+    
+    # Check for high-risk keywords
+    high_risk_found = []
+    for keyword in HIGH_RISK_KEYWORDS:
+        if keyword in text_lower:
+            high_risk_found.append(keyword)
+    
+    # Calculate scam score (0-1, higher = more likely scam)
+    pattern_score = min(len(matches) * 0.15, 0.8)
+    keyword_score = min(len(high_risk_found) * 0.3, 0.9)
+    
+    scam_score = max(pattern_score, keyword_score)
+    
+    # Adjust for multiple indicators
+    if len(matches) >= 5:
+        scam_score = min(scam_score + 0.2, 1.0)
+    
+    risk_level = "high_risk" if scam_score >= 0.7 else \
+                 "medium_risk" if scam_score >= 0.4 else \
+                 "low_risk"
+    
+    logger.info(f"Scam detection: score={scam_score:.2f}, risk={risk_level}")
+    
+    return {
+        "scam_score": scam_score,
+        "risk_level": risk_level,
+        "pattern_matches": matches,
+        "high_risk_keywords": high_risk_found,
+        "match_count": len(matches),
+        "keyword_count": len(high_risk_found),
+    }
+
+
+def check_investment_legitimacy(
+    description: str,
+    promised_return: float = None,
+    timeframe: str = None
+) -> Dict[str, Any]:
+    """
+    Check if an investment opportunity appears legitimate.
+    
+    Args:
+        description: Investment description
+        promised_return: Promised return percentage (if specified)
+        timeframe: Timeframe for returns (if specified)
+        
+    Returns:
+        Legitimacy assessment
+    """
+    # Detect scam indicators
+    scam_detection = detect_scam_indicators(description)
+    
+    # Check for unrealistic returns
+    unrealistic_return = False
+    if promised_return is not None:
+        # Returns over 20% annually are suspicious
+        # Returns over 50% are highly suspicious
+        if promised_return > 50:
+            unrealistic_return = True
+            scam_detection["scam_score"] = min(scam_detection["scam_score"] + 0.3, 1.0)
+        elif promised_return > 20:
+            unrealistic_return = True
+            scam_detection["scam_score"] = min(scam_detection["scam_score"] + 0.15, 1.0)
+    
+    # Check for short timeframes with high returns
+    suspicious_timeframe = False
+    if timeframe and promised_return:
+        timeframe_lower = timeframe.lower()
+        if any(word in timeframe_lower for word in ["day", "days", "week", "weeks"]):
+            if promised_return > 10:
+                suspicious_timeframe = True
+                scam_detection["scam_score"] = min(scam_detection["scam_score"] + 0.2, 1.0)
+    
+    is_legitimate = scam_detection["scam_score"] < 0.4
+    
+    return {
+        "is_legitimate": is_legitimate,
+        "scam_detection": scam_detection,
+        "unrealistic_return": unrealistic_return,
+        "suspicious_timeframe": suspicious_timeframe,
+        "recommendation": "avoid" if scam_detection["scam_score"] >= 0.7 else
+                         "investigate_thoroughly" if scam_detection["scam_score"] >= 0.4 else
+                         "proceed_with_caution",
+        "warnings": [
+            "Unrealistic return promises" if unrealistic_return else None,
+            "Suspicious timeframe" if suspicious_timeframe else None,
+            f"{scam_detection['match_count']} scam indicators found" if scam_detection['match_count'] > 0 else None,
+        ],
+    }

backend/app/domain_packs/finance/source_checker.py

@@ -0,0 +1,156 @@
+"""
+Source credibility checker for finance domain pack.
+
+Evaluates the credibility of financial news sources and information.
+"""
+
+from typing import Dict, Any
+from urllib.parse import urlparse
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Trusted financial news sources (expandable)
+TRUSTED_SOURCES = {
+    # Tier 1: Highly trusted
+    "bloomberg.com": {"tier": 1, "score": 0.95, "category": "financial_news"},
+    "reuters.com": {"tier": 1, "score": 0.95, "category": "news_wire"},
+    "wsj.com": {"tier": 1, "score": 0.95, "category": "financial_news"},
+    "ft.com": {"tier": 1, "score": 0.95, "category": "financial_news"},
+    
+    # Tier 2: Trusted
+    "cnbc.com": {"tier": 2, "score": 0.85, "category": "financial_news"},
+    "marketwatch.com": {"tier": 2, "score": 0.85, "category": "financial_news"},
+    "barrons.com": {"tier": 2, "score": 0.85, "category": "financial_news"},
+    "economist.com": {"tier": 2, "score": 0.85, "category": "business_news"},
+    "forbes.com": {"tier": 2, "score": 0.80, "category": "business_news"},
+    
+    # Tier 3: Generally reliable
+    "yahoo.com": {"tier": 3, "score": 0.70, "category": "aggregator"},
+    "seekingalpha.com": {"tier": 3, "score": 0.70, "category": "analysis"},
+    "investopedia.com": {"tier": 3, "score": 0.75, "category": "education"},
+    
+    # Official sources
+    "sec.gov": {"tier": 1, "score": 1.0, "category": "regulatory"},
+    "federalreserve.gov": {"tier": 1, "score": 1.0, "category": "regulatory"},
+    "treasury.gov": {"tier": 1, "score": 1.0, "category": "regulatory"},
+}
+
+# Red flag domains (known for misinformation)
+UNTRUSTED_SOURCES = {
+    "example-scam.com": {"score": 0.1, "reason": "known_scam"},
+    # Add more as identified
+}
+
+
+def check_source_credibility(url: str) -> Dict[str, Any]:
+    """
+    Check the credibility of a source URL.
+    
+    Args:
+        url: Source URL to check
+        
+    Returns:
+        Dictionary with credibility assessment
+    """
+    try:
+        parsed = urlparse(url)
+        domain = parsed.netloc.lower()
+        
+        # Remove www. prefix
+        if domain.startswith("www."):
+            domain = domain[4:]
+        
+        # Check if it's a trusted source
+        if domain in TRUSTED_SOURCES:
+            info = TRUSTED_SOURCES[domain]
+            logger.info(f"Source {domain} is trusted (tier {info['tier']})")
+            return {
+                "url": url,
+                "domain": domain,
+                "credibility_score": info["score"],
+                "tier": info["tier"],
+                "category": info["category"],
+                "trusted": True,
+                "reason": "known_trusted_source",
+            }
+        
+        # Check if it's an untrusted source
+        if domain in UNTRUSTED_SOURCES:
+            info = UNTRUSTED_SOURCES[domain]
+            logger.warning(f"Source {domain} is untrusted: {info['reason']}")
+            return {
+                "url": url,
+                "domain": domain,
+                "credibility_score": info["score"],
+                "trusted": False,
+                "reason": info["reason"],
+            }
+        
+        # Unknown source - neutral score
+        logger.info(f"Source {domain} is unknown, assigning neutral score")
+        return {
+            "url": url,
+            "domain": domain,
+            "credibility_score": 0.5,
+            "trusted": None,
+            "reason": "unknown_source",
+        }
+    
+    except Exception as e:
+        logger.error(f"Error checking source credibility for {url}: {e}")
+        return {
+            "url": url,
+            "credibility_score": 0.3,
+            "trusted": False,
+            "reason": "parse_error",
+        }
+
+
+def aggregate_source_scores(sources: list[str]) -> Dict[str, Any]:
+    """
+    Aggregate credibility scores from multiple sources.
+    
+    Args:
+        sources: List of source URLs
+        
+    Returns:
+        Aggregated credibility assessment
+    """
+    if not sources:
+        return {
+            "average_score": 0.0,
+            "trusted_count": 0,
+            "untrusted_count": 0,
+            "unknown_count": 0,
+        }
+    
+    scores = []
+    trusted_count = 0
+    untrusted_count = 0
+    unknown_count = 0
+    
+    for url in sources:
+        result = check_source_credibility(url)
+        scores.append(result["credibility_score"])
+        
+        if result.get("trusted") is True:
+            trusted_count += 1
+        elif result.get("trusted") is False:
+            untrusted_count += 1
+        else:
+            unknown_count += 1
+    
+    average_score = sum(scores) / len(scores) if scores else 0.0
+    
+    return {
+        "average_score": average_score,
+        "trusted_count": trusted_count,
+        "untrusted_count": untrusted_count,
+        "unknown_count": unknown_count,
+        "total_sources": len(sources),
+        "assessment": "high_credibility" if average_score >= 0.8 else
+                     "medium_credibility" if average_score >= 0.6 else
+                     "low_credibility",
+    }

backend/app/domain_packs/finance/stance_detector.py

@@ -0,0 +1,143 @@
+"""
+Stance detector for finance domain pack.
+
+Detects sentiment and stance (bullish/bearish) in financial content.
+"""
+
+import re
+from typing import Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Bullish indicators
+BULLISH_KEYWORDS = [
+    "bullish", "buy", "long", "upgrade", "outperform", "strong buy",
+    "positive", "growth", "rally", "surge", "soar", "climb", "gain",
+    "beat expectations", "exceed", "record high", "all-time high",
+    "momentum", "breakout", "uptrend", "optimistic", "confident",
+]
+
+# Bearish indicators
+BEARISH_KEYWORDS = [
+    "bearish", "sell", "short", "downgrade", "underperform", "strong sell",
+    "negative", "decline", "fall", "drop", "plunge", "crash", "loss",
+    "miss expectations", "disappoint", "record low", "downturn",
+    "weakness", "breakdown", "downtrend", "pessimistic", "concerned",
+]
+
+# Neutral indicators
+NEUTRAL_KEYWORDS = [
+    "hold", "neutral", "maintain", "unchanged", "stable", "flat",
+    "sideways", "range-bound", "wait and see", "cautious",
+]
+
+
+def detect_stance(text: str) -> Dict[str, Any]:
+    """
+    Detect financial stance (bullish/bearish/neutral) in text.
+    
+    Args:
+        text: Text to analyze
+        
+    Returns:
+        Dictionary with stance detection results
+    """
+    text_lower = text.lower()
+    
+    # Count keyword occurrences
+    bullish_count = sum(1 for keyword in BULLISH_KEYWORDS if keyword in text_lower)
+    bearish_count = sum(1 for keyword in BEARISH_KEYWORDS if keyword in text_lower)
+    neutral_count = sum(1 for keyword in NEUTRAL_KEYWORDS if keyword in text_lower)
+    
+    total_count = bullish_count + bearish_count + neutral_count
+    
+    if total_count == 0:
+        # No clear indicators
+        stance = "neutral"
+        confidence = 0.3
+        sentiment_score = 0.5
+    else:
+        # Calculate sentiment score (-1 to 1)
+        # Positive = bullish, negative = bearish
+        sentiment_score = (bullish_count - bearish_count) / total_count
+        
+        # Normalize to 0-1 range
+        sentiment_score = (sentiment_score + 1) / 2
+        
+        # Determine stance
+        if bullish_count > bearish_count and bullish_count > neutral_count:
+            stance = "bullish"
+            confidence = bullish_count / total_count
+        elif bearish_count > bullish_count and bearish_count > neutral_count:
+            stance = "bearish"
+            confidence = bearish_count / total_count
+        else:
+            stance = "neutral"
+            confidence = max(neutral_count / total_count, 0.5)
+    
+    logger.info(f"Stance detection: {stance} (confidence={confidence:.2f}, sentiment={sentiment_score:.2f})")
+    
+    return {
+        "stance": stance,
+        "confidence": confidence,
+        "sentiment_score": sentiment_score,
+        "bullish_count": bullish_count,
+        "bearish_count": bearish_count,
+        "neutral_count": neutral_count,
+        "total_indicators": total_count,
+    }
+
+
+def analyze_price_action_language(text: str) -> Dict[str, Any]:
+    """
+    Analyze language describing price action.
+    
+    Args:
+        text: Text to analyze
+        
+    Returns:
+        Price action analysis
+    """
+    text_lower = text.lower()
+    
+    # Detect magnitude words
+    strong_movement = any(word in text_lower for word in [
+        "surge", "soar", "plunge", "crash", "skyrocket", "plummet"
+    ])
+    
+    moderate_movement = any(word in text_lower for word in [
+        "rise", "fall", "climb", "drop", "gain", "loss"
+    ])
+    
+    weak_movement = any(word in text_lower for word in [
+        "inch", "edge", "slip", "dip", "tick"
+    ])
+    
+    # Detect direction
+    upward = any(word in text_lower for word in [
+        "up", "higher", "gain", "rise", "climb", "rally", "surge"
+    ])
+    
+    downward = any(word in text_lower for word in [
+        "down", "lower", "loss", "fall", "drop", "decline", "plunge"
+    ])
+    
+    magnitude = "strong" if strong_movement else \
+                "moderate" if moderate_movement else \
+                "weak" if weak_movement else \
+                "unclear"
+    
+    direction = "upward" if upward and not downward else \
+                "downward" if downward and not upward else \
+                "mixed" if upward and downward else \
+                "unclear"
+    
+    return {
+        "magnitude": magnitude,
+        "direction": direction,
+        "strong_movement": strong_movement,
+        "moderate_movement": moderate_movement,
+        "weak_movement": weak_movement,
+    }

backend/app/domain_packs/finance/ticker_resolver.py

@@ -0,0 +1,171 @@
+"""
+Ticker resolver for finance domain pack.
+
+Resolves company names to stock ticker symbols and vice versa.
+"""
+
+import re
+from typing import Optional, List, Dict, Any
+import logging
+
+from app.domain_packs.finance.market_data import search_symbol
+
+logger = logging.getLogger(__name__)
+
+
+# Ticker pattern: $SYMBOL or standalone uppercase 1-5 letters
+TICKER_PATTERN = re.compile(r'\$([A-Z]{1,5})\b')
+STANDALONE_TICKER_PATTERN = re.compile(r'\b([A-Z]{2,5})\b')
+
+# Known ticker mappings (expandable)
+KNOWN_TICKERS = {
+    "AAPL": "Apple Inc.",
+    "MSFT": "Microsoft Corporation",
+    "GOOGL": "Alphabet Inc.",
+    "GOOG": "Alphabet Inc.",
+    "AMZN": "Amazon.com Inc.",
+    "META": "Meta Platforms Inc.",
+    "TSLA": "Tesla Inc.",
+    "NVDA": "NVIDIA Corporation",
+    "BRK.A": "Berkshire Hathaway Inc.",
+    "BRK.B": "Berkshire Hathaway Inc.",
+    "JPM": "JPMorgan Chase & Co.",
+    "V": "Visa Inc.",
+    "WMT": "Walmart Inc.",
+    "XOM": "Exxon Mobil Corporation",
+    "JNJ": "Johnson & Johnson",
+}
+
+# Reverse mapping
+COMPANY_TO_TICKER = {v: k for k, v in KNOWN_TICKERS.items()}
+
+
+def extract_tickers(text: str) -> List[str]:
+    """
+    Extract stock ticker symbols from text.
+    
+    Args:
+        text: Input text
+        
+    Returns:
+        List of ticker symbols found
+    """
+    tickers = []
+    
+    # Find $SYMBOL patterns
+    dollar_tickers = TICKER_PATTERN.findall(text)
+    tickers.extend(dollar_tickers)
+    
+    # Find standalone uppercase symbols (more conservative)
+    # Only if they're known tickers to avoid false positives
+    standalone = STANDALONE_TICKER_PATTERN.findall(text)
+    for symbol in standalone:
+        if symbol in KNOWN_TICKERS:
+            tickers.append(symbol)
+    
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_tickers = []
+    for ticker in tickers:
+        if ticker not in seen:
+            unique_tickers.append(ticker)
+            seen.add(ticker)
+    
+    logger.info(f"Extracted {len(unique_tickers)} tickers from text: {unique_tickers}")
+    return unique_tickers
+
+
+def resolve_ticker(ticker: str) -> Optional[Dict[str, Any]]:
+    """
+    Resolve ticker symbol to company information.
+    
+    Args:
+        ticker: Stock ticker symbol
+        
+    Returns:
+        Dictionary with company information or None
+    """
+    ticker = ticker.upper()
+    
+    # Check known tickers first
+    if ticker in KNOWN_TICKERS:
+        return {
+            "ticker": ticker,
+            "company_name": KNOWN_TICKERS[ticker],
+            "source": "known_mapping",
+            "confidence": 1.0,
+        }
+    
+    # Try Alpha Vantage search
+    try:
+        results = search_symbol(ticker)
+        if results:
+            best_match = results[0]
+            return {
+                "ticker": best_match.get("1. symbol", ticker),
+                "company_name": best_match.get("2. name", "Unknown"),
+                "region": best_match.get("4. region", "Unknown"),
+                "currency": best_match.get("8. currency", "Unknown"),
+                "source": "alpha_vantage",
+                "confidence": 0.8,
+            }
+    except Exception as e:
+        logger.error(f"Error resolving ticker {ticker}: {e}")
+    
+    return None
+
+
+def resolve_company_to_ticker(company_name: str) -> Optional[str]:
+    """
+    Resolve company name to ticker symbol.
+    
+    Args:
+        company_name: Company name
+        
+    Returns:
+        Ticker symbol or None
+    """
+    # Check known mappings first
+    if company_name in COMPANY_TO_TICKER:
+        ticker = COMPANY_TO_TICKER[company_name]
+        logger.info(f"Resolved '{company_name}' to ticker {ticker}")
+        return ticker
+    
+    # Try Alpha Vantage search
+    try:
+        results = search_symbol(company_name)
+        if results:
+            best_match = results[0]
+            ticker = best_match.get("1. symbol")
+            logger.info(f"Resolved '{company_name}' to ticker {ticker} via Alpha Vantage")
+            return ticker
+    except Exception as e:
+        logger.error(f"Error resolving company '{company_name}' to ticker: {e}")
+    
+    return None
+
+
+def enrich_with_tickers(entities: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Enrich entity list with ticker symbols.
+    
+    Args:
+        entities: List of entities from entity_resolver
+        
+    Returns:
+        Enriched entities with ticker information
+    """
+    enriched = []
+    
+    for entity in entities:
+        enriched_entity = entity.copy()
+        
+        if entity.get("type") == "company":
+            company_name = entity.get("text", "")
+            ticker = resolve_company_to_ticker(company_name)
+            if ticker:
+                enriched_entity["ticker"] = ticker
+        
+        enriched.append(enriched_entity)
+    
+    return enriched

backend/app/domain_packs/init_packs.py

@@ -0,0 +1,39 @@
+"""
+Initialize and register domain packs.
+
+This module should be imported at application startup to register
+all available domain packs.
+"""
+
+import logging
+from app.config import os
+
+logger = logging.getLogger(__name__)
+
+
+def init_domain_packs():
+    """Initialize and register all domain packs."""
+    from app.domain_packs.registry import get_registry
+    
+    # Check if finance pack is enabled
+    finance_enabled = os.getenv("FINANCE_DOMAIN_PACK_ENABLED", "true").lower() == "true"
+    
+    if finance_enabled:
+        try:
+            from app.domain_packs.finance import FinanceDomainPack
+            
+            registry = get_registry()
+            finance_pack = FinanceDomainPack()
+            registry.register(finance_pack)
+            
+            logger.info("Finance domain pack registered successfully")
+        except Exception as e:
+            logger.error(f"Failed to register finance domain pack: {e}")
+    else:
+        logger.info("Finance domain pack is disabled")
+    
+    # Future domain packs can be registered here
+    # Example:
+    # if healthcare_enabled:
+    #     from app.domain_packs.healthcare import HealthcareDomainPack
+    #     registry.register(HealthcareDomainPack())

backend/app/domain_packs/registry.py

@@ -0,0 +1,69 @@
+"""
+Domain pack registry for managing and discovering domain packs.
+"""
+
+from typing import Dict, List, Optional
+import logging
+
+from app.domain_packs.base import DomainPack
+
+logger = logging.getLogger(__name__)
+
+
+class DomainPackRegistry:
+    """Registry for managing domain packs."""
+
+    def __init__(self):
+        self._packs: Dict[str, DomainPack] = {}
+
+    def register(self, pack: DomainPack) -> None:
+        """Register a domain pack."""
+        name = pack.name
+        if name in self._packs:
+            logger.warning(f"Domain pack '{name}' is already registered, overwriting")
+        self._packs[name] = pack
+        logger.info(f"Registered domain pack: {name}")
+
+    def get_pack(self, name: str) -> Optional[DomainPack]:
+        """Get a domain pack by name."""
+        return self._packs.get(name)
+
+    def detect_domain(self, query: str) -> Optional[str]:
+        """
+        Detect which domain pack matches the query based on keywords.
+        
+        Args:
+            query: The user's query
+            
+        Returns:
+            Domain pack name if detected, None otherwise
+        """
+        query_lower = query.lower()
+        
+        for name, pack in self._packs.items():
+            for keyword in pack.keywords:
+                if keyword.lower() in query_lower:
+                    logger.info(f"Detected domain '{name}' from keyword '{keyword}'")
+                    return name
+        
+        return None
+
+    def list_packs(self) -> List[str]:
+        """List all registered domain pack names."""
+        return list(self._packs.keys())
+
+    def get_capabilities(self) -> Dict[str, Any]:
+        """Get capabilities of all registered domain packs."""
+        return {
+            name: pack.get_capabilities()
+            for name, pack in self._packs.items()
+        }
+
+
+# Global registry instance
+_registry = DomainPackRegistry()
+
+
+def get_registry() -> DomainPackRegistry:
+    """Get the global domain pack registry."""
+    return _registry

backend/app/main.py

@@ -30,6 +30,10 @@ logger = logging.getLogger(__name__)
 
 app = FastAPI(title="MiroOrg Basic", version=APP_VERSION)
 
+# Initialize domain packs on startup
+from app.domain_packs.init_packs import init_domain_packs
+init_domain_packs()
+
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["http://localhost:3000", "http://127.0.0.1:3000"],

backend/app/schemas.py

@@ -2,6 +2,15 @@ from typing import List, Dict, Any, Optional
 from pydantic import BaseModel, Field
 
 
+class RouteDecision(BaseModel):
+    """Routing decision from Switchboard agent."""
+    task_family: str = Field(..., description="Task family: 'normal' or 'simulation'")
+    domain_pack: str = Field(..., description="Domain pack: 'finance', 'general', 'policy', 'custom'")
+    complexity: str = Field(..., description="Complexity: 'simple', 'medium', 'complex'")
+    execution_mode: str = Field(..., description="Execution mode: 'solo', 'standard', 'deep'")
+    risk_level: str = Field(default="low", description="Risk level: 'low', 'medium', 'high'")
+
+
 class UserTask(BaseModel):
     user_input: str
 

backend/app/services/health_service.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 from importlib.util import find_spec
 from typing import Dict, Any
+import logging
 
 from app.config import (
     APP_VERSION,
@@ -9,7 +10,11 @@ from app.config import (
     PRIMARY_PROVIDER,
     FALLBACK_PROVIDER,
     OPENROUTER_API_KEY,
+    OPENROUTER_BASE_URL,
     OLLAMA_ENABLED,
+    OLLAMA_BASE_URL,
+    OPENAI_API_KEY,
+    OPENAI_BASE_URL,
     TAVILY_API_KEY,
     NEWSAPI_KEY,
     ALPHAVANTAGE_API_KEY,
@@ -17,6 +22,8 @@ from app.config import (
 )
 from app.services.mirofish_client import mirofish_health
 
+logger = logging.getLogger(__name__)
+
 
 REQUIRED_PROMPTS = ["research.txt", "planner.txt", "verifier.txt", "synthesizer.txt"]
 
@@ -33,6 +40,52 @@ def _memory_dir_writable() -> bool:
         return False
 
 
+def _check_provider_health(provider: str) -> Dict[str, Any]:
+    """Check if a provider is configured and reachable."""
+    import httpx
+    
+    provider = provider.lower()
+    
+    if provider == "openrouter":
+        if not OPENROUTER_API_KEY:
+            return {"configured": False, "reachable": False, "error": "API key missing"}
+        try:
+            with httpx.Client(timeout=5) as client:
+                response = client.get(f"{OPENROUTER_BASE_URL}/models", headers={
+                    "Authorization": f"Bearer {OPENROUTER_API_KEY}"
+                })
+                return {"configured": True, "reachable": response.status_code < 500, "status_code": response.status_code}
+        except Exception as e:
+            logger.warning(f"OpenRouter health check failed: {e}")
+            return {"configured": True, "reachable": False, "error": str(e)}
+    
+    elif provider == "ollama":
+        if not OLLAMA_ENABLED:
+            return {"configured": False, "reachable": False, "error": "Ollama disabled"}
+        try:
+            with httpx.Client(timeout=5) as client:
+                response = client.get(f"{OLLAMA_BASE_URL.replace('/api', '')}/api/tags")
+                return {"configured": True, "reachable": response.status_code == 200, "status_code": response.status_code}
+        except Exception as e:
+            logger.warning(f"Ollama health check failed: {e}")
+            return {"configured": True, "reachable": False, "error": str(e)}
+    
+    elif provider == "openai":
+        if not OPENAI_API_KEY:
+            return {"configured": False, "reachable": False, "error": "API key missing"}
+        try:
+            with httpx.Client(timeout=5) as client:
+                response = client.get(f"{OPENAI_BASE_URL}/models", headers={
+                    "Authorization": f"Bearer {OPENAI_API_KEY}"
+                })
+                return {"configured": True, "reachable": response.status_code < 500, "status_code": response.status_code}
+        except Exception as e:
+            logger.warning(f"OpenAI health check failed: {e}")
+            return {"configured": True, "reachable": False, "error": str(e)}
+    
+    return {"configured": False, "reachable": False, "error": "Unknown provider"}
+
+
 def deep_health() -> Dict[str, Any]:
     prompt_checks = {
         prompt: (Path(PROMPTS_DIR) / prompt).exists()
@@ -41,13 +94,23 @@ def deep_health() -> Dict[str, Any]:
 
     mirofish = mirofish_health() if MIROFISH_ENABLED else {"reachable": False, "status_code": None, "body": "disabled"}
 
+    # Check provider health
+    primary_health = _check_provider_health(PRIMARY_PROVIDER)
+    fallback_health = _check_provider_health(FALLBACK_PROVIDER)
+    
+    logger.info(f"Primary provider {PRIMARY_PROVIDER} health: {primary_health}")
+    logger.info(f"Fallback provider {FALLBACK_PROVIDER} health: {fallback_health}")
+
     checks = {
         "memory_dir_writable": _memory_dir_writable(),
         "prompt_files": prompt_checks,
         "prompts_loaded": all(prompt_checks.values()),
         "primary_provider": PRIMARY_PROVIDER,
+        "primary_provider_health": primary_health,
         "fallback_provider": FALLBACK_PROVIDER,
+        "fallback_provider_health": fallback_health,
         "openrouter_key_present": bool(OPENROUTER_API_KEY),
+        "openai_key_present": bool(OPENAI_API_KEY),
         "ollama_enabled": OLLAMA_ENABLED,
         "tavily_enabled": bool(TAVILY_API_KEY),
         "newsapi_enabled": bool(NEWSAPI_KEY),

backend/test_requirements.py

@@ -0,0 +1,259 @@
+"""
+Test script to verify all requirements for Task 7 are met.
+
+Requirements being tested:
+- 4.1: Switchboard classifies using four dimensions (task_family, domain_pack, complexity, execution_mode)
+- 4.2: Simple queries (≤5 words) route to solo mode
+- 4.3: Medium queries (≤25 words) route to standard mode
+- 4.4: Complex queries (>25 words) route to deep mode
+- 4.5: Simulation trigger keywords detected
+- 4.6: Keywords are environment-configurable
+- 4.7: task_family="simulation" when keywords detected
+- 5.6: Domain pack detection using domain registry
+"""
+
+from app.agents.switchboard import decide_route
+from app.domain_packs.init_packs import init_domain_packs
+from app.domain_packs.registry import get_registry
+from app.config import SIMULATION_TRIGGER_KEYWORDS
+
+
+def test_requirement_4_1():
+    """Test Requirement 4.1: Four-dimension classification"""
+    print("\n" + "="*60)
+    print("Testing Requirement 4.1: Four-dimension classification")
+    print("="*60)
+    
+    init_domain_packs()
+    
+    result = decide_route("What is the stock market doing today?")
+    
+    required_keys = ["task_family", "domain_pack", "complexity", "execution_mode"]
+    
+    for key in required_keys:
+        if key in result:
+            print(f"✅ {key}: {result[key]}")
+        else:
+            print(f"❌ Missing dimension: {key}")
+            return False
+    
+    print("✅ Requirement 4.1 PASSED: All four dimensions present")
+    return True
+
+
+def test_requirement_4_2():
+    """Test Requirement 4.2: Simple queries (≤5 words) route to solo mode"""
+    print("\n" + "="*60)
+    print("Testing Requirement 4.2: Simple queries route to solo mode")
+    print("="*60)
+    
+    init_domain_packs()
+    
+    test_cases = [
+        "Hello",
+        "Hi there",
+        "What is this?",
+        "Tell me more",
+        "Show me data",
+    ]
+    
+    all_passed = True
+    for query in test_cases:
+        result = decide_route(query)
+        word_count = len(query.split())
+        
+        if word_count <= 5:
+            if result["complexity"] == "simple" and result["execution_mode"] == "solo":
+                print(f"✅ '{query}' ({word_count} words) -> solo mode")
+            else:
+                print(f"❌ '{query}' ({word_count} words) -> {result['execution_mode']} (expected solo)")
+                all_passed = False
+    
+    if all_passed:
+        print("✅ Requirement 4.2 PASSED")
+    return all_passed
+
+
+def test_requirement_4_3():
+    """Test Requirement 4.3: Medium queries (≤25 words) route to standard mode"""
+    print("\n" + "="*60)
+    print("Testing Requirement 4.3: Medium queries route to standard mode")
+    print("="*60)
+    
+    init_domain_packs()
+    
+    test_cases = [
+        "Can you tell me about the weather today?",
+        "What are the latest developments in artificial intelligence and machine learning?",
+        "I would like to know more about the current economic situation in the United States.",
+    ]
+    
+    all_passed = True
+    for query in test_cases:
+        result = decide_route(query)
+        word_count = len(query.split())
+        
+        if 5 < word_count <= 25:
+            if result["complexity"] == "medium" and result["execution_mode"] == "standard":
+                print(f"✅ '{query[:50]}...' ({word_count} words) -> standard mode")
+            else:
+                print(f"❌ '{query[:50]}...' ({word_count} words) -> {result['execution_mode']} (expected standard)")
+                all_passed = False
+    
+    if all_passed:
+        print("✅ Requirement 4.3 PASSED")
+    return all_passed
+
+
+def test_requirement_4_4():
+    """Test Requirement 4.4: Complex queries (>25 words) route to deep mode"""
+    print("\n" + "="*60)
+    print("Testing Requirement 4.4: Complex queries route to deep mode")
+    print("="*60)
+    
+    init_domain_packs()
+    
+    query = "I need a comprehensive analysis of the current market conditions including economic indicators, sector performance, and potential risks that could impact my investment portfolio over the next quarter with detailed recommendations."
+    
+    result = decide_route(query)
+    word_count = len(query.split())
+    
+    if word_count > 25:
+        if result["complexity"] == "complex" and result["execution_mode"] == "deep":
+            print(f"✅ Query ({word_count} words) -> deep mode")
+            print("✅ Requirement 4.4 PASSED")
+            return True
+        else:
+            print(f"❌ Query ({word_count} words) -> {result['execution_mode']} (expected deep)")
+            return False
+    else:
+        print(f"❌ Test query has only {word_count} words (need >25)")
+        return False
+
+
+def test_requirement_4_5_and_4_7():
+    """Test Requirements 4.5 & 4.7: Simulation keyword detection and task_family setting"""
+    print("\n" + "="*60)
+    print("Testing Requirements 4.5 & 4.7: Simulation keyword detection")
+    print("="*60)
+    
+    init_domain_packs()
+    
+    # Test with various simulation keywords
+    test_cases = [
+        "simulate the market reaction",
+        "predict the outcome",
+        "what if scenario analysis",
+        "model the reaction",
+        "test different scenarios",
+    ]
+    
+    all_passed = True
+    for query in test_cases:
+        result = decide_route(query)
+        
+        if result["task_family"] == "simulation":
+            print(f"✅ '{query}' -> task_family=simulation")
+        else:
+            print(f"❌ '{query}' -> task_family={result['task_family']} (expected simulation)")
+            all_passed = False
+    
+    if all_passed:
+        print("✅ Requirements 4.5 & 4.7 PASSED")
+    return all_passed
+
+
+def test_requirement_4_6():
+    """Test Requirement 4.6: Keywords are environment-configurable"""
+    print("\n" + "="*60)
+    print("Testing Requirement 4.6: Keywords are environment-configurable")
+    print("="*60)
+    
+    # Check that keywords are loaded from config
+    if SIMULATION_TRIGGER_KEYWORDS:
+        print(f"✅ Simulation keywords loaded from config: {len(SIMULATION_TRIGGER_KEYWORDS)} keywords")
+        print(f"   Sample keywords: {SIMULATION_TRIGGER_KEYWORDS[:5]}")
+        print("✅ Requirement 4.6 PASSED")
+        return True
+    else:
+        print("❌ No simulation keywords found in config")
+        return False
+
+
+def test_requirement_5_6():
+    """Test Requirement 5.6: Domain pack detection using domain registry"""
+    print("\n" + "="*60)
+    print("Testing Requirement 5.6: Domain pack detection")
+    print("="*60)
+    
+    init_domain_packs()
+    registry = get_registry()
+    
+    # Test finance domain detection
+    test_cases = [
+        ("What is the stock market doing?", "finance"),
+        ("Tell me about NASDAQ", "finance"),
+        ("How is the weather?", "general"),
+        ("What are earnings reports?", "finance"),
+    ]
+    
+    all_passed = True
+    for query, expected_domain in test_cases:
+        result = decide_route(query)
+        detected = result["domain_pack"]
+        
+        if detected == expected_domain:
+            print(f"✅ '{query}' -> domain={detected}")
+        else:
+            print(f"❌ '{query}' -> domain={detected} (expected {expected_domain})")
+            all_passed = False
+    
+    if all_passed:
+        print("✅ Requirement 5.6 PASSED")
+    return all_passed
+
+
+def run_all_tests():
+    """Run all requirement tests"""
+    print("\n" + "="*60)
+    print("TASK 7 REQUIREMENTS VERIFICATION")
+    print("="*60)
+    
+    tests = [
+        ("4.1", test_requirement_4_1),
+        ("4.2", test_requirement_4_2),
+        ("4.3", test_requirement_4_3),
+        ("4.4", test_requirement_4_4),
+        ("4.5 & 4.7", test_requirement_4_5_and_4_7),
+        ("4.6", test_requirement_4_6),
+        ("5.6", test_requirement_5_6),
+    ]
+    
+    results = {}
+    for req_id, test_func in tests:
+        try:
+            results[req_id] = test_func()
+        except Exception as e:
+            print(f"\n❌ Requirement {req_id} FAILED with exception: {e}")
+            results[req_id] = False
+    
+    # Summary
+    print("\n" + "="*60)
+    print("SUMMARY")
+    print("="*60)
+    
+    passed = sum(1 for v in results.values() if v)
+    total = len(results)
+    
+    for req_id, passed_test in results.items():
+        status = "✅ PASSED" if passed_test else "❌ FAILED"
+        print(f"Requirement {req_id}: {status}")
+    
+    print(f"\nTotal: {passed}/{total} requirements passed")
+    
+    return all(results.values())
+
+
+if __name__ == "__main__":
+    success = run_all_tests()
+    exit(0 if success else 1)

backend/test_switchboard.py

@@ -0,0 +1,125 @@
+"""
+Test script for switchboard routing enhancements.
+"""
+
+from app.agents.switchboard import decide_route
+from app.domain_packs.init_packs import init_domain_packs
+
+
+def test_routing():
+    """Test the enhanced switchboard routing."""
+    
+    # Initialize domain packs
+    init_domain_packs()
+    
+    # Test cases
+    test_cases = [
+        # Simple queries (≤5 words)
+        {
+            "input": "Hello world",
+            "expected": {
+                "complexity": "simple",
+                "execution_mode": "solo",
+                "task_family": "normal",
+                "domain_pack": "general"
+            }
+        },
+        {
+            "input": "What is AAPL?",
+            "expected": {
+                "complexity": "simple",
+                "execution_mode": "solo",
+                "task_family": "normal",
+                "domain_pack": "general"  # AAPL alone doesn't trigger finance keywords
+            }
+        },
+        
+        # Medium queries (≤25 words)
+        {
+            "input": "Can you tell me about the latest stock market trends and what's happening with tech stocks?",
+            "expected": {
+                "complexity": "medium",
+                "execution_mode": "standard",
+                "task_family": "normal",
+                "domain_pack": "finance"
+            }
+        },
+        {
+            "input": "What are the best practices for software development in modern teams?",
+            "expected": {
+                "complexity": "medium",
+                "execution_mode": "standard",
+                "task_family": "normal",
+                "domain_pack": "general"
+            }
+        },
+        
+        # Complex queries (>25 words)
+        {
+            "input": "I need a comprehensive analysis of the current market conditions including economic indicators, sector performance, and potential risks that could impact my investment portfolio over the next quarter.",
+            "expected": {
+                "complexity": "complex",
+                "execution_mode": "deep",
+                "task_family": "normal",
+                "domain_pack": "finance"
+            }
+        },
+        
+        # Simulation queries
+        {
+            "input": "Simulate the market reaction to a Fed rate hike",
+            "expected": {
+                "complexity": "complex",
+                "execution_mode": "deep",
+                "task_family": "simulation",
+                "domain_pack": "finance"
+            }
+        },
+        {
+            "input": "What if the company announces bankruptcy?",
+            "expected": {
+                "complexity": "complex",
+                "execution_mode": "deep",
+                "task_family": "simulation",
+                "domain_pack": "finance"  # "bankruptcy" is a finance keyword
+            }
+        },
+    ]
+    
+    print("Testing Switchboard Routing\n" + "="*50)
+    
+    passed = 0
+    failed = 0
+    
+    for i, test in enumerate(test_cases, 1):
+        user_input = test["input"]
+        expected = test["expected"]
+        
+        result = decide_route(user_input)
+        
+        print(f"\nTest {i}:")
+        print(f"  Input: {user_input}")
+        print(f"  Result: {result}")
+        
+        # Check each expected field
+        test_passed = True
+        for key, expected_value in expected.items():
+            if result.get(key) != expected_value:
+                print(f"  ❌ FAILED: {key} = {result.get(key)}, expected {expected_value}")
+                test_passed = False
+        
+        if test_passed:
+            print(f"  ✅ PASSED")
+            passed += 1
+        else:
+            failed += 1
+    
+    print(f"\n{'='*50}")
+    print(f"Results: {passed} passed, {failed} failed out of {len(test_cases)} tests")
+    
+    return failed == 0
+
+
+if __name__ == "__main__":
+    success = test_routing()
+    exit(0 if success else 1)