Initial deploy: DELPHI Pump Analytics (renamed from MURPHY)

.gitignore

@@ -0,0 +1,6 @@
+.env
+.env.local
+secrets.toml
+__pycache__/
+*.pyc
+.DS_Store

.streamlit/config.toml

@@ -0,0 +1,9 @@
+[theme]
+primaryColor = "#D4A04A"
+backgroundColor = "#0C0A08"
+secondaryBackgroundColor = "#12100E"
+textColor = "#E8E0D4"
+font = "monospace"
+
+[server]
+headless = true

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# System deps for psycopg2-binary
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libpq-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# HF Spaces expects port 7860
+EXPOSE 7860
+
+CMD ["streamlit", "run", "app.py", \
+     "--server.port=7860", \
+     "--server.address=0.0.0.0", \
+     "--server.headless=true", \
+     "--browser.gatherUsageStats=false"]

README.md

@@ -1,10 +1,51 @@
 ---
-title: Delphi Pump Analytics
-emoji: 😻
-colorFrom: purple
-colorTo: pink
+title: CSH2 DELPHI — Pump Analytics
+emoji: ⚙️
+colorFrom: yellow
+colorTo: gray
 sdk: docker
+app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CSH2 DELPHI -- Pump Analytics Dashboard
+
+Interactive Streamlit dashboard for the CSH2 cryogenic hydrogen pump test platform.
+Connects to TimescaleDB for real-time and historical sensor analytics across 74 sensors,
+with LLM-powered diagnostic analysis via Claude API.
+
+## Pages
+
+1. **Data Explorer** -- Browse sensor time-series with NL query support (ask in plain English)
+2. **Testing Cycles** -- Browse pre-computed pump test cycles with summary metrics
+3. **Cycle Detail** -- Deep-dive into a single cycle with multi-sensor overlay plots
+4. **Variation Analysis** -- LLM-powered analysis of within-cycle stabilizations and variations
+5. **Cycle Comparison** -- Side-by-side comparison of two cycles with LLM diagnostic commentary
+6. **Advanced Data Explorer** -- NL-to-SQL analytical pipeline with structured operation execution
+
+## Secrets (Required)
+
+Set these as Space Secrets in the HuggingFace Space settings:
+
+| Secret | Description |
+|--------|-------------|
+| `DB_HOST` | TimescaleDB hostname |
+| `DB_PORT` | Connection port |
+| `DB_NAME` | Database name |
+| `DB_USER` | Read-only database user |
+| `DB_PASSWORD` | Database password |
+| `ANTHROPIC_API_KEY` | Claude API key (optional -- pages 1-3 work without it) |
+
+Without `ANTHROPIC_API_KEY`, the NL query parser (page 1), variation analysis (page 4),
+cycle comparison (page 5), and advanced explorer interpretation (page 6) will show a
+graceful fallback message. All data browsing and charting works without it.
+
+## Architecture
+
+- `core/config.py` -- Reads secrets from `st.secrets` (Streamlit Cloud / HF Spaces) first, falls back to `os.environ` / `.env`
+- `core/db_connector.py` -- Singleton PostgreSQL connector with smart table routing (raw / 1sec / 15sec aggregates)
+- `analysis/` -- LLM analyzer, NL-to-SQL parser, domain knowledge YAML retriever, cycle detection
+- `ui/` -- Custom HUD-themed components, Plotly chart builders, CSS injection
+- `pages/` -- Streamlit multi-page app (6 pages)
+
+Built for Clear Skies Hydrogen (CSH2).

analysis/advanced_analysis.py

@@ -0,0 +1,159 @@
+"""
+Advanced Analysis Module - adapted from clearskies_agent_v1.1
+Peak pressure detection, plateau detection, downsampling
+"""
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Optional
+
+
+class AdvancedAnalyzer:
+    """Advanced analysis functions for cycle detail views"""
+
+    def find_peak_pressure_blocks(
+        self,
+        df: pd.DataFrame,
+        pressure_tag: str = 'PT130',
+        threshold_bar: float = 900.0,
+    ) -> Dict:
+        """Find time blocks where pressure exceeded a threshold"""
+        if pressure_tag not in df.columns:
+            # Try long format
+            pressure_data = df[df.get('tag_name', pd.Series()) == pressure_tag].copy()
+            if pressure_data.empty:
+                return {'error': f'No data for {pressure_tag}', 'num_blocks': 0}
+            pressure_data = pressure_data.sort_values('timestamp')
+            values = pressure_data['value']
+            timestamps = pressure_data['timestamp']
+        else:
+            # Wide format
+            pressure_data = df[['timestamp', pressure_tag]].dropna(subset=[pressure_tag]).copy()
+            pressure_data = pressure_data.sort_values('timestamp')
+            values = pressure_data[pressure_tag]
+            timestamps = pressure_data['timestamp']
+
+        above = values > threshold_bar
+        if not above.any():
+            return {
+                'threshold': threshold_bar,
+                'sensor': pressure_tag,
+                'num_blocks': 0,
+                'total_points_above': 0,
+                'message': f'No data points exceeded {threshold_bar} bar',
+            }
+
+        # Group consecutive above-threshold points
+        above_df = pd.DataFrame({'timestamp': timestamps[above].values, 'value': values[above].values})
+        blocks = self._group_consecutive_timestamps(above_df)
+
+        block_stats = []
+        for block in blocks:
+            mask = (above_df['timestamp'] >= block['start']) & (above_df['timestamp'] <= block['end'])
+            block_data = above_df[mask]
+            block_stats.append({
+                'start_time': block['start'],
+                'end_time': block['end'],
+                'duration_minutes': (block['end'] - block['start']).total_seconds() / 60,
+                'num_points': len(block_data),
+                'peak_pressure': block_data['value'].max(),
+                'avg_pressure': block_data['value'].mean(),
+            })
+
+        return {
+            'threshold': threshold_bar,
+            'sensor': pressure_tag,
+            'num_blocks': len(block_stats),
+            'total_points_above': int(above.sum()),
+            'percentage_above': (above.sum() / len(values)) * 100,
+            'blocks': block_stats,
+            'overall_peak': values.max(),
+        }
+
+    def detect_constant_periods(
+        self,
+        df: pd.DataFrame,
+        tag: str,
+        tolerance: float = 0.01,
+        min_duration_minutes: float = 2.0,
+    ) -> List[Dict]:
+        """
+        Detect periods where a sensor value is constant within tolerance.
+
+        Works with both wide-format (tag as column) and long-format data.
+        """
+        if tag in df.columns:
+            # Wide format
+            sensor_data = df[['timestamp', tag]].dropna(subset=[tag]).sort_values('timestamp')
+            timestamps = sensor_data['timestamp'].values
+            values = sensor_data[tag].values
+        else:
+            # Long format
+            sensor_data = df[df.get('tag_name', pd.Series()) == tag].sort_values('timestamp')
+            if sensor_data.empty:
+                return []
+            timestamps = sensor_data['timestamp'].values
+            values = sensor_data['value'].values
+
+        if len(values) < 2:
+            return []
+
+        constant_periods = []
+        period_start = 0
+        period_value = values[0]
+
+        for i in range(1, len(values)):
+            # Check if value is constant within tolerance
+            denom = abs(period_value) + 1e-10
+            if abs(values[i] - period_value) / denom <= tolerance:
+                continue
+
+            # Period ended — check duration
+            duration_sec = (pd.Timestamp(timestamps[i - 1]) - pd.Timestamp(timestamps[period_start])).total_seconds()
+            duration_min = duration_sec / 60
+
+            if duration_min >= min_duration_minutes:
+                constant_periods.append({
+                    'start': pd.Timestamp(timestamps[period_start]),
+                    'end': pd.Timestamp(timestamps[i - 1]),
+                    'duration_minutes': duration_min,
+                    'value': float(period_value),
+                })
+
+            period_start = i
+            period_value = values[i]
+
+        # Check last period
+        duration_sec = (pd.Timestamp(timestamps[-1]) - pd.Timestamp(timestamps[period_start])).total_seconds()
+        duration_min = duration_sec / 60
+        if duration_min >= min_duration_minutes:
+            constant_periods.append({
+                'start': pd.Timestamp(timestamps[period_start]),
+                'end': pd.Timestamp(timestamps[-1]),
+                'duration_minutes': duration_min,
+                'value': float(period_value),
+            })
+
+        return constant_periods
+
+    def _group_consecutive_timestamps(self, df: pd.DataFrame, max_gap_seconds: float = 2.0) -> List[Dict]:
+        """Group consecutive timestamps into blocks"""
+        if df.empty:
+            return []
+
+        blocks = []
+        current_start = df.iloc[0]['timestamp']
+        current_end = df.iloc[0]['timestamp']
+
+        for i in range(1, len(df)):
+            t = df.iloc[i]['timestamp']
+            gap = (t - current_end).total_seconds() if hasattr(t - current_end, 'total_seconds') else 0
+
+            if gap <= max_gap_seconds:
+                current_end = t
+            else:
+                blocks.append({'start': current_start, 'end': current_end})
+                current_start = t
+                current_end = t
+
+        blocks.append({'start': current_start, 'end': current_end})
+        return blocks

analysis/basic_analysis.py

@@ -0,0 +1,184 @@
+"""
+Basic Analysis Module - adapted from clearskies_agent_v1.1
+Compression ratio, ramp rate, flow stats, fill event analysis
+"""
+import pandas as pd
+import numpy as np
+from typing import Dict, Optional
+from core import config
+
+
+class DataAnalyzer:
+    """Performs analysis on testing cycle / fill event data"""
+
+    def __init__(self):
+        self.performance_targets = config.PERFORMANCE_TARGETS
+
+    def analyze_cycle(
+        self,
+        df_pivot: pd.DataFrame,
+        discharge_tag: str = 'PT130',
+        supply_tag: str = 'PT01T',
+        flow_tag: str = 'FT140',
+        temp_tags: list = None,
+    ) -> Dict:
+        """
+        Comprehensive analysis of a testing cycle from pivoted data.
+
+        Args:
+            df_pivot: Wide-format DataFrame with timestamp and tag columns
+            discharge_tag: Discharge pressure sensor
+            supply_tag: Supply pressure sensor
+            flow_tag: Flow meter sensor
+            temp_tags: Temperature sensor tags
+
+        Returns:
+            Dict with comprehensive cycle analysis
+        """
+        if temp_tags is None:
+            temp_tags = ['TT110', 'TT130']
+
+        analysis = {
+            'time_range': {
+                'start': df_pivot['timestamp'].min(),
+                'end': df_pivot['timestamp'].max(),
+                'duration_minutes': (df_pivot['timestamp'].max() - df_pivot['timestamp'].min()).total_seconds() / 60,
+            }
+        }
+
+        # Discharge pressure
+        if discharge_tag in df_pivot.columns:
+            col = df_pivot[discharge_tag].dropna()
+            if len(col) > 0:
+                analysis['discharge_pressure'] = {
+                    'peak': float(col.max()),
+                    'avg': float(col.mean()),
+                    'std': float(col.std()) if len(col) > 1 else 0.0,
+                    'initial': float(col.iloc[0]),
+                    'final': float(col.iloc[-1]),
+                    'unit': 'bar',
+                }
+
+        # Supply pressure
+        if supply_tag in df_pivot.columns:
+            col = df_pivot[supply_tag].dropna()
+            if len(col) > 0:
+                analysis['supply_pressure'] = {
+                    'avg': float(col.mean()),
+                    'min': float(col.min()),
+                    'max': float(col.max()),
+                    'unit': 'bar',
+                }
+
+        # Compression ratio
+        if discharge_tag in df_pivot.columns and supply_tag in df_pivot.columns:
+            valid = df_pivot[[discharge_tag, supply_tag]].dropna()
+            if len(valid) > 0 and (valid[supply_tag] != 0).any():
+                cr = valid[discharge_tag] / valid[supply_tag].replace(0, np.nan)
+                cr = cr.dropna()
+                if len(cr) > 0:
+                    analysis['compression_ratio'] = {
+                        'avg': float(cr.mean()),
+                        'max': float(cr.max()),
+                        'min': float(cr.min()),
+                    }
+
+        # Temperature analysis
+        for tag in temp_tags:
+            if tag in df_pivot.columns:
+                col = df_pivot[tag].dropna()
+                if len(col) > 0:
+                    analysis[f'temperature_{tag}'] = {
+                        'peak': float(col.max()),
+                        'min': float(col.min()),
+                        'avg': float(col.mean()),
+                        'unit': 'K',
+                    }
+
+        # Flow analysis
+        if flow_tag in df_pivot.columns:
+            col = df_pivot[flow_tag].dropna()
+            if len(col) > 0:
+                analysis['flow'] = {
+                    'avg_flow': float(col.mean()),
+                    'max_flow': float(col.max()),
+                    'unit': 'kg/min',
+                }
+                # Estimate total mass (trapezoidal integration)
+                flow_sorted = df_pivot[['timestamp', flow_tag]].dropna().sort_values('timestamp')
+                if len(flow_sorted) > 1:
+                    time_diff_min = flow_sorted['timestamp'].diff().dt.total_seconds().fillna(0) / 60
+                    mass_increment = flow_sorted[flow_tag] * time_diff_min
+                    analysis['flow']['total_mass_kg'] = float(mass_increment.sum())
+
+        # Pressure ramp rate
+        if discharge_tag in df_pivot.columns:
+            ramp = self._calculate_ramp_rate(df_pivot, discharge_tag)
+            if ramp:
+                analysis['ramp_rate'] = ramp
+
+        # Motor speed — apply display multiplier (5/3) to convert raw signal to RPM
+        speed_mult = getattr(config, 'MOTOR_SPEED_DISPLAY_MULTIPLIER', 1.0)
+        for speed_tag in ['M130_Speed', 'MC130_VFD_Speed', 'M130_RPM']:
+            if speed_tag in df_pivot.columns:
+                col = df_pivot[speed_tag].dropna()
+                if len(col) > 0:
+                    analysis['motor'] = {
+                        'peak_speed': float(col.max()) * speed_mult,
+                        'avg_speed': float(col.mean()) * speed_mult,
+                        'tag': speed_tag,
+                        'unit': 'RPM',
+                    }
+                    break
+
+        # Performance vs targets
+        analysis['performance_vs_targets'] = self._compare_to_targets(analysis)
+
+        return analysis
+
+    def _calculate_ramp_rate(self, df: pd.DataFrame, pressure_tag: str) -> Optional[Dict]:
+        """Calculate pressure ramp rate in bar/min"""
+        data = df[['timestamp', pressure_tag]].dropna().sort_values('timestamp')
+        if len(data) < 2:
+            return None
+
+        time_diff_min = data['timestamp'].diff().dt.total_seconds() / 60
+        pressure_diff = data[pressure_tag].diff()
+        ramp_rate = pressure_diff / time_diff_min
+
+        valid_rates = ramp_rate.replace([np.inf, -np.inf], np.nan).dropna()
+        if len(valid_rates) == 0:
+            return None
+
+        return {
+            'avg': float(valid_rates.mean()),
+            'max': float(valid_rates.max()),
+            'min': float(valid_rates.min()),
+            'unit': 'bar/min',
+        }
+
+    def _compare_to_targets(self, analysis: Dict) -> Dict:
+        """Compare analysis results against performance targets"""
+        comparison = {}
+
+        if 'discharge_pressure' in analysis:
+            peak = analysis['discharge_pressure']['peak']
+            targets = self.performance_targets['pressure']
+            comparison['pressure'] = {
+                'achieved': peak,
+                'phase1_target': targets['phase1'],
+                'h70_target': targets['h70'],
+                'meets_phase1': peak >= targets['phase1'],
+                'meets_h70': peak >= targets['h70'],
+            }
+
+        if 'flow' in analysis:
+            avg = analysis['flow']['avg_flow']
+            targets = self.performance_targets['flow']
+            comparison['flow'] = {
+                'achieved': avg,
+                'simplex_target': targets['simplex'],
+                'pct_of_target': (avg / targets['simplex']) * 100 if targets['simplex'] else 0,
+            }
+
+        return comparison

analysis/execution_engine.py

@@ -0,0 +1,203 @@
+"""
+Execution Engine for Advanced Data Explorer.
+
+Validates an ExecutionPlan, fetches the required data, dispatches
+operations sequentially via OperationDispatcher, and packages results.
+"""
+import time
+import pandas as pd
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from core import config
+from core.db_connector import get_db_connector
+from core.cached_queries import cached_get_pivot_data
+from analysis.operations import OperationDispatcher, OperationOutput
+
+
+# ── Result Dataclasses ───────────────────────────────────────────
+
+@dataclass
+class ExecutionResult:
+    """Complete result of executing a plan."""
+    success: bool
+    query_type: str
+    explanation: str
+    source_data: Optional[pd.DataFrame] = None
+    operation_results: List[OperationOutput] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    execution_time_seconds: float = 0.0
+    table_used: str = ""
+    row_count: int = 0
+
+
+# ── Table label mapping (for display) ───────────────────────────
+
+TABLE_LABELS = {
+    config.TABLES['raw']: 'Raw (10Hz)',
+    config.TABLES['agg_1sec']: '1-second aggregates',
+    config.TABLES['agg_15sec']: '15-second aggregates',
+}
+
+
+# ── Execution Engine ─────────────────────────────────────────────
+
+class ExecutionEngine:
+    """
+    Validate an ExecutionPlan, fetch data, run operations, package results.
+
+    Usage:
+        engine = ExecutionEngine()
+        result = engine.execute(plan)
+    """
+
+    def __init__(self):
+        self.dispatcher = OperationDispatcher()
+
+    def execute(self, plan: Dict) -> ExecutionResult:
+        """Execute a validated plan end-to-end."""
+        t0 = time.time()
+        errors = []
+        warnings = []
+
+        # ── 1. Validate plan structure ──
+        qt = plan.get("query_type", "FETCH")
+        explanation = plan.get("explanation", "")
+        dr = plan.get("data_requirements", {})
+        operations = plan.get("operations", [])
+
+        sensors = dr.get("sensors", [])
+        start_time = dr.get("start_time")
+        end_time = dr.get("end_time")
+        resolution = dr.get("resolution", "auto")
+
+        if not sensors:
+            return self._fail("No sensors specified in plan", qt, explanation, t0)
+
+        if not start_time or not end_time:
+            return self._fail("Missing start_time or end_time in plan", qt, explanation, t0)
+
+        # Ensure datetimes are datetime objects
+        if isinstance(start_time, str):
+            start_time = datetime.fromisoformat(start_time)
+        if isinstance(end_time, str):
+            end_time = datetime.fromisoformat(end_time)
+
+        # ── 2. Resolve table from resolution ──
+        table_override = None
+        if resolution in config.RESOLUTION_MAP:
+            table_override = config.RESOLUTION_MAP[resolution]
+        elif resolution == "auto":
+            # Let the DB connector decide via smart routing
+            table_override = None
+        else:
+            warnings.append(f"Unknown resolution '{resolution}', using auto routing.")
+
+        # ── 3. Safety: raw table time-range cap ──
+        if table_override == config.TABLES['raw']:
+            duration_h = (end_time - start_time).total_seconds() / 3600
+            if duration_h > 1.0:
+                return self._fail(
+                    f"Raw resolution limited to 1 hour. Requested {duration_h:.1f} hours. "
+                    f"Use '1sec' or '15sec' for longer ranges.",
+                    qt, explanation, t0,
+                )
+
+        # ── 4. Fetch data ──
+        try:
+            db = get_db_connector()
+            df = cached_get_pivot_data(
+                tag_names=tuple(sensors),
+                start_time=start_time,
+                end_time=end_time,
+                table_override=table_override,
+            )
+        except Exception as e:
+            return self._fail(f"Data fetch failed: {e}", qt, explanation, t0)
+
+        if df is None or df.empty:
+            return self._fail(
+                "No data returned for the specified sensors and time range. "
+                "Check that the sensors exist and the time range is within March 14 – September 25, 2025.",
+                qt, explanation, t0,
+            )
+
+        # Determine which table was actually used (for display)
+        if table_override:
+            table_used = table_override
+        else:
+            table_used = db._select_table(start_time, end_time)
+
+        table_label = TABLE_LABELS.get(table_used, table_used)
+
+        # Check which sensors actually came back
+        returned_sensors = [s for s in sensors if s in df.columns]
+        missing = [s for s in sensors if s not in df.columns and s != "timestamp"]
+        if missing:
+            warnings.append(f"Sensors not found in data: {', '.join(missing)}")
+
+        # ── 5. Run operations sequentially ──
+        op_results = []
+        prev_result = None
+
+        for i, op_spec in enumerate(operations):
+            op_name = op_spec.get("op", "")
+            op_params = op_spec.get("params", {})
+            op_label = op_spec.get("label", op_name)
+
+            try:
+                output = self.dispatcher.run(
+                    op_name=op_name,
+                    df=df,
+                    params=op_params,
+                    prev_result=prev_result,
+                    db_connector=get_db_connector(),
+                )
+                op_results.append(output)
+                prev_result = output
+
+                # Check for operation-level errors
+                if output.metadata.get("error"):
+                    warnings.append(f"Operation '{op_label}': {output.metadata['error']}")
+
+            except Exception as e:
+                error_msg = f"Operation '{op_label}' failed: {e}"
+                errors.append(error_msg)
+                # Create a placeholder output so downstream chaining can detect the failure
+                op_results.append(OperationOutput(
+                    op_name=op_name,
+                    label=f"{op_label} (FAILED)",
+                    data=None,
+                    metadata={"error": str(e)},
+                ))
+                prev_result = op_results[-1]
+
+        # ── 6. Package result ──
+        elapsed = time.time() - t0
+        success = len(errors) == 0
+
+        return ExecutionResult(
+            success=success,
+            query_type=qt,
+            explanation=explanation,
+            source_data=df,
+            operation_results=op_results,
+            errors=errors,
+            warnings=warnings,
+            execution_time_seconds=round(elapsed, 2),
+            table_used=table_label,
+            row_count=len(df),
+        )
+
+    @staticmethod
+    def _fail(msg: str, qt: str, explanation: str, t0: float) -> ExecutionResult:
+        """Return a failed ExecutionResult."""
+        return ExecutionResult(
+            success=False,
+            query_type=qt,
+            explanation=explanation,
+            errors=[msg],
+            execution_time_seconds=round(time.time() - t0, 2),
+        )

analysis/knowledge/failure_modes.yaml

@@ -0,0 +1,361 @@
+# CSH2 Cryogenic Pump — Failure Mode Knowledge Base
+# Derived from maintenance_log.xlsx (Jul 2025) and Technical PDF (Phase 1B results)
+# 8 failure modes ordered by frequency and system priority
+
+failure_modes:
+  - id: FM-001
+    name: "ICV Reverse Flow"
+    category: "check_valve"
+    symptoms:
+      primary: "Low pressure build — PT130 plateaus well below target"
+      secondary:
+        - "Degrades more at higher motor speeds"
+        - "DCV leak test normal (rules out DCV)"
+        - "Volumetric efficiency significantly below expected"
+      sensor_signatures:
+        - tag: PT130
+          tagindex: 18
+          behavior: "Plateaus at 40-60% of expected peak pressure"
+        - tag: TT110
+          tagindex: 24
+          behavior: "Gradual warming from high-pressure leakback through ICV"
+        - tag: FT140
+          tagindex: 7
+          behavior: "Flow rate reduced proportionally to leak severity"
+    physical_mechanism: >
+      ICV does not fully seat against head block during compression stroke.
+      Creates reverse flow path from high-pressure chamber back to inlet.
+      Volumetric efficiency drops proportionally with gap area and pressure
+      differential. Higher motor speeds worsen the leak because the pressure
+      differential per stroke increases while the seating time decreases.
+    candidate_causes:
+      - cause: "ICV installation orientation error"
+        prior: 0.45
+        evidence: "Jul 22 — fixed orientation restored 700 bar"
+        refs: ["2025-07-22"]
+      - cause: "ICV/head block tolerance mismatch"
+        prior: 0.30
+        evidence: "Jul 14 — manually polished ICV not flat"
+        refs: ["2025-07-14"]
+      - cause: "ICV sealing surface wear"
+        prior: 0.15
+        evidence: "Jul 1 — new valve helped but some leakage remained"
+        refs: ["2025-07-01"]
+      - cause: "Thermal distortion from cryo cycling"
+        prior: 0.10
+        evidence: "Theoretical — differential CTE at ICV/head block interface"
+    discriminating_tests:
+      - test: "DCV leak test (PT130 decay, pump stopped)"
+        rules_out: "DCV leak if decay < 0.5 bar/min"
+      - test: "Compare pressure build at 10% vs 50% motor speed"
+        interpretation: "ICV leak worsens disproportionately at higher speeds"
+      - test: "Visual inspect ICV seating — flashlight gap check"
+        confirms: "Installation tolerance issue"
+    recommended_actions:
+      immediate: "Check ICV seating orientation and gap against head block"
+      long_term: "Implement ICV installation jig or go/no-go gauge"
+    system_priority: "HIGH"
+    occurrence_count: 3
+    notes: "Most frequently recurring failure mode (3x July 2025)"
+
+  - id: FM-002
+    name: "DCV Leakage"
+    category: "check_valve"
+    symptoms:
+      primary: "PT130 decays during static hold test"
+      secondary:
+        - "Pressure build OK but cannot maintain pressure after pump stops"
+        - "Rate of PT130 decay proportional to leak severity"
+      sensor_signatures:
+        - tag: PT130
+          tagindex: 18
+          behavior: "Exponential decay during hold period (pump stopped)"
+        - tag: TT130
+          tagindex: 27
+          behavior: "May show slight cooling as high-pressure fluid expands backward"
+    physical_mechanism: >
+      DCV sealing surface does not fully seat, allowing high-pressure fluid
+      to leak backward through the discharge check valve. The leak rate is
+      proportional to the pressure differential and the effective orifice area
+      of the gap. This is a static leak — it occurs even when the pump is stopped.
+    candidate_causes:
+      - cause: "DCV sealing surface damage/scoring"
+        prior: 0.50
+        evidence: "Jul 1 — DCV sealing surface polished to restore seal"
+        refs: ["2025-07-01"]
+      - cause: "DCV spring fatigue"
+        prior: 0.25
+        evidence: "Theoretical — spring force decreases with cycling"
+      - cause: "Particulate contamination on seat"
+        prior: 0.25
+        evidence: "Theoretical — cryo system should be clean but possible"
+    discriminating_tests:
+      - test: "Pressurize to 500 bar, stop pump, log PT130 for 5 minutes"
+        interpretation: "Decay rate > 5 bar/min = actionable leak"
+      - test: "Compare decay rates before and after DCV polishing"
+        interpretation: "Improvement confirms surface damage as cause"
+    recommended_actions:
+      immediate: "Run PT130 decay test and compute leak rate"
+      long_term: "Establish DCV inspection/polishing interval based on cycling data"
+    system_priority: "MEDIUM"
+    occurrence_count: 1
+
+  - id: FM-003
+    name: "HP Seal Blowby / Energizer Degradation"
+    category: "seal"
+    symptoms:
+      primary: "Increased blowby leakage — reduced volumetric efficiency"
+      secondary:
+        - "Seal friction initially high after replacement (7-9 kgf)"
+        - "Friction breaks in to 4-5 kgf after ~1000 cycles"
+        - "Degradation rate very slow (8.2M cycle lower bound on seal life)"
+      sensor_signatures:
+        - tag: PT130
+          tagindex: 18
+          behavior: "Gradual pressure build degradation over thousands of cycles"
+        - tag: MC130_VFD_Speed
+          tagindex: 13
+          behavior: "Higher motor current at same speed = increased friction"
+    physical_mechanism: >
+      The HP seal energizer may degrade from repeated thermal cycling to 116K.
+      This reduces the radial sealing force against the cylinder bore, allowing
+      high-pressure fluid to leak past the piston (blowby). The seal life lower
+      bound from reliability testing is 8.2M cycles, equivalent to 3+ months
+      at 20 fills/day.
+    candidate_causes:
+      - cause: "Seal energizer thermal fatigue"
+        prior: 0.40
+        evidence: "Jul 18 — seal energizer possibly degraded from cryo cycling"
+        refs: ["2025-07-18"]
+      - cause: "Bore surface roughening"
+        prior: 0.30
+        evidence: "Theoretical — scoring increases blowby"
+      - cause: "Piston ring wear"
+        prior: 0.30
+        evidence: "Theoretical — progressive wear"
+    discriminating_tests:
+      - test: "Static blowby rate measurement at multiple pressures"
+        interpretation: "Higher blowby at higher P = seal gap increasing"
+      - test: "Track motor current at fixed speed over time"
+        interpretation: "Decreasing friction = seal wearing in (expected). Increasing = bore damage"
+    recommended_actions:
+      immediate: "Monitor blowby rate and motor current trends"
+      long_term: "Schedule seal inspection at cumulative stroke threshold"
+    system_priority: "LOW"
+    occurrence_count: 1
+    notes: "Seal life is very long — this is a slow degradation mode"
+
+  - id: FM-004
+    name: "Pressure Safety Loop Oscillation"
+    category: "controls"
+    symptoms:
+      primary: "Rapid pressure oscillations near setpoint"
+      secondary:
+        - "AOV141 opening/closing rapidly"
+        - "VFD speed oscillating"
+        - "Pressure overshoots followed by undershoots"
+      sensor_signatures:
+        - tag: PT130
+          tagindex: 18
+          behavior: "High-frequency oscillation (>0.5 Hz) near setpoint"
+        - tag: AOV140
+          tagindex: 1
+          behavior: "Rapid cycling between open and closed"
+    physical_mechanism: >
+      The pressure safety control loop has insufficient damping or incorrect
+      PID tuning. When pressure approaches the setpoint, the relief valve
+      (AOV141) opens and closes rapidly, causing pressure oscillation.
+      This stresses the valve mechanism and can cause premature wear.
+    candidate_causes:
+      - cause: "PID tuning too aggressive (insufficient damping)"
+        prior: 0.60
+        evidence: "Jul 22 — AOV141 rapid cycling observed at high pressure"
+        refs: ["2025-07-22"]
+      - cause: "Relief valve setpoint too close to operating pressure"
+        prior: 0.30
+        evidence: "Theoretical — narrow margin causes hunting"
+      - cause: "Valve actuator response delay"
+        prior: 0.10
+        evidence: "Theoretical"
+    discriminating_tests:
+      - test: "Ramp pressure slowly to setpoint and monitor AOV141 position"
+        interpretation: "Oscillation onset pressure identifies the trigger"
+    recommended_actions:
+      immediate: "Review safety loop PID parameters and increase damping"
+      long_term: "Tune safety loop with proper step-response testing"
+    system_priority: "MEDIUM"
+    occurrence_count: 1
+
+  - id: FM-005
+    name: "Dry Running"
+    category: "operational"
+    symptoms:
+      primary: "PT130/PT110 ratio drops below expected AND TT130 rises abnormally"
+      secondary:
+        - "Pump compressing gas instead of liquid"
+        - "Very damaging to seals and valves"
+        - "Mass flow drops to near zero"
+      sensor_signatures:
+        - tag: PT130
+          tagindex: 18
+          behavior: "Cannot reach target — pressure builds very slowly"
+        - tag: TT130
+          tagindex: 27
+          behavior: "Abnormal temperature rise (adiabatic gas compression)"
+        - tag: FT140
+          tagindex: 7
+          behavior: "Near zero flow"
+    physical_mechanism: >
+      When the inlet has insufficient liquid (boil-off, empty tank, blocked line),
+      the pump compresses gas instead of liquid. Gas has very low bulk modulus
+      compared to liquid, so pressure builds much slower. Adiabatic compression
+      of gas produces much higher discharge temperatures than liquid compression.
+      This is the most damaging operating condition — stop pump immediately.
+    candidate_causes:
+      - cause: "Insufficient cooldown (two-phase inlet)"
+        prior: 0.40
+        evidence: "D1 diagnostic signature"
+      - cause: "Cryotank empty/low liquid level"
+        prior: 0.30
+        evidence: "Check LT200"
+      - cause: "Inlet line blockage (ice formation)"
+        prior: 0.20
+        evidence: "Check TT110 for sudden changes"
+      - cause: "Valve stuck closed in inlet path"
+        prior: 0.10
+        evidence: "Check valve positions"
+    discriminating_tests:
+      - test: "Check TT110 — must be below saturation temperature at PT110"
+        interpretation: "TT110 > T_sat = two-phase or gas inlet"
+    recommended_actions:
+      immediate: "STOP PUMP. Verify inlet conditions before restart."
+      long_term: "Implement automatic dry-running protection based on D1"
+    system_priority: "CRITICAL"
+    occurrence_count: 0
+    notes: "Diagnostic D1 monitors for this continuously"
+
+  - id: FM-006
+    name: "ICV Thermal Backflow"
+    category: "check_valve"
+    symptoms:
+      primary: "TT110 rises while PT130 is high"
+      secondary:
+        - "Hot compressed fluid flowing backward through ICV"
+        - "Can cause inlet boiling — cascading failure"
+      sensor_signatures:
+        - tag: TT110
+          tagindex: 24
+          behavior: "Rising temperature correlated with high PT130"
+        - tag: PT130
+          tagindex: 18
+          behavior: "High pressure (normal operation)"
+    physical_mechanism: >
+      High-pressure, heated fluid leaks backward through the ICV during the
+      compression stroke. This hot fluid heats the inlet line, potentially
+      causing the subcooled inlet liquid to boil. Once boiling starts at the
+      inlet, the pump transitions to gas compression (FM-005 cascade).
+    candidate_causes:
+      - cause: "ICV not seating properly (same root cause as FM-001)"
+        prior: 0.70
+        evidence: "D3 diagnostic signature"
+      - cause: "ICV spring force insufficient at high pressure"
+        prior: 0.30
+        evidence: "Theoretical"
+    discriminating_tests:
+      - test: "Monitor TT110 rate of change during high-pressure operation"
+        interpretation: ">2 K/min rise = significant backflow"
+    recommended_actions:
+      immediate: "Check ICV seating. Same remediation as FM-001."
+      long_term: "Implement TT110 rate-of-rise protection"
+    system_priority: "HIGH"
+    occurrence_count: 0
+    notes: "Diagnostic D3 monitors this. Shares root cause with FM-001."
+
+  - id: FM-007
+    name: "Gas Entrainment / Insufficient Subcooling"
+    category: "thermal"
+    symptoms:
+      primary: "Reduced pump efficiency with two-phase inlet conditions"
+      secondary:
+        - "Inlet quality > 0 (not fully subcooled liquid)"
+        - "Volumetric efficiency reduced by gas fraction"
+        - "Less severe than full dry running (FM-005)"
+      sensor_signatures:
+        - tag: TT110
+          tagindex: 24
+          behavior: "Near or above saturation temperature at inlet pressure"
+        - tag: PT110
+          tagindex: 17
+          behavior: "May be low (insufficient supply pressure)"
+    physical_mechanism: >
+      When inlet liquid is not sufficiently subcooled (temperature close to
+      boiling point at inlet pressure), flash gas forms in the cylinder during
+      the suction stroke. This gas takes up volume that should be liquid,
+      reducing the effective displacement. The pump is 169x more efficient
+      with fully subcooled liquid than with gas (Technical PDF p.17).
+    candidate_causes:
+      - cause: "Cooldown incomplete"
+        prior: 0.40
+        evidence: "Check TT110 vs saturation temperature"
+      - cause: "Cryotank pressure too low (reduced subcooling margin)"
+        prior: 0.30
+        evidence: "Check PT110"
+      - cause: "Heat leak into inlet piping"
+        prior: 0.20
+        evidence: "Check insulation"
+      - cause: "Rapid pressure transients causing flash gas"
+        prior: 0.10
+        evidence: "Theoretical"
+    discriminating_tests:
+      - test: "Calculate subcooling margin: T_sat(PT110) - TT110"
+        interpretation: "< 2K margin = risk of flash gas"
+    recommended_actions:
+      immediate: "Verify adequate subcooling margin before fill"
+      long_term: "Add subcooling verification to pre-fill checklist"
+    system_priority: "MEDIUM"
+    occurrence_count: 0
+
+  - id: FM-008
+    name: "Cryotank Pressure Decay"
+    category: "system"
+    symptoms:
+      primary: "Pressure response drifts downward during extended fills"
+      secondary:
+        - "PT130 and flow rate decline over the fill duration"
+        - "Due to decreasing cryotank pressure (small tank)"
+        - "Not a pump fault — operational characteristic"
+      sensor_signatures:
+        - tag: PT130
+          tagindex: 18
+          behavior: "Gradual downward drift during extended fills"
+        - tag: PT110
+          tagindex: 17
+          behavior: "Decreasing during fill (cryotank depleting)"
+        - tag: LT200
+          tagindex: 12
+          behavior: "Decreasing (if available)"
+    physical_mechanism: >
+      The pump operates with a fixed pressure ratio. As cryotank pressure
+      drops (small tank being depleted), the inlet pressure drops, and since
+      the pump's pressure ratio is approximately constant, the discharge
+      pressure also decreases. This is documented in the Technical PDF p.22
+      and is an expected operational characteristic, not a fault.
+    candidate_causes:
+      - cause: "Normal tank depletion (small tank)"
+        prior: 0.80
+        evidence: "Technical PDF p.22 — documented behavior"
+      - cause: "Boil-off reducing tank pressure faster than expected"
+        prior: 0.15
+        evidence: "Check boil-off rate"
+      - cause: "Tank regulator malfunction"
+        prior: 0.05
+        evidence: "Theoretical"
+    discriminating_tests:
+      - test: "Plot PT110 and PT130 together over the fill"
+        interpretation: "Parallel decline = tank depletion. PT130 drops faster = pump issue"
+    recommended_actions:
+      immediate: "Expected behavior — no action unless decline rate is abnormal"
+      long_term: "Size production tank to maintain pressure over target fill profile"
+    system_priority: "LOW"
+    occurrence_count: 0
+    notes: "Not a fault — operational characteristic of small test tank"

analysis/knowledge/operational_context.yaml

