Update app.py

app.py

@@ -1,539 +1,210 @@
 import os
 import sys
-import time
-import uuid
-import json
+import subprocess
 from pathlib import Path
-
 import gradio as gr
-import numpy as np
-import matplotlib.pyplot as plt
+
+# ============================================================
+# Paths
+# ============================================================
 
 ROOT = Path(__file__).resolve().parent
 
-# Make local quark folders importable
-for p in [ROOT / 'Down', ROOT / 'Strange', ROOT / 'Charm']:
-    if p.exists() and str(p) not in sys.path:
-        sys.path.insert(0, str(p))
-
-RUNTIME_DIR = Path('/tmp/twoquarks_runs')
-RUNTIME_DIR.mkdir(parents=True, exist_ok=True)
-
-
-def _run_id() -> str:
-    return str(uuid.uuid4())[:8]
-
-
-def _save_csv(path: Path, header: list[str], rows: list[list[object]]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open('w', encoding='utf-8') as f:
-        f.write(','.join(header) + '\n')
-        for row in rows:
-            f.write(','.join(map(str, row)) + '\n')
-
-
-def _plot_series(y, title, xlabel='step', ylabel='value'):
-    fig, ax = plt.subplots()
-    ax.plot(y)
-    ax.set_title(title)
-    ax.set_xlabel(xlabel)
-    ax.set_ylabel(ylabel)
-    ax.grid(True, alpha=0.2)
-    return fig
-
-
-def _save_fig(fig, path: Path) -> str:
-    """Save a matplotlib figure as PNG and return the filepath (string)."""
-    path.parent.mkdir(parents=True, exist_ok=True)
-    fig.savefig(path, dpi=160, bbox_inches='tight')
-    return str(path)
-
-
-# =========================
-# DOWN / AntiDown
-# =========================
-
-def run_down(episodes_per_phase: int, seed: int):
-    """Runs Down paradox tabular experiment (HFLevo vs LevoParadoxIsomer)."""
-    from down.exp.run_paradox_tabular import run_experiment
-
-    run_id = _run_id()
-    out_dir = RUNTIME_DIR / f'down_{run_id}'
-    out_csv = out_dir / 'down_paradox_tabular_results.csv'
-
-    run_experiment(out_csv=out_csv, episodes_per_phase=int(episodes_per_phase), seed=int(seed))
-
-    # Load and summarize
-    import csv
-    rows = []
-    with out_csv.open('r', encoding='utf-8') as f:
-        reader = csv.DictReader(f)
-        for r in reader:
-            rows.append(r)
-
-    # Aggregate mean reward by phase+agent
-    phases = sorted({int(r['phase']) for r in rows})
-    agents = sorted({r['agent'] for r in rows})
-    summary = {}
-    for a in agents:
-        summary[a] = {p: [] for p in phases}
-    for r in rows:
-        summary[r['agent']][int(r['phase'])].append(float(r['episode_reward']))
-
-    table_lines = []
-    for a in agents:
-        for p in phases:
-            vals = summary[a][p]
-            table_lines.append({
-                'agent': a,
-                'phase': p,
-                'mean_reward': float(np.mean(vals)) if vals else float('nan'),
-                'std_reward': float(np.std(vals)) if vals else float('nan'),
-                'n': len(vals),
-            })
-
-    # Plot: mean reward per phase (bar-ish via line)
-    fig, ax = plt.subplots()
-    for a in agents:
-        means = [np.mean(summary[a][p]) if summary[a][p] else np.nan for p in phases]
-        ax.plot(phases, means, marker='o', label=a)
-    ax.set_title('DOWN: Mean reward by phase')
-    ax.set_xlabel('phase')
-    ax.set_ylabel('mean episode reward')
-    ax.grid(True, alpha=0.2)
-    ax.legend()
+DOWN_ROOT = ROOT / "Down"
+STRANGE_ROOT = ROOT / "Strange"
 
-    meta = {
-        'run_id': run_id,
-        'timestamp_utc': time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime()),
-        'seed': int(seed),
-        'episodes_per_phase': int(episodes_per_phase),
-        'artifact_csv': str(out_csv),
-    }
+DOWN_GRAPHICS = DOWN_ROOT / "graphics"
+STRANGE_GRAPHICS = STRANGE_ROOT / "graphics"
 
