feat: MiroOrg v2 full rebuild — conditional graph, new model layer, finance/mirofish nodes, research tools, sentinel layer, frontend overhaul

## Backend
- _model.py: OpenRouter free ladder (Nemotron → Llama 3.3 → DeepSeek R1 → openrouter/free) → Ollama fallback, zero Gemini
- graph.py: conditional LangGraph topology — switchboard forks to mirofish/finance/research, verifier→planner feedback loop (max 2 replans)
- agents/finance_node.py: Alpha Vantage integration (GLOBAL_QUOTE, OVERVIEW, NEWS_SENTIMENT, TOP_GAINERS_LOSERS, REAL_GDP, CPI, INFLATION)
- agents/mirofish_node.py: MiroFish simulation engine client
- agents/api_discovery.py: dynamic API registry for runtime tool expansion
- research.py: Tavily + NewsAPI + knowledge store + API discovery tool stack
- All agents: call_model(messages) + safe_parse(), structured error dicts, never None
- schemas.py: AgentState TypedDict, RunResponse with simulation/finance fields, no chart_data
- memory.py: KnowledgeStore with keyword search over data/knowledge/
- main.py: /debug/state/{case_id} endpoint, structured agent error logging
- routers/finance.py: /finance/ticker, /finance/news/analyze, /finance/headlines
- routers/sentinel.py: full sentinel layer API
- routers/learning.py: learning layer API
- services/sentinel/: watcher, diagnostician, patcher, capability_tracker, sentinel_engine, scheduler
- services/learning/: knowledge_ingestor, knowledge_store, learning_engine, prompt_optimizer, skill_distiller, trust_manager, freshness_manager, scheduler
- prompts/: switchboard, research, planner, verifier, synthesizer, finance, simulation all rewritten

## Frontend
- JANUS interface: art piece intro, Command/Intel Stream/Markets tabs
- Command tab: full 5-agent pipeline with confidence rings, typewriter synthesis
- Intel Stream: live headlines, search, Deep Research button fires full pipeline on any article
- Markets tab: ticker search (Indian NSE/BSE + global), TradingView chart, AI signal, Deep Research
- Sidebar: top nav bar replacing restrictive side rail
- Removed: scam/rumor/trust keyword-based scores (unreliable), TradingView logo issues fixed