@@ -0,0 +1,154 @@
+# CSH2 Cryogenic Pump — Operational Context Knowledge
+# Practical knowledge that operators have but specifications don't document.
+# Derived from maintenance_log.xlsx, Technical PDF, and data analysis.
+
+sensor_trustworthiness:
+  TT110:
+    notes: >
+      TT110 reads pipe wall temperature, not fluid temperature. After cooldown,
+      it needs 10-15 minutes to equilibrate with the flowing cryogen. During
+      transients (pump start/stop, flow changes), TT110 lags the actual fluid
+      temperature by 5-30 seconds depending on flow rate.
+    workaround: >
+      For precise inlet temperature, use virtual T_inlet back-calculated from
+      discharge state via ThermoProps (physics/thermo.py). The virtual sensor
+      uses PT110 + TT130 + isentropic relations to infer inlet conditions.
+    known_faults:
+      - "Jul 16, 2025: 0-32K readings are sensor fault, not real cryo temps"
+      - "Filter out readings during known warm periods where TT110 < 50K"
+
+  FT140:
+    notes: >
+      FT140 is a Coriolis mass flow meter calibrated for LN2. When running LH2,
+      the density difference (LN2: 808 kg/m³ vs LH2: 70.8 kg/m³) causes the
+      raw reading to be 100-200x too high. The FT140Calibrator applies a density
+      correction factor of approximately 11.4x.
+    workaround: >
+      Always apply FT140Calibrator (physics/ft140_calibration.py) density correction
+      before interpreting flow readings. Near-zero flow at low pump speeds is
+      expected and not a fault — the meter has a low-flow cutoff.
+    known_faults:
+      - "Raw FT140 reads ~100-200x too high for LH2 — apply correction"
+      - "Near-zero flow at idle is expected, not a sensor fault"
+
+  PT100:
+    notes: >
+      PT100 is stuck at -14.86 bar in the current dataset. This is not a
+      physical pressure — it's a sensor fault.
+    workaround: >
+      Use default_when_invalid=2.0 barg for any calculations requiring PT100
+      (e.g., Psat estimation). This is the saturation pressure approximation.
+    known_faults:
+      - "Stuck at -14.86 bar — use 2.0 barg default"
+
+  CalcMass:
+    notes: >
+      CalcMass is stuck at 0.18 kg in the current dataset. The PLC calculation
+      is not updating.
+    workaround: >
+      Use FT140 integration (corrected) for actual dispensed mass calculation.
+      Integrate corrected FT140 over the fill duration.
+    known_faults:
+      - "Stuck at 0.18 kg — use FT140 integration instead"
+
+  M130_Speed_vs_MC130:
+    notes: >
+      Tag 68 (M130_Speed) replaces tag 13 (MC130_VFD_Speed) after May 28, 2025.
+      Both map to motor speed percentage but are different register addresses.
+      TAG_ALIASES in config.py handles this mapping.
+    workaround: >
+      Check TAG_ALIASES. Use tag 68 for post-May data, tag 13 for pre-May.
+      Both are valid speed readings.
+
+post_maintenance_expectations:
+  hp_seal_replacement:
+    description: "After HP seal replacement or energizer work"
+    expected_behavior:
+      - "Initial friction: 7-9 kgf (from Jul 18 maintenance entry)"
+      - "Break-in period: ~1000 cycles to reach 4-5 kgf steady state"
+      - "Motor current will be higher initially — this is normal"
+      - "Volumetric efficiency may be slightly higher initially (tighter seal)"
+    timeline: "1000 cycles (~2-3 days at normal testing rate)"
+    ref: "2025-07-18 maintenance event"
+
+  icv_replacement:
+    description: "After ICV replacement or reseating"
+    expected_behavior:
+      - "Immediate improvement in pressure build if ICV was the issue"
+      - "New valve may need seating-in (initial performance varies)"
+      - "Jul 22: orientation fix restored 700 bar immediately"
+      - "Jul 14: polished ICV helped but didn't fully fix — surface not flat"
+    timeline: "Immediate improvement expected"
+    ref: "2025-07-01, 2025-07-14, 2025-07-22 events"
+
+  dcv_polishing:
+    description: "After DCV sealing surface polishing"
+    expected_behavior:
+      - "Immediate improvement in leak test results"
+      - "Run PT130 decay test before and after to quantify improvement"
+      - "Jul 1: polishing improved seal but some residual leakage"
+    timeline: "Immediate improvement"
+    ref: "2025-07-01 maintenance event"
+
+regime_caveats:
+  ln2_vs_lh2:
+    description: "LN2 and LH2 data are not directly comparable"
+    details: >
+      LN2 (77K, 808 kg/m³) and LH2 (20K, 70.8 kg/m³) have very different
+      fluid properties that shift all performance curves. Compression ratios,
+      volumetric efficiencies, heat transfer rates, and valve dynamics all
+      change significantly between fluids. The SPEED_SCALE_FACTOR in config.py
+      was calibrated for LN2 and needs adjustment for LH2.
+    impact:
+      - "Flow rate scales with density ratio"
+      - "Pressure build rate changes with bulk modulus"
+      - "Thermal effects are very different (77K vs 20K)"
+
+  pressure_drift:
+    description: "Discharge pressure drifts down during extended fills"
+    details: >
+      Documented in Technical PDF p.22. The pump operates at approximately
+      fixed pressure ratio. As the small test cryotank depletes, inlet
+      pressure (PT110) drops, and PT130 follows. This is NOT a fault —
+      it's an expected consequence of the small tank size.
+    impact:
+      - "PT130 and flow rate decline over extended fills"
+      - "Production tanks will be sized to maintain pressure"
+
+  subcooling_sensitivity:
+    description: "Pump performance is very sensitive to inlet subcooling"
+    details: >
+      From Technical PDF p.17: the pump is 169x more efficient with
+      subcooled liquid than with gas. Even small amounts of flash gas
+      at the inlet significantly reduce volumetric efficiency. Ensure
+      adequate subcooling margin (>5K) before starting fills.
+    impact:
+      - "Inlet quality > 0 = reduced efficiency"
+      - "Subcooling margin < 2K = risk zone"
+
+system_personality:
+  recurring_issues:
+    - priority: 1
+      description: "ICV sealing is the #1 recurring issue"
+      details: "3 occurrences in July 2025. Check ICV first for any pressure build problem."
+      refs: ["2025-07-01", "2025-07-14", "2025-07-22"]
+    - priority: 2
+      description: "DCV sealing is the #2 issue"
+      details: "1 occurrence. DCV polishing was effective but residual leakage remained."
+      refs: ["2025-07-01"]
+    - priority: 3
+      description: "Safety loop tuning needs attention at high pressures"
+      details: "AOV141 hunting observed. PID tuning required."
+      refs: ["2025-07-22"]
+
+  strengths:
+    - "HP seal life is excellent (8.2M cycle lower bound = 3+ months at 20 fills/day)"
+    - "Phase 1B achieved 100% uptime across 6 fills"
+    - "Specific energy of 0.26 kWh/kg matches target"
+    - "Back-to-back fill capability demonstrated (4 consecutive fills)"
+
+  known_limitations:
+    - "Pump gas ratio 14.4% vs 2.7% target — efficiency gap exists"
+    - "Peak pressure 370 bar vs 700 bar H70 target — further testing needed"
+    - "Small test tank causes pressure drift during extended fills"
+    - "FT140 requires density correction for LH2 — raw readings are wrong"

analysis/knowledge/reasoning_chains.yaml

@@ -0,0 +1,302 @@
+# CSH2 Cryogenic Pump — Diagnostic Reasoning Chains
+# Step-by-step decision trees encoding how an expert reasons from observation to diagnosis.
+# Each step specifies: what tool to call, what to look for, and branching rules.
+
+reasoning_chains:
+  - id: RC-001
+    name: "Low Pressure Build Diagnostic"
+    trigger: "PT130 cannot reach target pressure"
+    related_failure_modes: [FM-001, FM-002, FM-003, FM-007]
+    steps:
+      - step: 1
+        action: "query_sensor_data"
+        description: "Pull PT130, PT110, TT110, VFD speed for the time window"
+        parameters:
+          tagindices: [18, 17, 24, 13]
+        look_for: "PT130 plateau level, PT110 stability, TT110 trend"
+        next:
+          if_pt130_below_50pct_target: "step_2"
+          if_pt130_slow_build: "step_5"
+
+      - step: 2
+        action: "run_simulation"
+        description: "Compute expected PT130 at current operating conditions"
+        parameters_from: "extracted operating conditions"
+        look_for: "Sim vs measured gap magnitude"
+        next:
+          if_gap_gt_20pct: "step_3"
+          if_gap_lt_20pct: "step_6"
+
+      - step: 3
+        action: "Run DCV leak test"
+        description: "Check PT130 decay rate with pump stopped"
+        look_for: "Decay rate in bar/min"
+        next:
+          if_decay_gt_5_bar_per_min: "conclude_FM002"
+          if_decay_lt_5_bar_per_min: "step_4"
+
+      - step: 4
+        action: "Compare pressure build at multiple speeds"
+        description: "Run pump at 10%, 30%, 50% speed and compare pressure"
+        look_for: "Does pressure gap worsen at higher speeds?"
+        next:
+          if_worse_at_higher_speed: "conclude_FM001"
+          if_similar_at_all_speeds: "step_5"
+
+      - step: 5
+        action: "Check inlet conditions"
+        description: "Verify subcooling margin: T_sat(PT110) - TT110"
+        look_for: "Subcooling margin in K"
+        next:
+          if_margin_lt_2K: "conclude_FM007"
+          if_margin_gt_2K: "step_6"
+
+      - step: 6
+        action: "search_domain_knowledge"
+        description: "Search maintenance history for recent ICV/DCV work"
+        parameters:
+          category: "maintenance_history"
+          component: "ICV"
+        look_for: "Recent maintenance events"
+        next:
+          if_recent_icv_work: "conclude_FM001_installation"
+          if_no_recent_work: "conclude_FM003"
+
+    conclusions:
+      conclude_FM001:
+        diagnosis: "ICV reverse flow — leak worsens with speed"
+        confidence: "high"
+        failure_mode: FM-001
+      conclude_FM001_installation:
+        diagnosis: "ICV installation issue — recent maintenance"
+        confidence: "high"
+        failure_mode: FM-001
+      conclude_FM002:
+        diagnosis: "DCV leakage — static pressure decay"
+        confidence: "high"
+        failure_mode: FM-002
+      conclude_FM003:
+        diagnosis: "HP seal blowby — gradual degradation"
+        confidence: "moderate"
+        failure_mode: FM-003
+      conclude_FM007:
+        diagnosis: "Insufficient subcooling — two-phase inlet"
+        confidence: "high"
+        failure_mode: FM-007
+
+  - id: RC-002
+    name: "Pressure Oscillation Diagnostic"
+    trigger: "PT130 showing high-frequency oscillations"
+    related_failure_modes: [FM-004]
+    steps:
+      - step: 1
+        action: "query_sensor_data"
+        description: "Pull PT130 at 1-second resolution for oscillation analysis"
+        parameters:
+          tagindices: [18, 1]
+          resolution: "1sec"
+        look_for: "Oscillation frequency and amplitude"
+
+      - step: 2
+        action: "Correlate with AOV141 cycling"
+        description: "Check if AOV140/141 is cycling in sync with PT130"
+        look_for: "Phase correlation between pressure and valve"
+        next:
+          if_correlated: "conclude_FM004"
+          if_not_correlated: "step_3"
+
+      - step: 3
+        action: "Check DCV dynamics"
+        description: "Analyze stroke timing — DCV may be bouncing"
+        look_for: "DCV open/close timing anomalies"
+        next:
+          default: "conclude_valve_dynamics"
+
+    conclusions:
+      conclude_FM004:
+        diagnosis: "Safety loop oscillation — AOV141 hunting"
+        confidence: "high"
+        failure_mode: FM-004
+      conclude_valve_dynamics:
+        diagnosis: "DCV dynamic behavior anomaly — investigate spring force"
+        confidence: "moderate"
+        failure_mode: FM-002
+
+  - id: RC-003
+    name: "Elevated Discharge Temperature Diagnostic"
+    trigger: "TT130 higher than isentropic prediction"
+    related_failure_modes: [FM-005, FM-006]
+    steps:
+      - step: 1
+        action: "query_sensor_data"
+        description: "Pull TT130, PT130, PT110, TT110"
+        parameters:
+          tagindices: [27, 18, 17, 24]
+        look_for: "TT130 excess above isentropic prediction"
+
+      - step: 2
+        action: "run_simulation"
+        description: "Compute isentropic discharge temperature"
+        look_for: "Measured TT130 vs predicted"
+        next:
+          if_excess_gt_20K: "step_3"
+          if_excess_lt_20K: "conclude_normal_friction"
+
+      - step: 3
+        action: "Check pressure ratio"
+        description: "PT130/PT110 ratio vs expected"
+        look_for: "Is pressure building normally?"
+        next:
+          if_ratio_low: "conclude_FM005"
+          if_ratio_normal: "step_4"
+
+      - step: 4
+        action: "Check TT110 trend"
+        description: "Is TT110 rising during operation?"
+        look_for: "TT110 rate of change"
+        next:
+          if_tt110_rising: "conclude_FM006"
+          if_tt110_stable: "conclude_friction"
+
+    conclusions:
+      conclude_FM005:
+        diagnosis: "Dry running — pump compressing gas"
+        confidence: "high"
+        failure_mode: FM-005
+      conclude_FM006:
+        diagnosis: "ICV thermal backflow — hot fluid heating inlet"
+        confidence: "high"
+        failure_mode: FM-006
+      conclude_normal_friction:
+        diagnosis: "Normal — friction heating within expected range"
+        confidence: "high"
+      conclude_friction:
+        diagnosis: "Elevated friction — possible seal break-in or bore damage"
+        confidence: "moderate"
+        failure_mode: FM-003
+
+  - id: RC-004
+    name: "Reduced Flow Rate Diagnostic"
+    trigger: "FT140 below expected mass flow rate"
+    related_failure_modes: [FM-001, FM-002, FM-007]
+    steps:
+      - step: 1
+        action: "query_sensor_data"
+        description: "Pull FT140, PT130, VFD speed"
+        parameters:
+          tagindices: [7, 18, 13]
+        look_for: "Flow rate vs expected at current speed"
+
+      - step: 2
+        action: "Check FT140 calibration"
+        description: "Verify FT140 density correction factor is applied"
+        look_for: "Is fluid H2 or N2? Apply correct density correction"
+        next:
+          if_calibration_wrong: "conclude_calibration_error"
+          if_calibration_correct: "step_3"
+
+      - step: 3
+        action: "run_simulation"
+        description: "Compute expected flow at current conditions"
+        look_for: "Vol efficiency and loss breakdown"
+        next:
+          if_icv_leak_dominant: "conclude_FM001"
+          if_dcv_leak_dominant: "conclude_FM002"
+          if_gas_inlet: "conclude_FM007"
+
+    conclusions:
+      conclude_FM001:
+        diagnosis: "ICV leakage reducing effective displacement"
+        confidence: "high"
+        failure_mode: FM-001
+      conclude_FM002:
+        diagnosis: "DCV leakage losing compressed fluid"
+        confidence: "high"
+        failure_mode: FM-002
+      conclude_FM007:
+        diagnosis: "Two-phase inlet reducing effective displacement"
+        confidence: "high"
+        failure_mode: FM-007
+      conclude_calibration_error:
+        diagnosis: "FT140 reading incorrect — apply density correction"
+        confidence: "high"
+
+  - id: RC-005
+    name: "Motor Power Anomaly Diagnostic"
+    trigger: "Motor power or current anomaly at given speed"
+    related_failure_modes: [FM-003]
+    steps:
+      - step: 1
+        action: "query_sensor_data"
+        description: "Pull VFD power, current, speed, torque"
+        parameters:
+          tagindices: [43, 45, 13, 48]
+        look_for: "Power/current at each speed point"
+
+      - step: 2
+        action: "Compare to baseline power-speed curve"
+        description: "Plot power vs speed, compare to reference"
+        look_for: "Offset direction"
+        next:
+          if_power_higher: "step_3"
+          if_power_lower: "conclude_reduced_load"
+
+      - step: 3
+        action: "search_domain_knowledge"
+        description: "Check seal friction baseline expectations"
+        parameters:
+          category: "operational_context"
+        look_for: "Post-maintenance friction expectations"
+        next:
+          if_recent_seal_work: "conclude_seal_break_in"
+          if_no_recent_work: "conclude_FM003"
+
+    conclusions:
+      conclude_FM003:
+        diagnosis: "HP seal friction increasing — possible bore damage"
+        confidence: "moderate"
+        failure_mode: FM-003
+      conclude_seal_break_in:
+        diagnosis: "Normal seal break-in after maintenance (7-9 kgf → 4-5 kgf)"
+        confidence: "high"
+      conclude_reduced_load:
+        diagnosis: "Reduced load — possible liquid starvation or low discharge pressure"
+        confidence: "moderate"
+
+  - id: RC-006
+    name: "Post-Maintenance Performance Verification"
+    trigger: "Performance check after maintenance event"
+    related_failure_modes: [FM-001, FM-002, FM-003]
+    steps:
+      - step: 1
+        action: "search_domain_knowledge"
+        description: "Look up the maintenance event details"
+        parameters:
+          category: "maintenance_history"
+        look_for: "What was done, what to expect"
+
+      - step: 2
+        action: "query_sensor_data"
+        description: "Pull first test run after maintenance"
+        look_for: "Compare to pre-maintenance baseline"
+
+      - step: 3
+        action: "run_diagnostics"
+        description: "Run full D1-D8 diagnostic sweep"
+        look_for: "Any new or resolved diagnostic flags"
+
+      - step: 4
+        action: "run_simulation"
+        description: "Compare sim prediction to post-maintenance performance"
+        look_for: "Has the residual changed after maintenance?"
+
+    conclusions:
+      conclude_improved:
+        diagnosis: "Maintenance successfully addressed the issue"
+        confidence: "high"
+      conclude_no_change:
+        diagnosis: "Maintenance did not resolve the underlying issue"
+        confidence: "moderate"
+      conclude_degraded:
+        diagnosis: "Performance worse after maintenance — investigate installation"
+        confidence: "high"

analysis/knowledge_retriever.py