-    # Save plot(s) to PNG for the UI carousel
-    graphics_dir = out_dir / 'graphics'
-    mean_plot = _save_fig(fig, graphics_dir / 'down_mean_reward_by_phase.png')
-    carousel = [mean_plot]
-
-    headers = ['agent', 'phase', 'mean_reward', 'std_reward', 'n']
-    rows = [[row.get(h) for h in headers] for row in table_lines]
-    return json.dumps(meta, indent=2), rows, fig, str(out_csv), carousel
-
-
-def run_antidown(n_episodes: int, base_seed: int):
-    """Runs AntiDown corrupted valley tabular experiment with adjustable n_episodes."""
-    # Import pieces from the script
-    from AntiDown.envs.corrupted_valley import CorruptedValleyEnv
-    from AntiDown.levo.levo_q_tabular import LevoQTabularAgent
-    from AntiDown.levo.levo_thinking_ensemble import LevoThinkingEnsembleAgent
-    from AntiDown.exp.run_corrupted_valley_tabular import EpsGreedyQAgent, SoftmaxBoltzmannAgent, run_phase
-    from AntiDown.utils.logging import CSVLogger
-
-    run_id = _run_id()
-    out_dir = RUNTIME_DIR / f'antidown_{run_id}'
-    out_csv = out_dir / 'antidown_corrupted_valley_tabular.csv'
-
-    base_seed = int(base_seed)
-    seed_offset = 1000
-
-    probe_env = CorruptedValleyEnv(seed=base_seed, phase=1)
-    n_states = probe_env.n_states
-    n_actions = probe_env.n_actions
-
-    agents = [
-        EpsGreedyQAgent(n_states, n_actions, epsilon=0.1, name='EpsGreedy'),
-        SoftmaxBoltzmannAgent(n_states, n_actions, tau=0.5, name='Softmax'),
-        LevoQTabularAgent(n_states, n_actions, A=0.5, omega=0.05, ent_weight=0.0, name='LevoQ'),
-        LevoThinkingEnsembleAgent(n_states, n_actions, n_heads=5, A=0.5, omega=0.05, lambda_var=0.5, name='LevoThinking'),
-    ]
 
-    logger = CSVLogger(
-        str(out_csv),
-        fieldnames=['phase', 'phase_tag', 'episode', 'agent', 'total_reward', 'valley_visits'],
-    )
+# ============================================================
+# Helpers
+# ============================================================
 
-    n_episodes = int(n_episodes)
-
-    # 3 phases
-    run_phase(base_seed, seed_offset, 1, n_episodes, agents, logger, noisy_heads_spec=None, noise_std=0.0)
-    run_phase(base_seed, seed_offset, 2, n_episodes, agents, logger, noisy_heads_spec=None, noise_std=0.0)
-    run_phase(base_seed, seed_offset, 3, n_episodes, agents, logger, noisy_heads_spec=None, noise_std=0.1)
-
-    # Summarize
-    import csv
-    rows = []
-    with out_csv.open('r', encoding='utf-8') as f:
-        reader = csv.DictReader(f)
-        for r in reader:
-            rows.append(r)
-
-    phases = sorted({int(r['phase']) for r in rows})
-    agents_names = sorted({r['agent'] for r in rows})
-    summary = {a: {p: [] for p in phases} for a in agents_names}
-    for r in rows:
-        summary[r['agent']][int(r['phase'])].append(float(r['total_reward']))
-
-    table_lines = []
-    for a in agents_names:
-        for p in phases:
-            vals = summary[a][p]
-            table_lines.append({
-                'agent': a,
-                'phase': p,
-                'mean_total_reward': float(np.mean(vals)) if vals else float('nan'),
-                'std_total_reward': float(np.std(vals)) if vals else float('nan'),
-                'mean_valley_visits': float(np.mean([float(rr['valley_visits']) for rr in rows if rr['agent']==a and int(rr['phase'])==p])) if vals else float('nan'),
-                'n': len(vals),
-            })
-
-    fig, ax = plt.subplots()
-    for a in agents_names:
-        means = [np.mean(summary[a][p]) if summary[a][p] else np.nan for p in phases]
-        ax.plot(phases, means, marker='o', label=a)
-    ax.set_title('AntiDown: Mean total reward by phase')
-    ax.set_xlabel('phase')
-    ax.set_ylabel('mean episode total reward')
-    ax.grid(True, alpha=0.2)
-    ax.legend()
+def _clean_pngs(folder: Path):
+    if folder.exists():
+        for f in folder.glob("*.png"):
+            f.unlink()
+    else:
+        folder.mkdir(parents=True, exist_ok=True)
 
