Sweep/Sim param sync + CSV I/O + HW presets (Old/New ICV)

Major fix for Jimmy's reported bug: Sweep tab now honors Simulation tab baseline params. Cache key expanded to avoid stale results. Added CSV save/load for run params, 1D sweep point labels, and a Hardware dropdown with Baseline / Old ICV / New ICV presets sourced from the ICV sim-driver xlsx.

murphy_unified/__init__.py

@@ -0,0 +1,2 @@
+"""Murphy Unified — Consolidated Cryogenic Pump Dashboard."""
+__version__ = "0.1.0"

murphy_unified/__main__.py

@@ -0,0 +1,2 @@
+from murphy_unified.app import main
+main()

murphy_unified/agent/config.py

@@ -6,15 +6,14 @@ from pathlib import Path
 # ── Stored IDs (set by scripts/setup_agent.py, loaded from env) ──
 
 AGENT_ID = os.environ.get("CSH2_AGENT_ID", "")
-_agent_version_raw = os.environ.get("CSH2_AGENT_VERSION", "").strip()
-AGENT_VERSION = int(_agent_version_raw) if _agent_version_raw else 0
+AGENT_VERSION = os.environ.get("CSH2_AGENT_VERSION", "")
 ENVIRONMENT_ID = os.environ.get("CSH2_ENVIRONMENT_ID", "")
 
 # ── Paths ──
 
 DATA_DIR = Path(__file__).parent.parent / "data"
 SENSOR_TAG_MAP_PATH = DATA_DIR / "sensor_tag_map.json"
-DESIGN_RECORDS_DIR = Path("/tmp/design_records")
+DESIGN_RECORDS_DIR = Path(__file__).parent.parent.parent / "design_records"
 
 # ── System Prompt ──
 

murphy_unified/agent/orchestrator.py

@@ -92,7 +92,7 @@ class DesignSessionOrchestrator:
                 resources.append({
                     "type": "file",
                     "file_id": uploaded.id,
-                    "mount_path": "/workspace/sensor_tags.json",
+                    "path": "/workspace/sensor_tags.json",
                 })
                 log.info("Uploaded sensor tag map: %s", uploaded.id)
             except Exception:  # noqa: BLE001
@@ -146,7 +146,7 @@ class DesignSessionOrchestrator:
 
         self._emit(SessionEvent(type="status", content="Sending message…"))
 