@@ -0,0 +1,432 @@
+"""
+Domain Knowledge Retriever for CSH2 LLM Analysis
+
+Pattern-based retrieval: maps sensor data patterns to relevant failure modes,
+reasoning chains, and operational context from the YAML knowledge base.
+
+At this scale (8 failure modes, 6 chains), rule-based retrieval is more precise
+than embedding-based RAG — no vector DB needed.
+"""
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+try:
+    import yaml
+except ImportError:
+    yaml = None
+
+logger = logging.getLogger(__name__)
+
+KNOWLEDGE_DIR = Path(__file__).parent / "knowledge"
+
+# Trigger thresholds (physically meaningful boundaries)
+LOW_PRESSURE_THRESHOLD_BAR = 350  # H35 target — below this is underperforming
+HIGH_DISCHARGE_TEMP_K = 100       # Unusual for LH2 (inlet ~25K)
+LOW_FLOW_THRESHOLD_KG_MIN = 0.5   # < half of demonstrated 1.13 kg/min
+MOTOR_SPEED_ACTIVE_THRESHOLD = 83  # Scaled RPM (raw ~50 × 5/3 display multiplier) — pump is running
+
+
+class DomainKnowledgeRetriever:
+    """Retrieves structured domain knowledge from YAML files.
+
+    Loads failure_modes.yaml, reasoning_chains.yaml, operational_context.yaml
+    at startup. Uses pattern matching on cycle_stats to determine which
+    knowledge chunks to inject into LLM prompts.
+    """
+
+    def __init__(self, knowledge_dir: Optional[Path] = None):
+        self._dir = Path(knowledge_dir) if knowledge_dir else KNOWLEDGE_DIR
+
+        if yaml is None:
+            raise ImportError("PyYAML required. Install with: pip install pyyaml")
+
+        self._failure_modes = self._load_yaml("failure_modes.yaml")
+        self._reasoning_chains = self._load_yaml("reasoning_chains.yaml")
+        self._operational_context = self._load_yaml("operational_context.yaml")
+
+    def _load_yaml(self, filename: str) -> Dict:
+        path = self._dir / filename
+        if not path.exists():
+            logger.warning(f"Knowledge file not found: {path}")
+            return {}
+        with open(path, "r") as f:
+            return yaml.safe_load(f) or {}
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def get_context_for_cycle(
+        self, cycle_stats: Dict, plateaus: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """Determine which knowledge chunks are relevant based on cycle data.
+
+        Args:
+            cycle_stats: Dict from DataAnalyzer.analyze_cycle()
+            plateaus: Optional dict mapping tag names to plateau periods
+
+        Returns:
+            Dict with categorized knowledge chunks ready for formatting
+        """
+        context: Dict[str, Any] = {
+            "failure_modes": [],
+            "reasoning_chains": [],
+            "sensor_notes": [],
+            "regime_caveats": [],
+            "system_personality": [],
+            "benchmarks": {},
+        }
+
+        # Always-include sections
+        context["system_personality"] = self._get_system_personality()
+        context["sensor_notes"] = self._get_sensor_notes_for_stats(cycle_stats)
+        context["benchmarks"] = self._get_phase1_benchmarks()
+        context["regime_caveats"] = self._get_regime_caveats()
+
+        # Pattern-based trigger detection
+        triggers = self._detect_triggers(cycle_stats, plateaus)
+
+        if "low_pressure_build" in triggers:
+            context["failure_modes"].extend(
+                self._get_fm_by_ids(["FM-001", "FM-002", "FM-007", "FM-008"])
+            )
+            context["reasoning_chains"].extend(
+                self._get_rc_by_ids(["RC-001"])
+            )
+
+        if "high_discharge_temp" in triggers:
+            context["failure_modes"].extend(
+                self._get_fm_by_ids(["FM-005", "FM-006"])
+            )
+            context["reasoning_chains"].extend(
+                self._get_rc_by_ids(["RC-003"])
+            )
+
+        if "flow_anomaly" in triggers:
+            context["failure_modes"].extend(
+                self._get_fm_by_ids(["FM-001", "FM-002", "FM-007"])
+            )
+            context["reasoning_chains"].extend(
+                self._get_rc_by_ids(["RC-004"])
+            )
+
+        if "pressure_oscillation" in triggers:
+            context["failure_modes"].extend(
+                self._get_fm_by_ids(["FM-004"])
+            )
+            context["reasoning_chains"].extend(
+                self._get_rc_by_ids(["RC-002"])
+            )
+
+        if "motor_anomaly" in triggers:
+            context["failure_modes"].extend(
+                self._get_fm_by_ids(["FM-003"])
+            )
+            context["reasoning_chains"].extend(
+                self._get_rc_by_ids(["RC-005"])
+            )
+
+        # Deduplicate (triggers may overlap)
+        context["failure_modes"] = _deduplicate(context["failure_modes"], "id")
+        context["reasoning_chains"] = _deduplicate(context["reasoning_chains"], "id")
+
+        return context
+
+    def get_context_for_comparison(
+        self, stats_a: Dict, stats_b: Dict
+    ) -> Dict[str, Any]:
+        """Get knowledge context for a two-cycle comparison.
+
+        Runs trigger detection on both cycles and takes the union.
+        """
+        ctx_a = self.get_context_for_cycle(stats_a)
+        ctx_b = self.get_context_for_cycle(stats_b)
+
+        merged: Dict[str, Any] = {
+            "failure_modes": _deduplicate(
+                ctx_a["failure_modes"] + ctx_b["failure_modes"], "id"
+            ),
+            "reasoning_chains": _deduplicate(
+                ctx_a["reasoning_chains"] + ctx_b["reasoning_chains"], "id"
+            ),
+            "sensor_notes": _deduplicate(
+                ctx_a["sensor_notes"] + ctx_b["sensor_notes"], "sensor"
+            ),
+            "regime_caveats": ctx_a["regime_caveats"],  # Same for both
+            "system_personality": ctx_a["system_personality"],
+            "benchmarks": ctx_a["benchmarks"],
+        }
+        return merged
+
+    def format_for_prompt(self, context: Dict[str, Any]) -> str:
+        """Format retrieved knowledge into text blocks for LLM prompt injection."""
+        sections = []
+
+        # System personality
+        if context.get("system_personality"):
+            lines = ["SYSTEM PERSONALITY (known recurring issues & strengths):"]
+            for item in context["system_personality"]:
+                prefix = f"  [Priority {item['priority']}]" if "priority" in item else "  -"
+                lines.append(f"{prefix} {item['description']}")
+                if item.get("details"):
+                    lines.append(f"    {item['details']}")
+            sections.append("\n".join(lines))
+
+        # Sensor trustworthiness
+        if context.get("sensor_notes"):
+            lines = ["SENSOR TRUSTWORTHINESS NOTES:"]
+            for note in context["sensor_notes"]:
+                lines.append(f"  {note['sensor']}:")
+                lines.append(f"    Issue: {note['notes']}")
+                lines.append(f"    Workaround: {note['workaround']}")
+            sections.append("\n".join(lines))
+
+        # Failure modes (plain-language, no internal IDs)
+        if context.get("failure_modes"):
+            lines = ["RELEVANT FAILURE PATTERNS (from CSH2 knowledge base):"]
+            for fm in context["failure_modes"]:
+                priority = fm.get('priority', 'N/A')
+                lines.append(f"  **{fm['name']}** ({priority} priority)")
+                lines.append(f"    Primary symptom: {fm['primary_symptom']}")
+                mechanism = fm.get("mechanism", "")
+                if len(mechanism) > 250:
+                    mechanism = mechanism[:250] + "..."
+                lines.append(f"    Mechanism: {mechanism}")
+                if fm.get("candidate_causes"):
+                    causes = ", ".join(
+                        f"{c['cause']} ({c['prior']:.0%})"
+                        for c in fm["candidate_causes"][:3]
+                    )
+                    lines.append(f"    Top causes: {causes}")
+                if fm.get("recommended_action"):
+                    lines.append(f"    Action: {fm['recommended_action']}")
+            sections.append("\n".join(lines))
+
+        # Reasoning chains (plain-language, no internal IDs)
+        if context.get("reasoning_chains"):
+            lines = ["DIAGNOSTIC REASONING STEPS:"]
+            for rc in context["reasoning_chains"]:
+                lines.append(f"  **{rc['name']}**")
+                lines.append(f"    Trigger: {rc['trigger']}")
+                if rc.get("steps"):
+                    steps_text = "; ".join(
+                        f"Step {s['step']}: {s['description']}"
+                        for s in rc["steps"][:4]
+                    )
+                    lines.append(f"    Steps: {steps_text}")
+            sections.append("\n".join(lines))
+
+        # Regime caveats
+        if context.get("regime_caveats"):
+            lines = ["OPERATIONAL CAVEATS:"]
+            for caveat in context["regime_caveats"]:
+                lines.append(f"  {caveat['name']}: {caveat['description']}")
+            sections.append("\n".join(lines))
+
+        # Benchmarks
+        benchmarks = context.get("benchmarks", {})
+        if benchmarks:
+            lines = [
+                "PHASE 1B BENCHMARKS (reference values — Sept 24-26 ccH2 fills):",
+                f"  Specific energy: {benchmarks.get('specific_energy', '0.26 kWh/kg')}",
+                f"  Flow rate: {benchmarks.get('flow_rate', '1.13-1.25 kg/min at 65% motor')}",
+                f"  Peak pressure: {benchmarks.get('peak_pressure', '370 bar')}",
+                f"  Delivered temp: {benchmarks.get('delivered_temp', '55K')}",
+                f"  Uptime: {benchmarks.get('uptime', '100% (6 fills, 4 back-to-back)')}",
+            ]
+            sections.append("\n".join(lines))
+
+        return "\n\n".join(sections)
+
+    # ------------------------------------------------------------------
+    # Trigger detection
+    # ------------------------------------------------------------------
+
+    def _detect_triggers(
+        self, stats: Dict, plateaus: Optional[Dict] = None
+    ) -> Set[str]:
+        """Detect which diagnostic triggers are active based on sensor patterns."""
+        triggers: Set[str] = set()
+
+        # --- Low pressure build ---
+        dp = stats.get("discharge_pressure", {})
+        peak_pressure = dp.get("peak", 0)
+        if 0 < peak_pressure < LOW_PRESSURE_THRESHOLD_BAR:
+            triggers.add("low_pressure_build")
+
+        # Also check if PT130 plateaus below target
+        if plateaus:
+            pt130_plateaus = plateaus.get("PT130", [])
+            if pt130_plateaus:
+                max_plateau = max(
+                    (p.get("value", 0) for p in pt130_plateaus), default=0
+                )
+                if 0 < max_plateau < LOW_PRESSURE_THRESHOLD_BAR:
+                    triggers.add("low_pressure_build")
+
+        # --- High discharge temperature ---
+        tt130 = stats.get("temperature_TT130", {})
+        tt130_peak = tt130.get("peak", 0)
+        tt130_avg = tt130.get("avg", 0)
+        if tt130_peak > HIGH_DISCHARGE_TEMP_K:
+            triggers.add("high_discharge_temp")
+        if tt130_avg > 0 and tt130_peak > tt130_avg * 1.3 and tt130_peak > 60:
+            triggers.add("high_discharge_temp")
+
+        # --- Flow anomaly ---
+        flow = stats.get("flow", {})
+        avg_flow = flow.get("avg_flow", -1)
+        motor = stats.get("motor", {})
+        avg_speed = motor.get("avg_speed", 0)
+        if avg_flow >= 0 and avg_flow < LOW_FLOW_THRESHOLD_KG_MIN and avg_speed > MOTOR_SPEED_ACTIVE_THRESHOLD:
+            triggers.add("flow_anomaly")
+
+        # --- Pressure oscillation ---
+        # Distinguish oscillation from a normal smooth ramp.
+        # Key insight: a ramp from ambient to 370 bar has peak >> initial.
+        # True oscillation happens when the system is already at high
+        # pressure and fluctuates. We trigger ONLY when:
+        #   1. Peak pressure > 200 bar (system was pressurized)
+        #   2. Initial pressure > 30% of peak (NOT a ramp from ambient)
+        #   3. Std is non-trivial (> 20 bar — real fluctuation)
+        dp_initial = dp.get("initial", 0)
+        dp_std = dp.get("std", 0)
+        if peak_pressure > 200 and dp_initial > peak_pressure * 0.3 and dp_std > 20:
+            triggers.add("pressure_oscillation")
+
+        return triggers
+
+    # ------------------------------------------------------------------
+    # Knowledge accessors
+    # ------------------------------------------------------------------
+
+    def _get_fm_by_ids(self, fm_ids: List[str]) -> List[Dict]:
+        """Get failure modes by ID, formatted for context injection."""
+        modes = self._failure_modes.get("failure_modes", [])
+        results = []
+        for fm in modes:
+            if fm.get("id") in fm_ids:
+                results.append({
+                    "id": fm.get("id"),
+                    "name": fm.get("name"),
+                    "priority": fm.get("system_priority"),
+                    "primary_symptom": fm.get("symptoms", {}).get("primary", ""),
+                    "mechanism": fm.get("physical_mechanism", ""),
+                    "candidate_causes": [
+                        {"cause": c["cause"], "prior": c["prior"]}
+                        for c in fm.get("candidate_causes", [])
+                    ],
+                    "recommended_action": fm.get("recommended_actions", {}).get("immediate", ""),
+                })
+        return results
+
+    def _get_rc_by_ids(self, rc_ids: List[str]) -> List[Dict]:
+        """Get reasoning chains by ID, formatted for context injection."""
+        chains = self._reasoning_chains.get("reasoning_chains", [])
+        results = []
+        for chain in chains:
+            if chain.get("id") in rc_ids:
+                results.append({
+                    "id": chain.get("id"),
+                    "name": chain.get("name"),
+                    "trigger": chain.get("trigger"),
+                    "related_fms": chain.get("related_failure_modes", []),
+                    "steps": [
+                        {
+                            "step": s.get("step"),
+                            "action": s.get("action"),
+                            "description": s.get("description"),
+                        }
+                        for s in chain.get("steps", [])
+                    ],
+                })
+        return results
+
+    def _get_system_personality(self) -> List[Dict]:
+        """Get system personality: recurring issues + strengths."""
+        personality = self._operational_context.get("system_personality", {})
+        items = []
+        for issue in personality.get("recurring_issues", []):
+            items.append({
+                "priority": issue.get("priority"),
+                "description": issue.get("description"),
+                "details": issue.get("details"),
+                "type": "recurring_issue",
+            })
+        for strength in personality.get("strengths", []):
+            items.append({
+                "description": strength,
+                "details": None,
+                "type": "strength",
+            })
+        return items
+
+    def _get_sensor_notes_for_stats(self, stats: Dict) -> List[Dict]:
+        """Get sensor trustworthiness notes for sensors present in the data."""
+        sensors = self._operational_context.get("sensor_trustworthiness", {})
+        present_sensors = set()
+
+        # Detect which sensors are in the stats
+        if "discharge_pressure" in stats:
+            present_sensors.add("PT130")
+        if "supply_pressure" in stats:
+            present_sensors.add("PT110")
+        if "temperature_TT110" in stats:
+            present_sensors.add("TT110")
+        if "temperature_TT130" in stats:
+            present_sensors.add("TT130")
+        if "flow" in stats:
+            present_sensors.add("FT140")
+        if "motor" in stats:
+            present_sensors.add("M130_Speed_vs_MC130")
+
+        results = []
+        for sensor_key, info in sensors.items():
+            # Match sensor key to present sensors
+            if sensor_key in present_sensors or any(
+                s in sensor_key for s in present_sensors
+            ):
+                results.append({
+                    "sensor": sensor_key,
+                    "notes": info.get("notes", "").strip(),
+                    "workaround": info.get("workaround", "").strip(),
+                })
+        return results
+
+    def _get_regime_caveats(self) -> List[Dict]:
+        """Get all regime caveats."""
+        caveats = self._operational_context.get("regime_caveats", {})
+        return [
+            {
+                "name": name,
+                "description": info.get("description", ""),
+            }
+            for name, info in caveats.items()
+        ]
+
+    def _get_phase1_benchmarks(self) -> Dict[str, str]:
+        """Get Phase 1B benchmark values."""
+        return {
+            "specific_energy": "0.26 kWh/kg",
+            "flow_rate": "1.13-1.25 kg/min at 65% motor",
+            "peak_pressure": "370 bar (Phase 1B ccH2 fills)",
+            "delivered_temp": "55K",
+            "uptime": "100% (6 fills, 4 back-to-back)",
+        }
+
+
+# ------------------------------------------------------------------
+# Utility
+# ------------------------------------------------------------------
+
+def _deduplicate(items: List[Dict], key: str) -> List[Dict]:
+    """Deduplicate list of dicts by a key field."""
+    seen: set = set()
+    result = []
+    for item in items:
+        val = item.get(key)
+        if val not in seen:
+            seen.add(val)
+            result.append(item)
+    return result

analysis/llm_analyzer.py

@@ -0,0 +1,418 @@
+"""
+LLM-Powered Cycle Analysis Module
+Uses Claude API for variation analysis and cycle comparison.
+Injects domain knowledge from CSH2 YAML knowledge base via DomainKnowledgeRetriever.
+"""
+import os
+import re
+import json
+from typing import Dict, List, Optional
+from core import config
+
+
+# ── Output Sanitizer ──────────────────────────────────────────────
+# Catches any remaining internal reference codes the LLM generates
+# despite prompt instructions not to use them.
+
+# Pattern matches FM-001, RC-003, RM-001, D1-D8, etc.
+_INTERNAL_CODE_PATTERN = re.compile(
+    r'\b(?:FM|RC|RM|D)-?\d{1,3}\b',
+    re.IGNORECASE,
+)
+
+
+def sanitize_llm_output(text: str) -> str:
+    """Remove internal reference codes from LLM output.
+
+    Strips patterns like FM-001, RC-003, RM-001 that the engineering
+    team finds confusing. The surrounding text (which describes the
+    issue in plain language) is preserved.
+    """
+    if not text:
+        return text
+    # Remove the code pattern, plus optional surrounding parens/brackets
+    # e.g., "(FM-001)" → "", "FM-001:" → ":"
+    cleaned = re.sub(
+        r'\s*[\(\[]*' + _INTERNAL_CODE_PATTERN.pattern + r'[\)\]]*\s*[:\-—]?\s*',
+        ' ',
+        text,
+        flags=re.IGNORECASE,
+    )
+    # Clean up double spaces and leading/trailing whitespace per line
+    cleaned = re.sub(r'  +', ' ', cleaned)
+    return cleaned.strip()
+
+
+# ── Shared Murphy System Prompt ─────────────────────────────────
+# Extracted as a module-level constant so it can be reused by
+# result_interpreter.py and any future LLM callers.
+
+MURPHY_SYSTEM_PROMPT = """You are Murphy, the diagnostic intelligence layer for CSH2's cryogenic hydrogen pump platform. You are a senior cryogenic systems engineer with deep expertise in:
+
+- Reciprocating cryogenic pump physics (triplex design, 60mm stroke, ~40mm bore, ~75.4 cm3 swept volume)
+- Cryogenic fluid behavior (LH2 at 20.3K, LN2 at 77.4K, phase transitions, subcooling margins)
+- High-pressure hydrogen systems (up to 900 bar, H35/H70/ccH2 dispensing)
+- Seal integrity, check valve dynamics (ICV/DCV), and thermal management
+- Time-series sensor diagnostics and fault signature recognition
+
+When you identify a pattern in the data, explain WHY it matters thermodynamically — not just that a number is high or low. Describe any matching failure patterns by their plain-English name and physical mechanism. Never use internal reference codes like FM-001 or RC-001 — always describe issues in terms the engineering team can immediately understand (e.g., "DCV seat wear" not "FM-001").
+
+Always cite specific measured values from the data to support your claims. If the data summary says peak pressure was 371 bar, say "371 bar" — do not round, estimate, or invent values.
+
+Key system specifications:
+- Drive: Variable Frequency Drive (VFD), 0-100% speed, max ~300 RPM
+- Pressure targets: H35 (350 bar), H70 (700 bar), max rated 900+ bar
+- Phase 1B results: 0.26 kWh/kg, 1.13-1.25 kg/min flow, 370 bar, 55K delivered temp, 100% uptime
+- Testing phases: LN2 mechanical validation (Mar-Aug 2025), LH2 Phase 1A (early Sep), Phase 1B ccH2 fills (Sep 24-26)
+
+Be direct, methodical, and honest about uncertainty. Distinguish between "the data shows X" and "X could indicate Y but we'd need Z to confirm." """
+
+
+class LLMCycleAnalyzer:
+    """Claude-powered analysis for testing cycle interpretation.
+
+    Integrates DomainKnowledgeRetriever to inject CSH2-specific failure modes,
+    reasoning chains, and operational context into prompts.
+    """
+
+    def __init__(self):
+        self.api_key = config.ANTHROPIC_API_KEY
+        self.api_available = bool(self.api_key and self.api_key != 'your_api_key_here')
+        self.model = "claude-sonnet-4-20250514"
+        self._client = None
+        self._retriever = None
+
+    @property
+    def client(self):
+        if self._client is None and self.api_available:
+            import anthropic
+            self._client = anthropic.Anthropic(api_key=self.api_key)
+        return self._client
+
+    @property
+    def retriever(self):
+        """Lazy-load the domain knowledge retriever. Returns None on failure."""
+        if self._retriever is None:
+            try:
+                from analysis.knowledge_retriever import DomainKnowledgeRetriever
+                self._retriever = DomainKnowledgeRetriever()
+            except Exception:
+                self._retriever = None
+        return self._retriever
+
+    def _build_system_prompt(self) -> str:
+        """Build the system prompt establishing Murphy's identity and expertise."""
+        return MURPHY_SYSTEM_PROMPT
+
+    def analyze_cycle_variations(
+        self,
+        cycle_stats: Dict,
+        plateaus: Dict[str, List[Dict]],
+        transitions: List[Dict] = None,
+    ) -> str:
+        """
+        Feature 4: Explain variations and stabilizations in a single testing cycle.
+
+        Args:
+            cycle_stats: Dict from DataAnalyzer.analyze_cycle()
+            plateaus: Dict mapping tag names to lists of plateau periods
+            transitions: Optional list of notable transitions
+
+        Returns:
+            LLM analysis text
+        """
+        if not self.api_available:
+            return "LLM analysis unavailable. Add ANTHROPIC_API_KEY to .env file."
+
+        # Retrieve domain knowledge based on data patterns
+        knowledge_text = ""
+        if self.retriever:
+            try:
+                context = self.retriever.get_context_for_cycle(cycle_stats, plateaus)
+                knowledge_text = self.retriever.format_for_prompt(context)
+            except Exception:
+                knowledge_text = ""
+
+        prompt = self._build_variation_prompt(cycle_stats, plateaus, transitions, knowledge_text)
+
+        try:
+            message = self.client.messages.create(
+                model=self.model,
+                max_tokens=2000,
+                system=[
+                    {
+                        "type": "text",
+                        "text": self._build_system_prompt(),
+                        "cache_control": {"type": "ephemeral"},
+                    }
+                ],
+                messages=[{"role": "user", "content": prompt}],
+            )
+            return sanitize_llm_output(message.content[0].text)
+        except Exception as e:
+            return f"Analysis failed: {e}"
+
+    def compare_cycles(
+        self,
+        cycle_a_stats: Dict,
+        cycle_b_stats: Dict,
+        cycle_a_label: str = "Cycle A",
+        cycle_b_label: str = "Cycle B",
+    ) -> str:
+        """
+        Feature 5: Compare two testing cycles and explain differences.
+
+        Args:
+            cycle_a_stats: Dict from DataAnalyzer.analyze_cycle() for cycle A
+            cycle_b_stats: Dict from DataAnalyzer.analyze_cycle() for cycle B
+            cycle_a_label: Display label for cycle A
+            cycle_b_label: Display label for cycle B
+
+        Returns:
+            LLM comparison text
+        """
+        if not self.api_available:
+            return "LLM analysis unavailable. Add ANTHROPIC_API_KEY to .env file."
+
+        # Retrieve domain knowledge based on both cycles
+        knowledge_text = ""
+        if self.retriever:
+            try:
+                context = self.retriever.get_context_for_comparison(cycle_a_stats, cycle_b_stats)
+                knowledge_text = self.retriever.format_for_prompt(context)
+            except Exception:
+                knowledge_text = ""
+
+        prompt = self._build_comparison_prompt(
+            cycle_a_stats, cycle_b_stats, cycle_a_label, cycle_b_label, knowledge_text
+        )
+
+        try:
+            message = self.client.messages.create(
+                model=self.model,
+                max_tokens=2500,
+                system=[
+                    {
+                        "type": "text",
+                        "text": self._build_system_prompt(),
+                        "cache_control": {"type": "ephemeral"},
+                    }
+                ],
+                messages=[{"role": "user", "content": prompt}],
+            )
+            return sanitize_llm_output(message.content[0].text)
+        except Exception as e:
+            return f"Comparison analysis failed: {e}"
+
+    def follow_up(
+        self,
+        conversation_history: List[Dict],
+        follow_up_question: str,
+    ) -> str:
+        """Multi-turn follow-up on a previous analysis.
+
+        Args:
+            conversation_history: List of {role, content} message dicts
+                representing the prior conversation (user prompt + assistant
+                analysis + any prior follow-ups).
+            follow_up_question: The engineer's follow-up question.
+
+        Returns:
+            LLM follow-up response text.
+        """
+        if not self.api_available:
+            return "LLM analysis unavailable. Add ANTHROPIC_API_KEY to .env file."
+
+        messages = list(conversation_history) + [
+            {"role": "user", "content": follow_up_question},
+        ]
+
+        try:
+            message = self.client.messages.create(
+                model=self.model,
+                max_tokens=1500,
+                system=[
+                    {
+                        "type": "text",
+                        "text": self._build_system_prompt(),
+                        "cache_control": {"type": "ephemeral"},
+                    }
+                ],
+                messages=messages,
+            )
+            return sanitize_llm_output(message.content[0].text)
+        except Exception as e:
+            return f"Follow-up failed: {e}"
+
+    def _build_variation_prompt(
+        self,
+        stats: Dict,
+        plateaus: Dict[str, List[Dict]],
+        transitions: List[Dict] = None,
+        knowledge_text: str = "",
+    ) -> str:
+        """Build the prompt for single-cycle variation analysis"""
+
+        # Format cycle summary
+        time_range = stats.get('time_range', {})
+        duration = time_range.get('duration_minutes', 0)
+
+        summary_lines = [f"Duration: {duration:.1f} minutes"]
+
+        if 'discharge_pressure' in stats:
+            dp = stats['discharge_pressure']
+            summary_lines.append(f"Peak Discharge Pressure: {dp['peak']:.1f} bar")
+            summary_lines.append(f"Average Discharge Pressure: {dp['avg']:.1f} bar")
+            summary_lines.append(f"Initial Pressure: {dp['initial']:.1f} bar -> Final: {dp['final']:.1f} bar")
+
+        if 'compression_ratio' in stats:
+            cr = stats['compression_ratio']
+            summary_lines.append(f"Compression Ratio: {cr['min']:.1f}x to {cr['max']:.1f}x (avg: {cr['avg']:.1f}x)")
+
+        for key in ['temperature_TT110', 'temperature_TT130']:
+            if key in stats:
+                t = stats[key]
+                tag = key.replace('temperature_', '')
+                summary_lines.append(f"{tag}: {t['min']:.1f} K to {t['peak']:.1f} K (avg: {t['avg']:.1f} K)")
+
+        if 'flow' in stats:
+            f = stats['flow']
+            summary_lines.append(f"Average Flow: {f['avg_flow']:.2f} kg/min, Max: {f['max_flow']:.2f} kg/min")
+            if 'total_mass_kg' in f:
+                summary_lines.append(f"Total Mass Delivered: {f['total_mass_kg']:.2f} kg")
+
+        if 'ramp_rate' in stats:
+            r = stats['ramp_rate']
+            summary_lines.append(f"Pressure Ramp Rate: avg {r['avg']:.1f} bar/min, max {r['max']:.1f} bar/min")
+
+        if 'motor' in stats:
+            m = stats['motor']
+            summary_lines.append(f"Motor Peak Speed: {m['peak_speed']:.0f} RPM, Avg: {m['avg_speed']:.0f} RPM")
+
+        cycle_summary = "\n".join(f"  - {line}" for line in summary_lines)
+
+        # Format plateaus
+        plateau_lines = []
+        for tag, periods in plateaus.items():
+            if periods:
+                plateau_lines.append(f"\n  {tag} plateaus ({len(periods)} detected):")
+                for i, p in enumerate(periods[:5], 1):
+                    plateau_lines.append(
+                        f"    {i}. Value: {p['value']:.2f} | "
+                        f"Duration: {p['duration_minutes']:.1f} min | "
+                        f"From {p['start'].strftime('%H:%M:%S')} to {p['end'].strftime('%H:%M:%S')}"
+                    )
+        plateau_text = "\n".join(plateau_lines) if plateau_lines else "  No significant plateaus detected."
+
+        # Format performance vs targets
+        perf_lines = []
+        pvt = stats.get('performance_vs_targets', {})
+        if 'pressure' in pvt:
+            p = pvt['pressure']
+            status = "MET" if p['meets_phase1'] else "NOT MET"
+            perf_lines.append(f"  - Phase 1 pressure target (500 bar): {status} (achieved {p['achieved']:.0f} bar)")
+            status_h70 = "MET" if p['meets_h70'] else "NOT MET"
+            perf_lines.append(f"  - H70 pressure target (700 bar): {status_h70}")
+        perf_text = "\n".join(perf_lines) if perf_lines else "  No targets evaluated."
+
+        prompt = f"""Analyze this testing cycle and explain the observed variations and stabilizations:
+
+CYCLE SUMMARY:
+{cycle_summary}
+
+DETECTED PLATEAUS (constant-value periods):
+{plateau_text}
+
+PERFORMANCE vs TARGETS:
+{perf_text}"""
+
+        if knowledge_text:
+            prompt += f"""
+
+DOMAIN KNOWLEDGE (use this to inform your analysis — describe any matching patterns by name and mechanism):
+{knowledge_text}"""
+
+        prompt += """
+
+Provide a concise engineering analysis (3-5 paragraphs) covering:
+1. What physical processes likely caused the observed pressure/temperature variations
+2. Why plateaus (stabilizations) occurred at the specific values detected
+3. Any diagnostic concerns — describe matching failure patterns by name and physical mechanism, and walk through the diagnostic reasoning
+4. Recommendations for the next cycle or operational improvements
+
+Use specific values from the data — cite exact numbers, do not round or estimate. If sensor trustworthiness notes are provided, factor them into your interpretation (e.g., TT110 reads pipe wall not fluid, FT140 needs density correction for LH2). Never use internal codes like FM-XXX or RC-XXX."""
+
+        return prompt
+
+    def _build_comparison_prompt(
+        self,
+        a: Dict,
+        b: Dict,
+        label_a: str,
+        label_b: str,
+        knowledge_text: str = "",
+    ) -> str:
+        """Build the prompt for cycle comparison"""
+
+        def summarize(stats: Dict, label: str) -> str:
+            lines = [f"{label}:"]
+            tr = stats.get('time_range', {})
+            lines.append(f"  Duration: {tr.get('duration_minutes', 0):.1f} min")
+
+            if 'discharge_pressure' in stats:
+                dp = stats['discharge_pressure']
+                lines.append(f"  Peak Pressure: {dp['peak']:.1f} bar, Avg: {dp['avg']:.1f} bar")
+
+            if 'compression_ratio' in stats:
+                cr = stats['compression_ratio']
+                lines.append(f"  Compression Ratio: {cr['avg']:.1f}x (range: {cr['min']:.1f}x - {cr['max']:.1f}x)")
+
+            for key in ['temperature_TT110', 'temperature_TT130']:
+                if key in stats:
+                    t = stats[key]
+                    tag = key.replace('temperature_', '')
+                    lines.append(f"  {tag}: {t['min']:.1f} - {t['peak']:.1f} K (avg {t['avg']:.1f} K)")
+
+            if 'flow' in stats:
+                f = stats['flow']
+                lines.append(f"  Flow: avg {f['avg_flow']:.2f} kg/min, max {f['max_flow']:.2f} kg/min")
+                if 'total_mass_kg' in f:
+                    lines.append(f"  Total Mass: {f['total_mass_kg']:.2f} kg")
+
+            if 'ramp_rate' in stats:
+                r = stats['ramp_rate']
+                lines.append(f"  Ramp Rate: avg {r['avg']:.1f}, max {r['max']:.1f} bar/min")
+
+            if 'motor' in stats:
+                m = stats['motor']
+                lines.append(f"  Motor: peak {m['peak_speed']:.0f} RPM, avg {m['avg_speed']:.0f} RPM")
+
+            return "\n".join(lines)
+
+        summary_a = summarize(a, label_a)
+        summary_b = summarize(b, label_b)
+
+        prompt = f"""Compare these two testing cycles and provide an engineering analysis:
+
+{summary_a}
+
+{summary_b}"""
+
+        if knowledge_text:
+            prompt += f"""
+
+DOMAIN KNOWLEDGE (use this to inform your comparison — describe any matching patterns by name and mechanism):
+{knowledge_text}"""
+
+        prompt += """
+
+Provide a concise comparison (3-5 paragraphs) covering:
+1. Key differences between the two cycles (pressure, temperature, flow, duration)
+2. Likely physical or operational reasons for the differences — describe matching failure patterns by name and physical mechanism
+3. Which cycle performed better and why (considering efficiency, stability, and Phase 1B benchmarks)
+4. Any concerning trends or improvements noted between cycles
+5. Recommendations based on the comparison, with diagnostic reasoning
+
+Be technically precise. Cite exact values from both cycles — do not round or estimate. If sensor trustworthiness notes are provided, factor them into your interpretation. Never use internal codes like FM-XXX or RC-XXX."""
+
+        return prompt

analysis/nl2sql.py

@@ -0,0 +1,217 @@
+"""
+Natural Language Query Parser for Data Explorer
+Uses Claude API to parse engineer queries into structured sensor + time range selections.
+Adapted from clearskies_agent_v1.1/llm_parser.py
+"""
+import json
+from typing import Dict, Optional, List
+from datetime import datetime
+from core import config
+
+
+class NLQueryParser:
+    """Parses natural language queries into structured sensor + time range selections"""
+
+    def __init__(self):
+        self.api_key = config.ANTHROPIC_API_KEY
+        self.api_available = bool(self.api_key and self.api_key != 'your_api_key_here')
+        self.model = "claude-sonnet-4-20250514"
+        self._client = None
+
+    @property
+    def client(self):
+        if self._client is None and self.api_available:
+            import anthropic
+            self._client = anthropic.Anthropic(api_key=self.api_key)
+        return self._client
+
+    def parse(
+        self,
+        user_query: str,
+        available_sensors: List[str],
+    ) -> Optional[Dict]:
+        """
+        Parse a natural language query into structured parameters.
+
+        Args:
+            user_query: Natural language query from the engineer
+            available_sensors: List of available sensor tag names in the database
+
+        Returns:
+            Dict with keys:
+                sensors: List[str] - matched sensor tag names
+                start_time: datetime - query start time
+                end_time: datetime - query end time
+                explanation: str - human-readable interpretation
+            Or None if parsing fails.
+        """
+        if not self.api_available:
+            return None
+
+        static_instructions = self._build_static_instructions(available_sensors)
+        dynamic_query = f'User query: "{user_query}"\n\nReturn ONLY the JSON object, no other text.'
+
+        try:
+            message = self.client.messages.create(
+                model=self.model,
+                max_tokens=1000,
+                system=[
+                    {
+                        "type": "text",
+                        "text": static_instructions,
+                        "cache_control": {"type": "ephemeral"},
+                    }
+                ],
+                messages=[{"role": "user", "content": dynamic_query}],
+            )
+            response_text = message.content[0].text
+            parsed = self._extract_json(response_text)
+
+            if parsed:
+                return self._process_result(parsed, available_sensors)
+            return None
+
+        except Exception as e:
+            return {'error': str(e)}
+
+    def _build_static_instructions(self, available_sensors: List[str]) -> str:
+        """Build the cacheable static instruction block with sensor context.
+
+        This is separated from the dynamic user query so the Anthropic API
+        can cache this large, stable prefix across repeated calls within
+        the same session (5-minute TTL).
+        """
+        # Build sensor reference with descriptions
+        sensor_lines = []
+        for tag_name, info in config.SENSOR_TAGS.items():
+            desc = info.get('description', '')
+            units = info.get('units', '')
+            sensor_lines.append(f"  {tag_name}: {desc} ({units})")
+        sensor_reference = "\n".join(sensor_lines)
+
+        # Build sensor group reference
+        group_lines = []
+        for group_name, tags in config.SENSOR_GROUPS.items():
+            group_lines.append(f"  {group_name}: {', '.join(tags)}")
+        group_reference = "\n".join(group_lines)
+
+        current_date = datetime.now()
+
+        return f"""You are a query parser for a ClearSkies Hydrogen (CSH2) cryopump testing data system. Parse the engineer's natural language query into structured JSON for data retrieval.
+
+Current date/time: {current_date.strftime('%Y-%m-%d %H:%M:%S')}
+Data is available from March 2025 to September 2025.
+
+AVAILABLE SENSORS (tag name: description (units)):
+{sensor_reference}
+
+SENSOR GROUPS (for category-based queries):
+{group_reference}
+
+COMMON ALIASES:
+- "pressure" or "pressures" -> PT130 (Discharge), PT01T (Cryotank), PT110 (Inlet)
+- "temperature" or "temperatures" -> TT110 (Pump Feed Line), TT130 (Discharge)
+- "flow" -> FT140 (Flow Transmitter)
+- "motor" or "speed" or "rpm" -> M130_Speed (Motor Speed)
+- "power" -> AvgPower, PeakPower, PowerConsumption
+- "discharge pressure" -> PT130
+- "inlet pressure" or "supply pressure" -> PT110
+- "tank pressure" or "cryotank pressure" -> PT01T
+- "discharge temperature" -> TT130
+- "feed temperature" or "pump temperature" -> TT110
+- "valve" -> AOV140
+- "density" -> N2Density, H2Density
+- "level" -> LT200
+- "all sensors" or "everything" -> PT130, PT01T, PT110, TT110, TT130, FT140, M130_Speed
+
+Parse queries into a JSON object with these fields:
+{{
+  "sensors": ["PT130", "TT110"],
+  "start_time": "2025-09-25T10:00:00",
+  "end_time": "2025-09-25T14:00:00",
+  "explanation": "Discharge pressure and pump feed temperature from Sept 25, 10 AM to 2 PM"
+}}
+
+RULES:
+- Match sensor names to the available sensors list (case-insensitive)
+- Use the aliases above to resolve common terms like "pressure", "temperature" etc.
+- For relative dates like "yesterday", "last week", calculate based on current date
+- For date-only queries without specific times, use 00:00:00 for start and 23:59:59 for end
+- For "between X and Y" time references, parse both times
+- Use ISO 8601 format for timestamps (YYYY-MM-DDTHH:MM:SS)
+- If a sensor group is mentioned (e.g., "all pressures"), include all sensors from that group
+- The explanation should be a concise human-readable summary of what was parsed
+- If no sensors are explicitly mentioned, try to infer from context, or default to PT130, TT110, FT140
+- If no time range is mentioned, default to the most recent day (today)"""
+
+    def _build_prompt(self, user_query: str, available_sensors: List[str]) -> str:
+        """Build the full Claude prompt (used by fallback path).
+
+        The main parse() method uses _build_static_instructions() + dynamic query
+        separately for prompt caching. This method is kept for backward compatibility.
+        """
+        static = self._build_static_instructions(available_sensors)
+        return f"""{static}
+
+User query: "{user_query}"
+
+Return ONLY the JSON object, no other text."""
+
+    def _extract_json(self, text: str) -> Optional[Dict]:
+        """Extract JSON object from LLM response"""
+        try:
+            start = text.find('{')
+            end = text.rfind('}') + 1
+
+            if start != -1 and end > start:
+                json_str = text[start:end]
+                parsed = json.loads(json_str)
+
+                if 'sensors' in parsed:
+                    return parsed
+
+            return None
+        except json.JSONDecodeError:
+            return None
+
+    def _process_result(self, parsed: Dict, available_sensors: List[str]) -> Optional[Dict]:
+        """Validate and process the parsed result"""
+        try:
+            # Convert time strings to datetime
+            start_time = self._convert_to_datetime(parsed.get('start_time'))
+            end_time = self._convert_to_datetime(parsed.get('end_time'))
+
+            if not start_time or not end_time:
+                return {'error': 'Could not parse time range from query.'}
+
+            # Validate sensors exist in database
+            raw_sensors = parsed.get('sensors', [])
+            valid_sensors = []
+            # Case-insensitive match against available sensors
+            sensor_map = {s.upper(): s for s in available_sensors}
+            for s in raw_sensors:
+                matched = sensor_map.get(s.upper())
+                if matched:
+                    valid_sensors.append(matched)
+
+            if not valid_sensors:
+                return {'error': f'No matching sensors found. Requested: {", ".join(raw_sensors)}'}
+
+            return {
+                'sensors': valid_sensors,
+                'start_time': start_time,
+                'end_time': end_time,
+                'explanation': parsed.get('explanation', ''),
+            }
+
+        except Exception as e:
+            return {'error': f'Processing failed: {e}'}
+
+    def _convert_to_datetime(self, iso_string: Optional[str]) -> Optional[datetime]:
+        """Convert ISO string to datetime object"""
+        if not iso_string:
+            return None
+        try:
+            return datetime.fromisoformat(iso_string)
+        except (ValueError, TypeError):
+            return None

analysis/operations.py

@@ -0,0 +1,657 @@
+"""
+Operation Registry and Dispatcher for Advanced Data Explorer.
+
+All post-processing operations the execution engine can dispatch.
+The LLM QueryPlanner references this registry to build execution plans.
+Operations are whitelisted — no arbitrary code execution.
+"""
+import pandas as pd
+import numpy as np
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+
+from analysis.advanced_analysis import AdvancedAnalyzer
+
+
+# ── Result Dataclass ──────────────────────────────────────────────
+
+@dataclass
+class OperationOutput:
+    """Result of a single operation step."""
+    op_name: str
+    label: str
+    data: Any                                   # Primary result (dict, list, DataFrame)
+    metadata: Dict = field(default_factory=dict) # Stats about the operation
+    exportable_df: Optional[pd.DataFrame] = None # If this step produces downloadable data
+
+
+# ── Operation Registry ────────────────────────────────────────────
+# Each entry describes one whitelisted operation for the LLM prompt.
+
+OPERATION_REGISTRY = {
+    "find_peak_pressure_blocks": {
+        "description": "Find contiguous time blocks where a pressure sensor exceeds a threshold",
+        "params": {
+            "pressure_tag": {"type": "str", "required": True, "description": "Sensor tag (e.g. PT130)"},
+            "threshold_bar": {"type": "float", "required": True, "description": "Pressure threshold in bar"},
+        },
+        "returns": "Dict with blocks list: start_time, end_time, duration, peak, avg for each block",
+    },
+    "detect_constant_periods": {
+        "description": "Find periods where a single sensor value is constant within tolerance for a minimum duration",
+        "params": {
+            "tag": {"type": "str", "required": True, "description": "Sensor tag name"},
+            "tolerance": {"type": "float", "required": False, "default": 0.01},
+            "min_duration_minutes": {"type": "float", "required": False, "default": 2.0},
+        },
+        "returns": "List of constant period dicts: start, end, duration_minutes, value",
+    },
+    "detect_constant_periods_multi": {
+        "description": "Find periods where multiple sensors are simultaneously constant (overlapping constant windows)",
+        "params": {
+            "tags": {"type": "List[str]", "required": True, "description": "Sensor tags that must all be constant"},
+            "tolerance": {"type": "float", "required": False, "default": 0.01},
+            "min_duration_minutes": {"type": "float", "required": False, "default": 2.0},
+        },
+        "returns": "List of overlapping constant period dicts",
+    },
+    "downsample_frequency": {
+        "description": "Reduce data frequency (e.g. 10Hz to 2Hz). Requires raw resolution data.",
+        "params": {
+            "target_hz": {"type": "float", "required": True, "description": "Target frequency in Hz"},
+        },
+        "returns": "Downsampled DataFrame",
+    },
+    "detect_pressure_ramps": {
+        "description": "Detect windows where pressure ramps from one level to another",
+        "params": {
+            "pressure_tag": {"type": "str", "required": True, "description": "Pressure sensor tag"},
+            "start_bar": {"type": "float", "required": True, "description": "Ramp start pressure in bar"},
+            "end_bar": {"type": "float", "required": True, "description": "Ramp end pressure in bar"},
+            "max_ramps": {"type": "int", "required": False, "default": None, "description": "Max ramps to return"},
+        },
+        "returns": "List of ramp dicts: start_time, end_time, start_pressure, peak_pressure, duration_minutes",
+    },
+    "extract_windows": {
+        "description": "Extract sub-DataFrames for each time window from a previous operation's result",
+        "params": {
+            "source": {"type": "str", "required": True, "description": "Must be 'previous_result'"},
+        },
+        "returns": "List of DataFrames, one per detected window",
+    },
+    "filter_by_condition": {
+        "description": "Filter data rows where a sensor meets a condition",
+        "params": {
+            "tag": {"type": "str", "required": True, "description": "Sensor tag"},
+            "operator": {"type": "str", "required": True, "description": "One of: gt, gte, lt, lte, eq"},
+            "value": {"type": "float", "required": True, "description": "Threshold value"},
+        },
+        "returns": "Filtered DataFrame",
+    },
+    "compute_statistics": {
+        "description": "Compute summary statistics (min, max, mean, std, count) for sensors",
+        "params": {
+            "tags": {"type": "List[str]", "required": False, "default": None, "description": "Tags to summarize (default: all)"},
+        },
+        "returns": "Statistics dict per sensor",
+    },
+    "detect_and_analyze_fills": {
+        "description": "Detect fill/test cycles using motor speed, then compute per-fill metrics: kWh/kg, total mass, pump strokes, peak pressure. Can filter by kWh/kg threshold or specific fill ID.",
+        "params": {
+            "kwh_per_kg_threshold": {"type": "float", "required": False, "default": None, "description": "Only return fills where kWh/kg exceeds this"},
+            "fill_id": {"type": "int", "required": False, "default": None, "description": "Analyze only this fill number"},
+            "include_strokes": {"type": "bool", "required": False, "default": True, "description": "Whether to compute stroke count"},
+        },
+        "returns": "List of fill dicts: fill_id, start_time, end_time, duration_min, peak_pressure, avg_flow, total_mass_kg, kwh_per_kg, total_strokes",
+    },
+    "count_pump_strokes": {
+        "description": "Count total pump strokes (motor revolutions) in the time window by integrating RPM over time",
+        "params": {
+            "speed_tag": {"type": "str", "required": False, "default": None, "description": "Motor speed tag (defaults to first available)"},
+        },
+        "returns": "Dict: total_revolutions, avg_rpm, active_minutes, peak_rpm, note",
+    },
+}
+
+
+def get_registry_for_prompt() -> str:
+    """Serialize the operation registry as text for LLM prompt injection."""
+    lines = ["AVAILABLE OPERATIONS:"]
+    for op_name, info in OPERATION_REGISTRY.items():
+        lines.append(f"\n  {op_name}: {info['description']}")
+        lines.append("    Parameters:")
+        for pname, pinfo in info["params"].items():
+            req = "REQUIRED" if pinfo.get("required") else f"optional, default={pinfo.get('default')}"
+            lines.append(f"      {pname} ({pinfo['type']}, {req}): {pinfo.get('description', '')}")
+        lines.append(f"    Returns: {info['returns']}")
+    return "\n".join(lines)
+
+
+# ── Operation Dispatcher ──────────────────────────────────────────
+
+OPERATOR_MAP = {"gt": ">", "gte": ">=", "lt": "<", "lte": "<=", "eq": "=="}
+MOTOR_SPEED_TAGS = ["M130_Speed", "MC130_VFD_Speed", "M130_RPM"]
+
+
+class OperationDispatcher:
+    """Dispatch whitelisted operations against a DataFrame."""
+
+    def __init__(self):
+        self.analyzer = AdvancedAnalyzer()
+
+    def run(
+        self,
+        op_name: str,
+        df: pd.DataFrame,
+        params: Dict,
+        prev_result: Any = None,
+        db_connector=None,
+    ) -> OperationOutput:
+        """Dispatch a single operation by name."""
+        handler = getattr(self, f"_run_{op_name}", None)
+        if handler is None:
+            raise ValueError(f"Unknown operation: {op_name}")
+
+        # Some operations need extra context
+        if op_name in ("detect_and_analyze_fills",):
+            return handler(df, params, db_connector=db_connector)
+        if op_name in ("extract_windows",):
+            return handler(df, params, prev_result=prev_result)
+
+        return handler(df, params)
+
+    # ── Handlers ──────────────────────────────────────────────────
+
+    def _run_find_peak_pressure_blocks(self, df: pd.DataFrame, params: Dict) -> OperationOutput:
+        pressure_tag = params["pressure_tag"]
+        threshold = float(params["threshold_bar"])
+        result = self.analyzer.find_peak_pressure_blocks(df, pressure_tag, threshold)
+
+        # Build exportable table from blocks
+        export_df = None
+        blocks = result.get("blocks", [])
+        if blocks:
+            export_df = pd.DataFrame(blocks)
+
+        return OperationOutput(
+            op_name="find_peak_pressure_blocks",
+            label=f"{pressure_tag} > {threshold} bar",
+            data=result,
+            metadata={"num_blocks": result.get("num_blocks", 0), "total_points": result.get("total_points_above", 0)},
+            exportable_df=export_df,
+        )
+
+    def _run_detect_constant_periods(self, df: pd.DataFrame, params: Dict) -> OperationOutput:
+        tag = params["tag"]
+        tolerance = float(params.get("tolerance", 0.01))
+        min_dur = float(params.get("min_duration_minutes", 2.0))
+        periods = self.analyzer.detect_constant_periods(df, tag, tolerance, min_dur)
+
+        export_df = pd.DataFrame(periods) if periods else None
+
+        return OperationOutput(
+            op_name="detect_constant_periods",
+            label=f"{tag} constant periods (±{tolerance}, ≥{min_dur} min)",
+            data=periods,
+            metadata={"num_periods": len(periods)},
+            exportable_df=export_df,
+        )
+
+    def _run_detect_constant_periods_multi(self, df: pd.DataFrame, params: Dict) -> OperationOutput:
+        tags = params["tags"]
+        tolerance = float(params.get("tolerance", 0.01))
+        min_dur = float(params.get("min_duration_minutes", 2.0))
+
+        # Detect constant periods per tag
+        per_tag_periods = {}
+        for tag in tags:
+            if tag in df.columns:
+                per_tag_periods[tag] = self.analyzer.detect_constant_periods(df, tag, tolerance, min_dur)
+            else:
+                per_tag_periods[tag] = []
+
+        # Find overlapping intervals across all tags
+        overlapping = self._intersect_periods(per_tag_periods, min_dur)
+
+        export_df = pd.DataFrame(overlapping) if overlapping else None
+
+        return OperationOutput(
+            op_name="detect_constant_periods_multi",
+            label=f"Simultaneous constant: {', '.join(tags)} (≥{min_dur} min)",
+            data=overlapping,
+            metadata={"num_overlaps": len(overlapping), "per_tag_counts": {t: len(p) for t, p in per_tag_periods.items()}},
+            exportable_df=export_df,
+        )
+
+    def _intersect_periods(self, per_tag: Dict[str, List[Dict]], min_dur: float) -> List[Dict]:
+        """Intersect constant periods across multiple tags — return only overlapping windows."""
+        tags = list(per_tag.keys())
+        if not tags or any(len(per_tag[t]) == 0 for t in tags):
+            return []
+
+        # Start with first tag's periods
+        current_intervals = [(p["start"], p["end"]) for p in per_tag[tags[0]]]
+
+        # Intersect with each subsequent tag
+        for tag in tags[1:]:
+            other = [(p["start"], p["end"]) for p in per_tag[tag]]
+            current_intervals = self._pairwise_intersect(current_intervals, other)
+            if not current_intervals:
+                return []
+
+        # Filter by minimum duration and build result dicts
+        result = []
+        for start, end in current_intervals:
+            dur_min = (end - start).total_seconds() / 60
+            if dur_min >= min_dur:
+                # Gather each tag's value during this window
+                tag_values = {}
+                for tag in tags:
+                    for p in per_tag[tag]:
+                        if p["start"] <= start and p["end"] >= end:
+                            tag_values[tag] = p["value"]
+                            break
+
+                result.append({
+                    "start": start,
+                    "end": end,
+                    "duration_minutes": dur_min,
+                    "tag_values": tag_values,
+                })
+        return result
+
+    @staticmethod
+    def _pairwise_intersect(intervals_a, intervals_b):
+        """Compute pairwise intersection of two sorted interval lists."""
+        result = []
+        i, j = 0, 0
+        while i < len(intervals_a) and j < len(intervals_b):
+            a_start, a_end = intervals_a[i]
+            b_start, b_end = intervals_b[j]
+            # Overlap
+            start = max(a_start, b_start)
+            end = min(a_end, b_end)
+            if start < end:
+                result.append((start, end))
+            # Advance the interval that ends first
+            if a_end <= b_end:
+                i += 1
+            else:
+                j += 1
+        return result
+
+    def _run_downsample_frequency(self, df: pd.DataFrame, params: Dict) -> OperationOutput:
+        target_hz = float(params["target_hz"])
+
+        if "timestamp" not in df.columns or len(df) < 2:
+            return OperationOutput("downsample_frequency", f"Downsample to {target_hz} Hz", df, {"error": "Insufficient data"})
+
+        # Estimate current frequency
+        sorted_df = df.sort_values("timestamp")
+        dt = sorted_df["timestamp"].diff().dt.total_seconds().dropna()
+        current_hz = 1.0 / dt.median() if dt.median() > 0 else 1.0
+
+        if target_hz >= current_hz:
+            # Already at or below target frequency
+            return OperationOutput(
+                "downsample_frequency", f"Data already at {current_hz:.1f} Hz (target: {target_hz} Hz)",
+                sorted_df, {"current_hz": current_hz, "target_hz": target_hz, "rows_before": len(sorted_df), "rows_after": len(sorted_df)},
+                exportable_df=sorted_df,
+            )
+
+        step = max(1, int(round(current_hz / target_hz)))
+        downsampled = sorted_df.iloc[::step].reset_index(drop=True)
+
+        return OperationOutput(
+            op_name="downsample_frequency",
+            label=f"Downsampled {current_hz:.1f} Hz → {target_hz} Hz",
+            data=downsampled,
+            metadata={"current_hz": current_hz, "target_hz": target_hz, "step": step,
+                       "rows_before": len(sorted_df), "rows_after": len(downsampled)},
+            exportable_df=downsampled,
+        )
+
+    def _run_detect_pressure_ramps(self, df: pd.DataFrame, params: Dict) -> OperationOutput:
+        pressure_tag = params["pressure_tag"]
+        start_bar = float(params["start_bar"])
+        end_bar = float(params["end_bar"])
+        max_ramps = params.get("max_ramps")
+
+        if pressure_tag not in df.columns:
+            return OperationOutput("detect_pressure_ramps", f"Ramps in {pressure_tag}", [],
+                                   {"error": f"Tag {pressure_tag} not found"})
+
+        sorted_df = df[["timestamp", pressure_tag]].dropna(subset=[pressure_tag]).sort_values("timestamp")
+        timestamps = sorted_df["timestamp"].values
+        values = sorted_df[pressure_tag].values
+
+        # State machine: IDLE → RAMPING → COMPLETE
+        ramps = []
+        state = "IDLE"
+        ramp_start_idx = 0
+        ramp_max_val = 0.0
+
+        for i in range(len(values)):
+            if state == "IDLE":
+                # Look for crossing start_bar from below
+                if values[i] >= start_bar * 0.9 and values[i] <= start_bar * 1.3:
+                    state = "RAMPING"
+                    ramp_start_idx = i
+                    ramp_max_val = values[i]
+            elif state == "RAMPING":
+                ramp_max_val = max(ramp_max_val, values[i])
+
+                # Ramp complete: crossed end_bar
+                if values[i] >= end_bar:
+                    ramps.append({
+                        "start_time": pd.Timestamp(timestamps[ramp_start_idx]),
+                        "end_time": pd.Timestamp(timestamps[i]),
+                        "start_pressure": float(values[ramp_start_idx]),
+                        "peak_pressure": float(ramp_max_val),
+                        "duration_minutes": (pd.Timestamp(timestamps[i]) - pd.Timestamp(timestamps[ramp_start_idx])).total_seconds() / 60,
+                    })
+                    state = "IDLE"
+                    continue
+
+                # Ramp aborted: pressure dropped significantly below start
+                if values[i] < start_bar * 0.5:
+                    state = "IDLE"
+
+        if max_ramps and len(ramps) > int(max_ramps):
+            ramps = ramps[:int(max_ramps)]
+
+        export_df = pd.DataFrame(ramps) if ramps else None
+
+        return OperationOutput(
+            op_name="detect_pressure_ramps",
+            label=f"{pressure_tag} ramps {start_bar}→{end_bar} bar",
+            data=ramps,
+            metadata={"num_ramps": len(ramps)},
+            exportable_df=export_df,
+        )
+
+    def _run_extract_windows(self, df: pd.DataFrame, params: Dict, prev_result: Any = None) -> OperationOutput:
+        """Slice DataFrame into sub-DataFrames per detected window from previous operation."""
+        windows = []
+        if isinstance(prev_result, OperationOutput):
+            data = prev_result.data
+            if isinstance(data, list):
+                windows = data
+            elif isinstance(data, dict):
+                windows = data.get("blocks", data.get("ramps", []))
+
+        if not windows:
+            return OperationOutput("extract_windows", "Extract windows", [],
+                                   {"error": "No windows found in previous result"})
+
+        dfs = []
+        labels = []
+        for i, w in enumerate(windows):
+            start = w.get("start_time", w.get("start"))
+            end = w.get("end_time", w.get("end"))
+            if start is None or end is None:
+                continue
+
+            mask = (df["timestamp"] >= pd.Timestamp(start)) & (df["timestamp"] <= pd.Timestamp(end))
+            window_df = df[mask].copy()
+            if not window_df.empty:
+                dfs.append(window_df)
+                labels.append(f"Window {i + 1}")
+
+        return OperationOutput(
+            op_name="extract_windows",
+            label=f"Extracted {len(dfs)} windows",
+            data=dfs,
+            metadata={"num_windows": len(dfs), "labels": labels,
+                       "rows_per_window": [len(d) for d in dfs]},
+            exportable_df=None,  # Multi-window: handled by export_utils
+        )
+
+    def _run_filter_by_condition(self, df: pd.DataFrame, params: Dict) -> OperationOutput:
+        tag = params["tag"]
+        operator = params["operator"]
+        value = float(params["value"])
+
+        if tag not in df.columns:
+            return OperationOutput("filter_by_condition", f"Filter {tag}", df,
+                                   {"error": f"Tag {tag} not found"})
+
+        op_str = OPERATOR_MAP.get(operator)
+        if not op_str:
+            return OperationOutput("filter_by_condition", f"Filter {tag}", df,
+                                   {"error": f"Unknown operator: {operator}. Use: gt, gte, lt, lte, eq"})
+
+        if operator == "gt":
+            mask = df[tag] > value
+        elif operator == "gte":
+            mask = df[tag] >= value
+        elif operator == "lt":
+            mask = df[tag] < value
+        elif operator == "lte":
+            mask = df[tag] <= value
+        else:
+            mask = df[tag] == value
+
+        filtered = df[mask].copy()
+
+        return OperationOutput(
+            op_name="filter_by_condition",
+            label=f"{tag} {op_str} {value}",
+            data=filtered,
+            metadata={"rows_before": len(df), "rows_after": len(filtered)},
+            exportable_df=filtered,
+        )
+
+    def _run_compute_statistics(self, df: pd.DataFrame, params: Dict) -> OperationOutput:
+        tags = params.get("tags")
+        numeric_cols = [c for c in df.columns if c != "timestamp" and pd.api.types.is_numeric_dtype(df[c])]
+        if tags:
+            numeric_cols = [c for c in numeric_cols if c in tags]
+
+        stats = {}
+        for col in numeric_cols:
+            data = df[col].dropna()
+            if len(data) > 0:
+                stats[col] = {
+                    "count": int(len(data)),
+                    "min": float(data.min()),
+                    "max": float(data.max()),
+                    "mean": float(data.mean()),
+                    "std": float(data.std()),
+                }
+
+        export_df = pd.DataFrame(stats).T.reset_index().rename(columns={"index": "Sensor"}) if stats else None
+
+        return OperationOutput(
+            op_name="compute_statistics",
+            label=f"Statistics for {len(numeric_cols)} sensors",
+            data=stats,
+            metadata={"num_sensors": len(stats)},
+            exportable_df=export_df,
+        )
+
+    def _run_detect_and_analyze_fills(self, df: pd.DataFrame, params: Dict, db_connector=None) -> OperationOutput:
+        """Detect fill cycles and compute per-fill metrics."""
+        from analysis.pump_cycle_detector import PumpCycleDetector
+
+        kwh_threshold = params.get("kwh_per_kg_threshold")
+        target_fill_id = params.get("fill_id")
+        include_strokes = params.get("include_strokes", True)
+
+        # Find motor speed tag in DataFrame
+        speed_tag = None
+        for tag in MOTOR_SPEED_TAGS:
+            if tag in df.columns:
+                speed_tag = tag
+                break
+
+        if not speed_tag:
+            return OperationOutput("detect_and_analyze_fills", "Detect fills", [],
+                                   {"error": "No motor speed tag found in data. Include M130_Speed or MC130_VFD_Speed."})
+
+        # Prepare motor speed series for cycle detector
+        motor_df = df[["timestamp", speed_tag]].dropna(subset=[speed_tag]).rename(columns={speed_tag: "value"})
+
+        detector = PumpCycleDetector()
+        raw_cycles = detector.detect_cycles(motor_df)
+
+        if not raw_cycles:
+            return OperationOutput("detect_and_analyze_fills", "Detect fills", [],
+                                   {"error": "No cycles detected in the time range"})
+
+        # Enrich with pressure/flow/temp from the fetched data (no additional DB query needed)
+        enriched = self._enrich_fills_from_df(raw_cycles, df, db_connector)
+
+        # Compute per-fill advanced metrics
+        fill_results = []
+        for c in enriched:
+            fill_dict = {
+                "fill_id": c["cycle_id"],
+                "start_time": c["start_time"],
+                "end_time": c["end_time"],
+                "duration_min": c.get("duration_minutes", 0),
+                "peak_pressure_bar": c.get("peak_pressure", None),
+                "avg_flow_kg_min": c.get("avg_flow", None),
+                "total_mass_kg": c.get("total_mass_kg", None),
+                "kwh_per_kg": None,
+                "total_revolutions": None,
+            }
+
+            # kWh/kg computation
+            if "avg_power_kw" in c and c.get("avg_flow") and c["avg_flow"] > 0:
+                # kWh/kg = AvgPower [kW] * 60 / FT140 [kg/min]
+                kwh_kg = (c["avg_power_kw"] * 60) / c["avg_flow"] if c["avg_flow"] > 0.001 else None
+                fill_dict["kwh_per_kg"] = round(kwh_kg, 4) if kwh_kg is not None else None
+
+            # Stroke count
+            if include_strokes and "avg_rpm" in c and c.get("duration_minutes"):
+                revolutions = c["avg_rpm"] * c["duration_minutes"]
+                fill_dict["total_revolutions"] = int(round(revolutions))
+
+            fill_results.append(fill_dict)
+
+        # Apply filters
+        if target_fill_id is not None:
+            target_id = int(target_fill_id)
+            matched = [f for f in fill_results if f["fill_id"] == target_id]
+            if not matched:
+                available = [f["fill_id"] for f in fill_results]
+                return OperationOutput("detect_and_analyze_fills", f"Fill {target_id}", [],
+                                       {"error": f"Fill {target_id} not found. Available fill IDs: {available}"})
+            fill_results = matched
+
+        if kwh_threshold is not None:
+            threshold = float(kwh_threshold)
+            fill_results = [f for f in fill_results if f.get("kwh_per_kg") is not None and f["kwh_per_kg"] > threshold]
+
+        export_df = pd.DataFrame(fill_results) if fill_results else None
+
+        note = "Revolutions = RPM × minutes. For simplex: strokes = revolutions. For triplex: strokes = 3 × revolutions."
+
+        return OperationOutput(
+            op_name="detect_and_analyze_fills",
+            label=f"Fill analysis ({len(fill_results)} fills)",
+            data=fill_results,
+            metadata={"num_fills": len(fill_results), "note": note},
+            exportable_df=export_df,
+        )
+
+    def _enrich_fills_from_df(self, cycles: List[Dict], df: pd.DataFrame, db_connector) -> List[Dict]:
+        """Enrich cycle dicts with metrics computed from the already-fetched wide DataFrame."""
+        enriched = []
+        for c in cycles:
+            ec = c.copy()
+            mask = (df["timestamp"] >= c["start_time"]) & (df["timestamp"] <= c["end_time"])
+            cdf = df[mask]
+
+            if cdf.empty:
+                enriched.append(ec)
+                continue
+
+            # Peak pressure
+            if "PT130" in cdf.columns:
+                pt130 = cdf["PT130"].dropna()
+                if len(pt130) > 0:
+                    ec["peak_pressure"] = float(pt130.max())
+                    ec["initial_pressure"] = float(pt130.iloc[0])
+
+            # Average flow
+            if "FT140" in cdf.columns:
+                ft140 = cdf["FT140"].dropna()
+                if len(ft140) > 0:
+                    ec["avg_flow"] = float(ft140.mean())
+                    # Total mass via trapezoidal integration
+                    flow_sorted = cdf[["timestamp", "FT140"]].dropna().sort_values("timestamp")
+                    if len(flow_sorted) > 1:
+                        dt_min = flow_sorted["timestamp"].diff().dt.total_seconds().fillna(0) / 60
+                        ec["total_mass_kg"] = float((flow_sorted["FT140"] * dt_min).sum())
+
+            # Average power
+            if "AvgPower" in cdf.columns:
+                power = cdf["AvgPower"].dropna()
+                if len(power) > 0:
+                    ec["avg_power_kw"] = float(power.mean())
+
+            # Motor speed
+            for tag in MOTOR_SPEED_TAGS:
+                if tag in cdf.columns:
+                    speed = cdf[tag].dropna()
+                    if len(speed) > 0:
+                        ec["avg_rpm"] = float(speed.mean())
+                        ec["peak_rpm"] = float(speed.max())
+                        break
+
+            # Peak temperatures
+            for tag in ["TT110", "TT130"]:
+                if tag in cdf.columns:
+                    data = cdf[tag].dropna()
+                    if len(data) > 0:
+                        ec[f"peak_{tag}"] = float(data.max())
+
+            enriched.append(ec)
+        return enriched
+
+    def _run_count_pump_strokes(self, df: pd.DataFrame, params: Dict) -> OperationOutput:
+        """Count total pump revolutions by integrating RPM over time."""
+        speed_tag = params.get("speed_tag")
+
+        if not speed_tag:
+            for tag in MOTOR_SPEED_TAGS:
+                if tag in df.columns:
+                    speed_tag = tag
+                    break
+
+        if not speed_tag or speed_tag not in df.columns:
+            return OperationOutput("count_pump_strokes", "Pump strokes", {},
+                                   {"error": "No motor speed tag found. Include M130_Speed or MC130_VFD_Speed."})
+
+        speed_df = df[["timestamp", speed_tag]].dropna(subset=[speed_tag]).sort_values("timestamp")
+
+        if len(speed_df) < 2:
+            return OperationOutput("count_pump_strokes", "Pump strokes", {},
+                                   {"error": "Insufficient motor speed data"})
+
+        rpm_values = speed_df[speed_tag].values
+        timestamps = speed_df["timestamp"].values
+
+        # Integrate: revolutions = sum(RPM_i × Δt_i) where Δt in minutes
+        dt_minutes = pd.Series(timestamps).diff().dt.total_seconds().fillna(0).values / 60
+        total_revolutions = float(np.sum(rpm_values * dt_minutes))
+        active_mask = rpm_values > 10  # RPM > idle threshold
+        active_minutes = float(np.sum(dt_minutes[active_mask]))
+
+        result = {
+            "total_revolutions": int(round(total_revolutions)),
+            "avg_rpm": float(np.mean(rpm_values[active_mask])) if active_mask.any() else 0,
+            "peak_rpm": float(np.max(rpm_values)) if len(rpm_values) > 0 else 0,
+            "active_minutes": round(active_minutes, 1),
+            "speed_tag_used": speed_tag,
+            "note": "Revolutions = RPM × time. For simplex: strokes = revolutions. For triplex: strokes = 3 × revolutions.",
+        }
+
+        return OperationOutput(
+            op_name="count_pump_strokes",
+            label=f"Pump strokes ({speed_tag})",
+            data=result,
+            metadata={"total_revolutions": result["total_revolutions"]},
+        )

analysis/pump_cycle_detector.py

@@ -0,0 +1,319 @@
+"""
+Testing Cycle Detection Module
+Detects testing operation cycles from motor speed time series data,
+qualifies them by pressure/flow activity, and ranks by significance.
+"""
+import pandas as pd
+import numpy as np
+from typing import List, Dict, Optional
+from datetime import datetime
+from core import config
+
+
+class PumpCycleDetector:
+    """Detect and qualify testing cycles using motor speed state machine + multi-signal qualification.
+
+    Two-stage pipeline:
+      1. Candidate generation: motor speed thresholding finds all motor-on periods
+      2. Qualification: filters out brief jogs/false starts using pressure and flow data
+    """
+
+    def __init__(self):
+        params = config.CYCLE_DETECTION
+        self.idle_threshold = params['idle_threshold']
+        self.min_cycle_seconds = params['min_cycle_seconds']
+        self.smoothing_window = params['smoothing_window']
+        self.max_gap_seconds = params['max_gap_seconds']
+        # Qualification thresholds
+        self.min_peak_pressure = params.get('min_peak_pressure_bar', 50.0)
+        self.min_pressure_rise = params.get('min_pressure_rise_bar', 10.0)
+        self.min_avg_flow = params.get('min_avg_flow_kg_min', 0.05)
+        self.max_cycle_duration_min = params.get('max_cycle_duration_hours', 8.0) * 60
+
+    def detect_cycles(self, motor_speed_df: pd.DataFrame) -> List[Dict]:
+        """
+        Detect testing cycles from motor speed time series.
+
+        Args:
+            motor_speed_df: DataFrame with columns [timestamp, value]
+                            where value is motor speed in RPM
+
+        Returns:
+            List of cycle dicts with keys:
+                cycle_id, start_time, end_time, duration_minutes, peak_speed
+        """
+        if motor_speed_df.empty or len(motor_speed_df) < 10:
+            return []
+
+        df = motor_speed_df.sort_values('timestamp').copy()
+        df['speed_smooth'] = self._smooth_signal(df['value'])
+        df['is_running'] = df['speed_smooth'] > self.idle_threshold
+
+        # Find transitions
+        df['state_change'] = df['is_running'].astype(int).diff().fillna(0)
+
+        # Start events: state_change == 1 (idle -> running)
+        starts = df[df['state_change'] == 1]['timestamp'].tolist()
+        # Stop events: state_change == -1 (running -> idle)
+        stops = df[df['state_change'] == -1]['timestamp'].tolist()
+
+        if not starts and not stops:
+            # Check if entire period is running
+            if df['is_running'].any():
+                return [{
+                    'cycle_id': 1,
+                    'start_time': df['timestamp'].iloc[0],
+                    'end_time': df['timestamp'].iloc[-1],
+                    'duration_minutes': (df['timestamp'].iloc[-1] - df['timestamp'].iloc[0]).total_seconds() / 60,
+                    'peak_speed': df['value'].max(),
+                }]
+            return []
+
+        # Pair starts and stops into cycles
+        cycles = self._pair_transitions(starts, stops, df)
+
+        # Filter by minimum duration
+        cycles = [c for c in cycles if c['duration_seconds'] >= self.min_cycle_seconds]
+
+        # Merge cycles with short gaps between them
+        cycles = self._merge_short_gaps(cycles)
+
+        # Compute peak speed for each cycle
+        for c in cycles:
+            mask = (df['timestamp'] >= c['start_time']) & (df['timestamp'] <= c['end_time'])
+            cycle_data = df[mask]
+            c['peak_speed'] = cycle_data['value'].max() if not cycle_data.empty else 0
+
+        # Assign sequential IDs
+        for i, c in enumerate(cycles, 1):
+            c['cycle_id'] = i
+            c['duration_minutes'] = c['duration_seconds'] / 60
+            del c['duration_seconds']
+
+        return cycles
+
+    def _smooth_signal(self, series: pd.Series) -> pd.Series:
+        """Apply rolling median filter to reduce noise"""
+        return series.rolling(window=self.smoothing_window, center=True, min_periods=1).median()
+
+    def _pair_transitions(
+        self,
+        starts: List[datetime],
+        stops: List[datetime],
+        df: pd.DataFrame,
+    ) -> List[Dict]:
+        """Pair start/stop transitions into cycles"""
+        cycles = []
+
+        # If first data point is already running, prepend a synthetic start
+        if df['is_running'].iloc[0]:
+            starts = [df['timestamp'].iloc[0]] + starts
+
+        # If last data point is still running, append a synthetic stop
+        if df['is_running'].iloc[-1]:
+            stops = stops + [df['timestamp'].iloc[-1]]
+
+        # Match each start with the next stop
+        stop_idx = 0
+        for start in starts:
+            # Find the next stop after this start
+            while stop_idx < len(stops) and stops[stop_idx] <= start:
+                stop_idx += 1
+
+            if stop_idx < len(stops):
+                end = stops[stop_idx]
+                duration = (end - start).total_seconds()
+                cycles.append({
+                    'start_time': start,
+                    'end_time': end,
+                    'duration_seconds': duration,
+                })
+                stop_idx += 1
+
+        return cycles
+
+    def _merge_short_gaps(self, cycles: List[Dict]) -> List[Dict]:
+        """Merge cycles separated by brief motor stops"""
+        if len(cycles) <= 1:
+            return cycles
+
+        merged = [cycles[0].copy()]
+        for c in cycles[1:]:
+            gap = (c['start_time'] - merged[-1]['end_time']).total_seconds()
+            if gap <= self.max_gap_seconds:
+                # Merge: extend the previous cycle
+                merged[-1]['end_time'] = c['end_time']
+                merged[-1]['duration_seconds'] = (
+                    merged[-1]['end_time'] - merged[-1]['start_time']
+                ).total_seconds()
+            else:
+                merged.append(c.copy())
+
+        return merged
+
+    def _qualify_cycle(self, cycle: Dict) -> bool:
+        """Check if a cycle is a meaningful testing event.
+
+        A cycle must show evidence of actual compression (pressure) or flow
+        to qualify. Motor speed and duration alone are insufficient — they
+        only confirm the motor ran, not that meaningful work happened.
+
+        Hard rejects cycles exceeding max_cycle_duration_min (noise spans).
+        """
+        duration_min = cycle.get('duration_minutes', 0) or 0
+
+        # Hard reject: multi-day noise spans masquerading as cycles
+        if duration_min > self.max_cycle_duration_min:
+            return False
+
+        peak_pressure = cycle.get('peak_pressure', 0) or 0
+        initial_pressure = cycle.get('initial_pressure', 0) or 0
+        avg_flow = cycle.get('avg_flow', 0) or 0
+
+        # Criterion 1: Pressure built beyond ambient
+        if peak_pressure > self.min_peak_pressure:
+            return True
+
+        # Criterion 2: Meaningful pressure rise from initial value
+        if initial_pressure > 0 and (peak_pressure - initial_pressure) > self.min_pressure_rise:
+            return True
+
+        # Criterion 3: Flow was delivered
+        if avg_flow > self.min_avg_flow:
+            return True
+
+        return False
+
+    def _sort_and_renumber(self, cycles: List[Dict]) -> List[Dict]:
+        """Sort cycles by peak pressure descending (most significant first),
+        then by duration as tiebreaker. Re-assign sequential cycle_ids."""
+        sorted_cycles = sorted(
+            cycles,
+            key=lambda c: (-(c.get('peak_pressure', 0) or 0), -(c.get('duration_minutes', 0) or 0)),
+        )
+        for i, c in enumerate(sorted_cycles, 1):
+            c['cycle_id'] = i
+        return sorted_cycles
+
+    def enrich_cycle_metadata(
+        self,
+        cycle: Dict,
+        db_connector,
+        tags: List[str] = None,
+    ) -> Dict:
+        """
+        Add peak pressure, peak temp, avg flow to a cycle's metadata.
+
+        Args:
+            cycle: cycle dict with start_time, end_time
+            db_connector: DatabaseConnector instance
+            tags: list of tags to query (defaults to CYCLE_DETAIL_TAGS)
+
+        Returns:
+            Enriched cycle dict with additional metrics
+        """
+        if tags is None:
+            tags = config.CYCLE_DETAIL_TAGS
+
+        df = db_connector.get_sensor_data(
+            tags, cycle['start_time'], cycle['end_time'],
+        )
+
+        if df.empty:
+            return cycle
+
+        enriched = cycle.copy()
+
+        # Peak discharge pressure
+        pt130 = df[df['tag_name'] == 'PT130']
+        if not pt130.empty:
+            enriched['peak_pressure'] = pt130['value'].max()
+
+        # Peak temperatures
+        for tag in ['TT110', 'TT130']:
+            data = df[df['tag_name'] == tag]
+            if not data.empty:
+                enriched[f'peak_{tag}'] = data['value'].max()
+
+        # Average flow
+        ft140 = df[df['tag_name'] == 'FT140']
+        if not ft140.empty:
+            enriched['avg_flow'] = ft140['value'].mean()
+
+        return enriched
+
+    def batch_enrich_cycles(
+        self,
+        cycles: List[Dict],
+        db_connector,
+        tags: List[str] = None,
+        qualify: bool = True,
+    ) -> List[Dict]:
+        """
+        Enrich ALL cycles with metadata using a single DB query,
+        then optionally qualify and rank them.
+
+        Args:
+            cycles: list of cycle dicts with start_time, end_time
+            db_connector: DatabaseConnector instance
+            tags: list of tags to query (defaults to key enrichment tags)
+            qualify: if True, filter out non-meaningful cycles and sort by significance
+
+        Returns:
+            List of enriched (and optionally qualified + sorted) cycle dicts
+        """
+        if not cycles:
+            return cycles
+
+        if tags is None:
+            tags = ['PT130', 'TT110', 'TT130', 'FT140']
+
+        # Single query covering the full time span of all cycles
+        earliest = min(c['start_time'] for c in cycles)
+        latest = max(c['end_time'] for c in cycles)
+
+        df = db_connector.get_sensor_data(
+            tags, earliest, latest,
+            table_override='procdatafloattable_utc_15sec',
+        )
+
+        if df.empty:
+            return cycles
+
+        enriched = []
+        for c in cycles:
+            ec = c.copy()
+            mask = (df['timestamp'] >= c['start_time']) & (df['timestamp'] <= c['end_time'])
+            cycle_df = df[mask]
+
+            if cycle_df.empty:
+                enriched.append(ec)
+                continue
+
+            # Peak discharge pressure
+            pt130 = cycle_df[cycle_df['tag_name'] == 'PT130']
+            if not pt130.empty:
+                pt130_sorted = pt130.sort_values('timestamp')
+                ec['peak_pressure'] = pt130_sorted['value'].max()
+                ec['initial_pressure'] = pt130_sorted['value'].iloc[0]
+
+            # Peak temperatures
+            for tag in ['TT110', 'TT130']:
+                data = cycle_df[cycle_df['tag_name'] == tag]
+                if not data.empty:
+                    ec[f'peak_{tag}'] = data['value'].max()
+
+            # Average flow
+            ft140 = cycle_df[cycle_df['tag_name'] == 'FT140']
+            if not ft140.empty:
+                ec['avg_flow'] = ft140['value'].mean()
+
+            enriched.append(ec)
+
+        # Qualification: filter out non-meaningful cycles
+        if qualify:
+            qualified = [c for c in enriched if self._qualify_cycle(c)]
+            # Sort by significance and re-number
+            return self._sort_and_renumber(qualified) if qualified else []
+
+        return enriched

analysis/query_planner.py

@@ -0,0 +1,459 @@
+"""
+LLM-Powered Query Planner for Advanced Data Explorer.
+
+Classifies user queries (FETCH / ANALYZE / EXPORT), decomposes complex ones
+into structured ExecutionPlan JSON referencing the whitelisted operation registry.
+"""
+import json
+from typing import Dict, List, Optional
+from datetime import datetime
+from core import config
+from analysis.operations import get_registry_for_prompt
+
+
+SYSTEM_PROMPT = """You are a query planner for a cryogenic hydrogen pump testing data system (CSH2 MURPHY). Your job is to decompose an engineer's natural language query into a structured execution plan.
+
+You classify queries into three types:
+- FETCH: Simple data retrieval (sensors + time range, no post-processing). Use for "show me", "plot", "display" type queries.
+- ANALYZE: Data retrieval + one or more analysis operations. Use for "find", "identify", "detect", "count", "calculate" queries.
+- EXPORT: Data retrieval + transformation + CSV export. Use for "export", "download", "save" queries with transformations.
+
+CRITICAL RULES:
+1. You MUST output valid JSON matching the ExecutionPlan schema below. No other text.
+2. You MUST only use operations from the AVAILABLE_OPERATIONS list.
+3. You MUST NOT generate arbitrary SQL, Python code, or operations not in the registry.
+4. For FETCH queries, set operations to an empty array [].
+5. Always include the correct sensors needed for each operation in data_requirements.sensors.
+6. For fill/cycle analysis, always include motor speed tags (M130_Speed, MC130_VFD_Speed), PT130, FT140, and AvgPower.
+7. Choose resolution wisely:
+   - "raw": Only for sub-second analysis or frequency reduction from 10Hz. MAX 1 HOUR time range.
+   - "1sec": For detailed analysis within a single day.
+   - "15sec": For multi-day or full-range analysis.
+   - "auto": Let the system decide based on time range duration.
+
+ExecutionPlan JSON schema:
+{
+  "query_type": "FETCH | ANALYZE | EXPORT",
+  "explanation": "Human-readable summary of what will happen",
+  "data_requirements": {
+    "sensors": ["PT130", "TT110"],
+    "start_time": "YYYY-MM-DDTHH:MM:SS",
+    "end_time": "YYYY-MM-DDTHH:MM:SS",
+    "resolution": "raw | 1sec | 15sec | auto"
+  },
+  "operations": [
+    {
+      "op": "operation_name_from_registry",
+      "params": { ... },
+      "label": "Human-readable step description"
+    }
+  ],
+  "export": {
+    "enabled": true,
+    "filename_hint": "descriptive_name"
+  }
+}
+"""
+
+
+EXAMPLES = """
+WORKED EXAMPLES:
+
+Example 1 — Query: "Find time blocks where PT130 exceeded 900 bar"
+{
+  "query_type": "ANALYZE",
+  "explanation": "Find contiguous time blocks where discharge pressure PT130 exceeded 900 bar across the full data range",
+  "data_requirements": {
+    "sensors": ["PT130"],
+    "start_time": "2025-03-14T00:00:00",
+    "end_time": "2025-09-25T23:59:59",
+    "resolution": "15sec"
+  },
+  "operations": [
+    {
+      "op": "find_peak_pressure_blocks",
+      "params": {"pressure_tag": "PT130", "threshold_bar": 900.0},
+      "label": "Find time blocks where PT130 > 900 bar"
+    }
+  ],
+  "export": {"enabled": true, "filename_hint": "PT130_above_900bar"}
+}
+
+Example 2 — Query: "Find time blocks where both AOV140 and MC130 were constant for 5 minutes"
+{
+  "query_type": "ANALYZE",
+  "explanation": "Find periods where both AOV140 (valve) and MC130_VFD_Speed (motor) were simultaneously constant for at least 5 minutes",
+  "data_requirements": {
+    "sensors": ["AOV140", "MC130_VFD_Speed"],
+    "start_time": "2025-03-14T00:00:00",
+    "end_time": "2025-09-25T23:59:59",
+    "resolution": "15sec"
+  },
+  "operations": [
+    {
+      "op": "detect_constant_periods_multi",
+      "params": {"tags": ["AOV140", "MC130_VFD_Speed"], "tolerance": 0.01, "min_duration_minutes": 5.0},
+      "label": "Find overlapping constant periods for AOV140 and MC130_VFD_Speed"
+    }
+  ],
+  "export": {"enabled": true, "filename_hint": "constant_AOV140_MC130"}
+}
+
+Example 3 — Query: "Export PT130, TT110, FT140 at 2Hz as CSV for Sep 25 10am-11am"
+{
+  "query_type": "EXPORT",
+  "explanation": "Export PT130, TT110, FT140 at 2Hz (downsampled from 10Hz raw data) for Sep 25 10-11am",
+  "data_requirements": {
+    "sensors": ["PT130", "TT110", "FT140"],
+    "start_time": "2025-09-25T10:00:00",
+    "end_time": "2025-09-25T11:00:00",
+    "resolution": "raw"
+  },
+  "operations": [
+    {
+      "op": "downsample_frequency",
+      "params": {"target_hz": 2.0},
+      "label": "Downsample from 10Hz to 2Hz"
+    }
+  ],
+  "export": {"enabled": true, "filename_hint": "PT130_TT110_FT140_2Hz"}
+}
+
+Example 4 — Query: "Export the 3 testing windows May 5-6 where PT130 ramped from 100 to 800 bar"
+{
+  "query_type": "EXPORT",
+  "explanation": "Find 3 testing windows in May 5-6 where PT130 ramped from 100 to 800 bar, export each window's data",
+  "data_requirements": {
+    "sensors": ["PT130", "TT110", "TT130", "FT140", "M130_Speed", "AOV140"],
+    "start_time": "2025-05-05T00:00:00",
+    "end_time": "2025-05-06T23:59:59",
+    "resolution": "1sec"
+  },
+  "operations": [
+    {
+      "op": "detect_pressure_ramps",
+      "params": {"pressure_tag": "PT130", "start_bar": 100.0, "end_bar": 800.0, "max_ramps": 3},
+      "label": "Detect pressure ramps from 100 to 800 bar"
+    },
+    {
+      "op": "extract_windows",
+      "params": {"source": "previous_result"},
+      "label": "Extract data for each ramp window"
+    }
+  ],
+  "export": {"enabled": true, "filename_hint": "LN2_ramps_100_800bar"}
+}
+
+Example 5 — Query: "Identify fills where kWh per kg exceeded 0.6"
+{
+  "query_type": "ANALYZE",
+  "explanation": "Detect all testing fills, compute kWh/kg for each, return those exceeding 0.6 kWh/kg",
+  "data_requirements": {
+    "sensors": ["M130_Speed", "MC130_VFD_Speed", "PT130", "FT140", "AvgPower", "TT110", "TT130"],
+    "start_time": "2025-03-14T00:00:00",
+    "end_time": "2025-09-25T23:59:59",
+    "resolution": "15sec"
+  },
+  "operations": [
+    {
+      "op": "detect_and_analyze_fills",
+      "params": {"kwh_per_kg_threshold": 0.6, "include_strokes": false},
+      "label": "Detect fills and filter by kWh/kg > 0.6"
+    }
+  ],
+  "export": {"enabled": true, "filename_hint": "fills_above_0.6_kwhkg"}
+}
+
+Example 6 — Query: "In Fill 3, what was the total number of pump strokes?"
+{
+  "query_type": "ANALYZE",
+  "explanation": "Detect fills, find Fill 3, compute its total pump strokes from motor RPM",
+  "data_requirements": {
+    "sensors": ["M130_Speed", "MC130_VFD_Speed", "PT130", "FT140", "AvgPower"],
+    "start_time": "2025-03-14T00:00:00",
+    "end_time": "2025-09-25T23:59:59",
+    "resolution": "15sec"
+  },
+  "operations": [
+    {
+      "op": "detect_and_analyze_fills",
+      "params": {"fill_id": 3, "include_strokes": true},
+      "label": "Find Fill 3 and compute pump strokes"
+    }
+  ],
+  "export": {"enabled": false}
+}
+
+Example 7 — Query: "Between Sep 24 15:00 and 18:00, total pump strokes?"
+{
+  "query_type": "ANALYZE",
+  "explanation": "Count total pump revolutions between Sep 24 15:00 and 18:00 UTC",
+  "data_requirements": {
+    "sensors": ["M130_Speed", "MC130_VFD_Speed"],
+    "start_time": "2025-09-24T15:00:00",
+    "end_time": "2025-09-24T18:00:00",
+    "resolution": "1sec"
+  },
+  "operations": [
+    {
+      "op": "count_pump_strokes",
+      "params": {},
+      "label": "Count total pump revolutions in 3-hour window"
+    }
+  ],
+  "export": {"enabled": false}
+}
+"""
+
+
+class QueryPlanner:
+    """LLM-powered query classification and decomposition into ExecutionPlan JSON."""
+
+    def __init__(self):
+        self.api_key = config.ANTHROPIC_API_KEY
+        self.api_available = bool(self.api_key and self.api_key != 'your_api_key_here')
+        self.model = "claude-sonnet-4-20250514"
+        self._client = None
+
+    @property
+    def client(self):
+        if self._client is None and self.api_available:
+            import anthropic
+            self._client = anthropic.Anthropic(api_key=self.api_key)
+        return self._client
+
+    def plan(self, user_query: str, available_sensors: List[str]) -> Optional[Dict]:
+        """
+        Decompose a natural language query into a structured execution plan.
+
+        Uses Anthropic prompt caching: the system prompt and static context
+        (sensor catalog, operation registry, worked examples) are cached for
+        5 minutes, so repeated queries only pay for the dynamic user query.
+
+        Returns:
+            Dict (ExecutionPlan) or dict with 'error' key on failure.
+        """
+        if not self.api_available:
+            return {"error": "Claude API key not configured."}
+
+        static_context = self._build_static_context(available_sensors)
+        dynamic_query = f'User query: "{user_query}"\n\nReturn ONLY the JSON execution plan. No other text.'
+
+        try:
+            message = self.client.messages.create(
+                model=self.model,
+                max_tokens=2000,
+                system=[
+                    {
+                        "type": "text",
+                        "text": SYSTEM_PROMPT,
+                        "cache_control": {"type": "ephemeral"},
+                    }
+                ],
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": static_context,
+                                "cache_control": {"type": "ephemeral"},
+                            },
+                            {
+                                "type": "text",
+                                "text": dynamic_query,
+                            },
+                        ],
+                    }
+                ],
+            )
+            response_text = message.content[0].text
+            plan = self._extract_json(response_text)
+
+            if plan:
+                validation = self._validate_plan(plan, available_sensors)
+                if validation:
+                    return {"error": validation, "raw_plan": plan}
+                return self._process_plan(plan, available_sensors)
+
+            # Fallback: try V1 parser for simple queries
+            return self._fallback_parse(user_query, available_sensors)
+
+        except Exception as e:
+            return {"error": f"Planning failed: {e}"}
+
+    def _build_static_context(self, available_sensors: List[str]) -> str:
+        """Build the cacheable static context block.
+
+        Contains sensor catalog, groups, aliases, operation registry, and
+        worked examples. This is ~25-30KB of stable text that changes only
+        when sensors or operations are added — ideal for Anthropic's prompt
+        caching (5-minute TTL, 90% cost reduction on cache hit).
+        """
+        # Sensor reference with descriptions
+        sensor_lines = []
+        for tag_name, info in config.SENSOR_TAGS.items():
+            desc = info.get("description", "")
+            units = info.get("units", "")
+            sensor_lines.append(f"  {tag_name}: {desc} ({units})")
+        sensor_reference = "\n".join(sensor_lines)
+
+        # Sensor group reference
+        group_lines = []
+        for group_name, tags in config.SENSOR_GROUPS.items():
+            group_lines.append(f"  {group_name}: {', '.join(tags)}")
+        group_reference = "\n".join(group_lines)
+
+        # Operation registry
+        registry_text = get_registry_for_prompt()
+
+        current_date = datetime.now()
+
+        return f"""Current date/time: {current_date.strftime('%Y-%m-%d %H:%M:%S')}
+Data is available from March 14, 2025 to September 25, 2025.
+
+AVAILABLE SENSORS (tag name: description (units)):
+{sensor_reference}
+
+SENSOR GROUPS:
+{group_reference}
+
+COMMON ALIASES:
+- "pressure" or "pressures" -> PT130 (Discharge), PT01T (Cryotank), PT110 (Inlet)
+- "temperature" or "temperatures" -> TT110 (Pump Feed Line), TT130 (Discharge)
+- "flow" -> FT140 (Flow Transmitter)
+- "motor" or "speed" or "rpm" -> M130_Speed (Motor Speed)
+- "power" -> AvgPower, PeakPower, PowerConsumption
+- "discharge pressure" -> PT130
+- "inlet pressure" or "supply pressure" -> PT110
+- "tank pressure" or "cryotank pressure" -> PT01T
+- "discharge temperature" -> TT130
+- "feed temperature" or "pump temperature" -> TT110
+- "valve" -> AOV140
+- "fill" or "fills" or "test cycle" -> requires detect_and_analyze_fills operation
+- "strokes" or "pump strokes" or "revolutions" -> requires count_pump_strokes or detect_and_analyze_fills
+- "efficiency" or "kWh/kg" or "specific energy" -> requires detect_and_analyze_fills with AvgPower + FT140
+
+{registry_text}
+
+{EXAMPLES}"""
+
+    def _build_prompt(self, user_query: str, available_sensors: List[str]) -> str:
+        """Build the full user prompt (used by fallback path).
+
+        The main plan() method uses _build_static_context() + dynamic query
+        separately for prompt caching. This method is kept for backward
+        compatibility with the fallback parser.
+        """
+        static = self._build_static_context(available_sensors)
+        return f"""{static}
+
+User query: "{user_query}"
+
+Return ONLY the JSON execution plan. No other text."""
+
+    def _extract_json(self, text: str) -> Optional[Dict]:
+        """Extract JSON object from LLM response."""
+        try:
+            start = text.find("{")
+            end = text.rfind("}") + 1
+            if start != -1 and end > start:
+                json_str = text[start:end]
+                return json.loads(json_str)
+            return None
+        except json.JSONDecodeError:
+            return None
+
+    def _validate_plan(self, plan: Dict, available_sensors: List[str]) -> Optional[str]:
+        """Validate plan structure. Returns error string or None if valid."""
+        # Check required top-level fields
+        if "query_type" not in plan:
+            return "Missing 'query_type' field"
+        if plan["query_type"] not in ("FETCH", "ANALYZE", "EXPORT"):
+            return f"Invalid query_type: {plan['query_type']}"
+        if "data_requirements" not in plan:
+            return "Missing 'data_requirements' field"
+
+        dr = plan["data_requirements"]
+        if "sensors" not in dr or not dr["sensors"]:
+            return "No sensors specified"
+        if "start_time" not in dr or "end_time" not in dr:
+            return "Missing start_time or end_time"
+
+        # Validate resolution
+        resolution = dr.get("resolution", "auto")
+        if resolution not in ("raw", "1sec", "15sec", "auto"):
+            return f"Invalid resolution: {resolution}. Use: raw, 1sec, 15sec, auto"
+
+        # Safety: raw table time range limit
+        if resolution == "raw":
+            try:
+                start = datetime.fromisoformat(dr["start_time"])
+                end = datetime.fromisoformat(dr["end_time"])
+                duration_h = (end - start).total_seconds() / 3600
+                if duration_h > 1.0:
+                    return f"Raw resolution limited to 1 hour. Requested {duration_h:.1f} hours. Use '1sec' or '15sec' for longer ranges."
+            except (ValueError, TypeError):
+                pass
+
+        # Validate operations exist in registry
+        from analysis.operations import OPERATION_REGISTRY
+        for op in plan.get("operations", []):
+            if op.get("op") not in OPERATION_REGISTRY:
+                known = ", ".join(OPERATION_REGISTRY.keys())
+                return f"Unknown operation: '{op['op']}'. Available: {known}"
+
+        return None
+
+    def _process_plan(self, plan: Dict, available_sensors: List[str]) -> Dict:
+        """Process and clean up the plan: resolve sensors, parse datetimes."""
+        dr = plan.get("data_requirements", {})
+
+        # Validate sensors against available list (case-insensitive)
+        sensor_map = {s.upper(): s for s in available_sensors}
+        valid_sensors = []
+        for s in dr.get("sensors", []):
+            matched = sensor_map.get(s.upper())
+            if matched:
+                valid_sensors.append(matched)
+
+        if not valid_sensors:
+            return {"error": f"No matching sensors found. Requested: {dr.get('sensors', [])}"}
+
+        # Parse datetimes
+        try:
+            start_time = datetime.fromisoformat(dr["start_time"])
+            end_time = datetime.fromisoformat(dr["end_time"])
+        except (ValueError, TypeError, KeyError) as e:
+            return {"error": f"Invalid time format: {e}"}
+
+        # Clean up and return
+        plan["data_requirements"]["sensors"] = valid_sensors
+        plan["data_requirements"]["start_time"] = start_time
+        plan["data_requirements"]["end_time"] = end_time
+        plan["data_requirements"]["resolution"] = dr.get("resolution", "auto")
+
+        return plan
+
+    def _fallback_parse(self, user_query: str, available_sensors: List[str]) -> Optional[Dict]:
+        """Fallback: attempt to parse as simple FETCH query via V1 NLQueryParser."""
+        try:
+            from analysis.nl2sql import NLQueryParser
+            parser = NLQueryParser()
+            result = parser.parse(user_query, available_sensors)
+            if result and "error" not in result:
+                return {
+                    "query_type": "FETCH",
+                    "explanation": result.get("explanation", ""),
+                    "data_requirements": {
+                        "sensors": result["sensors"],
+                        "start_time": result["start_time"],
+                        "end_time": result["end_time"],
+                        "resolution": "auto",
+                    },
+                    "operations": [],
+                    "export": {"enabled": False},
+                }
+            return result  # Pass through error
+        except Exception as e:
+            return {"error": f"Fallback parse failed: {e}"}