-    meta = {
-        'run_id': run_id,
-        'timestamp_utc': time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime()),
-        'base_seed': base_seed,
-        'episodes_per_phase': n_episodes,
-        'artifact_csv': str(out_csv),
-    }
 
-    # Save plot(s) to PNG for the UI carousel
-    graphics_dir = out_dir / 'graphics'
-    mean_plot = _save_fig(fig, graphics_dir / 'antidown_mean_total_reward_by_phase.png')
-    carousel = [mean_plot]
+def _collect_pngs(folder: Path):
+    return sorted(str(p) for p in folder.glob("*.png"))
 
-    headers = ['agent', 'phase', 'mean_total_reward', 'std_total_reward', 'mean_valley_visits', 'n']
-    rows = [[row.get(h) for h in headers] for row in table_lines]
-    return json.dumps(meta, indent=2), rows, fig, str(out_csv), carousel
 
+# ============================================================
+# DOWN (Unified: Down + AntiDown)
+# ============================================================
 
-# =========================
-# STRANGE / AntiStrange
-# =========================
+def run_down_all(episodes_per_phase: int):
+    run_all = DOWN_ROOT / "run_all.py"
+    if not run_all.exists():
+        raise RuntimeError("Down/run_all.py not found")
 
-def run_strange(n_episodes: int, max_steps: int, seed: int, mode: str):
-    if mode == 'Strange':
-        from strange.exp.run_strange_hypothesis_lab import run_experiment
-        out_name = 'strange_hypothesis_lab.csv'
-    else:
-        from AntiStrange.exp.run_antistrange_hypothesis_lab import run_antistrange as run_experiment
-        out_name = 'antistrange_hypothesis_lab.csv'
-
-    run_id = _run_id()
-    out_dir = RUNTIME_DIR / f"{mode.lower()}_{run_id}"
-    out_csv = out_dir / out_name
-
-    run_experiment(n_episodes=int(n_episodes), max_steps=int(max_steps), seed=int(seed), out_path=str(out_csv))
-
-    # Load CSV and make curves
-    import csv
-    rewards_by_ep = {}
-    with out_csv.open('r', encoding='utf-8') as f:
-        reader = csv.DictReader(f)
-        for r in reader:
-            ep = int(r['episode'])
-            rewards_by_ep.setdefault(ep, 0.0)
-            rewards_by_ep[ep] += float(r['reward'])
-
-    eps = sorted(rewards_by_ep.keys())
-    ep_returns = [rewards_by_ep[e] for e in eps]
-
-    fig = _plot_series(ep_returns, f'{mode}: return per episode', xlabel='episode', ylabel='return')
-
-    metrics = {
-        'run_id': run_id,
-        'timestamp_utc': time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime()),
-        'mode': mode,
-        'seed': int(seed),
-        'n_episodes': int(n_episodes),
-        'max_steps': int(max_steps),
-        'return_mean_last_20': float(np.mean(ep_returns[-20:])) if len(ep_returns) >= 20 else float(np.mean(ep_returns)),
-        'return_std_last_20': float(np.std(ep_returns[-20:])) if len(ep_returns) >= 20 else float(np.std(ep_returns)),
-        'artifact_csv': str(out_csv),
-    }
+    _clean_pngs(DOWN_GRAPHICS)
 