-        with self._client.beta.sessions.events.stream(session_id=self.session_id) as stream:
+        with self._client.beta.sessions.stream(session_id=self.session_id) as stream:
             # Send after opening the stream (stream-first pattern)
             self._client.beta.sessions.events.send(
                 session_id=self.session_id,

murphy_unified/app.py

@@ -0,0 +1,108 @@
+"""Murphy Unified — Consolidated Cryogenic Pump Dashboard.
+
+Launch: python -m murphy_unified.app
+    or: murphy  (via pip install entry point)
+"""
+
+import gradio as gr
+
+from murphy_unified.sim_defaults import SIM_DEFAULTS
+from murphy_unified.theme import CSS, FONTS_HTML, FORCE_DARK
+from murphy_unified.tabs.simulation import build_simulation_tab
+from murphy_unified.tabs.sweep import build_sweep_tab
+from murphy_unified.tabs.sweep_params import build_sweep_params_tab
+from murphy_unified.tabs.comparison import build_comparison_tab
+from murphy_unified.tabs.real_cycles import build_real_cycles_tab
+from murphy_unified.tabs.design_agent import build_design_agent_tab
+from murphy_unified.tabs.process_sim import build_process_sim_tab
+
+# Feature flag: set True to show work-in-progress tabs (Optimizer, Sensitivity)
+SHOW_WIP_TABS = False
+
+if SHOW_WIP_TABS:
+    from murphy_unified.tabs.optimizer import build_optimizer_tab
+    from murphy_unified.tabs.sensitivity import build_sensitivity_tab
+
+
+def build_app() -> gr.Blocks:
+    with gr.Blocks(title="Murphy Unified") as app:
+        app.load(js=FORCE_DARK)
+
+        # Shared state: Simulation tab writes; Sweep tab reads (baseline panel).
+        sim_params_state = gr.State(dict(SIM_DEFAULTS))
+
+        # Cross-tab bridge: 2D sweep payload flows from Sweep → Process Sim.
+        sweep_to_process_state = gr.State(None)
+
+        gr.HTML(
+            '<div style="display:flex;align-items:center;gap:12px;padding:8px 0 4px;">'
+            '<span style="font-family:var(--body);font-size:18px;font-weight:700;'
+            'letter-spacing:3px;color:var(--accent);text-transform:uppercase;">'
+            'Murphy Unified</span>'
+            '<span style="font-family:var(--mono);font-size:11px;color:var(--text-dim);">'
+            'v0.2.0</span>'
+            '<span style="display:inline-flex;align-items:center;gap:6px;'
+            'font-family:var(--mono);font-size:10px;color:var(--accent2);'
+            'background:rgba(79,201,138,0.07);border:1px solid rgba(79,201,138,0.2);'
+            'border-radius:20px;padding:3px 10px;margin-left:auto;">'
+            '<span style="width:7px;height:7px;border-radius:50%;background:var(--accent2);'
+            'display:inline-block;"></span>READY</span>'
+            '</div>'
+        )
+
+        with gr.Tabs():
+            with gr.TabItem("Simulation"):
+                build_simulation_tab(sim_params_state)
+            with gr.TabItem("Sweep"):
+                sweep_handles = build_sweep_tab(sim_params_state)
+            with gr.TabItem("Sweep Across Parameters"):
+                build_sweep_params_tab()
+            with gr.TabItem("Process Sim"):
+                process_handles = build_process_sim_tab()
+            with gr.TabItem("Compare Engines"):
+                build_comparison_tab()
+            with gr.TabItem("Real Cycles"):
+                build_real_cycles_tab()
+            with gr.TabItem("Design Agent [WIP]"):
+                build_design_agent_tab()
+            if SHOW_WIP_TABS:
+                with gr.TabItem("Optimizer [WIP]"):
+                    build_optimizer_tab()
+                with gr.TabItem("Sensitivity [WIP]"):
+                    build_sensitivity_tab()
+
+        # ── Wire Sweep tab's Run button to produce the bridge payload ────
+        sweep_handles["run_btn"].click(
+            fn=sweep_handles["run_sweep"],
+            inputs=sweep_handles["run_inputs"],
+            outputs=[
+                sweep_handles["plot_out"],
+                sweep_handles["cache_html"],
+                sweep_handles["results_df"],
+                sweep_to_process_state,
+                sweep_handles["send_to_process_btn"],
+            ],
+        )
+
+        # ── Wire Send-to-Process-Sim button ──────────────────────────────
+        sweep_handles["send_to_process_btn"].click(
+            fn=process_handles["ingest_fn"],
+            inputs=[sweep_to_process_state],
+            outputs=[
+                process_handles["pump_lut_state"],
+                process_handles["pump_lut_status"],
+                process_handles["lut_mode"],
+                process_handles["sweep_provenance"],
+            ],
+        )
+
+    return app
+
+
+def main():
+    app = build_app()
+    app.launch(server_port=7860, css=CSS, head=FONTS_HTML)
+
+
+if __name__ == "__main__":
+    main()

murphy_unified/engine_bridge.py

@@ -17,16 +17,20 @@ from typing import Any, Dict, Tuple
 
 import numpy as np
 
-# ── Ensure engines/ is on sys.path ──────────────────────────────────────────
-# HF Space layout: engines/ sits next to murphy_unified/
-_ENGINES_DIR = os.path.normpath(
-    os.path.join(os.path.dirname(__file__), os.pardir, "engines")
+# ── Ensure ode_reformulation is on sys.path ──────────────────────────────────
+# __file__ = .../CSH2/murphy-unified/murphy_unified/engine_bridge.py
+# Two parents up reaches CSH2/
+_ODE_DIR = os.path.normpath(
+    os.path.join(os.path.dirname(__file__), os.pardir, os.pardir,
+                 "cycle2mdot_acceleration", "ode_reformulation")
 )
-if _ENGINES_DIR not in sys.path:
-    sys.path.insert(0, _ENGINES_DIR)
+if _ODE_DIR not in sys.path:
+    sys.path.insert(0, _ODE_DIR)
 
-# _ACCEL_DIR used by Numba warmup to locate h2_ps_lut.npz
-_ACCEL_DIR = _ENGINES_DIR
+# Also add the parent of ode_reformulation so break_coolprop is importable
+_ACCEL_DIR = os.path.dirname(_ODE_DIR)
+if _ACCEL_DIR not in sys.path:
+    sys.path.insert(0, _ACCEL_DIR)
 
 # ── Euler engine (always available via cryosim) ──────────────────────────────
 from cryosim.engine.fast import ICV_open  # noqa: E402
@@ -84,8 +88,9 @@ def _numba_warmup():
     """Background warmup for Numba JIT functions.
 
     Warms up both break_coolprop.h2_props (used by Lightspeed and DP45) and
-    the DP45 compiled solver itself, so the first user-facing H2/general_ode
-    click doesn't pay the ~30–60s JIT compilation cost.
+    the DP45 compiled solver itself (solve_cycle_compiled). The DP45 warmup
+    runs a tiny cycle so the first user-facing H2/general_ode click doesn't
+    pay the ~30–60s JIT compilation cost.
     """
     global _warmup_ok
     try:
@@ -102,6 +107,8 @@ def _numba_warmup():
     finally:
         _warmup_event.set()
 
+    # Pre-compile DP45 kernel (does not gate _warmup_ok — Lightspeed must
+    # still be declared ready even if DP45 warmup fails)
     if _HAS_DP45:
         try:
             print("[engine_bridge] DP45 warmup starting...")

murphy_unified/engine_params.py

@@ -0,0 +1,76 @@
+"""Pack a flat Simulation-parameter dict into cycle_sim keyword arguments.
+
+Shared by `run_simulation` (Tab 1) and `_sim_point` (Tab 2 sweep) so both
+tabs always hand identical kwargs to `cycle_sim`. If either tab wants a
+swept/override value, it merges `{key: value}` into the input dict BEFORE
+calling this helper.
+
+The array ordering here MUST match what `murphy_unified/engine_bridge.py`
+and the underlying engines expect.  See `tabs/simulation.py` (pre-refactor)
+lines ~237-258 for the original packing.
+"""
+
+from __future__ import annotations
+
+
+def build_engine_kwargs(params: dict) -> dict:
+    """Convert a flat params dict into kwargs for ``cycle_sim``.
+
+    Parameters
+    ----------
+    params : dict
+        Flat dict keyed by `run_simulation` parameter names (see
+        `murphy_unified/sim_defaults.py::SIM_DEFAULTS`).
+
+    Returns
+    -------
+    dict with keys:
+        ``Pexit_barg``, ``speed_f``, ``Ptank_barg``, ``Psat_barg``,
+        ``ICVparam``, ``DCVparam``, ``pump_geom``, ``proc_param``,
+        ``flash_eff``, and optionally ``exit_param`` and ``n_cycles``.
+    """
+    ICVparam = [
+        params["icv_port"], params["icv_mass"], params["icv_travel"],
+        params["icv_dp_area"], params["icv_Fs"], params["icv_SC"],
+        params["icv_leakKv"], params["icv_comp_eff"], int(params["icv_npts"]),
+    ]
+    DCVparam = [
+        params["dcv_port"], params["dcv_mass"], params["dcv_travel"],
+        params["dcv_dp_area"], params["dcv_Fs"], params["dcv_SC"],
+        params["dcv_leakKv"], params["dcv_comp_eff"], int(params["dcv_npts"]),
+    ]
+    pump_geom = [
+        params["bore"], params["stroke"], params["hOD"], params["cLen"],
+        params["emH"], params["emS"], params["kvoid"], params["kH"],
+        params["Vfv"], params["vac"], params["cpm"], params["dvf"],
+    ]
+    proc_param = [
+        params["Tamb"], params["htc"], params["drive"], params["Fmult"],
+        params["KvBB"], params["Pbb"], params["fric"], params["Exp"],
+    ]
+
+    kw: dict = {
+        "Pexit_barg":  params["Pexit"],
+        "speed_f":     params["speed"],
+        "Ptank_barg":  params["Ptank"],
+        "Psat_barg":   params["Psat"],
+        "ICVparam":    ICVparam,
+        "DCVparam":    DCVparam,
+        "pump_geom":   pump_geom,
+        "proc_param":  proc_param,
+        "flash_eff":   params["flash_eff"],
+    }
+
+    fill = params.get("fill_type", "Fixed Pexit")
+    if fill == "CHSS Fill":
+        kw["exit_param"] = [1, params["vsnubber"], params["vchss"],
+                            params["aov140f"], params["rodia"]]
+    elif fill == "RO Vent":
+        kw["exit_param"] = [0, params["vsnubber"], 0,
+                            params["aov140f"], params["rodia"]]
+
+    n_cyc = int(params.get("num_cycles", 1) or 1)
+    if n_cyc > 1:
+        kw["n_cycles"] = n_cyc
+
+    return kw

murphy_unified/params_io.py

@@ -0,0 +1,81 @@
+"""CSV round-trip for Simulation-tab run parameters.
+
+Format
+------
+Two-column CSV (``key,value``) written with ``csv.writer`` (QUOTE_MINIMAL).
+One row per entry in :data:`murphy_unified.sim_defaults.SIM_DEFAULTS`.
+
+Encoding rules (documented in
+``docs/superpowers/specs/2026-04-14-sweep-sim-sync-and-export.md``):
+  * floats/ints → ``repr()`` then ``float()`` on read (bit-exact)
+  * strings    → as-is; csv.writer quotes automatically when needed
+  * lists[str] → ``|``-joined (e.g. ``Energy Balance|Chamber Density``)
+  * empty numeric → fall back to ``SIM_DEFAULTS[key]`` on read
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+
+from murphy_unified.sim_defaults import SIM_DEFAULTS
+
+
+_LIST_KEYS = {"extra_plots"}
+_STRING_KEYS = {"engine_name", "fluid", "fill_type"}
+
+
+def params_to_csv(params: dict) -> str:
+    """Serialize a params dict to CSV text."""
+    buf = io.StringIO()
+    writer = csv.writer(buf)
+    writer.writerow(["key", "value"])
+    for key in SIM_DEFAULTS:
+        if key not in params:
+            continue
+        val = params[key]
+        if key in _LIST_KEYS:
+            encoded = "|".join(val) if val else ""
+        elif key in _STRING_KEYS:
+            encoded = str(val)
+        else:
+            encoded = repr(val)
+        writer.writerow([key, encoded])
+    return buf.getvalue()
+
+
+def csv_to_params(csv_text: str) -> tuple[dict, list[str]]:
+    """Parse CSV text into a params dict.
+
+    Returns
+    -------
+    (params, skipped_keys)
+        ``params`` contains successfully-parsed entries; ``skipped_keys``
+        lists unknown keys so the UI can surface them.
+    """
+    reader = csv.reader(io.StringIO(csv_text))
+    rows = list(reader)
+    if not rows:
+        return {}, []
+    if rows[0] == ["key", "value"]:
+        rows = rows[1:]
+
+    parsed: dict = {}
+    skipped: list[str] = []
+    for row in rows:
+        if len(row) != 2:
+            continue
+        key, value = row
+        if key not in SIM_DEFAULTS:
+            skipped.append(key)
+            continue
+        if key in _LIST_KEYS:
+            parsed[key] = value.split("|") if value else []
+        elif key in _STRING_KEYS:
+            parsed[key] = value
+        else:
+            if value == "":
+                parsed[key] = SIM_DEFAULTS[key]
+            else:
+                parsed[key] = float(value)
+    return parsed, skipped

murphy_unified/process_sim/pump_lut.py

@@ -138,6 +138,85 @@ class PumpLUT:
 
         return cls(speeds, pressures, mdot_grid, temp_grid)
 
+    @classmethod
+    def from_sweep_grid(
+        cls,
+        x_vals: "np.ndarray",
+        y_vals: "np.ndarray",
+        z_mdot_kgpm: "np.ndarray",
+        z_temp_K: "np.ndarray",
+        axis_x: str,
+        axis_y: str,
+    ) -> "PumpLUT":
+        """Build a PumpLUT from a 2D sweep payload on (Pexit_barg, speed_f).
+
+        Handles unit conversions and axis normalization.
+
+        Parameters
+        ----------
+        x_vals, y_vals : np.ndarray
+            1D arrays of the sweep's X and Y axis values (in sweep-native units).
+        z_mdot_kgpm, z_temp_K : np.ndarray
+            2D grids of shape ``(len(y_vals), len(x_vals))`` — mass flow in
+            kg/min and peak chamber temperature in Kelvin.
+        axis_x, axis_y : str
+            Axis names; must be exactly the set {"Pexit_barg", "speed_f"}.
+
+        Returns
+        -------
+        PumpLUT
+            LUT with ``speeds`` as axis 0 (motor_pct ∈ [0, 100]) and
+            ``pressures`` as axis 1 (absolute bar).
+
+        Notes
+        -----
+        Conversions:
+          * speed_f [0, 1] → motor_pct [0, 100]  (× 100)
+          * Pexit_barg    → back_pressure_bar    (+ 1.01325)
+          * mdot_kgpm     → mdot_kgs             (÷ 60)
+          * Tc_peak_K     → T_discharge_K        (identity)
+        """
+        valid_pair = {"Pexit_barg", "speed_f"}
+        if {axis_x, axis_y} != valid_pair:
+            raise ValueError(
+                f"from_sweep_grid requires axes {valid_pair}; got "
+                f"{{'{axis_x}', '{axis_y}'}}"
+            )
+
+        import numpy as _np
+
+        # Normalize so `speed_vals` is along axis 0 and `pexit_vals` is axis 1.
+        # Convention: z arrays have shape (len(y_vals), len(x_vals)).
+        if axis_x == "speed_f":
+            # x=speed_f, y=Pexit_barg → z shape is (Npexit, Nspeed)
+            # Transpose to (Nspeed, Npexit) for PumpLUT orientation.
+            speed_vals = _np.asarray(x_vals, dtype=float)
+            pexit_vals = _np.asarray(y_vals, dtype=float)
+            mdot_sp = _np.asarray(z_mdot_kgpm, dtype=float).T    # (speeds, pressures)
+            temp_sp = _np.asarray(z_temp_K, dtype=float).T
+        else:
+            # axis_x == "Pexit_barg", axis_y == "speed_f"
+            # x=Pexit_barg, y=speed_f → z shape is (Nspeed, Npexit) — correct.
+            speed_vals = _np.asarray(y_vals, dtype=float)
+            pexit_vals = _np.asarray(x_vals, dtype=float)
+            mdot_sp = _np.asarray(z_mdot_kgpm, dtype=float)
+            temp_sp = _np.asarray(z_temp_K, dtype=float)
+
+        speeds = speed_vals * 100.0
+        pressures = pexit_vals + 1.01325
+        mdot_grid = mdot_sp / 60.0   # kg/min → kg/s
+        temp_grid = temp_sp           # identity
+
+        # Sort both axes ascending (PumpLUT/RegularGridInterpolator requires this).
+        s_order = _np.argsort(speeds)
+        p_order = _np.argsort(pressures)
+        speeds = speeds[s_order]
+        pressures = pressures[p_order]
+        mdot_grid = mdot_grid[s_order][:, p_order]
+        temp_grid = temp_grid[s_order][:, p_order]
+
+        return cls(speeds, pressures, mdot_grid, temp_grid)
+
     def lookup(self, speed_pct: float, P_back_bar: float) -> tuple[float, float]:
         """Return (mdot_kg_s, T_discharge_K) at given speed and backpressure."""
         s = float(np.clip(speed_pct, self.speeds[0], self.speeds[-1]))

murphy_unified/sim_defaults.py

@@ -0,0 +1,78 @@
+"""Single canonical source of Simulation-tab parameter defaults.
+
+All Simulation-tab widgets, the initial `sim_params_state`, and the CSV I/O
+key set derive from this dict. Keeping one source prevents drift between
+Simulation widget defaults, Sweep-tab defaults, and engine defaults.
+
+Keys match the `run_simulation` signature (murphy_unified/tabs/simulation.py).
+"""
+
+from __future__ import annotations
+
+SIM_DEFAULTS: dict = {
+    # ── Operating ─────────────────────────────────────────────────────
+    "engine_name": "Lightspeed",
+    "fluid":       "H2",
+    "Pexit":       350.0,
+    "speed":       0.65,
+    "Ptank":       7.0,
+    "Psat":        2.0,
+
+    # ── ICV (9) ───────────────────────────────────────────────────────
+    "icv_port":     20.5,
+    "icv_mass":     48.0,
+    "icv_travel":   5.0,
+    "icv_dp_area":  779.3,
+    "icv_Fs":       33.4,
+    "icv_SC":       3.75,
+    "icv_leakKv":   7.36e-5,
+    "icv_comp_eff": 1.0,
+    "icv_npts":     100,
+
+    # ── DCV (9) ───────────────────────────────────────────────────────
+    "dcv_port":     8.3,
+    "dcv_mass":     25.0,
+    "dcv_travel":   3.79,
+    "dcv_dp_area":  78.54,
+    "dcv_Fs":       7.8,
+    "dcv_SC":       1.053,
+    "dcv_leakKv":   2.6e-6,
+    "dcv_comp_eff": 0.8,
+    "dcv_npts":     200,
+
+    # ── Pump geometry (12) ────────────────────────────────────────────
+    "bore":   40.3,
+    "stroke": 60.0,
+    "hOD":    120.0,
+    "cLen":   300.0,
+    "emH":    0.8,
+    "emS":    0.8,
+    "kvoid":  0.026,
+    "kH":     15.0,
+    "Vfv":    37.0,
+    "vac":    760000.0,
+    "cpm":    500.0,
+    "dvf":    0.01,
+
+    # ── Process / losses (9) ──────────────────────────────────────────
+    "Tamb":      300.0,
+    "htc":       10.0,
+    "drive":     4.0,
+    "Fmult":     30.0,
+    "KvBB":      0.006,
+    "Pbb":       0.0,
+    "fric":      0.5,
+    "Exp":       0.2,
+    "flash_eff": 0.02,
+
+    # ── Downstream / fill (6) ─────────────────────────────────────────
+    "fill_type":  "Fixed Pexit",
+    "num_cycles": 1,
+    "vsnubber":   5.0,
+    "vchss":      50.0,
+    "aov140f":    1.0,
+    "rodia":      0.94,
+
+    # ── Output selector ───────────────────────────────────────────────
+    "extra_plots": ["Energy Balance"],
+}

murphy_unified/sweep_cache.py

@@ -8,15 +8,26 @@ import sqlite3
 from typing import Any, Dict, Optional, Tuple
 
 
+SCHEMA_VERSION = 3
+
+
 class SweepCache:
     """Stores simulation scalar results in a local SQLite database.
 
     Keys are derived from a SHA256 hash of the canonicalised parameter dict,
     so identical runs are served from cache instead of re-simulated.
+
+    Schema is versioned via ``PRAGMA user_version``. On open, if the stored
+    version differs from ``SCHEMA_VERSION``, all rows are dropped and the
+    version is written.
     """
 
     def __init__(self, db_path: str = "sweep_cache.db") -> None:
-        self._conn = sqlite3.connect(db_path)
+        # check_same_thread=False: Gradio serves requests from a worker pool,
+        # so the same SweepCache instance is used across threads. Access is
+        # serialized at the Python level by SQLite's own locking, so cross-
+        # thread use is safe in practice.
+        self._conn = sqlite3.connect(db_path, check_same_thread=False)
         self._conn.execute("PRAGMA journal_mode=WAL")
         self._conn.execute(
             "CREATE TABLE IF NOT EXISTS cache ("
@@ -26,10 +37,19 @@ class SweepCache:
             "  ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
             ")"
         )
+        self._migrate_if_needed()
         self._conn.commit()
         self._session_hits = 0
         self._session_misses = 0
 
+    def _migrate_if_needed(self) -> None:
+        """If stored schema version != SCHEMA_VERSION, drop all rows."""
+        cur = self._conn.execute("PRAGMA user_version")
+        current = cur.fetchone()[0]
+        if current != SCHEMA_VERSION:
+            self._conn.execute("DELETE FROM cache")
+            self._conn.execute(f"PRAGMA user_version = {SCHEMA_VERSION}")
+
     # ------------------------------------------------------------------
     # Internal helpers
     # ------------------------------------------------------------------

murphy_unified/tabs/design_agent.py

@@ -103,7 +103,7 @@ def _end_session():
 def _load_session_history():
     records = list_design_records(DESIGN_RECORDS_DIR)
     choices = [r["slug"] for r in records]
-    return gr.Dropdown(choices=choices, value=choices[0] if choices else None)
+    return gr.update(choices=choices, value=choices[0] if choices else None)
 
 
 def _load_record(slug):

murphy_unified/tabs/optimizer.py

@@ -0,0 +1,176 @@
+"""Tab 3 -- Constraint-aware hardware optimizer via cryosim.
+
+Builds all Gradio components (left control panel + right results panel)
+and wires up the click handler.  Must be called inside an active
+``gr.TabItem`` context.
+"""
+
+from __future__ import annotations
+
+import traceback
+
+import gradio as gr
+import pandas as pd
+
+import cryosim
+from cryosim.calibration.params import PARAM_NAMES, get_nominal_values
+from murphy_unified.theme import metric_html, TRACE_COLORS, ACCENT, TEXT_DIM, engine_banner
+
+
+# -- Click handler -----------------------------------------------------------
+
+def run_optimize(
+    hardware: str,
+    target: str,
+    Pexit: float,
+    speed: float,
+    maxiter: float,
+    c_metric: str,
+    c_op: str,
+    c_val: float,
+):
+    """Run constrained optimisation and return (metrics_html, table_df)."""
+
+    try:
+        # Build constraints dict
+        constraints: dict[str, str] = {}
+        if c_metric:
+            constraints[c_metric] = f"{c_op}{c_val}"
+
+        # Baseline prediction
+        baseline = cryosim.predict(hardware=hardware, Pexit=Pexit, speed=speed)
+
+        # Optimise
+        opt = cryosim.optimize(
+            hardware=hardware,
+            target=target,
+            speed=speed,
+            Pexit=Pexit,
+            constraints=constraints,
+            maxiter=int(maxiter),
+        )
+
+        # Parameter comparison table
+        nominal = get_nominal_values(hardware)
+        rows = []
+        for name, nom, opt_val in zip(PARAM_NAMES, nominal, opt.optimal_values):
+            pct = (opt_val / nom - 1) * 100 if abs(nom) > 1e-12 else 0
+            rows.append({
+                "Parameter": name,
+                "Nominal": f"{nom:.6f}",
+                "Optimized": f"{opt_val:.6f}",
+                "Change %": f"{pct:+.1f}%",
+            })
+        table_df = pd.DataFrame(rows)
+
+        # Metric cards
+        status_accent = "green" if opt.constraints_satisfied else "red"
+        baseline_val = getattr(baseline, "mdot_kgpm", 0) if "mdot" in target else 0
+        opt_val_scalar = opt.target_value
+        improvement = (
+            ((opt_val_scalar / baseline_val - 1) * 100)
+            if baseline_val != 0
+            else 0
+        )
+
+        metrics = (
+            '<div class="metric-row">'
+            + metric_html("BASELINE", f"{baseline_val:.4f}")
+            + metric_html("OPTIMIZED", f"{opt_val_scalar:.4f}", "", "green")
+            + metric_html(
+                "IMPROVEMENT",
+                f"{improvement:+.1f}",
+                "%",
+                "green" if improvement > 0 else "amber",
+            )
+            + metric_html(
+                "CONSTRAINTS",
+                "OK" if opt.constraints_satisfied else "VIOLATED",
+                "",
+                status_accent,
+            )
+            + "</div>"
+            + '<div class="metric-row">'
+            + metric_html("EVALUATIONS", f"{opt.n_evals}")
+            + metric_html("CONVERGED", "YES" if opt.converged else "NO")
+            + "</div>"
+        )
+
+        return metrics, table_df
+
+    except Exception:
+        err = traceback.format_exc()
+        err_html = (
+            f'<div style="color:#c94a4a;font-family:JetBrains Mono,monospace;'
+            f'font-size:12px;white-space:pre-wrap;">'
+            f"Optimizer failed:\n{err}</div>"
+        )
+        return err_html, pd.DataFrame()
+
+
+# -- Builder -----------------------------------------------------------------
+
+def build_optimizer_tab():
+    """Create all Gradio components for the Optimizer tab and wire events.
+
+    Must be called inside an active ``gr.TabItem(...)`` context manager.
+    """
+
+    with gr.Row():
+        # -- Left panel -- controls -------------------------------------------
+        with gr.Column(scale=1, min_width=280):
+            gr.HTML(engine_banner("ENGINE: EULER (optimizer default)"))
+
+            hw_dd = gr.Dropdown(
+                choices=["old_icv", "new_icv"],
+                value="old_icv",
+                label="Hardware Config",
+            )
+            tgt_dd = gr.Dropdown(
+                choices=["max_mdot", "max_mass_eff", "min_kWh", "min_Tc_peak"],
+                value="max_mdot",
+                label="Objective",
+            )
+            pexit_sl = gr.Slider(
+                minimum=50, maximum=900, value=500, step=10,
+                label="Exit Pressure [barg]",
+            )
+            speed_sl = gr.Slider(
+                minimum=0.1, maximum=1.0, value=0.65, step=0.05,
+                label="Speed Fraction",
+            )
+            maxiter_sl = gr.Slider(
+                minimum=3, maximum=50, value=10, step=1,
+                label="Max Iterations",
+            )
+
+            gr.Markdown("**Constraint (optional):**")
+
+            c_metric_dd = gr.Dropdown(
+                choices=["", "Tc_peak_K", "mass_eff", "kWh_extend", "pc_peak_barg"],
+                value="",
+                label="Metric",
+            )
+            c_op_dd = gr.Dropdown(
+                choices=["<", ">", "<=", ">="],
+                value="<",
+                label="Operator",
+            )
+            c_val_num = gr.Number(value=200, label="Threshold")
+
+            run_btn = gr.Button("OPTIMIZE", variant="primary")
+
+        # -- Right panel -- results -------------------------------------------
+        with gr.Column(scale=3):
+            metrics_out = gr.HTML(label="Metrics")
+            table_out = gr.Dataframe(label="Parameter Changes")
+
+    # -- Wire click event -----------------------------------------------------
+    run_btn.click(
+        fn=run_optimize,
+        inputs=[
+            hw_dd, tgt_dd, pexit_sl, speed_sl, maxiter_sl,
+            c_metric_dd, c_op_dd, c_val_num,
+        ],
+        outputs=[metrics_out, table_out],
+    )

murphy_unified/tabs/process_sim.py

@@ -28,6 +28,7 @@ from murphy_unified.process_sim.pump_lut import (
     _load_csv,
     _find_col,
     DATA_DIR,
+    GENERATED_DIR,
 )
 from murphy_unified.theme import (
     ACCENT,
@@ -485,10 +486,75 @@ def _run_generate_lut(engine, spd_min, spd_max, spd_step, prs_min, prs_max,
     return lut, lut.summary()
 
 
+# ── Sweep payload ingestion ─────────────────────────────────────────────────
+
+def _ingest_sweep_payload(payload):
+    """Build a PumpLUT from a sweep bridge payload; save CSV; return UI updates.
+
+    Returns
+    -------
+    (PumpLUT, status_str, lut_mode_update, provenance_str)
+    """
+    if payload is None:
+        raise gr.Error(
+            "No compatible sweep data — run a 2D sweep on "
+            "Pexit_barg vs speed_f first."
+        )
+
+    lut = PumpLUT.from_sweep_grid(
+        x_vals=payload["x_vals"],
+        y_vals=payload["y_vals"],
+        z_mdot_kgpm=payload["z_mdot_kgpm"],
+        z_temp_K=payload["z_temp_K"],
+        axis_x=payload["axis_x"],
+        axis_y=payload["axis_y"],
+    )
+
+    # Save CSV to data/generated/ with a unique timestamp.
+    import datetime as _dt
+    now = _dt.datetime.now()
+    ts = now.strftime("%Y-%m-%d_%H%M%S")
+    hw = payload.get("hw", "unknown")
+    GENERATED_DIR.mkdir(parents=True, exist_ok=True)
+    csv_path = GENERATED_DIR / f"lut_{ts}_sweep_{hw}.csv"
+    lut.save(str(csv_path))
+
+    # Status + provenance strings.
+    n_speeds = len(lut.speeds)
+    n_press = len(lut.pressures)
+    status = (
+        f"Loaded from sweep ({n_speeds}x{n_press}, hw={hw}, "
+        f"{payload.get('timestamp', '')})\n"
+        f"{lut.summary()}\n"
+        f"Saved: {csv_path.name}"
+    )
+    provenance = (
+        f"Source: 2D sweep (axes: Pexit_barg x speed_f)\n"
+        f"Grid: {n_speeds} speeds x {n_press} pressures\n"
+        f"Hardware: {hw}\n"
+        f"Timestamp: {payload.get('timestamp', '')}\n"
+        f"Saved to: {csv_path.name}"
+    )
+    mode_update = gr.update(value="From Sweep")
+
+    return lut, status, mode_update, provenance
+
+
 # ── Tab builder ──────────────────────────────────────────────────────────────
 
 def build_process_sim_tab():
-    """Build the Process Sim tab. Must be called inside a gr.TabItem context."""
+    """Build the Process Sim tab. Must be called inside a gr.TabItem context.
+
+    Returns
+    -------
+    dict
+        Handles used by app.py to wire cross-tab events:
+          * ``pump_lut_state``
+          * ``pump_lut_status``
+          * ``lut_mode``
+          * ``sweep_provenance``
+          * ``ingest_fn`` (callable: bridge payload → (lut, status, mode_update, provenance))
+    """
 
     pump_lut_state = gr.State(None)
     results_state = gr.State(None)
@@ -500,7 +566,7 @@ def build_process_sim_tab():
         with gr.Column(scale=1):
             with gr.Accordion("LUT Source", open=True):
                 lut_mode = gr.Radio(
-                    choices=["Upload CSV", "Auto-Generate from Engine"],
+                    choices=["Upload CSV", "Auto-Generate from Engine", "From Sweep"],
                     value="Upload CSV",
                     label="Pump LUT Source",
                 )
@@ -536,6 +602,15 @@ def build_process_sim_tab():
                         prs_max = gr.Number(label="Pressure max (bar)", value=900)
                         prs_step = gr.Number(label="Pressure step (bar)", value=50)
 
+                # From-sweep mode (read-only provenance panel)
+                with gr.Group(visible=False) as sweep_group:
+                    sweep_provenance = gr.Textbox(
+                        label="Sweep provenance",
+                        value="No sweep data ingested yet. Run a 2D sweep on "
+                              "(Pexit_barg, speed_f) and click 'Send to Process Sim'.",
+                        interactive=False, lines=5,
+                    )
+
             sim_mode_radio = gr.Radio(
                 choices=SIM_MODES,
                 value=SIM_MODE_VALVE,
@@ -613,12 +688,13 @@ def build_process_sim_tab():
         return (
             gr.update(visible=(mode == "Upload CSV")),
             gr.update(visible=(mode == "Auto-Generate from Engine")),
+            gr.update(visible=(mode == "From Sweep")),
         )
 
     lut_mode.change(
         fn=_toggle_lut_mode,
         inputs=[lut_mode],
-        outputs=[csv_group, gen_group],
+        outputs=[csv_group, gen_group, sweep_group],
         api_name=False,
     )
 
@@ -686,3 +762,11 @@ def build_process_sim_tab():
     auto_btn.click(fn=_auto_analyze, inputs=auto_inputs, outputs=[chatbot, chat_input], api_name=False)
 
     clear_chat_btn.click(fn=lambda: ([], ""), inputs=[], outputs=[chatbot, chat_input], api_name=False)
+
+    return {
+        "pump_lut_state": pump_lut_state,
+        "pump_lut_status": pump_lut_status,
+        "lut_mode": lut_mode,
+        "sweep_provenance": sweep_provenance,
+        "ingest_fn": _ingest_sweep_payload,
+    }

murphy_unified/tabs/sensitivity.py

@@ -0,0 +1,112 @@
+"""Tab 4 -- Parameter sensitivity tornado chart via cryosim.
+
+Builds all Gradio components (left control panel + right results panel)
+and wires up the click handler.  Must be called inside an active
+``gr.TabItem`` context.
+"""
+
+from __future__ import annotations
+
+import traceback
+
+import gradio as gr
+import plotly.graph_objects as go
+
+import cryosim
+from murphy_unified.theme import metric_html, TRACE_COLORS, ACCENT, TEXT_DIM, FONT_MONO, engine_banner
+
+
+# -- Click handler -----------------------------------------------------------
+
+def run_sensitivity(hardware: str, Pexit: float, speed: float):
+    """Run sensitivity analysis and return (metrics_html, tornado_fig)."""
+
+    try:
+        s = cryosim.sensitivity(hardware=hardware, speed=speed, Pexit=Pexit)
+
+        ranked = s.rankings["mdot_kgpm"]
+        params = [p for p, _ in ranked]
+        vals = [v for _, v in ranked]
+
+        colors = [TRACE_COLORS[1] if v >= 0 else TRACE_COLORS[3] for v in vals]
+
+        fig = go.Figure(go.Bar(
+            y=params,
+            x=vals,
+            orientation="h",
+            marker_color=colors,
+            text=[f"{v:+.3f}" for v in vals],
+            textposition="outside",
+            textfont=dict(family=FONT_MONO, size=11),
+        ))
+        fig.update_layout(
+            title=f"Sensitivity: mdot @ {Pexit:.0f} barg (% metric / % param)",
+            xaxis_title="Normalized Sensitivity",
+            height=350,
+            yaxis=dict(tickfont=dict(family=FONT_MONO, size=11)),
+            margin=dict(l=120),
+        )
+
+        top = ranked[0]
+        metrics = (
+            '<div class="metric-row">'
+            + metric_html("TOP PARAMETER", top[0], "", "amber")
+            + metric_html("SENSITIVITY", f"{top[1]:+.3f}", "norm")
+            + metric_html("METRIC", "mdot_kgpm")
+            + "</div>"
+        )
+
+        return metrics, fig
+
+    except Exception:
+        err = traceback.format_exc()
+        err_html = (
+            f'<div style="color:#c94a4a;font-family:JetBrains Mono,monospace;'
+            f'font-size:12px;white-space:pre-wrap;">'
+            f"Sensitivity analysis failed:\n{err}</div>"
+        )
+        empty_fig = go.Figure()
+        empty_fig.update_layout(height=350)
+        return err_html, empty_fig
+
+
+# -- Builder -----------------------------------------------------------------
+
+def build_sensitivity_tab():
+    """Create all Gradio components for the Sensitivity tab and wire events.
+
+    Must be called inside an active ``gr.TabItem(...)`` context manager.
+    """
+
+    with gr.Row():
+        # -- Left panel -- controls -------------------------------------------
+        with gr.Column(scale=1, min_width=280):
+            gr.HTML(engine_banner("ENGINE: EULER"))
+
+            hw_dd = gr.Dropdown(
+                choices=["old_icv", "new_icv"],
+                value="old_icv",
+                label="Hardware Config",
+            )
+            pexit_sl = gr.Slider(
+                minimum=50, maximum=900, value=500, step=10,
+                label="Exit Pressure [barg]",
+            )
+            speed_sl = gr.Slider(
+                minimum=0.1, maximum=1.0, value=0.65, step=0.05,
+                label="Speed Fraction",
+            )
+
+            run_btn = gr.Button("ANALYZE", variant="primary")
+
+        # -- Right panel -- results -------------------------------------------
+        with gr.Column(scale=3):
+            metrics_out = gr.HTML(label="Metrics")
+            plot_out = gr.Plot(label="Tornado Chart")
+
+    # -- Wire click event -----------------------------------------------------
+    run_btn.click(
+        fn=run_sensitivity,
+        inputs=[hw_dd, pexit_sl, speed_sl],
+        outputs=[metrics_out, plot_out],
+    )

murphy_unified/tabs/simulation.py

@@ -15,7 +15,10 @@ Parameter surface mirrors the original DR MURPHY dashboard:
 
 from __future__ import annotations
 
+import os
+import tempfile
 import traceback
+from datetime import datetime, timezone
 
 import gradio as gr
 import numpy as np
@@ -23,6 +26,9 @@ import plotly.graph_objects as go
 
 from murphy_unified.engine_bridge import cycle_sim, ENGINES
 from murphy_unified.diagnostics import evaluate
+from murphy_unified.engine_params import build_engine_kwargs
+from murphy_unified.params_io import params_to_csv, csv_to_params
+from murphy_unified.sim_defaults import SIM_DEFAULTS
 from murphy_unified.theme import (
     metric_html, TRACE_COLORS, TEXT_DIM, TEXT_BRIGHT, ACCENT, ACCENT2, WARN, DANGER,
     FONT_MONO, VALVE_ICV, VALVE_DCV, ENERGY_POS, ENERGY_NEG, TEXT,
@@ -38,25 +44,6 @@ _ENGINE_MAP = {
 _FLUID_MAP = {"H2": "h2", "N2": "n2"}
 
 
-# ── MVP 1.0 Simplex defaults (ported from scenario_gui.py) ──────────────────
-# ICV: [port, mass, travel, dp_area, Fs, SC, leakKv, comp_eff, npts]
-D_ICV = dict(port=20.5, mass=48.0, travel=5.0, dp_area=779.3,
-             Fs=33.4, SC=3.75, leakKv=0.0000736, comp_eff=1.0, npts=100)
-
-# DCV: same order
-D_DCV = dict(port=8.3, mass=25.0, travel=3.79, dp_area=78.54,
-             Fs=7.8, SC=1.053, leakKv=0.0000026, comp_eff=0.8, npts=200)
-
-# Pump: [bore, stroke, hOD, cLen, emH, emS, kvoid, kH, Vfv, vac, cpm, dvf]
-D_PUMP = dict(bore=40.3, stroke=60.0, hOD=120.0, cLen=300.0,
-              emH=0.8, emS=0.8, kvoid=0.026, kH=15.0,
-              Vfv=37.0, vac=760000.0, cpm=500.0, dvf=0.01)
-
-# Proc: [Tamb, htc_amb, net_drive, F_mult, Kv_BB, Pbb_exit, fric2chamber, Exp_eff]
-D_PROC = dict(Tamb=300.0, htc=10.0, drive=4.0, Fmult=30.0,
-              KvBB=0.006, Pbb=0.0, fric=0.5, Exp=0.2)
-
-
 # ── Extra plot definitions ──────────────────────────────────────────────────
 # Each entry: (hist_key, y-axis label, trace color index)
 # "Energy Balance" is a special case (bar chart, not time-series).
@@ -230,32 +217,33 @@ def run_simulation(
 ):
     """Run one pump cycle with the full parameter set and return plots + diagnostics."""
 
+    # ── Snapshot submitted params BEFORE the engine call so sim_params_state
+    #    reflects user inputs even if cycle_sim raises.
+    sim_state: dict = {
+        "engine_name": engine_name, "fluid": fluid,
+        "Pexit": Pexit, "speed": speed, "Ptank": Ptank, "Psat": Psat,
+        "icv_port": icv_port, "icv_mass": icv_mass, "icv_travel": icv_travel,
+        "icv_dp_area": icv_dp_area, "icv_Fs": icv_Fs, "icv_SC": icv_SC,
+        "icv_leakKv": icv_leakKv, "icv_comp_eff": icv_comp_eff, "icv_npts": icv_npts,
+        "dcv_port": dcv_port, "dcv_mass": dcv_mass, "dcv_travel": dcv_travel,
+        "dcv_dp_area": dcv_dp_area, "dcv_Fs": dcv_Fs, "dcv_SC": dcv_SC,
+        "dcv_leakKv": dcv_leakKv, "dcv_comp_eff": dcv_comp_eff, "dcv_npts": dcv_npts,
+        "bore": bore, "stroke": stroke, "hOD": hOD, "cLen": cLen,
+        "emH": emH, "emS": emS, "kvoid": kvoid, "kH": kH,
+        "Vfv": Vfv, "vac": vac, "cpm": cpm, "dvf": dvf,
+        "Tamb": Tamb, "htc": htc, "drive": drive, "Fmult": Fmult,
+        "KvBB": KvBB, "Pbb": Pbb, "fric": fric, "Exp": Exp, "flash_eff": flash_eff,
+        "fill_type": fill_type, "num_cycles": num_cycles,
+        "vsnubber": vsnubber, "vchss": vchss, "aov140f": aov140f, "rodia": rodia,
+        "extra_plots": list(extra_plots or []),
+        "_written_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "_engine_ok": True,
+    }
+
     engine_id = _ENGINE_MAP.get(engine_name, "euler")
     fluid_id = _FLUID_MAP.get(fluid, "h2")
 
-    # ── Build parameter arrays ───────────────────────────────────────────
-    ICVparam = [icv_port, icv_mass, icv_travel, icv_dp_area,
-                icv_Fs, icv_SC, icv_leakKv, icv_comp_eff, int(icv_npts)]
-    DCVparam = [dcv_port, dcv_mass, dcv_travel, dcv_dp_area,
-                dcv_Fs, dcv_SC, dcv_leakKv, dcv_comp_eff, int(dcv_npts)]
-    pump_geom = [bore, stroke, hOD, cLen, emH, emS, kvoid, kH,
-                 Vfv, vac, cpm, dvf]
-    proc_param = [Tamb, htc, drive, Fmult, KvBB, Pbb, fric, Exp]
-
-    # ── Build exit_param if downstream mode is selected ──────────────────
-    # [mode, snubber_L, chss_L, aov140_frac, ro_dia_mm]  — mode: 1=CHSS, 0=RO
-    exit_param = None
-    if fill_type == "CHSS Fill":
-        exit_param = [1, vsnubber, vchss, aov140f, rodia]
-    elif fill_type == "RO Vent":
-        exit_param = [0, vsnubber, 0, aov140f, rodia]
-
-    extra_kwargs: dict = {}
-    if exit_param is not None:
-        extra_kwargs["exit_param"] = exit_param
     n_cyc = int(num_cycles) if num_cycles else 1
-    if n_cyc > 1:
-        extra_kwargs["n_cycles"] = n_cyc
 
     # ── Parameter summary (shown above plots on every run) ──────────────
     params_html = _build_params_summary_html(
@@ -267,22 +255,10 @@ def run_simulation(
         fill_type, vsnubber, vchss, aov140f, rodia, n_cyc,
     )
 
-    # ── Call engine bridge ───────────────────────────────────────────────
+    # ── Call engine bridge via shared helper ─────────────────────────────
+    engine_kwargs = build_engine_kwargs(sim_state)
     try:
-        out, hist = cycle_sim(
-            engine=engine_id,
-            fluid=fluid_id,
-            Pexit_barg=Pexit,
-            speed_f=speed,
-            Ptank_barg=Ptank,
-            Psat_barg=Psat,
-            ICVparam=ICVparam,
-            DCVparam=DCVparam,
-            pump_geom=pump_geom,
-            proc_param=proc_param,
-            flash_eff=flash_eff,
-            **extra_kwargs,
-        )
+        out, hist = cycle_sim(engine=engine_id, fluid=fluid_id, **engine_kwargs)
     except Exception:
         err = traceback.format_exc()
         err_html = (
@@ -291,7 +267,8 @@ def run_simulation(
             f'Simulation failed:\n{err}</div>'
         )
         ef = _empty_fig()
-        return err_html, params_html, ef, ef, ef, ef, err_html
+        sim_state["_engine_ok"] = False
+        return err_html, params_html, ef, ef, ef, ef, err_html, sim_state
 
     # ── Extract scalars (prefer hist dict) ───────────────────────────────
     mdot = hist.get("mdot_kgpm", 0.0)
@@ -455,12 +432,62 @@ def run_simulation(
     status_html = f'<div class="status-bar">{" | ".join(parts)}</div>'
 
     return (metrics_html, params_html, fig_pt, fig_valves,
-            extra_figs[0], extra_figs[1], status_html)
+            extra_figs[0], extra_figs[1], status_html, sim_state)
 
 
 # ── Builder ──────────────────────────────────────────────────────────────────
 
-def build_simulation_tab():
+_WIDGET_KEYS_IN_ORDER = (
+    "engine_name", "fluid", "Pexit", "speed", "Ptank", "Psat",
+    "icv_port", "icv_mass", "icv_travel", "icv_dp_area",
+    "icv_Fs", "icv_SC", "icv_leakKv", "icv_comp_eff", "icv_npts",
+    "dcv_port", "dcv_mass", "dcv_travel", "dcv_dp_area",
+    "dcv_Fs", "dcv_SC", "dcv_leakKv", "dcv_comp_eff", "dcv_npts",
+    "bore", "stroke", "hOD", "cLen", "emH", "emS", "kvoid", "kH",
+    "Vfv", "vac", "cpm", "dvf",
+    "Tamb", "htc", "drive", "Fmult", "KvBB", "Pbb", "fric", "Exp", "flash_eff",
+    "fill_type", "num_cycles", "vsnubber", "vchss", "aov140f", "rodia",
+    "extra_plots",
+)
+
+
+def _export_params(*widget_values) -> str:
+    """Write current widget state to a tempfile CSV; return path for gr.File."""
+    state = dict(zip(_WIDGET_KEYS_IN_ORDER, widget_values))
+    state["extra_plots"] = list(state.get("extra_plots") or [])
+    csv_text = params_to_csv(state)
+    stamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
+    path = os.path.join(tempfile.gettempdir(), f"murphy_run_{stamp}.csv")
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        f.write(csv_text)
+    return path
+
+
+def _import_params(file_obj):
+    """Load a CSV and return widget updates in _WIDGET_KEYS_IN_ORDER + info HTML."""
+    if file_obj is None:
+        return (*([gr.update()] * len(_WIDGET_KEYS_IN_ORDER)), "")
+    path = file_obj if isinstance(file_obj, str) else file_obj.name
+    with open(path, "r", encoding="utf-8") as f:
+        csv_text = f.read()
+    parsed, skipped = csv_to_params(csv_text)
+
+    updates = tuple(
+        gr.update(value=parsed[key]) if key in parsed else gr.update()
+        for key in _WIDGET_KEYS_IN_ORDER
+    )
+    loaded = len(parsed)
+    total = len(SIM_DEFAULTS)
+    skipped_msg = f" Skipped: {', '.join(skipped)}" if skipped else ""
+    info_html = (
+        f'<div style="font-family:JetBrains Mono,monospace;font-size:11px;'
+        f'color:{TEXT_DIM};padding:4px 0;">'
+        f'Loaded {loaded}/{total} params.{skipped_msg}</div>'
+    )
+    return (*updates, info_html)
+
+
+def build_simulation_tab(sim_params_state: gr.State):
     """Create all Gradio components for the Simulation tab and wire events.
 
     Must be called inside an active ``gr.TabItem(...)`` context manager.
@@ -473,119 +500,129 @@ def build_simulation_tab():
             # ── Operating conditions (always visible) ───────────────────
             engine_dd = gr.Dropdown(
                 choices=["Euler", "Lightspeed", "General-ODE"],
-                value="Lightspeed",
+                value=SIM_DEFAULTS["engine_name"],
                 label="Engine",
             )
             fluid_dd = gr.Dropdown(
                 choices=["H2", "N2"],
-                value="H2",
+                value=SIM_DEFAULTS["fluid"],
                 label="Fluid",
             )
             pexit_sl = gr.Slider(
-                minimum=50, maximum=1100, value=350, step=10,
+                minimum=50, maximum=1100, value=SIM_DEFAULTS["Pexit"], step=10,
                 label="Exit Pressure [barg]",
             )
             speed_sl = gr.Slider(
-                minimum=0.1, maximum=1.0, value=0.65, step=0.05,
+                minimum=0.1, maximum=1.0, value=SIM_DEFAULTS["speed"], step=0.05,
                 label="Speed Fraction",
             )
             with gr.Row():
-                ptank_num = gr.Number(value=7.0, label="Tank P [barg]", step=0.1)
-                psat_num = gr.Number(value=2.0, label="Sat P [barg]", step=0.1)
+                ptank_num = gr.Number(value=SIM_DEFAULTS["Ptank"], label="Tank P [barg]", step=0.1)
+                psat_num = gr.Number(value=SIM_DEFAULTS["Psat"], label="Sat P [barg]", step=0.1)
 
             run_btn = gr.Button("RUN CYCLE", variant="primary")
 
+            # ── Save / Load run params ──────────────────────────────────
+            with gr.Row():
+                save_btn = gr.DownloadButton("Save params to CSV")
+                load_file = gr.File(
+                    label="Load params from CSV",
+                    file_types=[".csv"],
+                    type="filepath",
+                )
+            load_info_html = gr.HTML()
+
             # ── ICV Parameters ──────────────────────────────────────────
             with gr.Accordion("ICV Parameters", open=False):
                 with gr.Row():
-                    icv_port   = gr.Number(value=D_ICV['port'],    label="Port Dia (mm)", step=0.1)
-                    icv_mass   = gr.Number(value=D_ICV['mass'],    label="Mass (g)",       step=0.1)
-                    icv_travel = gr.Number(value=D_ICV['travel'],  label="Travel (mm)",    step=0.1)
+                    icv_port   = gr.Number(value=SIM_DEFAULTS['icv_port'],    label="Port Dia (mm)", step=0.1)
+                    icv_mass   = gr.Number(value=SIM_DEFAULTS['icv_mass'],    label="Mass (g)",       step=0.1)
+                    icv_travel = gr.Number(value=SIM_DEFAULTS['icv_travel'],  label="Travel (mm)",    step=0.1)
                 with gr.Row():
-                    icv_dparea = gr.Number(value=D_ICV['dp_area'], label="dP Area (mm²)",  step=0.1)
-                    icv_Fs     = gr.Number(value=D_ICV['Fs'],      label="Spring F (N)",   step=0.1)
-                    icv_SC     = gr.Number(value=D_ICV['SC'],      label="Spring K (N/mm)", step=0.01)
+                    icv_dparea = gr.Number(value=SIM_DEFAULTS['icv_dp_area'], label="dP Area (mm²)",  step=0.1)
+                    icv_Fs     = gr.Number(value=SIM_DEFAULTS['icv_Fs'],      label="Spring F (N)",   step=0.1)
+                    icv_SC     = gr.Number(value=SIM_DEFAULTS['icv_SC'],      label="Spring K (N/mm)", step=0.01)
                 with gr.Row():
-                    icv_leak   = gr.Number(value=D_ICV['leakKv'],   label="Leak Kv (m³/hr)", step=1e-7)
-                    icv_ceff   = gr.Number(value=D_ICV['comp_eff'], label="Comp Eff",         step=0.01)
-                    icv_npts   = gr.Number(value=D_ICV['npts'],     label="Npts",             step=1, precision=0)
+                    icv_leak   = gr.Number(value=SIM_DEFAULTS['icv_leakKv'],   label="Leak Kv (m³/hr)", step=1e-7)
+                    icv_ceff   = gr.Number(value=SIM_DEFAULTS['icv_comp_eff'], label="Comp Eff",         step=0.01)
+                    icv_npts   = gr.Number(value=SIM_DEFAULTS['icv_npts'],     label="Npts",             step=1, precision=0)
 
             # ── DCV Parameters ──────────────────────────────────────────
             with gr.Accordion("DCV Parameters", open=False):
                 with gr.Row():
-                    dcv_port   = gr.Number(value=D_DCV['port'],    label="Port Dia (mm)", step=0.1)
-                    dcv_mass   = gr.Number(value=D_DCV['mass'],    label="Mass (g)",       step=0.1)
-                    dcv_travel = gr.Number(value=D_DCV['travel'],  label="Travel (mm)",    step=0.01)
+                    dcv_port   = gr.Number(value=SIM_DEFAULTS['dcv_port'],    label="Port Dia (mm)", step=0.1)
+                    dcv_mass   = gr.Number(value=SIM_DEFAULTS['dcv_mass'],    label="Mass (g)",       step=0.1)
+                    dcv_travel = gr.Number(value=SIM_DEFAULTS['dcv_travel'],  label="Travel (mm)",    step=0.01)
                 with gr.Row():
-                    dcv_dparea = gr.Number(value=D_DCV['dp_area'], label="dP Area (mm²)",  step=0.01)
-                    dcv_Fs     = gr.Number(value=D_DCV['Fs'],      label="Spring F (N)",   step=0.1)
-                    dcv_SC     = gr.Number(value=D_DCV['SC'],      label="Spring K (N/mm)", step=0.001)
+                    dcv_dparea = gr.Number(value=SIM_DEFAULTS['dcv_dp_area'], label="dP Area (mm²)",  step=0.01)
+                    dcv_Fs     = gr.Number(value=SIM_DEFAULTS['dcv_Fs'],      label="Spring F (N)",   step=0.1)
+                    dcv_SC     = gr.Number(value=SIM_DEFAULTS['dcv_SC'],      label="Spring K (N/mm)", step=0.001)
                 with gr.Row():
-                    dcv_leak   = gr.Number(value=D_DCV['leakKv'],   label="Leak Kv (m³/hr)", step=1e-7)
-                    dcv_ceff   = gr.Number(value=D_DCV['comp_eff'], label="Comp Eff",         step=0.01)
-                    dcv_npts   = gr.Number(value=D_DCV['npts'],     label="Npts",             step=1, precision=0)
+                    dcv_leak   = gr.Number(value=SIM_DEFAULTS['dcv_leakKv'],   label="Leak Kv (m³/hr)", step=1e-7)
+                    dcv_ceff   = gr.Number(value=SIM_DEFAULTS['dcv_comp_eff'], label="Comp Eff",         step=0.01)
+                    dcv_npts   = gr.Number(value=SIM_DEFAULTS['dcv_npts'],     label="Npts",             step=1, precision=0)
 
             # ── Pump Geometry ───────────────────────────────────────────
             with gr.Accordion("Pump Geometry", open=False):
                 with gr.Row():
-                    bore   = gr.Number(value=D_PUMP['bore'],   label="Bore (mm)",   step=0.1)
-                    stroke = gr.Number(value=D_PUMP['stroke'], label="Stroke (mm)", step=0.1)
+                    bore   = gr.Number(value=SIM_DEFAULTS['bore'],   label="Bore (mm)",   step=0.1)
+                    stroke = gr.Number(value=SIM_DEFAULTS['stroke'], label="Stroke (mm)", step=0.1)
                 with gr.Row():
-                    cpm    = gr.Number(value=D_PUMP['cpm'],    label="Speed (cpm)", step=1)
-                    dvf    = gr.Number(value=D_PUMP['dvf'],    label="Dead Vol Frac", step=0.001)
+                    cpm    = gr.Number(value=SIM_DEFAULTS['cpm'],    label="Speed (cpm)", step=1)
+                    dvf    = gr.Number(value=SIM_DEFAULTS['dvf'],    label="Dead Vol Frac", step=0.001)
                 with gr.Row():
-                    hOD    = gr.Number(value=D_PUMP['hOD'],    label="Housing OD (mm)",  step=1)
-                    cLen   = gr.Number(value=D_PUMP['cLen'],   label="Chamber Len (mm)", step=1)
+                    hOD    = gr.Number(value=SIM_DEFAULTS['hOD'],    label="Housing OD (mm)",  step=1)
+                    cLen   = gr.Number(value=SIM_DEFAULTS['cLen'],   label="Chamber Len (mm)", step=1)
                 with gr.Row():
-                    emH    = gr.Number(value=D_PUMP['emH'],    label="ε Housing", step=0.01)
-                    emS    = gr.Number(value=D_PUMP['emS'],    label="ε Shield",  step=0.01)
+                    emH    = gr.Number(value=SIM_DEFAULTS['emH'],    label="ε Housing", step=0.01)
+                    emS    = gr.Number(value=SIM_DEFAULTS['emS'],    label="ε Shield",  step=0.01)
                 with gr.Row():
-                    kvoid  = gr.Number(value=D_PUMP['kvoid'],  label="k void (W/m/K)",    step=0.001)
-                    kH     = gr.Number(value=D_PUMP['kH'],     label="k housing (W/m/K)", step=0.1)
+                    kvoid  = gr.Number(value=SIM_DEFAULTS['kvoid'],  label="k void (W/m/K)",    step=0.001)
+                    kH     = gr.Number(value=SIM_DEFAULTS['kH'],     label="k housing (W/m/K)", step=0.1)
                 with gr.Row():
-                    Vfv    = gr.Number(value=D_PUMP['Vfv'],    label="Void Vol Frac", step=0.1)
-                    vac    = gr.Number(value=D_PUMP['vac'],    label="Vacuum (µHg)",  step=1000)
+                    Vfv    = gr.Number(value=SIM_DEFAULTS['Vfv'],    label="Void Vol Frac", step=0.1)
+                    vac    = gr.Number(value=SIM_DEFAULTS['vac'],    label="Vacuum (µHg)",  step=1000)
 
             # ── Process / Losses ────────────────────────────────────────
             with gr.Accordion("Process / Losses", open=False):
                 with gr.Row():
-                    Tamb   = gr.Number(value=D_PROC['Tamb'],  label="T_amb (K)", step=1)
-                    htc    = gr.Number(value=D_PROC['htc'],   label="HTC (W/m²/K)", step=0.1)
+                    Tamb   = gr.Number(value=SIM_DEFAULTS['Tamb'],  label="T_amb (K)", step=1)
+                    htc    = gr.Number(value=SIM_DEFAULTS['htc'],   label="HTC (W/m²/K)", step=0.1)
                 with gr.Row():
-                    drive  = gr.Number(value=D_PROC['drive'], label="Drive (kgf)",  step=0.1)
-                    Fmult  = gr.Number(value=D_PROC['Fmult'], label="F Multiplier", step=1)
+                    drive  = gr.Number(value=SIM_DEFAULTS['drive'], label="Drive (kgf)",  step=0.1)
+                    Fmult  = gr.Number(value=SIM_DEFAULTS['Fmult'], label="F Multiplier", step=1)
                 with gr.Row():
-                    fric   = gr.Number(value=D_PROC['fric'],  label="Friction (0-1)",  step=0.01)
-                    KvBB   = gr.Number(value=D_PROC['KvBB'],  label="BB Kv (m³/hr)",   step=0.001)
+                    fric   = gr.Number(value=SIM_DEFAULTS['fric'],  label="Friction (0-1)",  step=0.01)
+                    KvBB   = gr.Number(value=SIM_DEFAULTS['KvBB'],  label="BB Kv (m³/hr)",   step=0.001)
                 with gr.Row():
-                    Pbb    = gr.Number(value=D_PROC['Pbb'],   label="BB Exit P (barg)", step=0.1)
-                    Exp    = gr.Number(value=D_PROC['Exp'],   label="Exp Eff (0-1)",    step=0.01)
-                flash_eff = gr.Number(value=0.02, label="Thermal Mass Eff (0-1)", step=0.01)
+                    Pbb    = gr.Number(value=SIM_DEFAULTS['Pbb'],   label="BB Exit P (barg)", step=0.1)
+                    Exp    = gr.Number(value=SIM_DEFAULTS['Exp'],   label="Exp Eff (0-1)",    step=0.01)
+                flash_eff = gr.Number(value=SIM_DEFAULTS["flash_eff"], label="Thermal Mass Eff (0-1)", step=0.01)
 
             # ── Downstream / Fill mode ──────────────────────────────────
             with gr.Accordion("Downstream / Fill Mode", open=False):
                 with gr.Row():
                     fill_type = gr.Dropdown(
                         choices=["Fixed Pexit", "CHSS Fill", "RO Vent"],
-                        value="Fixed Pexit", label="Fill Type",
+                        value=SIM_DEFAULTS["fill_type"], label="Fill Type",
                     )
                     num_cycles = gr.Number(
-                        value=1, label="No. cycles",
+                        value=SIM_DEFAULTS["num_cycles"], label="No. cycles",
                         step=1, minimum=1, maximum=50, precision=0,
                     )
                 with gr.Row():
-                    vsnubber = gr.Number(value=5.0,  label="Snubber (L)", step=0.1)
-                    vchss    = gr.Number(value=50.0, label="CHSS (L)",    step=1)
+                    vsnubber = gr.Number(value=SIM_DEFAULTS["vsnubber"], label="Snubber (L)", step=0.1)
+                    vchss    = gr.Number(value=SIM_DEFAULTS["vchss"], label="CHSS (L)",    step=1)
                 with gr.Row():
-                    aov140f  = gr.Number(value=1.0,  label="AOV140 (0-1)", step=0.01,
+                    aov140f  = gr.Number(value=SIM_DEFAULTS["aov140f"], label="AOV140 (0-1)", step=0.01,
                                          minimum=0, maximum=1)
-                    rodia    = gr.Number(value=0.94, label="RO Dia (mm)",  step=0.01)
+                    rodia    = gr.Number(value=SIM_DEFAULTS["rodia"], label="RO Dia (mm)",  step=0.01)
 
             # ── Extra plots selector ────────────────────────────────────
             gr.Markdown("**Additional plots** (select up to 2):")
             extras_cb = gr.CheckboxGroup(
                 choices=EXTRA_PLOT_CHOICES,
-                value=["Energy Balance"],
+                value=SIM_DEFAULTS["extra_plots"],
                 label="Extra Graphs",
             )
 
@@ -623,5 +660,31 @@ def build_simulation_tab():
             extras_cb,
         ],
         outputs=[metrics_out, params_out, fig_pt_out, fig_valves_out,
-                 fig_extra1_out, fig_extra2_out, status_out],
+                 fig_extra1_out, fig_extra2_out, status_out, sim_params_state],
+    )
+
+    # ── Widget list (order must match _WIDGET_KEYS_IN_ORDER) ─────────────
+    _all_widgets = [
+        engine_dd, fluid_dd, pexit_sl, speed_sl, ptank_num, psat_num,
+        icv_port, icv_mass, icv_travel, icv_dparea,
+        icv_Fs, icv_SC, icv_leak, icv_ceff, icv_npts,
+        dcv_port, dcv_mass, dcv_travel, dcv_dparea,
+        dcv_Fs, dcv_SC, dcv_leak, dcv_ceff, dcv_npts,
+        bore, stroke, hOD, cLen, emH, emS, kvoid, kH,
+        Vfv, vac, cpm, dvf,
+        Tamb, htc, drive, Fmult, KvBB, Pbb, fric, Exp, flash_eff,
+        fill_type, num_cycles, vsnubber, vchss, aov140f, rodia,
+        extras_cb,
+    ]
+
+    save_btn.click(
+        fn=_export_params,
+        inputs=_all_widgets,
+        outputs=[save_btn],
+    )
+
+    load_file.change(
+        fn=_import_params,
+        inputs=[load_file],
+        outputs=[*_all_widgets, load_info_html],
     )