analysis/result_interpreter.py

@@ -0,0 +1,205 @@
+"""
+Post-Execution Result Interpreter — "Murphy's Take"
+
+After the Advanced Explorer executes an analytical plan and produces raw
+tables/metrics, this module calls the LLM to generate a plain-English
+interpretation grounded in cryogenic physics context.
+"""
+import pandas as pd
+from typing import Optional
+from core import config
+from analysis.llm_analyzer import MURPHY_SYSTEM_PROMPT, sanitize_llm_output
+
+
+class ResultInterpreter:
+    """Generate plain-English interpretation of Advanced Explorer results.
+
+    Uses the shared Murphy system prompt with Anthropic prompt caching.
+    The system prompt is cached for 5 minutes across repeated calls,
+    so interpreting multiple query results in a session is fast.
+    """
+
+    def __init__(self):
+        self.api_key = config.ANTHROPIC_API_KEY
+        self.api_available = bool(self.api_key and self.api_key != 'your_api_key_here')
+        self.model = "claude-sonnet-4-20250514"
+        self._client = None
+
+    @property
+    def client(self):
+        if self._client is None and self.api_available:
+            import anthropic
+            self._client = anthropic.Anthropic(api_key=self.api_key)
+        return self._client
+
+    def interpret(self, user_query: str, result) -> str:
+        """Generate Murphy's interpretation of execution results.
+
+        Args:
+            user_query: The original natural language query from the user.
+            result: An ExecutionResult from the execution engine.
+
+        Returns:
+            Plain-English interpretation string, or an error message.
+        """
+        if not self.api_available:
+            return "LLM interpretation unavailable. Add ANTHROPIC_API_KEY to .env."
+
+        prompt = self._build_interpretation_prompt(user_query, result)
+
+        try:
+            message = self.client.messages.create(
+                model=self.model,
+                max_tokens=1500,
+                system=[
+                    {
+                        "type": "text",
+                        "text": MURPHY_SYSTEM_PROMPT,
+                        "cache_control": {"type": "ephemeral"},
+                    }
+                ],
+                messages=[{"role": "user", "content": prompt}],
+            )
+            return sanitize_llm_output(message.content[0].text)
+        except Exception as e:
+            return f"Interpretation failed: {e}"
+
+    def _build_interpretation_prompt(self, user_query: str, result) -> str:
+        """Build the prompt from execution results.
+
+        Serializes operation results compactly — key metrics, first N rows,
+        summary stats — to keep token usage reasonable while giving the LLM
+        enough context for a physics-grounded interpretation.
+        """
+        sections = []
+
+        # Header
+        sections.append(f'The engineer asked: "{user_query}"')
+        sections.append(f"Query type: {result.query_type}")
+        sections.append(f"Plan explanation: {result.explanation}")
+
+        # Data context
+        sections.append(
+            f"\nData fetched: {result.row_count:,} rows from {result.table_used or 'unknown table'}"
+        )
+
+        # Source data summary (compact)
+        if result.source_data is not None and not result.source_data.empty:
+            src = result.source_data
+            if "timestamp" in src.columns:
+                ts = src["timestamp"]
+                sections.append(
+                    f"Time range: {ts.min()} to {ts.max()}"
+                )
+            numeric_cols = [
+                c for c in src.columns
+                if c != "timestamp" and pd.api.types.is_numeric_dtype(src[c])
+            ]
+            if numeric_cols:
+                stats_lines = []
+                for col in numeric_cols[:8]:  # Cap at 8 sensors
+                    col_data = src[col].dropna()
+                    if len(col_data) > 0:
+                        stats_lines.append(
+                            f"  {col}: min={col_data.min():.3f}, "
+                            f"max={col_data.max():.3f}, "
+                            f"mean={col_data.mean():.3f}, "
+                            f"std={col_data.std():.3f}"
+                        )
+                if stats_lines:
+                    sections.append("Source data summary:\n" + "\n".join(stats_lines))
+
+        # Operation results (compact serialization)
+        for i, op_result in enumerate(result.operation_results):
+            op_section = [f"\n--- Step {i + 1}: {op_result.label} ---"]
+
+            if op_result.metadata.get("error"):
+                op_section.append(f"  ERROR: {op_result.metadata['error']}")
+                sections.append("\n".join(op_section))
+                continue
+
+            # Key metadata (non-error)
+            meta = {k: v for k, v in op_result.metadata.items() if k != "error"}
+            if meta:
+                for k, v in meta.items():
+                    op_section.append(f"  {k}: {v}")
+
+            data = op_result.data
+
+            # Dict result (pump strokes, statistics, blocks summary)
+            if isinstance(data, dict):
+                for k, v in data.items():
+                    if isinstance(v, (int, float, str, bool)):
+                        op_section.append(f"  {k}: {v}")
+                    elif isinstance(v, list) and len(v) > 0:
+                        op_section.append(f"  {k}: {len(v)} items")
+                        # Show first few items if they're dicts
+                        if isinstance(v[0], dict):
+                            for item in v[:5]:
+                                op_section.append(f"    {item}")
+
+            # List-of-dicts result (fills, periods, ramps)
+            elif isinstance(data, list) and data and isinstance(data[0], dict):
+                op_section.append(f"  Found {len(data)} results")
+                # Show first 10 rows
+                for row in data[:10]:
+                    row_str = ", ".join(
+                        f"{k}={v}" for k, v in row.items()
+                    )
+                    op_section.append(f"    {row_str}")
+                if len(data) > 10:
+                    op_section.append(f"    ... and {len(data) - 10} more")
+
+            # List-of-DataFrames result (extract_windows)
+            elif isinstance(data, list) and data and isinstance(data[0], pd.DataFrame):
+                op_section.append(f"  Extracted {len(data)} windows")
+                for j, window_df in enumerate(data[:5]):
+                    op_section.append(
+                        f"    Window {j + 1}: {len(window_df)} rows, "
+                        f"cols: {', '.join(window_df.columns[:6])}"
+                    )
+
+            # Single DataFrame result
+            elif isinstance(data, pd.DataFrame):
+                op_section.append(f"  DataFrame: {len(data)} rows × {len(data.columns)} cols")
+                numeric = [
+                    c for c in data.columns
+                    if c != "timestamp" and pd.api.types.is_numeric_dtype(data[c])
+                ]
+                for col in numeric[:5]:
+                    col_data = data[col].dropna()
+                    if len(col_data) > 0:
+                        op_section.append(
+                            f"    {col}: min={col_data.min():.3f}, "
+                            f"max={col_data.max():.3f}, "
+                            f"mean={col_data.mean():.3f}"
+                        )
+
+            sections.append("\n".join(op_section))
+
+        # Warnings
+        if result.warnings:
+            sections.append("\nWarnings: " + "; ".join(result.warnings))
+
+        # Errors
+        if result.errors:
+            sections.append("\nErrors: " + "; ".join(result.errors))
+
+        # Benchmarks reference
+        sections.append("""
+REFERENCE BENCHMARKS (CSH2 Phase 1B):
+- Specific energy: 0.26 kWh/kg (vs 4.5-5 kWh/kg conventional)
+- Flow rate: 1.13-1.25 kg/min at 65% motor power
+- Peak pressure: 370 bar achieved
+- Delivered temperature: 55K minimum
+- Uptime: 100% across 6 fills""")
+
+        # Final instruction
+        sections.append("""
+Based on the above results, provide Murphy's interpretation in 3-5 concise sentences:
+1. What do the results mean in physical/engineering terms?
+2. Flag anything unusual or noteworthy.
+3. Compare to Phase 1B benchmarks where applicable.
+Be direct and technical. Focus on the "so what" — what should the engineer take away from these results.""")
+
+        return "\n".join(sections)

