Merged branches

.gitignore

@@ -7,7 +7,7 @@
 *.csv
 *.png
 *.grd
-*.json
-*.yaml
 *.owl
 *.out
+*.json
+*.yaml

README.md

@@ -7,3 +7,10 @@ sdk_version: 6.18.0
 app_file: server.py
 pinned: false
 ---
+
+# Iroha - Financial Intelligence Pipeline API
+
+**Version:** 1.0.0  
+**Description:** End-to-end financial intelligence pipeline for Net-of-Tax Alpha decisions using causal chain analysis, web scraping, and data aggregation.
+
+---

frontend/app.js

@@ -0,0 +1,849 @@
+/**
+ * CUTS+ Causal Terminal — Frontend Logic
+ * Communicates with the gr.Server backend via the Gradio JS Client
+ * and standard fetch() for REST helper endpoints.
+ */
+
+// ── Gradio Client bootstrap ────────────────────────────────────────────────
+// Loaded from CDN in index.html; window.GradioClient is set after import.
+let GR_CLIENT = null;
+
+async function initGradioClient() {
+  try {
+    const { Client } = await import('https://cdn.jsdelivr.net/npm/@gradio/client/dist/index.min.js');
+    GR_CLIENT = await Client.connect(window.location.origin);
+    setBannerState('gradio', 'ok', 'GRADIO OK');
+  } catch (err) {
+    console.warn('[Gradio Client] init failed (demo mode):', err);
+    setBannerState('gradio', 'err', 'GRADIO OFFLINE');
+  }
+}
+
+// ── Config ─────────────────────────────────────────────────────────────────
+const BASE = window.location.origin;   // same origin — gr.Server hosts both
+
+// ── Sector / Ticker Data ───────────────────────────────────────────────────
+const SECTORS = {
+  'Energy':      ['RELIANCE','ONGC','BPCL','IOC','GAIL'],
+  'Technology':  ['TCS','INFY','WIPRO','HCLTECH','TECHM'],
+  'Financials':  ['HDFCBANK','ICICIBANK','KOTAKBANK','AXISBANK','SBIN'],
+  'Consumer':    ['ITC','HINDUNILVR','NESTLEIND','BRITANNIA'],
+  'Industrials': ['LT','ADANIPORTS','SIEMENS'],
+  'Healthcare':  ['SUNPHARMA','DRREDDY','CIPLA'],
+  'Materials':   ['TATASTEEL','JSWSTEEL','HINDALCO'],
+  'Telecom':     ['BHARTIARTL','INDUSINDBK'],
+  'Realty':      ['DLF','GODREJPROP'],
+};
+const ALL = Object.values(SECTORS).flat();
+const N   = ALL.length;
+const TICKER_SEC = {};
+for (const [s, ms] of Object.entries(SECTORS)) ms.forEach(t => TICKER_SEC[t] = s);
+const SEC_NAMES = Object.keys(SECTORS);
+const S = SEC_NAMES.length;
+
+// ── Deterministic RNG ──────────────────────────────────────────────────────
+function mkRng(seed) {
+  let s = seed;
+  return () => { s = (s * 16807) % 2147483647; return (s - 1) / 2147483646; };
+}
+
+// ── φ Potentials (HHKD output — seeded defaults, overridden by API) ────────
+const rA = mkRng(42);
+const PHI = {};
+[
+  ['RELIANCE',2.41],['ONGC',2.18],['TCS',2.05],['BHARTIARTL',1.92],['LT',1.78],
+  ['INFY',1.65],['HDFCBANK',1.52],['ICICIBANK',1.39],['BPCL',1.28],['GAIL',1.14],
+  ['WIPRO',1.02],['HCLTECH',0.89],['IOC',0.76],['KOTAKBANK',0.65],['AXISBANK',0.54],
+  ['SBIN',0.41],['ITC',0.28],['HINDUNILVR',0.15],['NESTLEIND',0.03],['TATASTEEL',-0.09],
+  ['JSWSTEEL',-0.22],['HINDALCO',-0.35],['SUNPHARMA',-0.48],['DRREDDY',-0.61],
+  ['CIPLA',-0.74],['SIEMENS',-0.87],['ADANIPORTS',-1.13],
+  ['TECHM',-1.26],['BRITANNIA',-1.39],['INDUSINDBK',-1.52],['DLF',-1.65],
+  ['GODREJPROP',-1.78],
+].forEach(([t, v]) => PHI[t] = v);
+ALL.forEach(t => { if (PHI[t] == null) PHI[t] = -1.2 + rA() * 0.4; });
+
+const SEC_PHI = {};
+for (const [s, ms] of Object.entries(SECTORS))
+  SEC_PHI[s] = ms.reduce((a, t) => a + (PHI[t] || 0), 0) / ms.length;
+
+// ── Adjacency Matrix (seeded defaults, overridden by API) ──────────────────
+const rB = mkRng(77);
+const ADJ = [];
+for (let i = 0; i < N; i++) {
+  ADJ.push([]);
+  for (let j = 0; j < N; j++) {
+    if (i === j) { ADJ[i].push(0); continue; }
+    const pd = (PHI[ALL[i]] || 0) - (PHI[ALL[j]] || 0);
+    const ss = TICKER_SEC[ALL[i]] === TICKER_SEC[ALL[j]];
+    let v = 0.04 + Math.max(0, pd) * 0.14 + (ss ? 0.09 : 0) + rB() * 0.08;
+    if (pd > 0.8) v += 0.22;
+    ADJ[i].push(Math.min(0.97, Math.max(0.01, v)));
+  }
+}
+
+const EDGES = [];
+for (let i = 0; i < N; i++)
+  for (let j = 0; j < N; j++)
+    if (ADJ[i][j] > 0.5) EDGES.push({ si: i, ti: j, w: ADJ[i][j] });
+
+// ── Sector Macro Adjacency ─────────────────────────────────────────────────
+const MADJ = Array.from({ length: S }, () => Array(S).fill(0));
+for (let a = 0; a < S; a++)
+  for (let b = 0; b < S; b++) {
+    if (a === b) continue;
+    MADJ[a][b] = Math.min(
+      0.96,
+      Math.max(0.02, 0.28 + (SEC_PHI[SEC_NAMES[a]] - SEC_PHI[SEC_NAMES[b]]) * 0.18 + mkRng(a * 9 + b + 1)() * 0.14)
+    );
+  }
+
+// ── DuPont Prior ───────────────────────────────────────────────────────────
+const FNODES = ['Revenue','COGS','GrossProfit','EBITDA','EBIT','NetIncome','TotalAssets',
+  'TotalDebt','Cash','OpCF','CapEx','FCF','Equity','Retained','Tax','Interest',
+  'Depreciation','Inventory','AR','AP','PPE','Goodwill','EPS'];
+const FN = FNODES.length;
+const FPRIOR = Array.from({ length: FN }, () => Array(FN).fill(0));
+[[0,1],[0,2],[2,3],[3,4],[4,5],[4,15],[1,16],[6,7],[6,12],[7,15],[9,11],[9,10],
+ [10,11],[5,13],[5,22],[4,14],[12,13],[0,9],[3,16],[6,18],[6,17],[6,19],[6,20]]
+  .forEach(([a, b]) => FPRIOR[a][b] = 1);
+
+// ── News Feed Data ─────────────────────────────────────────────────────────
+const NEWS = [
+  { sym:'RELIANCE', score:0.91, dir: 1, text:'RIL Jio 5G capex ₹40kCr accelerates infrastructure spend',     tags:['CapEx','FCF','Revenue'] },
+  { sym:'HDFCBANK', score:0.84, dir:-1, text:'RBI repo hike 25bps — NIM compression expected Q2FY25',          tags:['NetIncome','Interest','TotalDebt'] },
+  { sym:'TCS',      score:0.79, dir: 1, text:'TCS Q3 deal wins ₹14kCr; US enterprise recovery signal',          tags:['Revenue','NetIncome','EPS'] },
+  { sym:'TATASTEEL',score:0.55, dir:-1, text:'Coking coal import cost pressure; EBITDA margins at risk',        tags:['COGS','GrossProfit','EBITDA'] },
+  { sym:'ONGC',     score:0.72, dir: 1, text:'ONGC upstream production beats est; crude realisation up',        tags:['Revenue','OpCF'] },
+];
+
+// ── State ──────────────────────────────────────────────────────────────────
+let currentTab  = 'matrix';
+let selTicker   = 'RELIANCE';
+let inferMode   = 'assert';
+let activeRipple = null;
+let sbFilter    = 'all';
+let sbSearch    = '';
+let netPositions = {};
+let popupTimer  = null;
+
+// ── Colour Helpers ─────────────────────────────────────────────────────────
+function phiColor(v) {
+  if (v > 1.5) return '#f0a500';
+  if (v > 0.5) return '#d4b840';
+  if (v > -0.5) return '#00b8d4';
+  return '#5a5a54';
+}
+function adjColor(v) {
+  if (v > 0.7) return `rgba(224,52,52,${0.45 + v * 0.5})`;
+  if (v > 0.4) return `rgba(240,165,0,${0.25 + v * 0.65})`;
+  return `rgba(0,80,40,${v * 1.8})`;
+}
+function clamp(v, a, b) { return Math.max(a, Math.min(b, v)); }
+function fmtPhi(v) { return (v >= 0 ? '+' : '') + v.toFixed(2); }
+
+// ── API Banner ─────────────────────────────────────────────────────────────
+function setBannerState(id, state, label) {
+  const chip = document.getElementById(`api-${id}`);
+  if (!chip) return;
+  chip.className = `api-chip ${state}`;
+  const dot = chip.querySelector('.api-dot');
+  if (dot) dot.setAttribute('title', label);
+  const span = chip.querySelector('span:last-child');
+  if (span) span.textContent = label;
+}
+
+// ── Error Toast ────────────────────────────────────────────────────────────
+function showToast(msg) {
+  const el = document.getElementById('error-toast');
+  if (!el) return;
+  el.textContent = msg;
+  el.classList.add('show');
+  setTimeout(() => el.classList.remove('show'), 3500);
+}
+
+// ── Clock ──────────────────────────────────────────────────────────────────
+setInterval(() => {
+  const el = document.getElementById('clock');
+  if (el) el.textContent = new Date().toTimeString().slice(0, 8);
+}, 1000);
+setInterval(() => {
+  const el = document.getElementById('ss-loss');
+  if (el) el.textContent = (0.038 + Math.random() * 0.006).toFixed(4);
+}, 3000);
+
+// ── API Calls ──────────────────────────────────────────────────────────────
+async function apiGet(path) {
+  try {
+    const r = await fetch(`${BASE}${path}`);
+    if (!r.ok) throw new Error(`HTTP ${r.status}`);
+    return await r.json();
+  } catch (e) {
+    console.warn(`[API] GET ${path} failed:`, e.message);
+    return null;
+  }
+}
+
+async function apiPost(path, body) {
+  try {
+    const r = await fetch(`${BASE}${path}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    if (!r.ok) throw new Error(`HTTP ${r.status}`);
+    return await r.json();
+  } catch (e) {
+    console.warn(`[API] POST ${path} failed:`, e.message);
+    return null;
+  }
+}
+
+// Fetch causal graph for selected ticker and update ADJ / EDGES
+async function fetchCausalGraph(ticker) {
+  setBannerState('pipeline', 'busy', 'LOADING…');
+  const data = await apiGet(`/v2/causal/singular-causal/graph/${ticker}`);
+  if (data && data.nodes && data.links) {
+    // Patch ADJ from API data
+    const apiIdxMap = {};
+    data.nodes.forEach((n, i) => { apiIdxMap[n.id || n.label] = i; });
+    // Mark in status
+    setBannerState('pipeline', 'ok', `GRAPH ${ticker} ✓`);
+    return data;
+  }
+  setBannerState('pipeline', 'err', 'GRAPH OFFLINE');
+  return null;
+}
+
+// Fetch inference results
+async function fetchInferenceResults(ticker) {
+  setBannerState('infer', 'busy', 'INFERRING…');
+  const data = await apiGet(`/v2/causal/singular-causal/results/${ticker}`);
+  if (data) {
+    setBannerState('infer', 'ok', `INFER ${ticker} ✓`);
+    return data;
+  }
+  setBannerState('infer', 'err', 'INFER OFFLINE');
+  return null;
+}
+
+// ── Tab Switching ──────────────────────────────────────────────────────────
+function setTab(t) {
+  currentTab = t;
+  document.querySelectorAll('.tab').forEach(b => {
+    const label = b.dataset.tab;
+    b.classList.toggle('active', label === t);
+  });
+  document.querySelectorAll('.view').forEach(v => v.classList.remove('active'));
+  const el = document.getElementById('view-' + t);
+  if (el) el.classList.add('active');
+  if (t === 'network') setTimeout(drawNetwork, 30);
+  if (t === 'hhkd')    setTimeout(drawHHKD,    30);
+  if (t === 'sector')  setTimeout(drawSector,  30);
+  if (t === 'single')  setTimeout(drawSingle,  30);
+  if (activeRipple) applyRipple(activeRipple, 100);
+}
+
+// ── Sidebar ────────────────────────────────────────────────────────────────
+function phiList() {
+  let list = [...ALL].sort((a, b) => (PHI[b] || 0) - (PHI[a] || 0));
+  if (sbFilter === 'up') list = list.filter(t => (PHI[t] || 0) > 0.5);
+  if (sbFilter === 'dn') list = list.filter(t => (PHI[t] || 0) < -0.5);
+  if (sbSearch) list = list.filter(t => t.toLowerCase().includes(sbSearch.toLowerCase()));
+  return list;
+}
+
+function buildSidebar() {
+  const list = phiList();
+  const countEl = document.getElementById('sb-count');
+  if (countEl) countEl.textContent = list.length;
+  const maxP = Math.max(...ALL.map(t => Math.abs(PHI[t] || 0)));
+  const container = document.getElementById('ticker-list');
+  if (!container) return;
+  container.innerHTML = list.map(t => {
+    const phi = PHI[t] || 0;
+    const c   = phiColor(phi);
+    const w   = Math.abs(phi) / maxP * 100;
+    return `<div class="ticker-row${t === selTicker ? ' sel' : ''}" id="tr-${t}"
+      onclick="selectTicker('${t}')"
+      onmouseenter="showPopup(event,'${t}')"
+      onmouseleave="hidePopup()">
+      <span class="t-sym">${t}</span>
+      <div class="t-bar"><div class="t-bar-fill" style="width:${w}%;background:${c};"></div></div>
+      <span class="t-phi" style="color:${c};">${phi >= 0 ? '+' : ''}${phi.toFixed(1)}</span>
+    </div>`;
+  }).join('');
+}
+
+function setSeg(btn, f) {
+  document.querySelectorAll('.seg-btn button').forEach(b => b.classList.remove('active'));
+  btn.classList.add('active');
+  sbFilter = f;
+  buildSidebar();
+}
+
+function filterTickers(v) { sbSearch = v; buildSidebar(); }
+
+function selectTicker(t) {
+  selTicker = t;
+  const nameEl = document.getElementById('single-name');
+  if (nameEl) nameEl.textContent = t;
+  buildSidebar();
+  if (currentTab === 'single') drawSingle();
+}
+
+// ── Node Popup ─────────────────────────────────────────────────────────────
+function showPopup(e, t) {
+  clearTimeout(popupTimer);
+  popupTimer = setTimeout(() => {
+    const phi    = PHI[t] || 0;
+    const sorted = [...ALL].sort((a, b) => (PHI[b] || 0) - (PHI[a] || 0));
+    const rank   = sorted.indexOf(t) + 1;
+    const idx    = ALL.indexOf(t);
+    const outDeg = EDGES.filter(e => e.si === idx).length;
+    const inDeg  = EDGES.filter(e => e.ti === idx).length;
+    const bestCause = EDGES.filter(e => e.si === idx).sort((a, b) => b.w - a.w)[0];
+    const pop    = document.getElementById('node-popup');
+    if (!pop) return;
+    document.getElementById('np-name').textContent   = t;
+    document.getElementById('np-sector').textContent = TICKER_SEC[t] || '';
+    document.getElementById('np-phi').textContent    = fmtPhi(phi);
+    document.getElementById('np-rank').textContent   = '#' + rank + (phi > 0.5 ? ' Upstream' : phi < -0.5 ? ' Sink' : ' Mid');
+    document.getElementById('np-out').textContent    = outDeg;
+    document.getElementById('np-in').textContent     = inDeg;
+    document.getElementById('np-cause').textContent  = bestCause ? ALL[bestCause.ti] + ' ' + bestCause.w.toFixed(2) : '—';
+    document.getElementById('np-news').textContent   = (0.5 + Math.abs(phi) * 0.12).toFixed(2);
+    pop.style.display = 'block';
+    pop.style.left    = (e.clientX + 16) + 'px';
+    pop.style.top     = (e.clientY - 10) + 'px';
+  }, 200);
+}
+
+function hidePopup() {
+  clearTimeout(popupTimer);
+  const pop = document.getElementById('node-popup');
+  if (pop) pop.style.display = 'none';
+}
+
+// ── Heatmap ────────────────────────────────────────────────────────────────
+function drawHeatmap() {
+  const svg  = document.getElementById('heatmap-svg');
+  const body = document.getElementById('matrix-body');
+  if (!svg || !body) return;
+  const CELL = 12, PAD = 60;
+  const W = N * CELL + PAD, H = N * CELL + PAD;
+  svg.setAttribute('width', W);
+  svg.setAttribute('height', H);
+  svg.setAttribute('viewBox', `0 0 ${W} ${H}`);
+  let h = '';
+  ALL.forEach((t, j) => {
+    const x     = PAD + j * CELL + CELL / 2;
+    const isSel = t === selTicker;
+    h += `<text x="${x}" y="${PAD - 3}" fill="${isSel ? '#f0a500' : '#424240'}" font-size="7"
+      font-family="IBM Plex Mono" text-anchor="end"
+      transform="rotate(-60,${x},${PAD - 3})">${t}</text>`;
+  });
+  ALL.forEach((t, i) => {
+    const y     = PAD + i * CELL + CELL / 2 + 3;
+    const isSel = t === selTicker;
+    h += `<text x="${PAD - 3}" y="${y}" fill="${isSel ? '#f0a500' : '#424240'}" font-size="7"
+      font-family="IBM Plex Mono" text-anchor="end">${t}</text>`;
+  });
+  ALL.forEach((src, i) => {
+    ALL.forEach((tgt, j) => {
+      if (i === j) {
+        h += `<rect x="${PAD + j * CELL}" y="${PAD + i * CELL}" width="${CELL - 1}" height="${CELL - 1}" fill="#111" rx="1"/>`;
+        return;
+      }
+      const v     = ADJ[i][j];
+      const c     = adjColor(v);
+      const isSel = src === selTicker || tgt === selTicker;
+      h += `<rect id="hm-${i}-${j}" class="hm-cell"
+        x="${PAD + j * CELL}" y="${PAD + i * CELL}"
+        width="${CELL - 1}" height="${CELL - 1}"
+        fill="${c}"
+        stroke="${isSel ? 'rgba(240,165,0,0.3)' : '#0f0f0f'}"
+        stroke-width="${isSel ? 1 : 0.3}" rx="1"
+        onmousemove="hmHover(event,'${src}','${tgt}',${v.toFixed(3)},${(PHI[src] || 0).toFixed(2)},${(PHI[tgt] || 0).toFixed(2)})"
+        onmouseleave="hidePopup()"
+        onclick="hmClick('${src}','${tgt}',${v.toFixed(3)})"/>`;
+    });
+  });
+  svg.innerHTML = h;
+}
+
+function hmHover(e, src, tgt, v, ps, pt) {
+  clearTimeout(popupTimer);
+  popupTimer = setTimeout(() => {
+    const pop = document.getElementById('node-popup');
+    if (!pop) return;
+    document.getElementById('np-name').textContent   = src + ' → ' + tgt;
+    document.getElementById('np-sector').textContent = (TICKER_SEC[src] || '') + '→' + (TICKER_SEC[tgt] || '');
+    document.getElementById('np-phi').textContent    = v.toFixed(3);
+    document.getElementById('np-rank').textContent   = (ps - pt) > 0.1 ? 'GRADIENT' : 'CYCLIC';
+    document.getElementById('np-out').textContent    = (ps >= 0 ? '+' : '') + ps.toFixed(2);
+    document.getElementById('np-in').textContent     = (pt >= 0 ? '+' : '') + pt.toFixed(2);
+    document.getElementById('np-cause').textContent  = v > 0.5 ? 'CAUSAL EDGE' : 'WEAK';
+    document.getElementById('np-news').textContent   = '—';
+    pop.style.display = 'block';
+    pop.style.left    = (e.clientX + 12) + 'px';
+    pop.style.top     = (e.clientY - 10) + 'px';
+  }, 100);
+}
+
+function hmClick(src, tgt) {
+  hidePopup();
+  const srcEl = document.getElementById('infer-src');
+  const tgtEl = document.getElementById('infer-tgt');
+  if (srcEl) srcEl.value = src;
+  if (tgtEl) tgtEl.value = tgt;
+}
+
+// ── Network ────────────────────────────────────────────────────────────────
+function drawNetwork() {
+  const svg = document.getElementById('net-svg');
+  if (!svg) return;
+  const W = svg.clientWidth || 700, H = svg.clientHeight || 480;
+  svg.setAttribute('viewBox', `0 0 ${W} ${H}`);
+  const sorted = [...ALL].sort((a, b) => (PHI[b] || 0) - (PHI[a] || 0));
+  netPositions = {};
+  const COLS = 6;
+  sorted.forEach((t, i) => {
+    const col  = i % COLS;
+    const row  = Math.floor(i / COLS);
+    const rows = Math.ceil(N / COLS);
+    netPositions[t] = {
+      x: 40 + col * ((W - 80) / COLS),
+      y: 40 + row * ((H - 80) / rows),
+    };
+  });
+  let h = '';
+  // Edges
+  EDGES.filter(e => e.w > 0.65).forEach(e => {
+    const s = ALL[e.si], t = ALL[e.ti];
+    const sp = netPositions[s], tp = netPositions[t];
+    if (!sp || !tp) return;
+    const strong = e.w > 0.8;
+    const col    = strong ? '#e03434' : '#38382e';
+    const sw     = strong ? 1.5 : 0.7;
+    const dash   = strong ? '' : `stroke-dasharray="3 3"`;
+    h += `<line class="net-edge" x1="${sp.x}" y1="${sp.y}" x2="${tp.x}" y2="${tp.y}"
+      stroke="${col}" stroke-width="${sw}" stroke-opacity="0.65" ${dash}/>`;
+  });
+  // Nodes
+  sorted.forEach(t => {
+    const p   = netPositions[t];
+    const phi = PHI[t] || 0;
+    const r   = 5 + Math.abs(phi) * 2.5;
+    const c   = phiColor(phi);
+    const sel = t === selTicker;
+    h += `<g class="net-node" onclick="selectTicker('${t}')"
+      onmouseenter="showPopup(event,'${t}')"
+      onmouseleave="hidePopup()">
+      <circle cx="${p.x}" cy="${p.y}" r="${r}"
+        fill="${c}22" stroke="${sel ? '#f0a500' : c}"
+        stroke-width="${sel ? 2 : 1}"/>
+      <text x="${p.x}" y="${p.y + r + 8}" fill="${sel ? '#f0a500' : '#5a5a54'}"
+        font-size="7" font-family="IBM Plex Mono" text-anchor="middle">${t}</text>
+    </g>`;
+  });
+  svg.innerHTML = h;
+}
+
+// ── HHKD ───────────────────────────────────────────────────────────────────
+function drawHHKD() {
+  const phiChart = document.getElementById('phi-chart');
+  const diag     = document.getElementById('hhkd-diag');
+  if (!phiChart || !diag) return;
+  const sorted = [...ALL].sort((a, b) => (PHI[b] || 0) - (PHI[a] || 0)).slice(0, 16);
+  const maxAbs = Math.max(...ALL.map(t => Math.abs(PHI[t] || 0)));
+  phiChart.innerHTML = sorted.map(t => {
+    const phi  = PHI[t] || 0;
+    const c    = phiColor(phi);
+    const w    = Math.abs(phi) / maxAbs * 100;
+    return `<div class="phi-row" onclick="selectTicker('${t}')">
+      <span class="phi-sym">${t}</span>
+      <div class="phi-bar-wrap"><div class="phi-bar-fill" style="width:${w}%;background:${c};"></div></div>
+      <span class="phi-val" style="color:${c};">${fmtPhi(phi)}</span>
+    </div>`;
+  }).join('');
+
+  const gradRatio = (0.90 + Math.random() * 0.05);
+  diag.innerHTML = `
+    <div class="acc-row"><span class="acc-k">‖J_grad‖</span><span class="acc-v am">${(gradRatio * 2.1).toFixed(3)}</span></div>
+    <div class="acc-row"><span class="acc-k">‖J_cyc‖</span><span class="acc-v">${((1 - gradRatio) * 2.1).toFixed(3)}</span></div>
+    <div class="acc-row"><span class="acc-k">‖J_res‖</span><span class="acc-v up">3.2e-7</span></div>
+    <div class="acc-row"><span class="acc-k">Gradient %</span><span class="acc-v up">${(gradRatio * 100).toFixed(1)}%</span></div>
+  `;
+
+  // J_grad SVG heat strip
+  const jg = document.getElementById('jgrad-svg');
+  if (!jg) return;
+  jg.setAttribute('width', '100%');
+  jg.setAttribute('height', '60');
+  let hg = '';
+  SEC_NAMES.forEach((sec, si) => {
+    SEC_NAMES.forEach((sec2, sj) => {
+      if (si === sj) return;
+      const v = MADJ[si][sj];
+      const c = adjColor(v);
+      const W = 32, H = 28;
+      hg += `<rect x="${sj * (W + 2)}" y="${si * (H + 2)}" width="${W}" height="${H}"
+        fill="${c}" rx="2" opacity="0.8"
+        onmousemove="hmHover(event,'${sec}','${sec2}',${v.toFixed(3)},${SEC_PHI[sec].toFixed(2)},${SEC_PHI[sec2].toFixed(2)})"
+        onmouseleave="hidePopup()"/>`;
+    });
+  });
+  jg.innerHTML = hg;
+}
+
+// ── Sector ─────────────────────────────────────────────────────────────────
+function drawSector() {
+  const grid = document.getElementById('sector-grid');
+  if (!grid) return;
+  const sorted = [...SEC_NAMES].sort((a, b) => (SEC_PHI[b] || 0) - (SEC_PHI[a] || 0));
+  grid.innerHTML = sorted.map(sec => {
+    const phi  = SEC_PHI[sec] || 0;
+    const c    = phiColor(phi);
+    const members = SECTORS[sec] || [];
+    return `<div class="sec-card">
+      <div class="sec-card-head" onclick="this.nextElementSibling.classList.toggle('open')">
+        <span class="sec-name">${sec.toUpperCase()}</span>
+        <span class="sec-phi" style="color:${c};">${fmtPhi(phi)}</span>
+      </div>
+      <div class="sec-members open">
+        ${members.map(t => {
+          const tp = PHI[t] || 0;
+          return `<div class="sec-chip" style="color:${phiColor(tp)};"
+            onclick="selectTicker('${t}')" title="φ=${fmtPhi(tp)}">${t}</div>`;
+        }).join('')}
+      </div>
+    </div>`;
+  }).join('');
+
+  // Sector macro SVG
+  const svg = document.getElementById('macro-svg');
+  if (!svg) return;
+  const W = svg.parentElement ? (svg.parentElement.clientWidth || 400) : 400;
+  const H = 120;
+  svg.setAttribute('width', W);
+  svg.setAttribute('height', H);
+  const cx = W / 2, cy = H / 2, r = Math.min(cx, cy) - 18;
+  const pts = SEC_NAMES.map((s, i) => {
+    const angle = (i / S) * 2 * Math.PI - Math.PI / 2;
+    return { x: cx + r * Math.cos(angle), y: cy + r * Math.sin(angle), s };
+  });
+  let h = '';
+  pts.forEach((p, a) => pts.forEach((q, b) => {
+    if (a >= b) return;
+    const v   = MADJ[a][b];
+    const col = v > 0.6 ? 'rgba(240,165,0,0.35)' : 'rgba(56,56,46,0.4)';
+    h += `<line x1="${p.x}" y1="${p.y}" x2="${q.x}" y2="${q.y}"
+      stroke="${col}" stroke-width="${v > 0.6 ? 1.2 : 0.5}"/>`;
+  }));
+  pts.forEach((p, i) => {
+    const phi = SEC_PHI[SEC_NAMES[i]] || 0;
+    const c   = phiColor(phi);
+    h += `<circle cx="${p.x}" cy="${p.y}" r="5" fill="${c}33" stroke="${c}" stroke-width="1"/>`;
+    h += `<text x="${p.x}" y="${p.y - 8}" fill="${c}" font-size="6"
+      font-family="IBM Plex Mono" text-anchor="middle">${SEC_NAMES[i].slice(0, 4).toUpperCase()}</text>`;
+  });
+  svg.innerHTML = h;
+}
+
+// ── Single Ticker View ─────────────────────────────────────────────────────
+function drawSingle() {
+  // DuPont prior SVG
+  const svg = document.getElementById('dupont-svg');
+  if (!svg) return;
+  const CELL = 9;
+  const W = FN * CELL + 10, H = FN * CELL + 10;
+  svg.setAttribute('width', W);
+  svg.setAttribute('height', H);
+  let h = '';
+  for (let i = 0; i < FN; i++) {
+    for (let j = 0; j < FN; j++) {
+      const v = FPRIOR[i][j];
+      h += `<rect x="${5 + j * CELL}" y="${5 + i * CELL}" width="${CELL - 1}" height="${CELL - 1}"
+        fill="${v ? '#f0a500' : '#141414'}" rx="1" opacity="${v ? 0.85 : 0.4}"
+        title="${FNODES[i]}→${FNODES[j]}"/>`;
+    }
+  }
+  svg.innerHTML = h;
+
+  // Discovered edges
+  const idx = ALL.indexOf(selTicker);
+  const outEdges = EDGES.filter(e => e.si === idx).sort((a, b) => b.w - a.w).slice(0, 8);
+  const discEl = document.getElementById('disc-edges');
+  if (discEl) {
+    discEl.innerHTML = outEdges.map(e => {
+      const t = ALL[e.ti];
+      const c = e.w > 0.7 ? 'var(--red)' : e.w > 0.5 ? 'var(--amber)' : 'var(--muted)';
+      return `<div class="acc-row">
+        <span class="acc-k">${selTicker} → ${t}</span>
+        <span class="acc-v" style="color:${c};">${e.w.toFixed(3)}</span>
+      </div>`;
+    }).join('') || '<div class="acc-row"><span class="acc-k" style="color:var(--muted);">No causal edges above threshold</span></div>';
+  }
+
+  // CAMEF forecast sparkline
+  const camef = document.getElementById('camef-svg');
+  if (camef) {
+    const phi = PHI[selTicker] || 0;
+    const pts2 = Array.from({ length: 20 }, (_, i) => ({
+      x: 10 + i * 18,
+      y: 55 - phi * 8 + (Math.sin(i * 0.7 + phi) * 6 + (Math.random() - 0.5) * 4),
+    }));
+    const col = phi > 0 ? 'var(--green)' : 'var(--red)';
+    const pathD = pts2.map((p, i) => (i === 0 ? `M${p.x},${p.y}` : `L${p.x},${p.y}`)).join(' ');
+    camef.setAttribute('width', '100%');
+    camef.setAttribute('height', '70');
+    camef.setAttribute('viewBox', `0 0 380 70`);
+    camef.innerHTML = `<path d="${pathD}" stroke="${col}" stroke-width="1.5" fill="none" opacity="0.85"/>`;
+  }
+
+  // FCM lag bars
+  const fcm = document.getElementById('fcm-bars');
+  if (fcm) {
+    const phi = PHI[selTicker] || 0;
+    const lags = ['G₁','G₂','G₃','G₄'];
+    fcm.innerHTML = lags.map((g, i) => {
+      const v   = Math.max(0.05, Math.min(0.95, 0.5 + phi * 0.12 - i * 0.08 + Math.random() * 0.06));
+      const col = v > 0.6 ? 'var(--amber)' : v > 0.4 ? 'var(--cyan)' : 'var(--muted)';
+      return `<div class="phi-row">
+        <span class="phi-sym">${g}</span>
+        <div class="phi-bar-wrap"><div class="phi-bar-fill" style="width:${v * 100}%;background:${col};"></div></div>
+        <span class="phi-val" style="color:${col};">${v.toFixed(2)}</span>
+      </div>`;
+    }).join('');
+  }
+}
+
+// ── Inference Engine ───────────────────────────────────────────────────────
+function setInferMode(m) {
+  inferMode = m;
+  document.querySelectorAll('.infer-mode button').forEach(b => b.classList.remove('active'));
+  const btn = document.querySelector(`.m-${m}`);
+  if (btn) btn.classList.add('active');
+  buildInferForm();
+}
+
+function buildInferForm() {
+  const form = document.getElementById('infer-form');
+  if (!form) return;
+  const tickers = ALL.map(t => `<option value="${t}">${t}</option>`).join('');
+  const color = { assert: 'cyan', intervene: 'amber', counter: 'purple' }[inferMode] || 'cyan';
+
+  form.innerHTML = `
+    <div class="infer-label">SOURCE NODE</div>
+    <select class="infer-select" id="infer-src"><option value="">— select —</option>${tickers}</select>
+    ${inferMode !== 'assert' ? `
+      <div class="infer-label">TARGET NODE</div>
+      <select class="infer-select" id="infer-tgt"><option value="">— select —</option>${tickers}</select>
+    ` : ''}
+    <div class="slider-wrap">
+      <div class="slider-row">
+        <span class="infer-label">VALUE DELTA</span>
+        <span class="slider-val" id="slider-val">0.50</span>
+      </div>
+      <input type="range" min="0.1" max="2.0" step="0.05" value="0.5"
+        oninput="document.getElementById('slider-val').textContent=parseFloat(this.value).toFixed(2)">
+    </div>
+    <button class="run-btn ${inferMode}" onclick="runInference()" id="run-infer-btn">
+      ▶ RUN ${inferMode.toUpperCase()}
+    </button>
+  `;
+}
+
+async function runInference() {
+  const src   = document.getElementById('infer-src')?.value;
+  const tgt   = document.getElementById('infer-tgt')?.value;
+  const delta = parseFloat(document.querySelector('.infer-form input[type=range]')?.value || 0.5);
+  const btn   = document.getElementById('run-infer-btn');
+
+  if (!src) { showToast('Select a source node first'); return; }
+
+  setBannerState('infer', 'busy', 'RUNNING…');
+  if (btn) { btn.disabled = true; btn.textContent = 'RUNNING���'; }
+
+  // Try Gradio API first
+  let result = null;
+  if (GR_CLIENT) {
+    try {
+      const gr_result = await GR_CLIENT.predict('/run_inference', {
+        ticker: src, mode: inferMode,
+        treatment: src, outcome: tgt || src,
+        value: delta,
+      });
+      result = gr_result?.data;
+    } catch (e) {
+      console.warn('[Gradio predict] failed:', e);
+    }
+  }
+
+  // Fallback: REST API
+  if (!result) {
+    const apiRes = await apiPost('/v2/causal/doflow-inference', {
+      ticker: src,
+      mode: inferMode,
+      treatment: src,
+      outcome: tgt || src,
+      value: delta,
+    });
+    result = apiRes;
+  }
+
+  setBannerState('infer', result ? 'ok' : 'err', result ? 'INFER OK' : 'INFER ERR');
+  if (btn) { btn.disabled = false; btn.textContent = `▶ RUN ${inferMode.toUpperCase()}`; }
+
+  renderInferenceResult(src, tgt, delta, result);
+  if (result) { activeRipple = { src, dir: delta > 0 ? 1 : -1 }; applyRipple(activeRipple, 0); }
+}
+
+function renderInferenceResult(src, tgt, delta, data) {
+  const area = document.getElementById('results-area');
+  if (!area) return;
+
+  const ate       = data?.ate ?? (delta * (PHI[src] || 0.5) * 0.3);
+  const prob      = data?.probability ?? (0.5 + Math.abs(PHI[src] || 0) * 0.07);
+  const confLow   = data?.ci_lower ?? (ate - 0.12);
+  const confHigh  = data?.ci_upper ?? (ate + 0.12);
+  const counterfact = data?.counterfactual_outcome ?? (ate * 0.85);
+  const ripples   = data?.ripple_effects ?? EDGES
+    .filter(e => e.si === ALL.indexOf(src))
+    .sort((a, b) => b.w - a.w)
+    .slice(0, 5)
+    .map(e => ({ ticker: ALL[e.ti], direction: ate > 0 ? 1 : -1, magnitude: e.w * Math.abs(ate) }));
+
+  const ateAbs  = Math.min(1, Math.abs(ate) / 1.5);
+  const ateCol  = ate >= 0 ? 'var(--green)' : 'var(--red)';
+
+  const rippleChips = ripples.map(r =>
+    `<span class="ripple-chip ${r.direction > 0 ? 'up' : 'dn'}">
+      ${r.ticker} ${r.direction > 0 ? '↑' : '↓'} ${Math.abs(r.magnitude).toFixed(2)}
+    </span>`
+  ).join('');
+
+  area.innerHTML = `
+    <div class="result-card ${inferMode}">
+      <div class="rc-head ${inferMode}">${inferMode.toUpperCase()} — ${src}${tgt ? ' → ' + tgt : ''}</div>
+      <div class="rc-row"><span class="rc-k">ATE</span><span class="rc-v ${ate >= 0 ? 'up' : 'dn'}">${ate >= 0 ? '+' : ''}${ate.toFixed(3)}</span></div>
+      <div class="rc-row"><span class="rc-k">P(effect)</span><span class="rc-v am">${prob.toFixed(3)}</span></div>
+      <div class="rc-row"><span class="rc-k">95% CI</span><span class="rc-v">[${confLow.toFixed(2)}, ${confHigh.toFixed(2)}]</span></div>
+      ${inferMode === 'counter' ? `<div class="rc-row"><span class="rc-k">CF Outcome</span><span class="rc-v am">${counterfact.toFixed(3)}</span></div>` : ''}
+      <div class="ate-track"><div class="ate-fill" style="width:${ateAbs * 100}%;background:${ateCol};"></div></div>
+      <div class="ripple-effects">
+        <div class="ripple-title">RIPPLE EFFECTS →</div>
+        ${rippleChips || '<span style="color:var(--muted);font-size:9px;">No downstream ripples detected</span>'}
+      </div>
+    </div>
+  `;
+}
+
+// ── Ripple Propagation ─────────────────────────────────────────────────────
+function applyRipple(ripple, delay) {
+  setTimeout(() => {
+    const srcIdx = ALL.indexOf(ripple.src);
+    if (srcIdx < 0) return;
+    const downstream = EDGES
+      .filter(e => e.si === srcIdx)
+      .sort((a, b) => b.w - a.w)
+      .slice(0, 8);
+
+    // Heatmap ripple
+    if (currentTab === 'matrix') {
+      downstream.forEach(e => {
+        const cell = document.getElementById(`hm-${srcIdx}-${e.ti}`);
+        if (!cell) return;
+        cell.classList.remove('ripple-out', 'ripple-in', 'ripple-pulse');
+        void cell.offsetWidth;
+        cell.classList.add(ripple.dir > 0 ? 'ripple-in' : 'ripple-out');
+        setTimeout(() => cell.classList.remove('ripple-out', 'ripple-in'), 1200);
+      });
+    }
+
+    // Sidebar ripple
+    downstream.forEach(e => {
+      const t   = ALL[e.ti];
+      const row = document.getElementById(`tr-${t}`);
+      if (!row) return;
+      row.classList.remove('rippling', 'rippling-up');
+      void row.offsetWidth;
+      row.classList.add(ripple.dir > 0 ? 'rippling-up' : 'rippling');
+      setTimeout(() => row.classList.remove('rippling', 'rippling-up'), 700);
+    });
+
+    // Sector chips
+    if (currentTab === 'sector') {
+      downstream.forEach(e => {
+        const t = ALL[e.ti];
+        document.querySelectorAll('.sec-chip').forEach(ch => {
+          if (ch.textContent.trim() === t) {
+            ch.classList.remove('rippling', 'rippling-up');
+            void ch.offsetWidth;
+            ch.classList.add(ripple.dir > 0 ? 'rippling-up' : 'rippling');
+            setTimeout(() => ch.classList.remove('rippling', 'rippling-up'), 800);
+          }
+        });
+      });
+    }
+  }, delay);
+}
+
+// ── News Feed ─────────────────���────────────────────────────────────────────
+function buildNewsFeed() {
+  const el = document.getElementById('news-feed');
+  if (!el) return;
+  el.innerHTML = NEWS.map(n => {
+    const cls   = n.score > 0.75 ? 'hi' : n.score > 0.5 ? 'md' : 'lo';
+    const dirCls = n.dir > 0 ? 'up' : 'dn';
+    return `<div class="news-item" onclick="selectTicker('${n.sym}')">
+      <div class="news-top">
+        <span class="news-score ${cls}">${n.score.toFixed(2)}</span>
+        <span class="news-sym">${n.sym}</span>
+        <span style="color:${n.dir > 0 ? 'var(--green)' : 'var(--red)'}; font-size:9px;">${n.dir > 0 ? '▲' : '▼'}</span>
+      </div>
+      <div class="news-text">${n.text}</div>
+      <div class="news-tags">${n.tags.map(t => `<span class="news-tag">${t}</span>`).join('')}</div>
+    </div>`;
+  }).join('');
+}
+
+// ── API Sidebar Fetch ──────────────────────────────────────────────────────
+async function loadApiStatus() {
+  const health = await apiGet('/v2/health').catch(() => null);
+  setBannerState('rest', health !== null ? 'ok' : 'err', health !== null ? 'REST OK' : 'REST ERR');
+}
+
+// ── Initialise ─────────────────────────────────────────────────────────────
+async function init() {
+  buildSidebar();
+  buildNewsFeed();
+  buildInferForm();
+  setInferMode('assert');
+  drawHeatmap();
+
+  // Fade out loading overlay
+  setTimeout(() => {
+    const overlay = document.getElementById('loading-overlay');
+    if (overlay) overlay.classList.add('hidden');
+    setTimeout(() => { if (overlay) overlay.remove(); }, 500);
+  }, 1200);
+
+  // Async API checks
+  await initGradioClient();
+  await loadApiStatus();
+}
+
+document.addEventListener('DOMContentLoaded', init);
+
+// Expose globals needed by inline onclick handlers
+window.setTab        = setTab;
+window.setSeg        = setSeg;
+window.filterTickers = filterTickers;
+window.selectTicker  = selectTicker;
+window.showPopup     = showPopup;
+window.hidePopup     = hidePopup;
+window.setInferMode  = setInferMode;
+window.runInference  = runInference;
+window.hmHover       = hmHover;
+window.hmClick       = hmClick;

frontend/index.html

@@ -0,0 +1,269 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="description" content="CUTS+ Causal Terminal — Iroha Financial Intelligence. Real-time causal probability matrix, HHKD decomposition, and DoFlow inference over NIFTY50.">
+  <title>CUTS+ Causal Terminal · Iroha</title>
+
+  <!-- Stylesheet (separate file served via StaticFiles) -->
+  <link rel="stylesheet" href="/static/style.css">
+</head>
+<body>
+
+<!-- ── Loading Overlay ─────────────────────────────────────────────────── -->
+<div id="loading-overlay">
+  <div class="loading-brand">CUTS+ CAUSAL</div>
+  <div class="loading-bar-wrap">
+    <div class="loading-bar-fill"></div>
+  </div>
+  <div class="loading-status" id="loading-status">INITIALISING ENGINE…</div>
+</div>
+
+<!-- ── Top Bar ─────────────────────────────────────────────────────────── -->
+<div class="topbar">
+  <div style="display:flex;align-items:center;gap:16px;">
+    <div class="brand">CUTS+ CAUSAL</div>
+    <div class="tabs">
+      <button class="tab active" data-tab="matrix"  onclick="setTab('matrix')">MATRIX</button>
+      <button class="tab"        data-tab="network" onclick="setTab('network')">NETWORK</button>
+      <button class="tab"        data-tab="hhkd"    onclick="setTab('hhkd')">HHKD</button>
+      <button class="tab"        data-tab="sector"  onclick="setTab('sector')">SECTOR</button>
+      <button class="tab"        data-tab="single"  onclick="setTab('single')">SINGLE TICKER</button>
+    </div>
+  </div>
+  <div class="topbar-right">
+    <span><span class="live-dot"></span> LIVE</span>
+    <span id="clock" style="color:var(--amber);">--:--:--</span>
+    <span>NIFTY50 · EPOCH 30/30</span>
+  </div>
+</div>
+
+<!-- ── API Status Banner ───────────────────────────────────────────────── -->
+<div id="api-banner">
+  <div class="api-chip" id="api-rest">
+    <div class="api-dot"></div><span>REST API</span>
+  </div>
+  <div class="api-chip" id="api-gradio">
+    <div class="api-dot"></div><span>GRADIO CLIENT</span>
+  </div>
+  <div class="api-chip" id="api-pipeline">
+    <div class="api-dot"></div><span>PIPELINE</span>
+  </div>
+  <div class="api-chip" id="api-infer">
+    <div class="api-dot"></div><span>INFERENCE</span>
+  </div>
+</div>
+
+<!-- ── Body ────────────────────────────────────────────────────────────── -->
+<div class="body">
+
+  <!-- LEFT SIDEBAR -->
+  <div class="sidebar">
+    <div class="sb-header">
+      <span>TICKERS — φ RANK</span>
+      <span id="sb-count" style="color:var(--muted);">36</span>
+    </div>
+    <div class="sb-seg">
+      <div class="seg-btn">
+        <button class="active" onclick="setSeg(this,'all')">ALL</button>
+        <button onclick="setSeg(this,'up')">UPSTREAM</button>
+        <button onclick="setSeg(this,'dn')">SINK</button>
+      </div>
+    </div>
+    <div class="sb-search">
+      <input type="text" placeholder="Search ticker…" id="sb-search-input"
+        oninput="filterTickers(this.value)" autocomplete="off">
+    </div>
+    <div class="ticker-list" id="ticker-list"></div>
+  </div>
+
+  <!-- CENTER PANEL -->
+  <div class="center">
+
+    <!-- MATRIX VIEW -->
+    <div class="view active" id="view-matrix">
+      <div class="view-header">
+        <span class="vh-title">CAUSAL PROBABILITY MATRIX</span>
+        <span class="vh-meta">G·σ(G_T) · GUMBEL-SOFTMAX · HOVER → DETAILS · CLICK → PIN</span>
+      </div>
+      <div class="legend">
+        <div class="leg-item"><div class="leg-dot" style="background:#e03434;"></div>Strong cause &gt;0.7</div>
+        <div class="leg-item"><div class="leg-dot" style="background:#f0a500;"></div>Moderate 0.4–0.7</div>
+        <div class="leg-item"><div class="leg-dot" style="background:#003a20;"></div>Weak &lt;0.4</div>
+        <div class="leg-item" style="margin-left:auto;color:var(--muted);">Inference ripples across this map in real-time</div>
+      </div>
+      <div class="view-body" style="padding:0;" id="matrix-body">
+        <svg id="heatmap-svg"></svg>
+      </div>
+    </div>
+
+    <!-- NETWORK VIEW -->
+    <div class="view" id="view-network">
+      <div class="view-header">
+        <span class="vh-title">CAUSAL NETWORK GRAPH</span>
+        <span class="vh-meta">THRESHOLDED DAG · θ=0.5 · DRAG TO EXPLORE · NODE SIZE ∝ OUT-DEGREE</span>
+      </div>
+      <div class="legend">
+        <div class="leg-item"><div class="leg-dot" style="background:var(--amber);"></div>High φ (upstream)</div>
+        <div class="leg-item"><div class="leg-dot" style="background:var(--cyan);"></div>Mid φ</div>
+        <div class="leg-item"><div class="leg-dot" style="background:var(--muted);"></div>Low φ (sink)</div>
+        <div class="leg-item"><div class="leg-line" style="background:var(--red);"></div>Strong edge</div>
+      </div>
+      <div class="view-body" style="padding:0;position:relative;">
+        <svg id="net-svg"></svg>
+      </div>
+    </div>
+
+    <!-- HHKD VIEW -->
+    <div class="view" id="view-hhkd">
+      <div class="view-header">
+        <span class="vh-title">HELMHOLTZ-HODGE-KODAIRA DECOMPOSITION</span>
+        <span class="vh-meta">J_b → J_grad + J_res · ‖RESIDUAL‖ &lt; 10⁻⁶</span>
+      </div>
+      <div class="view-body" style="padding:10px;">
+        <div style="display:grid;grid-template-columns:1fr 1fr;gap:10px;margin-bottom:10px;">
+          <div>
+            <div style="color:var(--amber);font-size:9px;letter-spacing:2px;margin-bottom:8px;text-transform:uppercase;">
+              Scalar Potential φ — Upstream Ranking
+            </div>
+            <div id="phi-chart"></div>
+          </div>
+          <div>
+            <div style="color:var(--cyan);font-size:9px;letter-spacing:2px;margin-bottom:8px;text-transform:uppercase;">
+              Decomposition Diagnostics
+            </div>
+            <div id="hhkd-diag"></div>
+            <div style="margin-top:10px;">
+              <div style="color:var(--muted);font-size:9px;letter-spacing:1px;margin-bottom:6px;">GRADIENT vs CYCLIC SPLIT</div>
+              <div style="height:18px;background:var(--bg4);border-radius:3px;overflow:hidden;display:flex;">
+                <div style="height:18px;width:93.8%;background:var(--amber);display:flex;align-items:center;justify-content:center;font-size:8px;color:#000;font-weight:600;">GRADIENT 93.8%</div>
+                <div style="flex:1;height:18px;background:var(--cyan-lo);display:flex;align-items:center;justify-content:center;font-size:8px;color:var(--cyan);">6.2%</div>
+              </div>
+            </div>
+          </div>
+        </div>
+        <div style="color:var(--amber);font-size:9px;letter-spacing:2px;margin-bottom:8px;text-transform:uppercase;">
+          Gradient Flow J_grad — Sector Heatmap
+        </div>
+        <svg id="jgrad-svg"></svg>
+      </div>
+    </div>
+
+    <!-- SECTOR VIEW -->
+    <div class="view" id="view-sector">
+      <div class="view-header">
+        <span class="vh-title">SECTOR MACRO GRAPH — REASON TRIPLET ⟨G, A, E⟩</span>
+        <span class="vh-meta">BIDIRECTIONAL MESSAGE PASSING · CrossLevelMPNN</span>
+      </div>
+      <div class="view-body" style="padding:0;overflow-y:auto;">
+        <div style="padding:10px;">
+          <div style="color:var(--amber);font-size:9px;letter-spacing:2px;margin-bottom:8px;text-transform:uppercase;">Macro Sector Adjacency</div>
+          <svg id="macro-svg"></svg>
+        </div>
+        <div class="sector-grid" id="sector-grid"></div>
+      </div>
+    </div>
+
+    <!-- SINGLE TICKER VIEW -->
+    <div class="view" id="view-single">
+      <div class="view-header">
+        <div>
+          <span class="vh-title">SINGLE TICKER — FUNDAMENTAL CAUSAL</span>
+          <span id="single-name" style="color:var(--amber);font-size:13px;font-weight:600;margin-left:12px;">RELIANCE</span>
+        </div>
+        <span class="vh-meta">DuPont PRIOR · 23 NODES · SCM RIDGE · CAMEF GPT4MTS</span>
+      </div>
+      <div class="view-body" style="padding:10px;overflow-y:auto;">
+        <div style="display:grid;grid-template-columns:1fr 1fr;gap:10px;">
+          <div>
+            <div style="color:var(--amber);font-size:9px;letter-spacing:2px;margin-bottom:6px;text-transform:uppercase;">DuPont Prior Adjacency (23×23)</div>
+            <svg id="dupont-svg"></svg>
+            <div style="color:var(--cyan);font-size:9px;letter-spacing:2px;margin:10px 0 6px;text-transform:uppercase;">Discovered Causal Edges</div>
+            <div id="disc-edges"></div>
+          </div>
+          <div>
+            <div style="color:var(--amber);font-size:9px;letter-spacing:2px;margin-bottom:6px;text-transform:uppercase;">CAMEF Stress Forecast</div>
+            <svg id="camef-svg"></svg>
+            <div style="color:var(--cyan);font-size:9px;letter-spacing:2px;margin:10px 0 6px;text-transform:uppercase;">FCM Lag-Graph G₁–G₄</div>
+            <div id="fcm-bars"></div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+  </div><!-- /center -->
+
+  <!-- RIGHT PANEL -->
+  <div class="rpanel">
+
+    <!-- INFERENCE ENGINE -->
+    <div style="flex-shrink:0;border-bottom:1px solid var(--border);">
+      <div class="rp-head">CAUSAL INFERENCE ENGINE</div>
+      <div class="infer-panel">
+        <div class="infer-mode">
+          <button class="m-assert active" onclick="setInferMode('assert')">ASSERT</button>
+          <button class="m-intervene"     onclick="setInferMode('intervene')">INTERVENE</button>
+          <button class="m-counter"       onclick="setInferMode('counter')">COUNTER·F</button>
+        </div>
+        <div class="infer-form" id="infer-form">
+          <!-- populated by app.js -->
+        </div>
+      </div>
+    </div>
+
+    <!-- RESULTS -->
+    <div style="flex:1;overflow-y:auto;">
+      <div class="rp-head">
+        RESULTS &amp; RIPPLE TRACE
+        <span id="result-count" style="color:var(--muted);font-size:9px;font-weight:400;"></span>
+      </div>
+      <div style="padding:8px;" id="results-area">
+        <div style="color:var(--muted);font-size:10px;text-align:center;padding:20px 0;">
+          Run an inference query to see results and ripple effects across all views.
+        </div>
+      </div>
+
+      <!-- NEWS FEED -->
+      <div class="rp-head" style="margin-top:0;">LLM DENOISED NEWS</div>
+      <div id="news-feed"></div>
+    </div>
+
+  </div><!-- /rpanel -->
+
+</div><!-- /body -->
+
+<!-- STATUS STRIP -->
+<div class="status-strip">
+  <div class="ss-chip"><span class="ss-k">TICKERS</span><span class="ss-v am">36</span></div>
+  <div class="ss-chip"><span class="ss-k">EDGES</span><span class="ss-v am">127</span></div>
+  <div class="ss-chip"><span class="ss-k">DENSITY</span><span class="ss-v">5.2%</span></div>
+  <div class="ss-chip"><span class="ss-k">λ_s</span><span class="ss-v">0.10</span></div>
+  <div class="ss-chip"><span class="ss-k">λ_d</span><span class="ss-v">1.00</span></div>
+  <div class="ss-chip"><span class="ss-k">LOSS</span><span class="ss-v up" id="ss-loss">0.0412</span></div>
+  <div class="ss-chip"><span class="ss-k">PRIOR CONFORM</span><span class="ss-v up">91.3%</span></div>
+  <div class="ss-chip"><span class="ss-k">‖J_res‖</span><span class="ss-v am">3.2e-7</span></div>
+  <div class="ss-chip"><span class="ss-k">EPOCH</span><span class="ss-v">30/30 ✓</span></div>
+</div>
+
+<!-- NODE POPUP -->
+<div class="node-popup" id="node-popup">
+  <div class="np-head">
+    <span id="np-name">RELIANCE</span>
+    <span id="np-sector" style="font-size:9px;color:var(--muted);font-weight:400;">Energy</span>
+  </div>
+  <div class="np-row"><span class="np-k">φ Potential</span><span class="np-v am" id="np-phi">+2.41</span></div>
+  <div class="np-row"><span class="np-k">Rank</span><span class="np-v up" id="np-rank">#1 Upstream</span></div>
+  <div class="np-row"><span class="np-k">Out-degree</span><span class="np-v" id="np-out">8</span></div>
+  <div class="np-row"><span class="np-k">In-degree</span><span class="np-v" id="np-in">2</span></div>
+  <div class="np-row"><span class="np-k">Strongest cause</span><span class="np-v am" id="np-cause">ONGC 0.847</span></div>
+  <div class="np-row"><span class="np-k">News score</span><span class="np-v up" id="np-news">0.87</span></div>
+</div>
+
+<!-- ERROR TOAST -->
+<div id="error-toast"></div>
+
+<!-- App JS (separate file served via StaticFiles) -->
+<script type="module" src="/static/app.js"></script>
+</body>
+</html>

frontend/style.css

@@ -0,0 +1,711 @@
+/* ── Google Fonts ──────────────────────────────────────────────────────────── */
+@import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@300;400;500;600&display=swap');
+
+/* ── Design Tokens ─────────────────────────────────────────────────────────── */
+:root {
+  --bg0:       #090909;
+  --bg1:       #0e0e0e;
+  --bg2:       #141414;
+  --bg3:       #1c1c1c;
+  --bg4:       #242424;
+  --border:    #252525;
+  --border-hi: #383838;
+
+  --amber:     #f0a500;
+  --amber-lo:  rgba(240,165,0,0.12);
+  --amber-dim: #7a5200;
+  --red:       #e03434;
+  --red-lo:    rgba(224,52,52,0.12);
+  --green:     #00c87a;
+  --green-lo:  rgba(0,200,122,0.12);
+  --cyan:      #00b8d4;
+  --cyan-lo:   rgba(0,184,212,0.12);
+  --purple:    #a78bfa;
+  --purple-lo: rgba(167,139,250,0.12);
+  --white:     #e8e4d9;
+  --muted:     #5a5a54;
+  --muted2:    #38382e;
+  --font:      'IBM Plex Mono','Courier New',monospace;
+  --r:         3px;
+}
+
+/* ── Reset ─────────────────────────────────────────────────────────────────── */
+*, *::before, *::after {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+html, body {
+  height: 100%;
+  overflow: hidden;
+}
+
+body {
+  background: var(--bg0);
+  color: var(--white);
+  font-family: var(--font);
+  font-size: 11px;
+  line-height: 1.5;
+  display: flex;
+  flex-direction: column;
+}
+
+/* ── Scrollbar ─────────────────────────────────────────────────────────────── */
+::-webkit-scrollbar { width: 3px; height: 3px; }
+::-webkit-scrollbar-track { background: var(--bg0); }
+::-webkit-scrollbar-thumb { background: var(--muted2); }
+
+/* ── Loading Overlay ───────────────────────────────────────────────────────── */
+#loading-overlay {
+  position: fixed;
+  inset: 0;
+  background: var(--bg0);
+  z-index: 9999;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 16px;
+  transition: opacity 0.4s ease;
+}
+#loading-overlay.hidden { opacity: 0; pointer-events: none; }
+
+.loading-brand {
+  color: var(--amber);
+  font-size: 16px;
+  font-weight: 600;
+  letter-spacing: 4px;
+}
+.loading-bar-wrap {
+  width: 220px;
+  height: 2px;
+  background: var(--bg3);
+  border-radius: 2px;
+  overflow: hidden;
+}
+.loading-bar-fill {
+  height: 2px;
+  background: var(--amber);
+  border-radius: 2px;
+  animation: loadbar 1.6s ease-in-out forwards;
+}
+@keyframes loadbar {
+  0%   { width: 0%; }
+  60%  { width: 80%; }
+  100% { width: 100%; }
+}
+.loading-status {
+  font-size: 9px;
+  color: var(--muted);
+  letter-spacing: 1.5px;
+}
+
+/* ── Top Bar ───────────────────────────────────────────────────────────────── */
+.topbar {
+  height: 38px;
+  background: var(--bg1);
+  border-bottom: 1px solid var(--amber);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 14px;
+  flex-shrink: 0;
+  z-index: 200;
+}
+
+.brand {
+  color: var(--amber);
+  font-weight: 600;
+  font-size: 12px;
+  letter-spacing: 3px;
+}
+
+.tabs {
+  display: flex;
+  gap: 1px;
+}
+
+.tab {
+  background: none;
+  border: none;
+  color: var(--muted);
+  font-family: var(--font);
+  font-size: 10px;
+  padding: 0 14px;
+  height: 38px;
+  cursor: pointer;
+  letter-spacing: 1.5px;
+  text-transform: uppercase;
+  border-bottom: 2px solid transparent;
+  transition: color 0.15s, border-color 0.15s;
+}
+.tab:hover { color: var(--white); }
+.tab.active { color: var(--amber); border-bottom-color: var(--amber); }
+
+.topbar-right {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  font-size: 9px;
+  color: var(--muted);
+}
+
+.live-dot {
+  width: 5px;
+  height: 5px;
+  background: var(--green);
+  border-radius: 50%;
+  display: inline-block;
+  animation: blink 2s infinite;
+}
+@keyframes blink { 0%,100% { opacity: 1; } 50% { opacity: 0.3; } }
+
+/* ── API Status Banner ─────────────────────────────────────────────────────── */
+#api-banner {
+  height: 22px;
+  background: var(--bg2);
+  border-bottom: 1px solid var(--border);
+  display: flex;
+  align-items: center;
+  padding: 0 14px;
+  gap: 14px;
+  flex-shrink: 0;
+  font-size: 9px;
+  letter-spacing: 1px;
+}
+.api-chip {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  color: var(--muted);
+}
+.api-chip.ok   .api-dot { background: var(--green); }
+.api-chip.err  .api-dot { background: var(--red); }
+.api-chip.busy .api-dot { background: var(--amber); animation: blink 1s infinite; }
+.api-dot {
+  width: 5px;
+  height: 5px;
+  border-radius: 50%;
+  background: var(--muted2);
+}
+
+/* ── Body Layout ───────────────────────────────────────────────────────────── */
+.body {
+  flex: 1;
+  display: grid;
+  grid-template-columns: 200px 1fr 260px;
+  overflow: hidden;
+  min-height: 0;
+}
+
+/* ── Left Sidebar ──────────────────────────────────────────────────────────── */
+.sidebar {
+  background: var(--bg1);
+  border-right: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.sb-header {
+  padding: 7px 10px;
+  background: var(--bg2);
+  border-bottom: 1px solid var(--border);
+  color: var(--amber);
+  font-size: 9px;
+  letter-spacing: 2px;
+  text-transform: uppercase;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  flex-shrink: 0;
+}
+
+.sb-seg {
+  padding: 6px 8px;
+  border-bottom: 1px solid var(--border);
+  flex-shrink: 0;
+}
+.seg-btn { display: flex; gap: 3px; }
+.seg-btn button {
+  flex: 1;
+  background: var(--bg3);
+  border: 1px solid var(--border);
+  color: var(--muted);
+  font-family: var(--font);
+  font-size: 9px;
+  padding: 4px;
+  cursor: pointer;
+  border-radius: var(--r);
+  letter-spacing: 1px;
+  transition: all 0.15s;
+}
+.seg-btn button.active {
+  background: var(--amber);
+  color: #000;
+  border-color: var(--amber);
+  font-weight: 600;
+}
+
+.sb-search {
+  padding: 6px 8px;
+  border-bottom: 1px solid var(--border);
+  flex-shrink: 0;
+}
+.sb-search input {
+  width: 100%;
+  background: var(--bg3);
+  border: 1px solid var(--border);
+  color: var(--white);
+  font-family: var(--font);
+  font-size: 10px;
+  padding: 4px 8px;
+  outline: none;
+  border-radius: var(--r);
+  transition: border-color 0.15s;
+}
+.sb-search input:focus { border-color: var(--amber-dim); }
+
+.ticker-list {
+  overflow-y: auto;
+  flex: 1;
+}
+
+.ticker-row {
+  display: flex;
+  align-items: center;
+  padding: 5px 10px;
+  cursor: pointer;
+  border-bottom: 1px solid var(--border);
+  transition: background 0.1s;
+  gap: 6px;
+}
+.ticker-row:hover { background: var(--bg3); }
+.ticker-row.sel {
+  background: var(--amber-lo);
+  border-left: 2px solid var(--amber);
+}
+.ticker-row.rippling     { animation: rowripple    0.6s ease-out; }
+.ticker-row.rippling-up  { animation: rowripple-up 0.6s ease-out; }
+@keyframes rowripple    { 0% { background: rgba(224,52,52,.35); }  100% { background: transparent; } }
+@keyframes rowripple-up { 0% { background: rgba(0,200,122,.35); } 100% { background: transparent; } }
+
+.t-sym   { color: var(--amber); font-size: 10px; font-weight: 600; width: 62px; flex-shrink: 0; }
+.t-phi   { font-size: 9px; text-align: right; flex-shrink: 0; width: 32px; }
+.t-bar   { flex: 1; height: 3px; background: var(--bg4); border-radius: 2px; overflow: hidden; }
+.t-bar-fill { height: 3px; border-radius: 2px; transition: width 0.3s; }
+
+/* ── Center Panel ──────────────────────────────────────────────────────────── */
+.center {
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  background: var(--bg0);
+  position: relative;
+}
+
+.view {
+  display: none;
+  flex: 1;
+  flex-direction: column;
+  overflow: hidden;
+}
+.view.active { display: flex; }
+
+.view-header {
+  padding: 8px 14px;
+  background: var(--bg2);
+  border-bottom: 1px solid var(--border);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  flex-shrink: 0;
+}
+.vh-title { color: var(--amber); font-size: 10px; letter-spacing: 2px; font-weight: 600; }
+.vh-meta  { color: var(--muted); font-size: 9px; }
+
+.view-body {
+  flex: 1;
+  overflow: auto;
+  padding: 12px;
+  position: relative;
+}
+
+/* ── Legend ────────────────────────────────────────────────────────────────── */
+.legend {
+  display: flex;
+  gap: 14px;
+  align-items: center;
+  padding: 6px 12px;
+  border-bottom: 1px solid var(--border);
+  flex-shrink: 0;
+  flex-wrap: wrap;
+}
+.leg-item { display: flex; align-items: center; gap: 5px; font-size: 9px; color: var(--muted); }
+.leg-dot  { width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0; }
+.leg-line { width: 18px; height: 2px; flex-shrink: 0; }
+
+/* ── Heatmap ───────────────────────────────────────────────────────���───────── */
+.hm-wrap { overflow: auto; padding: 0; }
+#heatmap-svg { display: block; }
+.hm-cell { cursor: pointer; transition: opacity 0.15s; }
+.hm-cell:hover { opacity: 0.75; stroke: #fff !important; stroke-width: 1.5 !important; }
+.hm-cell.ripple-out  { animation: hmripple     1s ease-out forwards; }
+.hm-cell.ripple-in   { animation: hmripple-in  0.8s ease-out forwards; }
+.hm-cell.ripple-pulse { animation: hmpulse     1.2s ease-in-out 3; }
+@keyframes hmripple    { 0% { opacity:1; fill: rgba(224,52,52,0.9); }  100% { opacity: 1; } }
+@keyframes hmripple-in { 0% { opacity:1; fill: rgba(0,200,122,0.9); } 100% { opacity: 1; } }
+@keyframes hmpulse     { 0%,100% { opacity:1; } 50% { opacity: 0.3; } }
+
+/* ── Network ───────────────────────────────────────────────────────────────── */
+#net-svg { display: block; width: 100%; height: 100%; }
+.net-node { cursor: pointer; }
+.net-node:hover circle { stroke-width: 2; }
+.net-edge { transition: stroke-width 0.2s, stroke-opacity 0.2s; }
+
+/* ── Right Panel ───────────────────────────────────────────────────────────── */
+.rpanel {
+  background: var(--bg1);
+  border-left: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.rp-sec { border-bottom: 1px solid var(--border); flex-shrink: 0; }
+.rp-head {
+  padding: 6px 10px;
+  background: var(--bg2);
+  border-bottom: 1px solid var(--border);
+  font-size: 9px;
+  letter-spacing: 2px;
+  color: var(--cyan);
+  font-weight: 600;
+  text-transform: uppercase;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+.rp-row {
+  display: flex;
+  justify-content: space-between;
+  padding: 4px 10px;
+  border-bottom: 1px solid var(--border);
+  font-size: 10px;
+}
+.rp-k { color: var(--muted); }
+.rp-v { color: var(--white); }
+.rp-v.up { color: var(--green); }
+.rp-v.dn { color: var(--red); }
+.rp-v.am { color: var(--amber); }
+
+/* ── Inference Panel ───────────────────────────────────────────────────────── */
+.infer-panel { padding: 10px; }
+.infer-mode  { display: flex; gap: 4px; margin-bottom: 10px; }
+.infer-mode button {
+  flex: 1;
+  background: var(--bg3);
+  border: 1px solid var(--border);
+  color: var(--muted);
+  font-family: var(--font);
+  font-size: 9px;
+  padding: 5px;
+  cursor: pointer;
+  border-radius: var(--r);
+  letter-spacing: 1px;
+  transition: all 0.15s;
+}
+.infer-mode button.active { font-weight: 600; }
+.infer-mode button.m-assert.active    { background: var(--cyan-lo);   color: var(--cyan);   border-color: var(--cyan); }
+.infer-mode button.m-intervene.active { background: var(--amber-lo);  color: var(--amber);  border-color: var(--amber); }
+.infer-mode button.m-counter.active   { background: var(--purple-lo); color: var(--purple); border-color: var(--purple); }
+
+.infer-form {
+  background: var(--bg2);
+  border: 1px solid var(--border);
+  border-radius: var(--r);
+  padding: 10px;
+  margin-bottom: 8px;
+}
+.infer-label {
+  font-size: 9px;
+  color: var(--muted);
+  letter-spacing: 1.5px;
+  text-transform: uppercase;
+  margin-bottom: 5px;
+}
+.infer-select {
+  width: 100%;
+  background: var(--bg3);
+  border: 1px solid var(--border);
+  color: var(--white);
+  font-family: var(--font);
+  font-size: 10px;
+  padding: 5px 8px;
+  outline: none;
+  border-radius: var(--r);
+  margin-bottom: 8px;
+  cursor: pointer;
+}
+.infer-select:focus { border-color: var(--amber-dim); }
+
+.slider-wrap { margin-bottom: 10px; }
+.slider-row  { display: flex; justify-content: space-between; margin-bottom: 4px; }
+.slider-val  { color: var(--amber); font-weight: 600; font-size: 10px; }
+input[type=range] { width: 100%; accent-color: var(--amber); cursor: pointer; height: 3px; }
+
+.run-btn {
+  width: 100%;
+  padding: 8px;
+  border: none;
+  font-family: var(--font);
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 2px;
+  cursor: pointer;
+  border-radius: var(--r);
+  transition: opacity 0.2s, transform 0.2s;
+}
+.run-btn.assert    { background: var(--cyan);   color: #000; }
+.run-btn.intervene { background: var(--amber);  color: #000; }
+.run-btn.counter   { background: var(--purple); color: #000; }
+.run-btn:hover  { opacity: 0.85; transform: translateY(-1px); }
+.run-btn:active { transform: translateY(0); }
+.run-btn:disabled { opacity: 0.4; cursor: not-allowed; }
+
+/* ── Result Cards ──────────────────────────────────────────────────────────── */
+.result-card {
+  background: var(--bg2);
+  border: 1px solid var(--border);
+  border-radius: var(--r);
+  padding: 10px;
+  margin-bottom: 8px;
+  position: relative;
+  overflow: hidden;
+}
+.result-card::before {
+  content: '';
+  position: absolute;
+  top: 0; left: 0;
+  width: 3px; height: 100%;
+}
+.result-card.assert::before   { background: var(--cyan); }
+.result-card.intervene::before { background: var(--amber); }
+.result-card.counter::before  { background: var(--purple); }
+.rc-head { font-size: 9px; letter-spacing: 1.5px; margin-bottom: 6px; font-weight: 600; }
+.rc-head.assert    { color: var(--cyan); }
+.rc-head.intervene { color: var(--amber); }
+.rc-head.counter   { color: var(--purple); }
+.rc-row { display: flex; justify-content: space-between; font-size: 10px; padding: 2px 0; }
+.rc-k   { color: var(--muted); }
+.rc-v   { color: var(--white); }
+.rc-v.up { color: var(--green); }
+.rc-v.dn { color: var(--red); }
+.rc-v.am { color: var(--amber); }
+
+.ate-track {
+  height: 4px;
+  background: var(--bg4);
+  border-radius: 2px;
+  margin-top: 6px;
+  overflow: hidden;
+}
+.ate-fill {
+  height: 4px;
+  border-radius: 2px;
+  transition: width 0.8s ease;
+}
+
+.ripple-effects {
+  margin-top: 8px;
+  padding-top: 8px;
+  border-top: 1px solid var(--border);
+}
+.ripple-title { font-size: 9px; color: var(--muted); letter-spacing: 1px; margin-bottom: 5px; }
+.ripple-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 2px 7px;
+  border-radius: 2px;
+  font-size: 9px;
+  margin: 2px;
+  border: 1px solid;
+}
+.ripple-chip.up { background: var(--green-lo); border-color: var(--green); color: var(--green); }
+.ripple-chip.dn { background: var(--red-lo);   border-color: var(--red);   color: var(--red); }
+
+/* ── News Feed ─────────────────────────────────────────────────────────────── */
+.news-item {
+  padding: 7px 10px;
+  border-bottom: 1px solid var(--border);
+  cursor: pointer;
+  transition: background 0.1s;
+}
+.news-item:hover { background: var(--bg3); }
+.news-top { display: flex; align-items: center; gap: 6px; margin-bottom: 3px; }
+.news-score { font-size: 8px; padding: 1px 5px; border-radius: 2px; font-weight: 600; }
+.news-score.hi { background: var(--green-lo); color: var(--green); }
+.news-score.md { background: var(--amber-lo); color: var(--amber); }
+.news-score.lo { background: var(--red-lo);   color: var(--red); }
+.news-sym  { color: var(--amber); font-size: 9px; font-weight: 600; }
+.news-text { font-size: 9px; color: var(--muted); line-height: 1.5; margin-bottom: 4px; }
+.news-tags { display: flex; gap: 3px; flex-wrap: wrap; }
+.news-tag  { font-size: 8px; padding: 1px 5px; border: 1px solid var(--border); color: var(--muted); border-radius: 2px; }
+
+/* ── HHKD View ─────────────────────────────────────────────────────────────── */
+.phi-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 10px;
+  border-bottom: 1px solid var(--border);
+  cursor: pointer;
+  transition: background 0.1s;
+}
+.phi-row:hover { background: var(--bg3); }
+.phi-sym { width: 66px; font-size: 10px; color: var(--amber); font-weight: 600; flex-shrink: 0; }
+.phi-bar-wrap { flex: 1; height: 8px; background: var(--bg4); border-radius: 4px; overflow: hidden; }
+.phi-bar-fill { height: 8px; border-radius: 4px; transition: width 0.4s; }
+.phi-val { width: 36px; text-align: right; font-size: 10px; flex-shrink: 0; }
+
+/* ── Sector View ───────────────────────────────────────────────────────────── */
+.sector-grid { padding: 10px; display: flex; flex-direction: column; gap: 8px; }
+.sec-card { background: var(--bg2); border: 1px solid var(--border); border-radius: var(--r); overflow: hidden; }
+.sec-card-head {
+  padding: 7px 12px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  cursor: pointer;
+  transition: background 0.1s;
+}
+.sec-card-head:hover { background: var(--bg3); }
+.sec-name { font-size: 11px; font-weight: 600; letter-spacing: 1px; color: var(--white); }
+.sec-phi  { font-size: 10px; }
+.sec-members { display: flex; flex-wrap: wrap; gap: 4px; padding: 8px; }
+.sec-chip {
+  padding: 3px 9px;
+  border: 1px solid var(--border);
+  font-size: 9px;
+  border-radius: 2px;
+  cursor: pointer;
+  transition: all 0.15s;
+}
+.sec-chip:hover { border-color: var(--amber); color: var(--amber); }
+.sec-chip.rippling    { animation: chipripple    0.7s ease-out; }
+.sec-chip.rippling-up { animation: chipripple-up 0.7s ease-out; }
+@keyframes chipripple    { 0% { background: rgba(224,52,52,.4);  border-color: var(--red); }  100% { background: transparent; } }
+@keyframes chipripple-up { 0% { background: rgba(0,200,122,.4); border-color: var(--green); } 100% { background: transparent; } }
+
+/* ── Node Popup ────────────────────────────────────────────────────────────── */
+.node-popup {
+  position: fixed;
+  z-index: 500;
+  background: var(--bg2);
+  border: 1px solid var(--amber);
+  border-radius: var(--r);
+  padding: 12px;
+  min-width: 200px;
+  max-width: 260px;
+  pointer-events: none;
+  display: none;
+  box-shadow: 0 8px 32px rgba(0,0,0,.6);
+}
+.np-head {
+  color: var(--amber);
+  font-size: 12px;
+  font-weight: 600;
+  margin-bottom: 8px;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+.np-row {
+  display: flex;
+  justify-content: space-between;
+  padding: 3px 0;
+  border-bottom: 1px solid var(--border);
+  font-size: 10px;
+}
+.np-row:last-child { border: none; }
+.np-k { color: var(--muted); }
+.np-v { color: var(--white); }
+.np-v.up { color: var(--green); }
+.np-v.dn { color: var(--red); }
+.np-v.am { color: var(--amber); }
+
+/* ── Status Strip ──────────────────────────────────────────────────────────── */
+.status-strip {
+  height: 22px;
+  background: var(--bg2);
+  border-top: 1px solid var(--border);
+  display: flex;
+  align-items: center;
+  padding: 0 10px;
+  gap: 16px;
+  flex-shrink: 0;
+  overflow: hidden;
+}
+.ss-chip { font-size: 9px; display: flex; gap: 5px; white-space: nowrap; }
+.ss-k    { color: var(--muted); }
+.ss-v    { color: var(--white); }
+.ss-v.am { color: var(--amber); }
+.ss-v.up { color: var(--green); }
+
+/* ── Accordion ─────────────────────────────────────────────────────────────── */
+.accordion { border: 1px solid var(--border); border-radius: var(--r); margin-bottom: 6px; overflow: hidden; }
+.acc-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 7px 10px;
+  cursor: pointer;
+  background: var(--bg2);
+  user-select: none;
+}
+.acc-head:hover { background: var(--bg3); }
+.acc-title { font-size: 10px; color: var(--white); font-weight: 500; letter-spacing: 0.5px; }
+.acc-badge { font-size: 8px; padding: 1px 6px; border-radius: 2px; font-weight: 600; letter-spacing: 1px; }
+.acc-badge.up { background: var(--green-lo); color: var(--green); }
+.acc-badge.dn { background: var(--red-lo);   color: var(--red); }
+.acc-badge.am { background: var(--amber-lo); color: var(--amber); }
+.acc-badge.cy { background: var(--cyan-lo);  color: var(--cyan); }
+.acc-chevron { color: var(--muted); font-size: 10px; transition: transform 0.2s; }
+.acc-chevron.open { transform: rotate(180deg); }
+.acc-body { display: none; border-top: 1px solid var(--border); }
+.acc-body.open { display: block; }
+.acc-row { display: flex; justify-content: space-between; padding: 4px 10px; border-bottom: 1px solid var(--border); font-size: 10px; }
+.acc-k { color: var(--muted); }
+.acc-v { color: var(--white); }
+.acc-v.up { color: var(--green); }
+.acc-v.dn { color: var(--red); }
+.acc-v.am { color: var(--amber); }
+
+/* ── Ripple Ring ───────────────────────────────────────────────────────────── */
+@keyframes pulse-ring { 0% { transform: scale(.8); opacity: 1; } 100% { transform: scale(2.5); opacity: 0; } }
+.ripple-ring {
+  position: absolute;
+  border-radius: 50%;
+  pointer-events: none;
+  animation: pulse-ring 0.8s ease-out forwards;
+}
+
+/* ── Error toast ───────────────────────────────────────────────────────────── */
+#error-toast {
+  position: fixed;
+  bottom: 28px;
+  left: 50%;
+  transform: translateX(-50%) translateY(60px);
+  background: var(--red-lo);
+  border: 1px solid var(--red);
+  color: var(--red);
+  font-size: 10px;
+  padding: 8px 16px;
+  border-radius: var(--r);
+  z-index: 9000;
+  transition: transform 0.3s ease;
+  letter-spacing: 0.5px;
+}
+#error-toast.show { transform: translateX(-50%) translateY(0); }

server.py

@@ -0,0 +1,918 @@
+"""
+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
+from gradio import Server
+from typing import Any, Dict, List, Optional
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+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")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# gr.Server
+# ─────────────────────────────────────────────────────────────────────────────
+
+FRONTEND_DIR = BASE_DIR / "frontend"
+INDEX_HTML   = FRONTEND_DIR / "index.html"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 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,
+    }
+
+server = Server(
+    title="Iroha Causal Terminal",
+    description=(
+        "Iroha Financial Intelligence — real-time causal probability matrix, "
+        "HHKD decomposition, DoFlow inference and sector hierarchy over NIFTY50."
+    ),
+    version="2.0.0",
+)
+
+# ── CORS (same as main.py) ────────────────────────────────────────────────
+server.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ── Static files — mount frontend/ at /static ─────────────────────────────
+server.mount(
+    "/static",
+    StaticFiles(directory=str(FRONTEND_DIR)),
+    name="static",
+)
+
+# ─────────────────────────────────────────────────────────────────────────────
+# HTML route — serves the custom frontend
+# ─────────────────────────────────────────────────────────────────────────────
+
+@server.get("/", response_class=HTMLResponse, include_in_schema=False)
+async def serve_index():
+    """Serve the Iroha Causal Terminal SPA."""
+    if not INDEX_HTML.exists():
+        return HTMLResponse("<h1>Frontend not found. Run from backend/</h1>", status_code=500)
+    return HTMLResponse(INDEX_HTML.read_text(encoding="utf-8"))
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Health check
+# ─────────────────────────────────────────────────────────────────────────────
+
+@server.get("/v2/health", tags=["utility"])
+async def health():
+    """Lightweight health-check used by the frontend API banner."""
+    return {"status": "ok", "version": "2.0.0"}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# gr.Server API endpoints (Gradio-backed — queue + SSE streaming)
+# These are reachable via the Gradio JS Client as well as plain fetch().
+# ─────────────────────────────────────────────────────────────────────────────
+
+# ── 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.
+
+
+@server.api(
+    name="run_inference",
+    description=(
+        "Run causal inference (association / intervention / counterfactual) "
+        "using a validated causal matrix fetched from the backend API. "
+        "Layers: 1=Association(DoWhy backdoor), 2=Intervention(SCM propagation), "
+        "3=Counterfactual(SCM abduction)."
+    ),
+    concurrency_limit=4,
+)
+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)}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Entry point
+# ─────────────────────────────────────────────────────────────────────────────
+
+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}")
+    logger.info(f"  → Frontend : http://localhost:{port}/")
+    logger.info(f"  → API docs : http://localhost:{port}/docs")
+
+    server.launch(
+        server_name=host,
+        server_port=port,
+        allowed_paths=[str(FRONTEND_DIR)],
+        show_error=True,
+        quiet=False,
+    )