-    # Save plot(s) to PNG for the UI carousel
-    graphics_dir = out_dir / 'graphics'
-    plot_path = _save_fig(fig, graphics_dir / f"{mode.lower()}_return_per_episode.png")
-    carousel = [plot_path]
+    cmd = [
+        sys.executable,
+        "run_all.py",
+        "--episodes",
+        str(int(episodes_per_phase)),
+    ]
 
-    return json.dumps(metrics, indent=2), fig, str(out_csv), carousel
+    subprocess.run(
+        cmd,
+        cwd=str(DOWN_ROOT),
+        env=os.environ.copy(),
+        check=True,
+    )
 
+    images = _collect_pngs(DOWN_GRAPHICS)
 
-# =========================
-# CHARM
-# =========================
+    meta = {
+        "status": "completed",
+        "pipeline": "DOWN + AntiDown (unified)",
+        "episodes_per_phase": int(episodes_per_phase),
+        "graphics_count": len(images),
+        "graphics_dir": str(DOWN_GRAPHICS),
+    }
 
-def run_charm(n_episodes: int, seed: int):
-    from charm.levo.charm import train_charm_enchanted_valley
+    return meta, images
 
-    run_id = _run_id()
-    out_dir = RUNTIME_DIR / f'charm_{run_id}'
-    out_dir.mkdir(parents=True, exist_ok=True)
 
-    stats = train_charm_enchanted_valley(n_episodes=int(n_episodes), seed=int(seed))
+# ============================================================
+# STRANGE (Unified: Strange + AntiStrange)
+# ============================================================
 
-    rewards = stats['rewards']
-    lam = stats['lambda']
-    rho = stats['rho_mean']
+def run_strange_all():
+    run_all = STRANGE_ROOT / "run_all.py"
+    if not run_all.exists():
+        raise RuntimeError("Strange/run_all.py not found")
 
-    fig_r = _plot_series(rewards, 'Charm: reward per episode', xlabel='episode', ylabel='reward')
-    fig_l = _plot_series(lam, 'Charm: lambda (meta-control) per episode', xlabel='episode', ylabel='lambda')
-    fig_rho = _plot_series(rho, 'Charm: rho_mean per episode', xlabel='episode', ylabel='rho_mean')
+    _clean_pngs(STRANGE_GRAPHICS)
 
-    # Save CSV artifact
-    out_csv = out_dir / 'charm_timeseries.csv'
-    header = ['episode', 'reward', 'lambda', 'rho_mean']
-    rows = [[i, float(rewards[i]), float(lam[i]), float(rho[i])] for i in range(len(rewards))]
-    _save_csv(out_csv, header, rows)
+    cmd = [sys.executable, "run_all.py"]
 
-    metrics = {
-        'run_id': run_id,
-        'timestamp_utc': time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime()),
-        'seed': int(seed),
-        'n_episodes': int(n_episodes),
-        'reward_mean_last_50': float(np.mean(rewards[-50:])) if len(rewards) >= 50 else float(np.mean(rewards)),
-        'reward_std_last_50': float(np.std(rewards[-50:])) if len(rewards) >= 50 else float(np.std(rewards)),
-        'artifact_csv': str(out_csv),
-    }
+    subprocess.run(
+        cmd,
+        cwd=str(STRANGE_ROOT),
+        env=os.environ.copy(),
+        check=True,
+    )
 
-    # Save plots to PNG for the UI carousel
-    graphics_dir = out_dir / 'graphics'
-    p_r   = _save_fig(fig_r, graphics_dir / 'charm_reward.png')
-    p_l   = _save_fig(fig_l, graphics_dir / 'charm_lambda.png')
-    p_rho = _save_fig(fig_rho, graphics_dir / 'charm_rho_mean.png')
-    carousel = [p_r, p_l, p_rho]
+    images = _collect_pngs(STRANGE_GRAPHICS)
 