app.py

@@ -0,0 +1,87 @@
+"""
+CSH2 Web Analytics Dashboard — DELPHI
+Main entry point with multi-page navigation
+"""
+import streamlit as st
+import base64
+from pathlib import Path
+
+st.set_page_config(
+    page_title="CSH2 // DELPHI",
+    page_icon="⚙️",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+from ui.styles import inject_custom_css
+from core.db_connector import get_db_connector
+from ui.components import system_status_footer
+
+# Inject HUD theme CSS
+inject_custom_css()
+
+# Initialize DB connection (cached as singleton)
+db = get_db_connector()
+
+# Store DB connector in session state for access from pages
+if 'db' not in st.session_state:
+    st.session_state.db = db
+
+
+@st.cache_data
+def _get_logo_base64():
+    """Load logo and encode as base64 for inline display"""
+    logo_path = Path(__file__).parent / "assets" / "csh2_logo.jpeg"
+    if not logo_path.exists():
+        return None
+    with open(logo_path, "rb") as f:
+        return base64.b64encode(f.read()).decode()
+
+
+@st.cache_data(ttl=3600)
+def _cached_time_range():
+    """Cache the data time range (quasi-static, 1hr TTL)"""
+    _db = get_db_connector()
+    return _db.get_time_range()
+
+
+# Sidebar branding
+with st.sidebar:
+    # Logo with CSS filter for dark background
+    logo_b64 = _get_logo_base64()
+    if logo_b64:
+        st.markdown(f"""
+        <div style="text-align: center; margin-bottom: 0.5rem; padding-top: 0.5rem;">
+            <img src="data:image/jpeg;base64,{logo_b64}"
+                 style="width: 120px; filter: invert(0.85) sepia(0.3) saturate(2) hue-rotate(15deg) brightness(1.1);" />
+        </div>
+        """, unsafe_allow_html=True)
+
+    st.markdown(
+        '<div style="text-align: center; color: #D4A04A; font-size: 0.7rem; letter-spacing: 2px; '
+        'text-transform: uppercase; margin-bottom: 12px;">PUMP ANALYTICS</div>',
+        unsafe_allow_html=True,
+    )
+
+    # System status
+    earliest, latest = _cached_time_range()
+    system_status_footer(
+        sensor_count=len(db.tag_cache),
+        data_start=earliest.strftime('%Y-%m-%d') if earliest else 'N/A',
+        data_end=latest.strftime('%Y-%m-%d') if latest else 'N/A',
+        connected=True,
+    )
+
+    st.markdown('<div style="height: 8px;"></div>', unsafe_allow_html=True)
+
+# Page navigation
+data_explorer = st.Page("pages/1_data_explorer.py", title="Data Explorer", default=True)
+pump_cycles = st.Page("pages/2_pump_cycles.py", title="Testing Cycles")
+cycle_detail = st.Page("pages/3_cycle_detail.py", title="Cycle Detail")
+variation_analysis = st.Page("pages/4_variation_analysis.py", title="Variation Analysis")
+cycle_comparison = st.Page("pages/5_cycle_comparison.py", title="Cycle Comparison")
+advanced_explorer = st.Page("pages/6_advanced_explorer.py", title="Advanced Data Explorer")
+search = st.Page("pages/7_search.py", title="Search")
+
+pg = st.navigation([data_explorer, advanced_explorer, pump_cycles, cycle_detail, variation_analysis, cycle_comparison, search])
+pg.run()

core/cached_queries.py

@@ -0,0 +1,50 @@
+"""
+Cached query wrappers for Streamlit performance.
+Uses @st.cache_data to avoid re-fetching identical data on every rerun.
+Tag names must be passed as tuples (not lists) for hashability.
+"""
+import streamlit as st
+from typing import Optional
+from datetime import datetime
+from core.db_connector import get_db_connector
+
+
+@st.cache_data(ttl=600)
+def cached_get_pivot_data(
+    tag_names: tuple,
+    start_time: datetime,
+    end_time: datetime,
+    table_override: Optional[str] = None,
+    _cache_ver: int = 2,
+):
+    """Cached pivot data query (10-minute TTL). Supports table_override for resolution control."""
+    db = get_db_connector()
+    if table_override:
+        # Fetch via get_sensor_data with override, then pivot manually
+        df = db.get_sensor_data(list(tag_names), start_time, end_time, table_override=table_override)
+        if df.empty:
+            return df
+        pivot_df = df.pivot_table(index='timestamp', columns='tag_name', values='value').reset_index()
+        pivot_df.columns.name = None
+        return pivot_df
+    return db.get_pivot_data(list(tag_names), start_time, end_time)
+
+
+@st.cache_data(ttl=600)
+def cached_get_sensor_data(
+    tag_names: tuple,
+    start_time: datetime,
+    end_time: datetime,
+    table_override: Optional[str] = None,
+    _cache_ver: int = 2,
+):
+    """Cached sensor data query (10-minute TTL)"""
+    db = get_db_connector()
+    return db.get_sensor_data(list(tag_names), start_time, end_time, table_override=table_override)
+
+
+@st.cache_data(ttl=3600)
+def cached_get_available_months():
+    """Cached available months query (1-hour TTL)"""
+    db = get_db_connector()
+    return db.get_available_months()

core/config.py

@@ -0,0 +1,174 @@
+"""
+Configuration for CSH2 Web Analytics Dashboard
+Supports local (.env), Streamlit Cloud (st.secrets), and HuggingFace Spaces (env vars) deployment.
+"""
+import os
+from datetime import timedelta
+from zoneinfo import ZoneInfo
+import streamlit as st
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# ── Timezone Configuration ──────────────────────────────────────────────────
+# The PLC logs in US/Eastern. The DB's `dateandtime` column is Eastern local
+# time, while `utc_full_timestamp` is the real UTC. The `cycle_periods` table
+# stores Eastern times incorrectly labeled as UTC (+00:00), requiring a +4h
+# correction for sensor data queries. All data (Mar-Sep 2025) falls within
+# EDT (UTC-4). We display all user-facing times in Eastern.
+DISPLAY_TZ = ZoneInfo("US/Eastern")
+DISPLAY_TZ_LABEL = "ET"  # label for axis titles and UI
+CYCLE_PERIODS_UTC_OFFSET = timedelta(hours=4)  # correction for cycle_periods timestamps
+
+
+def _get_secret(key, default=None):
+    """Read from st.secrets (Streamlit Cloud) or os.environ/.env (local dev)"""
+    try:
+        return st.secrets[key]
+    except (KeyError, FileNotFoundError, AttributeError):
+        return os.getenv(key, default)
+
+
+# Database Configuration
+DB_CONFIG = {
+    'host': _get_secret('DB_HOST'),
+    'port': _get_secret('DB_PORT'),
+    'database': _get_secret('DB_NAME'),
+    'user': _get_secret('DB_USER'),
+    'password': _get_secret('DB_PASSWORD'),
+    'connect_timeout': 10,
+}
+
+ANTHROPIC_API_KEY = _get_secret('ANTHROPIC_API_KEY')
+
+# Database Tables
+TABLES = {
+    'raw': 'procdatafloattable',
+    'agg_1sec': 'procdatafloattable_utc_1sec',
+    'agg_15sec': 'procdatafloattable_utc_15sec',
+    'tag_metadata': 'procdatatagtable',
+    'events': 'allevent',
+    'fill_reports': 'fillreport',
+    'cooldown_periods': 'cooldown_periods',
+    'cycle_periods': 'cycle_periods',
+}
+
+# Smart table routing thresholds (seconds)
+TABLE_ROUTING = {
+    'raw_max_seconds': 3600,       # <= 1 hour -> raw 10Hz
+    'agg_1sec_max_seconds': 86400, # <= 1 day -> 1sec aggregates
+    # > 1 day -> 15sec aggregates
+}
+
+MAX_ROWS_RETURN = 500000
+
+# Resolution name to table mapping (used by Advanced Data Explorer execution engine)
+RESOLUTION_MAP = {
+    'raw': TABLES['raw'],
+    '1sec': TABLES['agg_1sec'],
+    '15sec': TABLES['agg_15sec'],
+}
+
+# Key sensor tags with descriptions and units
+SENSOR_TAGS = {
+    'AmbTempAvg': {'description': 'Ambient Temperature Average', 'units': 'K', 'tagindex': 0},
+    'AOV140': {'description': 'Valve Position AOV140', 'units': '%', 'tagindex': 1},
+    'AvgPower': {'description': 'Average Power', 'units': 'kW', 'tagindex': 2},
+    'CalcMass': {'description': 'Calculated Mass', 'units': 'kg', 'tagindex': 3},
+    'DPT01T': {'description': 'Differential Pressure', 'units': 'bar', 'tagindex': 4},
+    'DispTempAvg': {'description': 'Dispenser Temperature Average', 'units': 'K', 'tagindex': 5},
+    'FD100': {'description': 'Flow Detector', 'units': '', 'tagindex': 6},
+    'FT140': {'description': 'Flow Transmitter', 'units': 'kg/min', 'tagindex': 7},
+    'FTTMP': {'description': 'Flow Transmitter Temperature', 'units': 'K', 'tagindex': 8},
+    'GD100': {'description': 'Gas Detector', 'units': '', 'tagindex': 9},
+    'H201T': {'description': 'H2O Temperature', 'units': 'K', 'tagindex': 10},
+    'IR01T': {'description': 'IR Temperature', 'units': 'K', 'tagindex': 11},
+    'LT200': {'description': 'Level Transmitter', 'units': '%', 'tagindex': 12},
+    'MC130_VFD_Speed': {'description': 'Motor VFD Speed', 'units': 'RPM', 'tagindex': 13},
+    'PowerConsumption': {'description': 'Power Consumption', 'units': 'kW', 'tagindex': 14},
+    'PT01T': {'description': 'Cryotank Pressure', 'units': 'bar', 'tagindex': 15},
+    'PT100': {'description': 'Pressure PT100', 'units': 'bar', 'tagindex': 16},
+    'PT110': {'description': 'Inlet Pressure', 'units': 'bar', 'tagindex': 17},
+    'PT130': {'description': 'Discharge Pressure', 'units': 'bar', 'tagindex': 18},
+    'PT131': {'description': 'Discharge Pressure Alt', 'units': 'bar', 'tagindex': 19},
+    'PT150': {'description': 'Pressure PT150', 'units': 'bar', 'tagindex': 20},
+    'PT200': {'description': 'Pressure PT200', 'units': 'bar', 'tagindex': 21},
+    'PT310': {'description': 'Pressure PT310', 'units': 'bar', 'tagindex': 22},
+    'TT100': {'description': 'Temperature TT100', 'units': 'K', 'tagindex': 23},
+    'TT110': {'description': 'Pump Feed Line Temperature', 'units': 'K', 'tagindex': 24},
+    'TT120': {'description': 'Temperature TT120', 'units': 'K', 'tagindex': 25},
+    'TT121': {'description': 'Temperature TT121', 'units': 'K', 'tagindex': 26},
+    'TT130': {'description': 'Discharge Temperature', 'units': 'K', 'tagindex': 27},
+    'TT131': {'description': 'Discharge Temperature Alt', 'units': 'K', 'tagindex': 28},
+    'TT140': {'description': 'Temperature TT140', 'units': 'K', 'tagindex': 29},
+    'MC130_PwrConsumption': {'description': 'Motor Power Consumption', 'units': 'kW', 'tagindex': 30},
+    'PercentFill': {'description': 'Percent Fill', 'units': '%', 'tagindex': 31},
+    'PeakPower': {'description': 'Peak Power', 'units': 'kW', 'tagindex': 32},
+    'N2Density': {'description': 'N2 Density', 'units': 'kg/m3', 'tagindex': 33},
+    'PS100': {'description': 'Pump Status', 'units': '', 'tagindex': 34},
+    'H2Density': {'description': 'H2 Density', 'units': 'kg/m3', 'tagindex': 35},
+    'FTTMP2': {'description': 'Flow Temp 2', 'units': 'K', 'tagindex': 54},
+    'M130_BusV': {'description': 'Motor Bus Voltage', 'units': 'V', 'tagindex': 55},
+    'M130_Current': {'description': 'Motor Current', 'units': 'A', 'tagindex': 56},
+    'M130_Freq': {'description': 'Motor Frequency', 'units': 'Hz', 'tagindex': 58},
+    'M130_PF': {'description': 'Motor Power Factor', 'units': '', 'tagindex': 61},
+    'M130_Pwr': {'description': 'Motor Power', 'units': 'kW', 'tagindex': 62},
+    'M130_PwrCon': {'description': 'Motor Power Consumption', 'units': 'kW', 'tagindex': 63},
+    'M130_RPM': {'description': 'Motor RPM', 'units': 'RPM', 'tagindex': 66},
+    'M130_Speed': {'description': 'Motor Speed', 'units': 'RPM', 'tagindex': 68},
+    'M130_Torque': {'description': 'Motor Torque', 'units': 'Nm', 'tagindex': 70},
+    'PT010': {'description': 'Pressure PT010', 'units': 'bar', 'tagindex': 72},
+    'PT020': {'description': 'Pressure PT020', 'units': 'bar', 'tagindex': 73},
+}
+
+# Sensor groups for quick selection
+SENSOR_GROUPS = {
+    'Pressure': ['PT01T', 'PT100', 'PT110', 'PT130', 'PT131', 'PT150', 'PT200', 'PT310', 'PT010', 'PT020'],
+    'Temperature': ['TT100', 'TT110', 'TT120', 'TT121', 'TT130', 'TT131', 'TT140', 'AmbTempAvg', 'DispTempAvg'],
+    'Flow': ['FT140', 'FD100', 'FTTMP', 'FTTMP2', 'CalcMass'],
+    'Motor/VFD': ['MC130_VFD_Speed', 'M130_Speed', 'M130_RPM', 'M130_Pwr', 'M130_Current', 'M130_Freq', 'M130_Torque', 'M130_BusV', 'M130_PF'],
+    'Power': ['AvgPower', 'PeakPower', 'PowerConsumption', 'MC130_PwrConsumption', 'M130_PwrCon'],
+    'Level & Density': ['LT200', 'PercentFill', 'N2Density', 'H2Density'],
+    'Status': ['PS100'],
+}
+
+# Motor speed tags (for testing cycle detection - try in order)
+MOTOR_SPEED_TAGS = ['M130_Speed', 'MC130_VFD_Speed', 'M130_RPM']
+
+# Motor speed display multiplier: M130_Speed (tag 68) reads as a % signal (0-100).
+# Multiply by 5/3 to convert to actual RPM matching Grafana display.
+# e.g., M130_Speed=180 raw → 180 × 5/3 = 300 RPM.
+# Set to 1.0 to disable scaling.
+MOTOR_SPEED_DISPLAY_MULTIPLIER = 5 / 3
+
+# Testing cycle detection parameters
+CYCLE_DETECTION = {
+    'idle_threshold': 10.0,         # RPM below which motor is idle
+    'min_cycle_seconds': 60,        # Minimum cycle duration
+    'smoothing_window': 5,          # Rolling median window (in samples)
+    'max_gap_seconds': 120,         # Max gap to merge adjacent cycles
+    # Qualification: cycle must show real compression or flow
+    'min_peak_pressure_bar': 50.0,       # PT130 must exceed this (real fills reach 300+ bar)
+    'min_pressure_rise_bar': 10.0,       # PT130 must rise this much from initial
+    'min_avg_flow_kg_min': 0.05,         # FT140 average must exceed this (real fills do 1+ kg/min)
+    'max_cycle_duration_hours': 8.0,     # Reject multi-day noise spans (no real test > 8h)
+}
+
+# Key tags for cycle detail analysis
+CYCLE_DETAIL_TAGS = ['PT130', 'PT01T', 'PT110', 'TT110', 'TT130', 'FT140', 'M130_Speed', 'MC130_VFD_Speed', 'AOV140']
+
+# Performance targets
+PERFORMANCE_TARGETS = {
+    'pressure': {'phase1': 500, 'h70': 700, 'ultimate': 1000},
+    'flow': {'simplex': 2, 'triplex': 6},
+    'efficiency': {'pump_gas_ratio': 0.95, 'seal_blowby': 0.03},
+    'energy': {'specific_consumption': 0.5},
+}
+
+# Testing phases
+TESTING_PHASES = {
+    'mechanical': {'description': 'Mechanical validation with LN2', 'status': 'completed', 'max_pressure': '937 bar'},
+    'phase1a': {'description': 'Phase 1A H2 testing with LH2', 'status': 'completed', 'max_pressure': '495 bar'},
+    'phase1b': {'description': 'Phase 1B ccH2 fills', 'status': 'completed', 'max_pressure': '495 bar'},
+    'phase2': {'description': 'Phase 2 H35/H70 fills', 'status': 'planned', 'target_pressure': '700+ bar'},
+}

core/date_parser.py

@@ -0,0 +1,341 @@
+"""
+Natural language date/time parser for ClearSkies Analytics Agent
+Converts user queries like "yesterday", "Sept 25", "between 10:00 and 12:00 on Sept 24" into datetime objects
+NO EXTERNAL DEPENDENCIES - works with just standard library
+"""
+from datetime import datetime, timedelta
+from typing import Tuple, Optional
+import re
+
+class DateTimeParser:
+    """Parse natural language date/time expressions"""
+    
+    def __init__(self, reference_date: Optional[datetime] = None):
+        """
+        Initialize parser
+        
+        Args:
+            reference_date: Reference date for relative expressions (default: now)
+        """
+        self.reference_date = reference_date or datetime.now()
+        
+        # Month name mapping
+        self.month_map = {
+            'jan': 1, 'january': 1,
+            'feb': 2, 'february': 2,
+            'mar': 3, 'march': 3,
+            'apr': 4, 'april': 4,
+            'may': 5,
+            'jun': 6, 'june': 6,
+            'jul': 7, 'july': 7,
+            'aug': 8, 'august': 8,
+            'sep': 9, 'sept': 9, 'september': 9,
+            'oct': 10, 'october': 10,
+            'nov': 11, 'november': 11,
+            'dec': 12, 'december': 12
+        }
+    
+    def parse(self, text: str) -> Tuple[Optional[datetime], Optional[datetime]]:
+        """
+        Parse natural language date/time into start and end datetime
+        
+        Args:
+            text: User input text containing date/time references
+        
+        Returns:
+            Tuple of (start_datetime, end_datetime)
+        """
+        text = text.lower().strip()
+        
+        # Priority 1: Time range on specific date (most specific)
+        result = self._try_time_range_on_date(text)
+        if result:
+            return result
+        
+        # Priority 2: Specific date patterns
+        result = self._try_specific_patterns(text)
+        if result:
+            return result
+        
+        # Default: return None if no date found
+        return None, None
+    
+    def _try_time_range_on_date(self, text: str) -> Optional[Tuple[datetime, datetime]]:
+        """
+        Handle patterns like:
+        - "between 10:00 and 12:00 on Sept 24"
+        - "from 10:00 to 12:00 on Sept 24"
+        - "10:00 to 12:00 on Sept 24"
+        """
+        # Pattern 1: "between HH:MM and HH:MM on DATE"
+        pattern1 = r'between\s+(\d{1,2}):(\d{2})\s+and\s+(\d{1,2}):(\d{2})\s+on\s+(.+?)$'
+        match = re.search(pattern1, text, re.IGNORECASE)
+        
+        if match:
+            start_hour = int(match.group(1))
+            start_min = int(match.group(2))
+            end_hour = int(match.group(3))
+            end_min = int(match.group(4))
+            date_str = match.group(5).strip()
+            
+            # Parse the date part (just the date, ignore times in date string)
+            base_date = self._parse_date_only(date_str)
+            if base_date:
+                start = datetime(base_date.year, base_date.month, base_date.day, start_hour, start_min, 0, 0)
+                end = datetime(base_date.year, base_date.month, base_date.day, end_hour, end_min, 59, 999999)
+                return start, end
+        
+        # Pattern 2: "from HH:MM to HH:MM on DATE"
+        pattern2 = r'from\s+(\d{1,2}):(\d{2})\s+to\s+(\d{1,2}):(\d{2})\s+on\s+(.+?)$'
+        match = re.search(pattern2, text, re.IGNORECASE)
+        
+        if match:
+            start_hour = int(match.group(1))
+            start_min = int(match.group(2))
+            end_hour = int(match.group(3))
+            end_min = int(match.group(4))
+            date_str = match.group(5).strip()
+            
+            base_date = self._parse_date_only(date_str)
+            if base_date:
+                start = datetime(base_date.year, base_date.month, base_date.day, start_hour, start_min, 0, 0)
+                end = datetime(base_date.year, base_date.month, base_date.day, end_hour, end_min, 59, 999999)
+                return start, end
+        
+        # Pattern 3: "HH:MM to HH:MM on DATE" (without "from")
+        pattern3 = r'(\d{1,2}):(\d{2})\s+to\s+(\d{1,2}):(\d{2})\s+on\s+(.+?)$'
+        match = re.search(pattern3, text, re.IGNORECASE)
+        
+        if match:
+            start_hour = int(match.group(1))
+            start_min = int(match.group(2))
+            end_hour = int(match.group(3))
+            end_min = int(match.group(4))
+            date_str = match.group(5).strip()
+            
+            base_date = self._parse_date_only(date_str)
+            if base_date:
+                start = datetime(base_date.year, base_date.month, base_date.day, start_hour, start_min, 0, 0)
+                end = datetime(base_date.year, base_date.month, base_date.day, end_hour, end_min, 59, 999999)
+                return start, end
+        
+        return None
+    
+    def _parse_date_only(self, date_str: str) -> Optional[datetime]:
+        """Parse a date string like 'Sept 24' or '9/24' into a datetime (time will be 00:00:00)"""
+        
+        # Try month name + day
+        month_day_pattern = r'(jan|january|feb|february|mar|march|apr|april|may|jun|june|jul|july|aug|august|sep|sept|september|oct|october|nov|november|dec|december)[a-z]*\s+(\d{1,2})'
+        match = re.search(month_day_pattern, date_str, re.IGNORECASE)
+        if match:
+            month_str = match.group(1).lower()
+            month = self.month_map.get(month_str)
+            day = int(match.group(2))
+            year = self.reference_date.year
+            
+            # If the date is in the future, assume it was last year
+            try:
+                test_date = datetime(year, month, day)
+                if test_date > self.reference_date:
+                    year -= 1
+                return datetime(year, month, day, 0, 0, 0)
+            except ValueError:
+                return None
+        
+        # Try MM/DD or M/D
+        md_pattern = r'\b(\d{1,2})[/-](\d{1,2})\b'
+        match = re.search(md_pattern, date_str)
+        if match:
+            month = int(match.group(1))
+            day = int(match.group(2))
+            year = self.reference_date.year
+            try:
+                return datetime(year, month, day, 0, 0, 0)
+            except ValueError:
+                return None
+        
+        # Try YYYY-MM-DD
+        ymd_pattern = r'(\d{4})[/-](\d{1,2})[/-](\d{1,2})'
+        match = re.search(ymd_pattern, date_str)
+        if match:
+            year = int(match.group(1))
+            month = int(match.group(2))
+            day = int(match.group(3))
+            try:
+                return datetime(year, month, day, 0, 0, 0)
+            except ValueError:
+                return None
+        
+        return None
+    
+    def _try_specific_patterns(self, text: str) -> Optional[Tuple[datetime, datetime]]:
+        """Try to match specific common patterns"""
+        
+        # Month name + day (Sept 25, September 25th)
+        month_day_pattern = r'(jan|january|feb|february|mar|march|apr|april|may|jun|june|jul|july|aug|august|sep|sept|september|oct|october|nov|november|dec|december)[a-z]*\s+(\d{1,2})'
+        match = re.search(month_day_pattern, text, re.IGNORECASE)
+        if match:
+            month_str = match.group(1).lower()
+            month = self.month_map.get(month_str)
+            day = int(match.group(2))
+            year = self.reference_date.year
+            
+            # If the date is in the future, assume it was last year
+            try:
+                test_date = datetime(year, month, day)
+                if test_date > self.reference_date:
+                    year -= 1
+                
+                start = datetime(year, month, day, 0, 0, 0)
+                end = datetime(year, month, day, 23, 59, 59)
+                return start, end
+            except ValueError:
+                pass
+        
+        # YYYY-MM-DD or YYYY/MM/DD
+        ymd_pattern = r'(\d{4})[/-](\d{1,2})[/-](\d{1,2})'
+        match = re.search(ymd_pattern, text)
+        if match:
+            try:
+                year = int(match.group(1))
+                month = int(match.group(2))
+                day = int(match.group(3))
+                
+                start = datetime(year, month, day, 0, 0, 0)
+                end = datetime(year, month, day, 23, 59, 59)
+                return start, end
+            except ValueError:
+                pass
+        
+        # MM/DD or M/D
+        md_pattern = r'\b(\d{1,2})[/-](\d{1,2})\b'
+        match = re.search(md_pattern, text)
+        if match:
+            try:
+                month = int(match.group(1))
+                day = int(match.group(2))
+                year = self.reference_date.year
+                
+                start = datetime(year, month, day, 0, 0, 0)
+                end = datetime(year, month, day, 23, 59, 59)
+                return start, end
+            except ValueError:
+                pass
+        
+        # Today
+        if 'today' in text:
+            start = self.reference_date.replace(hour=0, minute=0, second=0, microsecond=0)
+            end = self.reference_date.replace(hour=23, minute=59, second=59, microsecond=999999)
+            return start, end
+        
+        # Yesterday
+        if 'yesterday' in text:
+            yesterday = self.reference_date - timedelta(days=1)
+            start = yesterday.replace(hour=0, minute=0, second=0, microsecond=0)
+            end = yesterday.replace(hour=23, minute=59, second=59, microsecond=999999)
+            return start, end
+        
+        # Last N hours
+        hours_match = re.search(r'last (\d+) hour', text)
+        if hours_match:
+            hours = int(hours_match.group(1))
+            end = self.reference_date
+            start = end - timedelta(hours=hours)
+            return start, end
+        
+        # Last N days
+        days_match = re.search(r'last (\d+) day', text)
+        if days_match:
+            days = int(days_match.group(1))
+            end = self.reference_date
+            start = end - timedelta(days=days)
+            return start, end
+        
+        # This week
+        if 'this week' in text:
+            start = self.reference_date - timedelta(days=self.reference_date.weekday())
+            start = start.replace(hour=0, minute=0, second=0, microsecond=0)
+            end = self.reference_date
+            return start, end
+        
+        # Last week
+        if 'last week' in text:
+            end = self.reference_date - timedelta(days=self.reference_date.weekday())
+            start = end - timedelta(days=7)
+            start = start.replace(hour=0, minute=0, second=0, microsecond=0)
+            end = end.replace(hour=23, minute=59, second=59, microsecond=999999)
+            return start, end
+        
+        # This month
+        if 'this month' in text:
+            start = self.reference_date.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+            end = self.reference_date
+            return start, end
+        
+        # Time range patterns: "from X to Y"
+        range_pattern = r'from\s+(.+?)\s+to\s+(.+?)(?:\s|$)'
+        match = re.search(range_pattern, text, re.IGNORECASE)
+        if match:
+            start_str = match.group(1).strip()
+            end_str = match.group(2).strip()
+            
+            # Try to parse each part recursively
+            start_result = self.parse(start_str)
+            end_result = self.parse(end_str)
+            
+            if start_result[0] and end_result[1]:
+                return start_result[0], end_result[1]
+        
+        return None
+    
+    def extract_time_window(self, text: str) -> Optional[Tuple[datetime, datetime]]:
+        """
+        Extract time window from query, with helpful error messages
+        
+        Args:
+            text: User query
+        
+        Returns:
+            (start_time, end_time) or None if no time found
+        """
+        start, end = self.parse(text)
+        
+        if start and end:
+            return start, end
+        
+        return None
+
+
+# Test function
+if __name__ == "__main__":
+    print("Testing DateTimeParser...")
+    
+    parser = DateTimeParser(reference_date=datetime(2025, 9, 26, 14, 30))
+    
+    test_queries = [
+        "yesterday",
+        "today",
+        "last 3 hours",
+        "last 5 days",
+        "Sept 25",
+        "September 25th",
+        "between 10:00 and 12:00 on Sept 24",
+        "from 10:00 to 12:00 on Sept 24",
+        "10:00 to 12:00 on Sept 24",
+        "from Sept 24 to Sept 25",
+        "this week",
+        "last week",
+        "9/25",
+        "2025-09-25",
+    ]
+    
+    print("\nTest queries:")
+    for query in test_queries:
+        start, end = parser.parse(query)
+        if start and end:
+            print(f"✅ '{query}'")
+            print(f"   Start: {start}")
+            print(f"   End:   {end}")
+        else:
+            print(f"❌ '{query}' - Could not parse")
+        print()

core/db_connector.py

@@ -0,0 +1,492 @@
+"""
+Enhanced Database Connector for CSH2 Web Dashboard
+Smart table routing, connection health checks, pivot data support
+"""
+import psycopg2
+from psycopg2.extras import RealDictCursor
+import pandas as pd
+from typing import List, Dict, Optional, Tuple
+from datetime import datetime, timezone
+import streamlit as st
+from core import config
+
+
+class DatabaseConnector:
+    """Handles all database operations with smart table routing"""
+
+    def __init__(self):
+        self.conn = None
+        self.tag_cache = {}
+        self.index_to_tag = {}
+        self._connect()
+        self._load_tag_cache()
+
+    def _connect(self):
+        try:
+            self.conn = psycopg2.connect(**config.DB_CONFIG)
+            self.conn.autocommit = True
+        except Exception as e:
+            raise ConnectionError(f"Database connection failed: {e}")
+
+    def _ensure_connection(self):
+        """Reconnect if the connection has gone stale"""
+        try:
+            with self.conn.cursor() as cur:
+                cur.execute("SELECT 1")
+        except Exception:
+            self._connect()
+
+    def _load_tag_cache(self):
+        try:
+            query = f"SELECT tagindex, tagname FROM {config.TABLES['tag_metadata']}"
+            df = pd.read_sql(query, self.conn)
+            self.tag_cache = {row['tagname']: row['tagindex'] for _, row in df.iterrows()}
+            self.index_to_tag = {row['tagindex']: row['tagname'] for _, row in df.iterrows()}
+        except Exception as e:
+            self.tag_cache = {}
+            self.index_to_tag = {}
+
+    def get_tag_index(self, tag_name: str) -> Optional[int]:
+        return self.tag_cache.get(tag_name) or self.tag_cache.get(tag_name.upper())
+
+    def get_tag_name(self, tag_index: int) -> Optional[str]:
+        return self.index_to_tag.get(tag_index)
+
+    def get_all_tag_names(self) -> List[str]:
+        return sorted(self.tag_cache.keys())
+
+    def _select_table(self, start_time: datetime, end_time: datetime) -> str:
+        """Select the optimal table based on time range duration"""
+        duration_seconds = (end_time - start_time).total_seconds()
+        routing = config.TABLE_ROUTING
+
+        if duration_seconds <= routing['raw_max_seconds']:
+            return config.TABLES['raw']
+        elif duration_seconds <= routing['agg_1sec_max_seconds']:
+            return config.TABLES['agg_1sec']
+        else:
+            return config.TABLES['agg_15sec']
+
+    def get_sensor_data(
+        self,
+        tag_names: List[str],
+        start_time: datetime,
+        end_time: datetime,
+        table_override: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> pd.DataFrame:
+        """
+        Fetch sensor data with smart table routing.
+
+        Returns DataFrame with columns: timestamp, tag_name, value
+        """
+        self._ensure_connection()
+
+        tag_indices = []
+        valid_tags = []
+        for tag in tag_names:
+            idx = self.get_tag_index(tag)
+            if idx is not None:
+                tag_indices.append(idx)
+                valid_tags.append(tag)
+
+        if not tag_indices:
+            return pd.DataFrame(columns=['timestamp', 'tag_name', 'value'])
+
+        table = table_override or self._select_table(start_time, end_time)
+        tag_list = ', '.join(map(str, tag_indices))
+        limit_clause = f"LIMIT {limit}" if limit else f"LIMIT {config.MAX_ROWS_RETURN}"
+
+        query = f"""
+        SELECT
+            utc_full_timestamp as timestamp,
+            tagindex,
+            val as value
+        FROM {table}
+        WHERE tagindex IN ({tag_list})
+          AND utc_full_timestamp >= %s
+          AND utc_full_timestamp <= %s
+        ORDER BY utc_full_timestamp, tagindex
+        {limit_clause}
+        """
+
+        try:
+            df = pd.read_sql(query, self.conn, params=(start_time, end_time))
+            df['tag_name'] = df['tagindex'].map(self.index_to_tag)
+            df = df[['timestamp', 'tag_name', 'value']]
+            return df
+        except Exception as e:
+            st.error(f"Query failed: {e}")
+            return pd.DataFrame(columns=['timestamp', 'tag_name', 'value'])
+
+    def get_pivot_data(
+        self,
+        tag_names: List[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> pd.DataFrame:
+        """Fetch data and return in wide (pivoted) format"""
+        df = self.get_sensor_data(tag_names, start_time, end_time)
+        if df.empty:
+            return df
+
+        pivot_df = df.pivot_table(
+            index='timestamp',
+            columns='tag_name',
+            values='value',
+        ).reset_index()
+
+        pivot_df.columns.name = None
+        return pivot_df
+
+    def get_available_months(self) -> List[str]:
+        """Get distinct months where data exists (using 15sec table for speed)"""
+        self._ensure_connection()
+        query = f"""
+        SELECT DISTINCT date_trunc('month', utc_full_timestamp)::date as month
+        FROM {config.TABLES['agg_15sec']}
+        ORDER BY month
+        """
+        try:
+            df = pd.read_sql(query, self.conn)
+            return [row['month'].strftime('%Y-%m') for _, row in df.iterrows()]
+        except Exception:
+            # Fallback: use raw table with a limit
+            try:
+                query = f"""
+                SELECT DISTINCT date_trunc('month', utc_full_timestamp)::date as month
+                FROM {config.TABLES['raw']}
+                ORDER BY month
+                """
+                df = pd.read_sql(query, self.conn)
+                return [row['month'].strftime('%Y-%m') for _, row in df.iterrows()]
+            except Exception:
+                return []
+
+    def get_time_range(self) -> Tuple[Optional[datetime], Optional[datetime]]:
+        """Get overall time range of available data"""
+        self._ensure_connection()
+        query = f"""
+        SELECT MIN(utc_full_timestamp) as earliest, MAX(utc_full_timestamp) as latest
+        FROM {config.TABLES['agg_15sec']}
+        """
+        try:
+            df = pd.read_sql(query, self.conn)
+            return df['earliest'][0], df['latest'][0]
+        except Exception:
+            return None, None
+
+    def get_data_summary(
+        self,
+        tag_name: str,
+        start_time: datetime,
+        end_time: datetime,
+    ) -> Dict:
+        """Get statistical summary for a single tag"""
+        self._ensure_connection()
+        tag_index = self.get_tag_index(tag_name)
+        if tag_index is None:
+            return {'error': f'Tag {tag_name} not found'}
+
+        table = self._select_table(start_time, end_time)
+        query = f"""
+        SELECT COUNT(*) as count, MIN(val) as min_value, MAX(val) as max_value,
+               AVG(val) as avg_value, STDDEV(val) as std_value
+        FROM {table}
+        WHERE tagindex = %s AND utc_full_timestamp >= %s AND utc_full_timestamp <= %s
+        """
+        try:
+            with self.conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute(query, (tag_index, start_time, end_time))
+                result = cur.fetchone()
+                return dict(result)
+        except Exception as e:
+            return {'error': str(e)}
+
+    def check_table_exists(self, table_name: str) -> bool:
+        """Check if a table exists in the database"""
+        self._ensure_connection()
+        query = """
+        SELECT EXISTS (
+            SELECT FROM information_schema.tables
+            WHERE table_schema = 'public' AND table_name = %s
+        )
+        """
+        try:
+            with self.conn.cursor() as cur:
+                cur.execute(query, (table_name,))
+                return cur.fetchone()[0]
+        except Exception:
+            return False
+
+    def get_cooldown_periods(self, start_time: datetime, end_time: datetime) -> pd.DataFrame:
+        """Query cooldown_periods table if it exists"""
+        self._ensure_connection()
+        if not self.check_table_exists('cooldown_periods'):
+            return pd.DataFrame()
+
+        query = """
+        SELECT cooldown_start, cooldown_end, start_temperature, end_temperature, duration_sec
+        FROM cooldown_periods
+        WHERE cooldown_start >= %s AND cooldown_start <= %s
+        ORDER BY cooldown_start
+        """
+        try:
+            return pd.read_sql(query, self.conn, params=(start_time, end_time))
+        except Exception:
+            return pd.DataFrame()
+
+    def resolve_motor_speed_tag(self) -> Optional[str]:
+        """Find which motor speed tag exists in the database"""
+        for tag in config.MOTOR_SPEED_TAGS:
+            if tag in self.tag_cache:
+                return tag
+        # Search for any tag containing 'speed' or 'rpm'
+        for tag_name in self.tag_cache:
+            if 'speed' in tag_name.lower() or 'rpm' in tag_name.lower():
+                return tag_name
+        return None
+
+    def get_cycle_periods(self, month_str: str = None) -> List[Dict]:
+        """Fetch pre-computed cycles from the cycle_periods table.
+
+        Args:
+            month_str: Optional "YYYY-MM" filter. None returns all cycles.
+
+        Returns:
+            List of cycle dicts in the format expected by downstream pages
+            (cycle_id, start_time, end_time, duration_minutes, peak_speed,
+            peak_pressure, avg_flow, etc.), plus new fields from the DB.
+        """
+        self._ensure_connection()
+
+        query = """
+        SELECT id, cycle_start, cycle_end, duration_sec,
+               max_motor_speed, max_flow_rate, avg_flow_rate,
+               total_kg_dispensed, min_discharge_pressure, max_discharge_pressure,
+               min_fill_temperature, max_fill_temperature, avg_ambient_temperature,
+               cryotank_start_pressure, cryotank_end_pressure, total_pump_strokes
+        FROM cycle_periods
+        """
+        params = []
+        if month_str:
+            year, month = map(int, month_str.split('-'))
+            if month == 12:
+                next_year, next_month = year + 1, 1
+            else:
+                next_year, next_month = year, month + 1
+            query += " WHERE cycle_start >= %s AND cycle_start < %s"
+            params = [
+                datetime(year, month, 1, tzinfo=timezone.utc),
+                datetime(next_year, next_month, 1, tzinfo=timezone.utc),
+            ]
+        query += " ORDER BY cycle_start"
+
+        try:
+            df = pd.read_sql(query, self.conn, params=params or None)
+        except Exception:
+            return []
+
+        if df.empty:
+            return []
+
+        from core.timezone import cycle_periods_to_utc, cycle_periods_to_eastern
+
+        speed_mult = getattr(config, 'MOTOR_SPEED_DISPLAY_MULTIPLIER', 1.0)
+
+        cycles = []
+        for _, row in df.iterrows():
+            raw_start = row['cycle_start'].to_pydatetime() if hasattr(row['cycle_start'], 'to_pydatetime') else row['cycle_start']
+            raw_end = row['cycle_end'].to_pydatetime() if hasattr(row['cycle_end'], 'to_pydatetime') else row['cycle_end']
+
+            cycles.append({
+                # Times corrected to real UTC — use these for all DB queries
+                'start_time': cycle_periods_to_utc(raw_start),
+                'end_time': cycle_periods_to_utc(raw_end),
+                # Eastern display times — use these for all UI rendering
+                'start_time_et': cycle_periods_to_eastern(raw_start),
+                'end_time_et': cycle_periods_to_eastern(raw_end),
+                # Standard fields
+                'cycle_id': int(row['id']),
+                'duration_minutes': float(row['duration_sec']) / 60.0,
+                'peak_speed': float(row['max_motor_speed'] or 0) * speed_mult,
+                'peak_pressure': float(row['max_discharge_pressure'] or 0),
+                'initial_pressure': float(row['min_discharge_pressure'] or 0),
+                'avg_flow': float(row['avg_flow_rate'] or 0),
+                'peak_TT110': float(row['max_fill_temperature'] or 0),
+                # Additional fields from cycle_periods table
+                'max_flow_rate': float(row['max_flow_rate'] or 0),
+                'total_kg_dispensed': float(row['total_kg_dispensed'] or 0),
+                'min_fill_temperature': float(row['min_fill_temperature'] or 0),
+                'avg_ambient_temperature': float(row['avg_ambient_temperature'] or 0),
+                'cryotank_start_pressure': float(row['cryotank_start_pressure'] or 0),
+                'cryotank_end_pressure': float(row['cryotank_end_pressure'] or 0),
+                'total_pump_strokes': float(row['total_pump_strokes'] or 0),
+            })
+        return cycles
+
+    def get_cycle_months(self) -> List[str]:
+        """Get distinct months where cycles exist in cycle_periods table."""
+        self._ensure_connection()
+        query = """
+        SELECT DISTINCT date_trunc('month', cycle_start)::date as month
+        FROM cycle_periods
+        ORDER BY month
+        """
+        try:
+            df = pd.read_sql(query, self.conn)
+            return [row['month'].strftime('%Y-%m') for _, row in df.iterrows()]
+        except Exception:
+            return []
+
+    # ── Text Search Methods ──
+
+    def search_memo_log(
+        self,
+        query: str,
+        limit: int = 20,
+        engineer: Optional[str] = None,
+        severity: Optional[str] = None,
+    ) -> pd.DataFrame:
+        """Full-text ranked search across engineer field notes in memo_log.
+
+        Uses PostgreSQL tsvector/tsquery with ts_rank for BM25-style relevance.
+        Searches across summary, issues_found, raw_transcript, maintenance_done,
+        and system_performance columns.
+        """
+        self._ensure_connection()
+        sql = """
+        SELECT id, logged_at, engineer, severity, activity_type,
+               summary, issues_found, maintenance_done, system_performance,
+               components_affected,
+               ts_rank(
+                   to_tsvector('english',
+                       coalesce(summary, '') || ' ' ||
+                       coalesce(issues_found, '') || ' ' ||
+                       coalesce(raw_transcript, '') || ' ' ||
+                       coalesce(maintenance_done, '') || ' ' ||
+                       coalesce(system_performance, '')
+                   ),
+                   plainto_tsquery('english', %(query)s)
+               ) AS rank
+        FROM memo_log
+        WHERE to_tsvector('english',
+                  coalesce(summary, '') || ' ' ||
+                  coalesce(issues_found, '') || ' ' ||
+                  coalesce(raw_transcript, '') || ' ' ||
+                  coalesce(maintenance_done, '') || ' ' ||
+                  coalesce(system_performance, '')
+              ) @@ plainto_tsquery('english', %(query)s)
+        """
+        params: Dict = {'query': query}
+        if engineer:
+            sql += " AND engineer = %(engineer)s"
+            params['engineer'] = engineer
+        if severity:
+            sql += " AND severity = %(severity)s"
+            params['severity'] = severity
+        sql += " ORDER BY rank DESC LIMIT %(limit)s"
+        params['limit'] = limit
+
+        try:
+            return pd.read_sql(sql, self.conn, params=params)
+        except Exception as e:
+            st.error(f"Memo search failed: {e}")
+            return pd.DataFrame()
+
+    def search_events(
+        self,
+        query: str,
+        condition: Optional[str] = None,
+        limit: int = 50,
+    ) -> pd.DataFrame:
+        """Search PLC alarm events using both full-text and pattern matching.
+
+        Alarm messages contain sensor tags in bracket notation (e.g. [AI_PT110_Alarm]),
+        so we use ILIKE alongside tsvector to catch tag name patterns.
+        """
+        self._ensure_connection()
+        # Use ILIKE for pattern matching (catches sensor names in brackets)
+        # plus tsvector for any natural text content
+        sql = """
+        SELECT eventtimestamp, conditionname, message, inputvalue, limitvalue
+        FROM allevent
+        WHERE (
+            message ILIKE %(pattern)s
+            OR conditionname ILIKE %(pattern)s
+        )
+        """
+        params: Dict = {'query': query, 'pattern': f'%{query}%', 'limit': limit}
+        if condition:
+            sql += " AND conditionname = %(condition)s"
+            params['condition'] = condition
+        sql += " ORDER BY eventtimestamp DESC LIMIT %(limit)s"
+        try:
+            return pd.read_sql(sql, self.conn, params=params)
+        except Exception as e:
+            st.error(f"Event search failed: {e}")
+            return pd.DataFrame()
+
+    def get_event_conditions(self) -> List[str]:
+        """Get distinct condition types from allevent for filter dropdown."""
+        self._ensure_connection()
+        try:
+            with self.conn.cursor() as cur:
+                cur.execute(
+                    "SELECT conditionname, COUNT(*) as cnt FROM allevent "
+                    "GROUP BY conditionname ORDER BY cnt DESC"
+                )
+                return [row[0] for row in cur.fetchall() if row[0]]
+        except Exception:
+            return []
+
+    def search_tags_fuzzy(self, query: str, limit: int = 15) -> pd.DataFrame:
+        """Fuzzy tag/sensor search using pg_trgm similarity on tagimport."""
+        self._ensure_connection()
+        sql = """
+        SELECT tagname, tagdesc, tagunit,
+               greatest(
+                   similarity(lower(tagname), lower(%(query)s)),
+                   similarity(lower(coalesce(tagdesc, '')), lower(%(query)s))
+               ) AS sim
+        FROM tagimport
+        WHERE lower(tagname) %% lower(%(query)s)
+           OR lower(coalesce(tagdesc, '')) %% lower(%(query)s)
+        ORDER BY sim DESC
+        LIMIT %(limit)s
+        """
+        try:
+            return pd.read_sql(sql, self.conn, params={'query': query, 'limit': limit})
+        except Exception as e:
+            st.error(f"Tag search failed: {e}")
+            return pd.DataFrame()
+
+    def get_memo_engineers(self) -> List[str]:
+        """Get distinct engineers from memo_log for filter dropdown."""
+        self._ensure_connection()
+        try:
+            with self.conn.cursor() as cur:
+                cur.execute("SELECT DISTINCT engineer FROM memo_log WHERE engineer IS NOT NULL ORDER BY engineer")
+                return [row[0] for row in cur.fetchall()]
+        except Exception:
+            return []
+
+    def get_memo_severities(self) -> List[str]:
+        """Get distinct severity levels from memo_log for filter dropdown."""
+        self._ensure_connection()
+        try:
+            with self.conn.cursor() as cur:
+                cur.execute("SELECT DISTINCT severity FROM memo_log WHERE severity IS NOT NULL ORDER BY severity")
+                return [row[0] for row in cur.fetchall()]
+        except Exception:
+            return []
+
+    def close(self):
+        if self.conn:
+            self.conn.close()
+
+
+@st.cache_resource
+def get_db_connector() -> DatabaseConnector:
+    """Create a singleton database connector"""
+    return DatabaseConnector()

core/export_utils.py

@@ -0,0 +1,73 @@
+"""
+Export utilities for the Advanced Data Explorer.
+Downsampling, multi-window CSV packaging, size estimation.
+"""
+import io
+import zipfile
+import pandas as pd
+from typing import List, Optional
+
+
+def downsample_dataframe(df: pd.DataFrame, target_hz: float) -> pd.DataFrame:
+    """Downsample a time-indexed DataFrame to a target frequency.
+
+    Args:
+        df: DataFrame with a 'timestamp' column
+        target_hz: Target frequency in Hz
+
+    Returns:
+        Downsampled DataFrame
+    """
+    if "timestamp" not in df.columns or len(df) < 2:
+        return df
+
+    sorted_df = df.sort_values("timestamp")
+    dt = sorted_df["timestamp"].diff().dt.total_seconds().dropna()
+    current_hz = 1.0 / dt.median() if dt.median() > 0 else 1.0
+
+    if target_hz >= current_hz:
+        return sorted_df
+
+    step = max(1, int(round(current_hz / target_hz)))
+    return sorted_df.iloc[::step].reset_index(drop=True)
+
+
+def package_multi_window_csv(
+    dfs: List[pd.DataFrame],
+    labels: Optional[List[str]] = None,
+    base_filename: str = "export",
+) -> bytes:
+    """Package multiple DataFrames into a zip of CSVs.
+
+    Args:
+        dfs: List of DataFrames to export
+        labels: Optional labels for each window (used in filenames)
+        base_filename: Base filename for the zip
+
+    Returns:
+        Bytes of the zip file
+    """
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+        for i, df in enumerate(dfs):
+            label = labels[i] if labels and i < len(labels) else f"window_{i + 1}"
+            safe_label = label.replace(" ", "_").replace("/", "-")
+            csv_name = f"{base_filename}_{safe_label}.csv"
+            csv_bytes = df.to_csv(index=False).encode("utf-8")
+            zf.writestr(csv_name, csv_bytes)
+
+    buffer.seek(0)
+    return buffer.getvalue()
+
+
+def estimate_csv_size(df: pd.DataFrame) -> str:
+    """Estimate CSV file size as a human-readable string."""
+    # Rough estimate: 50 bytes per cell
+    cells = df.shape[0] * df.shape[1]
+    bytes_est = cells * 50
+    if bytes_est < 1024:
+        return f"{bytes_est} B"
+    elif bytes_est < 1024 * 1024:
+        return f"{bytes_est / 1024:.0f} KB"
+    else:
+        return f"{bytes_est / (1024 * 1024):.1f} MB"

core/timezone.py

@@ -0,0 +1,100 @@
+"""
+Timezone utilities for CSH2 Web Dashboard.
+
+The PLC logs in US/Eastern. The database has two time columns:
+  - dateandtime: Eastern local time (no timezone info)
+  - utc_full_timestamp: real UTC (timestamptz)
+
+The cycle_periods table stores Eastern times incorrectly labeled as UTC.
+This module provides consistent conversion and display helpers.
+"""
+from datetime import datetime, timedelta, timezone
+from zoneinfo import ZoneInfo
+import pandas as pd
+from core.config import DISPLAY_TZ, DISPLAY_TZ_LABEL, CYCLE_PERIODS_UTC_OFFSET
+
+
+def to_eastern(dt) -> datetime:
+    """Convert a UTC datetime to Eastern time for display.
+
+    Accepts timezone-aware (UTC) or naive (assumed UTC) datetimes.
+    Returns a timezone-aware datetime in US/Eastern.
+    """
+    if dt is None:
+        return None
+    if isinstance(dt, pd.Timestamp):
+        dt = dt.to_pydatetime()
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(DISPLAY_TZ)
+
+
+def to_utc(dt) -> datetime:
+    """Convert an Eastern datetime to UTC for database queries.
+
+    Accepts timezone-aware (Eastern) or naive (assumed Eastern) datetimes.
+    Returns a timezone-aware datetime in UTC.
+    """
+    if dt is None:
+        return None
+    if isinstance(dt, pd.Timestamp):
+        dt = dt.to_pydatetime()
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=DISPLAY_TZ)
+    return dt.astimezone(timezone.utc)
+
+
+def cycle_periods_to_utc(dt) -> datetime:
+    """Convert a cycle_periods timestamp (Eastern mislabeled as UTC) to real UTC.
+
+    The cycle_periods table stores Eastern local times with a +00:00 suffix.
+    Adding 4 hours converts to real UTC for sensor data queries.
+    """
+    if dt is None:
+        return None
+    if isinstance(dt, pd.Timestamp):
+        dt = dt.to_pydatetime()
+    return dt + CYCLE_PERIODS_UTC_OFFSET
+
+
+def cycle_periods_to_eastern(dt) -> datetime:
+    """Convert a cycle_periods timestamp to a properly labeled Eastern datetime.
+
+    The stored values ARE Eastern — just strip the wrong UTC label and apply
+    the correct US/Eastern timezone.
+    """
+    if dt is None:
+        return None
+    if isinstance(dt, pd.Timestamp):
+        dt = dt.to_pydatetime()
+    # Strip the incorrect UTC tzinfo, replace with Eastern
+    naive = dt.replace(tzinfo=None)
+    return naive.replace(tzinfo=DISPLAY_TZ)
+
+
+def format_et(dt, fmt: str = '%b %d %H:%M') -> str:
+    """Format a datetime for display in Eastern time.
+
+    If the datetime is UTC, converts to Eastern first.
+    Appends the timezone label.
+    """
+    if dt is None:
+        return "—"
+    eastern = to_eastern(dt) if (dt.tzinfo and dt.tzinfo != DISPLAY_TZ) else dt
+    return f"{eastern.strftime(fmt)} {DISPLAY_TZ_LABEL}"
+
+
+def convert_df_timestamps_to_eastern(df: pd.DataFrame, col: str = 'timestamp') -> pd.DataFrame:
+    """Convert a DataFrame's timestamp column from UTC to Eastern for display.
+
+    Returns a new DataFrame (does not modify in place).
+    """
+    if col not in df.columns:
+        return df
+    df = df.copy()
+    if df[col].dt.tz is not None:
+        df[col] = df[col].dt.tz_convert(DISPLAY_TZ)
+    else:
+        # Naive timestamps assumed UTC
+        df[col] = df[col].dt.tz_localize('UTC').dt.tz_convert(DISPLAY_TZ)
+    return df

pages/1_data_explorer.py

@@ -0,0 +1,236 @@
+"""
+Feature 1: Data Explorer - Pivot data view with interactive charts
+Now with Natural Language query support powered by Claude
+"""
+import streamlit as st
+import pandas as pd
+from core.db_connector import get_db_connector
+from core.cached_queries import cached_get_pivot_data
+from analysis.nl2sql import NLQueryParser
+from ui.components import page_header, tag_multiselect, date_range_picker, no_data_message
+from ui.plotly_charts import create_timeseries_chart
+from core.timezone import to_utc, convert_df_timestamps_to_eastern
+
+page_header(
+    "Data Explorer",
+    "View sensor data in wide format with tags as columns. Use natural language or the sidebar controls to query."
+)
+
+db = get_db_connector()
+nl_parser = NLQueryParser()
+
+# ── Natural Language Query Section ──
+st.subheader("Ask in Natural Language")
+
+nl_col1, nl_col2 = st.columns([5, 1])
+with nl_col1:
+    nl_query = st.text_input(
+        "Describe what data you want",
+        placeholder='e.g. "show me pressure and temperature from Sept 25 between 10am and 2pm"',
+        key="nl_query_input",
+        label_visibility="collapsed",
+    )
+with nl_col2:
+    nl_btn = st.button("Query", type="primary", use_container_width=True, key="nl_query_btn")
+
+# Process NL query
+nl_parsed = None
+if nl_btn and nl_query:
+    if not nl_parser.api_available:
+        st.error("Claude API key not configured. Add ANTHROPIC_API_KEY to your .env file for natural language queries.")
+    else:
+        with st.spinner("Interpreting your query..."):
+            all_sensors = db.get_all_tag_names()
+            nl_parsed = nl_parser.parse(nl_query, all_sensors)
+
+        if nl_parsed and 'error' in nl_parsed:
+            st.error(f"Could not parse query: {nl_parsed['error']}")
+            nl_parsed = None
+        elif nl_parsed:
+            # Store parsed result in session state for data fetch
+            st.session_state['nl_parsed'] = nl_parsed
+        else:
+            st.error("Could not understand the query. Try being more specific about sensors and time range.")
+
+# Check for stored NL result (persists across reruns)
+if 'nl_parsed' in st.session_state and st.session_state['nl_parsed']:
+    nl_parsed = st.session_state['nl_parsed']
+
+# Show parsed interpretation
+if nl_parsed and 'error' not in nl_parsed:
+    with st.container():
+        st.success(f"**Parsed:** {nl_parsed.get('explanation', '')}")
+        pcol1, pcol2, pcol3 = st.columns(3)
+        pcol1.markdown(f"**Sensors:** {', '.join(nl_parsed['sensors'])}")
+        pcol2.markdown(f"**From:** {nl_parsed['start_time'].strftime('%b %d, %Y %H:%M')}")
+        pcol3.markdown(f"**To:** {nl_parsed['end_time'].strftime('%b %d, %Y %H:%M')}")
+
+    col_fetch, col_clear = st.columns([1, 1])
+    with col_fetch:
+        nl_fetch_btn = st.button("Fetch Data", type="primary", use_container_width=True, key="nl_fetch_btn")
+    with col_clear:
+        nl_clear_btn = st.button("Clear", use_container_width=True, key="nl_clear_btn")
+
+    if nl_clear_btn:
+        del st.session_state['nl_parsed']
+        st.rerun()
+
+    if nl_fetch_btn:
+        selected_tags = nl_parsed['sensors']
+        # NL parser returns naive datetimes — treat as Eastern, convert to UTC for queries
+        start_dt = to_utc(nl_parsed['start_time'])
+        end_dt = to_utc(nl_parsed['end_time'])
+
+        duration_hours = (end_dt - start_dt).total_seconds() / 3600
+        table_used = db._select_table(start_dt, end_dt)
+        table_label = {
+            'procdatafloattable': 'Raw (10Hz)',
+            'procdatafloattable_utc_1sec': '1-second aggregates',
+            'procdatafloattable_utc_15sec': '15-second aggregates',
+        }.get(table_used, table_used)
+
+        with st.spinner(f"Querying {len(selected_tags)} sensors ({duration_hours:.1f} hours) from {table_label}..."):
+            df_pivot = cached_get_pivot_data(tuple(selected_tags), start_dt, end_dt)
+
+        if df_pivot.empty:
+            no_data_message()
+        else:
+            # Convert timestamps to Eastern for display
+            df_pivot = convert_df_timestamps_to_eastern(df_pivot)
+
+            # Summary metrics
+            cols = st.columns(4)
+            cols[0].metric("Rows", f"{len(df_pivot):,}")
+            cols[1].metric("Sensors", len(selected_tags))
+            cols[2].metric("Duration", f"{duration_hours:.1f} hrs")
+            cols[3].metric("Table", table_label)
+
+            st.divider()
+
+            # Interactive chart
+            tags_in_data = [t for t in selected_tags if t in df_pivot.columns]
+            if tags_in_data:
+                chart_title = f"{', '.join(tags_in_data[:3])}{'...' if len(tags_in_data) > 3 else ''}"
+                fig = create_timeseries_chart(df_pivot, tags_in_data, title=chart_title)
+                st.plotly_chart(fig, use_container_width=True)
+
+            st.divider()
+
+            # Summary statistics
+            with st.expander("Summary Statistics", expanded=True):
+                stats_data = []
+                for tag in tags_in_data:
+                    col_data = df_pivot[tag].dropna()
+                    if len(col_data) > 0:
+                        stats_data.append({
+                            'Sensor': tag,
+                            'Count': len(col_data),
+                            'Min': f"{col_data.min():.4f}",
+                            'Max': f"{col_data.max():.4f}",
+                            'Mean': f"{col_data.mean():.4f}",
+                            'Std': f"{col_data.std():.4f}",
+                        })
+                if stats_data:
+                    st.dataframe(pd.DataFrame(stats_data), use_container_width=True, hide_index=True)
+
+            # Data table
+            with st.expander("Data Table", expanded=False):
+                st.dataframe(df_pivot, use_container_width=True, height=400)
+
+            # CSV download
+            csv = df_pivot.to_csv(index=False)
+            st.download_button(
+                label="Download CSV",
+                data=csv,
+                file_name=f"csh2_data_{start_dt.strftime('%Y%m%d_%H%M')}_{end_dt.strftime('%Y%m%d_%H%M')}.csv",
+                mime="text/csv",
+            )
+
+    st.divider()
+
+st.caption("Or use the sidebar controls for manual selection:")
+
+# ── Sidebar controls (manual mode) ──
+with st.sidebar:
+    st.subheader("Manual Query")
+    selected_tags = tag_multiselect(db, key="explorer")
+    st.divider()
+    start_dt, end_dt = date_range_picker(key="explorer")
+
+    query_btn = st.button("Fetch Data", type="primary", use_container_width=True, key="manual_fetch_btn")
+
+# Main content (manual mode)
+if query_btn and selected_tags:
+    # Manual date picker returns naive datetimes — treat as Eastern, convert to UTC for queries
+    start_dt_utc = to_utc(start_dt)
+    end_dt_utc = to_utc(end_dt)
+
+    if start_dt >= end_dt:
+        st.error("Start time must be before end time.")
+    else:
+        duration_hours = (end_dt_utc - start_dt_utc).total_seconds() / 3600
+        table_used = db._select_table(start_dt_utc, end_dt_utc)
+        table_label = {
+            'procdatafloattable': 'Raw (10Hz)',
+            'procdatafloattable_utc_1sec': '1-second aggregates',
+            'procdatafloattable_utc_15sec': '15-second aggregates',
+        }.get(table_used, table_used)
+
+        with st.spinner(f"Querying {len(selected_tags)} sensors ({duration_hours:.1f} hours) from {table_label}..."):
+            df_pivot = cached_get_pivot_data(tuple(selected_tags), start_dt_utc, end_dt_utc)
+
+        if df_pivot.empty:
+            no_data_message()
+        else:
+            # Convert timestamps to Eastern for display
+            df_pivot = convert_df_timestamps_to_eastern(df_pivot)
+            # Summary metrics
+            cols = st.columns(4)
+            cols[0].metric("Rows", f"{len(df_pivot):,}")
+            cols[1].metric("Sensors", len(selected_tags))
+            cols[2].metric("Duration", f"{duration_hours:.1f} hrs")
+            cols[3].metric("Table", table_label)
+
+            st.divider()
+
+            # Interactive chart
+            tags_in_data = [t for t in selected_tags if t in df_pivot.columns]
+            if tags_in_data:
+                chart_title = f"{', '.join(tags_in_data[:3])}{'...' if len(tags_in_data) > 3 else ''}"
+                fig = create_timeseries_chart(df_pivot, tags_in_data, title=chart_title)
+                st.plotly_chart(fig, use_container_width=True)
+
+            st.divider()
+
+            # Summary statistics
+            with st.expander("Summary Statistics", expanded=True):
+                stats_data = []
+                for tag in tags_in_data:
+                    col_data = df_pivot[tag].dropna()
+                    if len(col_data) > 0:
+                        stats_data.append({
+                            'Sensor': tag,
+                            'Count': len(col_data),
+                            'Min': f"{col_data.min():.4f}",
+                            'Max': f"{col_data.max():.4f}",
+                            'Mean': f"{col_data.mean():.4f}",
+                            'Std': f"{col_data.std():.4f}",
+                        })
+                if stats_data:
+                    st.dataframe(pd.DataFrame(stats_data), use_container_width=True, hide_index=True)
+
+            # Data table
+            with st.expander("Data Table", expanded=False):
+                st.dataframe(df_pivot, use_container_width=True, height=400)
+
+            # CSV download
+            csv = df_pivot.to_csv(index=False)
+            st.download_button(
+                label="Download CSV",
+                data=csv,
+                file_name=f"csh2_data_{start_dt.strftime('%Y%m%d_%H%M')}_{end_dt.strftime('%Y%m%d_%H%M')}.csv",
+                mime="text/csv",
+            )
+
+elif query_btn and not selected_tags:
+    st.warning("Please select at least one sensor from the sidebar.")

pages/2_pump_cycles.py

@@ -0,0 +1,117 @@
+"""
+Feature 2: Testing Cycle Browser
+Month-year filter with pre-computed cycles from the cycle_periods DB table.
+"""
+import streamlit as st
+import pandas as pd
+from core.db_connector import get_db_connector
+from ui.components import page_header, metric_row
+from ui.plotly_charts import create_cycle_timeline
+
+page_header(
+    "Testing Cycles",
+    "Cycles are identified from motor activity — >0% starts a cycle and returning to 0% ends a cycle. "
+    "To qualify, a testing cycle must show either >5% motor speed OR >10 sec duration observed."
+)
+
+db = get_db_connector()
+
+
+@st.cache_data(ttl=3600)
+def get_available_months():
+    return db.get_available_months()
+
+
+@st.cache_data(ttl=3600)
+def get_cycle_months():
+    return db.get_cycle_months()
+
+
+@st.cache_data(ttl=600)
+def load_cycles_for_month(month_str: str):
+    """Load pre-computed cycles from cycle_periods table for a given month."""
+    return db.get_cycle_periods(month_str)
+
+
+@st.cache_data(ttl=600)
+def load_all_cycles():
+    """Load all pre-computed cycles (for cross-page use)."""
+    return db.get_cycle_periods()
+
+
+# Sidebar: month selector
+with st.sidebar:
+    st.subheader("Select Period")
+    sensor_months = get_available_months()
+    cycle_months = get_cycle_months()
+    months = sorted(set(sensor_months) | set(cycle_months))
+
+    if not months:
+        st.error("No data months found in database.")
+        st.stop()
+
+    selected_month = st.selectbox(
+        "Month",
+        months,
+        index=len(months) - 1,  # Default to most recent
+        key="cycle_month",
+    )
+
+# Load cycles for selected month
+cycles = load_cycles_for_month(selected_month)
+
+# Also cache all cycles for the comparison page
+all_cycles = load_all_cycles()
+st.session_state.all_cycles = all_cycles
+
+if not cycles:
+    st.info(f"No testing cycles found in {selected_month}.")
+else:
+    # Summary metrics
+    total_runtime = sum(c['duration_minutes'] for c in cycles)
+    peak_pressures = [c.get('peak_pressure', 0) for c in cycles if c.get('peak_pressure')]
+    max_pressure = max(peak_pressures) if peak_pressures else 0
+    total_dispensed = sum(c.get('total_kg_dispensed', 0) for c in cycles)
+
+    metrics = [
+        {'label': 'Cycles', 'value': len(cycles), 'unit': ''},
+        {'label': 'Total Runtime', 'value': f"{total_runtime:.0f}", 'unit': 'min'},
+        {'label': 'Peak Pressure (PT130)', 'value': f"{max_pressure:.0f}", 'unit': 'bar'},
+        {'label': 'Total Dispensed', 'value': f"{total_dispensed:.1f}", 'unit': 'kg'},
+    ]
+    metric_row(metrics)
+
+    st.divider()
+
+    # Timeline chart
+    fig = create_cycle_timeline(cycles, selected_month)
+    st.plotly_chart(fig, use_container_width=True)
+
+    st.divider()
+
+    # Cycle table
+    st.subheader("Cycle Details")
+
+    table_data = []
+    for c in cycles:
+        display_start = c.get('start_time_et') or c['start_time']
+        display_end = c.get('end_time_et') or c['end_time']
+        table_data.append({
+            'Cycle': c['cycle_id'],
+            'Start (ET)': display_start.strftime('%b %d %H:%M'),
+            'End (ET)': display_end.strftime('%b %d %H:%M'),
+            'Duration (min)': f"{c['duration_minutes']:.1f}",
+            'Peak Speed (RPM)': f"{c.get('peak_speed', 0):.0f}",
+            'Peak Pressure (bar)': f"{c.get('peak_pressure', 0):.0f}" if c.get('peak_pressure') else 'N/A',
+            'Avg Flow (kg/min)': f"{c.get('avg_flow', 0):.2f}" if c.get('avg_flow') else 'N/A',
+            'Dispensed (kg)': f"{c.get('total_kg_dispensed', 0):.2f}" if c.get('total_kg_dispensed') else 'N/A',
+            'Pump Strokes': f"{c.get('total_pump_strokes', 0):.0f}" if c.get('total_pump_strokes') else 'N/A',
+        })
+
+    df_table = pd.DataFrame(table_data)
+    st.dataframe(df_table, use_container_width=True, hide_index=True)
+
+    # Store cycles in session state for other pages
+    st.session_state.detected_cycles = cycles
+
+    st.info("Select a cycle above, then navigate to **Cycle Detail** page for in-depth analysis.")

pages/3_cycle_detail.py

@@ -0,0 +1,179 @@
+"""
+Feature 3: Cycle Detail View
+KPI cards, multi-axis chart, plateau detection
+"""
+import streamlit as st
+import pandas as pd
+from core.db_connector import get_db_connector
+from core.cached_queries import cached_get_pivot_data
+from core import config
+from analysis.basic_analysis import DataAnalyzer
+from analysis.advanced_analysis import AdvancedAnalyzer
+from ui.components import page_header, metric_row, cycle_selector, no_data_message
+from ui.plotly_charts import create_multi_axis_chart
+from core.timezone import convert_df_timestamps_to_eastern
+
+page_header(
+    "Cycle Detail",
+    "In-depth analysis of a selected testing cycle with KPIs, charts, and plateau detection."
+)
+
+db = get_db_connector()
+analyzer = DataAnalyzer()
+adv_analyzer = AdvancedAnalyzer()
+
+# Check if cycles are loaded; fallback to DB if needed
+cycles = st.session_state.get('detected_cycles', [])
+
+if not cycles:
+    # Fallback: load all cycles from cycle_periods table
+    all_db_cycles = db.get_cycle_periods()
+    if all_db_cycles:
+        cycles = all_db_cycles
+        st.session_state.detected_cycles = cycles
+        st.info("Cycles loaded from database. Visit **Testing Cycles** page to filter by month.")
+    else:
+        st.warning("No cycles found. Check database connectivity or go to **Testing Cycles** page.")
+        st.stop()
+
+# Sidebar: cycle selector
+with st.sidebar:
+    st.subheader("Select Cycle")
+    month = st.session_state.get('cycle_month', '')
+    if month:
+        st.caption(f"Month: {month}")
+
+    selected_cycle = cycle_selector(cycles, key_prefix="detail")
+
+if selected_cycle is None:
+    st.stop()
+
+# Fetch cycle data
+st.subheader(f"Cycle {selected_cycle['cycle_id']}")
+
+# Determine which tags are available
+detail_tags = [t for t in config.CYCLE_DETAIL_TAGS if db.get_tag_index(t) is not None]
+
+with st.spinner("Loading cycle data..."):
+    df_pivot = cached_get_pivot_data(
+        tuple(detail_tags),
+        selected_cycle['start_time'],
+        selected_cycle['end_time'],
+    )
+
+if df_pivot.empty:
+    no_data_message()
+    st.stop()
+
+# Convert timestamps to Eastern for display
+df_pivot = convert_df_timestamps_to_eastern(df_pivot)
+
+# Run analysis
+cycle_stats = analyzer.analyze_cycle(df_pivot)
+
+# Store for LLM pages
+st.session_state.current_cycle_stats = cycle_stats
+st.session_state.current_cycle = selected_cycle
+st.session_state.current_cycle_df = df_pivot
+
+# KPI Cards
+kpi_metrics = []
+
+if 'discharge_pressure' in cycle_stats:
+    dp = cycle_stats['discharge_pressure']
+    kpi_metrics.append({'label': 'Peak Pressure (PT130)', 'value': f"{dp['peak']:.0f}", 'unit': 'bar'})
+
+if 'time_range' in cycle_stats:
+    tr = cycle_stats['time_range']
+    kpi_metrics.append({'label': 'Duration', 'value': f"{tr['duration_minutes']:.0f}", 'unit': 'min'})
+
+if 'compression_ratio' in cycle_stats:
+    cr = cycle_stats['compression_ratio']
+    kpi_metrics.append({'label': 'Compression Ratio', 'value': f"{cr['avg']:.1f}x", 'unit': ''})
+
+if 'motor' in cycle_stats:
+    m = cycle_stats['motor']
+    kpi_metrics.append({'label': 'Peak Motor Speed', 'value': f"{m['peak_speed']:.0f}", 'unit': 'RPM'})
+
+if 'flow' in cycle_stats:
+    f = cycle_stats['flow']
+    kpi_metrics.append({'label': 'Avg Flow', 'value': f"{f['avg_flow']:.2f}", 'unit': 'kg/min'})
+
+for key in ['temperature_TT110', 'temperature_TT130']:
+    if key in cycle_stats:
+        t = cycle_stats[key]
+        tag = key.replace('temperature_', '')
+        kpi_metrics.append({'label': f'Peak {tag}', 'value': f"{t['peak']:.1f}", 'unit': 'K'})
+
+if kpi_metrics:
+    # Display in rows of 4
+    for i in range(0, len(kpi_metrics), 4):
+        metric_row(kpi_metrics[i:i+4])
+
+st.divider()
+
+# Plateau Detection
+pressure_tags_available = [t for t in ['PT130', 'PT01T', 'PT110'] if t in df_pivot.columns]
+temp_tags_available = [t for t in ['TT110', 'TT130'] if t in df_pivot.columns]
+other_tags_available = [t for t in ['FT140', 'M130_Speed', 'MC130_VFD_Speed', 'AOV140'] if t in df_pivot.columns]
+
+all_plateau_tags = pressure_tags_available + temp_tags_available
+
+
+@st.cache_data(ttl=600)
+def _detect_plateaus(_df_pivot, tags: tuple, tolerance: float, min_duration: float):
+    """Cached plateau detection to avoid repeated CPU-bound ops on rerun"""
+    _adv = AdvancedAnalyzer()
+    result = {}
+    for tag in tags:
+        periods = _adv.detect_constant_periods(_df_pivot, tag, tolerance, min_duration)
+        if periods:
+            result[tag] = periods
+    return result
+
+
+plateaus = _detect_plateaus(df_pivot, tuple(all_plateau_tags), 0.02, 1.0)
+
+# Store plateaus for LLM page
+st.session_state.current_plateaus = plateaus
+
+# Multi-axis chart with plateau highlights
+# Use Eastern times for chart display
+display_start = selected_cycle.get('start_time_et') or selected_cycle['start_time']
+display_end = selected_cycle.get('end_time_et') or selected_cycle['end_time']
+
+fig = create_multi_axis_chart(
+    df_pivot,
+    pressure_tags=pressure_tags_available,
+    temp_tags=temp_tags_available,
+    other_tags=other_tags_available,
+    title=f"Cycle {selected_cycle['cycle_id']} — {display_start.strftime('%b %d %H:%M')} ET",
+    height=600,
+    plateaus=plateaus,
+    time_range=(display_start, display_end),
+)
+st.plotly_chart(fig, use_container_width=True)
+
+st.divider()
+
+# Plateau tables
+if plateaus:
+    st.subheader("Detected Plateaus (Constant Periods)")
+
+    tabs = st.tabs(list(plateaus.keys()))
+    for tab, (tag, periods) in zip(tabs, plateaus.items()):
+        with tab:
+            rows = []
+            for i, p in enumerate(periods, 1):
+                rows.append({
+                    '#': i,
+                    'Start': p['start'].strftime('%H:%M:%S'),
+                    'End': p['end'].strftime('%H:%M:%S'),
+                    'Duration (min)': f"{p['duration_minutes']:.1f}",
+                    'Value': f"{p['value']:.2f}",
+                })
+            st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
+else:
+    st.info("No significant plateaus detected in this cycle.")
+
+st.caption("Navigate to **Variation Analysis** for LLM-powered interpretation of this cycle.")

pages/4_variation_analysis.py

@@ -0,0 +1,113 @@
+"""
+Feature 4: LLM-Driven Variation Analysis
+Claude explains variations and stabilizations in a testing cycle
+"""
+import streamlit as st
+from core.db_connector import get_db_connector
+from analysis.llm_analyzer import LLMCycleAnalyzer
+from ui.components import page_header, analysis_card, follow_up_section
+
+page_header(
+    "Variation Analysis",
+    "AI-powered interpretation of pressure/temperature variations and stabilizations in a testing cycle."
+)
+
+db = get_db_connector()
+llm = LLMCycleAnalyzer()
+
+# Check prerequisites
+cycle_stats = st.session_state.get('current_cycle_stats')
+current_cycle = st.session_state.get('current_cycle')
+plateaus = st.session_state.get('current_plateaus', {})
+
+if not cycle_stats or not current_cycle:
+    st.warning(
+        "No cycle selected. Please go to **Testing Cycles** to detect cycles, "
+        "then **Cycle Detail** to select and analyze a specific cycle."
+    )
+    st.stop()
+
+# Header info
+st.subheader(f"Cycle {current_cycle['cycle_id']} - {current_cycle['start_time'].strftime('%b %d %H:%M')}")
+
+col1, col2, col3 = st.columns(3)
+col1.metric("Duration", f"{cycle_stats['time_range']['duration_minutes']:.0f} min")
+
+if 'discharge_pressure' in cycle_stats:
+    col2.metric("Peak PT130", f"{cycle_stats['discharge_pressure']['peak']:.0f} bar")
+
+plateau_count = sum(len(p) for p in plateaus.values())
+col3.metric("Plateaus", plateau_count)
+
+st.divider()
+
+# LLM availability check
+if not llm.api_available:
+    st.error("Claude API key not configured. Add ANTHROPIC_API_KEY to your .env file to enable AI analysis.")
+    st.stop()
+
+# Check for cached result
+cache_key = f"variation_{current_cycle['cycle_id']}_{current_cycle['start_time']}"
+prompt_key = f"{cache_key}_prompt"
+followup_key = f"{cache_key}_followups"
+cached_result = st.session_state.get(cache_key)
+
+if cached_result:
+    analysis_card("AI Analysis", cached_result)
+
+    # Follow-up section
+    original_prompt = st.session_state.get(prompt_key, "")
+    follow_up_section(
+        session_key=followup_key,
+        llm_analyzer=llm,
+        original_prompt=original_prompt,
+        original_analysis=cached_result,
+    )
+
+    if st.button("Re-analyze", key="reanalyze_variation"):
+        del st.session_state[cache_key]
+        st.session_state.pop(prompt_key, None)
+        st.session_state.pop(followup_key, None)
+        st.rerun()
+else:
+    st.info("Click below to generate an AI-powered analysis of this cycle's variations and stabilizations.")
+
+    if st.button("Analyze Cycle", type="primary", use_container_width=True):
+        with st.spinner("Claude is analyzing the cycle data..."):
+            result = llm.analyze_cycle_variations(
+                cycle_stats=cycle_stats,
+                plateaus=plateaus,
+            )
+
+        # Store the prompt that was used (for follow-up context)
+        st.session_state[prompt_key] = llm._build_variation_prompt(
+            cycle_stats, plateaus, None,
+            llm.retriever.format_for_prompt(
+                llm.retriever.get_context_for_cycle(cycle_stats, plateaus)
+            ) if llm.retriever else "",
+        )
+        st.session_state[cache_key] = result
+        st.rerun()
+
+# Show input data summary
+with st.expander("Data sent to AI", expanded=False):
+    st.json({
+        'time_range': {
+            'start': str(cycle_stats['time_range']['start']),
+            'end': str(cycle_stats['time_range']['end']),
+            'duration_minutes': cycle_stats['time_range']['duration_minutes'],
+        },
+        'discharge_pressure': cycle_stats.get('discharge_pressure'),
+        'compression_ratio': cycle_stats.get('compression_ratio'),
+        'flow': cycle_stats.get('flow'),
+        'ramp_rate': cycle_stats.get('ramp_rate'),
+        'motor': cycle_stats.get('motor'),
+        'plateaus': {
+            tag: [
+                {'value': p['value'], 'duration_min': p['duration_minutes']}
+                for p in periods
+            ]
+            for tag, periods in plateaus.items()
+        },
+        'performance_vs_targets': cycle_stats.get('performance_vs_targets'),
+    })

pages/5_cycle_comparison.py

@@ -0,0 +1,245 @@
+"""
+Feature 5: LLM-Driven Cycle Comparison
+Side-by-side comparison of two testing cycles with AI narrative.
+Supports cross-month comparison — cycles loaded directly from cycle_periods DB table.
+"""
+import streamlit as st
+import pandas as pd
+from core.db_connector import get_db_connector
+from core import config
+from analysis.basic_analysis import DataAnalyzer
+from analysis.llm_analyzer import LLMCycleAnalyzer
+from ui.components import page_header, cycle_selector, metric_row, analysis_card, follow_up_section
+from ui.plotly_charts import create_comparison_chart
+from core.timezone import convert_df_timestamps_to_eastern
+
+page_header(
+    "Cycle Comparison",
+    "Compare two testing cycles side-by-side with AI-powered analysis of differences."
+)
+
+db = get_db_connector()
+analyzer = DataAnalyzer()
+llm = LLMCycleAnalyzer()
+
+
+# ── Load all cycles directly from DB ────────────────────────────
+
+@st.cache_data(ttl=600)
+def load_all_cycles():
+    return db.get_cycle_periods()
+
+
+@st.cache_data(ttl=3600)
+def get_available_months():
+    return db.get_available_months()
+
+
+@st.cache_data(ttl=3600)
+def get_cycle_months():
+    return db.get_cycle_months()
+
+
+all_cycles = load_all_cycles()
+sensor_months = get_available_months()
+cycle_months = get_cycle_months()
+available_months = sorted(set(sensor_months) | set(cycle_months))
+
+if len(all_cycles) < 2:
+    st.warning("Need at least 2 cycles in the database for comparison.")
+    st.stop()
+
+
+# ── Cycle Selection with Independent Month Filters ──────────────
+
+@st.cache_data(ttl=600)
+def load_cycle_data(start_time, end_time):
+    """Load and analyze a cycle's data"""
+    detail_tags = [t for t in config.CYCLE_DETAIL_TAGS if db.get_tag_index(t) is not None]
+    df_pivot = db.get_pivot_data(detail_tags, start_time, end_time)
+    if df_pivot.empty:
+        return None, None
+    # Convert timestamps to Eastern for display
+    df_pivot = convert_df_timestamps_to_eastern(df_pivot)
+    stats = analyzer.analyze_cycle(df_pivot)
+    return df_pivot, stats
+
+
+month_options = ["All Months"] + available_months
+
+col_a, col_b = st.columns(2)
+
+with col_a:
+    st.subheader("Cycle A")
+    month_a = st.selectbox("Filter by month", month_options, key="comp_month_a")
+    if month_a == "All Months":
+        filtered_a = all_cycles
+    else:
+        filtered_a = [c for c in all_cycles if (c.get('start_time_et') or c['start_time']).strftime('%Y-%m') == month_a]
+    cycle_a = cycle_selector(filtered_a, key_prefix="comp_a")
+
+with col_b:
+    st.subheader("Cycle B")
+    month_b = st.selectbox("Filter by month", month_options, key="comp_month_b")
+    if month_b == "All Months":
+        filtered_b = all_cycles
+    else:
+        filtered_b = [c for c in all_cycles if (c.get('start_time_et') or c['start_time']).strftime('%Y-%m') == month_b]
+    cycle_b = cycle_selector(filtered_b, key_prefix="comp_b")
+
+if cycle_a is None or cycle_b is None:
+    st.stop()
+
+if cycle_a['cycle_id'] == cycle_b['cycle_id']:
+    st.warning("Please select two different cycles to compare.")
+    st.stop()
+
+# Load data for both cycles
+with st.spinner("Loading cycle data..."):
+    df_a, stats_a = load_cycle_data(cycle_a['start_time'], cycle_a['end_time'])
+    df_b, stats_b = load_cycle_data(cycle_b['start_time'], cycle_b['end_time'])
+
+if df_a is None or df_b is None:
+    st.error("Could not load data for one or both cycles.")
+    st.stop()
+
+st.divider()
+
+# Side-by-side metrics
+st.subheader("Key Metrics Comparison")
+
+metrics_table = []
+
+
+def add_metric(label, key_path_a, key_path_b, fmt=".1f", unit=""):
+    """Helper to extract nested dict values for comparison"""
+    val_a = stats_a
+    val_b = stats_b
+    for key in key_path_a:
+        val_a = val_a.get(key, {}) if isinstance(val_a, dict) else None
+    for key in key_path_b:
+        val_b = val_b.get(key, {}) if isinstance(val_b, dict) else None
+
+    # Ensure final values are numeric, not residual dicts from missing keys
+    if not isinstance(val_a, (int, float)):
+        val_a = None
+    if not isinstance(val_b, (int, float)):
+        val_b = None
+
+    if val_a is not None and val_b is not None:
+        diff = val_a - val_b
+        metrics_table.append({
+            'Metric': label,
+            f'Cycle {cycle_a["cycle_id"]}': f"{val_a:{fmt}} {unit}".strip(),
+            f'Cycle {cycle_b["cycle_id"]}': f"{val_b:{fmt}} {unit}".strip(),
+            'Difference': f"{diff:+{fmt}} {unit}".strip(),
+        })
+
+
+add_metric("Duration (min)", ['time_range', 'duration_minutes'], ['time_range', 'duration_minutes'], ".0f", "min")
+add_metric("Peak Pressure", ['discharge_pressure', 'peak'], ['discharge_pressure', 'peak'], ".0f", "bar")
+add_metric("Avg Pressure", ['discharge_pressure', 'avg'], ['discharge_pressure', 'avg'], ".1f", "bar")
+add_metric("Compression Ratio (avg)", ['compression_ratio', 'avg'], ['compression_ratio', 'avg'], ".1f", "x")
+add_metric("Avg Flow", ['flow', 'avg_flow'], ['flow', 'avg_flow'], ".2f", "kg/min")
+add_metric("Peak TT110", ['temperature_TT110', 'peak'], ['temperature_TT110', 'peak'], ".1f", "K")
+add_metric("Peak TT130", ['temperature_TT130', 'peak'], ['temperature_TT130', 'peak'], ".1f", "K")
+
+if 'motor' in stats_a and 'motor' in stats_b:
+    add_metric("Peak Motor Speed", ['motor', 'peak_speed'], ['motor', 'peak_speed'], ".0f", "RPM")
+
+if 'ramp_rate' in stats_a and 'ramp_rate' in stats_b:
+    add_metric("Max Ramp Rate", ['ramp_rate', 'max'], ['ramp_rate', 'max'], ".1f", "bar/min")
+
+if metrics_table:
+    st.dataframe(pd.DataFrame(metrics_table), use_container_width=True, hide_index=True)
+
+# Cycle metadata from DB (new fields)
+st.divider()
+st.subheader("Cycle Metadata (from DB)")
+meta_cols = st.columns(2)
+
+for meta_col, cycle, label in [(meta_cols[0], cycle_a, "A"), (meta_cols[1], cycle_b, "B")]:
+    with meta_col:
+        _et = (cycle.get('start_time_et') or cycle['start_time']).strftime('%b %d %H:%M')
+        st.markdown(f"**Cycle {cycle['cycle_id']}** ({_et} ET)")
+        m_cols = st.columns(2)
+        m_cols[0].metric("Dispensed", f"{cycle.get('total_kg_dispensed', 0):.2f} kg")
+        m_cols[1].metric("Pump Strokes", f"{cycle.get('total_pump_strokes', 0):.0f}")
+
+st.divider()
+
+# Comparison charts
+st.subheader("Overlaid Comparison Charts")
+
+# Find common tags
+common_tags = [t for t in df_a.columns if t in df_b.columns and t != 'timestamp']
+chart_tags = [t for t in ['PT130', 'TT110', 'TT130', 'FT140', 'M130_Speed', 'MC130_VFD_Speed'] if t in common_tags]
+
+if chart_tags:
+    selected_chart_tag = st.selectbox(
+        "Select sensor to compare",
+        chart_tags,
+        key="comparison_tag",
+    )
+
+    _et_a = (cycle_a.get('start_time_et') or cycle_a['start_time']).strftime('%b %d %H:%M')
+    _et_b = (cycle_b.get('start_time_et') or cycle_b['start_time']).strftime('%b %d %H:%M')
+    label_a = f"Cycle {cycle_a['cycle_id']} ({_et_a} ET)"
+    label_b = f"Cycle {cycle_b['cycle_id']} ({_et_b} ET)"
+
+    fig = create_comparison_chart(df_a, df_b, selected_chart_tag, label_a, label_b)
+    st.plotly_chart(fig, use_container_width=True)
+
+st.divider()
+
+# LLM Comparison
+st.subheader("AI Comparison Analysis")
+
+if not llm.api_available:
+    st.error("Claude API key not configured. Add ANTHROPIC_API_KEY to your .env file.")
+    st.stop()
+
+cache_key = f"comparison_{cycle_a['cycle_id']}_{cycle_b['cycle_id']}"
+prompt_key = f"{cache_key}_prompt"
+followup_key = f"{cache_key}_followups"
+cached_result = st.session_state.get(cache_key)
+
+if cached_result:
+    analysis_card("AI Comparison", cached_result)
+
+    # Follow-up section
+    original_prompt = st.session_state.get(prompt_key, "")
+    follow_up_section(
+        session_key=followup_key,
+        llm_analyzer=llm,
+        original_prompt=original_prompt,
+        original_analysis=cached_result,
+    )
+
+    if st.button("Re-analyze", key="reanalyze_comparison"):
+        del st.session_state[cache_key]
+        st.session_state.pop(prompt_key, None)
+        st.session_state.pop(followup_key, None)
+        st.rerun()
+else:
+    if st.button("Compare with AI", type="primary", use_container_width=True):
+        label_a = f"Cycle {cycle_a['cycle_id']} ({(cycle_a.get('start_time_et') or cycle_a['start_time']).strftime('%b %d')} ET)"
+        label_b = f"Cycle {cycle_b['cycle_id']} ({(cycle_b.get('start_time_et') or cycle_b['start_time']).strftime('%b %d')} ET)"
+
+        # Build and store the prompt for follow-up context
+        knowledge_text = ""
+        if llm.retriever:
+            try:
+                context = llm.retriever.get_context_for_comparison(stats_a, stats_b)
+                knowledge_text = llm.retriever.format_for_prompt(context)
+            except Exception:
+                pass
+        st.session_state[prompt_key] = llm._build_comparison_prompt(
+            stats_a, stats_b, label_a, label_b, knowledge_text
+        )
+
+        with st.spinner("Claude is comparing the two cycles..."):
+            result = llm.compare_cycles(stats_a, stats_b, label_a, label_b)
+
+        st.session_state[cache_key] = result
+        st.rerun()

pages/6_advanced_explorer.py

@@ -0,0 +1,437 @@
+"""
+Advanced Data Explorer — LLM-Powered Analytical Queries
+Decomposes natural language into structured execution plans,
+runs whitelisted operations, and presents results with exports.
+"""
+import json
+import copy
+import streamlit as st
+import pandas as pd
+from datetime import datetime
+
+from core.db_connector import get_db_connector
+from analysis.query_planner import QueryPlanner
+from analysis.execution_engine import ExecutionEngine
+from analysis.result_interpreter import ResultInterpreter
+from analysis.operations import OperationOutput
+from core.export_utils import package_multi_window_csv, estimate_csv_size
+from ui.components import page_header, analysis_card, follow_up_section
+from analysis.llm_analyzer import LLMCycleAnalyzer
+from ui.plotly_charts import create_timeseries_chart
+
+
+# ── Helper Functions (defined first for Streamlit top-to-bottom flow) ──
+
+
+def _plan_to_serializable(plan: dict) -> dict:
+    """Convert plan with datetimes to JSON-serializable dict."""
+    p = copy.deepcopy(plan)
+    dr = p.get("data_requirements", {})
+    for key in ("start_time", "end_time"):
+        if isinstance(dr.get(key), datetime):
+            dr[key] = dr[key].isoformat()
+    return p
+
+
+def _render_dict_result(data: dict, op_result: OperationOutput):
+    """Render a dict result (e.g., pump strokes, statistics)."""
+    # Special rendering for pump stroke results
+    if "total_revolutions" in data:
+        cols = st.columns(4)
+        cols[0].metric("Total Revolutions", f"{data.get('total_revolutions', 0):,}")
+        cols[1].metric("Avg RPM", f"{data.get('avg_rpm', 0):.1f}")
+        cols[2].metric("Peak RPM", f"{data.get('peak_rpm', 0):.1f}")
+        cols[3].metric("Active Time", f"{data.get('active_minutes', 0):.1f} min")
+
+        if data.get("note"):
+            st.info(data["note"])
+        return
+
+    # Blocks result from find_peak_pressure_blocks
+    if "blocks" in data:
+        blocks = data["blocks"]
+        if blocks:
+            st.markdown(f"Found **{len(blocks)}** time blocks")
+            block_df = pd.DataFrame(blocks)
+            st.dataframe(block_df, use_container_width=True, hide_index=True)
+        else:
+            st.info("No blocks found matching the criteria.")
+        return
+
+    # Generic dict
+    for key, val in data.items():
+        st.markdown(f"**{key}:** {val}")
+
+
+def _render_list_result(data: list, op_result: OperationOutput):
+    """Render a list-of-dicts result (fills, periods, ramps)."""
+    st.markdown(f"Found **{len(data)}** results")
+
+    result_df = pd.DataFrame(data)
+
+    # Format datetime columns for display
+    for col in result_df.columns:
+        if pd.api.types.is_datetime64_any_dtype(result_df[col]):
+            result_df[col] = result_df[col].dt.strftime("%Y-%m-%d %H:%M:%S")
+
+    st.dataframe(result_df, use_container_width=True, hide_index=True)
+
+
+def _render_multi_df_result(data: list, op_result: OperationOutput):
+    """Render multiple DataFrames (extract_windows)."""
+    labels = op_result.metadata.get("labels", [f"Window {i+1}" for i in range(len(data))])
+    rows = op_result.metadata.get("rows_per_window", [len(d) for d in data])
+
+    st.markdown(f"Extracted **{len(data)}** windows")
+
+    for i, (window_df, label) in enumerate(zip(data, labels)):
+        with st.expander(f"{label} ({rows[i] if i < len(rows) else len(window_df):,} rows)"):
+            tags_in_data = [c for c in window_df.columns if c != "timestamp" and pd.api.types.is_numeric_dtype(window_df[c])]
+            if "timestamp" in window_df.columns and tags_in_data:
+                fig = create_timeseries_chart(window_df, tags_in_data[:5], title=label)
+                st.plotly_chart(fig, use_container_width=True)
+            st.dataframe(window_df, use_container_width=True, height=200)
+
+    # Multi-window zip download
+    if data:
+        zip_bytes = package_multi_window_csv(data, labels)
+        st.download_button(
+            label=f"Download All Windows (ZIP, {len(data)} files)",
+            data=zip_bytes,
+            file_name="csh2_windows_export.zip",
+            mime="application/zip",
+            key="v2_download_zip",
+        )
+
+
+def _render_df_result(data: pd.DataFrame, op_result: OperationOutput):
+    """Render a single DataFrame result."""
+    st.markdown(f"**{len(data):,}** rows")
+
+    tags_in_data = [c for c in data.columns if c != "timestamp" and pd.api.types.is_numeric_dtype(data[c])]
+
+    if "timestamp" in data.columns and tags_in_data:
+        fig = create_timeseries_chart(data, tags_in_data[:5], title=op_result.label)
+        st.plotly_chart(fig, use_container_width=True)
+
+    with st.expander("Data Preview"):
+        st.dataframe(data.head(500), use_container_width=True, height=300)
+
+
+def _render_operation_result(op_result: OperationOutput, index: int):
+    """Render a single operation's results."""
+    st.subheader(f"Step {index + 1}: {op_result.label}")
+
+    if op_result.metadata.get("error"):
+        st.warning(f"Issue: {op_result.metadata['error']}")
+        return
+
+    data = op_result.data
+
+    if isinstance(data, dict):
+        _render_dict_result(data, op_result)
+    elif isinstance(data, list) and data and isinstance(data[0], dict):
+        _render_list_result(data, op_result)
+    elif isinstance(data, list) and data and isinstance(data[0], pd.DataFrame):
+        _render_multi_df_result(data, op_result)
+    elif isinstance(data, pd.DataFrame):
+        _render_df_result(data, op_result)
+
+    # Metadata display
+    meta = {k: v for k, v in op_result.metadata.items() if k != "error"}
+    if meta:
+        with st.expander("Details"):
+            for k, v in meta.items():
+                st.markdown(f"**{k}:** {v}")
+
+    # Export button for this operation
+    if op_result.exportable_df is not None and not op_result.exportable_df.empty:
+        csv = op_result.exportable_df.to_csv(index=False)
+        size = estimate_csv_size(op_result.exportable_df)
+        safe_name = op_result.op_name.replace(" ", "_")
+        st.download_button(
+            label=f"Download {safe_name}.csv ({size})",
+            data=csv,
+            file_name=f"csh2_{safe_name}.csv",
+            mime="text/csv",
+            key=f"v2_download_{index}",
+        )
+
+
+# ── Page Header ──────────────────────────────────────────────────
+
+page_header(
+    "Advanced Data Explorer",
+    "LLM-powered analytical queries with post-processing and export"
+)
+
+db = get_db_connector()
+planner = QueryPlanner()
+
+
+# ── Example Queries ──────────────────────────────────────────────
+
+EXAMPLE_QUERIES = [
+    "Find time blocks where PT130 exceeded 900 bar",
+    "Find where both AOV140 and MC130_VFD_Speed were constant for 5+ minutes",
+    "Export PT130, TT110, FT140 at 2Hz as CSV for Sep 25 10am-11am",
+    "Identify fills where kWh per kg dispensed exceeded 0.6",
+    "In Fill 3, what was the total number of pump strokes?",
+    "Between Sep 24 15:00 and Sep 24 18:00, total pump strokes?",
+]
+
+
+# ── Session State Initialization ─────────────────────────────────
+
+for key in ("v2_plan", "v2_result", "v2_query", "v2_run_plan", "v2_interpretation", "v2_interp_prompt"):
+    if key not in st.session_state:
+        st.session_state[key] = None
+# v2_run_plan is a bool flag, default False
+if st.session_state.v2_run_plan is None:
+    st.session_state.v2_run_plan = False
+
+
+# ── Query Input Section ──────────────────────────────────────────
+
+
+def _set_example_query(text: str):
+    """Callback: set the widget's own key so text appears on next render."""
+    st.session_state.v2_query_input = text
+    st.session_state.v2_query = text
+
+
+st.subheader("Ask a Complex Question")
+
+query_col, btn_col = st.columns([5, 1])
+with query_col:
+    user_query = st.text_input(
+        "Describe your analysis",
+        value=st.session_state.v2_query or "",
+        placeholder='e.g. "Find time blocks where PT130 exceeded 900 bar"',
+        key="v2_query_input",
+        label_visibility="collapsed",
+    )
+    # Sync widget value back to logical query state
+    st.session_state.v2_query = user_query
+with btn_col:
+    analyze_btn = st.button("Analyze", type="primary", use_container_width=True, key="v2_analyze_btn")
+
+# Example query chips
+st.caption("Try an example:")
+example_cols = st.columns(3)
+for i, example in enumerate(EXAMPLE_QUERIES):
+    col = example_cols[i % 3]
+    with col:
+        st.button(
+            example,
+            key=f"v2_example_{i}",
+            use_container_width=True,
+            on_click=_set_example_query,
+            args=(example,),
+        )
+
+st.divider()
+
+
+# ── Planning Phase ───────────────────────────────────────────────
+
+should_plan = (analyze_btn and user_query) or st.session_state.v2_run_plan
+if should_plan:
+    query_to_plan = user_query or st.session_state.v2_query or ""
+    st.session_state.v2_run_plan = False  # Reset flag immediately
+    st.session_state.v2_query = query_to_plan
+    st.session_state.v2_plan = None
+    st.session_state.v2_result = None
+    st.session_state.v2_interpretation = None
+    st.session_state.v2_interp_prompt = None
+    st.session_state.pop("v2_followups", None)
+
+    if not query_to_plan:
+        st.warning("Please enter a query or click an example.")
+    elif not planner.api_available:
+        st.error("Claude API key not configured. Add ANTHROPIC_API_KEY to your .env or Streamlit secrets.")
+    else:
+        with st.spinner("Planning execution..."):
+            all_sensors = db.get_all_tag_names()
+            plan = planner.plan(query_to_plan, all_sensors)
+
+        if plan and "error" in plan:
+            st.error(f"Planning failed: {plan['error']}")
+        elif plan:
+            st.session_state.v2_plan = plan
+        else:
+            st.error("Could not create an execution plan. Try rephrasing your query.")
+
+
+# ── Plan Review Card ─────────────────────────────────────────────
+
+plan = st.session_state.v2_plan
+
+if plan and "error" not in plan and st.session_state.v2_result is None:
+    qt = plan.get("query_type", "FETCH")
+    explanation = plan.get("explanation", "")
+    dr = plan.get("data_requirements", {})
+    ops = plan.get("operations", [])
+    export_info = plan.get("export", {})
+
+    # Query type badge
+    badge_colors = {"FETCH": "#5BA3B5", "ANALYZE": "#D4A04A", "EXPORT": "#5B9A6E"}
+    badge_color = badge_colors.get(qt, "#6B6358")
+
+    st.markdown(f"""
+    <div style="background: #1A1714; border: 1px solid #2A2520; border-radius: 8px; padding: 16px; margin-bottom: 16px;">
+        <div style="display: flex; align-items: center; gap: 12px; margin-bottom: 12px;">
+            <span style="background: {badge_color}; color: #0F0D0B; font-weight: 700; padding: 3px 10px;
+                         border-radius: 4px; font-size: 0.75rem; letter-spacing: 1px;">{qt}</span>
+            <span style="color: #B0A898; font-size: 0.9rem;">{explanation}</span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Data requirements
+    sensors = dr.get("sensors", [])
+    resolution = dr.get("resolution", "auto")
+    start_time = dr.get("start_time", "")
+    end_time = dr.get("end_time", "")
+
+    if isinstance(start_time, datetime):
+        start_str = start_time.strftime("%b %d, %Y %H:%M")
+    else:
+        start_str = str(start_time)
+    if isinstance(end_time, datetime):
+        end_str = end_time.strftime("%b %d, %Y %H:%M")
+    else:
+        end_str = str(end_time)
+
+    info_cols = st.columns(4)
+    info_cols[0].markdown(f"**Sensors:** {', '.join(sensors[:6])}{'...' if len(sensors) > 6 else ''}")
+    info_cols[1].markdown(f"**From:** {start_str}")
+    info_cols[2].markdown(f"**To:** {end_str}")
+    info_cols[3].markdown(f"**Resolution:** `{resolution}`")
+
+    if ops:
+        st.markdown("**Execution Steps:**")
+        for i, op in enumerate(ops, 1):
+            op_label = op.get("label", op.get("op", ""))
+            st.markdown(f"&nbsp;&nbsp;`{i}.` {op_label}")
+
+    if export_info.get("enabled"):
+        st.markdown(f"**Export:** `{export_info.get('filename_hint', 'export')}.csv`")
+
+    # Action buttons
+    exec_col, cancel_col = st.columns([2, 1])
+    with exec_col:
+        execute_btn = st.button("Execute Plan", type="primary", use_container_width=True, key="v2_execute_btn")
+    with cancel_col:
+        cancel_btn = st.button("Cancel", use_container_width=True, key="v2_cancel_btn")
+
+    with st.expander("Debug JSON"):
+        display_plan = _plan_to_serializable(plan)
+        st.code(json.dumps(display_plan, indent=2), language="json")
+
+    if cancel_btn:
+        st.session_state.v2_plan = None
+        st.session_state.v2_result = None
+        st.rerun()
+
+    if execute_btn:
+        engine = ExecutionEngine()
+        with st.spinner("Executing plan..."):
+            exec_result = engine.execute(plan)
+        st.session_state.v2_result = exec_result
+        st.rerun()
+
+
+# ── Results Display ──────────────────────────────────────────────
+
+result = st.session_state.v2_result
+
+if result is not None:
+    st.divider()
+
+    if result.success:
+        st.success(f"Execution completed in {result.execution_time_seconds:.1f}s")
+    else:
+        st.error(f"Execution failed ({result.execution_time_seconds:.1f}s)")
+        for err in result.errors:
+            st.error(err)
+
+    # Warnings
+    for warn in (result.warnings or []):
+        st.warning(warn)
+
+    # Summary metrics
+    metric_cols = st.columns(4)
+    metric_cols[0].metric("Rows Fetched", f"{result.row_count:,}")
+    metric_cols[1].metric("Table", result.table_used or "N/A")
+    metric_cols[2].metric("Operations", len(result.operation_results))
+    metric_cols[3].metric("Time", f"{result.execution_time_seconds:.1f}s")
+
+    # Explanation
+    if result.explanation:
+        analysis_card("Plan Summary", result.explanation)
+
+    # Render each operation result
+    for i, op_result in enumerate(result.operation_results):
+        st.divider()
+        _render_operation_result(op_result, i)
+
+    # ── Murphy's Interpretation ──
+    if result.success and result.operation_results:
+        st.divider()
+        if st.session_state.v2_interpretation:
+            analysis_card("Murphy's Take", st.session_state.v2_interpretation)
+
+            # Follow-up section for Murphy's Take
+            interp_prompt = st.session_state.get("v2_interp_prompt", "")
+            _llm_for_followup = LLMCycleAnalyzer()
+            follow_up_section(
+                session_key="v2_followups",
+                llm_analyzer=_llm_for_followup,
+                original_prompt=interp_prompt,
+                original_analysis=st.session_state.v2_interpretation,
+            )
+        else:
+            if st.button("Get Murphy's Take", type="primary", key="v2_interpret_btn"):
+                interpreter = ResultInterpreter()
+                if interpreter.api_available:
+                    # Store the prompt for follow-up context
+                    interp_prompt = interpreter._build_interpretation_prompt(
+                        st.session_state.v2_query or "", result
+                    )
+                    st.session_state.v2_interp_prompt = interp_prompt
+
+                    with st.spinner("Murphy is analyzing the results..."):
+                        interpretation = interpreter.interpret(
+                            st.session_state.v2_query or "", result
+                        )
+                    st.session_state.v2_interpretation = interpretation
+                    st.rerun()
+                else:
+                    st.error("Claude API key not configured for interpretation.")
+
+    # Source data overview
+    if result.source_data is not None and not result.source_data.empty:
+        st.divider()
+        with st.expander("Source Data Overview"):
+            src = result.source_data
+            st.markdown(f"**{len(src):,}** rows, **{len(src.columns)}** columns")
+            tags_in_src = [c for c in src.columns if c != "timestamp" and pd.api.types.is_numeric_dtype(src[c])]
+            if "timestamp" in src.columns and tags_in_src:
+                fig = create_timeseries_chart(src, tags_in_src[:5], title="Source Data")
+                st.plotly_chart(fig, use_container_width=True)
+            st.dataframe(src.head(200), use_container_width=True, height=200)
+
+
+# ── Reset Button ─────────────────────────────────────────────────
+
+if st.session_state.v2_plan or st.session_state.v2_result:
+    st.divider()
+    if st.button("New Query", use_container_width=True, key="v2_reset"):
+        st.session_state.v2_plan = None
+        st.session_state.v2_result = None
+        st.session_state.v2_query = None
+        st.session_state.v2_interpretation = None
+        st.session_state.v2_interp_prompt = None
+        st.session_state.pop("v2_followups", None)
+        st.rerun()

pages/7_search.py

@@ -0,0 +1,187 @@
+"""
+Feature 7: Search — Full-text search across engineer notes, PLC events, and sensor tags
+Uses PostgreSQL tsvector/tsquery (BM25-style ranking) and pg_trgm (fuzzy matching)
+"""
+import streamlit as st
+import pandas as pd
+from core.db_connector import get_db_connector
+from ui.components import page_header
+
+page_header(
+    "Search",
+    "Full-text search across engineer logs, PLC alarm events, and sensor metadata."
+)
+
+db = get_db_connector()
+
+# ── Search input ──
+search_col, btn_col = st.columns([5, 1])
+with search_col:
+    query = st.text_input(
+        "Search query",
+        placeholder='e.g. "seal leak", "pressure spike valve", "cooldown temperature"',
+        key="search_query",
+        label_visibility="collapsed",
+    )
+with btn_col:
+    search_btn = st.button("Search", type="primary", use_container_width=True)
+
+# ── Tabs for search targets ──
+tab_memos, tab_events, tab_tags = st.tabs([
+    "Engineer Logs (memo_log)",
+    "PLC Events (allevent)",
+    "Sensor Lookup (tags)",
+])
+
+# ── Tab 1: Memo Log Search ──
+with tab_memos:
+    # Filters
+    filter_col1, filter_col2 = st.columns(2)
+    with filter_col1:
+        engineers = db.get_memo_engineers()
+        engineer_filter = st.selectbox(
+            "Filter by Engineer",
+            ["All"] + engineers,
+            key="memo_engineer_filter",
+        )
+    with filter_col2:
+        severities = db.get_memo_severities()
+        severity_filter = st.selectbox(
+            "Filter by Severity",
+            ["All"] + severities,
+            key="memo_severity_filter",
+        )
+
+    if (search_btn or query) and query:
+        eng = engineer_filter if engineer_filter != "All" else None
+        sev = severity_filter if severity_filter != "All" else None
+
+        with st.spinner("Searching engineer logs..."):
+            df = db.search_memo_log(query, limit=25, engineer=eng, severity=sev)
+
+        if df.empty:
+            st.info(f'No engineer logs matching "{query}".')
+        else:
+            st.markdown(f"**{len(df)} results** — ranked by relevance")
+
+            for _, row in df.iterrows():
+                # Build header
+                date_str = row['logged_at'].strftime('%b %d, %Y') if pd.notna(row['logged_at']) else 'N/A'
+                engineer = row.get('engineer', 'Unknown')
+                severity = row.get('severity', '')
+                rank = row.get('rank', 0)
+
+                sev_color = {
+                    'High': '#CC3030', 'Medium': '#CC8F00', 'Low': '#5B9A6E',
+                }.get(severity, '#6B6358')
+
+                # Card for each result
+                parts = []
+                if pd.notna(row.get('summary')) and row['summary']:
+                    parts.append(f"**Summary:** {row['summary']}")
+                if pd.notna(row.get('issues_found')) and row['issues_found']:
+                    parts.append(f"**Issues:** {row['issues_found']}")
+                if pd.notna(row.get('maintenance_done')) and row['maintenance_done']:
+                    parts.append(f"**Maintenance:** {row['maintenance_done']}")
+                if pd.notna(row.get('system_performance')) and row['system_performance']:
+                    parts.append(f"**Performance:** {row['system_performance']}")
+                if pd.notna(row.get('components_affected')) and row['components_affected']:
+                    parts.append(f"**Components:** {row['components_affected']}")
+
+                body = "\n\n".join(parts) if parts else "(no text content)"
+
+                with st.expander(
+                    f"#{row['id']} — {date_str} — {engineer} — "
+                    f"Severity: {severity or 'N/A'} — Rank: {rank:.3f}",
+                    expanded=(rank > 0.5),
+                ):
+                    st.markdown(body)
+    else:
+        st.caption("Enter a search query above to search across 392 engineer field notes.")
+
+# ── Tab 2: PLC Event Search ──
+with tab_events:
+    event_col1, event_col2 = st.columns([3, 1])
+    with event_col1:
+        event_query = st.text_input(
+            "Event search",
+            value=query or "",
+            placeholder='e.g. "PT110", "PT130", "MainPumpFault", "SafetyRelay"',
+            key="event_query",
+            label_visibility="collapsed",
+        )
+    with event_col2:
+        conditions = db.get_event_conditions()
+        condition_filter = st.selectbox(
+            "Condition",
+            ["All"] + conditions,
+            key="event_condition_filter",
+        )
+
+    event_btn = st.button("Search Events", type="primary", key="event_search_btn")
+
+    if (event_btn or event_query) and event_query:
+        cond = condition_filter if condition_filter != "All" else None
+        with st.spinner("Searching PLC events..."):
+            df_events = db.search_events(event_query, condition=cond, limit=100)
+
+        if df_events.empty:
+            st.info(f'No PLC events matching "{event_query}".')
+        else:
+            st.markdown(f"**{len(df_events)} results** (showing up to 100)")
+
+            display_df = df_events[['eventtimestamp', 'conditionname', 'message']].copy()
+            display_df.columns = ['Timestamp', 'Condition', 'Message']
+            # Trim message for readability
+            display_df['Message'] = display_df['Message'].str[:120]
+
+            st.dataframe(display_df, use_container_width=True, height=500, hide_index=True)
+    else:
+        st.caption(
+            "Search across 385K PLC alarm events by sensor tag name (PT110, TT130, etc.) "
+            "or event type (MainPumpFault, SafetyRelay). Filter by condition: HI, LO, TRIP, HIHI, LOLO."
+        )
+
+# ── Tab 3: Fuzzy Tag Lookup ──
+with tab_tags:
+    tag_query = st.text_input(
+        "Sensor name or description",
+        placeholder='e.g. "discharge pressure", "temperature inlet", "motor speed"',
+        key="tag_search_query",
+        label_visibility="collapsed",
+    )
+    tag_btn = st.button("Find Sensors", type="primary", key="tag_search_btn")
+
+    if (tag_btn or tag_query) and tag_query:
+        with st.spinner("Fuzzy matching sensors..."):
+            df_tags = db.search_tags_fuzzy(tag_query, limit=15)
+
+        if df_tags.empty:
+            st.info(f'No sensors matching "{tag_query}". Try broader terms.')
+        else:
+            st.markdown(f"**{len(df_tags)} matches** — ranked by similarity")
+
+            # Color-code similarity
+            def fmt_sim(val):
+                if val > 0.5:
+                    return f"🟢 {val:.3f}"
+                elif val > 0.3:
+                    return f"🟡 {val:.3f}"
+                else:
+                    return f"🔴 {val:.3f}"
+
+            display = df_tags[['tagname', 'tagdesc', 'tagunit', 'sim']].copy()
+            display.columns = ['Tag Name', 'Description', 'Unit', 'Similarity']
+            display['Similarity'] = display['Similarity'].apply(fmt_sim)
+
+            st.dataframe(display, use_container_width=True, hide_index=True)
+
+            st.caption(
+                "Similarity scores use pg_trgm trigram matching. "
+                "🟢 >0.5 = strong match, 🟡 >0.3 = partial, 🔴 <0.3 = weak."
+            )
+    else:
+        st.caption(
+            "Enter a sensor name or description to fuzzy-search across 468 tags. "
+            "Works with partial names and typos."
+        )

requirements.txt

@@ -0,0 +1,9 @@
+streamlit==1.42.0
+psycopg2-binary==2.9.10
+pandas==2.2.3
+numpy==1.26.4
+plotly==5.24.1
+anthropic==0.44.0
+python-dotenv==1.0.1
+python-dateutil==2.9.0
+pyyaml==6.0.2

ui/components.py

@@ -0,0 +1,260 @@
+"""
+Reusable UI components for CSH2 Web Dashboard — HUD Theme
+"""
+import streamlit as st
+import pandas as pd
+from typing import List, Dict, Optional
+
+
+def page_header(title: str, subtitle: str = ""):
+    """Render a HUD-style page header with gradient accent lines"""
+    subtitle_html = f'<div class="hud-subtitle">{subtitle}</div>' if subtitle else ''
+    st.markdown(f"""
+    <div class="hud-page-header">
+        <div class="hud-header-line"></div>
+        <h1>{title}</h1>
+        {subtitle_html}
+        <div class="hud-header-line"></div>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def metric_row(metrics: List[Dict]):
+    """
+    Render a row of HUD-style metric cards.
+
+    metrics: list of dicts with keys: label, value, unit, delta (optional), status (optional)
+    status can be: 'nominal', 'warning', 'alarm' (defaults to no special styling)
+    """
+    cols = st.columns(len(metrics))
+    for col, m in zip(cols, metrics):
+        with col:
+            display_value = f"{m['value']}"
+            if m.get('unit'):
+                display_value = f"{m['value']} {m['unit']}"
+            st.metric(
+                label=m['label'],
+                value=display_value,
+                delta=m.get('delta'),
+            )
+
+
+def analysis_card(title: str, content: str):
+    """Render an LLM analysis result in a HUD terminal-style card"""
+    st.markdown(f"""
+    <div class="analysis-card">
+        <h4>// {title.upper()}</h4>
+        <div style="color: #B0A898; line-height: 1.7; font-size: 0.85rem;">
+            {content.replace(chr(10), '<br>')}
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def system_status_footer(sensor_count: int, data_start: str, data_end: str, connected: bool = True):
+    """Render a HUD-style system status panel in the sidebar"""
+    conn_color = '#5B9A6E' if connected else '#CC3030'
+    conn_text = 'CONNECTED' if connected else 'OFFLINE'
+    st.markdown(f"""
+    <div style="
+        border-top: 1px solid #2A2520;
+        padding-top: 12px;
+        margin-top: 12px;
+        font-size: 0.7rem;
+        color: #6B6358;
+        letter-spacing: 0.5px;
+    ">
+        <div style="margin-bottom: 4px;">
+            <span class="hud-indicator" style="background-color: {conn_color}; box-shadow: 0 0 6px {conn_color};"></span>
+            <span style="color: {conn_color};">{conn_text}</span>
+        </div>
+        <div>SENSORS: {sensor_count}</div>
+        <div>DATA: {data_start} — {data_end}</div>
+        <div style="margin-top: 6px; color: #2A2520;">CSH2 DELPHI v1.0</div>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def cycle_selector(cycles: List[Dict], key_prefix: str = "cycle") -> Optional[Dict]:
+    """
+    Render a cycle selector dropdown.
+
+    cycles: list of dicts with keys: cycle_id, start_time, end_time, duration_minutes, peak_pressure
+    Returns selected cycle dict or None
+    """
+    if not cycles:
+        st.info("No testing cycles detected for this period.")
+        return None
+
+    options = []
+    for c in cycles:
+        # Use Eastern display time if available, fall back to start_time
+        display_time = c.get('start_time_et') or c['start_time']
+        start_str = display_time.strftime('%b %d %H:%M') + " ET"
+        duration = f"{c['duration_minutes']:.0f} min"
+        peak = f"{c.get('peak_pressure', 0):.0f} bar" if c.get('peak_pressure') else "N/A"
+        options.append(f"Cycle {c['cycle_id']} | {start_str} | {duration} | Peak (PT130): {peak}")
+
+    selected_idx = st.selectbox(
+        "Select a testing cycle",
+        range(len(options)),
+        format_func=lambda i: options[i],
+        key=f"{key_prefix}_selector",
+    )
+
+    return cycles[selected_idx] if selected_idx is not None else None
+
+
+def tag_multiselect(db_connector, key: str = "tags", default_group: str = None) -> List[str]:
+    """
+    Render a tag multi-select with group filtering.
+
+    Selecting a sensor group filters the available options to only show
+    sensors in that group. "All Sensors" shows every tag in the database.
+
+    Returns list of selected tag names.
+    """
+    from core.config import SENSOR_GROUPS
+
+    group_names = ["All Sensors"] + list(SENSOR_GROUPS.keys())
+
+    def _clear_selection():
+        """Reset the multiselect when group changes to avoid stale selections."""
+        st.session_state.pop(f"{key}_select", None)
+
+    selected_group = st.selectbox(
+        "Sensor Group",
+        group_names,
+        key=f"{key}_group",
+        on_change=_clear_selection,
+    )
+
+    all_tags = db_connector.get_all_tag_names()
+
+    if selected_group == "All Sensors":
+        available_tags = all_tags
+        default_tags = []
+    else:
+        group_tags = SENSOR_GROUPS.get(selected_group, [])
+        available_tags = [t for t in group_tags if t in all_tags]
+        default_tags = available_tags  # Pre-select all sensors in the chosen group
+
+    selected_tags = st.multiselect(
+        "Select Sensors",
+        options=available_tags,
+        default=default_tags,
+        key=f"{key}_select",
+    )
+
+    return selected_tags
+
+
+def date_range_picker(key: str = "dates"):
+    """Render start/end date and time pickers. Returns (start_datetime, end_datetime)."""
+    from datetime import datetime, time, timedelta
+
+    col1, col2 = st.columns(2)
+    with col1:
+        start_date = st.date_input(
+            "Start Date",
+            value=datetime(2025, 9, 25),
+            key=f"{key}_start_date",
+        )
+        start_time = st.time_input("Start Time", value=time(0, 0), key=f"{key}_start_time")
+
+    with col2:
+        end_date = st.date_input(
+            "End Date",
+            value=datetime(2025, 9, 25),
+            key=f"{key}_end_date",
+        )
+        end_time = st.time_input("End Time", value=time(23, 59), key=f"{key}_end_time")
+
+    start_dt = datetime.combine(start_date, start_time)
+    end_dt = datetime.combine(end_date, end_time)
+
+    return start_dt, end_dt
+
+
+def no_data_message():
+    """Show a styled no-data message"""
+    st.warning("No data found for the selected sensors and time range. Try adjusting your filters.")
+
+
+def follow_up_section(
+    session_key: str,
+    llm_analyzer,
+    original_prompt: str,
+    original_analysis: str,
+    max_turns: int = 3,
+):
+    """Render a follow-up Q&A section below an analysis card.
+
+    Maintains a multi-turn conversation thread stored in
+    ``st.session_state[session_key]`` as a list of ``{role, content}`` dicts.
+
+    Args:
+        session_key: Unique session state key for this conversation thread.
+        llm_analyzer: An ``LLMCycleAnalyzer`` instance with ``follow_up()`` method.
+        original_prompt: The original user prompt that generated the analysis.
+        original_analysis: The original assistant analysis text.
+        max_turns: Maximum follow-up exchanges (default 3).
+    """
+    # Initialize conversation history if needed
+    if session_key not in st.session_state:
+        st.session_state[session_key] = []
+
+    followups = st.session_state[session_key]
+
+    # Display existing follow-up thread
+    if followups:
+        for msg in followups:
+            if msg["role"] == "user":
+                st.markdown(f"""
+                <div style="background: #1A1714; border-left: 3px solid #5BA3B5;
+                            padding: 8px 12px; margin: 8px 0; border-radius: 4px;
+                            font-size: 0.85rem; color: #B0A898;">
+                    <strong style="color: #5BA3B5;">You:</strong> {msg['content']}
+                </div>
+                """, unsafe_allow_html=True)
+            else:
+                analysis_card("Murphy Follow-up", msg["content"])
+
+    # Show input if under max turns
+    turn_count = len([m for m in followups if m["role"] == "user"])
+    if turn_count >= max_turns:
+        st.caption(f"Maximum {max_turns} follow-up questions reached.")
+        return
+
+    # Follow-up input
+    input_col, btn_col = st.columns([5, 1])
+    with input_col:
+        followup_q = st.text_input(
+            "Ask a follow-up question",
+            placeholder="e.g. 'What about the temperature trend?' or 'Explain the plateau at 370 bar'",
+            key=f"{session_key}_input",
+            label_visibility="collapsed",
+        )
+    with btn_col:
+        followup_btn = st.button(
+            "Ask",
+            type="primary",
+            use_container_width=True,
+            key=f"{session_key}_btn",
+        )
+
+    if followup_btn and followup_q:
+        # Build full conversation history for the API call
+        conversation = [
+            {"role": "user", "content": original_prompt},
+            {"role": "assistant", "content": original_analysis},
+        ] + followups
+
+        with st.spinner("Murphy is thinking..."):
+            response = llm_analyzer.follow_up(conversation, followup_q)
+
+        # Append to thread
+        followups.append({"role": "user", "content": followup_q})
+        followups.append({"role": "assistant", "content": response})
+        st.session_state[session_key] = followups
+        st.rerun()

ui/plotly_charts.py

@@ -0,0 +1,383 @@
+"""
+Plotly chart builders for CSH2 Web Dashboard — HUD Theme
+"""
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pandas as pd
+import numpy as np
+from typing import List, Dict, Optional, Tuple
+
+
+# Warm amber industrial palette
+COLORS = [
+    '#D4A04A',  # Warm amber (primary)
+    '#5B9A6E',  # Muted green (nominal)
+    '#5BA3B5',  # Muted teal (informational)
+    '#CC3030',  # Muted red (alarm)
+    '#E8C47A',  # Light amber
+    '#7DB88E',  # Light green
+    '#7BBFCC',  # Light teal
+    '#E06060',  # Light red
+    '#C4A35A',  # Gold
+    '#A0856A',  # Warm brown
+]
+
+# Downsample threshold for charts (browser performance)
+MAX_CHART_POINTS = 5000
+
+# Reusable HUD layout config for all Plotly charts
+HUD_LAYOUT = dict(
+    template='plotly_dark',
+    paper_bgcolor='#0C0A08',
+    plot_bgcolor='#0C0A08',
+    font=dict(family='JetBrains Mono, monospace', color='#B0A898', size=11),
+    title_font=dict(family='JetBrains Mono, monospace', color='#D4A04A', size=14),
+    hovermode='x unified',
+    hoverlabel=dict(
+        bgcolor='#12100E',
+        bordercolor='#D4A04A',
+        font=dict(family='JetBrains Mono, monospace', color='#E8E0D4', size=11),
+    ),
+    legend=dict(
+        orientation='h',
+        yanchor='bottom',
+        y=1.02,
+        xanchor='right',
+        x=1,
+        font=dict(size=10, color='#B0A898'),
+        bgcolor='rgba(12, 10, 8, 0.8)',
+        bordercolor='#2A2520',
+        borderwidth=1,
+    ),
+)
+
+# Reusable HUD axis config
+HUD_AXIS = dict(
+    gridcolor='#201C18',
+    zerolinecolor='#2A2520',
+    tickfont=dict(color='#6B6358', size=10),
+    title_font=dict(color='#B0A898', size=11),
+)
+
+
+def _downsample_df(
+    df: pd.DataFrame,
+    tags: List[str],
+    max_points: int = MAX_CHART_POINTS,
+) -> Tuple[pd.DataFrame, bool]:
+    """
+    Downsample a DataFrame for charting using min/max bucketing.
+    Preserves peaks and valleys while reducing point count.
+
+    Returns (downsampled_df, was_downsampled).
+    """
+    if len(df) <= max_points:
+        return df, False
+
+    n_buckets = max_points // 2  # each bucket yields ~2 rows (min + max)
+    bucket_size = max(len(df) // n_buckets, 2)
+
+    df = df.reset_index(drop=True)
+    df['_bucket'] = df.index // bucket_size
+
+    result_indices = {0, len(df) - 1}  # always keep first and last
+
+    # Find the primary tag to drive bucket selection
+    primary_tag = None
+    for tag in tags:
+        if tag in df.columns:
+            primary_tag = tag
+            break
+
+    if primary_tag is None:
+        # Fallback: uniform sampling
+        step = max(len(df) // max_points, 1)
+        return df.iloc[::step].drop(columns=['_bucket'], errors='ignore'), True
+
+    for _, group in df.groupby('_bucket'):
+        if len(group) == 0:
+            continue
+        col = group[primary_tag].dropna()
+        if len(col) > 0:
+            result_indices.add(col.idxmin())
+            result_indices.add(col.idxmax())
+
+    result = df.loc[sorted(result_indices)].drop(columns=['_bucket'])
+    return result, True
+
+
+def create_timeseries_chart(
+    df_pivot: pd.DataFrame,
+    tags: List[str],
+    title: str = "Sensor Data Over Time",
+    height: int = 500,
+    time_range: Optional[Tuple] = None,
+) -> go.Figure:
+    """Create an interactive time series chart from pivoted data"""
+    fig = go.Figure()
+
+    # Downsample for browser performance
+    df_plot, downsampled = _downsample_df(df_pivot, tags)
+
+    for i, tag in enumerate(tags):
+        if tag in df_plot.columns:
+            fig.add_trace(go.Scatter(
+                x=df_plot['timestamp'],
+                y=df_plot[tag],
+                mode='lines',
+                name=tag,
+                line=dict(color=COLORS[i % len(COLORS)], width=1.5),
+                hovertemplate=f'{tag}: %{{y:.2f}}<br>%{{x}}<extra></extra>',
+            ))
+
+    ds_note = f" (downsampled {len(df_pivot):,} \u2192 {len(df_plot):,} pts)" if downsampled else ""
+
+    # Compute explicit x-axis range
+    xaxis_range = None
+    if time_range is not None:
+        _x_min, _x_max = pd.Timestamp(time_range[0]), pd.Timestamp(time_range[1])
+        duration = (_x_max - _x_min).total_seconds()
+        margin = pd.Timedelta(seconds=max(duration * 0.02, 1))
+        xaxis_range = [_x_min - margin, _x_max + margin]
+    elif 'timestamp' in df_plot.columns and len(df_plot) > 0:
+        _x_min = df_plot['timestamp'].min()
+        _x_max = df_plot['timestamp'].max()
+        duration = (_x_max - _x_min).total_seconds()
+        margin = pd.Timedelta(seconds=max(duration * 0.02, 1))
+        xaxis_range = [_x_min - margin, _x_max + margin]
+
+    xaxis_cfg = dict(
+        title='Time (ET)',
+        rangeslider=dict(visible=True, thickness=0.05, bgcolor='#12100E'),
+        type='date',
+        **HUD_AXIS,
+    )
+    if xaxis_range is not None:
+        xaxis_cfg['range'] = xaxis_range
+
+    fig.update_layout(
+        **HUD_LAYOUT,
+        title=dict(text=title + ds_note, font=HUD_LAYOUT['title_font']),
+        xaxis=xaxis_cfg,
+        yaxis=dict(title='Value', **HUD_AXIS),
+        height=height,
+        margin=dict(l=60, r=20, t=60, b=40),
+    )
+
+    return fig
+
+
+def create_multi_axis_chart(
+    df: pd.DataFrame,
+    pressure_tags: List[str],
+    temp_tags: List[str],
+    other_tags: List[str] = None,
+    title: str = "Cycle Detail",
+    height: int = 600,
+    plateaus: Dict[str, List[Dict]] = None,
+    time_range: Optional[Tuple] = None,
+) -> go.Figure:
+    """
+    Create multi-axis chart for cycle detail view.
+    Left Y: Pressure, Right Y: Temperature, Subplot: Other sensors
+    """
+    has_other = other_tags and any(t in df.columns for t in other_tags)
+    rows = 2 if has_other else 1
+
+    # Downsample for browser performance
+    all_chart_tags = pressure_tags + temp_tags + (other_tags or [])
+    df_plot, _ = _downsample_df(df, all_chart_tags)
+
+    fig = make_subplots(
+        rows=rows, cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.12,
+        specs=[[{"secondary_y": True}]] + ([[{"secondary_y": False}]] if has_other else []),
+    )
+
+    color_idx = 0
+
+    # Pressure traces (left Y)
+    for tag in pressure_tags:
+        if tag in df_plot.columns:
+            fig.add_trace(go.Scatter(
+                x=df_plot['timestamp'], y=df_plot[tag],
+                mode='lines', name=tag,
+                line=dict(color=COLORS[color_idx % len(COLORS)], width=2),
+                hovertemplate=f'{tag}: %{{y:.1f}} bar<extra></extra>',
+            ), row=1, col=1, secondary_y=False)
+            color_idx += 1
+
+    # Temperature traces (right Y)
+    for tag in temp_tags:
+        if tag in df_plot.columns:
+            fig.add_trace(go.Scatter(
+                x=df_plot['timestamp'], y=df_plot[tag],
+                mode='lines', name=tag,
+                line=dict(color=COLORS[color_idx % len(COLORS)], width=2, dash='dash'),
+                hovertemplate=f'{tag}: %{{y:.1f}} K<extra></extra>',
+            ), row=1, col=1, secondary_y=True)
+            color_idx += 1
+
+    # Other sensor traces (subplot 2)
+    if has_other:
+        for tag in other_tags:
+            if tag in df_plot.columns:
+                fig.add_trace(go.Scatter(
+                    x=df_plot['timestamp'], y=df_plot[tag],
+                    mode='lines', name=tag,
+                    line=dict(color=COLORS[color_idx % len(COLORS)], width=1.5),
+                    hovertemplate=f'{tag}: %{{y:.2f}}<extra></extra>',
+                ), row=2, col=1)
+                color_idx += 1
+
+    # Compute x-axis bounds for clamping vrects and setting explicit range
+    if time_range is not None:
+        _x_min, _x_max = pd.Timestamp(time_range[0]), pd.Timestamp(time_range[1])
+    elif 'timestamp' in df_plot.columns and len(df_plot) > 0:
+        _x_min = df_plot['timestamp'].min()
+        _x_max = df_plot['timestamp'].max()
+    else:
+        _x_min = _x_max = None
+
+    # Add plateau highlights (clamped to data range)
+    if plateaus:
+        for tag, periods in plateaus.items():
+            color = 'rgba(212, 160, 74, 0.1)' if 'PT' in tag or 'pressure' in tag.lower() else 'rgba(91, 154, 110, 0.1)'
+            for p in periods:
+                vx0, vx1 = pd.Timestamp(p['start']), pd.Timestamp(p['end'])
+                # Normalize timezone awareness to match _x_min/_x_max
+                if _x_min is not None:
+                    if _x_min.tzinfo is not None and vx0.tzinfo is None:
+                        vx0 = vx0.tz_localize(_x_min.tzinfo)
+                        vx1 = vx1.tz_localize(_x_min.tzinfo)
+                    elif _x_min.tzinfo is None and vx0.tzinfo is not None:
+                        vx0 = vx0.tz_localize(None)
+                        vx1 = vx1.tz_localize(None)
+                # Clamp vrect bounds to prevent x-axis expansion
+                if _x_min is not None:
+                    vx0 = max(vx0, _x_min)
+                if _x_max is not None:
+                    vx1 = min(vx1, _x_max)
+                if _x_min is not None and vx1 < _x_min:
+                    continue
+                if _x_max is not None and vx0 > _x_max:
+                    continue
+                fig.add_vrect(
+                    x0=vx0, x1=vx1,
+                    fillcolor=color,
+                    layer='below',
+                    line_width=0,
+                    row=1, col=1,
+                    annotation_text=f"{tag} plateau",
+                    annotation_position="top left",
+                    annotation_font_size=9,
+                    annotation_font_color='#6B6358',
+                )
+
+    fig.update_layout(
+        **HUD_LAYOUT,
+        title=dict(text=title, font=HUD_LAYOUT['title_font']),
+        height=height,
+        margin=dict(l=60, r=60, t=120, b=40),
+    )
+    # Override legend position separately to avoid duplicate 'legend' kwarg
+    # (HUD_LAYOUT already contains 'legend', so passing it again raises TypeError)
+    fig.update_layout(legend_y=1.10)
+
+    fig.update_yaxes(title_text="Pressure (bar)", row=1, col=1, secondary_y=False, **HUD_AXIS)
+    fig.update_yaxes(title_text="Temperature (K)", row=1, col=1, secondary_y=True, **HUD_AXIS)
+    if has_other:
+        fig.update_yaxes(title_text="Motor & Flow", row=2, col=1, **HUD_AXIS)
+
+    # Set explicit x-axis range to prevent Plotly auto-expansion
+    if _x_min is not None and _x_max is not None:
+        duration = (_x_max - _x_min).total_seconds()
+        margin = pd.Timedelta(seconds=max(duration * 0.02, 1))
+        fig.update_xaxes(range=[_x_min - margin, _x_max + margin], **HUD_AXIS)
+    else:
+        fig.update_xaxes(**HUD_AXIS)
+
+    return fig
+
+
+def create_cycle_timeline(cycles: List[Dict], month: str, height: int = 300) -> go.Figure:
+    """Create a Gantt-style timeline of testing cycles in a month"""
+    fig = go.Figure()
+
+    for i, c in enumerate(cycles):
+        color = COLORS[i % len(COLORS)]
+        # Use Eastern display times for hover, fall back to start_time
+        _start_et = c.get('start_time_et') or c['start_time']
+        _end_et = c.get('end_time_et') or c['end_time']
+        fig.add_trace(go.Bar(
+            x=[c['duration_minutes']],
+            y=[f"Cycle {c['cycle_id']}"],
+            orientation='h',
+            marker=dict(color=color, line=dict(width=1, color='#2A2520')),
+            text=f"{c['duration_minutes']:.0f} min | Peak (PT130): {c.get('peak_pressure', 0):.0f} bar",
+            textposition='inside',
+            textfont=dict(color='#0C0A08', size=10),
+            hovertemplate=(
+                f"Cycle {c['cycle_id']}<br>"
+                f"Start: {_start_et.strftime('%b %d %H:%M')} ET<br>"
+                f"End: {_end_et.strftime('%b %d %H:%M')} ET<br>"
+                f"Duration: {c['duration_minutes']:.1f} min<br>"
+                f"Peak Pressure (PT130): {c.get('peak_pressure', 0):.0f} bar"
+                "<extra></extra>"
+            ),
+            showlegend=False,
+        ))
+
+    fig.update_layout(
+        **HUD_LAYOUT,
+        title=dict(text=f"TESTING CYCLES — {month}", font=HUD_LAYOUT['title_font']),
+        xaxis=dict(title='Duration (minutes)', **HUD_AXIS),
+        yaxis=dict(autorange='reversed', **HUD_AXIS),
+        height=height,
+        margin=dict(l=80, r=20, t=50, b=40),
+    )
+
+    return fig
+
+
+def create_comparison_chart(
+    df_a: pd.DataFrame,
+    df_b: pd.DataFrame,
+    tag: str,
+    label_a: str = "Cycle A",
+    label_b: str = "Cycle B",
+    height: int = 400,
+) -> go.Figure:
+    """Overlay two cycles on normalized time axis for comparison"""
+    fig = go.Figure()
+
+    if tag in df_a.columns:
+        # Normalize time to minutes from start
+        t0_a = df_a['timestamp'].min()
+        minutes_a = (df_a['timestamp'] - t0_a).dt.total_seconds() / 60
+        fig.add_trace(go.Scatter(
+            x=minutes_a, y=df_a[tag],
+            mode='lines', name=f"{label_a} — {tag}",
+            line=dict(color=COLORS[0], width=2),
+        ))
+
+    if tag in df_b.columns:
+        t0_b = df_b['timestamp'].min()
+        minutes_b = (df_b['timestamp'] - t0_b).dt.total_seconds() / 60
+        fig.add_trace(go.Scatter(
+            x=minutes_b, y=df_b[tag],
+            mode='lines', name=f"{label_b} — {tag}",
+            line=dict(color=COLORS[1], width=2),
+        ))
+
+    fig.update_layout(
+        **HUD_LAYOUT,
+        title=dict(text=f"{tag} — CYCLE COMPARISON", font=HUD_LAYOUT['title_font']),
+        xaxis=dict(title='Minutes from Cycle Start', **HUD_AXIS),
+        yaxis=dict(title=tag, **HUD_AXIS),
+        height=height,
+        margin=dict(l=60, r=20, t=50, b=40),
+    )
+
+    return fig

ui/styles.py

@@ -0,0 +1,442 @@
+"""
+Custom CSS styles for CSH2 Web Dashboard — Warm Amber Industrial Theme
+"""
+import streamlit as st
+
+
+def inject_custom_css():
+    """Inject Warm Amber HUD / Mission Control CSS theme"""
+    st.markdown("""
+    <style>
+    /* ============================================================
+       A. FONT IMPORT & GLOBAL OVERRIDE
+       ============================================================ */
+    @import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;600;700&display=swap');
+
+    * {
+        font-family: 'JetBrains Mono', 'Fira Code', 'Source Code Pro', 'Courier New', monospace !important;
+    }
+
+    /* Restore Material Icons/Symbols for Streamlit's internal UI elements
+       (sidebar collapse button, nav icons) — prevents ligature text leak */
+    [data-testid="stSidebarCollapseButton"],
+    [data-testid="stSidebarCollapseButton"] *,
+    [data-testid="stSidebarNavLink"] span[data-testid="stIconMaterial"],
+    [data-testid="stSidebarNavLink"] span[data-testid="stIconMaterial"] *,
+    .material-symbols-rounded,
+    .material-icons {
+        font-family: 'Material Symbols Rounded', 'Material Icons', sans-serif !important;
+        font-variant-ligatures: normal !important;
+    }
+
+    /* ============================================================
+       B. MAIN CONTAINER (scanline removed)
+       ============================================================ */
+    .main .block-container {
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+        max-width: 1400px;
+    }
+
+    /* ============================================================
+       C. TYPOGRAPHY
+       ============================================================ */
+    h1 {
+        color: #D4A04A !important;
+        font-weight: 700 !important;
+        letter-spacing: 1px;
+        text-transform: uppercase;
+        font-size: 1.5rem !important;
+    }
+
+    h2 {
+        color: #B0A898 !important;
+        font-weight: 600 !important;
+        border-bottom: 1px solid #2A2520;
+        padding-bottom: 0.3rem;
+        text-transform: uppercase;
+        font-size: 1.1rem !important;
+        letter-spacing: 0.5px;
+    }
+
+    h3 {
+        color: #B0A898 !important;
+        font-weight: 500 !important;
+        font-size: 0.95rem !important;
+        letter-spacing: 0.3px;
+    }
+
+    /* ============================================================
+       D. METRIC CARDS — HUD PANELS WITH CORNER BRACKETS
+       ============================================================ */
+    div[data-testid="stMetric"] {
+        background-color: #12100E;
+        border: 1px solid #2A2520;
+        border-radius: 2px;
+        padding: 12px 16px;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+        position: relative;
+        transition: box-shadow 0.3s ease;
+    }
+
+    div[data-testid="stMetric"]:hover {
+        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.4);
+    }
+
+    /* Corner bracket — top left */
+    div[data-testid="stMetric"]::before {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 12px;
+        height: 12px;
+        border-top: 2px solid #D4A04A;
+        border-left: 2px solid #D4A04A;
+        pointer-events: none;
+    }
+
+    /* Corner bracket — bottom right */
+    div[data-testid="stMetric"]::after {
+        content: '';
+        position: absolute;
+        bottom: 0;
+        right: 0;
+        width: 12px;
+        height: 12px;
+        border-bottom: 2px solid #D4A04A;
+        border-right: 2px solid #D4A04A;
+        pointer-events: none;
+    }
+
+    div[data-testid="stMetric"] label {
+        color: #6B6358 !important;
+        font-size: 0.7rem !important;
+        text-transform: uppercase;
+        letter-spacing: 1.5px;
+    }
+
+    div[data-testid="stMetric"] [data-testid="stMetricValue"] {
+        color: #FFFFFF !important;
+        font-size: 1.5rem !important;
+        font-weight: 700 !important;
+    }
+
+    div[data-testid="stMetric"] [data-testid="stMetricDelta"] svg {
+        fill: #5B9A6E;
+    }
+
+    /* ============================================================
+       E. SIDEBAR
+       ============================================================ */
+    section[data-testid="stSidebar"] {
+        background-color: #0C0A08;
+        border-right: 1px solid #2A2520;
+    }
+
+    section[data-testid="stSidebar"]::after {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        height: 2px;
+        background: linear-gradient(90deg, transparent, #D4A04A, transparent);
+        pointer-events: none;
+    }
+
+    section[data-testid="stSidebar"] h1,
+    section[data-testid="stSidebar"] h2,
+    section[data-testid="stSidebar"] h3 {
+        color: #D4A04A !important;
+        font-size: 1rem !important;
+    }
+
+    section[data-testid="stSidebar"] .stCaption {
+        color: #6B6358 !important;
+    }
+
+    /* ============================================================
+       F. BUTTONS — OUTLINE / HUD STYLE
+       ============================================================ */
+    .stButton > button {
+        border-radius: 2px;
+        border: 1px solid #D4A04A;
+        background-color: transparent;
+        color: #D4A04A !important;
+        font-weight: 600;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+        font-size: 0.8rem;
+        transition: all 0.2s;
+    }
+
+    .stButton > button:hover {
+        background-color: rgba(212, 160, 74, 0.1);
+        border-color: #D4A04A;
+        box-shadow: 0 0 12px rgba(212, 160, 74, 0.2);
+        color: #D4A04A !important;
+    }
+
+    .stButton > button:focus {
+        color: #D4A04A !important;
+    }
+
+    /* Primary buttons */
+    .stButton > button[kind="primary"],
+    .stButton > button[data-testid="stBaseButton-primary"] {
+        background-color: rgba(212, 160, 74, 0.15);
+        border-color: #D4A04A;
+        color: #D4A04A !important;
+    }
+
+    .stButton > button[kind="primary"]:hover,
+    .stButton > button[data-testid="stBaseButton-primary"]:hover {
+        background-color: rgba(212, 160, 74, 0.25);
+    }
+
+    /* Download button — muted teal accent */
+    .stDownloadButton > button {
+        background-color: transparent !important;
+        border: 1px solid #5BA3B5 !important;
+        color: #5BA3B5 !important;
+        border-radius: 2px;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+        font-size: 0.8rem;
+    }
+
+    .stDownloadButton > button:hover {
+        background-color: rgba(91, 163, 181, 0.1) !important;
+        box-shadow: 0 0 12px rgba(91, 163, 181, 0.2) !important;
+    }
+
+    /* ============================================================
+       G. ANALYSIS CARDS — TERMINAL OUTPUT AESTHETIC
+       ============================================================ */
+    .analysis-card {
+        background-color: #0C0A08;
+        border: 1px solid #2A2520;
+        border-left: 3px solid #D4A04A;
+        border-radius: 2px;
+        padding: 20px 24px;
+        margin: 16px 0;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+        position: relative;
+    }
+
+    .analysis-card::before {
+        content: '\25B8  ANALYSIS OUTPUT';
+        display: block;
+        color: #D4A04A;
+        font-size: 0.65rem;
+        letter-spacing: 2px;
+        text-transform: uppercase;
+        margin-bottom: 12px;
+        padding-bottom: 8px;
+        border-bottom: 1px solid #2A2520;
+        opacity: 0.7;
+    }
+
+    .analysis-card h4 {
+        color: #D4A04A !important;
+        margin-top: 0;
+        font-size: 0.9rem !important;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+    }
+
+    .analysis-card div {
+        color: #B0A898 !important;
+        line-height: 1.7;
+        font-size: 0.85rem;
+    }
+
+    /* ============================================================
+       H. TABS
+       ============================================================ */
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 0px;
+        border-bottom: 1px solid #2A2520;
+    }
+
+    .stTabs [data-baseweb="tab"] {
+        border-radius: 0;
+        padding: 8px 20px;
+        color: #6B6358;
+        border-bottom: 2px solid transparent;
+    }
+
+    .stTabs [data-baseweb="tab"][aria-selected="true"] {
+        color: #D4A04A !important;
+        border-bottom: 2px solid #D4A04A !important;
+        background-color: rgba(212, 160, 74, 0.05);
+    }
+
+    /* ============================================================
+       I. EXPANDERS, SELECTBOX, DIVIDERS, DATAFRAME
+       ============================================================ */
+    .streamlit-expanderHeader {
+        background-color: #12100E !important;
+        border-radius: 2px;
+        border: 1px solid #2A2520;
+        color: #B0A898 !important;
+    }
+
+    .stSelectbox > div > div {
+        border-radius: 2px;
+        border-color: #2A2520;
+    }
+
+    hr {
+        border-color: #2A2520 !important;
+    }
+
+    .stDataFrame {
+        border-radius: 2px;
+        overflow: hidden;
+        border: 1px solid #2A2520;
+    }
+
+    /* ============================================================
+       J. SPINNER
+       ============================================================ */
+    .stSpinner > div {
+        border-color: #D4A04A !important;
+    }
+
+    /* ============================================================
+       K. ANIMATIONS — PULSE (scanline removed)
+       ============================================================ */
+    @keyframes pulse-nominal {
+        0%, 100% { box-shadow: 0 0 6px rgba(91, 154, 110, 0.1); }
+        50% { box-shadow: 0 0 12px rgba(91, 154, 110, 0.2); }
+    }
+
+    @keyframes pulse-amber {
+        0%, 100% { box-shadow: 0 0 6px rgba(204, 143, 0, 0.1); }
+        50% { box-shadow: 0 0 12px rgba(204, 143, 0, 0.2); }
+    }
+
+    @keyframes pulse-red {
+        0%, 100% { box-shadow: 0 0 6px rgba(204, 48, 48, 0.1); }
+        50% { box-shadow: 0 0 12px rgba(204, 48, 48, 0.2); }
+    }
+
+    /* ============================================================
+       L. STATUS CLASSES (for dynamic component use)
+       ============================================================ */
+    .status-nominal {
+        border-color: #5B9A6E !important;
+    }
+    .status-nominal .hud-indicator {
+        background-color: #5B9A6E;
+        box-shadow: 0 0 6px #5B9A6E;
+    }
+
+    .status-warning {
+        border-color: #CC8F00 !important;
+        animation: pulse-amber 2s ease-in-out infinite;
+    }
+    .status-warning .hud-indicator {
+        background-color: #CC8F00;
+        box-shadow: 0 0 6px #CC8F00;
+    }
+
+    .status-alarm {
+        border-color: #CC3030 !important;
+        animation: pulse-red 1.5s ease-in-out infinite;
+    }
+    .status-alarm .hud-indicator {
+        background-color: #CC3030;
+        box-shadow: 0 0 6px #CC3030;
+    }
+
+    .hud-indicator {
+        display: inline-block;
+        width: 6px;
+        height: 6px;
+        border-radius: 50%;
+        margin-right: 6px;
+        vertical-align: middle;
+    }
+
+    /* ============================================================
+       M. HUD PAGE HEADER (used by components.py)
+       ============================================================ */
+    .hud-page-header {
+        margin-bottom: 1.5rem;
+    }
+
+    .hud-subtitle {
+        color: #6B6358;
+        font-size: 0.75rem;
+        letter-spacing: 0.5px;
+        margin-bottom: 0.5rem;
+    }
+
+    .hud-header-line {
+        height: 1px;
+        background: linear-gradient(90deg, #D4A04A, #2A2520 60%, transparent);
+    }
+
+    /* ============================================================
+       N. HIDE ERROR HELPER LINKS
+       ============================================================ */
+    [data-testid="stException"] a[href*="google"],
+    [data-testid="stException"] a[href*="chatgpt"],
+    [data-testid="stException"] a[href*="copy"],
+    div[data-testid="stException"] div:last-child {
+        display: none !important;
+    }
+
+    /* ============================================================
+       O. BRAND FOOTER
+       ============================================================ */
+    .brand-footer {
+        position: fixed;
+        bottom: 0;
+        left: 0;
+        width: 100%;
+        text-align: center;
+        padding: 6px;
+        background-color: #0C0A08;
+        color: #6B6358;
+        font-size: 0.65rem;
+        border-top: 1px solid #2A2520;
+        z-index: 999;
+        letter-spacing: 1px;
+        text-transform: uppercase;
+    }
+
+    /* ============================================================
+       P. TEXT INPUT / TEXTAREA STYLING
+       ============================================================ */
+    .stTextInput > div > div > input,
+    .stTextArea > div > div > textarea {
+        border-color: #2A2520;
+        border-radius: 2px;
+        color: #E8E0D4;
+    }
+
+    .stTextInput > div > div > input:focus,
+    .stTextArea > div > div > textarea:focus {
+        border-color: #D4A04A;
+        box-shadow: 0 0 6px rgba(212, 160, 74, 0.15);
+    }
+
+    /* ============================================================
+       Q. MULTISELECT / DATE INPUT
+       ============================================================ */
+    .stMultiSelect > div > div {
+        border-radius: 2px;
+        border-color: #2A2520;
+    }
+
+    .stDateInput > div > div > input {
+        border-radius: 2px;
+        border-color: #2A2520;
+    }
+
+    </style>
+    """, unsafe_allow_html=True)