## Security
- .env never committed (gitignored)
- .env.example uses placeholder values only
- backend/backend/ stray directory excluded
- Runtime data (memory/*.json, sentinel/*.json, knowledge/*.json) gitignored

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

@@ -353,7 +353,7 @@ The implementation follows 9 phases, each building on the previous while maintai
 
 ### Phase 7: Testing and Documentation
 
-- [~] 25. Write unit tests for core functionality
+- [ ] 25. Write unit tests for core functionality
   - [ ]* 25.1 Write provider abstraction tests
     - Test OpenRouter, Ollama, OpenAI provider calls
     - Test provider fallback behavior
@@ -388,7 +388,7 @@ The implementation follows 9 phases, each building on the previous while maintai
     - Test error handling for disabled MiroFish
     - _Requirements: 8.1, 8.11, 8.12_
 
-- [~] 26. Write property-based tests
+- [ ] 26. Write property-based tests
   - [ ]* 26.1 Write Property 1: Configuration Environment Isolation
     - **Property 1: Configuration Environment Isolation**
     - **Validates: Requirements 1.8, 6.7**
@@ -479,7 +479,7 @@ The implementation follows 9 phases, each building on the previous while maintai
     - Test that new domain packs don't require agent changes
     - Create mock domain pack and verify integration
 
-- [~] 27. Write integration tests
+- [ ] 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

backend/.env.example

@@ -1,76 +1,55 @@
 # ========================================
-# MiroOrg v1.1 - AI Financial Intelligence System
+# MiroOrg v2 — Multi-Agent Intelligence Platform
 # Environment Configuration
 # ========================================
 
 # ---------- Application Version ----------
-APP_VERSION=0.3.0
+APP_VERSION=2.0.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 (Primary — Free Models) ----------
 # Get your API key from: https://openrouter.ai/keys
-OPENROUTER_API_KEY=
-OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
-OPENROUTER_CHAT_MODEL=openrouter/free
-OPENROUTER_REASONER_MODEL=openrouter/free
-OPENROUTER_SITE_URL=http://localhost:3000
-OPENROUTER_APP_NAME=MiroOrg Basic
+# Uses free model ladder: Nemotron → Llama 3.3 → DeepSeek R1 → openrouter/free
+OPENROUTER_API_KEY=your_openrouter_key_here
 
-# ---------- Ollama ----------
-# Ollama provides local LLM inference
+# ---------- Ollama (Fallback — Local) ----------
+# Ollama provides local LLM inference via OpenAI-compatible endpoint
 # 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
+OLLAMA_BASE_URL=http://localhost:11434
+OLLAMA_MODEL=llama3.2
 
-# ---------- External research APIs ----------
+# ---------- External Research APIs ----------
 # Tavily: AI-powered web search API - https://tavily.com
+TAVILY_API_KEY=your_tavily_key_here
+
 # NewsAPI: News aggregation API - https://newsapi.org
+NEWS_API_KEY=your_newsapi_key_here
+
 # 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://
+ALPHA_VANTAGE_API_KEY=your_alpha_vantage_key_here
+
+# ---------- MiroFish Simulation Engine ----------
+# MiroFish handles scenario modelling, agent-based simulation, and outcome projection
+MIROFISH_BASE_URL=http://localhost:8001
 
-# ---------- 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
-MIROFISH_HEALTH_PATH=/health
-MIROFISH_RUN_PATH=/simulation/run
-MIROFISH_STATUS_PATH=/simulation/{id}
-MIROFISH_REPORT_PATH=/simulation/{id}/report
-MIROFISH_CHAT_PATH=/simulation/{id}/chat
+# ---------- API Discovery Layer ----------
+# Dynamic API registry for runtime tool expansion
+API_DISCOVERY_ENDPOINT=http://localhost:8002
 
 # ---------- Routing ----------
 # 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
 
+# ---------- Learning Layer ----------
+LEARNING_ENABLED=true
+KNOWLEDGE_MAX_SIZE_MB=200
+LEARNING_SCHEDULE_INTERVAL=6
+LEARNING_BATCH_SIZE=10
+LEARNING_TOPICS=finance,markets,technology,policy
 
 # ---------- Sentinel Layer ----------
-# Sentinel provides adaptive maintenance and self-healing
 SENTINEL_ENABLED=true
 SENTINEL_CYCLE_INTERVAL_MINUTES=60
 SENTINEL_MAX_DIAGNOSES_PER_CYCLE=5

backend/app/agents/_model.py

@@ -1,176 +1,98 @@
-from typing import Optional, List, Dict, Any
-import logging
+"""
+Unified model client for MiroOrg v2.
+Priority: OpenRouter free → Ollama fallback → raise with diagnostics.
+All tiers use the OpenAI-compatible messages format.
+"""
 
+import os, json, re, logging
 import httpx
-
-from app.config import (
-    PRIMARY_PROVIDER,
-    FALLBACK_PROVIDER,
-    OPENROUTER_API_KEY,
-    OPENROUTER_BASE_URL,
-    OPENROUTER_CHAT_MODEL,
-    OPENROUTER_REASONER_MODEL,
-    OPENROUTER_SITE_URL,
-    OPENROUTER_APP_NAME,
-    OLLAMA_ENABLED,
-    OLLAMA_BASE_URL,
-    OLLAMA_CHAT_MODEL,
-    OLLAMA_REASONER_MODEL,
-    OPENAI_API_KEY,
-    OPENAI_BASE_URL,
-    OPENAI_CHAT_MODEL,
-    OPENAI_REASONER_MODEL,
-)
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
+OPENROUTER_BASE   = "https://openrouter.ai/api/v1"
+OPENROUTER_KEY    = os.getenv("OPENROUTER_API_KEY", "")
 
-class LLMProviderError(Exception):
-    pass
-
-
-def _pick_openrouter_model(mode: str) -> str:
-    return OPENROUTER_REASONER_MODEL if mode == "reasoner" else OPENROUTER_CHAT_MODEL
-
-
-def _pick_ollama_model(mode: str) -> str:
-    return OLLAMA_REASONER_MODEL if mode == "reasoner" else OLLAMA_CHAT_MODEL
-
+# Pinned free models in preference order (all have :free suffix = zero cost)
+FREE_MODEL_LADDER = [
+    "nvidia/llama-3.1-nemotron-ultra-253b:free",   # best reasoning, large context
+    "meta-llama/llama-3.3-70b-instruct:free",       # reliable, GPT-4 class
+    "deepseek/deepseek-r1:free",                    # strong chain-of-thought
+    "openrouter/free",                              # random free as last resort
+]
 
-def _pick_openai_model(mode: str) -> str:
-    return OPENAI_REASONER_MODEL if mode == "reasoner" else OPENAI_CHAT_MODEL
+OLLAMA_BASE       = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+OLLAMA_MODEL      = os.getenv("OLLAMA_MODEL", "llama3.2")   # user configures
+TIMEOUT           = 120
 
 
-def _build_messages(prompt: str, system_prompt: Optional[str] = None) -> List[Dict[str, str]]:
-    messages: List[Dict[str, str]] = []
-    if system_prompt:
-        messages.append({"role": "system", "content": system_prompt})
-    messages.append({"role": "user", "content": prompt})
-    return messages
-
-
-def _call_openrouter(prompt: str, mode: str = "chat", system_prompt: Optional[str] = None) -> str:
-    if not OPENROUTER_API_KEY:
-        raise LLMProviderError("OPENROUTER_API_KEY is missing.")
-
+def _openrouter_call(messages: list[dict], model: str, **kwargs) -> str:
+    """Single call to OpenRouter. Raises on non-200."""
     headers = {
-        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Authorization": f"Bearer {OPENROUTER_KEY}",
+        "HTTP-Referer": "https://miroorg.local",
+        "X-Title": "MiroOrg v2",
         "Content-Type": "application/json",
     }
-    if OPENROUTER_SITE_URL:
-        headers["HTTP-Referer"] = OPENROUTER_SITE_URL
-    if OPENROUTER_APP_NAME:
-        headers["X-Title"] = OPENROUTER_APP_NAME
-
-    payload = {
-        "model": _pick_openrouter_model(mode),
-        "messages": _build_messages(prompt, system_prompt=system_prompt),
-    }
-
-    with httpx.Client(timeout=90) as client:
-        response = client.post(f"{OPENROUTER_BASE_URL}/chat/completions", headers=headers, json=payload)
-
-    if response.status_code >= 400:
-        raise LLMProviderError(f"OpenRouter error {response.status_code}: {response.text}")
-
-    data = response.json()
-    return data["choices"][0]["message"]["content"].strip()
-
-
-def _call_ollama(prompt: str, mode: str = "chat", system_prompt: Optional[str] = None) -> str:
-    if not OLLAMA_ENABLED:
-        raise LLMProviderError("Ollama fallback is disabled.")
-
-    payload = {
-        "model": _pick_ollama_model(mode),
-        "messages": _build_messages(prompt, system_prompt=system_prompt),
-        "stream": False,
-    }
-
-    with httpx.Client(timeout=120) as client:
-        response = client.post(f"{OLLAMA_BASE_URL}/chat", json=payload)
-
-    if response.status_code >= 400:
-        raise LLMProviderError(f"Ollama error {response.status_code}: {response.text}")
-
-    data = response.json()
-    message = data.get("message", {})
-    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",
-    system_prompt: Optional[str] = None,
-    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":
-            result = _call_openrouter(prompt, mode=mode, system_prompt=system_prompt)
-            logger.info(f"Provider {provider} succeeded")
-            return result
-        if provider == "ollama":
-            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}")
+    body = {"model": model, "messages": messages, "max_tokens": 2048, **kwargs}
+    r = httpx.post(f"{OPENROUTER_BASE}/chat/completions",
+                   headers=headers, json=body, timeout=TIMEOUT)
+    r.raise_for_status()
+    return r.json()["choices"][0]["message"]["content"]
+
+
+def _ollama_call(messages: list[dict], **kwargs) -> str:
+    """Fallback: Ollama local via OpenAI-compatible endpoint."""
+    body = {"model": OLLAMA_MODEL, "messages": messages, "stream": False}
+    r = httpx.post(f"{OLLAMA_BASE}/v1/chat/completions",
+                   json=body, timeout=TIMEOUT)
+    r.raise_for_status()
+    return r.json()["choices"][0]["message"]["content"]
+
+
+def call_model(messages: list[dict], **kwargs) -> str:
+    """
+    Try OpenRouter free models in ladder order, then Ollama.
+    Returns raw text. Never returns None — raises RuntimeError with full diagnostics
+    so the caller can write a structured error dict instead of silently propagating None.
+    """
+    errors = []
+    for model in FREE_MODEL_LADDER:
         try:
-            if fallback == "ollama":
-                result = _call_ollama(prompt, mode=mode, system_prompt=system_prompt)
-                logger.info(f"Fallback provider {fallback} succeeded")
-                return result
-            if fallback == "openrouter":
-                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}"
-            )
+            result = _openrouter_call(messages, model, **kwargs)
+            logger.info(f"Model call succeeded: {model}")
+            return result
+        except Exception as e:
+            errors.append(f"OpenRouter [{model}]: {e}")
+            logger.warning(f"OpenRouter [{model}] failed: {e}")
 
-        logger.error(f"Primary provider {provider} failed with no valid fallback")
-        raise LLMProviderError(str(primary_error))
+    # Ollama fallback
+    try:
+        result = _ollama_call(messages, **kwargs)
+        logger.info(f"Ollama fallback succeeded: {OLLAMA_MODEL}")
+        return result
+    except Exception as e:
+        errors.append(f"Ollama [{OLLAMA_MODEL}]: {e}")
+        logger.error(f"Ollama fallback failed: {e}")
+
+    raise RuntimeError("All model tiers failed:\n" + "\n".join(errors))
+
+
+def safe_parse(text: str) -> dict:
+    """
+    Strip markdown fences, attempt JSON parse.
+    On failure returns a structured error dict — NEVER returns None.
+    Callers must check for 'error' key in the result.
+    """
+    cleaned = re.sub(r"```(?:json)?|```", "", text).strip()
+    try:
+        return json.loads(cleaned)
+    except json.JSONDecodeError:
+        # Try extracting the first JSON-like block
+        match = re.search(r"\{.*\}", cleaned, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group())
+            except json.JSONDecodeError:
+                pass
+    return {"error": "parse_failed", "raw": text[:800]}

backend/app/agents/api_discovery.py

@@ -0,0 +1,49 @@
+"""
+API Discovery Layer client.
+Allows agents to query a registry of available APIs and invoke them dynamically.
+This enables MiroOrg to expand its tool set without code changes.
+"""
+import httpx, os
+import logging
+
+logger = logging.getLogger(__name__)
+
+DISCOVERY_BASE = os.getenv("API_DISCOVERY_ENDPOINT", "http://localhost:8002")
+
+
+def discover_apis(query: str, domain: str = "general") -> list[dict]:
+    """
+    Returns a list of available API descriptors relevant to the query.
+    Each descriptor: {name, endpoint, description, params_schema, auth_type}
+    """
+    try:
+        r = httpx.get(f"{DISCOVERY_BASE}/search", params={
+            "q": query, "domain": domain,
+        }, timeout=10)
+        r.raise_for_status()
+        return r.json().get("apis", [])
+    except Exception as e:
+        logger.debug(f"API Discovery unavailable: {e}")
+        return []
+
+
+def call_discovered_api(descriptor: dict, params: dict) -> dict:
+    """
+    Calls an API found via discovery. Handles auth injection from env.
+    Returns raw response dict or {"error": ...} on failure.
+    """
+    auth_type = descriptor.get("auth_type", "none")
+    headers = {}
+    if auth_type == "bearer":
+        env_key = descriptor.get("env_key", "")
+        token = os.getenv(env_key, "")
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+
+    try:
+        r = httpx.get(descriptor["endpoint"], params=params,
+                      headers=headers, timeout=30)
+        r.raise_for_status()
+        return r.json()
+    except Exception as e:
+        return {"error": str(e)}

backend/app/agents/finance_node.py

@@ -0,0 +1,118 @@
+"""
+Finance data node — Alpha Vantage integration.
+Fetches market data, fundamentals, sentiment, and economic indicators.
+No chart rendering — raw structured data only.
+"""
+import httpx, os, re, logging
+from app.agents._model import call_model, safe_parse
+from app.config import load_prompt
+
+logger = logging.getLogger(__name__)
+
+AV_BASE = "https://www.alphavantage.co/query"
+AV_KEY  = os.getenv("ALPHA_VANTAGE_API_KEY", os.getenv("ALPHAVANTAGE_API_KEY", "demo"))
+
+
+def av_get(function: str, **params) -> dict:
+    """Single Alpha Vantage GET call. Returns parsed JSON or {"error": ...}."""
+    try:
+        r = httpx.get(AV_BASE, params={"function": function, "apikey": AV_KEY, **params},
+                      timeout=20)
+        r.raise_for_status()
+        data = r.json()
+        # AV returns {"Information": "..."} when rate-limited or key is invalid
+        if "Information" in data or "Note" in data:
+            return {"error": data.get("Information") or data.get("Note")}
+        return data
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def extract_ticker(intent: str) -> str | None:
+    """
+    Try to pull a ticker symbol from the intent string.
+    Looks for uppercase sequences of 1–5 letters (e.g. AAPL, MSFT, TSLA).
+    Falls back to SYMBOL_SEARCH if a company name is detected.
+    """
+    match = re.search(r'\b([A-Z]{1,5})\b', intent)
+    if match:
+        return match.group(1)
+    return None
+
+
+def resolve_ticker(intent: str) -> str | None:
+    """Use SYMBOL_SEARCH to find a ticker from a company name in the intent."""
+    result = av_get("SYMBOL_SEARCH", keywords=intent)
+    matches = result.get("bestMatches", [])
+    if matches:
+        return matches[0].get("1. symbol")
+    return None
+
+
+def run(state: dict) -> dict:
+    route  = state.get("route", {})
+    intent = route.get("intent", "")
+    domain = route.get("domain", "finance")
+
+    gathered = {}
+
+    # Step 1: resolve ticker if query is about a specific stock
+    ticker = extract_ticker(intent) or resolve_ticker(intent)
+
+    if ticker:
+        # Quote (current price, change, volume) — no OHLCV chart data
+        quote = av_get("GLOBAL_QUOTE", symbol=ticker)
+        gathered["quote"] = quote.get("Global Quote", quote)
+
+        # Fundamentals (P/E, market cap, sector, EPS, etc.)
+        overview = av_get("OVERVIEW", symbol=ticker)
+        # Strip raw price series fields to keep payload clean
+        for drop_key in ["52WeekHigh", "52WeekLow", "50DayMovingAverage",
+                          "200DayMovingAverage", "AnalystTargetPrice"]:
+            overview.pop(drop_key, None)
+        gathered["fundamentals"] = overview
+
+        # News & sentiment for this ticker
+        news = av_get("NEWS_SENTIMENT", tickers=ticker, limit=5)
+        gathered["news_sentiment"] = news.get("feed", [])[:5]
+
+    else:
+        # No specific ticker — fetch macro / market-wide data
+        gathered["top_movers"]   = av_get("TOP_GAINERS_LOSERS")
+        gathered["news_general"] = av_get("NEWS_SENTIMENT", limit=5).get("feed", [])[:5]
+
+    # Step 3: if macro / economic query, add indicators
+    macro_keywords = ["gdp", "inflation", "cpi", "interest rate", "federal", "economy",
+                      "recession", "growth", "unemployment"]
+    if any(kw in intent.lower() for kw in macro_keywords):
+        gathered["gdp"]       = av_get("REAL_GDP", interval="annual")
+        gathered["cpi"]       = av_get("CPI", interval="monthly")
+        gathered["inflation"] = av_get("INFLATION")
+
+    # Step 4: LLM interprets the gathered data
+    prompt = load_prompt("finance")
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": (
+            f"User intent: {intent}\n\n"
+            f"Alpha Vantage data:\n{gathered}\n\n"
+            "Analyse this financial data and return ONLY valid JSON:\n"
+            "{\n"
+            "  \"ticker\": \"<symbol or null>\",\n"
+            "  \"signals\": [\"<signal 1>\", \"<signal 2>\"],\n"
+            "  \"risks\": [\"<risk 1>\"],\n"
+            "  \"sentiment\": \"bullish | bearish | neutral\",\n"
+            "  \"key_metrics\": {\"<metric>\": \"<value>\"},\n"
+            "  \"data_quality\": \"good | partial | limited\",\n"
+            "  \"summary\": \"<2-3 sentence plain English summary>\"\n"
+            "}\n"
+            "Do NOT include chart data, OHLCV arrays, image URLs, or price history."
+        )},
+    ]
+    try:
+        result = safe_parse(call_model(messages))
+    except RuntimeError as e:
+        logger.error(f"[AGENT ERROR] finance_node: {e}")
+        result = {"status": "error", "reason": str(e)}
+
+    return {**state, "finance": result}

backend/app/agents/mirofish_node.py

@@ -0,0 +1,55 @@
+"""
+Mirofish simulation node.
+Calls the Mirofish local simulation service and injects results into agent state.
+Mirofish handles scenario modelling, agent-based simulation, and outcome projection.
+"""
+import httpx, os, logging
+from app.agents._model import call_model, safe_parse
+from app.config import load_prompt
+
+logger = logging.getLogger(__name__)
+
+MIROFISH_BASE = os.getenv("MIROFISH_BASE_URL", "http://localhost:8001")
+
+
+def run_simulation(scenario: dict) -> dict:
+    r = httpx.post(f"{MIROFISH_BASE}/simulate", json=scenario, timeout=60)
+    r.raise_for_status()
+    return r.json()
+
+
+def run(state: dict) -> dict:
+    route = state.get("route", {})
+    intent = route.get("intent", "")
+    sub_tasks = route.get("sub_tasks", [])
+
+    scenario = {
+        "intent": intent,
+        "tasks": sub_tasks,
+        "complexity": route.get("complexity", "medium"),
+        "domain": route.get("domain", "general"),
+    }
+
+    try:
+        sim_result = run_simulation(scenario)
+    except Exception as e:
+        logger.warning(f"Mirofish unavailable: {e}")
+        sim_result = {"error": str(e), "note": "Mirofish unavailable, continuing without simulation"}
+
+    prompt = load_prompt("simulation")
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": (
+            f"Simulation results from Mirofish:\n{sim_result}\n\n"
+            f"Original intent: {intent}\n\n"
+            "Interpret these simulation results. Return ONLY valid JSON with: "
+            "key_findings, confidence, scenarios_run, recommended_path, caveats."
+        )},
+    ]
+    try:
+        result = safe_parse(call_model(messages))
+    except RuntimeError as e:
+        logger.error(f"[AGENT ERROR] mirofish_node: {e}")
+        result = {"status": "error", "reason": str(e)}
+
+    return {**state, "simulation": result}

backend/app/agents/planner.py

@@ -1,68 +1,68 @@
-import re
-from app.agents._model import call_model, LLMProviderError
-from app.config import SIMULATION_TRIGGER_KEYWORDS
+"""
+Planner agent — MiroOrg v2.
+Accepts Switchboard route + Research output + (optionally) Simulation and Finance outputs.
+Produces a structured plan with steps, dependencies, and risk assessment.
+"""
 import logging
+from app.agents._model import call_model, safe_parse
+from app.config import load_prompt
 
 logger = logging.getLogger(__name__)
 
-_CONFIDENCE_PATTERN = re.compile(r'Confidence:\s*([\d.]+)', re.IGNORECASE)
 
+def run(state: dict) -> dict:
+    route = state.get("route", {})
+    research = state.get("research", {})
+    simulation = state.get("simulation", {})
+    finance = state.get("finance", {})
+    replan_count = state.get("replan_count", 0)
+    verifier = state.get("verifier", {})
 
-def _extract_confidence(text: str, default: float = 0.5) -> float:
-    """Extract confidence score from structured LLM output."""
-    match = _CONFIDENCE_PATTERN.search(text)
-    if match:
-        try:
-            score = float(match.group(1))
-            return max(0.0, min(1.0, score))
-        except ValueError:
-            pass
-    return default
+    prompt = load_prompt("planner")
 
+    # Build context with all available upstream data
+    context_parts = [
+        f"Route: {route}",
+        f"Research findings: {research}",
+    ]
+    if simulation:
+        context_parts.append(f"Simulation results: {simulation}")
+    if finance:
+        context_parts.append(f"Finance data: {finance}")
+    if replan_count > 0 and verifier:
+        context_parts.append(f"REPLAN #{replan_count} — Verifier feedback: {verifier}")
 
-def run_planner(user_input: str, research_output: str, prompt_template: str) -> dict:
-    # Detect if simulation mode would be appropriate
-    user_lower = user_input.lower()
-    simulation_suggested = any(keyword in user_lower for keyword in SIMULATION_TRIGGER_KEYWORDS)
-    
-    # Check for scenario/prediction patterns in research
-    research_lower = research_output.lower()
-    scenario_patterns = ["scenario", "what if", "predict", "forecast", "impact", "reaction",
-                         "what would", "how would", "could affect", "might happen"]
-    has_scenario_context = any(pattern in research_lower for pattern in scenario_patterns)
-    
-    # Also check user input for scenario patterns
-    user_scenario_patterns = ["what would", "what if", "how would", "what happens",
-                              "what could", "imagine", "suppose", "hypothetical"]
-    has_user_scenario = any(pattern in user_lower for pattern in user_scenario_patterns)
-    
-    if (has_scenario_context or has_user_scenario) and not simulation_suggested:
-        simulation_suggested = True
-        logger.info("Planner detected scenario analysis opportunity - suggesting simulation mode")
-    
-    prompt = (
-        f"{prompt_template}\n\n"
-        f"User Request:\n{user_input}\n\n"
-        f"Research Packet:\n{research_output}"
-    )
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": (
+            f"User request: {state.get('user_input', route.get('intent', ''))}\n\n"
+            + "\n\n".join(context_parts)
+            + "\n\nProduce structured JSON output:\n"
+            "{\n"
+            "  \"plan_steps\": [\"<step 1>\", \"<step 2>\"],\n"
+            "  \"resources_needed\": [\"<resource 1>\"],\n"
+            "  \"dependencies\": [\"<dependency 1>\"],\n"
+            "  \"risk_level\": \"low | medium | high\",\n"
+            "  \"estimated_output\": \"<brief description of expected output>\""
+            + (",\n  \"replan_reason\": \"<why replanning>\"" if replan_count > 0 else "")
+            + "\n}\n"
+        )},
+    ]
 
     try:
-        text = call_model(prompt, mode="chat")
-        confidence = _extract_confidence(text, default=0.70)
-        
-        return {
-            "agent": "planner",
-            "summary": text,
-            "details": {
-                "model_mode": "chat",
-                "simulation_suggested": simulation_suggested
-            },
-            "confidence": confidence,
-        }
-    except LLMProviderError as e:
-        return {
-            "agent": "planner",
-            "summary": f"Error: {str(e)}",
-            "details": {"error_type": "provider_error"},
-            "confidence": 0.0,
+        result = safe_parse(call_model(messages))
+    except RuntimeError as e:
+        logger.error(f"[AGENT ERROR] planner: {e}")
+        result = {"status": "error", "reason": str(e)}
+
+    if "error" in result:
+        logger.warning(f"[AGENT ERROR] planner: {result.get('error')}")
+        result = {
+            "plan_steps": ["Unable to generate plan due to error"],
+            "resources_needed": [],
+            "dependencies": [],
+            "risk_level": "high",
+            "estimated_output": "Error in planning phase",
         }
+
+    return {**state, "planner": result}

backend/app/agents/research.py

@@ -1,90 +1,149 @@
-import re
-from app.agents._model import call_model, LLMProviderError
-from app.services.external_sources import build_external_context
-from app.domain_packs.registry import get_registry
-import logging
+"""
+Research agent — MiroOrg v2.
+Uses Tavily web search, News API, Knowledge Store, and API Discovery
+to gather context before calling the LLM for structured analysis.
+"""
+import os, logging
+import httpx
+from app.agents._model import call_model, safe_parse
+from app.agents.api_discovery import discover_apis, call_discovered_api
+from app.config import load_prompt
+from app.memory import knowledge_store
 
 logger = logging.getLogger(__name__)
 
-_CONFIDENCE_PATTERN = re.compile(r'Confidence:\s*([\d.]+)', re.IGNORECASE)
-
-
-def _extract_confidence(text: str, default: float = 0.5) -> float:
-    """Extract confidence score from structured LLM output."""
-    match = _CONFIDENCE_PATTERN.search(text)
-    if match:
-        try:
-            score = float(match.group(1))
-            return max(0.0, min(1.0, score))
-        except ValueError:
-            pass
-    return default
-
-
-def run_research(user_input: str, prompt_template: str) -> dict:
-    external_context = build_external_context(user_input)
-    
-    # Detect domain and enhance research with domain pack capabilities
-    registry = get_registry()
-    detected_domain = registry.detect_domain(user_input)
-    
-    domain_enhanced_context = {}
-    if detected_domain:
-        logger.info(f"Enhancing research with domain pack: {detected_domain}")
-        pack = registry.get_pack(detected_domain)
-        if pack:
-            try:
-                base_context = {
-                    "user_input": user_input,
-                    "external_context": external_context
-                }
-                domain_enhanced_context = pack.enhance_research(user_input, base_context)
-                logger.info(f"Domain enhancement successful: {detected_domain}")
-            except Exception as e:
-                logger.warning(f"Domain enhancement failed for {detected_domain}: {e}")
-                domain_enhanced_context = {}
-    
-    # Build enhanced prompt with domain context
-    domain_context_str = ""
-    if domain_enhanced_context:
-        domain_context_str = "\n\nDomain-Specific Context:\n"
-        for key, value in domain_enhanced_context.items():
-            if value:
-                domain_context_str += f"{key}: {value}\n"
-
-    prompt = (
-        f"{prompt_template}\n\n"
-        f"User Request:\n{user_input}\n\n"
-        f"External Context:\n{external_context}"
-        f"{domain_context_str}"
-    )
+TAVILY_API_KEY = os.getenv("TAVILY_API_KEY", "")
+NEWS_API_KEY = os.getenv("NEWS_API_KEY", os.getenv("NEWSAPI_KEY", ""))
 
+
+# ─── Tool: Tavily Web Search ─────────────────────────────────────────────────
+
+def tavily_search(query: str, max_results: int = 5) -> list[dict]:
+    """Returns list of {title, url, content} dicts."""
+    if not TAVILY_API_KEY:
+        return []
     try:
-        text = call_model(prompt, mode="chat")
-        
-        # Extract structured entities from domain enhancement
-        entities = domain_enhanced_context.get("entities", []) if domain_enhanced_context else []
-        tickers = domain_enhanced_context.get("tickers", []) if domain_enhanced_context else []
-        
-        # Extract confidence from LLM output (our prompt asks for it)
-        confidence = _extract_confidence(text, default=0.65)
-        
-        return {
-            "agent": "research",
-            "summary": text,
-            "details": {
-                "external_context_used": external_context != "No external API context available.",
-                "domain_pack": detected_domain or "general",
-                "entities": entities,
-                "tickers": tickers,
-                "domain_enhanced": bool(domain_enhanced_context)
-            },
-            "confidence": confidence,
-        }
-    except LLMProviderError as e:
-        return {
-            "agent": "research",
-            "summary": f"Error: {str(e)}",
-            "details": {"error_type": "provider_error"},
+        r = httpx.post("https://api.tavily.com/search", json={
+            "api_key": TAVILY_API_KEY,
+            "query": query,
+            "search_depth": "advanced",
+            "max_results": max_results,
+            "include_raw_content": False,
+        }, timeout=30)
+        r.raise_for_status()
+        return r.json().get("results", [])
+    except Exception as e:
+        logger.warning(f"Tavily search failed: {e}")
+        return []
+
+
+# ─── Tool: News API ──────────────────────────────────────────────────────────
+
+def news_search(query: str, max_articles: int = 5) -> list[dict]:
+    """Returns list of {title, source, publishedAt, description} dicts."""
+    if not NEWS_API_KEY:
+        return []
+    try:
+        r = httpx.get("https://newsapi.org/v2/everything", params={
+            "apiKey": NEWS_API_KEY, "q": query, "sortBy": "publishedAt",
+            "language": "en", "pageSize": max_articles,
+        }, timeout=30)
+        r.raise_for_status()
+        return [
+            {"title": a["title"], "source": a["source"]["name"],
+             "publishedAt": a["publishedAt"], "description": a["description"]}
+            for a in r.json().get("articles", [])
+        ]
+    except Exception as e:
+        logger.warning(f"News search failed: {e}")
+        return []
+
+
+# ─── Research Node ────────────────────────────────────────────────────────────
+
+def run(state: dict) -> dict:
+    route = state.get("route", {})
+    intent = route.get("intent", state.get("user_input", ""))
+    domain = route.get("domain", "general")
+
+    context_blocks = []
+
+    # Step 1: Tavily web search
+    web_results = tavily_search(intent)
+    if web_results:
+        formatted = "\n".join(
+            f"- {r.get('title', 'Untitled')}\n  URL: {r.get('url', '')}\n  {r.get('content', '')[:300]}"
+            for r in web_results
+        )
+        context_blocks.append(f"[Web Search Results]\n{formatted}")
+
+    # Step 2: News API (if requires_news or finance domain)
+    if route.get("requires_news") or domain == "finance":
+        news = news_search(intent)
+        if news:
+            formatted = "\n".join(
+                f"- {a['title']} ({a['source']}, {a['publishedAt']})\n  {a.get('description', '')[:200]}"
+                for a in news
+            )
+            context_blocks.append(f"[News Articles]\n{formatted}")
+
+    # Step 3: Knowledge store
+    knowledge = knowledge_store.search(intent, domain=domain)
+    if knowledge:
+        formatted = "\n".join(
+            f"- {k.get('text', k.get('content', ''))[:300]}"
+            for k in knowledge
+        )
+        context_blocks.append(f"[Knowledge Base]\n{formatted}")
+
+    # Step 4: API Discovery
+    discovered = discover_apis(query=intent, domain=domain)
+    for api in discovered[:3]:
+        extra_data = call_discovered_api(api, {"q": intent})
+        context_blocks.append(f"[{api.get('name', 'Discovered API')}]: {extra_data}")
+
+    # Step 5: Include simulation and finance data if available in state
+    if state.get("simulation"):
+        context_blocks.append(f"[Simulation Results]\n{state['simulation']}")
+    if state.get("finance"):
+        context_blocks.append(f"[Finance Data]\n{state['finance']}")
+
+    # Build context block
+    context_str = "\n\n".join(context_blocks) if context_blocks else "No external context retrieved."
+
+    # Step 6: Call LLM
+    prompt = load_prompt("research")
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": (
+            f"User request: {state.get('user_input', intent)}\n\n"
+            f"[CONTEXT]\n{context_str}\n\n"
+            "Produce structured JSON output:\n"
+            "{\n"
+            "  \"summary\": \"<comprehensive analysis>\",\n"
+            "  \"key_facts\": [\"<fact 1>\", \"<fact 2>\"],\n"
+            "  \"sources\": [\"<source 1>\", \"<source 2>\"],\n"
+            "  \"gaps\": [\"<what's missing>\"],\n"
+            "  \"confidence\": 0.0-1.0\n"
+            "}\n"
+            "If context is empty, return gaps: ['no data retrieved']. Do not hallucinate."
+        )},
+    ]
+
+    try:
+        result = safe_parse(call_model(messages))
+    except RuntimeError as e:
+        logger.error(f"[AGENT ERROR] research: {e}")
+        result = {"status": "error", "reason": str(e)}
+
+    if "error" in result:
+        logger.warning(f"[AGENT ERROR] research: {result.get('error')}")
+        result = {
+            "summary": "Research encountered an error during analysis.",
+            "key_facts": [],
+            "sources": [],
+            "gaps": ["analysis failed"],
             "confidence": 0.0,
         }
+
+    return {**state, "research": result}

backend/app/agents/switchboard.py

@@ -1,82 +1,55 @@
-from app.config import SIMULATION_TRIGGER_KEYWORDS
-from app.domain_packs.registry import get_registry
+"""
+Switchboard — intelligence router for MiroOrg v2.
+Classifies user input and produces structured routing decisions using LLM.
+"""
+import logging
+from app.agents._model import call_model, safe_parse
+from app.config import load_prompt
 
+logger = logging.getLogger(__name__)
 
-def decide_route(user_input: str) -> dict:
+
+def run(state: dict) -> 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
+    Analyse the user's input and produce a routing structure.
+    Uses LLM for intent classification with structured JSON output.
     """
-    text = user_input.strip()
-    lower = text.lower()
-    words = len(text.split())
-
-    # Dimension 1: Task family (simulation detection)
-    # Check configured keywords
-    task_family = "simulation" if any(k in lower for k in SIMULATION_TRIGGER_KEYWORDS) else "normal"
+    user_input = state.get("user_input", "")
+    prompt = load_prompt("switchboard")
 
-    # Additional scenario patterns that should also trigger deep analysis
-    scenario_patterns = [
-        "what would", "what if", "how would", "what happens if",
-        "what could", "imagine if", "suppose", "hypothetical",
-        "could affect", "might impact", "would react",
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": user_input},
     ]
-    is_speculative = any(p in lower for p in scenario_patterns)
-
-    # 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 and nature
-    if task_family == "simulation":
-        complexity = "complex"
-    elif is_speculative:
-        # Speculative questions always get at least medium complexity
-        complexity = "complex" if words > 15 else "medium"
-    elif words <= 5:
-        complexity = "simple"
-    elif words <= 25:
-        complexity = "medium"
-    else:
-        complexity = "complex"
-
-    # Dimension 4: Execution mode based on complexity and nature
-    if task_family == "simulation":
-        execution_mode = "deep"
-    elif is_speculative:
-        # Speculative questions always get deep mode (verifier should check uncertainty)
-        execution_mode = "deep"
-    elif complexity == "simple":
-        execution_mode = "solo"
-    elif complexity == "medium":
-        execution_mode = "standard"
-    else:
-        execution_mode = "deep"
 
-    # Risk level
-    if execution_mode == "deep":
-        risk_level = "medium"
-    elif is_speculative:
-        risk_level = "medium"
+    try:
+        result = safe_parse(call_model(messages))
+    except RuntimeError as e:
+        logger.error(f"[AGENT ERROR] switchboard: {e}")
+        result = {"status": "error", "reason": str(e)}
+
+    # Ensure all required fields exist with defaults
+    if "error" in result:
+        logger.warning(f"[AGENT ERROR] switchboard: {result.get('error')}")
+        result = {
+            "domain": "general",
+            "complexity": "medium",
+            "intent": user_input[:200],
+            "sub_tasks": [user_input[:200]],
+            "requires_simulation": False,
+            "requires_finance_data": False,
+            "requires_news": False,
+            "confidence": 0.3,
+        }
     else:
-        risk_level = "low"
-
-    return {
-        "task_family": task_family,
-        "domain_pack": domain_pack,
-        "complexity": complexity,
-        "execution_mode": execution_mode,
-        "risk_level": risk_level,
-    }
+        # Fill in any missing fields with safe defaults
+        result.setdefault("domain", "general")
+        result.setdefault("complexity", "medium")
+        result.setdefault("intent", user_input[:200])
+        result.setdefault("sub_tasks", [user_input[:200]])
+        result.setdefault("requires_simulation", False)
+        result.setdefault("requires_finance_data", False)
+        result.setdefault("requires_news", False)
+        result.setdefault("confidence", 0.5)
+
+    return {**state, "route": result}

backend/app/agents/synthesizer.py

@@ -1,100 +1,70 @@
-import re
-from app.agents._model import call_model, LLMProviderError
+"""
+Synthesizer agent — MiroOrg v2.
+Final voice in the pipeline. Accepts all upstream outputs and produces
+the definitive response the user sees.
+"""
 import logging
+from app.agents._model import call_model, safe_parse
+from app.config import load_prompt
 
 logger = logging.getLogger(__name__)
 
-_CONFIDENCE_PATTERN = re.compile(r'Confidence:\s*([\d.]+)', re.IGNORECASE)
-_UNCERTAINTY_PATTERN = re.compile(r'Uncertainty\s*Level:\s*(HIGH|MEDIUM|LOW)', re.IGNORECASE)
 
+def run(state: dict) -> dict:
+    route = state.get("route", {})
+    research = state.get("research", {})
+    planner = state.get("planner", {})
+    verifier = state.get("verifier", {})
+    simulation = state.get("simulation", {})
+    finance = state.get("finance", {})
+    replan_count = state.get("replan_count", 0)
 
-def _extract_confidence(text: str, default: float = 0.5) -> float:
-    """Extract confidence score from structured LLM output."""
-    match = _CONFIDENCE_PATTERN.search(text)
-    if match:
-        try:
-            score = float(match.group(1))
-            return max(0.0, min(1.0, score))
-        except ValueError:
-            pass
-    return default
+    prompt = load_prompt("synthesizer")
 
+    # Build comprehensive context
+    context_parts = [
+        f"Route: {route}",
+        f"Research: {research}",
+        f"Planner: {planner}",
+        f"Verifier: {verifier}",
+    ]
+    if simulation:
+        context_parts.append(f"Simulation: {simulation}")
+    if finance:
+        context_parts.append(f"Finance: {finance}")
+    if not verifier.get("passed", True) and replan_count >= 2:
+        context_parts.append("NOTE: Verifier did not fully pass and replan limit was reached. Acknowledge limitations.")
 
-def _extract_uncertainty(text: str) -> str:
-    """Extract uncertainty level from structured LLM output."""
-    match = _UNCERTAINTY_PATTERN.search(text)
-    if match:
-        return match.group(1).upper()
-    
-    # Fallback heuristic
-    text_lower = text.lower()
-    uncertainty_indicators = ["uncertain", "unclear", "missing", "unverified",
-                              "assumption", "unknown", "speculative", "conflicting",
-                              "limited evidence", "cannot confirm"]
-    count = sum(1 for indicator in uncertainty_indicators if indicator in text_lower)
-    
-    if count >= 4:
-        return "HIGH"
-    elif count >= 2:
-        return "MEDIUM"
-    return "LOW"
-
-
-def run_synthesizer(
-    user_input: str,
-    research_output: str,
-    planner_output: str,
-    verifier_output: str,
-    prompt_template: str
-) -> dict:
-    # Extract uncertainty level from verifier output (or synthesizer will self-assess)
-    uncertainty_level = _extract_uncertainty(verifier_output)
-    
-    # Check if simulation was recommended by planner or verifier
-    planner_lower = planner_output.lower()
-    simulation_recommended = (
-        ("simulation recommended: yes" in planner_lower) or
-        ("simulation" in planner_lower and "recommend" in planner_lower)
-    )
-    
-    logger.info(f"Synthesizer: uncertainty_level={uncertainty_level}, simulation_recommended={simulation_recommended}")
-    
-    prompt = (
-        f"{prompt_template}\n\n"
-        f"User Request:\n{user_input}\n\n"
-        f"Research Packet:\n{research_output}\n\n"
-        f"Planner Output:\n{planner_output}\n\n"
-        f"Verifier Output:\n{verifier_output}"
-    )
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": (
+            f"User request: {state.get('user_input', route.get('intent', ''))}\n\n"
+            + "\n\n".join(context_parts)
+            + "\n\nProduce the final structured JSON output:\n"
+            "{\n"
+            "  \"response\": \"<comprehensive, direct final answer>\",\n"
+            "  \"confidence\": 0.0-1.0,\n"
+            "  \"data_sources\": [\"<source 1>\", \"<source 2>\"],\n"
+            "  \"caveats\": [\"<caveat 1>\"],\n"
+            "  \"next_steps\": [\"<action 1>\", \"<action 2>\"]\n"
+            "}\n"
+        )},
+    ]
 
     try:
-        text = call_model(prompt, mode="chat")
-        confidence = _extract_confidence(text, default=0.60)
-        
-        # Also try to extract uncertainty from synthesizer's own output
-        synth_uncertainty = _extract_uncertainty(text)
-        # Use the higher uncertainty between verifier and synthesizer
-        if synth_uncertainty == "HIGH" or uncertainty_level == "HIGH":
-            final_uncertainty = "HIGH"
-        elif synth_uncertainty == "MEDIUM" or uncertainty_level == "MEDIUM":
-            final_uncertainty = "MEDIUM"
-        else:
-            final_uncertainty = "LOW"
-        
-        return {
-            "agent": "synthesizer",
-            "summary": text,
-            "details": {
-                "model_mode": "chat",
-                "uncertainty_level": final_uncertainty,
-                "simulation_recommended": simulation_recommended
-            },
-            "confidence": confidence,
-        }
-    except LLMProviderError as e:
-        return {
-            "agent": "synthesizer",
-            "summary": f"Error: {str(e)}",
-            "details": {"error_type": "provider_error"},
+        result = safe_parse(call_model(messages))
+    except RuntimeError as e:
+        logger.error(f"[AGENT ERROR] synthesizer: {e}")
+        result = {"status": "error", "reason": str(e)}
+
+    if "error" in result:
+        logger.warning(f"[AGENT ERROR] synthesizer: {result.get('error')}")
+        result = {
+            "response": "I encountered an error while synthesizing the analysis. Please try again.",
             "confidence": 0.0,
+            "data_sources": [],
+            "caveats": ["synthesis failed"],
+            "next_steps": ["retry the query"],
         }
+
+    return {**state, "final": result}

backend/app/agents/verifier.py

@@ -1,99 +1,59 @@
-import re
-from app.agents._model import call_model, LLMProviderError
-from app.domain_packs.registry import get_registry
+"""
+Verifier agent — MiroOrg v2.
+Accepts the Planner output and original route.
+Stress-tests the plan and returns pass/fail with actionable feedback.
+"""
 import logging
+from app.agents._model import call_model, safe_parse
+from app.config import load_prompt
 
 logger = logging.getLogger(__name__)
 
-_CONFIDENCE_PATTERN = re.compile(r'Confidence:\s*([\d.]+)', re.IGNORECASE)
 
+def run(state: dict) -> dict:
+    route = state.get("route", {})
+    planner = state.get("planner", {})
+    research = state.get("research", {})
 
-def _extract_confidence(text: str, default: float = 0.5) -> float:
-    """Extract confidence score from structured LLM output."""
-    match = _CONFIDENCE_PATTERN.search(text)
-    if match:
-        try:
-            score = float(match.group(1))
-            return max(0.0, min(1.0, score))
-        except ValueError:
-            pass
-    return default
+    prompt = load_prompt("verifier")
 
-
-def run_verifier(user_input: str, research_output: str, planner_output: str, prompt_template: str) -> dict:
-    # Detect domain and enhance verification with domain pack capabilities
-    registry = get_registry()
-    detected_domain = registry.detect_domain(user_input)
-    
-    domain_verification = {}
-    if detected_domain:
-        logger.info(f"Enhancing verification with domain pack: {detected_domain}")
-        pack = registry.get_pack(detected_domain)
-        if pack:
-            try:
-                # Extract claims from research and planner outputs for verification
-                claims = []
-                for line in (research_output + "\n" + planner_output).split("\n"):
-                    stripped = line.strip()
-                    if stripped and len(stripped) > 20 and not stripped.startswith(("Facts:", "Assumptions:", "Open Questions:", "Key Facts:", "Plan:", "Objective:")):
-                        claims.append(stripped)
-                
-                context = {
-                    "user_input": user_input,
-                    "research_output": research_output,
-                    "planner_output": planner_output,
-                    "claims": claims[:30]  # Limit claims to avoid token overflow
-                }
-                domain_verification = pack.enhance_verification(claims[:30], context)
-                logger.info(f"Domain verification successful: {detected_domain}")
-            except Exception as e:
-                logger.warning(f"Domain verification failed for {detected_domain}: {e}")
-                domain_verification = {}
-    
-    # Build enhanced prompt with domain verification
-    domain_verification_str = ""
-    if domain_verification:
-        domain_verification_str = "\n\nDomain-Specific Verification:\n"
-        for key, value in domain_verification.items():
-            if value:
-                domain_verification_str += f"{key}: {value}\n"
-    
-    prompt = (
-        f"{prompt_template}\n\n"
-        f"User Request:\n{user_input}\n\n"
-        f"Research Packet:\n{research_output}\n\n"
-        f"Planner Output:\n{planner_output}"
-        f"{domain_verification_str}"
-    )
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": (
+            f"Original route: {route}\n\n"
+            f"Research findings: {research}\n\n"
+            f"Planner output: {planner}\n\n"
+            "Verify the plan against the research and route. Return ONLY valid JSON:\n"
+            "{\n"
+            "  \"passed\": true | false,\n"
+            "  \"issues\": [\"<issue 1>\", \"<issue 2>\"],\n"
+            "  \"fixes_required\": [\"<fix 1>\", \"<fix 2>\"],\n"
+            "  \"confidence\": 0.0-1.0\n"
+            "}\n"
+            "passed=false MUST include specific, actionable fixes_required items."
+        )},
+    ]
 
     try:
-        text = call_model(prompt, mode="reasoner")
-        
-        # Extract confidence from LLM output
-        confidence = _extract_confidence(text, default=0.70)
-        
-        # Extract structured verification results
-        credibility_score = domain_verification.get("credibility_score", 0.5) if domain_verification else 0.5
-        rumors_detected = domain_verification.get("rumors_detected", []) if domain_verification else []
-        scams_detected = domain_verification.get("scams_detected", []) if domain_verification else []
-        
-        return {
-            "agent": "verifier",
-            "summary": text,
-            "details": {
-                "model_mode": "reasoner",
-                "domain_pack": detected_domain or "general",
-                "credibility_score": credibility_score,
-                "rumors_detected": rumors_detected,
-                "scams_detected": scams_detected,
-                "domain_verified": bool(domain_verification)
-            },
-            "confidence": confidence,
-        }
-    except LLMProviderError as e:
-        return {
-            "agent": "verifier",
-            "summary": f"Error: {str(e)}",
-            "details": {"error_type": "provider_error"},
-            "confidence": 0.0,
+        result = safe_parse(call_model(messages))
+    except RuntimeError as e:
+        logger.error(f"[AGENT ERROR] verifier: {e}")
+        result = {"status": "error", "reason": str(e)}
+
+    if "error" in result:
+        logger.warning(f"[AGENT ERROR] verifier: {result.get('error')}")
+        # Default to passed=true on error so pipeline doesn't get stuck
+        result = {
+            "passed": True,
+            "issues": ["verifier error — defaulting to pass"],
+            "fixes_required": [],
+            "confidence": 0.3,
         }
+
+    # Ensure passed field exists
+    result.setdefault("passed", True)
+    result.setdefault("issues", [])
+    result.setdefault("fixes_required", [])
+    result.setdefault("confidence", 0.5)
+
+    return {**state, "verifier": result}

backend/app/config.py

@@ -15,6 +15,15 @@ DATA_DIR = BASE_DIR / "data"
 MEMORY_DIR = DATA_DIR / "memory"
 SIMULATION_DIR = DATA_DIR / "simulations"
 
+# Prompt loader
+def load_prompt(name: str) -> str:
+    """Load a prompt file by name (without .txt extension)."""
+    path = PROMPTS_DIR / f"{name}.txt"
+    if not path.exists():
+        return f"You are the {name} agent in MiroOrg v2. Be helpful and precise."
+    return path.read_text(encoding="utf-8").strip()
+
+
 APP_VERSION = os.getenv("APP_VERSION", "0.3.0")
 
 PRIMARY_PROVIDER = os.getenv("PRIMARY_PROVIDER", "openrouter").lower()

backend/app/graph.py

@@ -1,185 +1,192 @@
+"""
+MiroOrg v2 — LangGraph pipeline with conditional routing and verifier feedback loop.
+
+Graph topology:
+  [switchboard]
+       │
+       ├─ requires_simulation=true → [mirofish] → [research]
+       ├─ requires_finance_data=true → [finance] → [research]
+       └─ (default) → [research]
+                            │
+                       [planner] ←──────┐
+                            │            │
+                       [verifier]        │
+                            │            │
+              passed=true ──┤            │
+              passed=false AND           │
+              replan_count < 2 ──────────┘
+                            │
+                       [synthesizer]
+                            │
+                          [END]
+"""
+
 import uuid
 import time
 import logging
-from typing import TypedDict, Dict, Any
+from typing import TypedDict, Dict, Any, Optional
 
 from langgraph.graph import StateGraph, START, END
 
-from app.config import PROMPTS_DIR
-from app.agents.switchboard import decide_route
-from app.agents.research import run_research
-from app.agents.planner import run_planner
-from app.agents.verifier import run_verifier
-from app.agents.synthesizer import run_synthesizer
+from app.agents import switchboard, research, planner, verifier, synthesizer
+from app.agents import mirofish_node, finance_node
 
 logger = logging.getLogger(__name__)
 
 
-# ── Prompt Loading with Production Version Support ────────────────────────────
-
-_prompt_cache: Dict[str, str] = {}
-
-
-def load_prompt(filename: str) -> str:
-    """Load prompt from file, with caching."""
-    if filename not in _prompt_cache:
-        path = PROMPTS_DIR / filename
-        _prompt_cache[filename] = path.read_text(encoding="utf-8")
-    return _prompt_cache[filename]
+# ── State Type ────────────────────────────────────────────────────────────────
 
+class AgentState(TypedDict, total=False):
+    # Input
+    user_input: str
+    case_id: str
 
-def get_active_prompt(prompt_name: str, filename: str) -> str:
-    """
-    Get the active prompt, preferring a promoted production version.
-    Falls back to the file-based prompt if none is promoted.
-    """
-    try:
-        from app.routers.learning import learning_engine
-        if learning_engine:
-            production = learning_engine.get_active_prompt(prompt_name)
-            if production:
-                logger.debug(f"Using production prompt version for {prompt_name}")
-                return production
-    except Exception:
-        pass
-
-    return load_prompt(filename)
-
+    # Pipeline state
+    route: dict          # switchboard output
+    simulation: dict     # mirofish output (optional)
+    finance: dict        # finance_node output (optional)
+    research: dict       # research output
+    planner: dict        # planner output
+    verifier: dict       # verifier output
+    final: dict          # synthesizer output
 
-RESEARCH_PROMPT = load_prompt("research.txt")
-PLANNER_PROMPT = load_prompt("planner.txt")
-VERIFIER_PROMPT = load_prompt("verifier.txt")
-SYNTHESIZER_PROMPT = load_prompt("synthesizer.txt")
+    # Control
+    replan_count: int
+    errors: list
 
 
-class OrgState(TypedDict):
-    case_id: str
-    user_input: str
-    route: Dict[str, Any]
-    research: Dict[str, Any]
-    planner: Dict[str, Any]
-    verifier: Dict[str, Any]
-    final: Dict[str, Any]
+# ── Node wrappers with timing ────────────────────────────────────────────────
 
+def switchboard_node(state: AgentState) -> dict:
+    t0 = time.perf_counter()
+    result = switchboard.run(state)
+    elapsed = time.perf_counter() - t0
+    logger.info(f"[{state.get('case_id', '?')[:8]}] switchboard: {elapsed:.2f}s — domain={result.get('route', {}).get('domain')}")
+    return result
 
-def empty_output(agent_name: str) -> Dict[str, Any]:
-    return {
-        "agent": agent_name,
-        "summary": "",
-        "details": {},
-        "confidence": 0.0,
-    }
 
+def mirofish_node_fn(state: AgentState) -> dict:
+    t0 = time.perf_counter()
+    result = mirofish_node.run(state)
+    elapsed = time.perf_counter() - t0
+    logger.info(f"[{state.get('case_id', '?')[:8]}] mirofish: {elapsed:.2f}s")
+    return result
 
-# ── Node Functions with Timing ───────────────────────────────────────────────
 
-def switchboard_node(state: OrgState):
+def finance_node_fn(state: AgentState) -> dict:
     t0 = time.perf_counter()
-    result = {"route": decide_route(state["user_input"])}
+    result = finance_node.run(state)
     elapsed = time.perf_counter() - t0
-    logger.info(f"[{state['case_id'][:8]}] switchboard: {elapsed:.2f}s — mode={result['route'].get('execution_mode')}")
+    logger.info(f"[{state.get('case_id', '?')[:8]}] finance: {elapsed:.2f}s")
     return result
 
 
-def research_node(state: OrgState):
-    if state["route"].get("execution_mode") == "solo":
-        return {"research": empty_output("research")}
-
+def research_node(state: AgentState) -> dict:
     t0 = time.perf_counter()
-    prompt = get_active_prompt("research", "research.txt")
-    result = {"research": run_research(state["user_input"], prompt)}
+    result = research.run(state)
     elapsed = time.perf_counter() - t0
-    logger.info(f"[{state['case_id'][:8]}] research: {elapsed:.2f}s")
+    logger.info(f"[{state.get('case_id', '?')[:8]}] research: {elapsed:.2f}s")
     return result
 
 
-def planner_node(state: OrgState):
-    if state["route"].get("execution_mode") == "solo":
-        return {"planner": empty_output("planner")}
-
+def planner_node(state: AgentState) -> dict:
     t0 = time.perf_counter()
-    prompt = get_active_prompt("planner", "planner.txt")
-    result = {
-        "planner": run_planner(
-            state["user_input"],
-            state["research"]["summary"],
-            prompt,
-        )
-    }
+    result = planner.run(state)
     elapsed = time.perf_counter() - t0
-    logger.info(f"[{state['case_id'][:8]}] planner: {elapsed:.2f}s")
+    logger.info(f"[{state.get('case_id', '?')[:8]}] planner: {elapsed:.2f}s")
     return result
 
 
-def verifier_node(state: OrgState):
-    if state["route"].get("execution_mode") != "deep":
-        return {"verifier": empty_output("verifier")}
-
+def verifier_node(state: AgentState) -> dict:
     t0 = time.perf_counter()
-    prompt = get_active_prompt("verifier", "verifier.txt")
-    result = {
-        "verifier": run_verifier(
-            state["user_input"],
-            state["research"]["summary"],
-            state["planner"]["summary"],
-            prompt,
-        )
-    }
+    result = verifier.run(state)
     elapsed = time.perf_counter() - t0
-    logger.info(f"[{state['case_id'][:8]}] verifier: {elapsed:.2f}s")
+    logger.info(f"[{state.get('case_id', '?')[:8]}] verifier: {elapsed:.2f}s")
     return result
 
 
-def synthesizer_node(state: OrgState):
+def synthesizer_node(state: AgentState) -> dict:
     t0 = time.perf_counter()
-    prompt = get_active_prompt("synthesizer", "synthesizer.txt")
-    result = {
-        "final": run_synthesizer(
-            state["user_input"],
-            state["research"]["summary"],
-            state["planner"]["summary"],
-            state["verifier"]["summary"],
-            prompt,
-        )
-    }
+    result = synthesizer.run(state)
     elapsed = time.perf_counter() - t0
-    logger.info(f"[{state['case_id'][:8]}] synthesizer: {elapsed:.2f}s")
+    logger.info(f"[{state.get('case_id', '?')[:8]}] synthesizer: {elapsed:.2f}s")
     return result
 
 
-graph = StateGraph(OrgState)
-graph.add_node("switchboard", switchboard_node)
-graph.add_node("research", research_node)
-graph.add_node("planner", planner_node)
-graph.add_node("verifier", verifier_node)
-graph.add_node("synthesizer", synthesizer_node)
+# ── Routing functions ─────────────────────────────────────────────────────────
+
+def after_switchboard(state: AgentState) -> str:
+    """Route based on switchboard flags."""
+    route = state.get("route", {})
+    if route.get("requires_simulation"):
+        return "mirofish"
+    if route.get("requires_finance_data"):
+        return "finance"
+    return "research"
+
+
+def after_verifier(state: AgentState) -> str:
+    """Verifier feedback loop: replan if failed and under limit."""
+    v = state.get("verifier", {})
+    replan_count = state.get("replan_count", 0)
+    if not v.get("passed", True) and replan_count < 2:
+        return "planner"
+    return "synthesizer"
+
+
+# ── Build graph ───────────────────────────────────────────────────────────────
+
+def build_graph():
+    g = StateGraph(AgentState)
+
+    g.add_node("switchboard", switchboard_node)
+    g.add_node("research", research_node)
+    g.add_node("mirofish", mirofish_node_fn)
+    g.add_node("finance", finance_node_fn)
+    g.add_node("planner", planner_node)
+    g.add_node("verifier", verifier_node)
+    g.add_node("synthesizer", synthesizer_node)
+
+    g.set_entry_point("switchboard")
+
+    # After switchboard: fork based on flags
+    g.add_conditional_edges("switchboard", after_switchboard,
+        {"mirofish": "mirofish", "finance": "finance", "research": "research"})
+
+    # mirofish and finance both merge into research
+    g.add_edge("mirofish", "research")
+    g.add_edge("finance", "research")
+    g.add_edge("research", "planner")
+
+    # Verifier feedback loop
+    g.add_edge("planner", "verifier")
+    g.add_conditional_edges("verifier", after_verifier,
+        {"planner": "planner", "synthesizer": "synthesizer"})
+
+    g.add_edge("synthesizer", END)
+    return g.compile()
 
-graph.add_edge(START, "switchboard")
-graph.add_edge("switchboard", "research")
-graph.add_edge("research", "planner")
-graph.add_edge("planner", "verifier")
-graph.add_edge("verifier", "synthesizer")
-graph.add_edge("synthesizer", END)
 
-compiled_graph = graph.compile()
+compiled_graph = build_graph()
 
 
-def run_case(user_input: str):
+def run_case(user_input: str) -> dict:
+    """Run the full agent pipeline on user input."""
     case_id = str(uuid.uuid4())
     t0 = time.perf_counter()
     logger.info("Starting case %s", case_id)
 
-    result = compiled_graph.invoke(
-        {
-            "case_id": case_id,
-            "user_input": user_input,
-            "route": {},
-            "research": {},
-            "planner": {},
-            "verifier": {},
-            "final": {},
-        }
-    )
+    result = compiled_graph.invoke({
+        "case_id": case_id,
+        "user_input": user_input,
+        "route": {},
+        "research": {},
+        "planner": {},
+        "verifier": {},
+        "final": {},
+        "replan_count": 0,
+        "errors": [],
+    })
 
     elapsed = time.perf_counter() - t0
     logger.info("Case %s completed in %.2fs", case_id, elapsed)

backend/app/main.py

@@ -1,7 +1,7 @@
-import asyncio
 import time
 import logging
 import os
+import json
 
 from fastapi import FastAPI, HTTPException, Query, Request
 from fastapi.middleware.cors import CORSMiddleware
@@ -12,17 +12,9 @@ from app.graph import run_case
 from app.memory import save_case
 from app.config import (
     APP_VERSION,
-    PRIMARY_PROVIDER,
-    FALLBACK_PROVIDER,
-    OPENROUTER_API_KEY,
-    OLLAMA_ENABLED,
-    TAVILY_API_KEY,
-    NEWSAPI_KEY,
-    ALPHAVANTAGE_API_KEY,
-    MIROFISH_ENABLED,
     MEMORY_DIR,
     PROMPTS_DIR,
-    get_config,
+    load_prompt,
 )
 from app.services.case_store import list_cases, get_case, delete_case, memory_stats
 from app.services.prompt_store import list_prompts, get_prompt, update_prompt
@@ -32,11 +24,12 @@ from app.routers.simulation import router as simulation_router
 from app.routers.learning import router as learning_router, init_learning_services, start_scheduler_background
 from app.routers.sentinel import router as sentinel_router
 from app.routers.finance import router as finance_router
+from app.config import get_config
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-app = FastAPI(title="MiroOrg v1.1", version=APP_VERSION)
+app = FastAPI(title="MiroOrg v2", version=APP_VERSION)
 
 # Initialize domain packs
 from app.domain_packs.init_packs import init_domain_packs
@@ -104,7 +97,7 @@ async def on_startup():
             logger.info("Background learning scheduler started")
         except Exception as e:
             logger.error(f"Failed to start learning scheduler: {e}")
-    
+
     # Start sentinel scheduler
     sentinel_enabled = os.getenv("SENTINEL_ENABLED", "true").lower() == "true"
     if sentinel_enabled:
@@ -132,14 +125,14 @@ def health_deep():
 def config_status():
     return {
         "app_version": APP_VERSION,
-        "primary_provider": PRIMARY_PROVIDER,
-        "fallback_provider": FALLBACK_PROVIDER,
-        "openrouter_key_present": bool(OPENROUTER_API_KEY),
-        "ollama_enabled": OLLAMA_ENABLED,
-        "mirofish_enabled": MIROFISH_ENABLED,
-        "tavily_enabled": bool(TAVILY_API_KEY),
-        "newsapi_enabled": bool(NEWSAPI_KEY),
-        "alphavantage_enabled": bool(ALPHAVANTAGE_API_KEY),
+        "openrouter_key_present": bool(os.getenv("OPENROUTER_API_KEY")),
+        "ollama_base_url": os.getenv("OLLAMA_BASE_URL", "http://localhost:11434"),
+        "ollama_model": os.getenv("OLLAMA_MODEL", "llama3.2"),
+        "tavily_enabled": bool(os.getenv("TAVILY_API_KEY")),
+        "newsapi_enabled": bool(os.getenv("NEWS_API_KEY", os.getenv("NEWSAPI_KEY"))),
+        "alphavantage_enabled": bool(os.getenv("ALPHA_VANTAGE_API_KEY", os.getenv("ALPHAVANTAGE_API_KEY"))),
+        "mirofish_base_url": os.getenv("MIROFISH_BASE_URL", "http://localhost:8001"),
+        "api_discovery_endpoint": os.getenv("API_DISCOVERY_ENDPOINT", "http://localhost:8002"),
         "memory_dir": str(MEMORY_DIR),
         "prompts_dir": str(PROMPTS_DIR),
     }
@@ -162,6 +155,17 @@ def agent_detail(agent_name: str):
 
 # ── Case Execution ────────────────────────────────────────────────────────────
 
+def _log_agent_errors(result: dict):
+    """Log any agent errors from the pipeline result."""
+    for agent_key in ["route", "research", "planner", "verifier", "simulation", "finance", "final"]:
+        agent_output = result.get(agent_key, {})
+        if isinstance(agent_output, dict):
+            if agent_output.get("status") == "error":
+                logger.warning(f"[AGENT ERROR] {agent_key}: {agent_output.get('reason', 'unknown')}")
+            elif agent_output.get("error"):
+                logger.warning(f"[AGENT ERROR] {agent_key}: {agent_output.get('error')}")
+
+
 def _fire_and_forget_learning(payload: dict):
     """Fire-and-forget learning from a completed case."""
     from app.routers.learning import learning_engine as _le
@@ -177,19 +181,31 @@ def run_org(task: UserTask):
     try:
         logger.info("Processing /run: %s", task.user_input[:100])
         result = run_case(task.user_input)
+
+        # Log any agent errors
+        _log_agent_errors(result)
+
+        # Build response payload
+        final = result.get("final", {})
         payload = {
-            "case_id": result["case_id"],
-            "user_input": result["user_input"],
-            "route": result["route"],
+            "case_id": result.get("case_id", ""),
+            "user_input": result.get("user_input", ""),
+            "route": result.get("route", {}),
+            "research": result.get("research", {}),
+            "planner": result.get("planner", {}),
+            "verifier": result.get("verifier", {}),
+            "simulation": result.get("simulation"),
+            "finance": result.get("finance"),
+            "final": final,
+            "final_answer": final.get("response", final.get("summary", "")),
             "outputs": [
-                result["research"],
-                result["planner"],
-                result["verifier"],
-                result["final"],
+                result.get("research", {}),
+                result.get("planner", {}),
+                result.get("verifier", {}),
+                final,
             ],
-            "final_answer": result["final"]["summary"],
         }
-        save_case(result["case_id"], payload)
+        save_case(result.get("case_id", ""), payload)
 
         # Fire-and-forget: learn from this case
         _fire_and_forget_learning(payload)
@@ -204,10 +220,9 @@ def run_org(task: UserTask):
 def run_org_debug(task: UserTask):
     try:
         result = run_case(task.user_input)
-        save_case(result["case_id"], result)
-
+        _log_agent_errors(result)
+        save_case(result.get("case_id", ""), result)
         _fire_and_forget_learning(result)
-
         return result
     except Exception as e:
         logger.exception("Error in /run/debug")
@@ -231,6 +246,21 @@ def run_one_agent(request: AgentRunRequest):
         raise HTTPException(status_code=500, detail="Failed to run agent. Please try again.")
 
 
+# ── Debug State Endpoint ──────────────────────────────────────────────────────
+
+@app.get("/debug/state/{case_id}")
+def debug_state(case_id: str):
+    """Return the full saved state for a case — useful for debugging."""
+    case_path = MEMORY_DIR / f"{case_id}.json"
+    if not case_path.exists():
+        raise HTTPException(status_code=404, detail=f"Case {case_id} not found")
+    try:
+        with open(case_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to read case: {e}")
+
+
 # ── Cases ─────────────────────────────────────────────────────────────────────
 
 @app.get("/cases")

backend/app/memory.py

@@ -1,10 +1,17 @@
 import json
 from datetime import datetime
 from pathlib import Path
-from app.config import MEMORY_DIR
+import glob
+import logging
+
+from app.config import MEMORY_DIR, DATA_DIR
+
+logger = logging.getLogger(__name__)
 
 Path(MEMORY_DIR).mkdir(parents=True, exist_ok=True)
 
+KNOWLEDGE_DIR = DATA_DIR / "knowledge"
+
 
 def save_case(case_id: str, payload: dict) -> str:
     path = Path(MEMORY_DIR) / f"{case_id}.json"
@@ -12,3 +19,32 @@ def save_case(case_id: str, payload: dict) -> str:
     with open(path, "w", encoding="utf-8") as f:
         json.dump(payload, f, indent=2, ensure_ascii=False)
     return str(path)
+
+
+class KnowledgeStore:
+    """
+    Simple keyword match over knowledge JSON files.
+    Each file is expected to be a dict or list of dicts with a 'text' field.
+    Upgrade to embedding-based retrieval when ready.
+    """
+
+    def search(self, query: str, domain: str = "general", top_k: int = 5) -> list[dict]:
+        results = []
+        query_lower = query.lower()
+        pattern = str(KNOWLEDGE_DIR / "*.json")
+        for path in glob.glob(pattern):
+            try:
+                data = json.loads(Path(path).read_text())
+                items = data if isinstance(data, list) else [data]
+                for item in items:
+                    text = str(item.get("text", item.get("content", "")))
+                    if any(w in text.lower() for w in query_lower.split()):
+                        results.append(item)
+                        if len(results) >= top_k:
+                            return results
+            except Exception:
+                continue
+        return results
+
+
+knowledge_store = KnowledgeStore()

backend/app/prompts/finance.txt

@@ -0,0 +1,10 @@
+You are a financial intelligence analyst inside MiroOrg v2.
+You receive raw market data from Alpha Vantage and produce structured, actionable intelligence.
+
+Rules:
+- Output ONLY valid JSON matching the schema provided in the user message.
+- Be precise with numbers — do not round or approximate market data.
+- Flag data quality issues (rate limits, missing fields, stale data) in the data_quality field.
+- Never include chart rendering instructions, OHLCV arrays, or image/chart URLs in output.
+- If Alpha Vantage returned an error, set data_quality to "limited" and explain in summary.
+- sentiment must be derived from news_sentiment scores and fundamentals — not guessed.

backend/app/prompts/planner.txt

@@ -1,90 +1,29 @@
-You are the Planner Agent in MiroOrg — a 5-layer AI intelligence organization.
-
-═══════════════════════════════════════════════════════════════
-ROLE
-═══════════════════════════════════════════════════════════════
-You receive the Research Agent's research packet and transform it into an actionable strategy. You are the strategic thinker — you decide WHAT should be done, in WHAT order, and with what resources. You also serve as the gateway to MiroFish simulation mode.
-
-═══════════════════════════════════════════════════════════════
-CAPABILITIES YOU HAVE ACCESS TO
-═══════════════════════════════════════════════════════════════
-• Full research packet with facts, entities, market data, domain insights
-• Simulation mode via MiroFish — a digital twin engine that can model multi-agent scenarios, stakeholder reactions, market impacts, and policy cascades
-• Knowledge from past cases — the system learns from previous analyses and can apply distilled skills
-
-═══════════════════════════════════════════════════════════════
-INSTRUCTIONS
-═══════════════════════════════════════════════════════════════
-
-1. ANALYZE THE RESEARCH PACKET
-   - Identify the user's core objective (what do they actually need?)
-   - Distinguish between informational needs and decision-making needs
-   - Note the complexity level: Is this a simple lookup, a multi-step analysis, or a strategic decision?
-
-2. CREATE A STRUCTURED PLAN
-   - Break the response into clear, numbered steps
-   - Each step should be actionable and specific
-   - Include conditional branches where outcomes are uncertain ("If X, then Y; otherwise Z")
-   - Prioritize steps by impact and urgency
-
-3. RISK ASSESSMENT
-   - What could go wrong with this plan?
-   - What are the key assumptions that could invalidate the strategy?
-   - What external factors could change the situation?
-   - Rate each risk: HIGH / MEDIUM / LOW impact and probability
-
-4. RESOURCE & DEPENDENCY MAPPING
-   - What information is needed that we don't have?
-   - What actions depend on other actions completing first?
-   - What external factors or decisions are blocking?
-
-5. TIMELINE ESTIMATION
-   - If the plan involves actions: suggest reasonable timeframes
-   - If the plan involves monitoring: suggest check-in intervals
-   - Note time-sensitive elements that could expire
-
-6. SIMULATION MODE DETECTION (CRITICAL)
-   The system has MiroFish — a powerful simulation engine that creates digital twins of scenarios and models multi-agent interactions. You MUST recommend simulation mode when ANY of these apply:
-
-   ALWAYS recommend simulation when the user:
-   → Asks "what if" or "what would happen if"
-   → Wants to predict outcomes or forecast trends
-   → Needs to model stakeholder reactions (market, public, government, competitors)
-   → Is evaluating policy impact or regulatory changes
-   → Needs scenario comparison (option A vs option B)
-   → Is dealing with complex multi-party dynamics
-   → Asks about public opinion, sentiment shifts, or social reactions
-   → Wants to stress-test a strategy or business decision
-
-   When recommending simulation, explain:
-   → WHY simulation adds value over static analysis
-   → WHAT kind of simulation would be most useful
-   → WHAT stakeholders/agents should be modeled
-
-═══════════════════════════════════════════════════════════════
-OUTPUT FORMAT (follow strictly)
-═══════════════════════════════════════════════════════════════
-
-Objective:
-<What the user actually needs, in one clear sentence>
-
-Strategic Plan:
-1. <Step> — <Why this step matters>
-2. <Step> — <Why this step matters>
-3. <Step> — <Why this step matters>
-   → Contingency: <If X fails, then...>
-
-Risk Assessment:
-- [HIGH/MEDIUM/LOW] <risk> — <probability> — <mitigation>
-
-Dependencies:
-- <What depends on what>
-
-Timeline:
-- <Step X>: <estimated timeframe or urgency>
-
-Simulation Recommended: YES / NO
-Simulation Rationale: <If YES: explain what kind of simulation, which stakeholders to model, and what insights it would generate. If NO: explain why static analysis is sufficient.>
-
-Confidence: <0.0 to 1.0>
-Reasoning: <one sentence explaining your confidence level>
+You are the Planner Agent in MiroOrg v2 — a multi-agent intelligence platform.
+
+You receive the Switchboard route, Research findings, and optionally Simulation
+and Finance data. Your job is to transform research into an actionable strategy.
+
+For complexity=very_high, produce 5–10 detailed steps.
+For complexity=high, produce 3–7 steps.
+For complexity=medium or low, produce 2–4 steps.
+
+If replan_count > 0, you are being asked to replan based on Verifier feedback.
+Address the Verifier's specific fixes_required items.
+
+Output ONLY valid JSON:
+{
+  "plan_steps": ["<step 1>", "<step 2>", "..."],
+  "resources_needed": ["<resource 1>"],
+  "dependencies": ["<dependency 1>"],
+  "risk_level": "low | medium | high",
+  "estimated_output": "<brief description of expected output>",
+  "replan_reason": "<only if replan_count > 0: what changed>"
+}
+
+Rules:
+- Each step must be actionable and specific.
+- Include conditional branches for uncertain outcomes.
+- Prioritise steps by impact and urgency.
+- If Simulation data is provided, incorporate scenario insights into the plan.
+- If Finance data is provided, ground quantitative claims in market data.
+- Never return an empty plan. Always provide at least one step.

backend/app/prompts/research.txt

@@ -1,87 +1,37 @@
-You are the Research Agent in MiroOrg — a 5-layer AI intelligence organization.
-
-═══════════════════════════════════════════════════════════════
-ROLE
-═══════════════════════════════════════════════════════════════
-You are the first analyst in the pipeline. Your research packet becomes the foundation for every downstream agent (Planner, Verifier, Synthesizer). Thoroughness and structure here directly determines the quality of the final answer.
-
-═══════════════════════════════════════════════════════════════
-CAPABILITIES YOU HAVE ACCESS TO
-═══════════════════════════════════════════════════════════════
-The system automatically provides you with:
-• Web search results (Tavily) — real-time web intelligence
-• News articles (NewsAPI) — recent headlines and reporting
-• Market data (Alpha Vantage) — live stock quotes for detected tickers
-• URL content (Jina Reader) — full-text extraction from any links the user provides
-• Domain pack insights — when a specialized domain is detected (e.g., finance), you receive entity resolution, ticker mapping, sentiment signals, event analysis, and credibility scores
-• Knowledge base — the learning layer may supply distilled knowledge from past research
-
-Use ALL of this context. Never ignore provided data. If external context is minimal, state what is missing and why it limits your analysis.
-
-═══════════════════════════════════════════════════════════════
-INSTRUCTIONS
-═══════════════════════════════════════════════════════════════
-
-1. EXTRACT & STRUCTURE KEY FACTS
-   - Separate hard facts (verified, sourced) from soft signals (opinions, projections)
-   - Attribute each fact to its source when possible
-   - Note temporal relevance (how recent is each data point?)
-
-2. ENTITY RESOLUTION
-   - Identify all entities: companies, people, organizations, countries, products, concepts
-   - For companies: map to official names and stock tickers (e.g., "Apple" → Apple Inc. ($AAPL))
-   - For people: note their role and relevance
-   - For events: note dates and impact scope
-
-3. DOMAIN-SPECIFIC DEEP DIVE
-   When domain context is detected (finance, policy, technology, etc.):
-   - Use market data to ground quantitative claims (price, volume, market cap)
-   - Use news context to identify trending narratives and sentiment shifts
-   - Note which sources are high-credibility vs. low-credibility
-   - Extract stance signals: bullish/bearish, supportive/opposing, optimistic/pessimistic
-   - Identify event catalysts: earnings, regulatory actions, mergers, policy changes
-
-4. GAP ANALYSIS
-   - What critical information is NOT available?
-   - What assumptions must the user be aware of?
-   - What would change the analysis if verified differently?
-
-5. SIGNAL DETECTION
-   - Contradictions between sources
-   - Unusual patterns or anomalies
-   - Emerging narratives that haven't been confirmed
-   - Risks or red flags that need the Verifier's attention
-
-═══════════════════════════════════════════════════════════════
-OUTPUT FORMAT (follow strictly)
-═══════════════════════════════════════════════════════════════
-
-Key Facts:
-- [FACT] <fact> (Source: <source name>)
-- [FACT] <fact> (Source: <source name>)
-
-Entities Detected:
-- <entity name> — <type> — <relevance to query>
-  → Ticker: $XXX (if applicable)
-
-Market & Quantitative Data:
-- <data point with attribution>
-
-Domain Insights:
-- <domain-specific finding or signal>
-
-Sentiment & Stance:
-- <source/entity>: <bullish/bearish/neutral/mixed> — <brief reasoning>
-
-Source Assessment:
-- <source name>: <high/medium/low credibility> — <why>
-
-Gaps & Assumptions:
-- [GAP] <what's missing and why it matters>
-- [ASSUMPTION] <assumption being made>
-
-Red Flags for Verifier:
-- <anything that needs skeptical examination>
-
-Confidence: <0.0 to 1.0>
-Reasoning: <one sentence explaining your confidence level>
+You are the Research Agent in MiroOrg v2 — a multi-agent intelligence platform.
+
+You are the first analyst in the pipeline. Your analysis becomes the foundation for
+the Planner, Verifier, and Synthesizer agents downstream.
+
+You receive a [CONTEXT] block containing data gathered from real tools:
+- Tavily web search results
+- News API articles (when current events are relevant)
+- Knowledge base entries (from past research)
+- Discovered API data (from the API discovery layer)
+- Simulation results (if Mirofish ran)
+- Finance data (if Alpha Vantage was queried)
+
+INSTRUCTIONS:
+1. Thoroughly analyse ALL provided context. Never ignore data.
+2. Separate verified facts from opinions and projections.
+3. Attribute findings to their sources when possible.
+4. Identify gaps — what critical information is missing.
+5. Do NOT hallucinate. If context is empty, acknowledge it.
+
+Output ONLY valid JSON matching this schema:
+{
+  "summary": "<comprehensive analysis based on provided context>",
+  "key_facts": ["<fact 1 with source>", "<fact 2 with source>"],
+  "sources": ["<source name 1>", "<source name 2>"],
+  "gaps": ["<what's missing and why it matters>"],
+  "confidence": 0.0-1.0
+}
+
+If no context was retrieved, return:
+{
+  "summary": "Limited analysis — no external data was retrieved.",
+  "key_facts": [],
+  "sources": [],
+  "gaps": ["no data retrieved"],
+  "confidence": 0.2
+}

backend/app/prompts/simulation.txt

@@ -0,0 +1,12 @@
+You are a scenario analysis agent inside MiroOrg v2.
+You interpret simulation output from MiroFish — the system's digital twin and scenario modelling engine.
+
+Rules:
+- Output ONLY valid JSON matching the schema provided in the user message.
+- Summarise key findings from simulation results clearly and actionably.
+- Assess confidence based on the number and quality of scenarios run.
+- If Mirofish returned an error or was unavailable, set confidence to 0.3 and note in caveats.
+- Identify the recommended path from among the simulated scenarios.
+- List caveats — assumptions, limitations, and conditions under which the recommendation changes.
+- Do NOT fabricate simulation data. Only interpret what Mirofish provided.
+- If simulation data is empty or minimal, state clearly that results are inconclusive.

backend/app/prompts/switchboard.txt

@@ -0,0 +1,24 @@
+You are the Switchboard intelligence router for MiroOrg v2.
+Your job is to analyse the user's input and produce a precise routing structure.
+
+Output ONLY valid JSON. No markdown, no explanation, no preamble.
+
+Required output schema:
+{
+  "domain": "finance | general | research | simulation | mixed",
+  "complexity": "low | medium | high | very_high",
+  "intent": "<one sentence: what the user wants>",
+  "sub_tasks": ["<task 1>", "<task 2>"],
+  "requires_simulation": <true|false>,
+  "requires_finance_data": <true|false>,
+  "requires_news": <true|false>,
+  "confidence": <0.0 to 1.0>
+}
+
+Rules:
+- Always return a full valid JSON object, even if confidence is low.
+- For multi-domain inputs, use "mixed" and list all sub_tasks.
+- Set requires_simulation=true for any scenario modelling, what-if, projection, or outcome analysis.
+- Set requires_finance_data=true for market, stock, portfolio, economic, or trading queries.
+- Set requires_news=true for any request needing current events or recent data.
+- confidence below 0.5 means the intent is ambiguous — still provide best-effort routing.

backend/app/prompts/synthesizer.txt

@@ -1,103 +1,30 @@
-You are the Synthesizer Agent in MiroOrg — a 5-layer AI intelligence organization.
-
-═══════════════════════════════════════════════════════════════
-ROLE
-═══════════════════════════════════════════════════════════════
-You are the FINAL voice. You receive everything — the Research packet, the Planner's strategy, and the Verifier's assessment — and you produce the definitive answer that the user sees. Your output IS the product. It must be clear, honest, actionable, and carry appropriate certainty levels.
-
-═══════════════════════════════════════════════════════════════
-SYSTEM CAPABILITIES TO REFERENCE
-═══════════════════════════════════════════════════════════════
-You can recommend these capabilities to the user:
-• Simulation Mode (MiroFish) — for scenario modeling, "what if" analysis, stakeholder reaction modeling, multi-agent simulations, and digital twin creation
-• Domain Intelligence — specialized analysis packs (finance: market data, entity resolution, event analysis, predictions)
-• Learning Layer — the system continuously improves from past cases, tracks source trust, and evolves its prompts
-
-═══════════════════════════════════════════════════════════════
-INSTRUCTIONS
-═══════════════════════════════════════════════════════════════
-
-1. INTEGRATE ALL INPUTS
-   - Research provides the RAW FACTS and SIGNALS
-   - Planner provides the STRATEGIC FRAMEWORK
-   - Verifier provides the QUALITY ASSESSMENT and UNCERTAINTY MAP
-   
-   Resolve conflicts between them:
-   → If Research says X but Verifier flagged X as unverified → mention X with caveat
-   → If Planner recommended action A but Verifier found it risky → recommend A with risk mitigation
-   → If sources disagree → present the disagreement honestly, don't pick sides without evidence
-
-2. WRITE THE FINAL ANSWER
-   The final answer must be:
-   - DIRECT: Lead with the answer, not the process. What does the user need to know FIRST?
-   - GROUNDED: Every claim should reference the evidence that supports it
-   - HONEST: State what you know, what you don't, and how confident you are
-   - ACTIONABLE: End with what the user should DO next
-   - READABLE: Use clear paragraphs, not walls of text. Use structure where helpful.
-
-3. UNCERTAINTY COMMUNICATION (CRITICAL)
-   Never hide uncertainty. The user trusts this system because it's honest about what it doesn't know.
-   
-   Use these guidelines:
-   - HIGH uncertainty: Lead with a prominent caveat. "Based on limited/conflicting information..."
-   - MEDIUM uncertainty: Weave caveats naturally. "While X suggests..., there is uncertainty around..."
-   - LOW uncertainty: State with confidence but note the basis. "Based on multiple verified sources..."
-   
-   Always specify:
-   → What would change your answer if new information emerged
-   → What the user should validate independently
-
-4. SIMULATION RECOMMENDATION (WHEN APPROPRIATE)
-   If the Planner recommended simulation mode, OR if you detect the user would benefit from it, actively recommend the MiroFish Simulation Lab.
-   
-   Frame it as:
-   "💡 This question would benefit from simulation mode. MiroFish can create a digital twin of this scenario and model [specific stakeholders/dynamics]. To run a simulation, use the Simulation Lab with your scenario details."
-   
-   Recommend simulation when:
-   → The answer involves too many unknowns to give a confident static analysis
-   → Multiple stakeholders would react differently to the same event
-   → The user is making a decision that could go multiple ways
-   → Temporal dynamics matter (how things evolve over time)
-
-5. CONFIDENCE CALIBRATION
-   Your confidence score must be CALIBRATED — don't default to generic values.
-   
-   0.9–1.0: Multiple verified sources agree, well-established facts
-   0.7–0.89: Strong evidence with minor gaps, reliable sources
-   0.5–0.69: Mixed evidence, some uncertainty, qualified conclusions
-   0.3–0.49: Significant uncertainty, limited evidence, speculative elements
-   0.0–0.29: Very little evidence, highly speculative, contradictory sources
-
-═══════════════════════════════════════════════════════════════
-OUTPUT FORMAT (follow strictly)
-═══════════════════════════════════════════════════════════════
-
-Final Answer:
-<Your comprehensive, direct answer. Lead with the most important insight. Use paragraphs for readability. Ground claims in evidence. Be honest about limitations.>
-
-Key Findings:
-- <Most important finding with evidence basis>
-- <Second most important finding>
-- <Third most important finding>
-
-Uncertainty Level: HIGH / MEDIUM / LOW
-Uncertainty Details:
-- <What we're uncertain about and why>
-- <What could change this answer>
-
-Caveats:
-- <Important limitations the user should be aware of>
-
-Next Actions:
-1. <Most important thing the user should do>
-2. <Second priority action>
-3. <Optional: additional recommended steps>
-
-Simulation Recommended: YES / NO
-Simulation Details: <If YES: what scenario to simulate, what stakeholders to model, what insights to expect. If NO: why static analysis is sufficient.>
-
-Sources Used:
-- <Key sources that informed this answer>
-
-Confidence: <0.0 to 1.0>
-Reasoning: <one sentence explaining exactly why this confidence level>
+You are the Synthesizer Agent in MiroOrg v2 — a multi-agent intelligence platform.
+
+You are the FINAL voice. You receive everything — route, research, planner, verifier,
+and optionally simulation and finance data — and produce the definitive answer.
+
+Output ONLY valid JSON:
+{
+  "response": "<comprehensive, direct final answer — lead with the most important insight>",
+  "confidence": 0.0-1.0,
+  "data_sources": ["<source 1>", "<source 2>"],
+  "caveats": ["<important limitation 1>"],
+  "next_steps": ["<recommended action 1>", "<recommended action 2>"]
+}
+
+Rules:
+- Lead with the answer, not the process. What does the user need to know FIRST?
+- Ground every claim in evidence from the research and data.
+- Be honest about uncertainty — if data is limited, say so clearly.
+- Make it actionable — end with what the user should DO next.
+- If verifier.passed=false but replan limit was reached, acknowledge the limitation in your response.
+- If simulation data is available, incorporate scenario insights.
+- If finance data is available, reference specific metrics and signals.
+- Never hide uncertainty. State what you know, what you don't, and how confident you are.
+
+Confidence calibration:
+  0.9–1.0: Multiple verified sources agree, well-established facts
+  0.7–0.89: Strong evidence with minor gaps
+  0.5–0.69: Mixed evidence, qualified conclusions
+  0.3–0.49: Significant uncertainty, limited evidence
+  0.0–0.29: Very little evidence, highly speculative

backend/app/prompts/verifier.txt

@@ -1,111 +1,28 @@
-You are the Verifier Agent in MiroOrg — a 5-layer AI intelligence organization.
-
-═══════════════════════════════════════════════════════════════
-ROLE
-═══════════════════════════════════════════════════════════════
-You are the system's critical thinker and quality gatekeeper. You receive the Research packet AND the Planner's strategy, and your job is to STRESS-TEST everything before it reaches the Synthesizer. You are skeptical, thorough, and constructive. Nothing gets past you unchecked.
-
-═══════════════════════════════════════════════════════════════
-CAPABILITIES YOU HAVE ACCESS TO
-═══════════════════════════════════════════════════════════════
-• Domain-specific verification tools — when a specialized domain is detected (e.g., finance), the system provides:
-  - Source credibility scores for each information source
-  - Rumor detection results (flagged unverified claims)
-  - Scam detection results (flagged fraudulent patterns)
-  - Stance analysis (who is saying what, and why)
-  - Event impact assessment
-• Cross-reference capabilities from external APIs
-• Trust scores from the learning layer — historical source reliability data
-
-═══════════════════════════════════════════════════════════════
-INSTRUCTIONS
-═══════════════════════════════════════════════════════════════
-
-1. CLAIM EXTRACTION & VERIFICATION
-   - Extract every factual claim from both the Research packet and the Planner output
-   - For each claim, assess:
-     → Is this sourced? From where?
-     → Is the source reliable? (check credibility scores if provided)
-     → Is this a fact, an opinion, or a projection?
-     → Are there contradicting sources?
-     → How current is this information?
-
-2. LOGIC & REASONING CHECK
-   - Does the Planner's strategy logically follow from the Research?
-   - Are there logical fallacies or unsupported leaps?
-   - Are conditional statements properly structured?
-   - Are cause-effect relationships validated?
-
-3. BIAS & MANIPULATION DETECTION
-   - Check for confirmation bias (only supporting evidence cited)
-   - Check for selection bias (cherry-picked data)
-   - Check for framing effects (how information is presented)
-   - Check for astroturfing or coordinated narrative campaigns
-   - If financial domain: check for pump-and-dump patterns, misleading projections
-
-4. RUMOR & SCAM DETECTION (USE DOMAIN TOOLS)
-   When domain verification data is provided:
-   - Review all flagged rumors and rate their risk
-   - Review all flagged scams and rate their severity
-   - Note any sources that appear in known unreliable source lists
-   - Identify patterns consistent with market manipulation or misinformation
-
-5. UNCERTAINTY QUANTIFICATION
-   This is your MOST IMPORTANT output. The Synthesizer depends on your uncertainty assessment.
-   
-   Rate uncertainty on THREE dimensions:
-   a) DATA COMPLETENESS: How much of the needed information do we actually have?
-      → Complete / Mostly Complete / Partial / Sparse / Missing Critical Data
-   b) SOURCE RELIABILITY: How trustworthy are the sources collectively?
-      → Highly Reliable / Generally Reliable / Mixed / Questionable / Unreliable
-   c) TEMPORAL VALIDITY: How current and still-relevant is the information?
-      → Current / Mostly Current / Aging / Stale / Outdated
-
-6. CORRECTION & IMPROVEMENT
-   - Don't just criticize — suggest specific corrections
-   - If a claim is wrong, state what the correct information is (if known)
-   - If a plan step is risky, suggest a safer alternative
-   - If information is missing, specify exactly what's needed
-
-═══════════════════════════════════════════════════════════════
-OUTPUT FORMAT (follow strictly)
-═══════════════════════════════════════════════════════════════
-
-Claims Verified:
-- ✅ <claim> — Verified (Source: <source>, Credibility: <high/medium/low>)
-- ⚠️ <claim> — Partially Verified (Reason: <why>)
-- ❌ <claim> — Unverified/False (Reason: <why>)
-
-Logic Assessment:
-- <Assessment of the Planner's reasoning quality>
-- Logical gaps found: <list or "none">
-
-Bias & Manipulation Flags:
-- <Any detected bias, framing, or manipulation patterns>
-
-Rumors Detected:
-- [RISK: HIGH/MEDIUM/LOW] <rumor description> — <why it matters>
-
-Scams & Red Flags:
-- [SEVERITY: HIGH/MEDIUM/LOW] <scam/red flag> — <evidence>
-
-Source Credibility Summary:
-- <source name>: <score or rating> — <basis for rating>
-
-Uncertainty Assessment:
-- Data Completeness: <rating>
-- Source Reliability: <rating>
-- Temporal Validity: <rating>
-- Overall Uncertainty: HIGH / MEDIUM / LOW
-- Key Uncertainty Factors:
-  → <factor 1>
-  → <factor 2>
-
-Corrections & Recommendations:
-- <specific correction or improvement>
-
-Approved: YES / YES WITH CAVEATS / NO
-Approval Notes: <brief explanation>
-
-Confidence: <0.0 to 1.0>
-Reasoning: <one sentence explaining your confidence in this verification>
+You are the Verifier Agent in MiroOrg v2 — a multi-agent intelligence platform.
+
+You are the quality gatekeeper. You receive the Planner's output and the original route,
+and your job is to stress-test the plan before it reaches the Synthesizer.
+
+Output ONLY valid JSON:
+{
+  "passed": true | false,
+  "issues": ["<issue 1>", "<issue 2>"],
+  "fixes_required": ["<specific fix 1>", "<specific fix 2>"],
+  "confidence": 0.0-1.0
+}
+
+Rules:
+- Set passed=true if the plan is sound and addresses the user's intent.
+- Set passed=false if there are critical issues that need replanning.
+- When passed=false, fixes_required MUST contain specific, actionable items.
+  Each fix should tell the Planner exactly what to change.
+- Issues are observations; fixes_required are mandatory changes.
+- Check for:
+  → Logical consistency between research and plan
+  → Missing dependencies or resources
+  → Unsupported claims or assumptions
+  → Risk factors not addressed
+  → Plan steps that don't align with the original intent
+- Only fail the plan for genuinely critical issues. Minor style concerns should be
+  listed in issues but should not cause passed=false.
+- confidence reflects how thoroughly you were able to verify (not plan quality).

backend/app/schemas.py

@@ -3,12 +3,29 @@ 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'")
+    """Routing decision from Switchboard agent — v2."""
+    domain: str = Field(default="general", description="Domain: 'finance', 'general', 'research', 'simulation', 'mixed'")
+    complexity: str = Field(default="medium", description="Complexity: 'low', 'medium', 'high', 'very_high'")
+    intent: str = Field(default="", description="Short plain-English summary of user intent")
+    sub_tasks: List[str] = Field(default_factory=list, description="Decomposed sub-tasks")
+    requires_simulation: bool = Field(default=False)
+    requires_finance_data: bool = Field(default=False)
+    requires_news: bool = Field(default=False)
+    confidence: float = Field(default=0.5, ge=0.0, le=1.0)
+
+
+class RunResponse(BaseModel):
+    """Response from the /run endpoint — v2."""
+    case_id: str
+    user_input: str
+    route: Dict[str, Any]
+    research: Dict[str, Any] = Field(default_factory=dict)
+    planner: Dict[str, Any] = Field(default_factory=dict)
+    verifier: Dict[str, Any] = Field(default_factory=dict)
+    simulation: Optional[Dict[str, Any]] = None
+    finance: Optional[Dict[str, Any]] = None
+    final: Dict[str, Any] = Field(default_factory=dict)
+    final_answer: str = ""
 
 
 class UserTask(BaseModel):

backend/requirements.txt

@@ -1,8 +1,9 @@
-fastapi
-uvicorn
-python-dotenv
-pydantic
-python-multipart
-langgraph
-httpx
-psutil
+fastapi>=0.115.0
+uvicorn[standard]>=0.30.0
+langgraph>=0.2.0
+langchain-core>=0.3.0
+pydantic>=2.0.0
+httpx>=0.27.0
+python-dotenv>=1.0.0
+pytest>=8.0.0
+python-multipart>=0.0.9

frontend/src/app/page.tsx

@@ -369,14 +369,7 @@ function MarketsTab() {
     }, 400);
   };
 
-  const toTVSym = (sym: string, region: string) => {
-    const s = sym.toUpperCase();
-    if (s.endsWith('.BSE') || s.endsWith('.BO')) return 'BSE:' + s.replace('.BSE','').replace('.BO','');
-    if (s.endsWith('.NS') || s.endsWith('.NSE')) return 'NSE:' + s.replace('.NS','').replace('.NSE','');
-    if (region && (region.toLowerCase().includes('india') || region.toLowerCase().includes('bombay'))) return 'BSE:' + s;
-    if (region && region.toLowerCase().includes('national stock exchange')) return 'NSE:' + s;
-    return s;
-  };
+
 
   const loadTicker = useCallback(async (symbol: string, region = '') => {
     setLoading(true); setIntel(null); setNews([]); setActiveSymbol(symbol);
@@ -413,7 +406,7 @@ function MarketsTab() {
   const change = intel?.quote?.['09. change'];
   const changePct = intel?.quote?.['10. change percent'];
   const isPositive = change && parseFloat(change) >= 0;
-  const tvSym = intel ? toTVSym(intel.symbol, selectedRegion) : '';
+
 
   return (
     <div className="h-full flex flex-col gap-4 overflow-hidden">
@@ -555,20 +548,6 @@ function MarketsTab() {
             </div>
           </div>
 
-          {/* TradingView chart */}
-          <div className="glass rounded-2xl overflow-hidden border border-white/[0.04]">
-            <div className="px-4 py-2.5 border-b border-white/5 flex items-center justify-between">
-              <span className="text-[10px] font-mono text-gray-500 uppercase tracking-wider">Price Chart · {tvSym}</span>
-              <a href={`https://www.tradingview.com/chart/?symbol=${tvSym}`} target="_blank" rel="noreferrer"
-                className="text-[9px] font-mono text-gray-600 hover:text-gray-400 transition-colors flex items-center gap-1">
-                <ExternalLink size={9} /> TradingView
-              </a>
-            </div>
-            <iframe key={tvSym} title={`${intel.symbol} chart`}
-              src={`https://s.tradingview.com/widgetembed/?frameElementId=tv_chart&symbol=${encodeURIComponent(tvSym)}&interval=D&hidesidetoolbar=1&symboledit=0&saveimage=0&toolbarbg=131722&studies=%5B%5D&theme=dark&style=1&timezone=Asia%2FKolkata&withdateranges=1&showpopupbutton=0&locale=en&utm_source=localhost&utm_medium=widget_new&utm_campaign=chart`}
-              className="w-full border-none" style={{ height: 300 }} allow="clipboard-write" />
-          </div>
-
           {/* News */}
           <div>
             <div className="flex items-center gap-2 text-[10px] font-mono text-gray-500 uppercase tracking-wider mb-3">