-    return json.dumps(metrics, indent=2), fig_r, fig_l, fig_rho, str(out_csv), carousel
+    meta = {
+        "status": "completed",
+        "pipeline": "STRANGE + AntiStrange (unified)",
+        "graphics_count": len(images),
+        "graphics_dir": str(STRANGE_GRAPHICS),
+    }
 
+    return meta, images
 
-# =========================
+
+# ============================================================
 # UI
-# =========================
+# ============================================================
 
 def build_ui():
-    css_path = ROOT / "style.css"
-    css = css_path.read_text(encoding="utf-8") if css_path.exists() else ""
-
-    NAV_HTML = """
-<nav id="tqNav">
-  <div class="nav-inner">
-    <div class="brand">TwoQuarks</div>
-    <div class="nav-links">
-      <a href="#down" onclick="return false;">DOWN</a>
-      <a href="#strange" onclick="return false;">STRANGE</a>
-      <a href="#top" onclick="return false;">TOP</a>
-      <a href="#charm" onclick="return false;">CHARM</a>
-      <a href="#up" onclick="return false;">UP</a>
-      <a href="#bottom" onclick="return false;">BOTTOM</a>
-    </div>
-    <div class="spacer"></div>
-    <div class="menu-btn" id="menuBtn" title="Menu"><span></span></div>
-    <div class="menu" id="siteMenu">
-      <a href="https://twoquarks.com/#about" target="_blank" rel="noopener">ABOUT</a>
-      <a href="https://twoquarks.com/quarkslab.html" target="_blank" rel="noopener">QuarksLab</a>
-      <div class="sep"></div>
-      <a href="https://twoquarks.com/quarks/bottom/resume.pdf" target="_blank" rel="noopener">Resume</a>
-      <a href="https://twoquarks.com/summary.pdf" target="_blank" rel="noopener">Summary</a>
-    </div>
-  </div>
-</nav>
-"""
+    with gr.Blocks(
+        title="TwoQuarks — QuarksLab (Interactive)",
+    ) as demo:
 