murphy_unified/tabs/sweep.py

@@ -17,6 +17,8 @@ import pandas as pd
 import plotly.graph_objects as go
 
 from murphy_unified.engine_bridge import cycle_sim
+from murphy_unified.engine_params import build_engine_kwargs
+from murphy_unified.sim_defaults import SIM_DEFAULTS
 from murphy_unified.sweep_cache import SweepCache
 from murphy_unified.theme import (
     metric_html,
@@ -56,8 +58,10 @@ SWEEP_PARAMS = {
     "htc":          {"label": "Heat Transfer Coeff",    "min": 0.0,   "max": 100.0, "default": 10.0},
 }
 
-# ── Parameter-to-array mapping ────────────────────────────────────────────
-# Maps sweep param name → (array_name, index) or "direct" for top-level args.
+# ── Legacy parameter-to-array mapping ─────────────────────────────────────
+# Kept for compatibility with murphy_unified/tabs/comparison.py, which still
+# uses the old override-dict shape. New sweep flow goes through
+# build_engine_kwargs + _SWEEP_KEY_TO_SIM_KEY below.
 _PARAM_MAP = {
     "Pexit_barg":   ("direct", "Pexit_barg"),
     "speed_f":      ("direct", "speed_f"),
@@ -78,7 +82,6 @@ _PARAM_MAP = {
     "Exp_eff":      ("proc_param", 7),
 }
 
-# MVP 1.0 Simplex defaults (must match engine_bridge.py)
 _DEFAULTS = {
     "ICVparam":   [20.5, 48, 5, 779.3, 33.4, 3.75, 0.0000736, 1.0, 100],
     "DCVparam":   [8.3, 25, 3.79, 78.54, 7.8, 1.053, 0.0000026, 0.8, 200],
@@ -86,32 +89,43 @@ _DEFAULTS = {
     "proc_param": [300, 10, 4, 30, 0.006, 0, 0.5, 0.2],
 }
 
-# HuggingFace Space caps
-_IS_HF = bool(os.environ.get("HF_SPACE"))
-_MAX_N_1D = 15 if _IS_HF else 20
-_MAX_GRID_2D = 10 if _IS_HF else 15
-
-# Module-level cache (created lazily so import doesn't touch disk)
-_cache: SweepCache | None = None
-
 
-def _get_cache() -> SweepCache:
-    global _cache
-    if _cache is None:
-        _cache = SweepCache()
-    return _cache
+# ── Hardware presets ──────────────────────────────────────────────────────
+# Sourced from "ICV open sim-driver for ode package (2).xlsx" (orig vs new ICV).
+# Applied on top of sim_state in _sim_point when the user picks a preset;
+# "baseline" leaves sim_state unchanged.
+_HW_PRESETS: dict[str, dict] = {
+    "old_icv": {
+        "icv_port":     19.052559,
+        "icv_mass":     28.0,
+        "icv_travel":   8.0,
+        "icv_dp_area":  897.741517,
+        "icv_Fs":       34.2,
+        "icv_SC":       3.402,
+        "icv_leakKv":   0.00669,
+        "icv_comp_eff": 1.0,
+        "icv_npts":     200,
+    },
+    "new_icv": {
+        "icv_port":     20.5,
+        "icv_mass":     48.0,
+        "icv_travel":   5.0,
+        "icv_dp_area":  779.311328,
+        "icv_Fs":       33.4,
+        "icv_SC":       3.75,
+        "icv_leakKv":   0.000864,
+        "icv_comp_eff": 1.0,
+        "icv_npts":     200,
+    },
+}
 
 
 def _build_overrides(overrides: dict[str, float]) -> dict:
-    """Convert {param_name: value} into cycle_sim keyword overrides.
-
-    Returns a dict with keys like Pexit_barg, speed_f, flash_eff,
-    ICVparam, DCVparam, pump_geom, proc_param — only those that differ
-    from defaults.
-    """
+    """Legacy helper: convert {param_name: value} to cycle_sim kwargs using
+    engine defaults for unspecified parameters. Used only by comparison tab;
+    new sweep flow goes through build_engine_kwargs."""
     kw: dict = {}
     arrays: dict[str, list] = {}
-
     for name, val in overrides.items():
         mapping = _PARAM_MAP[name]
         if mapping[0] == "direct":
@@ -119,54 +133,114 @@ def _build_overrides(overrides: dict[str, float]) -> dict:
         else:
             arr_name, idx = mapping
             if arr_name not in arrays:
-                arrays[arr_name] = list(_DEFAULTS[arr_name])  # copy
+                arrays[arr_name] = list(_DEFAULTS[arr_name])
             arrays[arr_name][idx] = val
-
     kw.update(arrays)
     return kw
 
 
+# ── Sweep-key → SIM_DEFAULTS-key aliases ──────────────────────────────────
+# Sweep-tab parameter names differ in some places from SIM_DEFAULTS keys (which
+# match run_simulation signature). This table translates before applying.
+# Params not listed here (Pexit_barg, speed_f, flash_eff, dvf, Fmult, htc) keep
+# the same name.
+_SWEEP_KEY_TO_SIM_KEY = {
+    "Pexit_barg":    "Pexit",
+    "speed_f":       "speed",
+    "Kv_BB":         "KvBB",
+    "bore_mm":       "bore",
+    "stroke_mm":     "stroke",
+    "ICV_spring_F":  "icv_Fs",
+    "DCV_spring_F":  "dcv_Fs",
+    "ICV_port_dia":  "icv_port",
+    "DCV_port_dia":  "dcv_port",
+    "ICV_leak_Kv":   "icv_leakKv",
+    "DCV_leak_Kv":   "dcv_leakKv",
+    "fric2chamber":  "fric",
+    "Exp_eff":       "Exp",
+}
+
+
+def _sweep_key_to_sim_key(sweep_key: str) -> str:
+    return _SWEEP_KEY_TO_SIM_KEY.get(sweep_key, sweep_key)
+
+# HuggingFace Space caps
+_IS_HF = bool(os.environ.get("HF_SPACE"))
+_MAX_N_1D = 15 if _IS_HF else 20
+_MAX_GRID_2D = 10 if _IS_HF else 15
+
+# Module-level cache (created lazily so import doesn't touch disk)
+_cache: SweepCache | None = None
+
+
+def _get_cache() -> SweepCache:
+    global _cache
+    if _cache is None:
+        _cache = SweepCache()
+    return _cache
+
+
 # ── Helper: run a single sim point with caching ─────────────────────────────
 
-def _sim_point(hw: str, Pexit: float, speed: float,
-               flash_eff: float = 0.0,
-               extra_overrides: dict[str, float] | None = None,
-               ) -> tuple[float, float, bool]:
-    """Run one cycle_sim call; return (mdot_kgpm, wall_s, was_cached)."""
+def _sim_point(
+    sim_state: dict,
+    hw: str,
+    Pexit: float,
+    speed: float,
+    swept_param: str,
+    swept_value: float,
+) -> tuple[float, float, float, bool]:
+    """Run one cycle_sim call; return (mdot_kgpm, T_peak_K, wall_s, was_cached).
+
+    The full `sim_state` baseline is used — every parameter flows into
+    both the engine call AND the cache key, so stale cache rows from a
+    different baseline can never be returned.
+    """
     cache = _get_cache()
-    params_key = {
-        "engine": "lightspeed",
-        "hw": hw,
-        "Pexit_barg": Pexit,
-        "speed_f": speed,
-        "flash_eff": flash_eff,
-    }
-    if extra_overrides:
-        params_key.update(extra_overrides)
+
+    # Apply hw preset (if any) on top of baseline, then swept override.
+    sim_key = _sweep_key_to_sim_key(swept_param)
+    params = dict(sim_state)
+    params.pop("_written_at", None)
+    params.pop("_engine_ok", None)
+    if hw in _HW_PRESETS:
+        params.update(_HW_PRESETS[hw])
+    params["Pexit"] = Pexit
+    params["speed"] = speed
+    params[sim_key] = swept_value
+
+    # Cache key = full baseline + hw + engine, floats rounded for stability.
+    params_key = {"engine": "lightspeed", "hw": hw}
+    for k, v in params.items():
+        if isinstance(v, float):
+            params_key[k] = float(f"{v:.10g}")
+        elif isinstance(v, list):
+            params_key[k] = tuple(v)
+        else:
+            params_key[k] = v
 
     hit = cache.get(params_key)
     if hit is not None:
         scalars, wall_s = hit
-        return scalars["mdot_kgpm"], wall_s, True
-
-    # Build engine kwargs from overrides
-    all_overrides = {"Pexit_barg": Pexit, "speed_f": speed, "flash_eff": flash_eff}
-    if extra_overrides:
-        all_overrides.update(extra_overrides)
-    kw = _build_overrides(all_overrides)
+        return (scalars.get("mdot_kgpm", 0.0),
+                scalars.get("Tc_peak_K", 60.0),
+                wall_s, True)
 
+    kw = build_engine_kwargs(params)
     t0 = time.perf_counter()
     _out, hist = cycle_sim(engine="lightspeed", **kw)
     wall_s = time.perf_counter() - t0
     mdot = hist.get("mdot_kgpm", 0.0)
+    T_peak = hist.get("Tc_peak_K", 60.0)
 
-    cache.put(params_key, {"mdot_kgpm": mdot}, wall_s)
-    return mdot, wall_s, False
+    cache.put(params_key, {"mdot_kgpm": mdot, "Tc_peak_K": T_peak}, wall_s)
+    return mdot, T_peak, wall_s, False
 
 
 # ── Main click handler ───────────────────────────────────────────────────────
 
 def run_sweep(
+    sim_state: dict | None,
     mode: str,
     hw: str,
     param_1d: str,
@@ -178,14 +252,19 @@ def run_sweep(
     grid_2d: int,
     Pexit: float,
     speed: float,
+    show_labels: bool = True,
 ):
     """Execute a 1D or 2D sweep and return (plot, cache_html, dataframe)."""
+    if sim_state is None:
+        sim_state = dict(SIM_DEFAULTS)
 
     try:
         if mode == "1D Sweep":
-            return _run_1d(hw, param_1d, min_1d, max_1d, int(n_1d), Pexit, speed)
+            return _run_1d(sim_state, hw, param_1d, min_1d, max_1d,
+                           int(n_1d), Pexit, speed, show_labels)
         else:
-            return _run_2d(hw, param_x, param_y, int(grid_2d), Pexit, speed)
+            return _run_2d(sim_state, hw, param_x, param_y,
+                           int(grid_2d), Pexit, speed)
     except Exception:
         err = traceback.format_exc()
         err_html = (
@@ -195,10 +274,10 @@ def run_sweep(
         )
         empty_fig = go.Figure()
         empty_fig.update_layout(height=300)
-        return empty_fig, err_html, pd.DataFrame()
+        return empty_fig, err_html, pd.DataFrame(), None, gr.update(visible=False)
 
 
-def _run_1d(hw, param, lo, hi, n, Pexit, speed):
+def _run_1d(sim_state, hw, param, lo, hi, n, Pexit, speed, show_labels=True):
     """1D parameter sweep — supports all 17 parameters."""
     n = min(n, _MAX_N_1D)
 
@@ -208,13 +287,11 @@ def _run_1d(hw, param, lo, hi, n, Pexit, speed):
     cache_hits = 0
 
     for v in values:
-        # Direct args default to operating point; overridden if swept
         p = float(v) if param == "Pexit_barg" else Pexit
         s = float(v) if param == "speed_f" else speed
-        fe = float(v) if param == "flash_eff" else 0.0
-        # Extra overrides for array-based params
-        extra = {param: float(v)} if param not in ("Pexit_barg", "speed_f", "flash_eff") else None
-        mdot, wall, cached = _sim_point(hw, p, s, fe, extra)
+        mdot, _T_peak, wall, cached = _sim_point(
+            sim_state, hw, p, s, param, float(v),
+        )
         mdots.append(mdot)
         total_wall += wall
         if cached:
@@ -223,13 +300,16 @@ def _run_1d(hw, param, lo, hi, n, Pexit, speed):
     # ── Plotly line chart ────────────────────────────────────────────────
     label = SWEEP_PARAMS[param]["label"]
     fig = go.Figure()
+    trace_mode = "lines+markers+text" if show_labels else "lines+markers"
     fig.add_trace(go.Scatter(
         x=values,
         y=mdots,
-        mode="lines+markers",
+        mode=trace_mode,
         name="mdot",
         line=dict(color=TRACE_COLORS[0], width=2),
         marker=dict(size=6, color=TRACE_COLORS[0]),
+        text=[f"{val:.4g}" for val in values] if show_labels else None,
+        textposition="top center",
     ))
     fig.update_layout(
         title=f"1D Sweep: {label}",
@@ -268,11 +348,20 @@ def _run_1d(hw, param, lo, hi, n, Pexit, speed):
         "mdot [kg/min]": np.round(mdots, 4),
     })
 
-    return fig, cache_html, df
+    return fig, cache_html, df, None, gr.update(visible=False)
+
 
+def _run_2d(sim_state, hw, param_x, param_y, grid_n, Pexit, speed):
+    """2D parameter sweep — supports any two parameters from SWEEP_PARAMS.
+
+    Returns a 5-tuple: ``(fig, cache_html, df, bridge_payload, send_btn_update)``.
+
+    ``bridge_payload`` is a dict (see design spec) iff the axes are exactly
+    ``{Pexit_barg, speed_f}``; otherwise ``None``. ``send_btn_update`` is a
+    ``gr.update(...)`` toggling the Send-to-Process-Sim button visibility.
+    """
+    import datetime as _dt
 
-def _run_2d(hw, param_x, param_y, grid_n, Pexit, speed):
-    """2D parameter sweep — supports any two parameters from SWEEP_PARAMS."""
     grid_n = min(grid_n, _MAX_GRID_2D)
 
     if param_x == param_y:
@@ -283,7 +372,7 @@ def _run_2d(hw, param_x, param_y, grid_n, Pexit, speed):
         )
         empty_fig = go.Figure()
         empty_fig.update_layout(height=300)
-        return empty_fig, info_html, pd.DataFrame()
+        return empty_fig, info_html, pd.DataFrame(), None, gr.update(visible=False)
 
     px_info = SWEEP_PARAMS[param_x]
     py_info = SWEEP_PARAMS[param_y]
@@ -291,21 +380,23 @@ def _run_2d(hw, param_x, param_y, grid_n, Pexit, speed):
     y_vals = np.linspace(py_info["min"], py_info["max"], grid_n)
 
     z = np.zeros((len(y_vals), len(x_vals)))
+    z_temp = np.zeros((len(y_vals), len(x_vals)))
     total_wall = 0.0
     cache_hits = 0
     total_pts = len(x_vals) * len(y_vals)
 
-    _direct_set = {"Pexit_barg", "speed_f", "flash_eff"}
-
     for j, yv in enumerate(y_vals):
         for i, xv in enumerate(x_vals):
-            overrides = {param_x: float(xv), param_y: float(yv)}
-            p = overrides.pop("Pexit_barg", Pexit)
-            s = overrides.pop("speed_f", speed)
-            fe = overrides.pop("flash_eff", 0.0)
-            extra = overrides if overrides else None
-            mdot, wall, cached = _sim_point(hw, p, s, fe, extra)
+            # Apply param_y on top of baseline; pass param_x as swept param.
+            local_state = dict(sim_state)
+            local_state[_sweep_key_to_sim_key(param_y)] = float(yv)
+            p = float(xv) if param_x == "Pexit_barg" else Pexit
+            s = float(xv) if param_x == "speed_f" else speed
+            mdot, T_peak, wall, cached = _sim_point(
+                local_state, hw, p, s, param_x, float(xv),
+            )
             z[j, i] = mdot
+            z_temp[j, i] = T_peak
             total_wall += wall
             if cached:
                 cache_hits += 1
@@ -374,11 +465,79 @@ def _run_2d(hw, param_x, param_y, grid_n, Pexit, speed):
             })
     df = pd.DataFrame(rows)
 
-    return fig, cache_html, df
+    # ── Bridge payload (only for compatible axes) ────────────────────────
+    if {param_x, param_y} == {"Pexit_barg", "speed_f"}:
+        payload = {
+            "axis_x": param_x,
+            "axis_y": param_y,
+            "x_vals": x_vals,
+            "y_vals": y_vals,
+            "z_mdot_kgpm": z,
+            "z_temp_K": z_temp,
+            "hw": hw,
+            "timestamp": _dt.datetime.now().isoformat(timespec="seconds"),
+        }
+        btn_update = gr.update(visible=True)
+    else:
+        payload = None
+        btn_update = gr.update(visible=False)
+
+    return fig, cache_html, df, payload, btn_update
 
 
 # ── Utility ──────────────────────────────────────────────────────────────────
 
+_SECTIONS = [
+    ("Operating",
+     ["engine_name", "fluid", "Pexit", "speed", "Ptank", "Psat"]),
+    ("ICV",
+     ["icv_port", "icv_mass", "icv_travel", "icv_dp_area",
+      "icv_Fs", "icv_SC", "icv_leakKv", "icv_comp_eff", "icv_npts"]),
+    ("DCV",
+     ["dcv_port", "dcv_mass", "dcv_travel", "dcv_dp_area",
+      "dcv_Fs", "dcv_SC", "dcv_leakKv", "dcv_comp_eff", "dcv_npts"]),
+    ("Pump",
+     ["bore", "stroke", "hOD", "cLen", "emH", "emS",
+      "kvoid", "kH", "Vfv", "vac", "cpm", "dvf"]),
+    ("Process",
+     ["Tamb", "htc", "drive", "Fmult", "KvBB", "Pbb",
+      "fric", "Exp", "flash_eff"]),
+    ("Downstream",
+     ["fill_type", "num_cycles", "vsnubber", "vchss", "aov140f", "rodia"]),
+]
+
+
+def _format_baseline_panel(sim_state: dict | None) -> str:
+    """Render sim_state as a grouped HTML table for the Sweep baseline panel."""
+    if sim_state is None:
+        sim_state = dict(SIM_DEFAULTS)
+    written_at = sim_state.get("_written_at", "defaults (no simulation run yet)")
+    engine_ok = sim_state.get("_engine_ok")
+    ok_str = ("ok" if engine_ok else "error") if engine_ok is not None else "—"
+    header = (
+        f'<div style="font-family:JetBrains Mono,monospace;font-size:11px;'
+        f'color:{TEXT_DIM};padding:4px 0;">'
+        f'Source: user inputs at {written_at} (engine: {ok_str})</div>'
+    )
+    rows = []
+    for section, keys in _SECTIONS:
+        rows.append(
+            f'<tr><td colspan="2" style="padding-top:8px;font-weight:600;'
+            f'color:{TEXT_BRIGHT};">{section}</td></tr>'
+        )
+        for key in keys:
+            val = sim_state.get(key, "")
+            rows.append(
+                f'<tr><td style="color:{TEXT_DIM};padding:2px 12px 2px 0;">{key}</td>'
+                f'<td style="font-family:JetBrains Mono,monospace;color:{TEXT_BRIGHT};">{val}</td></tr>'
+            )
+    table = (
+        '<table style="border-collapse:collapse;font-size:11px;">'
+        + "".join(rows) + "</table>"
+    )
+    return header + table
+
+
 def _hex_to_rgb(h: str) -> str:
     """Convert '#4a9eca' to '74,158,202'."""
     h = h.lstrip("#")
@@ -387,8 +546,15 @@ def _hex_to_rgb(h: str) -> str:
 
 # ── Builder ──────────────────────────────────────────────────────────────────
 
-def build_sweep_tab():
-    """Create all Gradio components for the Parameter Sweep tab and wire events.
+def build_sweep_tab(sim_params_state: gr.State):
+    """Create all Gradio components for the Parameter Sweep tab.
+
+    Returns a dict of handles for app.py to wire cross-tab events:
+      * ``run_btn``, ``run_sweep`` (callable)
+      * ``run_inputs`` (list of components for the click handler)
+      * ``plot_out``, ``cache_html``, ``results_df``
+      * ``send_to_process_btn``
+      * ``mode_radio``
 
     Must be called inside an active ``gr.TabItem(...)`` context manager.
     """
@@ -401,9 +567,16 @@ def build_sweep_tab():
         with gr.Column(scale=1, min_width=280):
             gr.HTML(engine_banner("ENGINE: LIGHTSPEED"))
 
+            with gr.Accordion("Baseline parameters in use", open=False):
+                baseline_html = gr.HTML(_format_baseline_panel(None))
+
             hw_dd = gr.Dropdown(
-                choices=["old_icv", "new_icv"],
-                value="old_icv",
+                choices=[
+                    ("Baseline (Simulation tab)", "baseline"),
+                    ("Old ICV", "old_icv"),
+                    ("New ICV", "new_icv"),
+                ],
+                value="baseline",
                 label="Hardware",
             )
 
@@ -467,6 +640,11 @@ def build_sweep_tab():
                 label="Operating Speed Fraction",
             )
 
+            show_labels_cb = gr.Checkbox(
+                label="Show point labels on 1D plot",
+                value=True,
+            )
+
             run_btn = gr.Button("RUN SWEEP", variant="primary")
 
         # ── Right panel — results ────────────────────────────────────────
@@ -474,6 +652,9 @@ def build_sweep_tab():
             plot_out = gr.Plot(label="Sweep Results")
             cache_html = gr.HTML(label="Cache Status")
             results_df = gr.Dataframe(label="Results Table")
+            send_to_process_btn = gr.Button(
+                "Send to Process Sim", variant="secondary", visible=False,
+            )
 
     # ── Mode toggle: show/hide 1D vs 2D control groups ───────────────────
     def toggle_mode(mode):
@@ -488,6 +669,12 @@ def build_sweep_tab():
         outputs=[grp_1d, grp_2d],
     )
 
+    mode_radio.change(
+        fn=lambda _m: gr.update(visible=False),
+        inputs=[mode_radio],
+        outputs=[send_to_process_btn],
+    )
+
     # ── Auto-populate min/max when 1D parameter changes ──────────────────
     def update_minmax(param):
         info = SWEEP_PARAMS.get(param, SWEEP_PARAMS[first_key])
@@ -499,14 +686,27 @@ def build_sweep_tab():
         outputs=[min_1d, max_1d],
     )
 
-    # ── Wire RUN SWEEP button ────────────────────────────────────────────
-    run_btn.click(
-        fn=run_sweep,
-        inputs=[
+    # ── Reactive: baseline panel updates whenever sim_params_state changes ──
+    sim_params_state.change(
+        fn=_format_baseline_panel,
+        inputs=[sim_params_state],
+        outputs=[baseline_html],
+    )
+
+    return {
+        "run_btn": run_btn,
+        "run_sweep": run_sweep,
+        "run_inputs": [
+            sim_params_state,
             mode_radio, hw_dd,
             param_1d_dd, min_1d, max_1d, n_1d_sl,
             param_x_dd, param_y_dd, grid_2d_sl,
             pexit_sl, speed_sl,
+            show_labels_cb,
         ],
-        outputs=[plot_out, cache_html, results_df],
-    )
+        "plot_out": plot_out,
+        "cache_html": cache_html,
+        "results_df": results_df,
+        "send_to_process_btn": send_to_process_btn,
+        "mode_radio": mode_radio,
+    }