Fix: Wrap Gradio demo creation in function to prevent module-level initialization errors

server.py

@@ -0,0 +1,886 @@
+"""
+dashboard_server.py
+====================
+Iroha Financial Intelligence — gr.Server entry point.
+
+Architecture
+------------
+gr.Server (extends FastAPI)
+├── GET  /           → serves frontend/index.html
+├── GET  /static/*   → serves frontend/{style.css, app.js}  (StaticFiles)
+│
+├── @server.api  run_inference   → DoFlow / SCM causal query (via BACKEND_API)
+│
+├── GET  /v2/health              → health-check
+│
+└── All existing /v2/* routers from main.py are included here too
+    (so this server is a superset of main.py).
+
+Usage
+-----
+    python dashboard_server.py
+
+Or with uvicorn:
+    uvicorn dashboard_server:server --host 0.0.0.0 --port 7860 --reload
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import json
+import logging
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+import gradio as gr
+from typing import Any, Dict, List, Optional
+from dotenv import load_dotenv
+
+load_dotenv()
+
+BASE_DIR = Path(__file__).parent.resolve()
+if str(BASE_DIR) not in sys.path:
+    sys.path.insert(0, str(BASE_DIR))
+
+# Also add the backend directory to sys.path so we can import 'app', 'causal', etc.
+BACKEND_DIR = (BASE_DIR.parent / "noisy_boy_backend").resolve()
+if BACKEND_DIR.exists() and str(BACKEND_DIR) not in sys.path:
+    sys.path.insert(0, str(BACKEND_DIR))
+
+# ──────────────────────────────────────────────────────────────────[...]
+# Logging
+# ──────────────────────────────────────────────────────────────────[...]
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger("dashboard-server")
+
+# ──────────────────────────────────────────────────────────────────[...]
+# Backend URL
+# ──��───────────────────────────────────────────────────────────────[...]
+
+_BACKEND_BASE_URL: str = os.environ.get("BACKEND_API_URL", "http://localhost:7860")
+
+
+# ──────────────────────────────────────────────────────────────────[...]
+# Public API
+# ──────────────────────────────────────────────────────────────────[...]
+
+def run_pipeline(
+    ticker: str = "RELIANCE",
+    threshold: float = 0.5,
+    treatment: Optional[str] = None,
+    outcome: Optional[str] = None,
+    include_pywhyllm: bool = False,
+) -> Dict[str, Any]:
+    """
+    Fetch the validated causal matrix for *ticker* from the backend API.
+
+    Parameters
+    ----------
+    ticker          : NSE symbol (e.g. RELIANCE, HDFCBANK)
+    threshold       : adjacency threshold for DAG construction
+    treatment       : optional treatment node for pywhyllm assumptions
+    outcome         : optional outcome node  for pywhyllm assumptions
+    include_pywhyllm: request pywhyllm assumption report from backend
+
+    Returns
+    -------
+    dict with keys:
+        nodes, adj_matrix, dag_adj, equations, data_level,
+        topological_order, nodes_graph, links_graph
+    Raises RuntimeError if the backend cannot be reached or returns an error.
+    """
+    params: dict = {"threshold": threshold}
+    if treatment:
+        params["treatment"] = treatment
+    if outcome:
+        params["outcome"] = outcome
+    if include_pywhyllm:
+        params["include_pywhyllm"] = "true"
+
+    qs = urllib.parse.urlencode(params)
+    url = f"{_BACKEND_BASE_URL}/v2/api/singular-causal/causal-matrix/{ticker.upper()}?{qs}"
+    logger.info("run_pipeline: fetching %s", url)
+
+    try:
+        with urllib.request.urlopen(url, timeout=60) as resp:
+            raw = resp.read()
+    except urllib.error.URLError as exc:
+        raise RuntimeError(
+            f"Could not reach backend at {_BACKEND_BASE_URL}. "
+            f"Ensure noisy_boy_backend is running. Original error: {exc}"
+        ) from exc
+
+    payload = json.loads(raw)
+
+    status = payload.get("status")
+    if status == "not_found":
+        raise RuntimeError(
+            payload.get(
+                "detail",
+                f"No cached pipeline data for {ticker} on backend. "
+                "Run the singular-causal pipeline on the backend first.",
+            )
+        )
+    if status not in ("success", None, "ok"):
+        raise RuntimeError(
+            f"Backend returned unexpected status '{status}' for {ticker}. "
+            f"Payload: {payload}"
+        )
+
+    # Build frontend-friendly graph representation
+    nodes: List[str] = payload.get("nodes", [])
+    adj_matrix = payload.get("adj_matrix", [])
+    dag_adj = payload.get("dag_adj", [])
+
+    nodes_graph = [{"id": n, "label": n} for n in nodes]
+    links_graph = []
+    for i, src in enumerate(nodes):
+        for j, dst in enumerate(nodes):
+            if i != j:
+                try:
+                    score = float(adj_matrix[i][j])
+                except (IndexError, TypeError, ValueError):
+                    score = 0.0
+                if score >= threshold:
+                    links_graph.append({"source": src, "target": dst, "score": round(score, 4)})
+
+    return {
+        **payload,
+        "nodes_graph": nodes_graph,
+        "links_graph": links_graph,
+    }
+
+# ─────────────────��────────────────────────────────────────────────[...]
+# Helpers
+# ──────────────────────────────────────────────────────────────────[...]
+
+# URL of the noisy_boy_backend — used to fetch the validated causal matrix.
+# By default, point to ourselves since we now successfully mount the backend routers.
+# Override via BACKEND_API_URL env var if running a separate backend on 8000.
+_BACKEND_BASE_URL = os.environ.get("BACKEND_API_URL", "http://localhost:7860")
+
+
+def _fetch_causal_matrix(
+    ticker: str,
+    treatment: Optional[str] = None,
+    outcome: Optional[str] = None,
+    include_pywhyllm: bool = False,
+    threshold: float = 0.5,
+) -> Optional[dict]:
+    """
+    Fetch the fully validated causal matrix from the backend API.
+
+    Calls GET {BACKEND_BASE_URL}/v2/api/singular-causal/causal-matrix/{ticker}
+    and returns the parsed JSON payload, or None on failure.
+
+    The payload contains:
+      nodes        — ordered list of node names
+      adj_matrix   — raw float adjacency matrix
+      dag_adj      — thresholded 0/1 DAG
+      equations    — per-node structural equations (coefficients, intercepts, residual_std)
+      data_level   — (T, N) time-series observations used to fit the SCM
+      topological_order — nodes in topological traversal order
+      pywhyllm_report   — (optional) assumption analysis for treatment→outcome
+    """
+    import urllib.request
+    import urllib.error
+    import urllib.parse
+
+    params: dict = {"threshold": threshold}
+    if treatment:
+        params["treatment"] = treatment
+    if outcome:
+        params["outcome"] = outcome
+    if include_pywhyllm:
+        params["include_pywhyllm"] = "true"
+
+    query_string = urllib.parse.urlencode(params)
+    url = f"{_BACKEND_BASE_URL}/v2/api/singular-causal/causal-matrix/{ticker.upper()}?{query_string}"
+
+    try:
+        with urllib.request.urlopen(url, timeout=30) as resp:
+            raw = resp.read()
+        data = json.loads(raw)
+        if data.get("status") not in ("success", None):
+            logger.warning(
+                "_fetch_causal_matrix: backend returned status=%s for URL %s. Payload: %s",
+                data.get("status"), url, data,
+            )
+            return None
+        return data
+    except Exception as exc:
+        logger.warning("_fetch_causal_matrix failed for %s: %s", ticker, exc)
+        return None
+
+
+def _safe_json(obj: Any) -> Any:
+    """Recursively make numpy types JSON-serialisable."""
+    try:
+        import numpy as np
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+    except ImportError:
+        pass
+    if isinstance(obj, dict):
+        return {k: _safe_json(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_safe_json(v) for v in obj]
+    return obj
+
+
+def _resolve_value(value: float, value_type: str, current: float) -> float:
+    """Convert a user-supplied value + value_type to the absolute node value."""
+    vt = value_type.strip().lower()
+    if vt == "absolute":
+        return value
+    if vt == "multiplier":
+        return current * value
+    if vt == "percent_change":
+        return current * (1.0 + value / 100.0)
+    # default: treat as absolute
+    return value
+
+
+# ──────────────────────────────────────────────────────────────────[...]
+# Pure-numpy inference helpers (no local causal training imports)
+# These functions work entirely from the payload returned by the backend API.
+# ──────────────────────────────────────────────────────────────────[...]
+
+def _build_dag_from_payload(payload: dict):
+    """
+    Return a numpy bool DAG adjacency matrix and list of node names
+    from the backend causal-matrix payload.
+    """
+    import numpy as np
+    nodes = payload["nodes"]
+    dag_adj = np.array(payload["dag_adj"], dtype=bool)
+    adj_matrix = np.array(payload["adj_matrix"], dtype=float)
+    return nodes, dag_adj, adj_matrix
+
+
+def _propagate_intervention(
+    nodes: list,
+    dag_adj,
+    equations: dict,
+    data_level,
+    topological_order: list,
+    treatment: str,
+    abs_value: float,
+    targets: list,
+    horizon: int = 5,
+):
+    """
+    Propagate a hard intervention (do(treatment=abs_value)) through the
+    structural equations for `horizon` steps, returning ATE per target node.
+    Uses only numpy — no local causal model imports.
+    """
+    import numpy as np
+
+    node_to_idx = {n: i for i, n in enumerate(nodes)}
+    n = len(nodes)
+    T = data_level.shape[0]
+
+    # Start from the last observed time step
+    state = data_level[-1].copy().astype(float)
+
+    # Fix the treatment node
+    t_idx = node_to_idx[treatment]
+    state[t_idx] = abs_value
+
+    ate_per_target: Dict[str, float] = {}
+    baseline = data_level[-1].copy().astype(float)
+
+    for _ in range(horizon):
+        new_state = state.copy()
+        for node_name in topological_order:
+            if node_name == treatment:
+                continue
+            eq = equations.get(node_name)
+            if eq is None:
+                continue
+            parents = eq.get("parents", [])
+            coefficients = eq.get("coefficients", {})
+            intercept = float(eq.get("intercept", 0.0))
+            if not parents:
+                continue
+            val = intercept
+            for p in parents:
+                p_idx = node_to_idx.get(p)
+                if p_idx is not None:
+                    val += float(coefficients.get(p, 0.0)) * float(state[p_idx])
+            n_idx = node_to_idx[node_name]
+            new_state[n_idx] = val
+        state = new_state
+
+    for target in targets:
+        t_i = node_to_idx.get(target)
+        if t_i is not None:
+            ate_per_target[target] = float(state[t_i] - baseline[t_i])
+
+    return ate_per_target, state
+
+
+def _abduct_and_predict(
+    nodes: list,
+    dag_adj,
+    equations: dict,
+    data_level,
+    topological_order: list,
+    treatment: str,
+    cf_value: float,
+    target: str,
+    observed_t: int,
+):
+    """
+    Simple SCM abduction for counterfactual:
+      1. Abduct residuals from the observed time step.
+      2. Re-run structural equations with treatment fixed to cf_value.
+      3. Return factual_outcome, cf_outcome, ITE.
+    """
+    import numpy as np
+
+    node_to_idx = {n: i for i, n in enumerate(nodes)}
+    obs = data_level[observed_t].copy().astype(float)
+
+    # Abduct residuals
+    residuals: Dict[str, float] = {}
+    for node_name in topological_order:
+        eq = equations.get(node_name)
+        if eq is None or not eq.get("parents"):
+            residuals[node_name] = 0.0
+            continue
+        parents = eq.get("parents", [])
+        coefficients = eq.get("coefficients", {})
+        intercept = float(eq.get("intercept", 0.0))
+        predicted = intercept
+        for p in parents:
+            p_idx = node_to_idx.get(p)
+            if p_idx is not None:
+                predicted += float(coefficients.get(p, 0.0)) * float(obs[node_to_idx[p]])
+        residuals[node_name] = float(obs[node_to_idx[node_name]]) - predicted
+
+    # Counterfactual: fix treatment, replay equations with abducted noise
+    cf_state = obs.copy()
+    cf_state[node_to_idx[treatment]] = cf_value
+
+    for node_name in topological_order:
+        if node_name == treatment:
+            continue
+        eq = equations.get(node_name)
+        if eq is None or not eq.get("parents"):
+            continue
+        parents = eq.get("parents", [])
+        coefficients = eq.get("coefficients", {})
+        intercept = float(eq.get("intercept", 0.0))
+        predicted = intercept
+        for p in parents:
+            p_idx = node_to_idx.get(p)
+            if p_idx is not None:
+                predicted += float(coefficients.get(p, 0.0)) * float(cf_state[p_idx])
+        n_idx = node_to_idx[node_name]
+        cf_state[n_idx] = predicted + residuals.get(node_name, 0.0)
+
+    factual_outcome = float(obs[node_to_idx[target]])
+    cf_outcome = float(cf_state[node_to_idx[target]])
+    ite = cf_outcome - factual_outcome
+    return factual_outcome, cf_outcome, ite
+
+
+# ── API: Causal inference (assert / intervene / counterfactual) ───────────
+#
+# Architecture:
+#   1. Fetch the VALIDATED causal matrix from noisy_boy_backend via HTTP.
+#      The backend has already run CUTS+ learning + pywhyllm + DoWhy validation.
+#   2. Use the payload data (equations, adj, data_level) for inference
+#      using pure numpy/pandas — no local causal training imports required.
+#   3. Optionally consult pywhyllm guidance from the backend payload.
+
+
+def run_inference(
+    ticker: str = "RELIANCE",
+    mode: str = "assert",
+    treatment: str = "Revenue",
+    outcome: Optional[str] = "NetIncome",
+    target: Optional[str] = None,
+    value: float = 1.1,
+    cf_value: Optional[float] = None,
+    value_type: str = "multiplier",
+    horizon: int = 5,
+    observed_t: int = -1,
+    threshold: float = 0.5,
+    use_pywhyllm: bool = False,
+    return_assumption_report: bool = False,
+) -> Dict[str, Any]:
+    """
+    Three-layer causal inference driven by the backend's validated causal matrix.
+
+    Parameters
+    ----------
+    ticker       : NSE ticker (backend must have a cached pipeline run for it)
+    mode         : "assert" | "intervene" | "counterfactual"
+    treatment    : source node name
+    outcome      : outcome node  (assert / Layer-1 association)
+    target       : target node   (counterfactual / Layer-3); if None, falls back to outcome
+    value        : intervention magnitude (Layer 2)
+    cf_value     : explicit counterfactual value (Layer 3); if None, 'value' + 'value_type' used
+    value_type   : "absolute" | "multiplier" | "percent_change"
+    horizon      : propagation horizon for intervention (Layer 2, steps)
+    observed_t   : time index for counterfactual abduction (Layer 3; -1 = last obs)
+    threshold    : adjacency threshold used when loading the graph
+    use_pywhyllm : consult pywhyllm for structural assumptions before running DoWhy
+    return_assumption_report : include the pywhyllm report dict in the response
+
+    Returns
+    -------
+    JSON with ate, ci_lower, ci_upper, probability, ripple_effects,
+    and (for counterfactual) factual_outcome, counterfactual_outcome, ite,
+    shapley_contributions.
+    """
+    import numpy as np
+    import pandas as pd
+
+    try:
+        # ── 0. Determine target node ──────────────────────────────────────────
+        target_node = target if target else outcome
+        if not target_node:
+            return {"status": "error", "detail": "Either 'outcome' or 'target' must be provided."}
+
+        # ── 1. Fetch validated causal matrix from backend ─────────────────────
+        #      This includes the adjacency matrix, fitted structural equations,
+        #      level-domain data, and optionally a pywhyllm assumption report.
+        payload = _fetch_causal_matrix(
+            ticker=ticker,
+            treatment=treatment if use_pywhyllm else None,
+            outcome=target_node if use_pywhyllm else None,
+            include_pywhyllm=use_pywhyllm,
+            threshold=threshold,
+        )
+
+        if payload is None:
+            return {
+                "status": "error",
+                "detail": (
+                    f"Could not fetch causal matrix for {ticker} from backend. "
+                    "Ensure noisy_boy_backend is running and the pipeline has been run for this ticker."
+                ),
+            }
+
+        if payload.get("status") == "not_found":
+            return {
+                "status": "error",
+                "detail": payload.get("detail", f"No cached pipeline data for {ticker}."),
+            }
+
+        # ── 2. Unpack payload (no local causal training imports) ──────────────
+        nodes, dag_adj, adj_matrix = _build_dag_from_payload(payload)
+        node_to_idx = {n: i for i, n in enumerate(nodes)}
+        data_level = np.array(payload["data_level"], dtype=float)
+        equations_raw = payload.get("equations", {})
+        topo_order = payload.get("topological_order", nodes)
+
+        T = data_level.shape[0]
+        df = pd.DataFrame(data_level, columns=nodes)
+
+        if treatment not in node_to_idx:
+            return {"status": "error", "detail": f"Unknown treatment node: {treatment}"}
+        if target_node not in node_to_idx:
+            return {"status": "error", "detail": f"Unknown outcome/target node: {target_node}"}
+        if df.shape[0] < 5:
+            return {
+                "status": "error",
+                "detail": f"Insufficient observations ({df.shape[0]}) to run inference.",
+            }
+
+        # ── 3. pywhyllm structural guidance (from backend payload) ────────────
+        pywhyllm_report: Optional[dict] = payload.get("pywhyllm_report")
+        adjustment_sets: List[List[str]] = []
+
+        if use_pywhyllm and pywhyllm_report and pywhyllm_report.get("available"):
+            raw_backdoor = pywhyllm_report.get("suggested_backdoor_sets") or []
+            valid_nodes = set(nodes) - {treatment, target_node}
+            for suggested_set in raw_backdoor:
+                clean = [n for n in suggested_set if n in valid_nodes]
+                if clean and clean not in adjustment_sets:
+                    adjustment_sets.append(clean)
+
+            confounders = [
+                n for n in (pywhyllm_report.get("suggested_confounders") or [])
+                if n in valid_nodes
+            ]
+            if confounders and confounders not in adjustment_sets:
+                adjustment_sets.append(confounders)
+
+        result: Dict[str, Any] = {}
+
+        # ═══════════════════════════════════════════════════════════════[...]
+        # LAYER 1 — Association: "What does Y look like given X?"
+        # Uses DoWhy with the backend-provided DAG, falling back to OLS.
+        # ═══════════════════════════════════════════════════════════════[...]
+        if mode == "assert":
+            try:
+                from dowhy import CausalModel
+
+                # Build DOT graph string from dag_adj
+                edges = []
+                for si, src in enumerate(nodes):
+                    for di, dst in enumerate(nodes):
+                        if dag_adj[si, di]:
+                            edges.append(f"{src} -> {dst}")
+                graph_dot = "digraph{" + "; ".join(edges) + "}"
+
+                dowhy_model = CausalModel(
+                    data=df,
+                    treatment=treatment,
+                    outcome=target_node,
+                    graph=graph_dot,
+                )
+                identified_estimand = dowhy_model.identify_effect(
+                    proceed_when_unidentifiable=True
+                )
+                estimate = dowhy_model.estimate_effect(
+                    identified_estimand,
+                    method_name="backdoor.linear_regression",
+                )
+                ate = float(estimate.value)
+
+                # Confidence interval from OLS residuals
+                se: float = 0.0
+                try:
+                    import numpy.linalg as nla
+                    X = df[[c for c in df.columns if c != target_node]].values
+                    y = df[target_node].values
+                    XtX_inv = nla.pinv(X.T @ X)
+                    resid = y - X @ nla.lstsq(X, y, rcond=None)[0]
+                    sigma2 = float(np.sum(resid ** 2) / max(1, len(y) - X.shape[1]))
+                    t_idx_local = list(df.columns).index(treatment)
+                    se = float(np.sqrt(max(0.0, sigma2 * XtX_inv[t_idx_local, t_idx_local])))
+                except Exception:
+                    se = abs(ate) * 0.15  # graceful fallback
+
+                ci_lower = ate - 1.96 * se
+                ci_upper = ate + 1.96 * se
+                prob = min(1.0, abs(ate) / (abs(ate) + se + 1e-9))
+
+                # Ripple effects: direct downstream neighbours of treatment
+                ripple_effects = []
+                t_idx_g = node_to_idx[treatment]
+                for j, node in enumerate(nodes):
+                    if node == treatment or node == target_node:
+                        continue
+                    if dag_adj[t_idx_g, j]:
+                        edge_score = float(adj_matrix[t_idx_g, j])
+                        ripple_effects.append({
+                            "ticker": node,
+                            "direction": 1 if ate > 0 else -1,
+                            "magnitude": round(edge_score * abs(ate), 4),
+                        })
+
+                result = {
+                    "ate": ate,
+                    "ci_lower": ci_lower,
+                    "ci_upper": ci_upper,
+                    "probability": prob,
+                    "strategy": "backdoor.linear_regression",
+                    "adjustment_set": adjustment_sets[0] if adjustment_sets else [],
+                    "ripple_effects": ripple_effects,
+                }
+
+            except Exception as dowhy_exc:
+                # DoWhy not installed or identification failed — fall back to OLS
+                logger.warning("DoWhy association failed (%s), falling back to OLS", dowhy_exc)
+                t_idx_g = node_to_idx[treatment]
+                out_idx = node_to_idx[target_node]
+
+                # Simple OLS: regress target on treatment
+                X = df[[treatment]].values
+                y = df[target_node].values
+                import numpy.linalg as nla
+                coef = nla.lstsq(np.c_[np.ones(len(X)), X], y, rcond=None)[0]
+                ate = float(coef[1])
+                se = abs(ate) * 0.15
+                ci_lower = ate - 1.96 * se
+                ci_upper = ate + 1.96 * se
+
+                ripple_effects = []
+                for j, node in enumerate(nodes):
+                    if node == treatment or node == target_node:
+                        continue
+                    if dag_adj[t_idx_g, j]:
+                        ripple_effects.append({
+                            "ticker": node,
+                            "direction": 1 if ate > 0 else -1,
+                            "magnitude": round(float(adj_matrix[t_idx_g, j]) * abs(ate), 4),
+                        })
+
+                result = {
+                    "ate": ate,
+                    "ci_lower": ci_lower,
+                    "ci_upper": ci_upper,
+                    "probability": min(1.0, abs(ate) / (abs(ate) + se + 1e-9)),
+                    "strategy": "ols_fallback",
+                    "adjustment_set": adjustment_sets[0] if adjustment_sets else [],
+                    "ripple_effects": ripple_effects,
+                }
+
+        # ═══════════════════════════════════════════════════════════════[...]
+        # LAYER 2 — Intervention: "What will happen to Y if we do X=value?"
+        # Propagates through structural equations from the backend payload.
+        # ═══════════════════════════════════════════════════════════════[...]
+        elif mode == "intervene":
+            current_val = float(data_level[-1, node_to_idx[treatment]])
+            abs_value = _resolve_value(value, value_type, current_val)
+
+            # Try DoWhy for ATE estimation first
+            ate = 0.0
+            method_used = "scm_propagation"
+            try:
+                from dowhy import CausalModel
+
+                edges = []
+                for si, src in enumerate(nodes):
+                    for di, dst in enumerate(nodes):
+                        if dag_adj[si, di]:
+                            edges.append(f"{src} -> {dst}")
+                graph_dot = "digraph{" + "; ".join(edges) + "}"
+
+                dowhy_model = CausalModel(
+                    data=df,
+                    treatment=treatment,
+                    outcome=target_node,
+                    graph=graph_dot,
+                )
+                identified_estimand = dowhy_model.identify_effect(
+                    proceed_when_unidentifiable=True
+                )
+                estimate = dowhy_model.estimate_effect(
+                    identified_estimand,
+                    method_name="backdoor.linear_regression",
+                )
+                ate_unit = float(estimate.value)
+                delta = abs_value - current_val
+                ate = ate_unit * delta
+                method_used = "backdoor.linear_regression"
+            except Exception as dowhy_exc:
+                logger.warning("DoWhy intervention failed (%s), using SCM propagation", dowhy_exc)
+
+            # SCM propagation for ripple effects (pure numpy, no training imports)
+            ate_per_target, final_state = _propagate_intervention(
+                nodes=nodes,
+                dag_adj=dag_adj,
+                equations=equations_raw,
+                data_level=data_level,
+                topological_order=topo_order,
+                treatment=treatment,
+                abs_value=abs_value,
+                targets=[target_node] + [n for n in nodes if n != treatment],
+                horizon=horizon,
+            )
+
+            if method_used == "scm_propagation" and target_node in ate_per_target:
+                ate = float(ate_per_target[target_node])
+
+            se = abs(ate) * 0.12
+            ci_lower = ate - 1.96 * se
+            ci_upper = ate + 1.96 * se
+
+            ripple_effects = []
+            for node, delta_val in ate_per_target.items():
+                if node == treatment:
+                    continue
+                ripple_effects.append({
+                    "ticker": node,
+                    "direction": 1 if float(delta_val) > 0 else -1,
+                    "magnitude": round(abs(float(delta_val)), 4),
+                })
+
+            result = {
+                "ate": ate,
+                "ci_lower": ci_lower,
+                "ci_upper": ci_upper,
+                "probability": min(1.0, abs(ate) / (abs(ate) + abs(ci_upper - ci_lower) / 2 + 1e-9)),
+                "strategy": method_used,
+                "intervention_value": abs_value,
+                "value_type": value_type,
+                "horizon": horizon,
+                "ripple_effects": ripple_effects,
+                "adjustment_set": adjustment_sets[0] if adjustment_sets else [],
+            }
+
+        # ═══════════════════════════════════════════════════════════════[...]
+        # LAYER 3 — Counterfactual: "What if X had been different in the past?"
+        # Uses SCM abduction via pure numpy structural equations.
+        # ═══════════════════════════════════════════════════════════════[...]
+        elif mode in ("counterfactual", "counter"):
+            # Resolve observed timestep
+            t = observed_t if observed_t >= 0 else (T + observed_t)
+            t = max(0, min(T - 1, t))
+
+            # Resolve counterfactual value
+            current_val = float(data_level[t, node_to_idx[treatment]])
+            if cf_value is not None:
+                abs_cf_value = float(cf_value)
+            else:
+                abs_cf_value = _resolve_value(value, value_type, current_val)
+
+            # Try DoWhy GCM first
+            gcm_used = False
+            factual_outcome = 0.0
+            cf_outcome_val = 0.0
+            ite = 0.0
+
+            try:
+                import dowhy.gcm as gcm_module
+                import networkx as nx
+
+                causal_graph = nx.DiGraph()
+                for si, src in enumerate(nodes):
+                    for di, dst in enumerate(nodes):
+                        if dag_adj[si, di]:
+                            causal_graph.add_edge(src, dst)
+                for node in nodes:
+                    if node not in causal_graph.nodes:
+                        causal_graph.add_node(node)
+
+                gcm_model = gcm_module.InvertibleStructuralCausalModel(causal_graph)
+                gcm_module.auto.assign_mechanisms(gcm_model, df)
+                gcm_module.fit(gcm_model, df)
+
+                observed_data = df.iloc[[t]]
+                cf_val_fixed = abs_cf_value
+                cf_samples = gcm_module.counterfactual_samples(
+                    gcm_model,
+                    {treatment: lambda x, v=cf_val_fixed: np.full(x.shape, v)},
+                    observed_data=observed_data,
+                    num_samples_to_draw=1,
+                )
+
+                factual_outcome = float(observed_data[target_node].iloc[0])
+                cf_outcome_val = float(cf_samples[target_node].iloc[0])
+                ite = cf_outcome_val - factual_outcome
+                gcm_used = True
+
+            except Exception as gcm_exc:
+                logger.warning("DoWhy GCM counterfactual failed (%s), using SCM abduction", gcm_exc)
+
+            if not gcm_used:
+                factual_outcome, cf_outcome_val, ite = _abduct_and_predict(
+                    nodes=nodes,
+                    dag_adj=dag_adj,
+                    equations=equations_raw,
+                    data_level=data_level,
+                    topological_order=topo_order,
+                    treatment=treatment,
+                    cf_value=abs_cf_value,
+                    target=target_node,
+                    observed_t=t,
+                )
+
+            # Shapley: single-treatment — just use the ITE directly
+            shapley = {treatment: ite}
+
+            # SE from residual_std of the target equation (from backend payload)
+            target_eq_data = equations_raw.get(target_node, {})
+            se = float(target_eq_data.get("residual_std", abs(ite) * 0.15))
+            ci_lower = ite - 1.96 * se
+            ci_upper = ite + 1.96 * se
+
+            result = {
+                "ate": ite,
+                "ite": ite,
+                "factual_outcome": factual_outcome,
+                "counterfactual_outcome": cf_outcome_val,
+                "ci_lower": ci_lower,
+                "ci_upper": ci_upper,
+                "probability": min(1.0, abs(ite) / (abs(ite) + se + 1e-9)),
+                "strategy": "dowhy_gcm" if gcm_used else "scm_abduction",
+                "counterfactual_value": abs_cf_value,
+                "value_type": value_type,
+                "observed_t": t,
+                "shapley_contributions": shapley,
+                "ripple_effects": [],
+            }
+
+        else:
+            return {
+                "status": "error",
+                "detail": f"Unknown mode '{mode}'. Must be one of: assert, intervene, counterfactual.",
+            }
+
+        # ── Attach pywhyllm assumption report if requested ────────────────────
+        if return_assumption_report and pywhyllm_report:
+            result["pywhyllm_report"] = pywhyllm_report
+
+        return _safe_json({"status": "ok", "ticker": ticker.upper(), "mode": mode, **result})
+
+    except Exception as exc:
+        logger.exception("run_inference failed")
+        return {"status": "error", "detail": str(exc)}
+
+
+# ──────────────────────────────────────────────────────────────────[...]
+# Gradio UI & Entry point
+# ──────────────────────────────────────────────────────────────────[...]
+
+def create_demo():
+    """Create and return the Gradio Blocks interface."""
+    with gr.Blocks(title="Iroha Causal Terminal") as demo:
+        gr.Markdown("# Iroha Causal Terminal")
+        gr.Markdown("Iroha Financial Intelligence — real-time causal probability matrix, HHKD decomposition, DoFlow inference and sector hierarchy over NIFTY50.")
+        
+        with gr.Row():
+            ticker = gr.Textbox(label="Ticker", value="RELIANCE")
+            mode = gr.Dropdown(choices=["assert", "intervene", "counterfactual"], label="Mode", value="assert")
+            treatment = gr.Textbox(label="Treatment", value="Revenue")
+            outcome = gr.Textbox(label="Outcome", value="NetIncome")
+            target = gr.Textbox(label="Target", value="")
+            
+        with gr.Row():
+            value = gr.Number(label="Value", value=1.1)
+            cf_value = gr.Number(label="CF Value")
+            value_type = gr.Dropdown(choices=["absolute", "multiplier", "percent_change"], label="Value Type", value="multiplier")
+            horizon = gr.Number(label="Horizon", value=5, precision=0)
+            observed_t = gr.Number(label="Observed T", value=-1, precision=0)
+            threshold = gr.Number(label="Threshold", value=0.5)
+            
+        with gr.Row():
+            use_pywhyllm = gr.Checkbox(label="Use PyWhyLLM", value=False)
+            return_assumption_report = gr.Checkbox(label="Return Assumption Report", value=False)
+            
+        btn = gr.Button("Run Inference")
+        out = gr.JSON(label="Result")
+        
+        btn.click(
+            fn=run_inference,
+            inputs=[
+                ticker, mode, treatment, outcome, target, value, cf_value, value_type,
+                horizon, observed_t, threshold, use_pywhyllm, return_assumption_report
+            ],
+            outputs=out,
+            api_name="run_inference"
+        )
+    
+    return demo
+
+
+if __name__ == "__main__":
+    port = int(os.environ.get("GRADIO_SERVER_PORT", os.environ.get("PORT", "7860")))
+    host = os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0")
+
+    logger.info(f"Starting Iroha Causal Terminal on {host}:{port}")
+
+    demo = create_demo()
+    demo.launch(
+        server_name=host,
+        server_port=port,
+        show_error=True,
+    )