-    head = """
-<link rel="preconnect" href="https://fonts.googleapis.com">
-<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-<link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600;700&display=swap" rel="stylesheet">
-
-<canvas id="quantumField"></canvas>
-
-<script>
-(function(){
-  // Hamburger menu toggle
-  window.addEventListener("load", () => {
-    const menuBtn = document.getElementById('menuBtn');
-    const siteMenu = document.getElementById('siteMenu');
-    if(menuBtn && siteMenu){
-      menuBtn.addEventListener('click', (e)=>{ e.stopPropagation(); siteMenu.classList.toggle('open'); });
-      document.addEventListener('click', ()=> siteMenu.classList.remove('open'));
-      siteMenu.addEventListener('click', (e)=> e.stopPropagation());
-    }
-  });
-
-  // Starfield (ported from your site canvas pattern)
-  const canvas = document.getElementById('quantumField');
-  if(!canvas) return;
-  const ctx = canvas.getContext('2d');
-
-  function resize(){
-    canvas.width = innerWidth;
-    canvas.height = innerHeight;
-  }
-  resize();
-  addEventListener('resize', resize);
-
-  let particles = [];
-  const count = 680;
-
-  for(let i=0;i<count;i++){
-    particles.push({
-      x:(Math.random()-0.5)*canvas.width,
-      y:(Math.random()-0.5)*canvas.height,
-      z:Math.random()*canvas.width,
-    });
-  }
-
-  function render(){
-    ctx.clearRect(0,0,canvas.width,canvas.height);
-    for(const p of particles){
-      p.z -= 2.2;
-      if(p.z < 1){
-        p.x=(Math.random()-0.7)*canvas.width;
-        p.y=(Math.random()-0.7)*canvas.height;
-        p.z=canvas.width;
-      }
-      const k=128/p.z;
-      const px=p.x*k+canvas.width/2;
-      const py=p.y*k+canvas.height/2;
-      const size=(1-p.z/canvas.width)*1.29;
-      ctx.beginPath();
-      ctx.fillStyle="rgba(140,180,255,0.85)";
-      ctx.arc(px,py,size,0,Math.PI*2);
-      ctx.fill();
-    }
-    requestAnimationFrame(render);
-  }
-  render();
-})();
-</script>
-"""
+        gr.Markdown(
+            """
+# TwoQuarks • QuarksLab (Interactive)
 
-    with gr.Blocks(title='TwoQuarks - QuarksLab (Interactive)', css=css, head=head) as demo:
-        gr.HTML(NAV_HTML)
-
-        with gr.Column(elem_id='tqApp'):
-            gr.HTML(
-                """
-                <div class="tq-hero">
-                  <div class="brand">TwoQuarks - QuarksLab (Interactive)</div>
-                  <div class="desc">Real runs, real knobs: seed/episodes/steps. Short-bounded experiments (public CPU).</div>
-                </div>
-                """
-            )
-
-            with gr.Tab('DOWN / AntiDown'):
-                gr.Markdown('Tabular experiments (fast).')
-
-                with gr.Row():
-                    down_eps = gr.Slider(50, 800, value=200, step=50, label='DOWN: episodes_per_phase')
-                    down_seed = gr.Number(value=2025, precision=0, label='DOWN: seed')
-                    run_down_btn = gr.Button('Run DOWN')
-
-                down_meta = gr.Code(label='DOWN: run meta (JSON)', language='json')
-                down_table = gr.Dataframe(
-                    headers=['agent', 'phase', 'mean_reward', 'std_reward', 'n'],
-                    label='DOWN: summary (mean/std by phase+agent)',
-                    interactive=False,
-                )
-                down_plot = gr.Plot(label='DOWN: mean reward by phase')
-                down_carousel = gr.Gallery(label='DOWN: results (carousel)', columns=1, height=520)
-                down_file = gr.File(label='DOWN: results CSV')
-
-                run_down_btn.click(
-                    fn=run_down,
-                    inputs=[down_eps, down_seed],
-                    outputs=[down_meta, down_table, down_plot, down_file, down_carousel],
-                )
-
-                gr.Markdown('---')
-
-                with gr.Row():
-                    ad_eps = gr.Slider(20, 400, value=120, step=20, label='AntiDown: episodes_per_phase')
-                    ad_seed = gr.Number(value=1234, precision=0, label='AntiDown: base seed')
-                    run_ad_btn = gr.Button('Run AntiDown')
-
-                ad_meta = gr.Code(label='AntiDown: run meta (JSON)', language='json')
-                ad_table = gr.Dataframe(
-                    headers=['agent', 'phase', 'mean_total_reward', 'std_total_reward', 'mean_valley_visits', 'n'],
-                    label='AntiDown: summary',
-                    interactive=False,
-                )
-                ad_plot = gr.Plot(label='AntiDown: mean total reward by phase')
-                ad_carousel = gr.Gallery(label='AntiDown: results (carousel)', columns=1, height=520)
-                ad_file = gr.File(label='AntiDown: results CSV')
-
-                run_ad_btn.click(
-                    fn=run_antidown,
-                    inputs=[ad_eps, ad_seed],
-                    outputs=[ad_meta, ad_table, ad_plot, ad_file, ad_carousel],
-                )
-
-            with gr.Tab('STRANGE / AntiStrange'):
-                gr.Markdown('HypothesisLab: swarm dynamics with hidden regime shifts.')
-                mode = gr.Radio(['Strange', 'AntiStrange'], value='Strange', label='Mode')
-
-                with gr.Row():
-                    seps = gr.Slider(50, 500, value=200, step=50, label='Episodes')
-                    ssteps = gr.Slider(10, 120, value=50, step=5, label='Max steps per episode')
-                    sseed = gr.Number(value=0, precision=0, label='Seed')
-
-                run_s_btn = gr.Button('Run')
-                s_meta = gr.Code(label='Run meta (JSON)', language='json')
-                s_plot = gr.Plot(label='Return per episode')
-                s_carousel = gr.Gallery(label='Results (carousel)', columns=1, height=520)
-                s_file = gr.File(label='Results CSV')
-
-                run_s_btn.click(
-                    fn=run_strange,
-                    inputs=[seps, ssteps, sseed, mode],
-                    outputs=[s_meta, s_plot, s_file, s_carousel],
-                )
-
-            with gr.Tab('CHARM'):
-                gr.Markdown('Enchanted Valley: non-stationary graph + CharmField meta-control.')
-
-                with gr.Row():
-                    ceps = gr.Slider(50, 600, value=300, step=50, label='Episodes')
-                    cseed = gr.Number(value=0, precision=0, label='Seed')
-                    run_c_btn = gr.Button('Run CHARM')
-
-                c_meta = gr.Code(label='Run meta (JSON)', language='json')
-                c_plot_r = gr.Plot(label='Reward')
-                c_plot_l = gr.Plot(label='Lambda')
-                c_plot_rho = gr.Plot(label='Rho_mean')
-                c_carousel = gr.Gallery(label='CHARM: results (carousel)', columns=1, height=520)
-                c_file = gr.File(label='Timeseries CSV')
-
-                run_c_btn.click(
-                    fn=run_charm,
-                    inputs=[ceps, cseed],
-                    outputs=[c_meta, c_plot_r, c_plot_l, c_plot_rho, c_file, c_carousel],
-                )
-
-            gr.Markdown(
-                """### Notes
-- This Space runs bounded experiments on shared CPU.
-- For heavy runs, keep episodes modest and use the CSV artifact to reproduce locally.
+**Real runs. Real artifacts. No duplicated models.**  
+Each section launches a **single unified pipeline** and displays the **actual plots generated**.
+"""
+        )
+
+        # ----------------------------
+        # DOWN
+        # ----------------------------
+        gr.Markdown("## DOWN / AntiDown")
+        gr.Markdown(
+            """
+Unified tabular paradox experiment.  
+This runs **one pipeline** that includes both quark and antiquark.
+"""
+        )
+
+        down_eps = gr.Slider(
+            minimum=50,
+            maximum=800,
+            step=50,
+            value=200,
+            label="Episodes per phase",
+        )
+
+        run_down_btn = gr.Button("Run DOWN (unified)")
+
+        down_meta = gr.JSON(label="Run status")
+        down_gallery = gr.Gallery(
+            label="Generated plots",
+            columns=2,
+            height="auto",
+        )
+
+        run_down_btn.click(
+            fn=run_down_all,
+            inputs=[down_eps],
+            outputs=[down_meta, down_gallery],
+        )
+
+        gr.Markdown("---")
+
+        # ----------------------------
+        # STRANGE
+        # ----------------------------
+        gr.Markdown("## STRANGE / AntiStrange")
+        gr.Markdown(
+            """
+Unified hypothesis lab (swarm dynamics + regime shifts).  
+Runs **Strange + AntiStrange + dual comparison** as a single experiment.
 """
-            )
+        )
+
+        run_strange_btn = gr.Button("Run STRANGE (unified)")
+
+        strange_meta = gr.JSON(label="Run status")
+        strange_gallery = gr.Gallery(
+            label="Generated plots",
+            columns=2,
+            height="auto",
+        )
+
+        run_strange_btn.click(
+            fn=run_strange_all,
+            inputs=[],
+            outputs=[strange_meta, strange_gallery],
+        )
+
+        gr.Markdown(
+            """
+---
+### Notes
+- All experiments are executed via their respective **`run_all.py`**.
+- Gradio does not import or orchestrate internal model logic.
+- All visualizations are read directly from the `graphics/` folders.
+"""
+        )
 
     return demo
 
 
+# ============================================================
+# Launch
+# ============================================================
+
 demo = build_ui()
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     demo.launch(
-        server_name='0.0.0.0',
-        server_port=int(os.getenv('PORT', '7860')),
+        server_name="0.0.0.0",
+        server_port=int(os.getenv("PORT", "7860")),
         show_api=False,
     )
-