Upload 97 files

.dockerignore

@@ -0,0 +1,26 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.env
+.venv
+pip-log.txt
+pip-delete-this-directory.txt
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.gitignore
+.mytg
+.pytest_cache
+docs/
+tests/
+tmp/

.env

@@ -0,0 +1,8 @@
+# GOOGLE_API_KEY=AIzaSyAjTiwQ6Pk__y7VmLStQpyT3ZdHPCL76uk
+# GOOGLE_API_KEY_1=AIzaSyDXBFif6puAw8I7lAOlEv6p24SUWpwUF1k
+# GOOGLE_API_KEY_2=AIzaSyBYU1pjQW_tSSC07FOjUVWoAx-JbGvbQGE
+# GOOGLE_API_KEY_3=AIzaSyAfF-13nsrMdAAe3SFOPSxFya4EtfLBjho
+GOOGLE_API_KEY=AIzaSyDeIdKxOMYB002k5W-vT5IiVUW7KJKoX_I
+GOOGLE_API_KEY_1=AIzaSyDlx9XjJMzkD1oZxstW3xzodSBJqymXlyg
+GOOGLE_API_KEY_2=AIzaSyAnykdmhgqHpEtqglf6KCf_rCvYnhCl__Y
+GOOGLE_API_KEY_3=AIzaSyAkogd4IytURSGx6VYK8VYhlymJMgUfDBI

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,66 @@
+# Deploying DCRM Streamlit App to DigitalOcean
+
+This guide outlines how to deploy your DCRM Analyzer Pro application to DigitalOcean's App Platform.
+
+## Prerequisites
+
+1.  **DigitalOcean Account**: You need an account on [DigitalOcean](https://www.digitalocean.com/).
+2.  **GitHub Repository**: Your code must be pushed to a GitHub repository (private or public).
+3.  **Google API Key**: You will need your `GOOGLE_API_KEY` for the application to function.
+
+## Step 1: Push Code to GitHub
+
+Ensure your latest code (including the new `Dockerfile` and `.dockerignore`) is committed and pushed to your GitHub repository.
+
+```bash
+git add .
+git commit -m "Add Docker deployment configuration"
+git push origin main
+```
+
+## Step 2: Create App on DigitalOcean
+
+1.  Log in to the **DigitalOcean Control Panel**.
+2.  Click **Create** (green button at top right) -> **Apps**.
+3.  **Choose Source**: Select **GitHub**.
+4.  **Repository**: Select your repository (e.g., `final_DCRM_3PHASE_REVIEWED`).
+5.  **Branch**: Select `main` (or your working branch).
+6.  **Source Directory**: `/` (default).
+7.  Click **Next**.
+
+## Step 3: Configure Resources
+
+1.  DigitalOcean should auto-detect the `Dockerfile` and select **Dockerfile** as the build strategy.
+2.  **Service Name**: You can rename it (e.g., `dcrm-api`).
+3.  **HTTP Port**: Ensure this is set to **5000** (Flask default).
+4.  **Instance Size**: 
+    *   Basic / Pro plans work well. 
+    *   **Recommendation**: 1 GB RAM minimum (approx $6/mo) is good for the API.
+5.  Click **Next**.
+
+## Step 4: Environment Variables
+
+1.  Click **Edit** next to your service (or go to extracting environment variables step).
+2.  Add the following **Global Environment Variables**:
+    *   **Key**: `GOOGLE_API_KEY`
+    *   **Value**: *[Paste your actual Google API Key here]*
+    *   **Encrypt**: Checked (Recommended)
+3.  Click **Save**.
+4.  Click **Next**.
+
+## Step 5: Review & Deploy
+
+1.  Review the details (Region, Plan, Cost).
+2.  Click **Create Resources**.
+
+DigitalOcean will now build your Docker image and deploy it. This process usually takes 3-5 minutes.
+
+## Step 6: Access Your App
+
+Once deployment is successful, you will see a **Live URL** (e.g., `https://dcrm-app-xyz.ondigitalocean.app/`). Click it to access your DCRM Analyzer!
+
+## Troubleshooting
+
+-   **Build Failed**: Check the "Activity" tab for build logs. Verify requirements installation.
+-   **Health Check Failed**: Ensure port 5000 is exposed in Dockerfile (we handled this) and App Platform settings.
+-   **App Crashes**: Check "Runtime Logs". Often due to missing API keys or memory limits. If OOM (Out of Memory), upgrade to a 1GB or 2GB instance.

Dockerfile

@@ -0,0 +1,44 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies required for OpenCV and other common libraries
+# libgl1-mesa-glx and libglib2.0-0 are often needed for cv2
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application's code
+# specific to this project structure where apps/streamlit_dashboard.py depends on core/
+COPY . .
+
+# Create a non-root user to run the app (required by Hugging Face Spaces)
+RUN useradd -m -u 1000 user
+
+# Switch to the new user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Expose port 7860 for Hugging Face
+EXPOSE 7860
+
+# Healthcheck to ensure the app is running
+HEALTHCHECK CMD curl --fail http://localhost:7860/ || exit 1
+
+# Run the application
+# We run from the root directory so Python path finds 'core'
+CMD ["python", "apps/flask_server.py"]

README_HF.md

@@ -0,0 +1,51 @@
+# Deploying to Hugging Face Spaces
+
+This guide explains how to host your DCRM API on Hugging Face Spaces using Docker.
+
+## Prerequisites
+
+1.  **Hugging Face Account**: [Sign up here](https://huggingface.co/join).
+2.  **Google API Key**: Required for the app to run.
+
+## Step 1: Create a Space
+
+1.  Go to [huggingface.co/new-space](https://huggingface.co/new-space).
+2.  **Space Name**: e.g., `dcrm-api`.
+3.  **License**: MIT or Apache 2.0.
+4.  **SDK**: Select **Docker**.
+5.  **Clean Template**: Choose "Blank".
+6.  Click **Create Space**.
+
+## Step 2: Push Your Code
+
+You can push your code directly via Git:
+
+```bash
+# Initialize git if you haven't
+git init
+
+# Add the Hugging Face remote (found in your Space's "Clone repository" button)
+git remote add space https://huggingface.co/spaces/YOUR_USERNAME/dcrm-api
+
+# Push
+git add .
+git commit -m "Deploy to HF"
+git push space main
+```
+
+## Step 3: Configure Settings
+
+1.  Go to your Space's **Settings** tab.
+2.  Scroll to **Variables and secrets**.
+3.  Click **New Secret**.
+    *   **Name**: `GOOGLE_API_KEY`
+    *   **Value**: *[Your Google API Key]*
+4.  The Space will restart automatically.
+
+## API Usage
+
+Your API will be available at:
+`https://YOUR_USERNAME-dcrm-api.hf.space`
+
+Example Health Check:
+`https://YOUR_USERNAME-dcrm-api.hf.space/api/health`

apps/fastapi_server.py

@@ -0,0 +1,340 @@
+"""
+DCRM Analysis API Wrapper
+==========================
+FastAPI wrapper for the DCRM analysis pipeline.
+Accepts CSV uploads via POST and returns comprehensive JSON analysis.
+
+Endpoint: POST /api/circuit-breakers/{breaker_id}/tests/upload
+"""
+
+import os
+import json
+import traceback
+from typing import Optional
+import sys
+
+# Add project root to sys.path to allow importing from core
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Previous Name: fastapi_app.py
+from fastapi import FastAPI, File, UploadFile, HTTPException, Path
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import pandas as pd
+from io import StringIO
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Ensure API key is set
+if not os.getenv("GOOGLE_API_KEY"):
+    print("WARNING: GOOGLE_API_KEY not found in environment variables. Please check your .env file.")
+
+from langchain_google_genai import ChatGoogleGenerativeAI
+from core.calculators.kpi import calculate_kpis
+from core.calculators.cbhi import compute_cbhi
+from core.signal.phases import analyze_dcrm_data
+from core.engines.rules import analyze_dcrm_advanced
+from core.agents.diagnosis import detect_fault, standardize_input
+from core.utils.report_generator import generate_dcrm_json
+from core.agents.recommendation import generate_recommendations
+
+# Optional ViT Model
+try:
+    from core.models.vit_classifier import predict_dcrm_image, plot_resistance_for_vit
+    VIT_AVAILABLE = True
+except Exception as e:
+    print(f"ViT Model not available: {e}")
+    VIT_AVAILABLE = False
+    predict_dcrm_image = None
+    plot_resistance_for_vit = None
+
+# =============================================================================
+# CONFIGURATION - CHANGE THIS URL AFTER DEPLOYMENT
+# =============================================================================
+DEPLOYMENT_URL = "http://localhost:5000"  # Change this to your deployed URL
+# Example: DEPLOYMENT_URL = "https://your-domain.com"
+# =============================================================================
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="DCRM Analysis API",
+    description="Circuit Breaker Dynamic Contact Resistance Measurement Analysis",
+    version="1.0.0"
+)
+
+# Enable CORS for frontend access
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure this based on your security requirements
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize LLM (reused across requests)
+llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "service": "DCRM Analysis API",
+        "version": "1.0.0",
+        "deployment_url": DEPLOYMENT_URL
+    }
+
+
+@app.post("/api/circuit-breakers/{breaker_id}/tests/upload")
+async def analyze_dcrm(
+    breaker_id: str = Path(..., description="Circuit breaker ID"),
+    file: UploadFile = File(..., description="CSV file with DCRM test data")
+):
+    """
+    Analyze DCRM test data from uploaded CSV file.
+    
+    Expected CSV format:
+    - Columns: Time_ms, Resistance, Current, Travel, Close_Coil, Trip_Coil_1, Trip_Coil_2
+    - ~400 rows of time-series data
+    
+    Returns:
+    - Comprehensive JSON analysis report matching dcrm-sample-response.txt structure
+    """
+    
+    # Validate file type
+    if not file.filename.endswith('.csv'):
+        raise HTTPException(
+            status_code=400,
+            detail={
+                "error": "Invalid file type",
+                "message": "Only CSV files are accepted",
+                "received": file.filename
+            }
+        )
+    
+    try:
+        # Read CSV file
+        contents = await file.read()
+        csv_string = contents.decode('utf-8')
+        df = pd.read_csv(StringIO(csv_string))
+        
+        # Validate required columns
+        required_columns = ['Time_ms', 'Resistance', 'Current', 'Travel', 
+                          'Close_Coil', 'Trip_Coil_1', 'Trip_Coil_2']
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        
+        if missing_columns:
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "error": "Missing required columns",
+                    "missing": missing_columns,
+                    "required": required_columns,
+                    "found": list(df.columns)
+                }
+            )
+        
+        # Validate data size
+        if len(df) < 100:
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "error": "Insufficient data",
+                    "message": "CSV must contain at least 100 rows of data",
+                    "received_rows": len(df)
+                }
+            )
+        
+        # =====================================================================
+        # MAIN PROCESSING PIPELINE
+        # =====================================================================
+        
+        # 1. Calculate KPIs
+        kpi_results = calculate_kpis(df)
+        kpis = kpi_results['kpis']
+        
+        # 2. Phase Segmentation (AI-based)
+        phase_analysis_result = analyze_dcrm_data(df, llm)
+        
+        # 3. Prepare KPIs for Rule Engine and AI Agent
+        raj_kpis = {
+            "Closing Time (ms)": kpis.get('closing_time'),
+            "Opening Time (ms)": kpis.get('opening_time'),
+            "Contact Speed (m/s)": kpis.get('contact_speed'),
+            "DLRO Value (µΩ)": kpis.get('dlro'),
+            "Peak Resistance (µΩ)": kpis.get('peak_resistance'),
+            "Peak Close Coil Current (A)": kpis.get('peak_close_coil'),
+            "Peak Trip Coil 1 Current (A)": kpis.get('peak_trip_coil_1'),
+            "Peak Trip Coil 2 Current (A)": kpis.get('peak_trip_coil_2'),
+            "SF6 Pressure (bar)": kpis.get('sf6_pressure'),
+            "Ambient Temperature (°C)": kpis.get('ambient_temp'),
+            "Main Wipe (mm)": kpis.get('main_wipe'),
+            "Arc Wipe (mm)": kpis.get('arc_wipe'),
+            "Contact Travel Distance (mm)": kpis.get('contact_travel')
+        }
+        
+        raj_ai_kpis = {
+            "kpis": [
+                {"name": "Closing Time", "unit": "ms", "value": kpis.get('closing_time')},
+                {"name": "Opening Time", "unit": "ms", "value": kpis.get('opening_time')},
+                {"name": "DLRO Value", "unit": "µΩ", "value": kpis.get('dlro')},
+                {"name": "Peak Resistance", "unit": "µΩ", "value": kpis.get('peak_resistance')},
+                {"name": "Contact Speed", "unit": "m/s", "value": kpis.get('contact_speed')},
+                {"name": "Peak Close Coil Current", "unit": "A", "value": kpis.get('peak_close_coil')},
+                {"name": "Peak Trip Coil 1 Current", "unit": "A", "value": kpis.get('peak_trip_coil_1')},
+                {"name": "Peak Trip Coil 2 Current", "unit": "A", "value": kpis.get('peak_trip_coil_2')},
+                {"name": "SF6 Pressure", "unit": "bar", "value": kpis.get('sf6_pressure')},
+                {"name": "Ambient Temperature", "unit": "°C", "value": kpis.get('ambient_temp')}
+            ]
+        }
+        
+        # 4. Standardize resistance data for Rule Engine
+        temp_df = df[['Resistance']].copy()
+        if len(temp_df) < 401:
+            last_val = temp_df.iloc[-1, 0]
+            padding = pd.DataFrame({'Resistance': [last_val] * (401 - len(temp_df))})
+            temp_df = pd.concat([temp_df, padding], ignore_index=True)
+        
+        std_df = standardize_input(temp_df)
+        row_values = std_df.iloc[0].values.tolist()
+        
+        # 5. Run Rule Engine Analysis
+        rule_engine_result = analyze_dcrm_advanced(row_values, raj_kpis)
+        
+        # 6. Run AI Agent Analysis
+        ai_agent_result = detect_fault(df, raj_ai_kpis)
+        
+        # 7. Run ViT Model (if available)
+        vit_result = None
+        vit_plot_path = "temp_vit_plot.png"
+        
+        plot_generated = False
+        try:
+            if plot_resistance_for_vit and plot_resistance_for_vit(df, vit_plot_path):
+                plot_generated = True
+        except Exception as e:
+            print(f"ViT Plot generation failed: {e}")
+        
+        if plot_generated and VIT_AVAILABLE and predict_dcrm_image:
+            try:
+                vit_class, vit_conf, vit_details = predict_dcrm_image(vit_plot_path)
+                if vit_class:
+                    vit_result = {
+                        "class": vit_class,
+                        "confidence": vit_conf,
+                        "details": vit_details
+                    }
+            except Exception as e:
+                print(f"ViT Prediction failed: {e}")
+        
+        # 8. Calculate CBHI Score
+        cbhi_phase_data = {}
+        if 'phaseWiseAnalysis' in phase_analysis_result:
+            for phase in phase_analysis_result['phaseWiseAnalysis']:
+                p_name = f"Phase {phase.get('phaseNumber')}"
+                cbhi_phase_data[p_name] = {
+                    "status": phase.get('status', 'Unknown'),
+                    "confidence": phase.get('confidence', 0)
+                }
+        
+        cbhi_score = compute_cbhi(raj_ai_kpis['kpis'], ai_agent_result, cbhi_phase_data)
+        
+        # 9. Generate Recommendations
+        recommendations = generate_recommendations(
+            kpis=kpis,
+            cbhi_score=cbhi_score,
+            rule_faults=rule_engine_result.get("Fault_Detection", []),
+            ai_faults=ai_agent_result.get("Fault_Detection", []),
+            llm=llm
+        )
+        
+        # 10. Generate Final JSON Report
+        full_report = generate_dcrm_json(
+            df=df,
+            kpis=kpis,
+            cbhi_score=cbhi_score,
+            rule_result=rule_engine_result,
+            ai_result=ai_agent_result,
+            llm=llm,
+            vit_result=vit_result,
+            phase_analysis_result=phase_analysis_result,
+            recommendations=recommendations
+        )
+        
+        # Add breaker_id to response
+        full_report['breakerId'] = breaker_id
+        
+        # Return JSON response
+        return JSONResponse(content=full_report, status_code=200)
+    
+    except HTTPException:
+        # Re-raise HTTP exceptions as-is
+        raise
+    
+    except pd.errors.EmptyDataError:
+        raise HTTPException(
+            status_code=400,
+            detail={
+                "error": "Empty CSV file",
+                "message": "The uploaded CSV file is empty or contains no data"
+            }
+        )
+    
+    except pd.errors.ParserError as e:
+        raise HTTPException(
+            status_code=400,
+            detail={
+                "error": "CSV parsing error",
+                "message": "Failed to parse CSV file. Please check the file format.",
+                "details": str(e)
+            }
+        )
+    
+    except Exception as e:
+        # Log the full error for debugging
+        error_trace = traceback.format_exc()
+        print(f"ERROR in DCRM analysis: {error_trace}")
+        
+        # Return clean error to client
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": "Analysis failed",
+                "message": "An error occurred during DCRM analysis",
+                "error_type": type(e).__name__,
+                "error_details": str(e)
+            }
+        )
+
+
+@app.get("/api/health")
+async def health_check():
+    """Detailed health check with component status"""
+    return {
+        "status": "healthy",
+        "components": {
+            "llm": "operational",
+            "vit_model": "available" if VIT_AVAILABLE else "unavailable",
+            "kpi_calculator": "operational",
+            "rule_engine": "operational",
+            "ai_agent": "operational",
+            "phase_analysis": "operational"
+        },
+        "deployment_url": DEPLOYMENT_URL
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    # Run the API server
+    # Change host and port as needed
+    uvicorn.run(
+        app, 
+        host="0.0.0.0",  # Listen on all interfaces
+        port=5001,       # Change port if needed
+        log_level="info"
+    )

apps/flask_server.py

@@ -0,0 +1,436 @@
+"""
+DCRM Analysis Flask API - Three Phase Support
+==============================================
+Flask API wrapper for the DCRM analysis pipeline.
+Accepts 3 CSV uploads (R, Y, B phases) via POST and returns comprehensive JSON analysis.
+
+Endpoint: POST /api/circuit-breakers/{breaker_id}/tests/upload-three-phase
+"""
+
+import os
+import json
+import traceback
+import uuid
+from datetime import datetime, timezone
+import sys
+import concurrent.futures
+
+# Add project root to sys.path to allow importing from core
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Previous Name: flask_app.py
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from werkzeug.utils import secure_filename
+import pandas as pd
+from io import StringIO
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Ensure API key is set
+if not os.getenv("GOOGLE_API_KEY"):
+    print("WARNING: GOOGLE_API_KEY not found in environment variables. Please check your .env file.")
+
+from langchain_google_genai import ChatGoogleGenerativeAI
+from core.calculators.kpi import calculate_kpis
+from core.calculators.cbhi import compute_cbhi
+from core.signal.phases import analyze_dcrm_data
+from core.engines.rules import analyze_dcrm_advanced
+from core.agents.diagnosis import detect_fault, standardize_input
+from core.utils.report_generator import generate_dcrm_json
+from core.agents.recommendation import generate_recommendations
+
+# Optional ViT Model
+try:
+    from core.models.vit_classifier import predict_dcrm_image, plot_resistance_for_vit
+    VIT_AVAILABLE = True
+except Exception as e:
+    print(f"ViT Model not available: {e}")
+    VIT_AVAILABLE = False
+    predict_dcrm_image = None
+    plot_resistance_for_vit = None
+
+# =============================================================================
+# CONFIGURATION - CHANGE THIS URL AFTER DEPLOYMENT
+# =============================================================================
+DEPLOYMENT_URL = "http://localhost:5000"  # Change this to your deployed URL
+# Example: DEPLOYMENT_URL = "https://your-domain.com"
+# =============================================================================
+
+# Initialize Flask app
+app = Flask(__name__)
+CORS(app)  # Enable CORS for frontend access
+
+def get_llm(api_key=None):
+    """
+    Factory function to create an LLM instance with a specific API key.
+    If no key is provided, falls back to the default GOOGLE_API_KEY.
+    """
+    if not api_key:
+        api_key = os.getenv("GOOGLE_API_KEY")
+    
+    if not api_key:
+        raise ValueError("No Google API Key provided and GOOGLE_API_KEY not found in env.")
+        
+    return ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0, google_api_key=api_key)
+
+
+def process_single_phase_csv(args):
+    """
+    Process a single phase CSV through the complete DCRM pipeline.
+    Designed to be run in a separate thread.
+    
+    Args:
+        args: Tuple containing (df, breaker_id, api_key, phase_name)
+        
+    Returns:
+        dict: Complete analysis results for one phase
+    """
+    df, breaker_id, api_key, phase_name = args
+    
+    try:
+        print(f"[{phase_name.upper()}] Starting processing with key ending in ...{api_key[-4:] if api_key else 'None'}")
+        
+        # Initialize local LLM for this thread
+        llm = get_llm(api_key)
+        
+        # 1. Calculate KPIs
+        kpi_results = calculate_kpis(df)
+        kpis = kpi_results['kpis']
+        
+        # 2. Phase Segmentation (AI-based)
+        phase_analysis_result = analyze_dcrm_data(df, llm)
+        
+        # 3. Prepare KPIs for Rule Engine and AI Agent
+        raj_kpis = {
+            "Closing Time (ms)": kpis.get('closing_time'),
+            "Opening Time (ms)": kpis.get('opening_time'),
+            "Contact Speed (m/s)": kpis.get('contact_speed'),
+            "DLRO Value (µΩ)": kpis.get('dlro'),
+            "Peak Resistance (µΩ)": kpis.get('peak_resistance'),
+            "Peak Close Coil Current (A)": kpis.get('peak_close_coil'),
+            "Peak Trip Coil 1 Current (A)": kpis.get('peak_trip_coil_1'),
+            "Peak Trip Coil 2 Current (A)": kpis.get('peak_trip_coil_2'),
+            "SF6 Pressure (bar)": kpis.get('sf6_pressure'),
+            "Ambient Temperature (°C)": kpis.get('ambient_temp'),
+            "Main Wipe (mm)": kpis.get('main_wipe'),
+            "Arc Wipe (mm)": kpis.get('arc_wipe'),
+            "Contact Travel Distance (mm)": kpis.get('contact_travel')
+        }
+        
+        raj_ai_kpis = {
+            "kpis": [
+                {"name": "Closing Time", "unit": "ms", "value": kpis.get('closing_time')},
+                {"name": "Opening Time", "unit": "ms", "value": kpis.get('opening_time')},
+                {"name": "DLRO Value", "unit": "µΩ", "value": kpis.get('dlro')},
+                {"name": "Peak Resistance", "unit": "µΩ", "value": kpis.get('peak_resistance')},
+                {"name": "Contact Speed", "unit": "m/s", "value": kpis.get('contact_speed')},
+                {"name": "Peak Close Coil Current", "unit": "A", "value": kpis.get('peak_close_coil')},
+                {"name": "Peak Trip Coil 1 Current", "unit": "A", "value": kpis.get('peak_trip_coil_1')},
+                {"name": "Peak Trip Coil 2 Current", "unit": "A", "value": kpis.get('peak_trip_coil_2')},
+                {"name": "SF6 Pressure", "unit": "bar", "value": kpis.get('sf6_pressure')},
+                {"name": "Ambient Temperature", "unit": "°C", "value": kpis.get('ambient_temp')}
+            ]
+        }
+        
+        # 4. Standardize resistance data for Rule Engine
+        temp_df = df[['Resistance']].copy()
+        if len(temp_df) < 401:
+            last_val = temp_df.iloc[-1, 0]
+            padding = pd.DataFrame({'Resistance': [last_val] * (401 - len(temp_df))})
+            temp_df = pd.concat([temp_df, padding], ignore_index=True)
+        
+        std_df = standardize_input(temp_df)
+        row_values = std_df.iloc[0].values.tolist()
+        
+        # 5. Run Rule Engine Analysis
+        rule_engine_result = analyze_dcrm_advanced(row_values, raj_kpis)
+        
+        # 6. Run AI Agent Analysis with error handling
+        try:
+            ai_agent_result = detect_fault(df, raj_ai_kpis)
+            print(f"[{phase_name.upper()}] AI Agent analysis completed successfully")
+        except Exception as e:
+            print(f"[{phase_name.upper()}] AI Agent failed: {e}. Using fallback.")
+            # Fallback: Use rule engine result as AI result
+            ai_agent_result = {
+                "Fault_Detection": rule_engine_result.get("Fault_Detection", []),
+                "overall_health_assessment": rule_engine_result.get("overall_health_assessment", {}),
+                "classifications": rule_engine_result.get("classifications", [])
+            }
+        
+        # 7. Run ViT Model (if available)
+        vit_result = None
+        vit_plot_path = f"temp_vit_plot_{phase_name}_{uuid.uuid4().hex[:8]}.png" # Unique path for parallel safety
+        
+        plot_generated = False
+        try:
+            if plot_resistance_for_vit and plot_resistance_for_vit(df, vit_plot_path):
+                plot_generated = True
+        except Exception as e:
+            print(f"[{phase_name.upper()}] ViT Plot generation failed: {e}")
+        
+        if plot_generated and VIT_AVAILABLE and predict_dcrm_image:
+            try:
+                # Pass API key to ViT as well if needed, though currently it might use env var
+                # The updated vit_classifier uses requests to a deployed model, so API key is for Gemini part
+                vit_class, vit_conf, vit_details = predict_dcrm_image(vit_plot_path, api_key=api_key)
+                if vit_class:
+                    vit_result = {
+                        "class": vit_class,
+                        "confidence": vit_conf,
+                        "details": vit_details
+                    }
+            except Exception as e:
+                print(f"[{phase_name.upper()}] ViT Prediction failed: {e}")
+            finally:
+                # Cleanup temp file
+                if os.path.exists(vit_plot_path):
+                    try:
+                        os.remove(vit_plot_path)
+                    except:
+                        pass
+        
+        # 8. Calculate CBHI Score
+        cbhi_phase_data = {}
+        if 'phaseWiseAnalysis' in phase_analysis_result:
+            for phase in phase_analysis_result['phaseWiseAnalysis']:
+                p_name = f"Phase {phase.get('phaseNumber')}"
+                cbhi_phase_data[p_name] = {
+                    "status": phase.get('status', 'Unknown'),
+                    "confidence": phase.get('confidence', 0)
+                }
+        
+        cbhi_score = compute_cbhi(raj_ai_kpis['kpis'], ai_agent_result, cbhi_phase_data)
+        
+        # 9. Generate Recommendations with error handling
+        try:
+            recommendations = generate_recommendations(
+                kpis=kpis,
+                cbhi_score=cbhi_score,
+                rule_faults=rule_engine_result.get("Fault_Detection", []),
+                ai_faults=ai_agent_result.get("Fault_Detection", []),
+                llm=llm
+            )
+            print(f"[{phase_name.upper()}] Recommendations generated successfully")
+        except Exception as e:
+            print(f"[{phase_name.upper()}] Recommendations failed: {e}. Using fallback.")
+            # Fallback: Create basic recommendations from rule engine
+            recommendations = {
+                "maintenanceActions": [],
+                "futureFaultsPdf": []
+            }
+            # Extract from rule faults
+            for fault in rule_engine_result.get("Fault_Detection", []):
+                if fault.get("Severity") in ["High", "Critical"]:
+                    recommendations["maintenanceActions"].append({
+                        "action": f"Address {fault.get('defect_name')}",
+                        "priority": "High",
+                        "timeframe": "Immediate"
+                    })
+        
+        # 10. Generate Final JSON Report with error handling
+        try:
+            full_report = generate_dcrm_json(
+                df=df,
+                kpis=kpis,
+                cbhi_score=cbhi_score,
+                rule_result=rule_engine_result,
+                ai_result=ai_agent_result,
+                llm=llm,
+                vit_result=vit_result,
+                phase_analysis_result=phase_analysis_result,
+                recommendations=recommendations
+            )
+            print(f"[{phase_name.upper()}] Final report generated successfully")
+        except Exception as e:
+            print(f"[{phase_name.upper()}] Report generation failed: {e}. Using fallback.")
+            # Fallback: Create minimal valid report
+            full_report = {
+                "_id": f"fallback_{phase_name}_{uuid.uuid4().hex[:8]}",
+                "phase": phase_name,
+                "status": "partial_success",
+                "error": str(e),
+                "ruleBased_result": rule_engine_result,
+                "vitResult": vit_result,
+                "kpis": kpis,
+                "cbhi": {"score": cbhi_score},
+                "phaseWiseAnalysis": phase_analysis_result.get('phaseWiseAnalysis', [])
+            }
+        
+        print(f"[{phase_name.upper()}] Processing complete.")
+        return full_report
+
+    except Exception as e:
+        print(f"[{phase_name.upper()}] Error: {e}")
+        traceback.print_exc()
+        # Return a partial error result so the whole request doesn't fail
+        return {
+            "error": str(e),
+            "phase": phase_name
+        }
+
+
+@app.route('/')
+def root():
+    """Health check endpoint"""
+    return jsonify({
+        "status": "healthy",
+        "service": "DCRM Analysis Flask API",
+        "version": "2.1.0",
+        "deployment_url": DEPLOYMENT_URL
+    })
+
+
+@app.route('/api/health')
+def health_check():
+    """Detailed health check with component status"""
+    return jsonify({
+        "status": "healthy",
+        "components": {
+            "llm": "operational",
+            "vit_model": "available" if VIT_AVAILABLE else "unavailable",
+            "kpi_calculator": "operational",
+            "rule_engine": "operational",
+            "ai_agent": "operational",
+            "phase_analysis": "operational"
+        },
+        "deployment_url": DEPLOYMENT_URL
+    })
+
+
+@app.route('/api/circuit-breakers/<breaker_id>/tests/upload-three-phase', methods=['POST'])
+def analyze_three_phase_dcrm(breaker_id):
+    """
+    Analyze DCRM test data from 3 uploaded CSV files (R, Y, B phases).
+    Uses parallel processing with multiple API keys to speed up execution.
+    
+    Expected files in request:
+    - fileR: Red phase CSV
+    - fileY: Yellow phase CSV  
+    - fileB: Blue phase CSV
+    
+    Returns:
+    - Comprehensive JSON analysis report with combined three-phase results
+    """
+    
+    try:
+        # Validate files are present
+        if 'fileR' not in request.files or 'fileY' not in request.files or 'fileB' not in request.files:
+            return jsonify({
+                "error": "Missing required files",
+                "message": "All three phase files are required: fileR, fileY, fileB",
+                "received": list(request.files.keys())
+            }), 400
+        
+        fileR = request.files['fileR']
+        fileY = request.files['fileY']
+        fileB = request.files['fileB']
+        
+        # Validate file types
+        for file in [fileR, fileY, fileB]:
+            if not file.filename.endswith('.csv'):
+                return jsonify({
+                    "error": "Invalid file type",
+                    "message": "Only CSV files are accepted",
+                    "received": file.filename
+                }), 400
+        
+        # Prepare DataFrames
+        dfs = {}
+        for phase_name, file in [('r', fileR), ('y', fileY), ('b', fileB)]:
+            file.seek(0)
+            csv_string = file.read().decode('utf-8')
+            try:
+                df = pd.read_csv(StringIO(csv_string))
+                
+                # Basic validation
+                if len(df) < 100:
+                    raise ValueError(f"Insufficient data in {phase_name.upper()} phase")
+                
+                dfs[phase_name] = df
+            except Exception as e:
+                return jsonify({
+                    "error": f"Error reading {phase_name.upper()} CSV",
+                    "details": str(e)
+                }), 400
+
+        # Get API Keys
+        # Fallback to main key if specific ones aren't set
+        main_key = os.getenv("GOOGLE_API_KEY")
+        keys = {
+            'r': os.getenv("GOOGLE_API_KEY_1", main_key),
+            'y': os.getenv("GOOGLE_API_KEY_2", main_key),
+            'b': os.getenv("GOOGLE_API_KEY_3", main_key)
+        }
+        
+        # Prepare tasks
+        tasks = []
+        for phase in ['r', 'y', 'b']:
+            tasks.append((dfs[phase], breaker_id, keys[phase], phase))
+            
+        # Execute in parallel
+        results = {}
+        health_scores = []
+        
+        print("Starting parallel processing of 3 phases...")
+        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+            # Map tasks to futures
+            future_to_phase = {
+                executor.submit(process_single_phase_csv, task): task[3] 
+                for task in tasks
+            }
+            
+            for future in concurrent.futures.as_completed(future_to_phase):
+                phase = future_to_phase[future]
+                try:
+                    result = future.result()
+                    results[phase] = result
+                    if 'healthScore' in result:
+                        health_scores.append(result['healthScore'])
+                except Exception as exc:
+                    print(f'{phase} generated an exception: {exc}')
+                    results[phase] = {"error": str(exc)}
+
+        # Combine results into three-phase structure (removed breakerId and operator)
+        combined_result = {
+            "_id": str(uuid.uuid4()).replace('-', '')[:24],
+            "createdAt": datetime.now(timezone.utc).strftime("%a, %d %b %Y %H:%M:%S GMT"),
+            "healthScore": round(sum(health_scores) / len(health_scores), 1) if health_scores else 0,
+            "r": results.get('r', {}),
+            "y": results.get('y', {}),
+            "b": results.get('b', {})
+        }
+        
+        return jsonify(combined_result), 200
+    
+    except Exception as e:
+        # Log the full error for debugging
+        error_trace = traceback.format_exc()
+        print(f"ERROR in three-phase DCRM analysis: {error_trace}")
+        
+        # Return clean error to client
+        return jsonify({
+            "error": "Analysis failed",
+            "message": "An error occurred during DCRM analysis",
+            "error_type": type(e).__name__,
+            "error_details": str(e)
+        }), 500
+
+
+if __name__ == "__main__":
+    # Print all registered routes for debugging
+    print("Registered Routes:")
+    print(app.url_map)
+    
+    # Run the Flask app
+    # Run the Flask app
+    port = int(os.environ.get("PORT", 7860))
+    app.run(
+        host="0.0.0.0",
+        port=port,
+        debug=False, # Set debug to False for production
+        use_reloader=False
+    )

apps/streamlit_dashboard.py

@@ -0,0 +1,867 @@
+# Previous Name: streamlit_app_v2.py
+import streamlit as st
+import pandas as pd
+import numpy as np
+import os
+import json
+import sys
+
+# Add project root to sys.path to allow importing from core
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Ensure API key is set
+if not os.getenv("GOOGLE_API_KEY"):
+    st.error("GOOGLE_API_KEY not found in environment variables. Please check your .env file.")
+    st.stop()
+
+from langchain_experimental.agents.agent_toolkits import create_pandas_dataframe_agent
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import base64
+import io
+from langchain_core.messages import HumanMessage
+from core.agents.plotting import create_dcrm_plot, create_velocity_plot, create_resistance_zoom_plot, get_dcrm_prompt
+from core.calculators.kpi import calculate_kpis
+from core.calculators.cbhi import compute_cbhi
+from core.signal.phases import analyze_dcrm_data
+from core.engines.rules import analyze_dcrm_advanced
+from core.agents.diagnosis import detect_fault, standardize_input
+from core.utils.report_generator import generate_dcrm_json
+from core.agents.recommendation import generate_recommendations
+
+# Optional ViT Model (requires PyTorch compatibility)
+try:
+    from core.models.vit_classifier import predict_dcrm_image, plot_resistance_for_vit
+    VIT_AVAILABLE = True
+except Exception as e:
+    print(f"ViT Model not available: {e}")
+    VIT_AVAILABLE = False
+    predict_dcrm_image = None
+    plot_resistance_for_vit = None
+
+# --- Configuration & CSS ---
+st.set_page_config(page_title="DCRM Analyzer Pro", page_icon="⚡", layout="wide")
+
+def load_css():
+    st.markdown("""
+        <style>
+        /* Main Font */
+        html, body, [class*="css"] {
+            font-family: 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+        }
+        /* Headers */
+        h1, h2, h3 {
+            color: #2c3e50;
+            font-weight: 600;
+        }
+        /* Metrics */
+        [data-testid="stMetricValue"] {
+            font-size: 2rem;
+            color: #2980b9;
+        }
+        /* Cards/Containers */
+        .stExpander {
+            border: 1px solid #e0e0e0;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        }
+        /* Sidebar */
+        section[data-testid="stSidebar"] {
+            background-color: #f8f9fa;
+        }
+        /* Status Indicators */
+        .status-pass { color: #27ae60; font-weight: bold; }
+        .status-warning { color: #f39c12; font-weight: bold; }
+        .status-fail { color: #c0392b; font-weight: bold; }
+        </style>
+    """, unsafe_allow_html=True)
+
+def main():
+    load_css()
+    
+    with st.sidebar:
+        st.title("⚡ DCRM Analyzer")
+        st.markdown("---")
+        mode = st.radio("Select Module", ["General Chat", "DCRM Analysis"], index=1)
+        
+        # Segmentation method selector removed - using robust signal processing by default
+        
+        st.markdown("---")
+        st.caption("Powered by Gemini 1.5 Flash")
+
+    st.header(f"{mode}")
+
+    uploaded_file = st.file_uploader("Upload DCRM Data (CSV)", type="csv")
+
+    if uploaded_file is not None:
+        try:
+            df = pd.read_csv(uploaded_file)
+            llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+
+            if mode == "General Chat":
+                st.info("💡 **Tip:** You can ask for graphs! Try: 'Plot the resistance in Zone 2'")
+                
+                # Zone Enrichment Option
+                if st.checkbox("✨ Enrich Data with Zones"):
+                    with st.spinner("Detecting Zones..."):
+                        df, zones = enrich_data_with_zones(df, llm)
+                        st.success("Data enriched with 'Zone' column!")
+                
+                with st.expander("View Data"):
+                    st.dataframe(df.head())
+                
+                # Agent with Plotting Capabilities
+                agent = create_pandas_dataframe_agent(
+                    llm, 
+                    df, 
+                    verbose=True, 
+                    allow_dangerous_code=True, 
+                    handle_parsing_errors=True,
+                    prefix="""
+                    You are a data analysis agent. 
+                    If the user asks for a plot or graph:
+                    1. Use `plotly.graph_objects` (import as go) or `plotly.express` (import as px).
+                    2. Create the figure object `fig`.
+                    3. Display it using `st.plotly_chart(fig)`.
+                    4. Do NOT use matplotlib.
+                    5. Ensure you import streamlit as st inside the code execution.
+                    """
+                )
+                
+                st.divider()
+                user_question = st.chat_input("Ask a question or request a plot...")
+                
+                if user_question:
+                    st.chat_message("user").write(user_question)
+                    with st.spinner("Thinking..."):
+                        try:
+                            # We use the agent directly for everything now, as it handles both plotting and QA
+                            response = agent.run(user_question)
+                            
+                            with st.chat_message("assistant"):
+                                st.write(response)
+                                
+                        except Exception as e:
+                            st.error(f"An error occurred: {str(e)}")
+
+            elif mode == "DCRM Analysis":
+                if st.button("🚀 Run Advanced Analysis", type="primary", width='stretch'):
+                    with st.spinner("Performing Kinematic Segmentation & Diagnostics..."):
+                        try:
+                            # 1. Deterministic KPI Calculation
+                            kpi_results = calculate_kpis(df)
+                            kpis = kpi_results['kpis']
+                            # cbhi_score will be calculated later after AI and Phase analysis
+                            
+                            # 1.5. Phase Segmentation (using AI Agent)
+                            with st.spinner("Running AI-Based Phase Segmentation..."):
+                                # Use analyze_dcrm_data for robust segmentation and status
+                                phase_analysis_result = analyze_dcrm_data(df, llm)
+                                
+                                # Extract zones for plotting
+                                phase_to_zone_map = {
+                                    1: "zone_1_pre_contact",
+                                    2: "zone_2_arcing_engagement",
+                                    3: "zone_3_main_conduction",
+                                    4: "zone_4_parting",
+                                    5: "zone_5_final_open"
+                                }
+                                zones = {}
+                                phase_timings = []
+                                
+                                if 'phaseWiseAnalysis' in phase_analysis_result:
+                                    st.success("✓ AI Segmentation complete!")
+                                    for phase in phase_analysis_result['phaseWiseAnalysis']:
+                                        p_num = phase.get('phaseNumber')
+                                        zone_key = phase_to_zone_map.get(p_num)
+                                        start_time = phase.get('startTime', 0)
+                                        end_time = phase.get('endTime', 0)
+                                        duration = end_time - start_time
+                                        
+                                        if zone_key:
+                                            zones[zone_key] = {
+                                                'start_ms': start_time,
+                                                'end_ms': end_time
+                                            }
+                                        
+                                        phase_timings.append({
+                                            "Phase": phase.get('name'),
+                                            "Start (ms)": start_time,
+                                            "End (ms)": end_time,
+                                            "Duration (ms)": duration
+                                        })
+                                else:
+                                    st.warning("⚠️ AI Segmentation returned no zones.")
+                            
+                            # 2. Rule Engine & AI Agent Analysis
+                            # Prepare KPIs for Raj modules (needs specific format)
+                            # kpis dict from calculate_kpis_and_score is flat: {'closing_time': 45.15, ...}
+                            # Raj modules expect: {'kpis': [{'name': 'Closing Time', 'value': ...}, ...]} or dict {'Closing Time (ms)': ...}
+                            # Let's construct the dict format expected by raj_rule_engine (it handles dicts loosely but prefers specific keys)
+                            
+                            # Mapping current KPIs to Raj expected keys
+                            raj_kpis = {
+                                "Closing Time (ms)": kpis.get('closing_time'),
+                                "Opening Time (ms)": kpis.get('opening_time'),
+                                "Contact Speed (m/s)": kpis.get('contact_speed'),
+                                "DLRO Value (µΩ)": kpis.get('dlro'),
+                                "Peak Resistance (µΩ)": kpis.get('peak_resistance'),
+                                "Peak Close Coil Current (A)": kpis.get('peak_close_coil'),
+                                "Peak Trip Coil 1 Current (A)": kpis.get('peak_trip_coil_1'),
+                                "Peak Trip Coil 2 Current (A)": kpis.get('peak_trip_coil_2'),
+                                "SF6 Pressure (bar)": kpis.get('sf6_pressure'),
+                                "Ambient Temperature (°C)": kpis.get('ambient_temp'),
+                                "Main Wipe (mm)": kpis.get('main_wipe'),
+                                "Arc Wipe (mm)": kpis.get('arc_wipe'),
+                                "Contact Travel Distance (mm)": kpis.get('contact_travel')
+                            }
+                            
+                            # Also construct the list format for raj_ai_agent if needed, but detect_fault takes sample_kpis dict
+                            # detect_fault expects: {'kpis': [{'name': '...', 'value': ...}]}
+                            raj_ai_kpis = {
+                                "kpis": [
+                                    {"name": "Closing Time", "unit": "ms", "value": kpis.get('closing_time')},
+                                    {"name": "Opening Time", "unit": "ms", "value": kpis.get('opening_time')},
+                                    {"name": "DLRO Value", "unit": "µΩ", "value": kpis.get('dlro')},
+                                    {"name": "Peak Resistance", "unit": "µΩ", "value": kpis.get('peak_resistance')},
+                                    {"name": "Contact Speed", "unit": "m/s", "value": kpis.get('contact_speed')},
+                                    {"name": "Peak Close Coil Current", "unit": "A", "value": kpis.get('peak_close_coil')},
+                                    {"name": "Peak Trip Coil 1 Current", "unit": "A", "value": kpis.get('peak_trip_coil_1')},
+                                    {"name": "Peak Trip Coil 2 Current", "unit": "A", "value": kpis.get('peak_trip_coil_2')},
+                                    {"name": "SF6 Pressure", "unit": "bar", "value": kpis.get('sf6_pressure')},
+                                    {"name": "Ambient Temperature", "unit": "°C", "value": kpis.get('ambient_temp')}
+                                ]
+                            }
+
+                            # Prepare row values for Rule Engine
+                            # We need 401 points. If df has > 401, take first 401. If < 401, pad?
+                            # Assuming standard 400ms data at 1ms sample rate.
+                            # If Time_ms is present, we can try to resample or just take the Resistance column values.
+                            # raj_rule_engine.standardize_input handles this.
+                            
+                            # Create a temp df for standardize_input
+                            temp_df = df[['Resistance']].copy()
+                            # Ensure we have enough data or handle it
+                            if len(temp_df) < 401:
+                                # Pad with last value
+                                last_val = temp_df.iloc[-1, 0]
+                                padding = pd.DataFrame({'Resistance': [last_val] * (401 - len(temp_df))})
+                                temp_df = pd.concat([temp_df, padding], ignore_index=True)
+                            
+                            std_df = standardize_input(temp_df)
+                            row_values = std_df.iloc[0].values.tolist()
+
+                            # --- Run Rule Engine ---
+                            rule_engine_result = analyze_dcrm_advanced(row_values, raj_kpis)
+                            
+                            # --- Run AI Agent ---
+                            # detect_fault takes (df, sample_kpis)
+                            # We can pass the original df, it calls standardize_input internally
+                            ai_agent_result = detect_fault(df, raj_ai_kpis)
+
+                            # --- Run ViT Model (Visual Inspection) ---
+                            vit_result = None
+                            # --- Run ViT Model (Visual Inspection) ---
+                            vit_result = None
+                            vit_plot_path = "temp_vit_plot.png"
+                            
+                            # Always generate plot (doesn't require torch)
+                            plot_generated = False
+                            try:
+                                if plot_resistance_for_vit(df, vit_plot_path):
+                                    plot_generated = True
+                            except Exception as e:
+                                print(f"ViT Plot generation failed: {e}")
+
+                            # Try prediction if plot exists and VIT is available
+                            if plot_generated and VIT_AVAILABLE:
+                                try:
+                                    vit_class, vit_conf, vit_details = predict_dcrm_image(vit_plot_path)
+                                    if vit_class: # Ensure we got a result
+                                        vit_result = {
+                                            "class": vit_class,
+                                            "confidence": vit_conf,
+                                            "details": vit_details
+                                        }
+                                except Exception as e:
+                                    print(f"ViT Prediction failed: {e}")
+
+
+
+                            # ============================================
+                            # SECTION 1: CBHI SCORE & KPIs
+                            # ============================================
+                            
+                            # Calculate CBHI using new logic
+                            # Prepare phase_data for CBHI
+                            cbhi_phase_data = {}
+                            if 'phaseWiseAnalysis' in phase_analysis_result:
+                                for phase in phase_analysis_result['phaseWiseAnalysis']:
+                                    p_name = f"Phase {phase.get('phaseNumber')}"
+                                    cbhi_phase_data[p_name] = {
+                                        "status": phase.get('status', 'Unknown'),
+                                        "confidence": phase.get('confidence', 0)
+                                    }
+                            
+                            # Compute Score
+                            cbhi_score = compute_cbhi(raj_ai_kpis['kpis'], ai_agent_result, cbhi_phase_data)
+
+                            # --- Run Recommendation Agent ---
+                            with st.spinner("Generating Maintenance Recommendations..."):
+                                recommendations = generate_recommendations(
+                                    kpis=kpis,
+                                    cbhi_score=cbhi_score,
+                                    rule_faults=rule_engine_result.get("Fault_Detection", []),
+                                    ai_faults=ai_agent_result.get("Fault_Detection", []),
+                                    llm=llm
+                                )
+                            
+                            st.markdown("## 🏆 Composite Breaker Health Index (CBHI)")
+                            
+                            # CBHI Score Display
+                            cbhi_col1, cbhi_col2, cbhi_col3 = st.columns([1, 2, 1])
+                            
+                            with cbhi_col1:
+                                st.markdown("")  # Spacer
+                            
+                            with cbhi_col2:
+                                # Large centered score
+                                if cbhi_score >= 90:
+                                    score_color = "#27ae60"  # Green
+                                    status_text = "✅ Excellent Condition"
+                                    status_color = "success"
+                                    gradient = "linear-gradient(135deg, #11998e 0%, #38ef7d 100%)"
+                                elif cbhi_score >= 75:
+                                    score_color = "#f39c12"  # Orange
+                                    status_text = "⚠️ Good - Minor Review Needed"
+                                    status_color = "warning"
+                                    gradient = "linear-gradient(135deg, #f093fb 0%, #f5576c 100%)"
+                                else:
+                                    score_color = "#e74c3c"  # Red
+                                    status_text = "🚨 Critical Attention Required"
+                                    status_color = "error"
+                                    gradient = "linear-gradient(135deg, #fa709a 0%, #fee140 100%)"
+                                
+                                st.markdown(f"""
+                                <div style='text-align: center; padding: 30px; background: {gradient}; border-radius: 20px; box-shadow: 0 8px 16px rgba(0,0,0,0.2);'>
+                                    <h1 style='color: white; font-size: 5rem; margin: 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);'>{cbhi_score}</h1>
+                                    <p style='color: white; font-size: 1.4rem; margin: 10px 0; font-weight: 500;'>out of 100</p>
+                                </div>
+                                """, unsafe_allow_html=True)
+                                
+                                st.markdown("<br>", unsafe_allow_html=True)
+                                
+                                if status_color == "success":
+                                    st.success(status_text)
+                                elif status_color == "warning":
+                                    st.warning(status_text)
+                                else:
+                                    st.error(status_text)
+                            
+                            with cbhi_col3:
+                                st.markdown("")  # Spacer
+                            
+                            st.markdown("---")
+                            
+                            # KPIs Section
+                            st.markdown("### 📊 Key Performance Indicators")
+                            st.caption("Measured parameters from DCRM test data")
+                            
+                            # Timing & Motion
+                            with st.container():
+                                st.markdown("**⏱️ Timing & Motion**")
+                                k1, k2, k3, k4 = st.columns(4)
+                                k1.metric("Closing Time", f"{kpis['closing_time']} ms", help="Time taken for contacts to close")
+                                k2.metric("Opening Time", f"{kpis['opening_time']} ms", help="Time taken for contacts to open")
+                                k3.metric("Contact Speed", f"{kpis['contact_speed']} m/s", help="Average contact movement speed")
+                                k4.metric("Contact Travel", f"{kpis['contact_travel']} mm", help="Total mechanical travel distance")
+                            
+                            st.markdown("")
+                            
+                            # Contact Health
+                            with st.container():
+                                st.markdown("**🔌 Contact Health**")
+                                k5, k6, k7, k8 = st.columns(4)
+                                k5.metric("DLRO", f"{kpis['dlro']} µΩ", help="Dynamic Low Resistance - contact quality indicator")
+                                k6.metric("Peak Resistance", f"{kpis['peak_resistance']} µΩ", help="Maximum resistance during operation")
+                                k7.metric("Main Wipe", f"{kpis['main_wipe']} mm", help="Main contact wipe distance")
+                                k8.metric("Arc Wipe", f"{kpis['arc_wipe']} mm", help="Arcing contact wipe distance")
+                            
+                            st.markdown("")
+                            
+                            # Electrical & Environment
+                            with st.container():
+                                st.markdown("**⚡ Electrical & Environment**")
+                                k9, k10, k11, k12, k13 = st.columns(5)
+                                k9.metric("Close Coil", f"{kpis['peak_close_coil']} A", help="Peak closing coil current")
+                                k10.metric("Trip Coil 1", f"{kpis['peak_trip_coil_1']} A", help="Peak trip coil 1 current")
+                                k11.metric("Trip Coil 2", f"{kpis['peak_trip_coil_2']} A", help="Peak trip coil 2 current")
+                                k12.metric("Temperature", f"{kpis['ambient_temp']} °C", help="Ambient temperature during test")
+                                k13.metric("SF6 Pressure", f"{kpis['sf6_pressure']} bar", help="SF6 gas pressure")
+
+                            st.markdown("---")
+                            
+                            # ============================================
+                            # SECTION 2: SEGMENTED GRAPH WITH ZONES
+                            # ============================================
+                            
+                            st.markdown("## 📈 DCRM Waveforms with Phase Segmentation")
+                            st.caption("Programmatic phase detection using resistance, current, and travel thresholds")
+                            
+                            # Generate the full JSON report first to get phase boundaries
+                            with st.spinner("Analyzing phases and generating report..."):
+                                full_report = generate_dcrm_json(
+                                    df=df,
+                                    kpis=kpis,
+                                    cbhi_score=cbhi_score,
+                                    rule_result=rule_engine_result,
+                                    ai_result=ai_agent_result,
+                                    llm=llm,
+                                    vit_result=vit_result,
+                                    phase_analysis_result=phase_analysis_result,
+                                    recommendations=recommendations
+                                )
+                            
+                            # Get phase boundaries and create zone timing table
+                            phase_to_zone_map = {
+                                "Pre-Contact Travel": "zone_1_pre_contact",
+                                "Arcing Contact Engagement & Arc Initiation": "zone_2_arcing_engagement",
+                                "Main Contact Conduction": "zone_3_main_conduction",
+                                "Main Contact Parting & Arc Elongation": "zone_4_parting",
+                                "Final Open State": "zone_5_final_open"
+                            }
+                            
+                            zones = {}
+                            phase_timings = []
+                            
+                            if 'phaseWiseAnalysis' in full_report:
+                                for phase in full_report['phaseWiseAnalysis']:
+                                    phase_name = phase.get('name', '')
+                                    zone_key = phase_to_zone_map.get(phase_name)
+                                    start_time = phase.get('startTime', 0)
+                                    end_time = phase.get('endTime', 0)
+                                    duration = end_time - start_time
+                                    
+                                    if zone_key:
+                                        zones[zone_key] = {
+                                            'start_ms': start_time,
+                                            'end_ms': end_time
+                                        }
+                                    
+                                    phase_timings.append({
+                                        "Phase": phase_name,
+                                        "Start (ms)": start_time,
+                                        "End (ms)": end_time,
+                                        "Duration (ms)": duration
+                                    })
+                            
+                            # Display graph
+                            fig_main = create_dcrm_plot(df, zones)
+                            st.plotly_chart(fig_main, width='stretch')
+                            
+                            # Display phase timing table
+                            if phase_timings:
+                                st.markdown("#### ⏱️ Phase Timing Breakdown")
+                                timing_df = pd.DataFrame(phase_timings)
+                                st.dataframe(timing_df, width='stretch', hide_index=True)
+
+                            st.markdown("---")
+                            
+                            # ============================================
+                            # SECTION 3: PHASE-WISE DETAILED ANALYSIS
+                            # ============================================
+                            
+                            st.markdown("## 🔍 Phase-Wise Detailed Analysis")
+                            st.caption("AI-enhanced analysis of each operational phase with diagnostic verdicts")
+                            
+                            if 'phaseWiseAnalysis' in full_report:
+                                for phase in full_report['phaseWiseAnalysis']:
+                                    phase_num = phase.get('phaseNumber', 0)
+                                    phase_name = phase.get('name', 'Unknown Phase')
+                                    phase_title = phase.get('phaseTitle', phase_name)
+                                    phase_desc = phase.get('description', '')
+                                    confidence = phase.get('confidence', 0)
+                                    
+                                    # Color code by phase
+                                    phase_colors = {
+                                        1: "#ff9800",  # Orange
+                                        2: "#ff26bd",  # Pink
+                                        3: "#4caf50",  # Green
+                                        4: "#2196f3",  # Blue
+                                        5: "#a629ff"   # Purple
+                                    }
+                                    phase_color = phase_colors.get(phase_num, "#cccccc")
+                                    
+                                    with st.expander(f"**Phase {phase_num}: {phase_name}** | Confidence: {confidence}%", expanded=False):
+                                        # Phase header
+                                        st.markdown(f"""
+                                        <div style='padding: 15px; background-color: {phase_color}22; border-left: 5px solid {phase_color}; border-radius: 5px; margin-bottom: 15px;'>
+                                            <h4 style='margin: 0; color: {phase_color};'>{phase_title}</h4>
+                                            <p style='margin: 5px 0 0 0; color: #666;'>{phase_desc}</p>
+                                        </div>
+                                        """, unsafe_allow_html=True)
+                                        
+                                        # Event Synopsis
+                                        event_synopsis = phase.get('eventSynopsis', '')
+                                        if event_synopsis:
+                                            st.markdown("**📋 Event Synopsis**")
+                                            st.info(event_synopsis)
+                                        
+                                        # Key Characteristics
+                                        characteristics = phase.get('details', {}).get('characteristics', [])
+                                        if characteristics:
+                                            st.markdown("**🔑 Key Characteristics**")
+                                            for char in characteristics:
+                                                st.markdown(f"- {char}")
+                                        
+                                        # Waveform Analysis
+                                        waveform = phase.get('waveformAnalysis', {})
+                                        if waveform:
+                                            st.markdown("**📊 Waveform Analysis**")
+                                            
+                                            wave_col1, wave_col2, wave_col3 = st.columns(3)
+                                            
+                                            with wave_col1:
+                                                st.markdown("**Resistance**")
+                                                st.caption(waveform.get('resistance', 'N/A'))
+                                            
+                                            with wave_col2:
+                                                st.markdown("**Current**")
+                                                st.caption(waveform.get('current', 'N/A'))
+                                            
+                                            with wave_col3:
+                                                st.markdown("**Travel**")
+                                                st.caption(waveform.get('travel', 'N/A'))
+                                        
+                                        # Diagnostic Verdict
+                                        verdict = phase.get('diagnosticVerdict', '')
+                                        if verdict:
+                                            st.markdown("**🩺 Diagnostic Verdict & Justification**")
+                                            st.success(verdict)
+
+                            st.markdown("---")
+                            
+                            # ============================================
+                            # SECTION 4: AI AGENT ANALYSIS
+                            # ============================================
+                            
+                            st.markdown("## 🤖 AI Agent Analysis (Generative)")
+                            st.caption("Deep learning-based fault detection using physics-informed signatures")
+                            
+                            ai_faults = ai_agent_result.get("Fault_Detection", [])
+                            if not ai_faults:
+                                st.success("✅ **No AI-detected faults found.** System appears healthy based on generative AI analysis.")
+                            else:
+                                for idx, fault in enumerate(ai_faults):
+                                    name = fault.get("defect_name", "Unknown")
+                                    conf = fault.get("Confidence", "0%")
+                                    sev = fault.get("Severity", "Low")
+                                    desc = fault.get("description", "")
+                                    
+                                    # Check if this is "No Secondary Defect Detected"
+                                    if "no secondary defect" in name.lower() or "no defect" in name.lower():
+                                        st.success(f"✅ **{name}**")
+                                    else:
+                                        # Color code by severity
+                                        if sev == "Critical":
+                                            icon = "🔴"
+                                            border_color = "#e74c3c"
+                                        elif sev == "High":
+                                            icon = "🟠"
+                                            border_color = "#f39c12"
+                                        else:
+                                            icon = "🟡"
+                                            border_color = "#f1c40f"
+                                        
+                                        with st.expander(f"{icon} **{name}** | Confidence: {conf} | Severity: {sev}", expanded=(sev in ["Critical", "High"])):
+                                            st.markdown(f"""
+                                            <div style='padding: 10px; background-color: {border_color}11; border-left: 4px solid {border_color}; border-radius: 5px;'>
+                                                <p style='margin: 0;'><strong>AI Reasoning:</strong> {desc}</p>
+                                            </div>
+                                            """, unsafe_allow_html=True)
+
+                            st.markdown("---")
+                            
+                            # ============================================
+                            # SECTION 5: RULE ENGINE ANALYSIS
+                            # ============================================
+                            
+                            st.markdown("## ⚙️ Rule-Based Analysis (Deterministic)")
+                            st.caption("Threshold-based fault detection using industry standards and expert knowledge")
+                            
+                            re_faults = rule_engine_result.get("Fault_Detection", [])
+                            if not re_faults:
+                                st.success("✅ **No rule-based faults detected.** All parameters within acceptable ranges per industry standards.")
+                            else:
+                                for idx, fault in enumerate(re_faults):
+                                    name = fault.get("defect_name", "Unknown")
+                                    conf = fault.get("Confidence", "0%")
+                                    sev = fault.get("Severity", "Low")
+                                    desc = fault.get("description", "")
+                                    
+                                    # Color code by severity
+                                    if sev == "Critical":
+                                        icon = "🔴"
+                                        border_color = "#e74c3c"
+                                    elif sev == "High":
+                                        icon = "🟠"
+                                        border_color = "#f39c12"
+                                    else:
+                                        icon = "🟡"
+                                        border_color = "#f1c40f"
+                                    
+                                    with st.expander(f"{icon} **{name}** | Confidence: {conf} | Severity: {sev}", expanded=(sev in ["Critical", "High"])):
+                                        st.markdown(f"""
+                                        <div style='padding: 10px; background-color: {border_color}11; border-left: 4px solid {border_color}; border-radius: 5px;'>
+                                            <p style='margin: 0;'><strong>Rule Engine Reasoning:</strong> {desc}</p>
+                                        </div>
+                                        """, unsafe_allow_html=True)
+
+                            st.markdown("---")
+                            
+                            # ============================================
+                            # SECTION 6: ViT MODEL ANALYSIS
+                            # ============================================
+                            
+                            st.markdown("## 📸 Visual Pattern Recognition (ViT Model)")
+                            st.caption("Computer vision-based classification using Vision Transformer neural network")
+                            
+                            vit_col1, vit_col2 = st.columns([1, 2])
+                            
+                            with vit_col1:
+                                if plot_generated:
+                                    st.image(vit_plot_path, caption="Resistance Curve Input", width='stretch')
+                                else:
+                                    st.warning("⚠️ Could not generate visualization.")
+                                    
+                            with vit_col2:
+                                if vit_result:
+                                    pred_class = vit_result['class']
+                                    pred_conf = vit_result['confidence'] * 100
+                                    
+                                    st.markdown("### 🎯 Prediction Results (ViT + Gemini Ensemble)")
+                                    
+                                    metric_col1, metric_col2 = st.columns(2)
+                                    with metric_col1:
+                                        st.metric("Predicted Condition", pred_class)
+                                    with metric_col2:
+                                        st.metric("Ensemble Confidence", f"{pred_conf:.1f}%")
+                                    
+                                    st.markdown("---")
+                                    
+                                    # Show Breakdown if available
+                                    details = vit_result.get("details", {})
+                                    if details and details.get("gemini_probs"):
+                                        with st.expander("📊 Detailed Ensemble Breakdown", expanded=True):
+                                            st.caption("Comparison of ViT Model and Gemini Expert Analysis")
+                                            
+                                            # Prepare data for chart
+                                            vit_probs = details.get("vit_probs", {})
+                                            gemini_probs = details.get("gemini_probs", {})
+                                            ensemble_scores = details.get("ensemble_scores", {})
+                                            
+                                            chart_data = []
+                                            for cls, score in ensemble_scores.items():
+                                                chart_data.append({
+                                                    "Class": cls,
+                                                    "ViT": vit_probs.get(cls, 0),
+                                                    "Gemini": gemini_probs.get(cls, 0),
+                                                    "Ensemble": score
+                                                })
+                                            
+                                            if chart_data:
+                                                st.bar_chart(
+                                                    pd.DataFrame(chart_data).set_index("Class")[["ViT", "Gemini", "Ensemble"]]
+                                                )
+                                    
+                                    if pred_class == "Healthy":
+                                        st.success("✅ **Visual pattern matches healthy signature.**")
+                                    else:
+                                        st.warning(f"⚠️ **Visual pattern suggests: {pred_class}**")
+                                        
+                                elif not VIT_AVAILABLE:
+                                    st.info("ℹ️ **ViT Model Unavailable**\n\nThe Vision Transformer model requires PyTorch.")
+                                else:
+                                    st.warning("⚠️ **Prediction failed.** Model may not be loaded correctly or input image is invalid.")
+
+                            st.markdown("---")
+                            
+                            # ============================================
+                            # SECTION 7: ADDITIONAL DIAGNOSTICS
+                            # ============================================
+                            
+                            st.markdown("## 🔬 Additional Diagnostic Plots")
+                            st.caption("Supplementary visualizations for detailed analysis")
+                            
+                            diag_col1, diag_col2 = st.columns(2)
+                            
+                            with diag_col1:
+                                st.markdown("### Contact Velocity Profile")
+                                st.caption("Derivative of travel - indicates mechanical performance")
+                                fig_vel = create_velocity_plot(df)
+                                st.plotly_chart(fig_vel, width='stretch')
+                                
+                            with diag_col2:
+                                st.markdown("### Resistance Detail (Log Scale)")
+                                st.caption("Logarithmic view reveals subtle resistance variations")
+                                fig_res = create_resistance_zoom_plot(df)
+                                st.plotly_chart(fig_res, width='stretch')
+
+                            st.markdown("---")
+                            st.markdown("---")
+                            
+                            # ============================================
+                            # SECTION 8: RECOMMENDATIONS & PREDICTIONS
+                            # ============================================
+                            
+                            st.markdown("## 🛠️ Recommendations & Future Fault Predictions")
+                            st.caption("AI-generated maintenance actions and predictive failure analysis")
+                            
+                            # Maintenance Actions
+                            if recommendations.get("maintenanceActions"):
+                                st.markdown("### 🔧 Recommended Maintenance Actions")
+                                for group in recommendations["maintenanceActions"]:
+                                    priority = group.get("priority", "Priority")
+                                    color = group.get("color", "#333")
+                                    bg_color = group.get("bgColor", "#eee")
+                                    
+                                    st.markdown(f"""
+                                    <div style='background-color: {bg_color}; padding: 10px; border-radius: 5px; border-left: 5px solid {color}; margin-bottom: 10px;'>
+                                        <h4 style='color: {color}; margin: 0;'>{priority}</h4>
+                                    </div>
+                                    """, unsafe_allow_html=True)
+                                    
+                                    for action in group.get("actions", []):
+                                        with st.expander(f"**{action.get('title')}**"):
+                                            st.markdown(f"**Justification:** {action.get('justification')}")
+                                            st.markdown(f"**Timeline:** {action.get('timeline')}")
+                                            if action.get("whatToLookFor"):
+                                                st.markdown("**What to Look For:**")
+                                                for item in action["whatToLookFor"]:
+                                                    st.markdown(f"- {item}")
+
+                            st.markdown("---")
+
+                            # Future Faults
+                            if recommendations.get("futureFaultsPdf"):
+                                st.markdown("### 🔮 Future Fault Predictions")
+                                
+                                cols = st.columns(len(recommendations["futureFaultsPdf"]))
+                                for idx, fault in enumerate(recommendations["futureFaultsPdf"]):
+                                    with cols[idx % 4]: # Wrap around if many
+                                        prob = fault.get("probability", 0)
+                                        color = fault.get("color", "#333")
+                                        
+                                        st.markdown(f"""
+                                        <div style='text-align: center; border: 1px solid #ddd; border-radius: 10px; padding: 15px; height: 100%;'>
+                                            <h3 style='color: {color};'>{prob}%</h3>
+                                            <p style='font-weight: bold;'>{fault.get('fault')}</p>
+                                            <p style='font-size: 0.9em; color: #666;'>{fault.get('timeline')}</p>
+                                            <hr>
+                                            <p style='font-size: 0.8em; text-align: left;'>{fault.get('evidence')}</p>
+                                        </div>
+                                        """, unsafe_allow_html=True)
+
+                            st.markdown("---")
+
+                            # RUL Estimation
+                            ai_verdict = full_report.get("aiVerdict", {})
+                            rul_est = ai_verdict.get("rulEstimate")
+                            uncertainty = ai_verdict.get("uncertainty")
+                            
+                            if rul_est:
+                                st.markdown("### ⏳ Remaining Useful Life (RUL) Estimation")
+                                st.caption("Estimated remaining operations based on current degradation")
+                                
+                                rul_col1, rul_col2 = st.columns(2)
+                                with rul_col1:
+                                    st.metric("RUL Estimate", rul_est, delta=uncertainty, delta_color="off")
+                                with rul_col2:
+                                    st.info(f"**Uncertainty:** {uncertainty}\n\nThis estimate considers contact wear, timing deviations, and coil health.")
+                                
+                                st.markdown("---")
+
+                            # AI Strategic Advice
+                            ai_advice = ai_verdict.get("aiAdvice", [])
+                            if ai_advice:
+                                st.markdown("## 🧠 AI Strategic Advisory")
+                                st.caption("Expert recommendations based on engineering analysis")
+                                
+                                for advice in ai_advice:
+                                    color = advice.get("color", "#333")
+                                    title = advice.get("title", "Recommendation")
+                                    desc = advice.get("description", "")
+                                    impact = advice.get("expectedImpact", "")
+                                    priority = advice.get("priority", "Medium")
+                                    
+                                    with st.expander(f"**{priority}**: {title}", expanded=(priority=="Critical")):
+                                        st.markdown(f"""
+                                        <div style='border-left: 5px solid {color}; padding-left: 15px;'>
+                                            <p><strong>Rationale:</strong> {desc}</p>
+                                            <p><strong>Expected Impact:</strong> {impact}</p>
+                                        </div>
+                                        """, unsafe_allow_html=True)
+                                        
+                                        effects = advice.get("effectAnalysis", {})
+                                        if effects:
+                                            e_col1, e_col2 = st.columns(2)
+                                            with e_col1:
+                                                if effects.get("shortTerm"):
+                                                    st.markdown("**Short Term Benefits:**")
+                                                    for item in effects["shortTerm"]:
+                                                        st.markdown(f"- {item}")
+                                            with e_col2:
+                                                if effects.get("longTerm"):
+                                                    st.markdown("**Long Term Benefits:**")
+                                                    for item in effects["longTerm"]:
+                                                        st.markdown(f"- {item}")
+                                
+                                st.markdown("---")
+                            
+                            # ============================================
+                            # SECTION 9: DOWNLOAD REPORT
+                            # ============================================
+                            
+                            st.markdown("## 📥 Export Analysis Report")
+                            st.caption("Download complete JSON report with all metrics, phase data, and AI insights")
+                            
+                            col_download1, col_download2, col_download3 = st.columns([1, 2, 1])
+                            
+                            with col_download1:
+                                st.markdown("")  # Spacer
+                            
+                            with col_download2:
+                                st.download_button(
+                                    label="📄 Download Full Report (JSON)",
+                                    data=json.dumps(full_report, indent=2),
+                                    file_name=f"dcrm_analysis_report_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.json",
+                                    mime="application/json",
+                                    width='stretch'
+                                )
+                                st.caption("✅ Includes: KPIs, CBHI score, phase analysis, AI verdicts, rule engine results, and ViT predictions")
+                            
+                            with col_download3:
+                                st.markdown("")  # Spacer
+
+
+                            
+                        except Exception as e:
+                            st.error(f"Analysis failed: {str(e)}")
+                            st.expander("Debug Info").write(content if 'content' in locals() else "No content")
+                else:
+                    st.info("Click 'Run Advanced Analysis' to start.")
+                    with st.expander("Preview Raw Data"):
+                        st.dataframe(df.head())
+
+        except Exception as e:
+            st.error(f"Error reading CSV file: {str(e)}")
+
+if __name__ == "__main__":
+    main()

core/agents/advice.py

@@ -0,0 +1,395 @@
+# Previous Name: analysis/agents/advice_agent.py
+import os
+import sys
+import json
+import google.generativeai as genai
+
+# Set UTF-8 encoding for console output
+if sys.stdout.encoding != 'utf-8':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+# =========================
+# CONFIGURATION
+# =========================
+API_KEY = os.environ.get("GOOGLE_API_KEY", "AIzaSyDSGda4-5VLmd-y09K6sBfHqoqk1QUL6Xo")
+genai.configure(api_key=API_KEY)
+
+MODEL_NAME = "gemini-2.0-flash"
+
+# =========================
+# AI ADVICE GENERATION PROMPT
+# =========================
+AI_ADVICE_PROMPT = """
+Role: You are an elite Circuit Breaker Condition Monitoring & Diagnostics Expert with deep domain expertise in DCRM (Dynamic Contact Resistance Measurement), operating mechanism health, SF6 gas systems, contact metallurgy, and circuit breaker failure modes. You understand the nuances of contact bounce, contact wear progression, trip coil degradation, insulation breakdown, and mechanical timing issues.
+
+Your Task: Based on comprehensive diagnostic data including RUL analysis, maintenance recommendations, and future fault predictions, generate 3-5 **Strategic Advisory Recommendations** that provide actionable insights grounded in circuit breaker engineering principles and field maintenance best practices.
+
+===== INPUT DATA =====
+
+**RUL Analysis (Remaining Useful Life):**
+{rul_json}
+
+**Maintenance Actions:**
+{maintenance_json}
+
+**Future Fault Predictions:**
+{future_faults_json}
+
+**KPIs (Key Performance Indicators):**
+{kpis_json}
+
+**CBHI Score:**
+{cbhi_score} / 100
+
+**Phase-Wise Analysis:**
+{phase_analysis_json}
+
+**AI Fault Detection:**
+{ai_verdict_json}
+
+===== AI ADVICE GUIDELINES =====
+
+**Purpose**: Provide **domain-rich, engineering-focused** recommendations that demonstrate deep understanding of circuit breaker systems. Focus on:
+- Contact resistance mitigation strategies and bounce reduction techniques
+- Operating mechanism calibration and spring tension optimization
+- SF6 gas management protocols and leak detection
+- Contact refurbishment timing based on resistance trends
+- Trip coil redundancy monitoring and protection system integrity
+- Mechanical timing adjustments and damping system optimization
+
+**Advice Categories to Consider (Based on Maintenance Actions & Future Faults):**
+1. **Critical Interventions** (Priority: Critical, Color: #B71C1C)
+   - Address Priority 1 maintenance actions and high-probability future faults
+   - Focus on trip coil failures, severe contact wear (>250µΩ DLRO), SF6 leaks
+   - Examples: "Optimize Contact Bounce Mitigation Strategy", "Enhance SF6 Gas Management Protocol"
+
+2. **High-Priority Optimizations** (Priority: High, Color: #F57F17)
+   - Address Priority 2 maintenance actions and medium-probability future faults
+   - Focus on operating mechanism issues, contact refurbishment, insulation degradation
+   - Examples: "Recalibrate Operating Mechanism Timing", "Implement Contact Wear Tracking Program"
+
+3. **Preventive Enhancements** (Priority: High/Medium, Color: #F57F17 or #0D47A1)
+   - Address Priority 3+ maintenance actions and low-probability future faults
+   - Focus on long-term reliability improvements and preventive measures
+   - Examples: "Optimize Lubrication & Damping Systems", "Enhance Phase-Wise Diagnostic Monitoring"
+
+**CRITICAL JSON FORMATTING RULES:**
+- All strings must use double quotes (")
+- Escape any double quotes within strings using backslash (\")
+- Do NOT use smart quotes, apostrophes, or special Unicode quotes
+- Ensure all brackets and braces are properly matched
+- Use standard ASCII characters only in field values
+
+**Output Structure (EXACT format required):**
+
+{{
+  "aiAdvice": [
+    {{
+      "color": "#B71C1C",
+      "confidence": 94,
+      "description": "Clear, domain-specific description focusing on circuit breaker systems. Explain the engineering rationale and field maintenance approach. Reference specific components like contact springs, damping dashpots, SF6 purity, contact metallurgy, or mechanism linkages. Keep it concise but technically rich (MAX 250 characters).",
+      "effectAnalysis": {{
+        "longTerm": [
+          "Long-term benefit 1 (e.g., 'Extended circuit breaker service life by 25-30%')",
+          "Long-term benefit 2 (e.g., 'Reduced maintenance costs by $50,000-75,000 annually')",
+          "Long-term benefit 3 (e.g., 'Improved grid reliability and reduced downtime')",
+          "Long-term benefit 4 (e.g., 'Predictive maintenance scheduling optimization')"
+        ],
+        "performanceGains": [
+          "Performance gain 1 (e.g., 'Improved contact resistance stability')",
+          "Performance gain 2 (e.g., 'Enhanced operational reliability')"
+        ],
+        "riskMitigation": [
+          "Risk mitigation 1 (e.g., 'Prevent catastrophic failures through early detection')",
+          "Risk mitigation 2 (e.g., 'Reduce unplanned outages by 75%')"
+        ],
+        "shortTerm": [
+          "Short-term benefit 1 (e.g., 'Immediate improvement in contact resistance stability')",
+          "Short-term benefit 2 (e.g., 'Reduced contact bounce amplitude by 60-70%')",
+          "Short-term benefit 3 (e.g., 'Enhanced SF6 pressure monitoring accuracy')",
+          "Short-term benefit 4 (e.g., 'Real-time fault detection capabilities')"
+        ]
+      }},
+      "expectedImpact": "Primary quantifiable or qualitative benefit (e.g., 'Reduce contact wear rate by 40%', 'Prevent contact welding risk', 'Extend asset life by 2-3 years'). Be specific and measurable (MAX 100 characters).",
+      "id": "1",
+      "priority": "Critical",
+      "title": "Domain-specific, action-oriented title (e.g., 'Optimize Contact Bounce Mitigation Strategy', 'Enhance SF6 Gas Management Protocol'). MAX 80 characters."
+    }},
+    {{
+      "color": "#F57F17",
+      "confidence": 89,
+      "description": "Second most critical advice with engineering depth.",
+      "effectAnalysis": {{
+        "longTerm": ["benefit 1", "benefit 2", "benefit 3", "benefit 4"],
+        "performanceGains": ["gain 1", "gain 2"],
+        "riskMitigation": ["mitigation 1", "mitigation 2"],
+        "shortTerm": ["benefit 1", "benefit 2", "benefit 3", "benefit 4"]
+      }},
+      "expectedImpact": "Expected benefit or risk reduction.",
+      "id": "2",
+      "priority": "High",
+      "title": "Second priority engineering recommendation"
+    }},
+    {{
+      "color": "#F57F17",
+      "confidence": 92,
+      "description": "Third strategic recommendation with domain expertise.",
+      "effectAnalysis": {{
+        "longTerm": ["benefit 1", "benefit 2", "benefit 3", "benefit 4"],
+        "performanceGains": ["gain 1", "gain 2"],
+        "riskMitigation": ["mitigation 1", "mitigation 2"],
+        "shortTerm": ["benefit 1", "benefit 2", "benefit 3", "benefit 4"]
+      }},
+      "expectedImpact": "Quantifiable impact or performance improvement.",
+      "id": "3",
+      "priority": "High",
+      "title": "Third priority optimization strategy"
+    }}
+  ]
+}}
+
+===== ANALYSIS INSTRUCTIONS =====
+
+**Step 1: Synthesize All Input Data**
+- Analyze RUL estimate and uncertainty to assess urgency
+- Review maintenance priorities to identify critical failure modes
+- Examine future fault predictions to understand progression risks
+- Cross-reference KPIs, phase analysis, and AI verdict for root cause insights
+
+**Step 2: Generate Strategic AI Advice (3-5 items)**
+- **CRITICAL: Generate exactly 3-5 advice items** (minimum 3, maximum 5)
+- **CRITICAL: id field is sequential** ("1", "2", "3", "4", "5")
+- **CRITICAL JSON FIELD ORDER**: color → confidence → description → effectAnalysis → expectedImpact → id → priority → title
+- **effectAnalysis Structure**: MUST contain all 4 arrays: "longTerm" (4 items), "performanceGains" (2 items), "riskMitigation" (2 items), "shortTerm" (4 items)
+- **HARDCODED Color scheme**:
+  * 1st advice: "#B71C1C" (Critical priority)
+  * 2nd advice: "#F57F17" (High priority)
+  * 3rd advice: "#F57F17" (High priority)
+  * 4th advice (if any): "#0D47A1" (Medium priority)
+  * 5th advice (if any): "#2E7D32" (Low priority)
+
+**Confidence Scoring:**
+- 90-100: High confidence, strong data support, clear evidence chain
+- 80-89: Good confidence, supported by multiple indicators
+- 70-79: Moderate confidence, some uncertainty in data
+- 60-69: Lower confidence, limited data or conflicting signals
+
+**Priority Assignment:**
+- **Critical**: RUL <500 cycles, imminent safety risk, coil failure, SF6 leak
+- **High**: RUL <1500 cycles, significant degradation, contact wear >200µΩ
+- **High**: RUL <3000 cycles, preventive optimization, performance improvement
+- **Medium**: RUL >3000 cycles, long-term enhancements, technology upgrades
+- **Low**: RUL >5000 cycles, continuous improvement, best practices
+
+**Strategic Advice Themes to Consider (Domain-Rich, Engineering-Focused):**
+
+**IMPORTANT: Base your recommendations on the SPECIFIC maintenance actions and future faults provided in the input data.**
+
+1. **Contact Bounce Mitigation** (if contact bounce detected in 55-65ms region):
+   - "Optimize Contact Bounce Mitigation Strategy"
+   - Description: "Address the detected contact bounce (55-65ms region) through operating mechanism calibration and spring tension adjustment. Calibrate damping dashpot to reduce impact velocity and minimize bounce amplitude, preventing accelerated contact erosion."
+   - Short-term effects: "Immediate reduction in contact bounce amplitude by 60-70%", "Stabilized contact resistance during closing", "Enhanced closing operation smoothness", "Real-time bounce monitoring activation"
+   - Long-term effects: "Extended contact life by 25-30%", "Reduced risk of contact welding by 40%", "Lower maintenance frequency and costs", "Improved breaker reliability over 5+ years"
+   - Performance gains: "Improved contact resistance stability", "Enhanced operational reliability"
+   - Risk mitigation: "Prevent accelerated contact erosion", "Reduce risk of contact failure"
+
+2. **SF6 Gas Management** (if SF6 issues, insulation anomalies, or Phase 5 low confidence):
+   - "Enhanced SF6 Gas Management Protocol"
+   - Description: "Implement predictive SF6 pressure monitoring with automated alerts for gas quality degradation and leakage detection. Monitor moisture content, purity, and decomposition products to prevent insulation breakdown."
+   - Short-term effects: "Real-time SF6 leak detection", "Enhanced gas purity monitoring accuracy", "Immediate identification of moisture ingress", "Automated alert system activation"
+   - Long-term effects: "Prevented insulation failures saving $75,000-100,000", "Extended gas replacement intervals", "Reduced environmental SF6 emissions", "Improved arc quenching performance consistency"
+   - Performance gains: "Maintained optimal arc quenching capability", "Enhanced dielectric strength stability"
+   - Risk mitigation: "Prevent insulation breakdown and flashover events", "Reduce environmental compliance risks"
+
+3. **Trip Coil Redundancy** (if Trip Coil 2 failed or coil current = 0.0A):
+   - "Trip Coil Redundancy & Protection System Enhancement"
+   - Description: "With Trip Coil 2 failed (0.0A current), establish continuous monitoring of Trip Coil 1 operational status. Implement backup trip mechanisms and redundancy verification protocols to ensure critical fault interruption capability."
+   - Short-term effects: "Immediate trip coil status verification", "Backup protection activation", "Enhanced fault interruption assurance", "Real-time coil health monitoring"
+   - Long-term effects: "Prevented protection system failures by 95%", "Enhanced grid reliability and safety", "Reduced risk of catastrophic grid faults", "Extended protection system lifespan"
+   - Performance gains: "Guaranteed fault clearing capability", "Improved protection system reliability"
+   - Risk mitigation: "Eliminate single-point-of-failure in trip system", "Prevent grid instability due to breaker trip failure"
+
+4. **Contact Refurbishment Planning** (if DLRO >200µΩ or Main Contact Wear detected):
+   - "Strategic Contact Refurbishment & Wear Tracking Program"
+   - Description: "With DLRO at 300µΩ indicating severe contact wear, plan proactive contact refurbishment within 3 months. Implement contact wear tracking to optimize refurbishment timing and prevent contact welding or overheating failures."
+   - Short-term effects: "Immediate contact resistance stability improvement", "Thermal hotspot elimination", "Reduced I²R losses and heating", "Enhanced current carrying capacity"
+   - Long-term effects: "Extended circuit breaker service life by 2-3 years", "Reduced emergency outage costs by $50,000+", "Prevented contact welding incidents", "Optimized maintenance scheduling"
+   - Performance gains: "Restored nominal contact resistance levels", "Improved current distribution across contacts"
+   - Risk mitigation: "Prevent contact welding and breaker failure-to-open", "Eliminate overheating-induced insulation damage"
+
+5. **Operating Mechanism Calibration** (if excessive travel, wipe, speed, or timing deviations):
+   - "Operating Mechanism Calibration & Timing Optimization"
+   - Description: "Recalibrate operating mechanism to address excessive contact travel, wipe, or speed anomalies. Optimize spring tension, lubrication, and linkage alignment to reduce mechanical stress and improve timing accuracy."
+   - Short-term effects: "Normalized contact motion parameters", "Reduced mechanical vibration by 40%", "Improved timing consistency", "Enhanced mechanism smoothness"
+   - Long-term effects: "Extended mechanism component life by 30%", "Improved operational reliability", "Reduced wear on linkages and bearings", "Lower maintenance intervention frequency"
+   - Performance gains: "Optimized contact closing/opening velocities", "Enhanced mechanical timing precision"
+   - Risk mitigation: "Prevent mechanism seizure or binding", "Reduce risk of contact damage due to excessive impact forces"
+
+6. **Phase Anomaly Investigation** (if Phase 5 low confidence or electrical anomalies):
+   - "Phase-Wise Diagnostic Enhancement & Anomaly Resolution"
+   - Description: "Investigate Final Open State anomaly showing 15% confidence with abnormal resistance profile. Conduct insulation resistance tests (Megger, PI, DAR), SF6 analysis, and internal inspection to identify root cause of electrical anomaly."
+   - Short-term effects: "Root cause identification of phase anomaly", "Enhanced diagnostic confidence", "Immediate safety hazard assessment", "Isolation capability verification"
+   - Long-term effects: "Prevented insulation breakdown failures", "Optimized phase-wise health monitoring", "Improved diagnostic accuracy for future assessments", "Reduced uncertainty in condition assessments"
+   - Performance gains: "Confirmed dielectric strength integrity", "Enhanced phase-wise analysis reliability"
+   - Risk mitigation: "Prevent internal flashover or tracking failures", "Eliminate incomplete isolation hazards"
+
+**Step 3: Tailor Advice to Current Situation (Analyze Maintenance Actions & Future Faults)**
+- **CRITICAL**: Review the Priority 1, 2, 3+ maintenance actions in detail
+- **CRITICAL**: Review the high, medium, low risk future faults in detail
+- **CRITICAL**: Combine insights from both to create cohesive recommendations
+
+**Mapping Guidelines:**
+- If Priority 1 includes Trip Coil repair → Focus on trip coil redundancy and protection system
+- If Priority 1 includes contact refurbishment → Focus on contact wear tracking and DLRO monitoring
+- If Priority 2 includes mechanism overhaul → Focus on operating mechanism calibration and timing
+- If Priority 3 includes insulation/SF6 investigation → Focus on SF6 gas management and phase diagnostics
+- If future faults include "Main Contact Wear" (high probability) → Emphasize contact refurbishment urgency
+- If future faults include "Operating Mechanism Malfunction" → Emphasize mechanism calibration
+- If future faults include "Trip Coil Damage" → Emphasize coil monitoring and redundancy
+- If RUL is low (<500 cycles) → Add Critical priority advice on immediate monitoring
+- If DLRO >250µΩ → Add High priority advice on contact resistance mitigation
+- If Phase 5 confidence <20% → Add advice on phase-wise diagnostic enhancement
+
+**FINAL CHECKLIST BEFORE GENERATING OUTPUT:**
+1. ✓ Total AI advice items: 3-5 (minimum 3, maximum 5)
+2. ✓ Each advice item has all required fields: color, confidence, description, effectAnalysis, expectedImpact, id, priority, title
+3. ✓ **CRITICAL JSON FIELD ORDER**: color → confidence → description → effectAnalysis → expectedImpact → id → priority → title
+4. ✓ **effectAnalysis has all 4 required arrays**: longTerm (4 items), performanceGains (2 items), riskMitigation (2 items), shortTerm (4 items)
+5. ✓ **HARDCODED Colors**: 1st=#B71C1C, 2nd=#F57F17, 3rd=#F57F17, 4th=#0D47A1, 5th=#2E7D32
+6. ✓ Confidence values are realistic (60-100 range)
+7. ✓ Descriptions are domain-rich, engineering-focused, and specific (under 250 chars)
+8. ✓ Expected impacts are quantifiable benefits from circuit breaker domain (under 100 chars)
+9. ✓ Titles are domain-specific and clear (under 80 chars)
+10. ✓ All JSON properly formatted with double quotes, no smart quotes
+11. ✓ Advice is based on SPECIFIC maintenance actions and future faults from input data
+12. ✓ Recommendations reference actual KPI values (DLRO, coil current, timing, etc.)
+13. ✓ Each advice item provides unique value focused on circuit breaker engineering
+14. ✓ Short-term effects are immediate operational improvements (weeks to months)
+15. ✓ Long-term effects are strategic benefits (years, cost savings, reliability)
+16. ✓ Performance gains focus on operational improvements and capability enhancements
+17. ✓ Risk mitigation items identify specific hazards being prevented
+18. ✓ In any response dont mention like phase 1,2,3,4,5 etc..instead replace with their formal names like:
+     phase 1: Pre Contact Travel
+     phase 2: Arc Initiation
+     phase 3: Main Contact Conduction
+     phase 4: Main Contact Separation & Arc elongation
+     phase 5: Final Open State
+**Remember**: Your advice should demonstrate deep expertise in DCRM circuit breaker systems. Reference specific components, failure modes, and field maintenance practices. Avoid generic "AI" or "IoT" buzzwords - instead use domain-specific terms like "contact bounce mitigation", "SF6 purity monitoring", "trip coil redundancy", "damping dashpot calibration", "DLRO trending", etc.
+
+Generate value-rich, engineering-grounded insights that maintenance teams can immediately understand and implement.
+"""
+
+# =========================
+# MAIN FUNCTION
+# =========================
+def generate_ai_advice(rul_data, recommendations_data, kpis_data, cbhi_score, phase_analysis, ai_verdict):
+    """
+    Generate AI-driven strategic advice using Gemini AI.
+    
+    Args:
+        rul_data (dict): RUL analysis with rulEstimate and uncertainty
+        recommendations_data (dict): Combined dict with "maintenanceActions" and "futureFaultsPdf"
+        kpis_data (dict): KPI data with structure {"kpis": [...]}
+        cbhi_score (int): Circuit Breaker Health Index (0-100)
+        phase_analysis (dict): Phase-wise analysis JSON
+        ai_verdict (dict): AI fault detection verdict
+    
+    Returns:
+        dict: JSON with aiAdvice array
+    """
+    
+    # Extract maintenance and future faults from combined data
+    maintenance_data = recommendations_data.get("maintenanceActions", [])
+    future_faults_data = recommendations_data.get("futureFaultsPdf", [])
+    
+    # Format the prompt with actual data
+    prompt = AI_ADVICE_PROMPT.format(
+        rul_json=json.dumps(rul_data, indent=2, ensure_ascii=False),
+        maintenance_json=json.dumps(maintenance_data, indent=2, ensure_ascii=False),
+        future_faults_json=json.dumps(future_faults_data, indent=2, ensure_ascii=False),
+        kpis_json=json.dumps(kpis_data, indent=2, ensure_ascii=False),
+        cbhi_score=cbhi_score,
+        phase_analysis_json=json.dumps(phase_analysis, indent=2, ensure_ascii=False),
+        ai_verdict_json=json.dumps(ai_verdict, indent=2, ensure_ascii=False)
+    )
+    
+    # Configure generation
+    generation_config = {
+        "temperature": 0.3,  # Lower temperature for more focused, consistent output
+        "top_p": 0.95,
+        "top_k": 40,
+        "max_output_tokens": 4096,
+    }
+    
+    # Initialize model
+    model = genai.GenerativeModel(
+        model_name=MODEL_NAME,
+        generation_config=generation_config
+    )
+    
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            if attempt == 0:
+                print("🤖 Generating AI strategic advice...")
+            else:
+                print(f"🔄 Retry attempt {attempt}/{max_retries-1}...")
+            
+            # Add JSON validation instruction on retry
+            if attempt > 0:
+                prompt_with_retry = prompt + "\n\nIMPORTANT: Ensure all text in description, expectedImpact, and title fields has properly escaped quotes. Use single quotes within text or escape double quotes with backslash."
+            else:
+                prompt_with_retry = prompt
+            
+            # Generate response
+            response = model.generate_content(prompt_with_retry)
+            
+            # Extract JSON from response
+            response_text = response.text.strip()
+            
+            # Clean up markdown code fences if present
+            if response_text.startswith("```json"):
+                response_text = response_text[7:]
+            if response_text.startswith("```"):
+                response_text = response_text[3:]
+            if response_text.endswith("```"):
+                response_text = response_text[:-3]
+            
+            response_text = response_text.strip()
+            
+            # Additional cleanup: fix common JSON issues
+            # Replace smart quotes with regular quotes
+            response_text = response_text.replace('"', '"').replace('"', '"')
+            response_text = response_text.replace("'", "'").replace("'", "'")
+            
+            # Parse JSON
+            result = json.loads(response_text)
+            
+            print("✅ Successfully generated AI strategic advice")
+            return result
+            
+        except json.JSONDecodeError as e:
+            print(f"❌ JSON parsing error (attempt {attempt+1}/{max_retries}): {e}")
+            if attempt == max_retries - 1:
+                print(f"Raw response excerpt:\n{response_text[:1000]}...")
+                # Try to salvage what we can
+                return {
+                    "error": f"Failed to parse AI response after {max_retries} attempts",
+                    "raw_response": response_text[:2000],
+                    "aiAdvice": []
+                }
+            # Wait a bit before retry
+            import time
+            time.sleep(1)
+            
+        except Exception as e:
+            print(f"❌ Error generating AI advice: {e}")
+            return {
+                "error": str(e),
+                "aiAdvice": []
+            }
+    
+    return {
+        "error": "Max retries exceeded",
+        "aiAdvice": []
+    }

core/agents/diagnosis.py

@@ -0,0 +1,754 @@
+# Previous Name: analysis/agents/ai_agent.py
+import os
+import sys
+import time
+import json
+import pandas as pd
+import matplotlib.pyplot as plt
+from PIL import Image
+import google.generativeai as genai
+import numpy as np
+
+# Set UTF-8 encoding for console output (handles µ, Ω, etc.)
+if sys.stdout.encoding != 'utf-8':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+# =========================
+# CONFIGURATION
+# =========================
+API_KEY = os.getenv("GOOGLE_API_KEY")
+genai.configure(api_key=API_KEY)
+
+MODEL_NAME = "gemini-2.5-flash"
+
+BASELINE_OFFSET_UOHM = float(os.getenv("DCRM_BASELINE_UOHM", "0"))
+PLOT_PATH = "resistance_vs_time.png"
+
+# =========================
+# AGENT 1: PRIMARY CONTACT & COIL DEFECT DETECTOR (Classes 1-5, 11-12)
+# =========================
+AGENT1_SYSTEM_PROMPT = """
+Role: You are a High Voltage Circuit Breaker Contact & Coil Diagnostic AI specialized in Dynamic Contact Resistance Measurement (DCRM).
+You must analyze ONLY the Resistance-vs-Time waveform (uOhm) from T_0 to T_400 ms. Green line = Resistance.
+
+Physics Regions (nominal):
+- Region 1 (Open): Resistance > 10,000,000 uOhm (effectively open).
+- Region 2 (Arcing Make / Left Shoulder): ~3500 uOhm nominal shoulder before main contact engages.
+- Region 3 (Main Contact Floor): ~20–40 uOhm nominal, smooth, low noise.
+- Region 4 (Arcing Break / Right Shoulder): ~3500 uOhm nominal shoulder after main contact disengages.
+- Region 5 (Open): Return to infinite resistance.
+
+in any response dont address regions 1,2,3,4,5 directly as newcomers will not understand these terminologies. instead for them address through below mapping:
+
+- "Pre contact Travel": Region 1
+- "Arcing Contact Engagement & Arc Initiation": Region 2
+- "Main Contact Conduction": Region 3
+- "Main Contact Parting & Arc Elongation": Region 4
+- "Final Open Phase": Region 5
+
+Defect classes & strict signatures:
+1) Healthy:
+   - Region 3 mean ~20–50 uOhm, std low; transitions sharp (sigmoid-like) into and out of Region 3.
+   - Regions 2 & 4 stable, without severe spikes.
+2) Main Contact Wear:
+   - Region 3 is ELEVATED (>100 uOhm after baseline correction) and NOISY (std > 25 uOhm or visible grassy drift).
+3) Arcing Contact Wear:
+   - Region 3 healthy, but Region 2 and/or 4 exhibit severe upward spikes (>6000 uOhm) or heavy instability.
+4) Main Contact Misalignment:
+   - Region 3 may show telegraph noise (square-wave-like jumping).
+   - Transition 2→3 or 3→4 has a mid-slope step/shelf (non-smooth pause).
+5) Arcing Contact Misalignment:
+   - Timing asymmetry: Opening shoulder (Region 4) significantly wider/longer than Closing shoulder (Region 2).
+   - Rounded bounces on Opening shoulder.
+11) Close Coil Damage:
+    - Peak Close Coil Current (KPI) is very low (<2A) or zero during a detected closing operation.
+    - Normal close coil current: 4-7A for EHV breakers.
+12) Trip Coil Damage:
+    - BOTH Peak Trip Coil 1 AND Peak Trip Coil 2 currents are very low (<2A) or zero.
+    - CRITICAL: At least ONE trip coil must work (>=2A). If Trip Coil 1 OR Trip Coil 2 is working (>=2A), then NO FAULT.
+    - Only report fault if BOTH coils fail simultaneously.
+    - Normal trip coil current: 4-7A per coil for EHV breakers.
+
+Mandatory analysis steps:
+- Compute features from the provided time-series:
+  * Region 3 mean, median, std, min, max (approx. nominal window 120–320 ms).
+  * Presence and magnitude of spikes in Regions 2 & 4 (e.g., >6000 uOhm).
+  * Transition smoothness: detect shelves/steps around 100–120 ms (closing) and 320–340 ms (opening).
+- If region boundaries are unclear, state that and lower confidence.
+- DO NOT declare a defect unless thresholds are clearly met. Prefer "Healthy" with rationale if ambiguous.
+- Consider baseline offset explicitly.
+- Severity depends on confidence: above 85% then High, 50-85% then Medium, else Low.
+- Confidence depends on how much the signature deviates from healthy and how many feature of a particular defect it satisfies.
+
+Verification Notes (apply before finalizing):
+- For Main Contact Wear: Look for consistent, uniform low-high medium to high spikes across entire Region 3 plateau.
+- For Main Contact Misalignment: Look for square-shaped (telegraphic) spikes in Region 3, AND a two-or-more-step transition from Region 2 to 3.
+- For Arcing Contact Wear: Look for very high up/down spikes in Regions 2 and 4. Spikes are 95% similar on both sides.
+- For Arcing Contact Misalignment: Look for square-shaped (telegraphic) or sinusoidal high-frequency noise spikes in Regions 2 and 4. Curve MUST be asymmetric (Region 4 wider/longer than Region 2). Region 3 duration might be reduced.
+
+Output: Return ONLY valid JSON (no markdown code fences). Structure:
+{
+  "Fault_Detection": [
+    {
+      "defect_name": "Exact Class Name or 'Healthy'",
+      "Confidence": "XX.XX %",
+      "Severity": "Low/Medium/High",
+      "description": "1–2 short sentences citing quantified features and KPIs.",
+    }
+  ],
+  "primary_defect_class": "1-5 or 11-12 or Healthy"
+}
+List ONLY the most likely primary defect. If healthy, return only Healthy.
+"""
+
+# =========================
+# AGENT 2: SECONDARY MECHANICAL/OPERATIONAL DEFECT DETECTOR (Classes 6-10)
+# =========================
+AGENT2_SYSTEM_PROMPT = """
+Role: You are a Circuit Breaker Mechanical & Operational Diagnostic AI. You analyze DCRM waveforms and KPIs for secondary mechanical/operational issues with EXTREME STRICTNESS.
+
+You will receive:
+1. DCRM waveform data (Resistance vs Time, T_0 to T_400 ms)
+2. KPI values with industry-standard nominal ranges
+3. PRIMARY DEFECT from Agent 1 (Classes 1-5, 11-12)
+
+Your task: Detect ONLY Classes 6-10 defects with OVERWHELMING EVIDENCE. Confidence must be >75%.
+
+=== DEFECT CLASSES WITH PHYSICS-BASED SIGNATURES ===
+
+6) Operating Mechanism Malfunction (Slow/Fast Operation)
+   Physical Basis:
+   - Operating mechanism (spring, hydraulic, pneumatic) drives contacts. Weak springs, hydraulic leaks, sticky linkages affect speed.
+   
+   Industry Standard KPI Ranges (Ministry of Power / POWERGRID norms for EHV breakers):
+   - Closing Time: 80-100 ms (nominal)
+   - Opening Time: 30-40 ms (nominal)
+   - Contact Speed: 4.5-6.5 m/s (nominal)
+   
+   DCRM Curve Manifestation:
+   - **Horizontal Shift**: ENTIRE curve shifts left (fast) or right (slow) compared to nominal timeline.
+   - **Slope Changes**: Resistance transitions (Region 2->3, Region 3->4) have altered steepness across ENTIRE operation.
+   - **Delayed Closure/Opening**: Time from first contact movement to full closure/opening is >20% off nominal.
+   
+   Detection Criteria (STRICT):
+   - Closing Time >120 ms OR <64 ms (>20% deviation from 80-100 ms range)
+   - Opening Time >48 ms OR <24 ms (>20% deviation from 30-40 ms range)
+   - Contact Speed <3.6 m/s OR >7.8 m/s (>20% deviation from 4.5-6.5 m/s)
+   - AND waveform shows consistent timing shift across ALL phases
+   
+   Confidence Requirements:
+   - 90-95%: If 2+ KPIs exceed threshold by >25%
+   - 80-89%: If 1 KPI exceeds threshold by >20%
+   - <80%: Insufficient evidence, DO NOT report
+   also most notable point in it see region 1 and 5, if there are spikes in this region lines are not straight at high resistance then 100% its operating mechanism malfunction
+
+7) Damping System Fault (Excessive Bouncing/Oscillation)
+   Physical Basis:
+   - Dampers (dashpots, hydraulic dampers) absorb kinetic energy, prevent contact rebound. Failure causes persistent oscillation.
+   
+   DCRM Curve Manifestation:
+   - **Excessive Bounces at Main Contact Closure**: Multiple rapid spikes (>5 distinct bounces) back towards arcing resistance AFTER initial closure.
+   - **Prolonged Oscillation in Region 3**: Main contact plateau shows persistent fluctuations (decaying sinusoidal pattern, NOT random noise).
+   - **Secondary Bounces at Opening**: Clean separation disrupted by re-closure spikes.
+   
+   Detection Criteria (VERY STRICT):
+   - >5 distinct bounces with amplitude >100 µΩ in Region 3 (120-320 ms window)
+   - Bounce pattern shows decaying oscillation (each bounce smaller than previous)
+   - NOT simple noise or wear (std in Region 3 must show structured oscillation, not random)
+   
+   Confidence Requirements:
+   - 85-95%: Clear decaying oscillation pattern with >7 bounces
+   - 75-84%: 5-6 distinct bounces with structured pattern
+   - <75%: Could be noise/wear, DO NOT report
+
+8) Pressure System Leakage (SF6 Gas Chamber)
+   Physical Basis:
+   - SF6 gas provides insulation and arc quenching. Leak reduces pressure, weakens dielectric strength, prolongs arc.
+   
+   Industry Standard:
+   - SF6 Pressure: 5.5-6.5 bar (at 20°C) for typical EHV breakers
+   
+   DCRM Curve Manifestation:
+   - **Prolonged Arc-Quenching**: Region 4->5 transition (arcing break to open) takes >20 ms (nominal: 10-15 ms).
+   - **Less Sharp Opening**: Opening slope less steep due to extended arc duration.
+   - **Higher Peak Arcing Resistance**: Arc resistance >5000 µΩ sustained for longer duration.
+   
+   Detection Criteria (EXTREMELY STRICT):
+   - Requires external SF6 Pressure KPI <5.0 bar
+   - OR (if no pressure KPI): Arc-quenching duration >25 ms AND primary defect is Arcing Contact Wear with confidence >85%
+   - WITHOUT pressure KPI, confidence CANNOT exceed 70%
+   
+   Confidence Requirements:
+   - 85-95%: SF6 Pressure KPI <4.5 bar AND prolonged arc
+   - 70-84%: No pressure KPI but severe arc prolongation (>30 ms) AND severe Arcing Wear
+   - <70%: Insufficient evidence, DO NOT report
+
+9) Linkage/Connecting Rod Obstruction/Damage
+   Physical Basis:
+   - Operating rod and linkages transmit force from mechanism to contacts. Obstruction, bending, friction, or looseness impede smooth movement.
+   
+   DCRM Curve Manifestation:
+   - **"Stutter" or "Hesitation"**: Momentary pauses, jerks, or sudden slope changes within smooth transitions (Region 2->3, Region 3->4).
+   - **Square Plateaus Within Slopes**: Small flat sections (20-50 ms duration) interrupting the sigmoid curve, indicating momentary stuck movement.
+   - **Sudden Speed Changes**: Abrupt changes in transition rate (detected as derivative discontinuities).
+   - **High-Frequency Mechanical Noise**: Increased jitter/vibration during transitions (NOT smooth noise).
+   
+   Detection Criteria (VERY STRICT):
+   - >3 distinct "stutters" (flat plateaus >10 ms within transition slopes)
+   - AND increased operating time (>10% longer than nominal)
+   - Stutter signature must be VERY distinct (resistance plateaus for >10 ms, then sudden drops/rises)
+   
+   Confidence Requirements:
+   - 85-95%: >5 distinct stutters with clear mechanical impedance pattern
+   - 75-84%: 3-4 stutters AND operating time >15% off nominal
+   - <75%: Could be normal transition, DO NOT report
+
+10) Fixed Contact Damage/Deformation
+    Physical Basis:
+    - Fixed contacts can be damaged (scoring, pitting, bending, high connection resistance). Distinct from moving contact wear.
+    
+    Industry Standard:
+    - DLRO Value (Dynamic Low Resistance Ohmmeter): <50 µΩ for healthy EHV breaker
+    - Acceptable Range: 50-80 µΩ (moderate concern)
+    - Critical: >80 µΩ (indicates fixed contact or connection issues)
+    
+    DCRM Curve Manifestation:
+    - **Elevated Baseline Resistance**: Main Contact Plateau (Region 3) consistently higher (>80 µΩ) even when curve shape is smooth.
+    - **Low Variability**: Region 3 std <15 µΩ (smooth plateau, NOT noisy like Main Contact Wear).
+    - **Asymmetric Wear Pattern**: Closing and opening transitions show different resistance levels (fixed contact deformation).
+    - **Localized Spikes in Plateau**: Specific recurring spikes at same time points (damaged spot on fixed contact).
+    
+    Detection Criteria (STRICT):
+    - DLRO Value >80 µΩ (from KPI)
+    - AND Region 3 mean >80 µΩ with std <15 µΩ (smooth but elevated)
+    - AND Primary defect is NOT Main Contact Wear (avoid duplication)
+    - IF Primary is Main Contact Wear: Can list as SECONDARY but with confidence <70%
+    
+    Confidence Requirements:
+    - 80-90%: DLRO >100 µΩ AND smooth curve (std <10 µΩ)
+    - 70-79%: DLRO 80-100 µΩ AND smooth curve
+    - 50-69%: Listed as secondary to Main Contact Wear
+    - <50%: Primary defect already explains, DO NOT report
+
+=== CRITICAL RULES ===
+1. BE EXTREMELY STRICT. Only report if confidence >75% AND evidence is OVERWHELMING.
+2. If Primary defect (from Agent 1) already explains the waveform, DO NOT add redundant secondary defects.
+3. Check ALL thresholds and criteria. If ANY criterion is not met, DO NOT report that defect.
+4. For Class 10 (Fixed Contact): Only if DLRO >80 µΩ AND std <15 µΩ. If Main Contact Wear is primary, list as secondary with reduced confidence.
+5. If no secondary defect meets strict criteria, return: "No Secondary Defect Detected"
+6. Confidence for Classes 6-10 should be 75-90% range unless extreme deviations (>95% rare).
+7. Compare waveform timing against nominal windows: Region 2 (85-105 ms), Region 3 (120-300 ms), Region 4 (315-335 ms).
+
+Output: Return ONLY valid JSON (no markdown):
+{
+  "Secondary_Fault_Detection": [
+    {
+      "defect_name": "Exact Class Name or 'No Secondary Defect Detected'",
+      "Confidence": "XX.XX %",
+      "Severity": "Low/Medium/High",
+      "description": "1–2 short sentences citing quantified features and KPIs.",
+    }
+  ]
+}
+List at most 1-2 secondary defects. If uncertain or evidence weak, return "No Secondary Defect Detected".
+"""
+
+def parse_kpis_from_json(kpis_json):
+    """
+    Convert KPI JSON format to dictionary for internal use.
+    
+    Input format:
+    {
+        "kpis": [
+            {"name": "Closing Time", "unit": "ms", "value": 87.8},
+            ...
+        ]
+    }
+    
+    Output format:
+    {
+        "Closing Time (ms)": 87.8,
+        ...
+    }
+    """
+    if kpis_json is None:
+        return {}
+    
+    # If already in dict format, return as-is
+    if isinstance(kpis_json, dict) and "kpis" not in kpis_json:
+        return kpis_json
+    
+    # Parse from JSON format
+    kpi_dict = {}
+    kpis_list = kpis_json.get("kpis", [])
+    
+    for kpi in kpis_list:
+        name = kpi.get("name", "")
+        unit = kpi.get("unit", "")
+        value = kpi.get("value", None)
+        
+        # Create key in format "Name (unit)"
+        key = f"{name} ({unit})" if unit else name
+        kpi_dict[key] = value
+    
+    return kpi_dict
+
+
+def standardize_input(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Returns a DataFrame with one row and columns T_0...T_400 containing Resistance values (uOhm).
+    """
+    if 'Resistance' not in df.columns:
+        potential_resistance_cols = [c for c in df.columns if not c.startswith('T_')]
+        if not potential_resistance_cols:
+             raise KeyError("CSV must contain a 'Resistance' column.")
+        
+        if len(potential_resistance_cols) > 1:
+            print(f"Warning: Multiple non-T_ columns found. Using first one as 'Resistance'.")
+        
+        df = df.rename(columns={potential_resistance_cols[0]: 'Resistance'})
+
+    df = df[['Resistance']]
+
+    if df.shape[0] >= 401 and df.shape[1] == 1:
+        values = df.iloc[:401, 0].values.reshape(1, -1)
+        cols = [f"T_{i}" for i in range(401)]
+        return pd.DataFrame(values, columns=cols)
+
+    elif df.shape[1] >= 401:
+        df = df.iloc[:, :401]
+        df.columns = [f"T_{i}" for i in range(401)]
+        return df
+
+    else:
+        raise ValueError(f"Input shape {df.shape} invalid. Expected 401 Resistance points.")
+
+def plot_resistance(row_values, save_path=PLOT_PATH):
+    """Saves a line plot Resistance (uOhm) vs Time (ms)."""
+    t = list(range(401))
+    plt.figure(figsize=(10, 4.2), dpi=150)
+    plt.plot(t, row_values, color="green", linewidth=1.6, label="Resistance (uΩ)")
+    plt.title("Dynamic Resistance vs Time (DCRM)")
+    plt.xlabel("Time (ms)")
+    plt.ylabel("Resistance (μΩ)")
+    plt.grid(True, alpha=0.3)
+    plt.xlim(0, 400)
+    plt.legend(loc="upper right")
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+def validate_trip_coil_logic(kpis):
+    """
+    Validates Trip Coil logic: At least ONE trip coil must work.
+    Returns (is_fault, description)
+    """
+    trip_coil_1 = kpis.get("Peak Trip Coil 1 Current (A)", 0)
+    trip_coil_2 = kpis.get("Peak Trip Coil 2 Current (A)", 0)
+    
+    # At least ONE must be >= 2A (working)
+    if trip_coil_1 >= 2.0 or trip_coil_2 >= 2.0:
+        return False, f"Trip coils functional (Coil 1: {trip_coil_1}A, Coil 2: {trip_coil_2}A)"
+    
+    # BOTH are below 2A = FAULT
+    return True, f"BOTH trip coils failed (Coil 1: {trip_coil_1}A, Coil 2: {trip_coil_2}A - both below 2A threshold)"
+
+def build_agent1_prompt(row_values, baseline_offset_uohm, kpis):
+    """Build prompt for Agent 1 (Primary Contact & Coil Defects)."""
+    data_str = ",".join(map(str, row_values))
+    
+    # Parse KPIs if in JSON format
+    kpis_dict = parse_kpis_from_json(kpis)
+    
+    kpi_str = "\n".join([f"- {name}: {value}" for name, value in kpis_dict.items()])
+    
+    # Validate Trip Coil logic
+    trip_fault, trip_msg = validate_trip_coil_logic(kpis_dict)
+
+    prompt = f"""
+Analyze this DCRM waveform for PRIMARY CONTACT & COIL DEFECTS (Classes 1-5, 11-12).
+
+DCRM Data:
+- Array length: {len(row_values)} (T_0 to T_400 ms)
+- Baseline offset: {baseline_offset_uohm} uOhm
+- Attached image: Resistance vs Time plot (green line)
+
+KPIs:
+{kpi_str}
+
+TRIP COIL PRE-VALIDATION:
+{trip_msg}
+{"⚠️ REPORT TRIP COIL DAMAGE (Class 12)" if trip_fault else "✓ Trip coils are functional - DO NOT report Trip Coil Damage"}
+
+Tasks:
+1) Compute Region 3 features (mean, std, spikes).
+2) Analyze Regions 2 & 4 for arcing issues.
+3) Check Close Coil Current (normal: 4-7A, fault if <2A).
+4) For Trip Coils: {"Report Class 12 (Trip Coil Damage)" if trip_fault else "DO NOT report Class 12 - at least one coil is working"}.
+5) Classify as one of: Healthy, Main Contact Wear, Arcing Contact Wear, Main Contact Misalignment, Arcing Contact Misalignment, Close Coil Damage, {"Trip Coil Damage" if trip_fault else "(NOT Trip Coil Damage)"}.
+6) Return ONLY the PRIMARY defect with highest confidence.
+
+Data array (uOhm):
+[{data_str}]
+"""
+    return prompt
+
+def build_agent2_prompt(row_values, baseline_offset_uohm, kpis, agent1_result):
+    """Build prompt for Agent 2 (Secondary Mechanical Defects)."""
+    data_str = ",".join(map(str, row_values))
+    
+    # Parse KPIs if in JSON format
+    kpis_dict = parse_kpis_from_json(kpis)
+    
+    kpi_str = "\n".join([f"- {name}: {value}" for name, value in kpis_dict.items()])
+    
+    agent1_summary = json.dumps(agent1_result.get("Fault_Detection", []), indent=2)
+    primary_class = agent1_result.get("primary_defect_class", "Unknown")
+
+    prompt = f"""
+Analyze this DCRM waveform for SECONDARY MECHANICAL/OPERATIONAL DEFECTS (Classes 6-10).
+
+PRIMARY DEFECT (from Agent 1):
+Class: {primary_class}
+Details:
+{agent1_summary}
+
+DCRM Data:
+- Array length: {len(row_values)} (T_0 to T_400 ms)
+- Baseline offset: {baseline_offset_uohm} uOhm
+- Attached image: Resistance vs Time plot (green line)
+
+KPIs with Industry Standards:
+{kpi_str}
+
+Industry Standard Nominal Ranges (Ministry of Power / POWERGRID norms for EHV breakers):
+- Closing Time: 80-100 ms (acceptable range)
+- Opening Time: 30-40 ms (acceptable range)
+- Contact Speed: 4.5-6.5 m/s (acceptable range)
+- DLRO Value: <50 µΩ (healthy), 50-80 µΩ (moderate), >80 µΩ (critical)
+- Close Coil Current: 4-7A (nominal)
+- Trip Coil Current: 4-7A per coil (nominal)
+- SF6 Pressure: 5.5-6.5 bar at 20°C (if applicable)
+
+Tasks:
+1) BE EXTREMELY STRICT. Only report if confidence >75% AND evidence is OVERWHELMING.
+2) For each Class 6-10, check ALL detection criteria and thresholds listed in system instructions.
+3) Calculate % deviation from nominal ranges for timing KPIs.
+4) Analyze waveform for physics-based signatures:
+   - Class 6: Horizontal shift of ENTIRE curve, altered transition slopes
+   - Class 7: >5 distinct decaying bounces in Region 3
+   - Class 8: Prolonged arc-quenching (Region 4->5 >25 ms)
+   - Class 9: >3 distinct stutters (flat plateaus within slopes)
+   - Class 10: DLRO >80 µΩ AND Region 3 std <15 µΩ
+5) Do NOT duplicate primary defect explanations.
+6) If ALL criteria are not met for a defect, DO NOT report it.
+7) If uncertain or evidence weak, return "No Secondary Defect Detected".
+
+Expected Region Timing (nominal):
+- Region 1 (Open before): 0-85 ms
+- Region 2 (Arcing Make): 85-105 ms
+- Region 3 (Main Contact): 120-300 ms
+- Region 4 (Arcing Break): 315-335 ms
+- Region 5 (Open after): 335-400 ms
+
+Data array (uOhm):
+[{data_str}]
+"""
+    return prompt
+
+def call_agent1(row_values, kpis_data):
+    """Agent 1: Primary Contact & Coil Defect Detection."""
+    plot_resistance(row_values, PLOT_PATH)
+    file = genai.upload_file(path=PLOT_PATH)
+    
+    prompt = build_agent1_prompt(row_values, BASELINE_OFFSET_UOHM, kpis_data)
+    
+    model = genai.GenerativeModel(MODEL_NAME, system_instruction=AGENT1_SYSTEM_PROMPT)
+    response = model.generate_content([prompt, file])
+    
+    text = (response.text or "").strip()
+    text = text.replace("```json", "").replace("```", "").strip()
+    
+    try:
+        obj = json.loads(text)
+        return obj
+    except Exception as e:
+        return {"Error": f"Agent 1 failed. {e}", "raw_response": text}
+
+def call_agent2(row_values, kpis_data, agent1_result):
+    """Agent 2: Secondary Mechanical Defect Detection (STRICT)."""
+    prompt = build_agent2_prompt(row_values, BASELINE_OFFSET_UOHM, kpis_data, agent1_result)
+    
+    # Reuse same image with error handling
+    try:
+        file = genai.upload_file(path=PLOT_PATH)
+    except Exception as upload_error:
+        print(f"⚠️ Agent 2: File upload failed: {upload_error}. Skipping Agent 2.")
+        return {"Error": f"File upload failed: {upload_error}", "agent2_skipped": True}
+    
+    try:
+        model = genai.GenerativeModel(MODEL_NAME, system_instruction=AGENT2_SYSTEM_PROMPT)
+        response = model.generate_content([prompt, file])
+        
+        # Check if response has valid content
+        if not response.text or response.text.strip() == "":
+            print(f"⚠️ Agent 2: Empty response. Finish reason: {response.candidates[0].finish_reason if response.candidates else 'Unknown'}")
+            return {"Error": "Agent 2 returned empty response", "finish_reason": response.candidates[0].finish_reason if response.candidates else None}
+        
+        text = response.text.strip()
+        text = text.replace("```json", "").replace("```", "").strip()
+        
+        try:
+            obj = json.loads(text)
+            return obj
+        except Exception as e:
+            return {"Error": f"Agent 2 JSON parse failed. {e}", "raw_response": text}
+            
+    except Exception as e:
+        print(f"⚠️ Agent 2: Generation failed: {e}")
+        return {"Error": f"Agent 2 generation failed: {e}", "agent2_failed": True}
+
+def merge_results(agent1_result, agent2_result):
+    """Merge Agent 1 and Agent 2 results into final comprehensive report."""
+    final_report = {
+        "Fault_Detection": [],
+        "overall_health_assessment": {
+            "Contacts (moving & arcing)": "Normal",
+            "SF6 Gas Chamber": "Normal",
+            "Operating Mechanism": "Normal",
+            "Coil": "Normal"
+        }
+    }
+    
+    # Add Agent 1 primary defects
+    if "Fault_Detection" in agent1_result:
+        final_report["Fault_Detection"].extend(agent1_result["Fault_Detection"])
+    
+    # Add Agent 2 secondary defects (only if Agent 2 succeeded and not "No Secondary Defect Detected")
+    if "Error" not in agent2_result and "Secondary_Fault_Detection" in agent2_result:
+        for defect in agent2_result["Secondary_Fault_Detection"]:
+            if defect.get("defect_name", "").lower() != "no secondary defect detected":
+                final_report["Fault_Detection"].append(defect)
+    elif "Error" in agent2_result:
+        print(f"⚠️ Agent 2 failed, using only Agent 1 results: {agent2_result.get('Error')}")
+    
+    # Assess overall health based on detected defects
+    for defect in final_report["Fault_Detection"]:
+        name = defect.get("defect_name", "").lower()
+        severity = defect.get("Severity", "").lower()
+        confidence = float(defect.get("Confidence", "0").replace("%", "").strip())
+        
+        # Determine risk level
+        if confidence >= 85 and severity == "high":
+            risk = "High Risk"
+        elif confidence >= 50:
+            risk = "Moderate Risk"
+        else:
+            risk = "Normal"
+        
+        # Map to health categories
+        if any(x in name for x in ["main contact", "arcing contact", "contact wear", "contact misalignment"]):
+            if final_report["overall_health_assessment"]["Contacts (moving & arcing)"] != "High Risk":
+                final_report["overall_health_assessment"]["Contacts (moving & arcing)"] = risk
+        
+        if "sf6" in name or "pressure" in name:
+            if final_report["overall_health_assessment"]["SF6 Gas Chamber"] != "High Risk":
+                final_report["overall_health_assessment"]["SF6 Gas Chamber"] = risk
+        
+        if any(x in name for x in ["operating mechanism", "damping", "linkage", "rod"]):
+            if final_report["overall_health_assessment"]["Operating Mechanism"] != "High Risk":
+                final_report["overall_health_assessment"]["Operating Mechanism"] = risk
+        
+        if "coil" in name:
+            if final_report["overall_health_assessment"]["Coil"] != "High Risk":
+                final_report["overall_health_assessment"]["Coil"] = risk
+    
+    return final_report
+
+# def main():
+#     df = pd.read_csv("df3_final.csv")
+#     df = standardize_input(df)
+
+#     # Analyze all rows if small DF; otherwise sample
+#     indices = df.index if len(df) <= 3 else df.sample(3, random_state=42).index
+
+#     time_cols = [c for c in df.columns if c.startswith('T_')]
+#     for idx in indices:
+#         row_values_raw = df.loc[idx, time_cols].values.tolist()
+
+#         # Sample KPIs in new JSON format (based on industry standards and Ministry of Power / POWERGRID norms)
+#         sample_kpis = {
+#             "kpis": [
+#                 {
+#                     "name": "Closing Time",
+#                     "unit": "ms",
+#                     "value": 103.5
+#                 },
+#                 {
+#                     "name": "Opening Time",
+#                     "unit": "ms",
+#                     "value": 37.0
+#                 },
+#                 {
+#                     "name": "DLRO Value",
+#                     "unit": "µΩ",
+#                     "value": 299.93
+#                 },
+#                 {
+#                     "name": "Peak Resistance",
+#                     "unit": "µΩ",
+#                     "value": 408.0
+#                 },
+#                 {
+#                     "name": "Contact Travel Distance",
+#                     "unit": "mm",
+#                     "value": 550.0
+#                 },
+#                 {
+#                     "name": "Main Wipe",
+#                     "unit": "mm",
+#                     "value": 46.0
+#                 },
+#                 {
+#                     "name": "Arc Wipe",
+#                     "unit": "mm",
+#                     "value": 63.0
+#                 },
+#                 {
+#                     "name": "Contact Speed",
+#                     "unit": "m/s",
+#                     "value": 5.2
+#                 },
+#                 {
+#                     "name": "Peak Close Coil Current",
+#                     "unit": "A",
+#                     "value": 5.5
+#                 },
+#                 {
+#                     "name": "Peak Trip Coil 1 Current",
+#                     "unit": "A",
+#                     "value": 5.5
+#                 },
+#                 {
+#                     "name": "Peak Trip Coil 2 Current",
+#                     "unit": "A",
+#                     "value": 0.0
+#                 },
+#                 {
+#                     "name": "Ambient Temperature",
+#                     "unit": "°C",
+#                     "value": 28.4
+#                 }
+#             ]
+#         }
+
+#         # STEP 1: Call Agent 1 (Primary Defects)
+#         agent1_result = call_agent1(row_values_raw, sample_kpis)
+        
+#         # STEP 2: Call Agent 2 (Secondary Defects) - runs in parallel after Agent 1
+#         agent2_result = call_agent2(row_values_raw, sample_kpis, agent1_result)
+        
+#         # STEP 3: Merge Results and Print ONLY Final JSON
+#         final_report = merge_results(agent1_result, agent2_result)
+        
+#         # Print with proper Unicode handling (ensure_ascii=False prevents \u00b5 escape sequences)
+#         print(json.dumps(final_report, indent=2, ensure_ascii=False))
+#         print()  # Empty line separator between rows
+
+
+
+
+
+def detect_fault(df,sample_kpis):
+    df = standardize_input(df)
+
+    # Analyze all rows if small DF; otherwise sample
+    indices = df.index if len(df) <= 3 else df.sample(3, random_state=42).index
+
+    time_cols = [c for c in df.columns if c.startswith('T_')]
+    for idx in indices:
+        row_values_raw = df.loc[idx, time_cols].values.tolist()
+
+        # STEP 1: Call Agent 1 (Primary Defects)
+        agent1_result = call_agent1(row_values_raw, sample_kpis)
+        
+        # STEP 2: Call Agent 2 (Secondary Defects) - runs in parallel after Agent 1
+        agent2_result = call_agent2(row_values_raw, sample_kpis, agent1_result)
+        
+        # STEP 3: Merge Results and Print ONLY Final JSON
+        final_report = merge_results(agent1_result, agent2_result)
+        
+        return final_report
+
+
+
+if __name__ == "__main__":
+    df = pd.read_csv("df3_final.csv")
+    # Sample KPIs in new JSON format (based on industry standards and Ministry of Power / POWERGRID norms)
+    sample_kpis = {
+            "kpis": [
+                {
+                    "name": "Closing Time",
+                    "unit": "ms",
+                    "value": 103.5
+                },
+                {
+                    "name": "Opening Time",
+                    "unit": "ms",
+                    "value": 37.0
+                },
+                {
+                    "name": "DLRO Value",
+                    "unit": "µΩ",
+                    "value": 299.93
+                },
+                {
+                    "name": "Peak Resistance",
+                    "unit": "µΩ",
+                    "value": 408.0
+                },
+                {
+                    "name": "Contact Travel Distance",
+                    "unit": "mm",
+                    "value": 550.0
+                },
+                {
+                    "name": "Main Wipe",
+                    "unit": "mm",
+                    "value": 46.0
+                },
+                {
+                    "name": "Arc Wipe",
+                    "unit": "mm",
+                    "value": 63.0
+                },
+                {
+                    "name": "Contact Speed",
+                    "unit": "m/s",
+                    "value": 5.2
+                },
+                {
+                    "name": "Peak Close Coil Current",
+                    "unit": "A",
+                    "value": 5.5
+                },
+                {
+                    "name": "Peak Trip Coil 1 Current",
+                    "unit": "A",
+                    "value": 5.5
+                },
+                {
+                    "name": "Peak Trip Coil 2 Current",
+                    "unit": "A",
+                    "value": 0.0
+                },
+                {
+                    "name": "Ambient Temperature",
+                    "unit": "°C",
+                    "value": 28.4
+                }
+            ]
+        }
+
+    result = detect_fault(df,sample_kpis)
+    print(json.dumps(result, indent=2, ensure_ascii=False))

core/agents/plotting.py

@@ -0,0 +1,271 @@
+# Previous Name: analysis/agents/dcrm_analysis.py
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import base64
+import json
+from langchain_core.messages import HumanMessage
+import streamlit as st
+
+def get_dcrm_prompt(data_str):
+    return f"""
+    I have extracted data from a DCRM (Dynamic Contact Resistance Measurement) graph.
+    Data (Sampled): {data_str}
+    
+    The columns are:
+    - 'time': Time in milliseconds.
+    - 'curr': Current signal amplitude (Blue curve) - represents the test current flowing through the contacts.
+    - 'res': Dynamic Resistance amplitude (Green curve) - represents the contact resistance in micro-ohms (µΩ).
+    - 'travel': Travel signal amplitude (Red curve) - represents the mechanical position/displacement of the moving contact.
+
+    IMPORTANT: Higher values mean the signal is HIGHER on the graph.
+    
+    I have also provided the image of the graph. Use the visual information from the image to cross-reference with the data.
+
+    === HEALTHY DCRM SIGNATURE REFERENCE ===
+    
+    **Resistance (Green) - Healthy Characteristics:**
+    - Pre-contact: Infinite/Very High (off-scale or flat at top)
+    - Arcing engagement: Drops sharply with moderate spikes (arcing activity), typically 100-500 µΩ
+    - Main conduction: LOW and STABLE (30-80 µΩ for healthy contacts), minimal oscillation (<10 µΩ variance)
+    - Parting: Sharp rise with spikes (arcing during separation)
+    - Final open: Returns to infinite/very high (off-scale)
+    
+    **Current (Blue) - Healthy Characteristics:**
+    - Pre-contact: Near zero baseline
+    - Arcing engagement: Begins rising as circuit closes
+    - Main conduction: Stable at test current level (plateau)
+    - Parting: Maintained until final separation
+    - Final open: Drops to zero
+    
+    **Travel (Red) - Healthy Characteristics:**
+    - Pre-contact: Increasing linearly (contacts approaching)
+    - Arcing engagement: Continues increasing
+    - Main conduction: Reaches MAXIMUM and plateaus (fully closed position)
+    - Parting: Decreases linearly (contacts separating)
+    - Final open: Stabilizes at minimum (fully open position)
+
+    === TASK: SEGMENT INTO 5 KINEMATIC ZONES ===
+    
+    Use ALL THREE curves together for accurate boundary detection. Each zone represents a distinct physical state of the circuit breaker.
+    
+    **Zone 1: Pre-Contact Travel (Initial Closing Motion)**
+    *   **Physical Meaning**: The moving contact is traveling toward the stationary contact but has NOT yet made electrical contact. This is pure mechanical motion with no current flow.
+    *   **Start**: time = 0 ms
+    *   **End Boundary**: Detect when CURRENT (blue) FIRST starts rising significantly from baseline.
+        *   Cross-reference: Resistance (green) should still be very high/infinite
+        *   Cross-reference: Travel (red) should be steadily increasing
+        *   **Typical Duration**: 80-120 ms
+        *   **Detection Logic**: Find the point where 'curr' rises above baseline noise (e.g., >5% of max current)
+    
+    **Zone 2: Arcing Contact Engagement (Initial Electrical Contact)**
+    *   **Physical Meaning**: The arcing contacts (W-Cu tips) make first contact and establish an electrical path. Current begins flowing through a small contact area, causing arcing and resistance fluctuations. This is the "make" transition.
+    *   **Start**: End of Zone 1
+    *   **End Boundary**: Detect when resistance SETTLES after initial spike activity.
+        *   Primary indicator: Resistance (green) drops from high values, exhibits spikes, then STABILIZES to low plateau
+        *   Cross-reference: Current (blue) should be rising/stabilizing
+        *   Cross-reference: Travel (red) continues increasing toward maximum
+        *   **Typical Duration**: 20-40 ms (Zone 2 typically ends around 110-150 ms total time)
+        *   **Detection Logic**: Find where 'res' completes its descent and spike activity, settling into a stable low range
+    
+    **Zone 3: Main Contact Conduction (Fully Closed State)**
+    *   **Physical Meaning**: The main contacts (Ag-plated) are fully engaged, providing a large, stable contact area. This is the "healthy contact" signature zone - resistance should be at its MINIMUM and STABLE. The breaker is in its fully closed, current-carrying state.
+    *   **Start**: End of Zone 2
+    *   **End Boundary**: Detect when the breaker begins OPENING (travel reverses direction).
+        *   Primary indicator: Travel (red) reaches MAXIMUM and starts to DESCEND
+        *   Cross-reference: Resistance (green) should remain low and stable throughout this zone
+        *   Cross-reference: Current (blue) should be stable at test level
+        *   **Typical Duration**: 100-200 ms (this is the longest zone, representing the dwell time)
+        *   **Detection Logic**: Find the peak of 'travel' curve and the point where it starts decreasing
+    
+    **Zone 4: Main Contact Parting (Breaking/Opening Transition)**
+    *   **Physical Meaning**: The main contacts are separating. As the contact area decreases, resistance rises sharply. Arcing occurs during the final separation of the arcing contacts. This is the "break" transition - the most critical phase for fault detection.
+    *   **Start**: End of Zone 3
+    *   **End Boundary**: Detect when resistance STABILIZES at high value after parting spikes.
+        *   Primary indicator: Resistance (green) shoots UP, exhibits parting spikes, then STABILIZES at high/infinite value
+        *   Cross-reference: Travel (red) should be decreasing (opening motion)
+        *   Cross-reference: Current (blue) may drop or fluctuate during final arc extinction
+        *   **Typical Duration**: 40-80 ms (Zone 4 typically ends around 280-340 ms total time)
+        *   **Detection Logic**: Find where 'res' completes its rise and spike activity, becoming constant at high value
+        *   **CRITICAL**: Do NOT extend this zone too long - end AS SOON AS resistance stabilizes
+    
+    **Zone 5: Final Open State (Fully Open)**
+    *   **Physical Meaning**: The contacts are fully separated with an air gap. No current flows, resistance is infinite. The breaker is in its fully open, non-conducting state.
+    *   **Start**: End of Zone 4
+    *   **End**: The last time point in the dataset
+    *   **Characteristics**: 
+        *   Resistance (green): Very high/infinite (flat line at top)
+        *   Current (blue): Zero or near-zero
+        *   Travel (red): Stable at minimum (fully open position)
+
+    **MULTI-CURVE ANALYSIS STRATEGY:**
+    1. Use Current (blue) to identify Zone 1 → Zone 2 transition (first current rise)
+    2. Use Resistance (green) to identify Zone 2 → Zone 3 transition (resistance settles to low plateau)
+    3. Use Travel (red) to identify Zone 3 → Zone 4 transition (travel peak and reversal)
+    4. Use Resistance (green) to identify Zone 4 → Zone 5 transition (resistance stabilizes at high value)
+    5. Always cross-validate boundaries using all three curves for consistency
+
+    **OUTPUT FORMAT (Strict JSON)**
+    Return ONLY this JSON object:
+    {{
+      "zones": {{
+        "zone_1_pre_contact": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_2_arcing_engagement": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_3_main_conduction": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_4_parting": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_5_final_open": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }}
+      }},
+      "report_card": {{
+        "opening_speed": {{ "status": "Pass"|"Warning"|"Fail", "comment": "Assessment of travel curve steepness" }},
+        "contact_wear": {{ "status": "Pass"|"Warning"|"Fail", "comment": "Based on resistance fluctuations in Zone 2/4" }},
+        "timing_consistency": {{ "status": "Pass"|"Warning"|"Fail", "comment": "Are phases within expected ranges?" }},
+        "overall_health": {{ "status": "Healthy"|"Needs Review"|"Critical", "comment": "Overall summary" }}
+      }},
+      "detailed_analysis": "Provide a comprehensive technical analysis (in Markdown)..."
+    }}
+    """
+
+def create_dcrm_plot(df, zones):
+    # Create figure with secondary y-axis
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+    # Add Traces
+    fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Current'], name="Current (A)", line=dict(color='#2980b9', width=2)), secondary_y=False)
+    fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Resistance'], name="Resistance (uOhm)", line=dict(color='#27ae60', width=2)), secondary_y=False)
+    fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Travel'], name="Travel (mm)", line=dict(color='#c0392b', width=2)), secondary_y=True)
+
+    # Zone Colors
+    zone_colors = {
+        "zone_1_pre_contact": "rgba(52, 152, 219, 0.1)",
+        "zone_2_arcing_engagement": "rgba(231, 76, 60, 0.1)",
+        "zone_3_main_conduction": "rgba(46, 204, 113, 0.1)",
+        "zone_4_parting": "rgba(155, 89, 182, 0.1)",
+        "zone_5_final_open": "rgba(149, 165, 166, 0.1)"
+    }
+
+    # Add Zone Rectangles
+    for zone_name, details in zones.items():
+        start = details.get("start_ms")
+        end = details.get("end_ms")
+        color = zone_colors.get(zone_name, "rgba(0,0,0,0)")
+        
+        if start is not None and end is not None:
+            fig.add_vrect(
+                x0=start, x1=end,
+                fillcolor=color, opacity=1,
+                layer="below", line_width=0,
+                annotation_text=zone_name.split('_')[1].upper(),
+                annotation_position="top left",
+                annotation_font_color="#7f8c8d"
+            )
+
+    fig.update_layout(
+        title_text="<b>Main Signals & Zones</b>",
+        height=500,
+        hovermode="x unified",
+        plot_bgcolor="white",
+        paper_bgcolor="white",
+        font=dict(family="Segoe UI, sans-serif"),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        margin=dict(l=20, r=20, t=60, b=20)
+    )
+    fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    fig.update_yaxes(title_text="Current / Resistance", secondary_y=False, showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    fig.update_yaxes(title_text="Travel", secondary_y=True, showgrid=False)
+
+    return fig
+
+def create_velocity_plot(df):
+    # Calculate Velocity (Derivative of Travel)
+    # V = d(Travel) / d(Time)
+    # Units: mm/ms = m/s
+    df['Velocity'] = df['Travel'].diff() / df['Time_ms'].diff()
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Velocity'], name="Velocity (m/s)", line=dict(color='#e67e22', width=2), fill='tozeroy'))
+    
+    fig.update_layout(
+        title_text="<b>Contact Velocity Profile</b>",
+        height=300,
+        hovermode="x unified",
+        plot_bgcolor="white",
+        paper_bgcolor="white",
+        font=dict(family="Segoe UI, sans-serif"),
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
+    fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    fig.update_yaxes(title_text="Velocity (m/s)", showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    return fig
+
+def create_resistance_zoom_plot(df):
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Resistance'], name="Resistance", line=dict(color='#27ae60', width=2)))
+    
+    fig.update_layout(
+        title_text="<b>Detailed Resistance (Log Scale)</b>",
+        height=300,
+        hovermode="x unified",
+        plot_bgcolor="white",
+        paper_bgcolor="white",
+        font=dict(family="Segoe UI, sans-serif"),
+        yaxis_type="log", # Log scale to see details
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
+    fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    fig.update_yaxes(title_text="Resistance (uOhm)", showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    return fig
+
+def enrich_data_with_zones(df, llm):
+    """
+    Uses the LLM to identify zones and adds a 'Zone' column to the DataFrame.
+    """
+    try:
+        # 1. Prepare Text Data
+        data_str = df.to_string(index=False)
+        prompt_text = get_dcrm_prompt(data_str)
+
+        # 2. Prepare Image Data
+        # Create a simplified plot for the LLM to "see"
+        fig = make_subplots(specs=[[{"secondary_y": True}]])
+        fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Current'], name="Current", line=dict(color='blue')), secondary_y=False)
+        fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Resistance'], name="Resistance", line=dict(color='green')), secondary_y=False)
+        fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Travel'], name="Travel", line=dict(color='red')), secondary_y=True)
+        fig.update_layout(title="DCRM Graph", showlegend=True)
+        
+        # Convert plot to image bytes
+        img_bytes = fig.to_image(format="png", width=1024, height=600)
+        base64_image = base64.b64encode(img_bytes).decode('utf-8')
+
+        # 3. Construct Multimodal Message
+        message = HumanMessage(
+            content=[
+                {"type": "text", "text": prompt_text},
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{base64_image}"}
+                }
+            ]
+        )
+
+        # 4. Invoke LLM
+        response = llm.invoke([message])
+        content = response.content.replace("```json", "").replace("```", "").strip()
+        result = json.loads(content)
+        zones = result.get("zones", {})
+        
+        # Initialize Zone column
+        df['Zone'] = "Unknown"
+        
+        for zone_name, details in zones.items():
+            start = details.get("start_ms")
+            end = details.get("end_ms")
+            if start is not None and end is not None:
+                # Map zone name to a simpler label (e.g., "Zone 1")
+                short_name = zone_name.split('_')[1] # "1", "2", etc.
+                mask = (df['Time_ms'] >= start) & (df['Time_ms'] <= end)
+                df.loc[mask, 'Zone'] = f"Zone {short_name}"
+        
+        return df, zones
+    except Exception as e:
+        st.error(f"Enrichment failed: {str(e)}")
+        return df, {}

core/agents/recommendation.py

@@ -0,0 +1,427 @@
+# Previous Name: analysis/agents/recommendation_agent.py
+import json
+import google.generativeai as genai
+
+# Configure Gemini API
+API_KEY = "AIzaSyDSGda4-5VLmd-y09K6sBfHqoqk1QUL6Xo"
+genai.configure(api_key=API_KEY)
+MODEL_NAME = "gemini-2.5-flash"
+
+# =========================
+# DEEP DOMAIN KNOWLEDGE PROMPT
+# =========================
+RECOMMENDATIONS_PROMPT = """
+Role: You are an expert High Voltage Circuit Breaker Maintenance Engineer with 25+ years of experience in DCRM (Dynamic Contact Resistance Measurement) diagnostics, predictive maintenance, and failure analysis for SF6 circuit breakers in EHV (220 kV and onwards) substations.
+
+Your Task: Based on comprehensive circuit breaker diagnostic data, provide:
+1. **Maintenance Recommendations** (Priority 1, 2, 3)
+2. **Future Fault Predictions** (minimum 3, with probabilities and timelines)
+
+===== DOMAIN KNOWLEDGE BASE =====
+
+**Circuit Breaker Defects (12 Classes) - Deep Knowledge Base:**
+
+1. **Healthy**: All parameters within spec, DLRO 20-50µΩ, smooth phase transitions, stable contact pressure, no timing deviations
+
+2. **Main Contact Wear**: 
+   - DLRO >100µΩ (healthy: 20-70µΩ), elevated plateau resistance during Phase 3
+   - Surface erosion, material loss, rough contact surfaces with "grassy noise" signature
+   - Causes: Thermal stress, mechanical friction, oxidation, improper contact pressure
+   - Progression: Early (70-100µΩ) → Moderate (100-180µΩ) → Severe (180-280µΩ) → Critical (>280µΩ)
+   - Risks: Overheating → Contact welding → Failed interruption → Explosion hazard
+
+3. **Arcing Contact Wear**: 
+   - High-amplitude spikes during Phase 2/4 arcing zones (>5000µΩ), sustained arc duration
+   - Contact pitting, erosion, craters from arc flash, prolonged arcing time
+   - Causes: Excessive fault interruptions, poor SF6 quality, contact misalignment
+   - Risks: Arc flash → Main contact damage → Failed interruption → Catastrophic failure
+
+4. **Main Contact Misalignment**: 
+   - "Telegraph pattern" with square-wave jumps (>120µΩ steps), uneven contact engagement
+   - Stepped resistance plateaus, asymmetric contact pressure distribution
+   - Causes: Mechanical wear, linkage looseness, contact holder deformation, improper assembly
+   - Risks: Localized heating → Uneven wear → Contact welding → Mechanical seizure
+
+5. **Arcing Contact Misalignment**: 
+   - Asymmetric Phase 2 vs Phase 4 durations (ratio >1.6), sinusoidal bounce patterns
+   - One contact engages before the other, timing mismatch between poles
+   - Causes: Linkage rod bending, pole asynchrony, damping system failure
+   - Risks: Unbalanced arcing → Accelerated wear → Phase-to-phase timing errors
+
+6. **Operating Mechanism Malfunction**: 
+   - Abnormal closing/opening times (>20% deviation), reduced contact speed (<4.5 m/s)
+   - Sluggish operation, stutter patterns, inconsistent travel curves
+   - Causes: Lubrication degradation, bearing wear, spring fatigue, control linkage issues
+   - Risks: Timing drift → Failed synchronization → Protection coordination loss
+
+7. **Damping System Fault**: 
+   - Contact bounce (>5 oscillations, >100µΩ amplitude), sinusoidal resistance patterns
+   - Excessive mechanical vibration during closing, oil leakage from dampers
+   - Causes: Hydraulic oil degradation, seal failure, piston wear, gas spring leakage
+   - Risks: Contact welding → Mechanical damage → Spring breakage → Stuck breaker
+
+8. **SF6 Pressure Leakage**: 
+   - Prolonged arcing duration (>25ms), poor arc quenching, elevated arc resistance
+   - Pressure below spec (<5.5 bar), gas purity degradation, moisture ingress
+   - Causes: Gasket deterioration, seal failure, manufacturing defects, thermal cycling
+   - Risks: Reduced dielectric strength → Internal flashover → Arc quenching failure → Explosion
+
+9. **Linkage/Rod Obstruction**: 
+   - Stutter patterns during travel (>3 distinct flat plateaus >10ms), mechanical binding
+   - Irregular travel curve, sudden speed changes, torque fluctuations
+   - Causes: Foreign object ingress, ice formation, corrosion, misaligned rods
+   - Risks: Incomplete stroke → Failed operation → Mechanical jam → Safety hazard
+
+10. **Fixed Contact Damage**: 
+    - Elevated DLRO (>80µΩ) with smooth stable Phase 3 (no grassy noise = stationary contact issue)
+    - DC offset shift, baseline resistance elevation, contact deformation
+    - Causes: Thermal damage, arc erosion of stationary contact, improper installation
+    - Risks: Increased heating → Insulation damage → Tracking → Ground fault
+
+11. **Close Coil Damage**: 
+    - Close coil current <2A (healthy: 4-7A), failed closing operation, coil overheating
+    - Open/short circuit in coil winding, control circuit failure
+    - Causes: Electrical overstress, insulation breakdown, mechanical damage, moisture ingress
+    - Risks: Failed closing → Breaker stuck open → System de-energization
+
+12. **Trip Coil Damage**: 
+    - Trip coil 1 or 2 current <2A, redundancy loss, failed opening operation
+    - Both coils failed = catastrophic (breaker cannot trip during fault)
+    - Causes: Coil burnout, circuit failure, auxiliary contact malfunction
+    - Risks: Failed interruption → Sustained fault current → Equipment damage → Fire hazard
+
+**KPI Thresholds (Healthy Ranges):**
+- Closing Time: 70-110 ms
+- Opening Time: 20-40 ms
+- DLRO Value: 20-100 µΩ (ideal: 20-50 µΩ)
+- Peak Resistance: 500-1000000000000 µΩ (during conduction excluding open baseline)
+- Main Wipe: 10-20 mm
+- Arc Wipe: 15-25 mm
+- Contact Travel Distance: 150-200 mm
+- Contact Speed: 2.0-6.0 m/s
+- Coil Currents: 1-7 A (nominal: 4-7A)
+- Ambient Temperature: 10-40°C
+
+**CBHI Score Interpretation:**
+- 90-100: Excellent - Routine monitoring only
+- 75-89: Good - Minor preventive actions
+- 60-74: Fair - Scheduled maintenance needed
+- 40-59: Poor - Urgent attention required
+- 0-39: Critical - Immediate intervention
+
+**Common Failure Progressions:**
+- Contact Wear → Increased Resistance → Overheating → Welding/Failure
+- Gas Leak → Poor Arc Quenching → Contact Damage → Catastrophic Failure
+- Mechanism Issues → Timing Drift → Coordination Loss → System Fault
+- Coil Degradation → Incomplete Operation → Stuck Breaker → Protection Failure
+
+**Maintenance Action Guidelines:**
+- **Priority 1 (Critical)**: 0-1 month, safety/reliability risk, Red (#B71C1C bg:#FFCDD2)
+- **Priority 2 (Important)**: 1-3 months, performance degradation, Amber (#F57F17 bg:#FFF9C4)
+- **Priority 3 (Preventive)**: 3-6 months, optimization/prevention, Blue (#0D47A1 bg:#BBDEFB)
+- **Priority 4 (Additional)**: If needed, Red (#B71C1C bg:#FFCDD2)
+- **Priority 5 (Additional)**: If needed, Amber (#F57F17 bg:#FFF9C4)
+- **CRITICAL: Each priority level must have EXACTLY ONE action** (create Priority 4, 5, etc. if needed)
+- **Total actions: Minimum 3, Maximum 5** (distribute across priorities as needed)
+
+**Future Fault Risk Levels & STRICT Color Mapping:**
+- **High Risk**: Probability >60%, Timeline <12 months
+- **Medium Risk**: Probability 30-60%, Timeline 12-24 months
+- **Low Risk**: Probability <30%, Timeline >24 months
+- **HARDCODED Colors (by position, NOT risk_level)**: 1st=#2E7D32, 2nd=#F57F17, 3rd=#0D47A1, 4th=#2E7D32, 5th=#F57F17
+- **Total predictions: Minimum 3, Maximum 5** (ensure variety of risk levels)
+
+===== INPUT DATA =====
+
+**KPIs (Key Performance Indicators):**
+{kpis_json}
+
+**CBHI Score (Circuit Breaker Health Index):**
+{cbhi_score} / 100
+
+**Detected Faults:**
+{faults_summary}
+
+===== OUTPUT REQUIREMENTS =====
+
+Return ONLY valid JSON (no markdown fences, no extra text). 
+
+**CRITICAL JSON FORMATTING RULES:**
+- All strings must use double quotes (")
+- Escape any double quotes within strings using backslash (\")
+- Do NOT use smart quotes, apostrophes, or special Unicode quotes
+- Ensure all brackets and braces are properly matched
+- Use standard ASCII characters only in field values
+- Multi-line text should be a single string with spaces, not actual line breaks
+
+**LANGUAGE STYLE - CRITICAL:**
+- **justification**: Write as NATURAL EXPLANATION (not bullet points). Explain the CAUSE and EFFECT relationship clearly. 
+  - Example GOOD: "SF6 pressure declining from 7.0 to 6.8 bar over recent tests. Gas quality directly affects arc quenching and contact performance."
+  - Example BAD: "KPI: SF6 6.8 bar; Phase 2: arc; AI: leak 45%"
+  - MAX 150 characters total
+  
+- **evidence** (for future faults): Write as EXPLANATORY SENTENCE describing the trend or pattern observed.
+  - Example GOOD: "Contact resistance is significantly elevated, indicating material degradation. This will worsen over time, leading to overheating."
+  - Example BAD: "DLRO +15%/mo; Phase 3: plateau; Wear: 68% conf"
+  - MAX 120 characters total
+  
+- **Use proper technical narratives, NOT statistical shorthand**
+
+Structure (EXACT format and ordering required):
+
+{{
+  "maintenanceActions": [
+    {{
+      "actions": [
+        {{
+          "id": "1",
+          "justification": "Natural language explanation citing key evidence from KPIs/Faults",
+          "timeline": "Within 1 month",
+          "title": "Clear, actionable maintenance task",
+          "whatToLookFor": [
+            "Specific inspection point 1",
+            "Specific measurement/check 2",
+            "Expected finding/threshold 3",
+            "Corrective action trigger 4"
+          ]
+        }}
+      ],
+      "bgColor": "#FFCDD2",
+      "color": "#B71C1C",
+      "priority": "Priority 1"
+    }},
+    {{
+      "actions": [
+        {{
+          "id": "2",
+          "justification": "Clear explanation with evidence",
+          "timeline": "Within 3 months",
+          "title": "Second most critical task",
+          "whatToLookFor": ["item1", "item2", "item3", "item4"]
+        }}
+      ],
+      "bgColor": "#FFF9C4",
+      "color": "#F57F17",
+      "priority": "Priority 2"
+    }},
+    {{
+      "actions": [
+        {{
+          "id": "3",
+          "justification": "Brief evidence-based reasoning",
+          "timeline": "Within 6 months",
+          "title": "Preventive maintenance task",
+          "whatToLookFor": ["item1", "item2", "item3", "item4"]
+        }}
+      ],
+      "bgColor": "#BBDEFB",
+      "color": "#0D47A1",
+      "priority": "Priority 3"
+    }}
+  ],
+  "futureFaultsPdf": [
+    {{
+      "color": "#2E7D32",
+      "evidence": "Natural language explanation of trends and patterns observed.",
+      "fault": "Specific fault name from 12 defect classes",
+      "id": "1",
+      "probability": 68,
+      "risk_level": "high",
+      "timeline": "6 - 12 Months"
+    }},
+    {{
+      "color": "#F57F17",
+      "evidence": "Descriptive sentence about observed patterns and correlations.",
+      "fault": "Another potential fault",
+      "id": "2",
+      "probability": 42,
+      "risk_level": "medium",
+      "timeline": "12 - 18 Months"
+    }},
+    {{
+      "color": "#0D47A1",
+      "evidence": "Long-term risk explanation based on industry experience.",
+      "fault": "Third potential fault",
+      "id": "3",
+      "probability": 25,
+      "risk_level": "low",
+      "timeline": "> 24 Months"
+    }}
+  ]
+}}
+
+===== ANALYSIS INSTRUCTIONS =====
+
+**Step 1: Deep Multi-Source Analysis**
+- Cross-reference KPIs, CBHI, and Detected Faults to identify CORRELATIONS and PATTERNS
+- Look for evidence chains: e.g., High DLRO → Elevated resistance → Main Wear verdict → Overheating risk
+- Consider ALL 12 defect classes and identify which ones apply (even if probability is lower)
+
+**Step 2: Maintenance Action Prioritization (3-5 actions total)**
+- **CRITICAL RULE: Each priority level has EXACTLY ONE action** (no multiple actions per priority)
+- **CRITICAL RULE: Provide 3-5 priority levels** (create Priority 4, 5 if needed)
+- **CRITICAL RULE: The "id" field MUST match priority number** (Priority 1 → id="1", Priority 2 → id="2", etc.)
+- **HARDCODED Color scheme (DO NOT CHANGE)**: 
+  * Priority 1: color="#B71C1C", bgColor="#FFCDD2"
+  * Priority 2: color="#F57F17", bgColor="#FFF9C4"
+  * Priority 3: color="#0D47A1", bgColor="#BBDEFB"
+  * Priority 4 (if any): color="#B71C1C", bgColor="#FFCDD2"
+  * Priority 5 (if any): color="#F57F17", bgColor="#FFF9C4"
+
+**Step 3: Future Fault Predictions (3-5 predictions)**
+- **CRITICAL RULE: Provide 3-5 predictions with DIVERSE risk levels and timelines**
+- **CRITICAL RULE: The "id" field is sequential** (1, 2, 3, 4, 5)
+- **HARDCODED Color scheme (DO NOT CHANGE)**: 
+  * 1st fault: color="#2E7D32"
+  * 2nd fault: color="#F57F17"
+  * 3rd fault: color="#0D47A1"
+  * 4th fault (if any): color="#2E7D32"
+  * 5th fault (if any): color="#F57F17"
+- **Color assignment is FIXED by position, NOT by risk_level**
+- **Progression logic to apply:**
+  - Contact Wear → Overheating → Welding → Failed interruption (6-12 months high risk)
+  - Gas Leak → Poor arc quenching → Contact damage → Catastrophic failure (12-18 months medium)
+  - Mechanism wear → Timing drift → Coordination loss → Protection failure (18-24 months medium)
+  - Coil degradation (one failed) → Second coil stress → Redundancy loss (>24 months low)
+  - Arcing wear → Main contact damage → System fault (12-18 months medium)
+
+**Remember**: Your output will be used by field maintenance engineers. Be PRECISE, ACTIONABLE, and INSIGHTFUL.
+Generate thoughtful, data-driven, practical insights that can immediately guide maintenance decisions.
+"""
+
+
+def generate_recommendations(kpis, cbhi_score, rule_faults, ai_faults, llm):
+    """
+    Generates maintenance actions and future fault predictions based on DCRM analysis.
+    
+    Args:
+        kpis (dict): Calculated KPIs.
+        cbhi_score (float): The overall health score.
+        rule_faults (list): Faults detected by the Rule Engine.
+        ai_faults (list): Faults detected by the AI Agent.
+        llm: The LLM instance (not used, using Gemini directly).
+        
+    Returns:
+        dict: A dictionary containing 'maintenanceActions' and 'futureFaultsPdf'.
+    """
+    
+    # 1. Prepare Context
+    faults_summary = "Deterministic Faults:\n"
+    if not rule_faults:
+        faults_summary += "- None (Healthy)\n"
+    else:
+        for f in rule_faults:
+            faults_summary += f"- {f.get('defect_name')}: {f.get('description')} (Severity: {f.get('Severity')})\n"
+            
+    faults_summary += "\nAI Agent Insights:\n"
+    if not ai_faults:
+        faults_summary += "- None\n"
+    else:
+        for f in ai_faults:
+            faults_summary += f"- {f.get('defect_name')}: {f.get('description')} (Severity: {f.get('Severity')})\n"
+
+    kpi_summary = json.dumps(kpis, indent=2, ensure_ascii=False)
+    
+    # 2. Format the prompt with actual data
+    prompt = RECOMMENDATIONS_PROMPT.format(
+        kpis_json=kpi_summary,
+        cbhi_score=cbhi_score,
+        faults_summary=faults_summary
+    )
+    
+    # 3. Configure generation
+    generation_config = {
+        "temperature": 0.4,  
+        "top_p": 0.95,
+        "top_k": 40,
+        "max_output_tokens": 8192,
+    }
+    
+    # 4. Initialize model
+    model = genai.GenerativeModel(
+        model_name=MODEL_NAME,
+        generation_config=generation_config
+    )
+    
+    # 5. Generate with retry logic
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            if attempt == 0:
+                print("🔮 Generating recommendations and future fault predictions...")
+            else:
+                print(f"🔄 Retry attempt {attempt}/{max_retries-1}...")
+            
+            # Add JSON validation instruction on retry
+            if attempt > 0:
+                prompt_with_retry = prompt + "\n\nIMPORTANT: Ensure all text in justification, evidence, and whatToLookFor fields has properly escaped quotes. Use single quotes within text or escape double quotes with backslash."
+            else:
+                prompt_with_retry = prompt
+            
+            # Generate response
+            response = model.generate_content(prompt_with_retry)
+            
+            # Check if response has valid content
+            if not response or not response.text or response.text.strip() == "":
+                print(f"⚠️ Empty response from API. Finish reason: {response.candidates[0].finish_reason if response and response.candidates else 'Unknown'}")
+                if attempt == max_retries - 1:
+                    return {
+                        "error": "Empty response from API (quota/safety block)",
+                        "finish_reason": response.candidates[0].finish_reason if response and response.candidates else None,
+                        "maintenanceActions": [],
+                        "futureFaultsPdf": []
+                    }
+                continue  # Try again
+            
+            # Extract JSON from response
+            response_text = response.text.strip()
+            
+            # Clean up markdown code fences if present
+            if response_text.startswith("```json"):
+                response_text = response_text[7:]
+            if response_text.startswith("```"):
+                response_text = response_text[3:]
+            if response_text.endswith("```"):
+                response_text = response_text[:-3]
+            
+            response_text = response_text.strip()
+            
+            # Additional cleanup: fix common JSON issues
+            # Replace smart quotes with regular quotes
+            response_text = response_text.replace('"', '"').replace('"', '"')
+            response_text = response_text.replace("'", "'").replace("'", "'")
+            
+            # Parse JSON
+            result = json.loads(response_text)
+            
+            print("✅ Successfully generated recommendations and predictions")
+            return result
+            
+        except json.JSONDecodeError as e:
+            print(f"❌ JSON parsing error (attempt {attempt+1}/{max_retries}): {e}")
+            if attempt == max_retries - 1:
+                print(f"Raw response excerpt:\n{response_text[:1000]}...")
+                # Try to salvage what we can
+                return {
+                    "error": f"Failed to parse AI response after {max_retries} attempts",
+                    "raw_response": response_text[:2000],
+                    "maintenanceActions": [],
+                    "futureFaultsPdf": []
+                }
+            # Wait a bit before retry
+            import time
+            time.sleep(1)
+            
+        except Exception as e:
+            print(f"❌ Error generating recommendations: {e}")
+            return {
+                "error": str(e),
+                "maintenanceActions": [],
+                "futureFaultsPdf": []
+            }
+    
+    return {
+        "error": "Max retries exceeded",
+        "maintenanceActions": [],
+        "futureFaultsPdf": []
+    }

core/calculators/cbhi.py

@@ -0,0 +1,197 @@
+# Previous Name: analysis/cbhi_calculator.py
+import json
+
+def calculate_score(val, min_good, max_good, buffer):
+    # Calculate the middle of the ideal range
+    middle = (min_good + max_good) / 2.0
+    half_range = (max_good - min_good) / 2.0
+    
+    if min_good <= val <= max_good:
+        # Distance from the middle point
+        distance_from_middle = abs(val - middle)
+        # If exactly at middle, score is 100
+        if distance_from_middle == 0:
+            return 100.0
+        # Scale from 90 to 100 based on how far from middle
+        # Closer to middle = higher score (90-100%)
+        score = 100.0 - (10.0 * (distance_from_middle / half_range))
+        return max(90.0, score)  # Ensure minimum 90% within range
+    
+    # 2. Low Side: Value is lower than min_good
+    if val < min_good:
+        # Calculate how far off it is
+        distance = min_good - val
+        # If distance exceeds buffer, score is 0. Otherwise, scale it.
+        if distance >= buffer:
+            return 0.0
+        return 90.0 * (1.0 - (distance / buffer))
+
+    # 3. High Side: Value is higher than max_good
+    if val > max_good:
+        distance = val - max_good
+        if distance >= buffer:
+            return 0.0
+        return 90.0 * (1.0 - (distance / buffer))
+    
+    return 0.0
+
+WEIGHTS = {
+    "peak_resistance": 0.15,
+    "dlro": 0.10,
+    "travel": 0.10,
+    "speed": 0.10,
+    "open_time": 0.15,
+    "close_time": 0.15,
+    "main_wipe": 0.05,
+    "arc_wipe": 0.05,
+    "coil_current": 0.10,  
+    "temp": 0.05
+}
+
+# ==========================================
+# NEW LOGIC: AI & PHASE ADJUSTMENTS
+# ==========================================
+
+def calculate_ai_penalty(ai_verdict_list):
+    """
+    Calculates penalty based on AI defects.
+    High: -15, Medium: -12, Low: -10 (Scaled by Confidence)
+    """
+    total_penalty = 0.0
+    
+    # Base penalty values
+    severity_map = {
+        "High": 15.0,
+        "Medium": 12.0,
+        "Low": 10.0
+    }
+
+    # Ensure input is a list (handle single object or list of objects)
+    if isinstance(ai_verdict_list, dict):
+        ai_verdict_list = [ai_verdict_list]
+    
+    for defect in ai_verdict_list:
+        label = defect.get("faultLabel", defect.get("defect_name", "Healthy"))
+        
+        # If explicitly Healthy, no penalty
+        if label.lower() == "healthy":
+            continue
+
+        severity = defect.get("severity", "Low")
+        confidence = float(defect.get("confidence", 0)) / 100.0
+        
+        # Dynamic Penalty: Base * Confidence
+        # Example: High (15) * 0.90 = 13.5 deduction
+        base_deduction = severity_map.get(severity, 10.0)
+        actual_deduction = base_deduction * confidence
+        
+        total_penalty += actual_deduction
+
+    return total_penalty
+
+def calculate_phase_adjustment(phase_data):
+    """
+    Calculates adjustment based on 5 phases.
+    Healthy: Add +2.0 to +3.0 (based on confidence)
+    Not Healthy: Subtract -1.5 to -2.0 (based on confidence)
+    """
+    adjustment = 0.0
+    
+    for phase_name, data in phase_data.items():
+        status = data.get("status", "Not Healthy").lower()
+        confidence = float(data.get("confidence", 0)) / 100.0
+        
+        if status == "healthy":
+            # REWARD: Range 2.0 to 3.0
+            # If conf=100 -> +3.0, If conf=0 -> +2.0
+            reward = 2.0 + (1.0 * confidence)
+            adjustment += reward
+        else:
+            # PENALTY: Range 1.5 to 2.0
+            # If conf=100 -> -2.0, If conf=0 -> -1.5
+            penalty = 1.5 + (0.5 * confidence)
+            adjustment -= penalty
+            
+    return adjustment
+
+# ==========================================
+# MAIN COMPUTE FUNCTION (UPDATED)
+# ==========================================
+
+def compute_cbhi(kpis_list, ai_data=None, phase_data=None):
+    # 1. Parse KPIs into Dictionary
+    kpi_dict = {item['name']: item['value'] for item in kpis_list}
+
+    # 2. Compute Individual KPI Scores (Existing Logic)
+    def get_val(name):
+        v = kpi_dict.get(name)
+        return v if v is not None else 0.0
+
+    s_dlro = calculate_score(get_val("DLRO Value"), 20, 100, 50)
+    s_peak = calculate_score(get_val("Peak Resistance"), 80, 150, 200)
+    s_travel = calculate_score(get_val("Contact Travel Distance"), 150, 200, 30)
+    s_speed = calculate_score(get_val("Contact Speed"), 2.0, 6.0, 1.5)
+    s_open = calculate_score(get_val("Opening Time"), 20, 40, 20)
+    s_close = calculate_score(get_val("Closing Time"), 70, 110, 20)
+    s_mw = calculate_score(get_val("Main Wipe"), 10, 20, 5)
+    s_aw = calculate_score(get_val("Arc Wipe"), 15, 25, 5)
+    
+    c_close = get_val("Peak Close Coil Current")
+    c_trip = max(get_val("Peak Trip Coil 1 Current"), get_val("Peak Trip Coil 2 Current"))
+    s_coil_c = calculate_score(c_close, 1.0, 7.0, 5.0)
+    s_coil_t = calculate_score(c_trip, 1.0, 7.0, 5.0)
+    s_coil = (s_coil_c + s_coil_t) / 2.0
+    
+    s_temp = calculate_score(get_val("Ambient Temperature"), 10, 40, 30)
+
+    # 3. Store Scores
+    scores = {
+        "dlro": s_dlro,
+        "peak_resistance": s_peak,
+        "travel": s_travel,
+        "speed": s_speed,
+        "open_time": s_open,
+        "close_time": s_close,
+        "main_wipe": s_mw,
+        "arc_wipe": s_aw,
+        "coil_current": s_coil,
+        "temp": s_temp
+    }
+
+    # 4. Calculate Base Weighted Score
+    base_cbhi = sum(scores[key] * WEIGHTS[key] for key in scores)
+    
+    # 5. Calculate AI Verdict Penalty
+    ai_penalty = 0.0
+    if ai_data:
+        # Extract verdicts from ai_data robustly
+        defects = []
+        if isinstance(ai_data, dict):
+            if "aiVerdict" in ai_data:
+                verdicts = ai_data["aiVerdict"]
+                if isinstance(verdicts, dict):
+                    defects = [verdicts]
+                elif isinstance(verdicts, list):
+                    defects = verdicts
+            else:
+                defects = [ai_data]
+        elif isinstance(ai_data, list):
+            defects = ai_data
+        # Only penalize non-healthy verdicts
+        non_healthy_defects = [d for d in defects if str(d.get("faultLabel", d.get("defect_name", "Healthy")).lower()) != "healthy"]
+        if non_healthy_defects:
+            ai_penalty = calculate_ai_penalty(non_healthy_defects)
+
+    # 6. Calculate Phase Adjustments
+    phase_adj = 0.0
+    if phase_data:
+        phase_adj = calculate_phase_adjustment(phase_data)
+
+    # 7. Final Aggregation
+    final_score = base_cbhi - ai_penalty + phase_adj
+    
+    # 8. Clamp to 0-100
+    final_score = max(3.33, min(98.67, final_score))
+
+    # Return Detailed Object (optional) or just the number
+    return  int(round(final_score, 2))

core/calculators/kpi.py

@@ -0,0 +1,307 @@
+# Previous Name: analysis/kpi_calculator.py
+import json
+import math
+import numpy as np
+import pandas as pd
+import requests
+
+# =========================
+# 1) Weather (optional)
+# =========================
+def get_ambient_temperature_pune(timeout: int = 3, fallback_c: float = 28.0) -> float:
+    try:
+        lat, lon = 18.52, 73.86
+        url = f"https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&current_weather=true"
+        j = requests.get(url, timeout=timeout).json()
+        return float(j["current_weather"]["temperature"])
+    except Exception:
+        return float(fallback_c)
+
+# =========================
+# 2) Helpers
+# =========================
+def rolling_smooth(x: np.ndarray, window: int = 7) -> np.ndarray:
+    """Centered rolling median smoothing (robust to spikes)."""
+    s = pd.Series(x)
+    sm = s.rolling(window=window, center=True).median()
+    sm = sm.bfill().ffill().fillna(s)
+    return sm.values
+
+def first_time_above(t: np.ndarray, y: np.ndarray, thr: float) -> float:
+    """First time y crosses above thr (with linear interpolation)."""
+    for i in range(1, len(y)):
+        if y[i-1] < thr <= y[i]:
+            dy = y[i] - y[i-1]
+            dt = t[i] - t[i-1]
+            if dy == 0 or dt == 0:
+                return float(t[i])
+            frac = (thr - y[i-1]) / dy
+            return float(t[i-1] + frac * dt)
+    if len(y) and y[0] >= thr:
+        return float(t[0])
+    return math.nan
+
+def crossing_time(t: np.ndarray, y: np.ndarray, thr: float, direction: str) -> float:
+    for i in range(1, len(y)):
+        y0, y1 = y[i-1], y[i]
+        if direction == "below" and y0 > thr >= y1:
+            dt = t[i] - t[i-1]
+            dy = y1 - y0
+            if dy == 0 or dt == 0:
+                return float(t[i])
+            frac = (thr - y0) / dy
+            return float(t[i-1] + frac * dt)
+        if direction == "above" and y0 < thr <= y1:
+            dt = t[i] - t[i-1]
+            dy = y1 - y0
+            if dy == 0 or dt == 0:
+                return float(t[i])
+            frac = (thr - y0) / dy
+            return float(t[i-1] + frac * dt)
+    return math.nan
+
+def interp_series_at(t: np.ndarray, y: np.ndarray, t_query: float) -> float:
+    if np.isnan(t_query):
+        return math.nan
+    idx = np.searchsorted(t, t_query)
+    if idx == 0:
+        return float(y[0])
+    if idx >= len(t):
+        return float(y[-1])
+    t0, t1 = t[idx-1], t[idx]
+    y0, y1 = y[idx-1], y[idx]
+    if t1 == t0:
+        return float(y0)
+    return float(y0 + (y1 - y0) * (t_query - t0) / (t1 - t0))
+
+# =========================
+# 3) KPI computation
+# =========================
+def analyze_breaker_data(
+    df,
+    coil_threshold: float = 0.5,
+    travel_edge_mm: float = 2.0,
+    arc_end_pct_open: float = 0.95,
+    dlro_margin_ms: float = 10.0,
+    ambient_fallback_c: float = 28.0,
+):
+
+    df.columns = [c.strip() for c in df.columns]
+
+    # Extract series as floats
+    t = df["Time_ms"].values.astype(float)
+    R = df["Resistance"].values.astype(float)
+    travel = df["Travel"].values.astype(float)
+    close_coil = df["Close_Coil"].values.astype(float)
+    trip1 = df["Trip_Coil_1"].values.astype(float)
+    trip2 = df["Trip_Coil_2"].values.astype(float)
+
+    # Basic travel stats
+    travel_min = float(np.min(travel))
+    travel_max = float(np.max(travel))
+
+    # Define open/closed masks
+    open_mask = travel <= (travel_min + 5.0)      # near minimum (open)
+    closed_mask = travel >= (travel_max - 5.0)    # near maximum (closed)
+
+    # Resistance baselines
+    R_open_baseline = float(np.median(R[open_mask])) if np.any(open_mask) else float(np.median(R[:max(1, int(len(R)*0.2))]))
+    R_closed_baseline = float(np.median(R[closed_mask])) if np.any(closed_mask) else float(np.median(R[int(len(R)*0.3):int(len(R)*0.7)]))
+
+    # Threshold for state transition
+    R_mid = (R_open_baseline + R_closed_baseline) / 2.0
+
+    # Coil energization times
+    close_sm = pd.Series(close_coil).rolling(window=3, center=True).max().bfill().ffill().values
+    trip_sm  = pd.Series(trip1).rolling(window=3, center=True).max().bfill().ffill().values
+
+    T_close_cmd = first_time_above(t, close_sm, coil_threshold)
+    T_trip1_cmd = first_time_above(t, trip_sm,  coil_threshold)
+
+    # Contact make / part
+    post_close_mask = t >= T_close_cmd if not math.isnan(T_close_cmd) else np.ones_like(t, dtype=bool)
+    T_make = crossing_time(t[post_close_mask], R[post_close_mask], R_mid, direction="below")
+
+    post_trip_mask = t >= T_trip1_cmd if not math.isnan(T_trip1_cmd) else np.ones_like(t, dtype=bool)
+    T_part = crossing_time(t[post_trip_mask], R[post_trip_mask], R_mid, direction="above")
+
+    # Travel at make/part
+    travel_at_make = interp_series_at(t, travel, T_make)
+    travel_at_part = interp_series_at(t, travel, T_part)
+
+    # Main wipe 
+    main_wipe_mm = travel_max - travel_at_make if not math.isnan(travel_at_make) else math.nan
+
+    # Arc wipe
+    R_arc_end_thr = R_open_baseline * arc_end_pct_open
+    after_part_mask = t >= T_part if not math.isnan(T_part) else np.ones_like(t, dtype=bool)
+    T_arc_end = crossing_time(t[after_part_mask], R[after_part_mask], R_arc_end_thr, direction="above")
+    travel_at_arc_end = interp_series_at(t, travel, T_arc_end)
+    arc_wipe_mm = (travel_at_part - travel_at_arc_end) if (not math.isnan(travel_at_part) and not math.isnan(travel_at_arc_end)) else math.nan
+    if arc_wipe_mm < 0 and not math.isnan(arc_wipe_mm):
+        arc_wipe_mm = abs(arc_wipe_mm)
+
+    # Contact travel distance
+    contact_travel_distance_mm = travel_max - travel_min
+
+    # Motion segments and speeds (m/s)
+    travel_sm = rolling_smooth(travel, window=7)
+    dt = np.gradient(t)
+    dy = np.gradient(travel_sm)
+    velocity_ms = np.where(dt != 0, dy / dt, 0.0)
+
+    # Closing segment
+    if not math.isnan(T_close_cmd):
+        start_idx = np.argmax((t >= T_close_cmd) & (travel > (travel_min + travel_edge_mm)))
+    else:
+        start_idx = np.argmax(travel > (travel_min + travel_edge_mm))
+    end_candidates = np.where(travel >= (travel_max - 1.0))[0]
+    end_idx = end_candidates[0] if len(end_candidates) else len(t)-1
+    closing_time_window_ms = t[end_idx] - t[start_idx] if end_idx > start_idx else math.nan
+    closing_distance_mm = travel[end_idx] - travel[start_idx] if end_idx > start_idx else math.nan
+    closing_speed_avg_ms = (closing_distance_mm / closing_time_window_ms) if (not math.isnan(closing_time_window_ms) and closing_time_window_ms > 0) else math.nan
+    closing_speed_peak_ms = float(np.max(velocity_ms[start_idx:end_idx+1])) if end_idx > start_idx else math.nan
+
+    # Opening segment
+    if not math.isnan(T_trip1_cmd):
+        dec = np.r_[False, np.diff(travel) < 0]
+        opening_start_idx = np.argmax((t >= T_trip1_cmd) & dec)
+    else:
+        opening_start_idx = np.argmax(np.r_[False, np.diff(travel) < 0])
+    open_end_candidates = np.where(travel <= (travel_min + 1.0))[0]
+    opening_end_idx = open_end_candidates[-1] if len(open_end_candidates) else len(t)-1
+    opening_time_window_ms = t[opening_end_idx] - t[opening_start_idx] if opening_end_idx > opening_start_idx else math.nan
+    opening_distance_mm = travel[opening_start_idx] - travel[opening_end_idx] if opening_end_idx > opening_start_idx else math.nan
+    opening_speed_avg_ms = (opening_distance_mm / opening_time_window_ms) if (not math.isnan(opening_time_window_ms) and opening_time_window_ms > 0) else math.nan
+    opening_speed_peak_ms = float(np.max(velocity_ms[opening_start_idx:opening_end_idx+1])) if opening_end_idx > opening_start_idx else math.nan
+
+    # DLRO
+    start_closed = (T_make + dlro_margin_ms) if not math.isnan(T_make) else t[0]
+    end_closed   = (T_part - dlro_margin_ms) if not math.isnan(T_part) else t[-1]
+    closed_interval_mask = (t >= start_closed) & (t <= end_closed)
+    if np.any(closed_interval_mask):
+        DLRO_uohm = float(np.median(R[closed_interval_mask]))
+    else:
+        DLRO_uohm = float(np.median(R[closed_mask])) if np.any(closed_mask) else float(np.median(R))
+
+    # --- ROBUST PEAK RESISTANCE LOGIC ---
+    # Peak Resistance should be the maximum value during actual conduction (when contacts are touching).
+    # The "open baseline" (850 in this case) represents infinite/saturated resistance and should be excluded.
+    # Strategy:
+    # 1. Identify the open baseline as the most frequent high value (mode of upper percentile)
+    # 2. Find peak in the conduction range (values significantly below open baseline)
+    
+    # Find the open baseline (saturation value) - use upper 10% of data
+    R_sorted = np.sort(R)
+    upper_10pct_idx = int(len(R_sorted) * 0.90)
+    upper_values = R_sorted[upper_10pct_idx:]
+    
+    # If upper values are relatively constant (std < 5% of mean), treat as saturation
+    if len(upper_values) > 0:
+        upper_mean = np.mean(upper_values)
+        upper_std = np.std(upper_values)
+        
+        if upper_std < (upper_mean * 0.05):  # Very stable upper region = saturation
+            saturation_value = upper_mean
+        else:
+            saturation_value = R_open_baseline
+    else:
+        saturation_value = R_open_baseline
+    
+    # Define conduction range: values at least 10% below saturation
+    conduction_threshold = saturation_value * 0.90
+    
+    # Find all resistance values in the conduction range
+    conduction_mask = R < conduction_threshold
+    
+    if np.any(conduction_mask):
+        peak_resistance_uohm = float(np.max(R[conduction_mask]))
+    else:
+        # Fallback: use median of lower 50% of data
+        lower_half_idx = int(len(R_sorted) * 0.50)
+        peak_resistance_uohm = float(np.max(R_sorted[:lower_half_idx])) if lower_half_idx > 0 else float(np.median(R))
+    # -------------------------------------
+
+    # Peak coil currents
+    peak_close_coil_A = float(np.max(close_coil))
+    peak_trip1_coil_A = float(np.max(trip1))
+    peak_trip2_coil_A = float(np.max(trip2))
+
+    # Opening/Closing times
+    closing_time_ms = (T_make - T_close_cmd) if (not math.isnan(T_make) and not math.isnan(T_close_cmd)) else math.nan
+    opening_time_ms = (T_part - T_trip1_cmd) if (not math.isnan(T_part) and not math.isnan(T_trip1_cmd)) else math.nan
+
+    # Ambient temperature
+    ambient_temp_c = get_ambient_temperature_pune(fallback_c=ambient_fallback_c)
+
+    # Contact Speed
+    contact_speed_ms = None
+    if not math.isnan(closing_speed_avg_ms) and not math.isnan(opening_speed_avg_ms):
+        contact_speed_ms = (closing_speed_avg_ms + opening_speed_avg_ms) / 2.0
+    elif not math.isnan(closing_speed_avg_ms):
+        contact_speed_ms = closing_speed_avg_ms
+    elif not math.isnan(opening_speed_avg_ms):
+        contact_speed_ms = opening_speed_avg_ms
+
+    kpis = [
+        {"name": "Closing Time", "value": float(round(closing_time_ms, 2)) if not math.isnan(closing_time_ms) else None, "unit": "ms"},
+        {"name": "Opening Time", "value": float(round(opening_time_ms, 2)) if not math.isnan(opening_time_ms) else None, "unit": "ms"},
+        {"name": "DLRO Value", "value": float(round(DLRO_uohm, 2)), "unit": "µΩ"},
+        {"name": "Peak Resistance", "value": float(round(peak_resistance_uohm, 2)), "unit": "µΩ"},
+        {"name": "Main Wipe", "value": float(round(main_wipe_mm, 2)) if not math.isnan(main_wipe_mm) else None, "unit": "mm"},
+        {"name": "Arc Wipe", "value": float(round(arc_wipe_mm, 2)) if not math.isnan(arc_wipe_mm) else None, "unit": "mm"},
+        {"name": "Contact Travel Distance", "value": float(round(contact_travel_distance_mm, 2)), "unit": "mm"},
+        {"name": "Contact Speed", "value": float(round(contact_speed_ms, 2)) if contact_speed_ms is not None else None, "unit": "m/s"},
+        {"name": "Peak Close Coil Current", "value": float(round(peak_close_coil_A, 2)), "unit": "A"},
+        {"name": "Peak Trip Coil 1 Current", "value": float(round(peak_trip1_coil_A, 2)), "unit": "A"},
+        {"name": "Peak Trip Coil 2 Current", "value": float(round(peak_trip2_coil_A, 2)), "unit": "A"},
+        {"name": "Ambient Temperature", "value": float(round(ambient_temp_c, 1)), "unit": "°C"},
+    ]
+
+    return {"kpis": kpis}
+
+# ==========================================
+# 3. MAIN INTERFACE
+# ==========================================
+
+def calculate_kpis(df):
+    """
+    Main entry point. Calculates KPIs.
+    Returns a dictionary containing KPIs in the flat format expected by app.py.
+    """
+    result = analyze_breaker_data(df)
+    kpi_list = result['kpis']
+    
+    # Convert list of dicts to flat dict
+    # Expected keys: closing_time, opening_time, dlro, peak_resistance, main_wipe, arc_wipe, 
+    # contact_travel, contact_speed, peak_close_coil, peak_trip_coil_1, peak_trip_coil_2, ambient_temp
+    
+    flat_kpis = {}
+    
+    key_map = {
+        "Closing Time": "closing_time",
+        "Opening Time": "opening_time",
+        "DLRO Value": "dlro",
+        "Peak Resistance": "peak_resistance",
+        "Main Wipe": "main_wipe",
+        "Arc Wipe": "arc_wipe",
+        "Contact Travel Distance": "contact_travel",
+        "Contact Speed": "contact_speed",
+        "Peak Close Coil Current": "peak_close_coil",
+        "Peak Trip Coil 1 Current": "peak_trip_coil_1",
+        "Peak Trip Coil 2 Current": "peak_trip_coil_2",
+        "Ambient Temperature": "ambient_temp"
+    }
+    
+    for item in kpi_list:
+        name = item['name']
+        value = item['value']
+        if name in key_map:
+            flat_kpis[key_map[name]] = value if value is not None else 0.0
+            
+    # Add default SF6 pressure as it's not in the new logic but used in app
+    flat_kpis["sf6_pressure"] = 7.0
+    
+    return {
+        "kpis": flat_kpis
+    }

core/calculators/rul.py

@@ -0,0 +1,500 @@
+# Previous Name: analysis/rul_calculator.py
+import math
+from typing import Dict, Any
+
+def calculate_rul_and_uncertainty(kpis: Dict, cbhi_score: float, ai_verdict: Dict, phase_data: Dict) -> Dict:
+    """
+    Optimized RUL Calculator with tight bounds and defect-specific degradation.
+    
+    Returns:
+        Dictionary with only 'rulEstimate' and 'uncertainty'
+    """
+    
+    # =========================================================================
+    # 1. INDUSTRIAL CONSTANTS (IEEE C37.10 / IEC 62271-100)
+    # =========================================================================
+    MAX_CYCLES = 10000      # Class M2 rated life
+    HEALTHY_BASELINE = 8500 # Healthy breaker typical RUL
+    MIN_CYCLES = 100        # Absolute floor
+    
+    # Defect Class Degradation Multipliers (1.0 = no impact, lower = worse)
+    # These directly reduce RUL based on detected fault type
+    DEFECT_MULTIPLIERS = {
+        "healthy": 1.0,
+        "main contact wear": 0.35,
+        "arcing contact wear": 0.40,
+        "main contact misalignment": 0.45,
+        "arcing contact misalignment": 0.50,
+        "operating mechanism malfunction": 0.55,
+        "damping system fault": 0.60,
+        "sf6 pressure leakage": 0.30,
+        "linkage obstruction": 0.50,
+        "fixed contact damage": 0.40,
+        "close coil damage": 0.25,
+        "trip coil damage": 0.20,
+        "unknown": 0.70
+    }
+    
+    # Severity-based additional reduction
+    SEVERITY_REDUCTION = {
+        "Critical": 0.50,
+        "High": 0.70,
+        "Medium": 0.85,
+        "Low": 0.95,
+        "None": 1.0
+    }
+    
+    # KPI Critical Thresholds (beyond these = severe degradation)
+    KPI_CRITICAL = {
+        "DLRO Value": {"healthy_max": 70, "warning": 150, "critical": 250, "severe": 350},
+        "Peak Resistance": {"healthy_max": 400, "warning": 600, "critical": 800, "severe": 1000},
+        "Closing Time": {"healthy_max": 100, "warning": 120, "critical": 140, "severe": 160},
+        "Opening Time": {"healthy_max": 45, "warning": 55, "critical": 70, "severe": 90},
+        "Contact Speed": {"healthy_min": 4.0, "healthy_max": 6.5, "warning_dev": 1.0, "critical_dev": 2.0},
+        "Peak Trip Coil 1 Current": {"healthy_min": 3.0, "critical_min": 1.5, "zero": 0.5},
+        "Peak Trip Coil 2 Current": {"healthy_min": 3.0, "critical_min": 1.5, "zero": 0.5},
+        "Peak Close Coil Current": {"healthy_min": 3.0, "critical_min": 1.5, "zero": 0.5},
+    }
+    
+    # =========================================================================
+    # 2. HELPER FUNCTIONS
+    # =========================================================================
+    
+    def clamp(val: float, min_val: float = 0.0, max_val: float = 1.0) -> float:
+        return max(min_val, min(max_val, val))
+    
+    def safe_get(d: Any, *keys, default=None):
+        for key in keys:
+            if isinstance(d, dict):
+                d = d.get(key, default)
+            elif isinstance(d, list) and isinstance(key, int) and 0 <= key < len(d):
+                d = d[key]
+            else:
+                return default
+        return d if d is not None else default
+    
+    def get_defect_multiplier(fault_label: str) -> float:
+        """Get degradation multiplier based on fault label."""
+        label_lower = fault_label.lower().strip()
+        for defect, multiplier in DEFECT_MULTIPLIERS.items():
+            if defect in label_lower or label_lower in defect:
+                return multiplier
+        # Partial matches
+        if "wear" in label_lower:
+            return 0.38
+        if "misalignment" in label_lower:
+            return 0.48
+        if "coil" in label_lower:
+            return 0.22
+        if "mechanism" in label_lower or "damping" in label_lower:
+            return 0.55
+        if "sf6" in label_lower or "pressure" in label_lower or "leak" in label_lower:
+            return 0.30
+        return DEFECT_MULTIPLIERS.get("unknown", 0.70)
+    
+    # =========================================================================
+    # 3. EXTRACT DATA
+    # =========================================================================
+    
+    # Extract KPIs
+    kpis_list = kpis.get("kpis", kpis) if isinstance(kpis, dict) else kpis
+    if isinstance(kpis_list, dict):
+        kpis_list = [{"name": k, "value": v} for k, v in kpis_list.items()]
+    kpi_map = {k.get('name', ''): float(k.get('value', 0)) for k in kpis_list if isinstance(k, dict)}
+    
+    # Extract AI Verdict
+    ai_verdict_data = safe_get(ai_verdict, "aiVerdict", default={})
+    fault_label = safe_get(ai_verdict_data, "faultLabel", default="Unknown")
+    ai_confidence = float(safe_get(ai_verdict_data, "confidence", default=50)) / 100.0
+    ai_severity = safe_get(ai_verdict_data, "severity", default="Low")
+    severity_reason = safe_get(ai_verdict_data, "severityReason", default="")
+    
+    # Extract CBHI components
+    cbhi_components = safe_get(ai_verdict, "cbhi", "overall_health_assessment", default={})
+    
+    # Extract Phase Analysis
+    phases_list = safe_get(phase_data, "phaseWiseAnalysis", default=[])
+    if not isinstance(phases_list, list):
+        phases_list = []
+    
+    # Normalize CBHI
+    cbhi_normalized = clamp(float(cbhi_score) / 100.0)
+    
+    # =========================================================================
+    # 4. DETERMINE IF HEALTHY OR FAULTY
+    # =========================================================================
+    
+    is_healthy = fault_label.lower().strip() == "healthy"
+    
+    # =========================================================================
+    # 5. CALCULATE ELECTRICAL WEAR FACTOR (Contact & Resistance Issues)
+    # =========================================================================
+    
+    electrical_penalties = []
+    
+    # DLRO Analysis (most critical for electrical wear)
+    dlro = kpi_map.get("DLRO Value", 50)
+    if dlro <= 70:
+        electrical_penalties.append(0.0)  # Healthy
+    elif dlro <= 150:
+        electrical_penalties.append(0.15 + 0.15 * (dlro - 70) / 80)
+    elif dlro <= 250:
+        electrical_penalties.append(0.30 + 0.25 * (dlro - 150) / 100)
+    elif dlro <= 350:
+        electrical_penalties.append(0.55 + 0.25 * (dlro - 250) / 100)
+    else:
+        electrical_penalties.append(0.80 + 0.15 * min((dlro - 350) / 150, 1.0))
+    
+    # Peak Resistance Analysis
+    peak_r = kpi_map.get("Peak Resistance", 300)
+    if peak_r <= 400:
+        electrical_penalties.append(0.0)
+    elif peak_r <= 600:
+        electrical_penalties.append(0.10 + 0.15 * (peak_r - 400) / 200)
+    elif peak_r <= 800:
+        electrical_penalties.append(0.25 + 0.20 * (peak_r - 600) / 200)
+    else:
+        electrical_penalties.append(0.45 + 0.25 * min((peak_r - 800) / 400, 1.0))
+    
+    # Coil Current Analysis (Trip Coil failures are CRITICAL)
+    trip1 = kpi_map.get("Peak Trip Coil 1 Current", 5.0)
+    trip2 = kpi_map.get("Peak Trip Coil 2 Current", 5.0)
+    close_coil = kpi_map.get("Peak Close Coil Current", 5.0)
+    
+    # Trip Coil 1 penalty
+    if trip1 < 0.5:
+        electrical_penalties.append(0.70)  # Critical - coil failed
+    elif trip1 < 1.5:
+        electrical_penalties.append(0.50)
+    elif trip1 < 3.0:
+        electrical_penalties.append(0.25)
+    else:
+        electrical_penalties.append(0.0)
+    
+    # Trip Coil 2 penalty
+    if trip2 < 0.5:
+        electrical_penalties.append(0.60)  # Critical - redundancy lost
+    elif trip2 < 1.5:
+        electrical_penalties.append(0.40)
+    elif trip2 < 3.0:
+        electrical_penalties.append(0.20)
+    else:
+        electrical_penalties.append(0.0)
+    
+    # Close Coil penalty
+    if close_coil < 0.5:
+        electrical_penalties.append(0.50)
+    elif close_coil < 1.5:
+        electrical_penalties.append(0.30)
+    elif close_coil < 3.0:
+        electrical_penalties.append(0.15)
+    else:
+        electrical_penalties.append(0.0)
+    
+    # Weighted electrical wear (DLRO has highest weight)
+    electrical_weights = [0.35, 0.20, 0.20, 0.15, 0.10]  # DLRO, Peak_R, Trip1, Trip2, Close
+    electrical_wear = sum(p * w for p, w in zip(electrical_penalties, electrical_weights))
+    
+    # =========================================================================
+    # 6. CALCULATE MECHANICAL WEAR FACTOR (Timing & Mechanism Issues)
+    # =========================================================================
+    
+    mechanical_penalties = []
+    
+    # Closing Time Analysis
+    close_time = kpi_map.get("Closing Time", 85)
+    if close_time <= 100:
+        mechanical_penalties.append(0.0)
+    elif close_time <= 120:
+        mechanical_penalties.append(0.15 + 0.15 * (close_time - 100) / 20)
+    elif close_time <= 140:
+        mechanical_penalties.append(0.30 + 0.25 * (close_time - 120) / 20)
+    else:
+        mechanical_penalties.append(0.55 + 0.25 * min((close_time - 140) / 40, 1.0))
+    
+    # Opening Time Analysis
+    open_time = kpi_map.get("Opening Time", 35)
+    if open_time <= 45:
+        mechanical_penalties.append(0.0)
+    elif open_time <= 55:
+        mechanical_penalties.append(0.15 + 0.15 * (open_time - 45) / 10)
+    elif open_time <= 70:
+        mechanical_penalties.append(0.30 + 0.25 * (open_time - 55) / 15)
+    else:
+        mechanical_penalties.append(0.55 + 0.25 * min((open_time - 70) / 30, 1.0))
+    
+    # Contact Speed Analysis
+    speed = kpi_map.get("Contact Speed", 5.0)
+    if 4.0 <= speed <= 6.5:
+        mechanical_penalties.append(0.0)
+    elif 3.0 <= speed <= 7.5:
+        deviation = max(abs(speed - 4.0), abs(speed - 6.5)) if speed < 4.0 or speed > 6.5 else 0
+        mechanical_penalties.append(0.15 + 0.15 * deviation)
+    else:
+        mechanical_penalties.append(0.50)
+    
+    # Contact Travel Distance Analysis
+    travel = kpi_map.get("Contact Travel Distance", 550)
+    if 500 <= travel <= 600:
+        mechanical_penalties.append(0.0)
+    elif 450 <= travel <= 650:
+        mechanical_penalties.append(0.15)
+    else:
+        mechanical_penalties.append(0.35)
+    
+    # Main/Arc Wipe Analysis
+    main_wipe = kpi_map.get("Main Wipe", 150)
+    arc_wipe = kpi_map.get("Arc Wipe", 15)
+    
+    if main_wipe < 100 or main_wipe > 200:
+        mechanical_penalties.append(0.25)
+    else:
+        mechanical_penalties.append(0.0)
+    
+    if arc_wipe < 10 or arc_wipe > 25:
+        mechanical_penalties.append(0.20)
+    else:
+        mechanical_penalties.append(0.0)
+    
+    # Weighted mechanical wear
+    mech_weights = [0.25, 0.25, 0.20, 0.10, 0.10, 0.10]
+    mechanical_wear = sum(p * w for p, w in zip(mechanical_penalties, mech_weights))
+    
+    # =========================================================================
+    # 7. CALCULATE CBHI COMPONENT IMPACT
+    # =========================================================================
+    
+    component_multipliers = {
+        "Contacts (moving & arcing)": {"weight": 0.40, "High Risk": 0.35, "Medium Risk": 0.60, "Low Risk": 0.85, "Normal": 1.0},
+        "SF6 Gas Chamber": {"weight": 0.25, "High Risk": 0.30, "Medium Risk": 0.55, "Low Risk": 0.80, "Normal": 1.0},
+        "Operating Mechanism": {"weight": 0.20, "High Risk": 0.40, "Medium Risk": 0.65, "Low Risk": 0.85, "Normal": 1.0},
+        "Coil": {"weight": 0.15, "High Risk": 0.25, "Medium Risk": 0.50, "Low Risk": 0.80, "Normal": 1.0}
+    }
+    
+    cbhi_factor = 0.0
+    total_weight = 0.0
+    
+    for component, status in cbhi_components.items():
+        if component in component_multipliers:
+            config = component_multipliers[component]
+            weight = config["weight"]
+            multiplier = config.get(status, 0.70)
+            cbhi_factor += weight * multiplier
+            total_weight += weight
+    
+    if total_weight > 0:
+        cbhi_factor = cbhi_factor / total_weight
+    else:
+        cbhi_factor = cbhi_normalized
+    
+    # =========================================================================
+    # 8. CALCULATE PHASE CONFIDENCE IMPACT
+    # =========================================================================
+    
+    phase_weights = {
+        "Pre-Contact Travel": 0.10,
+        "Arcing Contact Engagement & Arc Initiation": 0.25,
+        "Main Contact Conduction": 0.35,
+        "Main Contact Parting & Arc Elongation": 0.20,
+        "Final Open State": 0.10
+    }
+    
+    phase_factor = 0.0
+    phase_total_weight = 0.0
+    critical_phase_failure = False
+    
+    for phase in phases_list:
+        conf = float(safe_get(phase, "confidence", default=75))
+        name = safe_get(phase, "name", default="")
+        
+        weight = 0.15  # Default weight
+        for pname, pw in phase_weights.items():
+            if pname.lower() in name.lower() or name.lower() in pname.lower():
+                weight = pw
+                break
+        
+        # Normalize confidence to factor (0-1)
+        conf_factor = conf / 100.0
+        
+        # Critical phase failure detection
+        if conf < 30:
+            critical_phase_failure = True
+            conf_factor *= 0.5  # Double penalty for critical failure
+        elif conf < 50:
+            conf_factor *= 0.75
+        
+        phase_factor += weight * conf_factor
+        phase_total_weight += weight
+    
+    if phase_total_weight > 0:
+        phase_factor = phase_factor / phase_total_weight
+    else:
+        phase_factor = 0.75
+    
+    # =========================================================================
+    # 9. CALCULATE DEFECT-SPECIFIC DEGRADATION
+    # =========================================================================
+    
+    # Get defect multiplier based on AI verdict
+    defect_multiplier = get_defect_multiplier(fault_label)
+    
+    # Apply severity reduction
+    severity_factor = SEVERITY_REDUCTION.get(ai_severity, 0.85)
+    
+    # Confidence-weighted defect impact
+    # Higher confidence = more trust in the defect diagnosis
+    confidence_weight = 0.3 + 0.7 * ai_confidence  # Range: 0.3-1.0
+    
+    if is_healthy:
+        # Healthy: Use baseline with minor adjustments
+        defect_impact = 1.0 - (1.0 - defect_multiplier) * (1.0 - ai_confidence) * 0.3
+    else:
+        # Faulty: Full defect impact weighted by confidence
+        defect_impact = defect_multiplier * confidence_weight + (1.0 - confidence_weight) * 0.6
+    
+    defect_impact *= severity_factor
+    
+    # =========================================================================
+    # 10. EXTRACT DEVIATION PERCENTAGE FROM SEVERITY REASON
+    # =========================================================================
+    
+    import re
+    deviation_penalty = 0.0
+    if severity_reason:
+        percentages = re.findall(r'(\d+)%', severity_reason)
+        if percentages:
+            max_dev = max(int(p) for p in percentages)
+            if max_dev > 500:
+                deviation_penalty = 0.40
+            elif max_dev > 300:
+                deviation_penalty = 0.30
+            elif max_dev > 150:
+                deviation_penalty = 0.20
+            elif max_dev > 50:
+                deviation_penalty = 0.10
+    
+    # =========================================================================
+    # 11. COMBINE ALL FACTORS INTO FINAL RUL
+    # =========================================================================
+    
+    # Combined wear factor (electrical has higher weight for contact issues)
+    if "contact" in fault_label.lower() or "wear" in fault_label.lower():
+        combined_wear = 0.65 * electrical_wear + 0.35 * mechanical_wear
+    elif "mechanism" in fault_label.lower() or "damping" in fault_label.lower() or "linkage" in fault_label.lower():
+        combined_wear = 0.35 * electrical_wear + 0.65 * mechanical_wear
+    else:
+        combined_wear = 0.50 * electrical_wear + 0.50 * mechanical_wear
+    
+    # Health factor combining all components
+    # Weights: Defect (35%), CBHI (25%), Wear (25%), Phase (15%)
+    health_factor = (
+        0.35 * defect_impact +
+        0.25 * cbhi_factor +
+        0.25 * (1.0 - combined_wear) +
+        0.15 * phase_factor
+    )
+    
+    # Apply deviation penalty
+    health_factor *= (1.0 - deviation_penalty)
+    
+    # Apply critical phase penalty
+    if critical_phase_failure:
+        health_factor *= 0.70
+    
+    # Clamp health factor
+    health_factor = clamp(health_factor, 0.05, 1.0)
+    
+    # Calculate base RUL
+    if is_healthy:
+        base_rul = HEALTHY_BASELINE * health_factor
+    else:
+        # Non-healthy: Start from reduced baseline
+        base_rul = (MAX_CYCLES * 0.6) * health_factor
+    
+    # Apply Weibull-like degradation curve for acceleration
+    beta = 1.3 if is_healthy else 1.6  # Steeper curve for faulty
+    final_rul = base_rul * math.pow(health_factor, beta - 1)
+    
+    # Ensure minimum floor
+    final_rul = max(MIN_CYCLES, min(MAX_CYCLES, final_rul))
+    
+    # =========================================================================
+    # 12. CALCULATE TIGHT UNCERTAINTY BOUNDS
+    # =========================================================================
+    
+    # Base uncertainty factors
+    uncertainty_components = []
+    
+    # Factor 1: AI Confidence uncertainty (inversely proportional)
+    ai_uncertainty = (1.0 - ai_confidence) * 0.08
+    uncertainty_components.append(ai_uncertainty)
+    
+    # Factor 2: Phase confidence variance
+    phase_confs = [float(safe_get(p, "confidence", default=75)) for p in phases_list]
+    if len(phase_confs) >= 2:
+        phase_variance = (max(phase_confs) - min(phase_confs)) / 100.0
+        uncertainty_components.append(phase_variance * 0.06)
+    
+    # Factor 3: CBHI vs AI discrepancy
+    cbhi_health = cbhi_factor
+    ai_health = defect_impact
+    discrepancy = abs(cbhi_health - ai_health)
+    uncertainty_components.append(discrepancy * 0.05)
+    
+    # Factor 4: KPI spread (how many KPIs are in warning/critical range)
+    warning_count = 0
+    for name, val in kpi_map.items():
+        if name == "DLRO Value" and val > 100:
+            warning_count += 1
+        if name == "Closing Time" and val > 110:
+            warning_count += 1
+        if name == "Opening Time" and val > 50:
+            warning_count += 1
+        if name in ["Peak Trip Coil 1 Current", "Peak Trip Coil 2 Current"] and val < 2.0:
+            warning_count += 1
+    uncertainty_components.append(warning_count * 0.025)
+    
+    # Base irreducible uncertainty (5%)
+    base_uncertainty_ratio = 0.05
+    
+    # Total uncertainty ratio
+    total_uncertainty_ratio = base_uncertainty_ratio + sum(uncertainty_components)
+    total_uncertainty_ratio = clamp(total_uncertainty_ratio, 0.08, 0.25)  # Tight bounds: 8-25%
+    
+    # Calculate uncertainty value
+    uncertainty_value = final_rul * total_uncertainty_ratio
+    
+    # Round to sensible values
+    uncertainty_value = int(round(uncertainty_value / 25) * 25)
+    uncertainty_value = max(50, min(uncertainty_value, int(final_rul * 0.30)))
+    
+    # =========================================================================
+    # 13. CALCULATE FINAL RANGE
+    # =========================================================================
+    
+    estimated_cycles = int(round(final_rul / 10) * 10)
+    low_range = max(MIN_CYCLES, estimated_cycles - uncertainty_value)
+    high_range = min(MAX_CYCLES, estimated_cycles + uncertainty_value)
+    
+    # Ensure reasonable gap (minimum 10% of estimate or 100 cycles)
+    min_gap = max(100, int(estimated_cycles * 0.10))
+    if high_range - low_range < min_gap:
+        mid = (low_range + high_range) // 2
+        low_range = max(MIN_CYCLES, mid - min_gap // 2)
+        high_range = min(MAX_CYCLES, mid + min_gap // 2)
+    
+    # Safety checks
+    if low_range >= high_range:
+        low_range = max(MIN_CYCLES, high_range - min_gap)
+    
+    # Ensure estimate is within range
+    estimated_cycles = clamp(estimated_cycles, low_range, high_range)
+    
+    # =========================================================================
+    # 14. RETURN SIMPLIFIED OUTPUT
+    # =========================================================================
+    
+    return {
+        "rulEstimate": f"{low_range}-{high_range} cycles",
+        "uncertainty": f"±{uncertainty_value} cycles"
+    }

core/engines/advanced_rules.py

@@ -0,0 +1,399 @@
+# Previous Name: analysis/engines/advanced_rule_engine.py
+import numpy as np
+import pandas as pd
+import json
+import sys
+from scipy.signal import savgol_filter, find_peaks, welch
+from scipy.stats import skew, kurtosis
+from scipy.integrate import simpson
+
+# Set UTF-8 encoding for console output
+if sys.stdout.encoding != 'utf-8':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+class AdvancedDCRMEngine:
+    """
+    Top-Notch Advanced Rule-Based DCRM Engine
+    =========================================
+    Combines Physics-Based Signal Processing (Scipy) with Expert Heuristic Logic.
+    
+    Features:
+    - 12-Class Defect Detection (Primary + Secondary)
+    - Evidence-Based Scoring (0-100% Confidence)
+    - Advanced Signal Processing:
+        * Savitzky-Golay Filtering (Noise reduction without edge blurring)
+        * FFT (Mechanical Chatter detection)
+        * Peak Finding (Spike counting, Bounce detection)
+        * Derivative Analysis (Jerk/Stutter detection)
+        * Energy Integration (Arcing Ablation)
+    """
+
+    def __init__(self):
+        # --- CONFIGURATION & THRESHOLDS ---
+        
+        # 1. Signal Processing Config
+        self.SAVGOL_WINDOW = 11       # Window length for smoothing (must be odd)
+        self.SAVGOL_POLYORDER = 2     # Polynomial order
+        
+        # 2. Physics Thresholds (Strict - Industry Standard)
+        self.R_OPEN_THRESHOLD = 1_000_000 # µΩ
+        self.R_MAIN_MAX_HEALTHY = 50.0    # µΩ
+        self.R_MAIN_WARNING = 80.0        # µΩ
+        self.R_MAIN_CRITICAL = 150.0      # µΩ
+        
+        # 3. Wear & Arcing Thresholds
+        self.ARCING_SPIKE_CRITICAL = 8000 # µΩ
+        self.ARCING_SPIKE_SEVERE = 5000   # µΩ
+        self.ARCING_ENERGY_CRITICAL = 2000.0 # Joules
+        
+        # 4. Mechanical Thresholds
+        self.BOUNCE_PROMINENCE = 500      # µΩ
+        self.JERK_THRESHOLD = 500.0       # µΩ/ms^2
+        self.FFT_CHATTER_POWER_THRESHOLD = 100.0
+
+    def analyze(self, df: pd.DataFrame, segments: dict, kpis: dict = None) -> dict:
+        """
+        Main entry point for analysis.
+        
+        Args:
+            df: DataFrame with 'Resistance' column.
+            segments: Dictionary containing phase start/end indices.
+                      Expected keys: 'phase2_start', 'phase2_end', 'phase3_start', 
+                      'phase3_end', 'phase4_start', 'phase4_end'.
+            kpis: Optional dictionary of Key Performance Indicators.
+        """
+        if kpis is None: kpis = {}
+            
+        # 1. Standardize Input
+        df_std = self._standardize_input(df)
+        resistance = df_std['Resistance'].values
+        
+        # 2. Signal Preprocessing (Scipy)
+        try:
+            resistance_smooth = savgol_filter(resistance, self.SAVGOL_WINDOW, self.SAVGOL_POLYORDER)
+        except Exception:
+            resistance_smooth = resistance
+            
+        # Derivatives
+        res_velocity = np.gradient(resistance_smooth)
+        res_acceleration = np.gradient(res_velocity)
+        
+        # 3. Advanced Feature Extraction (Using provided segments)
+        features = self._extract_advanced_features(
+            resistance, resistance_smooth, res_velocity, res_acceleration, segments, kpis
+        )
+        
+        # 4. Heuristic Defect Detection (12 Classes)
+        defects = self._detect_defects(features, kpis)
+        
+        # 5. Construct Report
+        report = self._build_report(features, defects)
+        
+        return report
+
+    def _standardize_input(self, df: pd.DataFrame) -> pd.DataFrame:
+        if 'Resistance' not in df.columns:
+            cols = [c for c in df.columns if 'res' in c.lower() or 'uohm' in c.lower()]
+            if cols: df = df.rename(columns={cols[0]: 'Resistance'})
+            else:
+                non_time = [c for c in df.columns if not c.lower().startswith('t')]
+                if non_time: df = df.rename(columns={non_time[0]: 'Resistance'})
+                else: raise ValueError("Could not identify Resistance column")
+        
+        if df.shape[1] > 100 and df.shape[0] < 10:
+             vals = df.iloc[0].values
+             return pd.DataFrame({'Resistance': vals})
+             
+        return df[['Resistance']].reset_index(drop=True)
+
+    def _extract_advanced_features(self, r_raw, r_smooth, r_vel, r_acc, seg, kpis):
+        """
+        Extracts comprehensive features for heuristic scoring.
+        """
+        features = {}
+        if not seg['valid']:
+            features['valid_data'] = False
+            return features
+        features['valid_data'] = True
+        
+        # --- A. MAIN CONTACT (Phase 3) ---
+        p3_slice = slice(seg['phase3_start'], seg['phase3_end'])
+        r_p3 = r_raw[p3_slice]
+        
+        if len(r_p3) > 0:
+            features['main_mean'] = float(np.mean(r_p3))
+            features['main_std'] = float(np.std(r_p3))
+            features['main_min'] = float(np.min(r_p3))
+            features['main_max'] = float(np.max(r_p3))
+            features['main_range'] = float(features['main_max'] - features['main_min'])
+            
+            # Detrend for roughness analysis
+            x = np.arange(len(r_p3))
+            p = np.polyfit(x, r_p3, 1)
+            detrended = r_p3 - np.polyval(p, x)
+            
+            features['roughness_rms'] = float(np.sqrt(np.mean(detrended**2)))
+            features['roughness_skew'] = float(skew(detrended)) if len(detrended) > 2 else 0
+            features['roughness_kurtosis'] = float(kurtosis(detrended)) if len(detrended) > 2 else 0
+            
+            # FFT for Chatter (50-300Hz)
+            if len(detrended) > 32:
+                freqs, psd = welch(detrended, fs=1000)
+                chatter_band = (freqs >= 50) & (freqs <= 300)
+                features['chatter_power'] = float(simpson(psd[chatter_band], freqs[chatter_band]))
+            else:
+                features['chatter_power'] = 0.0
+                
+            # Telegraph Noise (Square Jumps)
+            diffs = np.abs(np.diff(r_p3))
+            features['telegraph_jumps'] = int(np.sum(diffs > 120)) # Jump > 120uOhm
+            
+            # Shelf Detection (Histogram)
+            hist, _ = np.histogram(r_p3, bins=10)
+            features['num_shelves'] = int(np.sum(hist > len(r_p3)*0.1)) # Bins with >10% data
+            
+        else:
+            features.update({'main_mean': 9999, 'roughness_rms': 0, 'chatter_power': 0, 'telegraph_jumps': 0})
+
+        # --- B. ARCING ZONES (Phase 2 & 4) ---
+        test_current = kpis.get('Test Current (A)', 100.0)
+        
+        # Closing Arc
+        p2_slice = slice(seg['phase2_start'], seg['phase2_end'])
+        r_p2 = r_raw[p2_slice]
+        features['closing_arc_duration'] = len(r_p2)
+        if len(r_p2) > 0:
+            power_p2 = (test_current ** 2) * r_p2 * 1e-6
+            features['closing_arc_energy_joules'] = float(np.sum(power_p2) * 0.001)
+            features['closing_critical_spikes'] = int(np.sum(r_p2 > self.ARCING_SPIKE_CRITICAL))
+            features['closing_severe_spikes'] = int(np.sum(r_p2 > self.ARCING_SPIKE_SEVERE))
+        else:
+            features.update({'closing_arc_energy_joules': 0, 'closing_critical_spikes': 0, 'closing_severe_spikes': 0})
+
+        # Opening Arc
+        p4_slice = slice(seg['phase4_start'], seg['phase4_end'])
+        r_p4 = r_raw[p4_slice]
+        features['opening_arc_duration'] = len(r_p4)
+        if len(r_p4) > 0:
+            power_p4 = (test_current ** 2) * r_p4 * 1e-6
+            features['opening_arc_energy_joules'] = float(np.sum(power_p4) * 0.001)
+            features['opening_critical_spikes'] = int(np.sum(r_p4 > self.ARCING_SPIKE_CRITICAL))
+            features['opening_severe_spikes'] = int(np.sum(r_p4 > self.ARCING_SPIKE_SEVERE))
+            
+            # Bounce Detection (Find Peaks)
+            peaks, _ = find_peaks(r_p4, prominence=self.BOUNCE_PROMINENCE, distance=5)
+            features['num_bounces'] = len(peaks)
+            
+            # Telegraph in Arcing
+            features['arcing_telegraph'] = int(np.sum(np.abs(np.diff(r_p4)) > 400))
+        else:
+            features.update({'opening_arc_energy_joules': 0, 'opening_critical_spikes': 0, 'opening_severe_spikes': 0, 'num_bounces': 0, 'arcing_telegraph': 0})
+            
+        # --- C. KINEMATICS ---
+        features['dur_closing'] = len(r_p2)
+        features['dur_opening'] = len(r_p4)
+        features['asymmetry_ratio'] = float(features['dur_opening'] / max(1, features['dur_closing']))
+        
+        acc_p3 = r_acc[p3_slice] if len(r_p3) > 0 else []
+        features['max_micro_jerk'] = float(np.max(np.abs(acc_p3))) if len(acc_p3) > 0 else 0.0
+
+        return features
+
+    def _detect_defects(self, f, kpis):
+        """
+        Applies Heuristic Scoring Logic for 12 Defect Classes.
+        Returns list of defects with 'Confidence' and 'Evidence'.
+        """
+        defects = []
+        if not f['valid_data']: return defects
+        
+        # --- CLASS 1: HEALTHY (Implicit - if no defects found) ---
+        
+        # --- CLASS 2: MAIN CONTACT WEAR ---
+        score = 0
+        evidence = []
+        if f['main_mean'] > self.R_MAIN_CRITICAL:
+            score += 50; evidence.append(f"Critical Resistance ({f['main_mean']:.1f} µΩ)")
+        elif f['main_mean'] > self.R_MAIN_WARNING:
+            score += 30; evidence.append(f"Elevated Resistance ({f['main_mean']:.1f} µΩ)")
+            
+        if f['roughness_rms'] > 25:
+            score += 25; evidence.append(f"Severe Surface Roughness (RMS {f['roughness_rms']:.1f})")
+        elif f['roughness_rms'] > 15:
+            score += 15; evidence.append(f"Moderate Roughness (RMS {f['roughness_rms']:.1f})")
+            
+        if f['roughness_skew'] > 1.5:
+            score += 10; evidence.append("Positive Skew indicates pitting")
+            
+        if score > 40:
+            defects.append(self._make_defect("Main Contact Wear", score, evidence))
+            
+        # --- CLASS 3: ARCING CONTACT WEAR ---
+        score = 0
+        evidence = []
+        total_spikes = f['closing_critical_spikes'] + f['opening_critical_spikes']
+        total_energy = f['closing_arc_energy_joules'] + f['opening_arc_energy_joules']
+        
+        if total_spikes >= 4:
+            score += 50; evidence.append(f"{total_spikes} Critical Arc Flashes (>8000µΩ)")
+        elif f['closing_severe_spikes'] + f['opening_severe_spikes'] >= 3:
+            score += 40; evidence.append("Multiple Severe Spikes (>5000µΩ)")
+            
+        if total_energy > self.ARCING_ENERGY_CRITICAL:
+            score += 30; evidence.append(f"Critical Arc Energy ({total_energy:.1f} J)")
+            
+        if score > 40:
+            defects.append(self._make_defect("Arcing Contact Wear", score, evidence))
+            
+        # --- CLASS 4: MAIN CONTACT MISALIGNMENT ---
+        score = 0
+        evidence = []
+        if f['telegraph_jumps'] >= 6:
+            score += 45; evidence.append(f"Telegraph Pattern: {f['telegraph_jumps']} square jumps")
+        elif f['telegraph_jumps'] >= 3:
+            score += 25; evidence.append(f"Partial Telegraph: {f['telegraph_jumps']} jumps")
+            
+        if f['num_shelves'] >= 3:
+            score += 20; evidence.append(f"Stepped Shelves: {f['num_shelves']} plateaus")
+            
+        if f['main_std'] > 70:
+            score += 15; evidence.append(f"High Instability (Std {f['main_std']:.1f})")
+            
+        if score > 40:
+            defects.append(self._make_defect("Main Contact Misalignment", score, evidence))
+            
+        # --- CLASS 5: ARCING CONTACT MISALIGNMENT ---
+        score = 0
+        evidence = []
+        if f['asymmetry_ratio'] > 2.2:
+            score += 35; evidence.append(f"Severe Asymmetry (Opening {f['asymmetry_ratio']:.1f}x Closing)")
+        elif f['asymmetry_ratio'] > 1.6:
+            score += 20; evidence.append(f"Moderate Asymmetry ({f['asymmetry_ratio']:.1f}x)")
+            
+        if f['num_bounces'] >= 5:
+            score += 30; evidence.append(f"Mechanical Oscillation: {f['num_bounces']} bounces")
+        elif f['num_bounces'] >= 3:
+            score += 15; evidence.append(f"{f['num_bounces']} bounces detected")
+            
+        if f['arcing_telegraph'] > 10:
+            score += 15; evidence.append("High-freq telegraph in arcing zone")
+            
+        if score > 40:
+            defects.append(self._make_defect("Arcing Contact Misalignment", score, evidence))
+            
+        # --- CLASS 6: OPERATING MECHANISM (Timing) ---
+        # Requires KPIs
+        score = 0
+        evidence = []
+        c_time = kpis.get('Closing Time (ms)')
+        o_time = kpis.get('Opening Time (ms)')
+        
+        if c_time and (c_time > 120 or c_time < 64):
+            score += 40; evidence.append(f"Closing Time Deviation ({c_time}ms)")
+        if o_time and (o_time > 48 or o_time < 24):
+            score += 40; evidence.append(f"Opening Time Deviation ({o_time}ms)")
+            
+        if score > 40:
+            defects.append(self._make_defect("Operating Mechanism Malfunction", score, evidence))
+            
+        # --- CLASS 7: DAMPING SYSTEM FAULT ---
+        score = 0
+        evidence = []
+        if f['num_bounces'] > 7:
+            score += 80; evidence.append(f"Excessive Bouncing ({f['num_bounces']} peaks) - Damper failure")
+        elif f['num_bounces'] > 5:
+            score += 50; evidence.append(f"High Bouncing ({f['num_bounces']} peaks)")
+            
+        if score > 40:
+            defects.append(self._make_defect("Damping System Fault", score, evidence))
+            
+        # --- CLASS 9: LINKAGE/ROD OBSTRUCTION ---
+        score = 0
+        evidence = []
+        if f['max_micro_jerk'] > self.JERK_THRESHOLD:
+            score += 60; evidence.append(f"High Kinematic Jerk ({f['max_micro_jerk']:.1f}) - Stick-slip friction")
+            
+        if score > 40:
+            defects.append(self._make_defect("Linkage/Rod Obstruction", score, evidence))
+            
+        # --- CLASS 10: FIXED CONTACT DAMAGE ---
+        score = 0
+        evidence = []
+        dlro = kpis.get('DLRO Value (µΩ)')
+        if dlro and dlro > 80 and f['roughness_rms'] < 15:
+            # High resistance but smooth curve = Fixed contact issue
+            score += 85; evidence.append(f"High DLRO ({dlro}µΩ) with Smooth Curve (Fixed Contact)")
+            
+        if score > 40:
+            defects.append(self._make_defect("Fixed Contact Damage", score, evidence))
+            
+        # --- CLASS 11/12: COIL DAMAGE ---
+        # Simple threshold checks
+        cc = kpis.get('Peak Close Coil Current (A)')
+        if cc and cc < 2.0:
+            defects.append(self._make_defect("Close Coil Damage", 95, [f"Current {cc}A < 2A"]))
+            
+        tc1 = kpis.get('Peak Trip Coil 1 Current (A)')
+        tc2 = kpis.get('Peak Trip Coil 2 Current (A)')
+        if tc1 and tc2 and tc1 < 2.0 and tc2 < 2.0:
+            defects.append(self._make_defect("Trip Coil Damage", 95, [f"Both Coils Failed (TC1:{tc1}A, TC2:{tc2}A)"]))
+
+        return defects
+
+    def _make_defect(self, name, score, evidence):
+        return {
+            "defect_name": name,
+            "Confidence": f"{min(99.9, score):.1f} %",
+            "Severity": "High" if score > 70 else "Medium",
+            "description": "; ".join(evidence)
+        }
+
+    def _build_report(self, features, defects):
+        """Constructs the final JSON report."""
+        
+        # Calculate Overall Health Score
+        health_score = 100
+        for d in defects:
+            sev = d['Severity']
+            if sev == 'High': health_score -= 30
+            elif sev == 'Medium': health_score -= 15
+            
+        health_score = max(0, health_score)
+        status = "Healthy"
+        if health_score < 50: status = "Critical"
+        elif health_score < 80: status = "Warning"
+        
+        # Sort defects by confidence
+        defects.sort(key=lambda x: float(x['Confidence'].replace('%','')), reverse=True)
+        
+        return {
+            "Fault_Detection": defects,
+            "advanced_analysis": {
+                "health_score": health_score,
+                "status": status,
+                "physics_metrics": {
+                    "main_contact_resistance_uohm": round(features.get('main_mean', 0), 2),
+                    "surface_roughness_rms": round(features.get('roughness_rms', 0), 2),
+                    "arc_energy_joules": round(features.get('closing_arc_energy_joules', 0) + features.get('opening_arc_energy_joules', 0), 2),
+                    "mechanical_chatter_power": round(features.get('chatter_power', 0), 2),
+                    "kinematic_jerk_index": round(features.get('max_micro_jerk', 0), 2),
+                    "telegraph_jumps": features.get('telegraph_jumps', 0),
+                    "bounces": features.get('num_bounces', 0)
+                }
+            }
+        }
+
+if __name__ == "__main__":
+    # Test Block
+    t = np.linspace(0, 400, 401)
+    r = np.ones_like(t) * 100000
+    r[100:300] = 40 + np.random.normal(0, 2, 200)
+    # Add synthetic defects
+    r[150:200] += 10 * np.sin(2 * np.pi * 60 * t[150:200]/1000) # Chatter
+    r[305:315] = 4000 # Bounce
+    
+    df = pd.DataFrame({'T_ms': t, 'Resistance': r})
+    
+    engine = AdvancedDCRMEngine()
+    report = engine.analyze(df)
+    print(json.dumps(report, indent=2))

core/engines/diagnostics.py

@@ -0,0 +1,141 @@
+# Previous Name: analysis/advanced_diagnostics.py
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import base64
+import json
+from langchain_core.messages import HumanMessage
+import streamlit as st
+
+def get_defect_prompt(data_str):
+    return f"""
+    System Role: Principal DCRM & Kinematic Analyst
+    Role:
+    You are an expert High-Voltage Circuit Breaker Diagnostician. Your task is to interpret Dynamic Contact Resistance (DCRM) traces to detect specific electrical and mechanical faults.
+    
+    Critical "Anti-Overfitting" Directive:
+    You must distinguish between Systematic Defects and Artifacts.
+    True Degradation: Flag issues only when the visual signature is statistically significant and exceeds the "noise floor."
+    
+    Capability:
+    Identify Multiple Concurrent Issues if present. (e.g., A breaker can have both misalignment and contact wear).
+    there will mostly be 3 line charts in the input
+    green resistance profile
+    blue current profile 
+    red travel profile
+    
+    Data (Sampled): {data_str}
+    
+    1. Diagnostic Heuristics & Defect Taxonomy
+    Map the visual DCRM trace to ONLY the following defect types. Use the specific Visual Heuristics to confirm detection.
+    
+    Defect Type | Visual Heuristic (The "Hint") | Mechanical Significance (Root Cause)
+    --- | --- | ---
+    Main Contact Issue (Corrosion/Oxidation) | "The Significant Grass"<br>In the fully closed plateau, look for pronounced, erratic instability. <br>• Ignore: Uniform, low-amplitude fuzz (sensor noise).<br>• Flag: Jagged, irregular peaks/valleys with significant amplitude (e.g., > 15–20 μΩ variance). The trace looks like a "rough rocky road," not just a "gravel path." | Surface Pathology: The Silver (Ag) plating is compromised (fretting corrosion) or heavy oxidation has occurred. The current path is constantly shifting through microscopic non-conductive spots.
+    Arcing Contact Wear | "Big Spikes & Short Wipe"<br>Resistance spikes are frequent and significantly large (high amplitude). Crucially, the duration of the arcing zone (the time between first touch and main contact touch) is noticeably shorter than expected. | Ablation: The Tungsten-Copper (W-Cu) tips are heavily eroded. The contact length has physically diminished, risking failure to commutate current during opening.
+    Misalignment (Main) | "The Struggle to Settle"<br>There are significant, high-amplitude peaks just before the trace tries to settle into the stable plateau. These are not bounces; they are "struggles" to mate that persist longer than 3-5ms. | Mechanical Centering: The moving contact pin is hitting the side or edge of the stationary rosette fingers before forcing its way in. Caused by loose nuts, kinematic play, or guide ring failure.
+    Misalignment (Arcing) | "Rough Entry"<br>Erratic resistance spikes occurring specifically during the initial entry (commutation), well before the main contacts engage. | Tip Eccentricity: The arcing pin is not entering the nozzle concentrically. It is scraping the nozzle throat or hitting the side, indicating a bent rod or skewed interrupter.
+    Slow Mechanism | "Stretched Time"<br>The entire resistance profile is elongated along the X-axis. Events happen later than normal. | Energy Starvation: Low spring charge, hydraulic pressure loss, or high friction due to hardened grease in the linkage.
+    
+    2. Analysis Logic (The "Signal-to-Noise" Filter)
+    Before declaring a defect, run these logic checks:
+    The "Noise Floor" Test (For Main Contacts):
+    Is the plateau variance uniform and small (< 10 μΩ)? -> Classify as Healthy (Sensor/Manufacturing artifact).
+    Is the variance erratic, jagged, and large (> 15 μΩ)? -> Classify as Corrosion/Oxidation.
+    The "Duration" Test (For Misalignment):
+    Are the pre-plateau peaks < 2ms? -> Ignore (Benign Bounce).
+    Do the peaks persist > 3-5ms before settling? -> Classify as Misalignment.
+    The "Combination" Check:
+    Does the trace show both "Rough Entry" AND "Stretched Time"? -> Report Both (Misalignment + Slow Mechanism).
+    
+    3. Output Structure
+    Provide a concise Executive Lead followed by the JSON.
+    
+    Executive Lead (3-4 Lines)
+    Status: Healthy | Warning | Critical.
+    Key Findings: Summary of valid defects found (ignoring sensor noise).
+    Action: "Return to service" or specific repair instruction.
+    
+    JSON Schema
+    Return ONLY this JSON object:
+    {{
+      "image_url": "string",
+      "overall_condition": "Healthy|Warning|Critical",
+      "executive_lead": "string (The 3-4 line summary)",
+      "detected_issues": [
+        {{
+          "issue_type": "Main Contact Issue (Corrosion/Oxidation)|Arcing Contact Wear|Misalignment (Main)|Misalignment (Arcing)|Slow Mechanism",
+          "confidence": "High|Medium|Low",
+          "visual_evidence": "string (e.g., 'Plateau instability >20 micro-ohms detected, exceeding sensor noise threshold.')",
+          "mechanical_significance": "string (Root cause from table)",
+          "severity": "Low|Medium|High"
+        }}
+      ],
+      "analysis_metrics": {{
+        "static_resistance_Rp_uOhm": "float",
+        "signal_noise_level": "Low (Sensor/Mfg)|High (Defect)",
+        "wipe_quality": "Normal|Short|Erratic"
+      }},
+      "maintenance_recommendation": "string"
+    }}
+    """
+
+def perform_defect_analysis(df, llm):
+    """
+    Performs advanced defect analysis using the specialized DCRM prompt.
+    """
+    try:
+        # 1. Prepare Text Data
+        data_str = df.to_string(index=False)
+        prompt_text = get_defect_prompt(data_str)
+
+        # 2. Prepare Image Data (Simplified for LLM Vision)
+        fig = make_subplots(specs=[[{"secondary_y": True}]])
+        fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Current'], name="Current", line=dict(color='blue')), secondary_y=False)
+        fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Resistance'], name="Resistance", line=dict(color='green')), secondary_y=False)
+        fig.add_trace(go.Scatter(x=df['Time_ms'], y=df['Travel'], name="Travel", line=dict(color='red')), secondary_y=True)
+        fig.update_layout(title="DCRM Graph for Defect Analysis", showlegend=True)
+        
+        # Convert plot to image bytes
+        img_bytes = fig.to_image(format="png", width=1024, height=600)
+        base64_image = base64.b64encode(img_bytes).decode('utf-8')
+
+        # 3. Construct Multimodal Message
+        message = HumanMessage(
+            content=[
+                {"type": "text", "text": prompt_text},
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{base64_image}"}
+                }
+            ]
+        )
+
+        # 4. Invoke LLM
+        response = llm.invoke([message])
+        content = response.content.replace("```json", "").replace("```", "").strip()
+        
+        # Extract JSON part if there's extra text
+        try:
+            start_idx = content.find("{")
+            end_idx = content.rfind("}") + 1
+            if start_idx != -1 and end_idx != -1:
+                json_str = content[start_idx:end_idx]
+                result = json.loads(json_str)
+            else:
+                raise ValueError("No JSON found in response")
+        except json.JSONDecodeError:
+             # Fallback: try to parse the whole content
+             result = json.loads(content)
+
+        return result
+
+    except Exception as e:
+        st.error(f"Defect Analysis failed: {str(e)}")
+        return {
+            "overall_condition": "Unknown",
+            "executive_lead": f"Analysis failed due to error: {str(e)}",
+            "detected_issues": [],
+            "analysis_metrics": {},
+            "maintenance_recommendation": "Check system logs."
+        }

core/engines/rules.py

@@ -0,0 +1,1328 @@
+# Previous Name: analysis/engines/rule_engine.py
+import pandas as pd
+import numpy as np
+import json
+import sys
+from scipy.signal import find_peaks
+
+# Set UTF-8 encoding for console output (handles µ, Ω, etc.)
+if sys.stdout.encoding != 'utf-8':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+# ============================================================================
+# PHYSICS-BASED CONSTANTS (Ultra-Optimized for Real-Life DCRM Analysis)
+# ============================================================================
+
+# Phase Detection Thresholds (Industry-Calibrated)
+R_OPEN_THRESHOLD = 1_000_000      # Above this = Open Circuit (Phase 1 & 5)
+R_ARCING_THRESHOLD = 1000         # Intermediate resistance = Arcing Phase (Phase 2 & 4)
+R_MAIN_THRESHOLD = 600            # Below this = Main Contact Zone (Phase 3)
+
+# Nominal Healthy Values (Real-World Calibrated)
+R_HEALTHY_MEAN_IDEAL = 35         # Ideal healthy: ~20-50 µΩ
+R_HEALTHY_MAX = 70                # STRICT: >70 µΩ = early wear
+R_HEALTHY_STD_MAX = 15            # Healthy std deviation < 15 µΩ (very smooth)
+
+# Main Contact Wear Thresholds (Physics-Based Progressive Scale)
+R_WEAR_EARLY_MIN = 70             # Mean > 70 µΩ = early wear (preventive)
+R_WEAR_MODERATE_MIN = 100         # Mean > 100 µΩ = moderate wear
+R_WEAR_SEVERE_MIN = 180           # Mean > 180 µΩ = severe wear
+R_WEAR_CRITICAL_MIN = 280         # Mean > 280 µΩ = critical wear (imminent failure)
+WEAR_STD_EARLY = 15               # Std > 15 µΩ = surface roughness
+WEAR_STD_MODERATE = 25            # Std > 25 µΩ = noisy/grassy wear
+WEAR_STD_SEVERE = 45              # Std > 45 µΩ = severe pitting/erosion
+
+# Main Contact Misalignment (Square-Wave/Telegraph Pattern)
+MISALIGNMENT_JUMP_MIN = 120       # Telegraph jump > 120 µΩ (square wave edge)
+MISALIGNMENT_COUNT_MIN = 6        # Must have >= 6 distinct square-wave jumps
+MISALIGNMENT_JUMP_RATIO = 0.15    # Affects >= 15% of main contact duration
+MISALIGNMENT_STD_MIN = 70         # Std deviation > 70 µΩ for telegraph
+SHELF_DETECTION_THRESHOLD = 80    # Mid-transition shelf > 80 µΩ
+SQUARE_WAVE_DUTY_CYCLE = 0.3      # Square wave duty cycle check
+
+# Arcing Contact Wear (Spike/Impulse Detection)
+ARCING_SPIKE_CRITICAL = 8000      # Critical spike > 8000 µΩ (arc flash)
+ARCING_SPIKE_SEVERE = 5000        # Severe spike > 5000 µΩ
+ARCING_SPIKE_MODERATE = 3000      # Moderate spike > 3000 µΩ
+ARCING_SPIKE_COUNT_CRITICAL = 4   # >= 4 critical spikes
+ARCING_SPIKE_COUNT_SEVERE = 3     # >= 3 severe spikes
+ARCING_INSTABILITY_STD = 700      # High std in arcing zones
+SPIKE_WIDTH_THRESHOLD = 3         # Spike width > 3 samples = sustained arc
+
+# Arcing Contact Misalignment (Asymmetry + Sinusoidal Bounce)
+ASYMMETRY_RATIO_MODERATE = 1.6    # Opening/Closing ratio > 1.6
+ASYMMETRY_RATIO_SEVERE = 2.2      # Ratio > 2.2 = severe asymmetry
+ASYMMETRY_RATIO_CRITICAL = 3.0    # Ratio > 3.0 = critical misalignment
+BOUNCE_PROMINENCE = 500           # Bounce/rounded peak > 500 µΩ
+BOUNCE_SINUSOIDAL_FREQ = 10       # Sinusoidal frequency (samples per cycle)
+PHASE3_REDUCTION_RATIO = 0.65     # Phase 3 < 65% of expected = reduced contact
+
+# ============================================================================
+# KPI THRESHOLDS FOR CLASSES 6-12 (Secondary Mechanical & Coil Defects)
+# ============================================================================
+
+# Class 6: Operating Mechanism Malfunction (Timing/Speed)
+CLOSING_TIME_NOM = (80, 100)      # ms
+OPENING_TIME_NOM = (30, 40)       # ms
+CONTACT_SPEED_NOM = (4.5, 6.5)    # m/s
+TIMING_DEVIATION_THRESHOLD = 0.20 # >20% off nominal
+
+# Class 7: Damping System Fault (Bouncing)
+BOUNCE_COUNT_THRESHOLD = 5        # >5 distinct bounces
+BOUNCE_AMPLITUDE = 100            # >100 µΩ amplitude
+
+# Class 8: SF6 Pressure Leakage
+SF6_PRESSURE_NOM = (5.5, 6.5)     # bar
+SF6_PRESSURE_CRITICAL = 5.0       # <5.0 bar = leak
+ARC_QUENCH_DURATION_MAX = 25      # >25 ms = prolonged arc
+
+# Class 9: Linkage/Rod Obstruction
+STUTTER_COUNT_MIN = 3             # >3 distinct stutters
+STUTTER_DURATION_MIN = 10         # >10 ms flat plateau
+
+# Class 10: Fixed Contact Damage
+DLRO_HEALTHY_MAX = 50             # <50 µΩ healthy
+DLRO_MODERATE = 80                # 50-80 µΩ moderate
+DLRO_CRITICAL = 100               # >100 µΩ critical
+FIXED_CONTACT_STD_MAX = 15        # <15 µΩ = smooth (not wear)
+
+# Class 11/12: Coil Damage
+CLOSE_COIL_CURRENT_MIN = 2.0      # <2A = failure
+TRIP_COIL_CURRENT_MIN = 2.0       # <2A = failure (both coils)
+COIL_CURRENT_NOM = (4.0, 7.0)     # Normal: 4-7A
+
+
+
+def standardize_input(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Returns a DataFrame with one row and columns T_0...T_400 containing Resistance values (uOhm).
+    Supports vertical (>=401 rows, 1 col 'Resistance') or horizontal (>=401 cols).
+    """
+    if 'Resistance' not in df.columns:
+        raise KeyError("CSV must contain a 'Resistance' column.")
+
+    df = df[['Resistance']]
+
+    # Vertical data (e.g., 401+ rows, single column)
+    if df.shape[0] >= 401 and df.shape[1] == 1:
+        values = df.iloc[:401, 0].values.reshape(1, -1)
+        cols = [f"T_{i}" for i in range(401)]
+        return pd.DataFrame(values, columns=cols)
+
+    # Horizontal data (already a single row with many columns)
+    elif df.shape[1] >= 401:
+        df = df.iloc[:, :401]
+        df.columns = [f"T_{i}" for i in range(401)]
+        return df
+
+    else:
+        raise ValueError(f"Input shape {df.shape} invalid. Expected 401 Resistance points.")
+    
+
+def analyze_dcrm_advanced(row_values, kpis=None):
+    """
+    Production-Grade DCRM Analysis Engine with Full KPI Support
+    ============================================================
+    Detects ALL 12 defect classes:
+    1. Healthy
+    2. Main Contact Wear
+    3. Arcing Contact Wear
+    4. Main Contact Misalignment
+    5. Arcing Contact Misalignment
+    6. Operating Mechanism Malfunction
+    7. Damping System Fault
+    8. SF6 Pressure Leakage
+    9. Linkage/Rod Obstruction
+    10. Fixed Contact Damage
+    11. Close Coil Damage
+    12. Trip Coil Damage
+    
+    Args:
+        row_values: DCRM waveform (401 time points, resistance in µΩ)
+        kpis: Optional dictionary with KPIs (Closing Time, Opening Time, Contact Speed, 
+              SF6 Pressure, DLRO, Close Coil Current, Trip Coil 1/2 Currents, etc.)
+    
+    Returns: 
+        JSON with ALL defects having confidence >75% (Gemini-style dual-agent output)
+        + classifications array with confidence scores for all 12 classes
+    """
+    arr = np.array(row_values, dtype=float)
+    
+    # Default KPIs if not provided
+    if kpis is None:
+        kpis = {}
+    
+    # === PHASE 1: AUTOMATIC PHASE DETECTION ===
+    phases = detect_five_phases(arr)
+    
+    if phases is None:
+        return {
+            "Fault_Detection": [_build_result(
+                "Open Circuit or Invalid Data", 
+                "100.00 %", 
+                "Critical", 
+                "Breaker did not close properly or data is corrupted"
+            )],
+            "overall_health_assessment": {
+                "Contacts (moving & arcing)": "High Risk",
+                "SF6 Gas Chamber": "Normal",
+                "Operating Mechanism": "High Risk",
+                "Coil": "Normal"
+            }
+        }
+    
+    # Extract phase segments
+    phase1_open = arr[phases['phase1_start']:phases['phase1_end']]
+    phase2_closing = arr[phases['phase2_start']:phases['phase2_end']]
+    phase3_main = arr[phases['phase3_start']:phases['phase3_end']]
+    phase4_opening = arr[phases['phase4_start']:phases['phase4_end']]
+    phase5_open = arr[phases['phase5_start']:phases['phase5_end']]
+    
+    # === PHASE 2: FEATURE EXTRACTION ===
+    features = extract_features(phase3_main, phase2_closing, phase4_opening, phases)
+    
+    # === PHASE 3: PRIMARY FAULT CLASSIFICATION (Classes 1-5, 11-12) ===
+    primary_faults = classify_primary_faults(features, phases, kpis)
+    
+    # === PHASE 4: SECONDARY MECHANICAL FAULT CLASSIFICATION (Classes 6-10) ===
+    secondary_faults = classify_secondary_faults(features, phases, kpis, primary_faults)
+    
+    # === PHASE 5: MERGE AND FILTER (Return ALL defects with probability >50%) ===
+    all_faults = primary_faults + secondary_faults
+    
+    # Filter: Only return defects with probability >50% (convert "XX.XX %" to float)
+    high_prob_faults = []
+    for fault in all_faults:
+        prob_str = fault['Confidence'].replace('%', '').strip()
+        prob_val = float(prob_str)
+        if prob_val > 50.0:
+            high_prob_faults.append(fault)
+    
+    # Sort by probability (highest first)
+    high_prob_faults.sort(key=lambda x: float(x['Confidence'].replace('%', '').strip()), reverse=True)
+    
+    # If no high-probability defects, return Healthy with low score
+    if not high_prob_faults:
+        healthy_desc = f"Insufficient evidence for any specific defect. Main Contact: Mean={features['main_mean']:.1f} µΩ, Std={features['main_std']:.1f} µΩ. All defect probabilities <50%."
+        high_prob_faults.append(_build_result(
+            "Inconclusive",
+            "45.00 %",
+            "Low",
+            healthy_desc
+        ))
+    
+    # === PHASE 6: BUILD OVERALL HEALTH ASSESSMENT (Gemini-style) ===
+    overall_health = {
+        "Contacts (moving & arcing)": "Normal",
+        "SF6 Gas Chamber": "Normal",
+        "Operating Mechanism": "Normal",
+        "Coil": "Normal"
+    }
+    
+    for fault in high_prob_faults:
+        name = fault['defect_name'].lower()
+        severity = fault['Severity'].lower()
+        probability = float(fault['Confidence'].replace('%', '').strip())
+        
+        # Determine risk level based on probability
+        if probability >= 85 and severity in ["high", "critical"]:
+            risk = "High Risk"
+        elif probability >= 70:
+            risk = "Moderate Risk"
+        elif probability >= 50:
+            risk = "Low Risk"
+        else:
+            risk = "Normal"
+        
+        # Map defects to health categories
+        if any(x in name for x in ["main contact", "arcing contact", "contact wear", "contact misalignment", "fixed contact"]):
+            if overall_health["Contacts (moving & arcing)"] != "High Risk":
+                overall_health["Contacts (moving & arcing)"] = risk
+        
+        if "sf6" in name or "pressure" in name:
+            if overall_health["SF6 Gas Chamber"] != "High Risk":
+                overall_health["SF6 Gas Chamber"] = risk
+        
+        if any(x in name for x in ["operating mechanism", "damping", "linkage", "rod"]):
+            if overall_health["Operating Mechanism"] != "High Risk":
+                overall_health["Operating Mechanism"] = risk
+        
+        if "coil" in name:
+            if overall_health["Coil"] != "High Risk":
+                overall_health["Coil"] = risk
+    
+    # === PHASE 7: BUILD CLASSIFICATIONS ARRAY FOR ALL 12 CLASSES ===
+    # Collect all probabilities (convert from all_faults list)
+    class_probabilities = {
+        "Healthy": 0.0,
+        "Main Contact Wear": 0.0,
+        "Arcing Contact Wear": 0.0,
+        "Main Contact Misalignment": 0.0,
+        "Arcing Contact Misalignment": 0.0,
+        "Operating Mechanism Malfunction": 0.0,
+        "Damping System Fault": 0.0,
+        "Pressure System Leakage (SF6 Gas Chamber)": 0.0,
+        "Linkage/Connecting Rod Obstruction/Damage": 0.0,
+        "Fixed Contact Damage/Deformation": 0.0,
+        "Close Coil Damage": 0.0,
+        "Trip Coil Damage": 0.0
+    }
+    
+    # Fill in probabilities from all_faults (including those <50%)
+    for fault in all_faults:
+        name = fault['defect_name']
+        prob_str = fault['Confidence'].replace('%', '').strip()
+        prob_val = float(prob_str) / 100.0  # Convert to 0-1 scale
+        class_probabilities[name] = prob_val
+    
+    # Build classifications array (all 12 classes)
+    classifications = []
+    for class_name, confidence in class_probabilities.items():
+        classifications.append({
+            "Class": class_name,
+            "Confidence": round(confidence, 4)
+        })
+    
+    # === RETURN OPTIMIZED JSON (Probability-Based Scoring) ===
+    result = {
+        "Fault_Detection": high_prob_faults,
+        "overall_health_assessment": overall_health,
+        "classifications": classifications
+    }
+    
+    return result
+
+
+def detect_five_phases(arr):
+    """
+    Automatically detects all 5 DCRM phases using adaptive thresholding.
+    Returns dict with start/end indices for each phase, or None if detection fails.
+    """
+    # Find contact regions (below threshold)
+    is_contact = arr < R_ARCING_THRESHOLD
+    contact_indices = np.where(is_contact)[0]
+    
+    if len(contact_indices) < 20:
+        return None  # No valid contact detected
+    
+    # Identify main contact region (very low resistance)
+    is_main = arr < R_MAIN_THRESHOLD
+    main_indices = np.where(is_main)[0]
+    
+    if len(main_indices) < 5:
+        # No main contact = severe fault
+        # Best effort: assume entire contact is arcing
+        phase1_end = contact_indices[0]
+        phase5_start = contact_indices[-1] + 1
+        
+        return {
+            'phase1_start': 0,
+            'phase1_end': phase1_end,
+            'phase2_start': phase1_end,
+            'phase2_end': contact_indices[-1],
+            'phase3_start': contact_indices[-1],
+            'phase3_end': contact_indices[-1],  # Empty main phase
+            'phase4_start': contact_indices[-1],
+            'phase4_end': phase5_start,
+            'phase5_start': phase5_start,
+            'phase5_end': len(arr)
+        }
+    
+    # Normal case: Main contact exists
+    t_contact_start = contact_indices[0]
+    t_contact_end = contact_indices[-1]
+    t_main_start = main_indices[0]
+    t_main_end = main_indices[-1]
+    
+    return {
+        'phase1_start': 0,
+        'phase1_end': t_contact_start,
+        'phase2_start': t_contact_start,
+        'phase2_end': t_main_start,
+        'phase3_start': t_main_start,
+        'phase3_end': t_main_end,
+        'phase4_start': t_main_end,
+        'phase4_end': t_contact_end + 1,
+        'phase5_start': t_contact_end + 1,
+        'phase5_end': len(arr)
+    }
+
+
+def extract_features(seg_main, seg_closing, seg_opening, phases):
+    """
+    ULTRA-OPTIMIZED Feature Extraction with Micro-Level Waveform Analysis
+    =====================================================================
+    Detects:
+    - Square wave patterns (misalignment)
+    - Sinusoidal oscillations (damping/bounce)
+    - Impulse spikes (arcing wear)
+    - Grassy noise (contact wear)
+    - Telegraph jumps (mechanical defects)
+    - DC offset shifts (fixed contact issues)
+    """
+    features = {}
+    
+    # === MAIN CONTACT FEATURES (Phase 3) - MICRO-LEVEL ANALYSIS ===
+    if len(seg_main) > 0:
+        # Basic statistics
+        features['main_mean'] = float(np.mean(seg_main))
+        features['main_median'] = float(np.median(seg_main))
+        features['main_std'] = float(np.std(seg_main))
+        features['main_min'] = float(np.min(seg_main))
+        features['main_max'] = float(np.max(seg_main))
+        features['main_range'] = float(features['main_max'] - features['main_min'])
+        
+        # === SQUARE WAVE PATTERN DETECTION (Misalignment) ===
+        diffs = np.diff(seg_main)
+        abs_diffs = np.abs(diffs)
+        
+        # Count sharp edges (square wave transitions)
+        sharp_edges = np.sum(abs_diffs > MISALIGNMENT_JUMP_MIN)
+        features['telegraph_jumps'] = int(sharp_edges)
+        features['jump_ratio'] = float(sharp_edges / len(seg_main) if len(seg_main) > 0 else 0)
+        
+        # Detect duty cycle of square wave (time spent at high vs low levels)
+        if features['main_range'] > 100:
+            threshold = features['main_median']
+            high_time = np.sum(seg_main > threshold)
+            duty_cycle = high_time / len(seg_main)
+            features['square_wave_duty'] = float(duty_cycle)
+            # True square wave has duty cycle ~0.3-0.7 (not 0 or 1)
+            features['is_square_wave'] = 1 if 0.2 < duty_cycle < 0.8 else 0
+        else:
+            features['square_wave_duty'] = 0.5
+            features['is_square_wave'] = 0
+        
+        # === SINUSOIDAL/OSCILLATION DETECTION (Damping Fault) ===
+        # Use autocorrelation to detect periodic patterns
+        if len(seg_main) > 20:
+            # Detrend signal
+            detrended = seg_main - np.mean(seg_main)
+            # Simple autocorrelation at lag=10 (typical bounce frequency)
+            if len(detrended) > BOUNCE_SINUSOIDAL_FREQ:
+                autocorr = np.correlate(detrended[:min(100, len(detrended))], 
+                                       detrended[:min(100, len(detrended))], mode='valid')[0]
+                features['oscillation_score'] = float(abs(autocorr) / (np.std(detrended)**2 * len(detrended) + 1))
+            else:
+                features['oscillation_score'] = 0.0
+        else:
+            features['oscillation_score'] = 0.0
+        
+        # === GRASSY NOISE PATTERN (Wear Signature) ===
+        # Count uniform medium-amplitude spikes throughout plateau
+        noise_threshold_low = features['main_median'] + 30
+        noise_threshold_high = features['main_median'] + 200
+        grassy_spikes = np.sum((seg_main > noise_threshold_low) & (seg_main < noise_threshold_high))
+        features['uniform_spikes'] = int(grassy_spikes)
+        features['spike_density'] = float(grassy_spikes / len(seg_main) if len(seg_main) > 0 else 0)
+        
+        # Measure continuous noise level (RMS of derivative)
+        features['avg_noise'] = float(np.mean(abs_diffs))
+        features['max_single_jump'] = float(np.max(abs_diffs)) if len(abs_diffs) > 0 else 0
+        features['noise_rms'] = float(np.sqrt(np.mean(abs_diffs**2)))
+        
+        # === STEPPED SHELF PATTERN (Misalignment Signature) ===
+        if len(seg_main) > 20:
+            # Histogram analysis to find discrete levels
+            hist, edges = np.histogram(seg_main, bins=min(15, len(seg_main)//10))
+            # Count bins with >8% of data (significant plateaus)
+            significant_bins = np.sum(hist > (len(seg_main) * 0.08))
+            features['num_shelves'] = int(significant_bins)
+            
+            # Detect initial transient vs steady-state
+            split_point = min(25, len(seg_main)//3)
+            initial_segment = seg_main[:split_point]
+            plateau_segment = seg_main[split_point:]
+            features['initial_deviation'] = float(np.std(initial_segment))
+            features['plateau_stability'] = float(np.std(plateau_segment))
+            
+            # Initial jump indicator
+            if len(initial_segment) > 0 and len(plateau_segment) > 0:
+                features['has_initial_jump'] = 1 if features['initial_deviation'] > features['plateau_stability'] * 1.8 else 0
+            else:
+                features['has_initial_jump'] = 0
+        else:
+            features['num_shelves'] = 1
+            features['initial_deviation'] = 0
+            features['plateau_stability'] = features['main_std']
+            features['has_initial_jump'] = 0
+            
+    else:
+        # Empty main contact = severe fault
+        features.update({
+            'main_mean': 9999, 'main_median': 9999, 'main_std': 0,
+            'main_min': 9999, 'main_max': 9999, 'main_range': 0,
+            'telegraph_jumps': 0, 'jump_ratio': 0, 'uniform_spikes': 0,
+            'spike_density': 0, 'avg_noise': 0, 'max_single_jump': 0,
+            'noise_rms': 0, 'square_wave_duty': 0, 'is_square_wave': 0,
+            'oscillation_score': 0, 'initial_deviation': 0, 
+            'plateau_stability': 0, 'has_initial_jump': 0, 'num_shelves': 0
+        })
+    
+    # === TIMING FEATURES ===
+    features['dur_closing'] = int(max(1, len(seg_closing)))
+    features['dur_opening'] = int(max(1, len(seg_opening)))
+    features['dur_main'] = int(len(seg_main))
+    features['asymmetry_ratio'] = float(features['dur_opening'] / features['dur_closing'])
+    
+    # Detect reduced Phase 3 (arcing misalignment signature)
+    expected_main_duration = 160  # Typical ~160-180 ms
+    features['phase3_reduction'] = float(features['dur_main'] / expected_main_duration)
+    
+    # === ARCING CONTACT FEATURES - IMPULSE SPIKE ANALYSIS ===
+    
+    features['closing_critical_spikes'] = 0
+    features['closing_severe_spikes'] = 0
+    features['closing_moderate_spikes'] = 0
+    features['opening_critical_spikes'] = 0
+    features['opening_severe_spikes'] = 0
+    features['opening_moderate_spikes'] = 0
+    features['closing_std'] = 0
+    features['opening_std'] = 0
+    features['closing_peak'] = 0
+    features['opening_peak'] = 0
+    
+    # === CLOSING ARCING ZONE ANALYSIS ===
+    if len(seg_closing) > 0:
+        features['closing_critical_spikes'] = int(np.sum(seg_closing > ARCING_SPIKE_CRITICAL))
+        features['closing_severe_spikes'] = int(np.sum(seg_closing > ARCING_SPIKE_SEVERE))
+        features['closing_moderate_spikes'] = int(np.sum(seg_closing > ARCING_SPIKE_MODERATE))
+        features['closing_std'] = float(np.std(seg_closing))
+        features['closing_peak'] = float(np.max(seg_closing))
+        
+        # Analyze spike width (sustained arc vs transient)
+        critical_indices = np.where(seg_closing > ARCING_SPIKE_SEVERE)[0]
+        if len(critical_indices) > 0:
+            # Count sustained spikes (width > threshold)
+            spike_groups = np.split(critical_indices, np.where(np.diff(critical_indices) > 2)[0] + 1)
+            sustained_spikes = sum(1 for group in spike_groups if len(group) >= SPIKE_WIDTH_THRESHOLD)
+            features['closing_sustained_spikes'] = int(sustained_spikes)
+        else:
+            features['closing_sustained_spikes'] = 0
+    else:
+        features['closing_sustained_spikes'] = 0
+    
+    # === OPENING ARCING ZONE ANALYSIS ===
+    if len(seg_opening) > 0:
+        features['opening_critical_spikes'] = int(np.sum(seg_opening > ARCING_SPIKE_CRITICAL))
+        features['opening_severe_spikes'] = int(np.sum(seg_opening > ARCING_SPIKE_SEVERE))
+        features['opening_moderate_spikes'] = int(np.sum(seg_opening > ARCING_SPIKE_MODERATE))
+        features['opening_std'] = float(np.std(seg_opening))
+        features['opening_peak'] = float(np.max(seg_opening))
+        
+        # Spike width analysis
+        critical_indices = np.where(seg_opening > ARCING_SPIKE_SEVERE)[0]
+        if len(critical_indices) > 0:
+            spike_groups = np.split(critical_indices, np.where(np.diff(critical_indices) > 2)[0] + 1)
+            sustained_spikes = sum(1 for group in spike_groups if len(group) >= SPIKE_WIDTH_THRESHOLD)
+            features['opening_sustained_spikes'] = int(sustained_spikes)
+        else:
+            features['opening_sustained_spikes'] = 0
+        
+        # === SINUSOIDAL BOUNCE DETECTION (Arcing Misalignment) ===
+        # Detect rounded/oscillating peaks
+        peaks, properties = find_peaks(seg_opening, prominence=BOUNCE_PROMINENCE, distance=5)
+        features['num_bounces'] = int(len(peaks))
+        
+        # Detect high-frequency telegraph in arcing zone
+        opening_diffs = np.abs(np.diff(seg_opening))
+        features['arcing_telegraph'] = int(np.sum(opening_diffs > 400))
+    else:
+        features['opening_sustained_spikes'] = 0
+        features['num_bounces'] = 0
+        features['arcing_telegraph'] = 0
+    
+    # Add closing telegraph
+    if len(seg_closing) > 10:
+        closing_diffs = np.abs(np.diff(seg_closing))
+        features['arcing_telegraph'] += int(np.sum(closing_diffs > 400))
+    
+    # === TOTAL SPIKE COUNTS (All Severity Levels) ===
+    features['total_critical_spikes'] = features['closing_critical_spikes'] + features['opening_critical_spikes']
+    features['total_severe_spikes'] = features['closing_severe_spikes'] + features['opening_severe_spikes']
+    features['total_moderate_spikes'] = features['closing_moderate_spikes'] + features['opening_moderate_spikes']
+    features['total_sustained_spikes'] = features['closing_sustained_spikes'] + features['opening_sustained_spikes']
+    
+    # Symmetry check (wear = similar spikes; misalignment = asymmetric)
+    if features['closing_severe_spikes'] > 0 and features['opening_severe_spikes'] > 0:
+        spike_ratio = max(features['closing_severe_spikes'], features['opening_severe_spikes']) / \
+                      max(1, min(features['closing_severe_spikes'], features['opening_severe_spikes']))
+        features['spike_symmetry'] = float(spike_ratio)  # ~1.0 = symmetric (wear)
+    else:
+        features['spike_symmetry'] = 1.0
+    
+    return features
+
+
+def classify_primary_faults(features, phases, kpis):
+    """
+    ULTRA-OPTIMIZED Multi-Class PRIMARY Fault Classification with Individual Probability Scores
+    ============================================================================================
+    Returns ALL defects with probability > 50% (independent scores, not cumulative).
+    
+    Scoring Logic:
+    - Each defect gets 0-100% probability based on signature strength
+    - Multiple defects can coexist (e.g., Wear + Misalignment both at 85%)
+    - Scores are NOT normalized (don't sum to 100%)
+    - Only defects >50% probability are returned
+    
+    Classes: 1-Healthy, 2-Main Wear, 3-Arcing Wear, 4-Main Misalign, 
+             5-Arcing Misalign, 11-Close Coil, 12-Trip Coil
+    """
+    all_faults = []
+    
+    # ========================================================================
+    # CLASS 11: CLOSE COIL DAMAGE
+    # ========================================================================
+    close_coil_current = kpis.get('Peak Close Coil Current (A)', None)
+    if close_coil_current is not None:
+        if close_coil_current < CLOSE_COIL_CURRENT_MIN:
+            conf = 95.0
+            sev = "High"
+            desc = f"Close Coil Current critically low ({close_coil_current:.2f} A, normal: 4-7 A). Coil winding damaged or control circuit fault."
+            all_faults.append(_build_result("Close Coil Damage", f"{conf:.2f} %", sev, desc))
+    
+    # ========================================================================
+    # CLASS 12: TRIP COIL DAMAGE
+    # CRITICAL: BOTH trip coils must fail. If at least ONE works, NO FAULT.
+    # ========================================================================
+    trip_coil1 = kpis.get('Peak Trip Coil 1 Current (A)', None)
+    trip_coil2 = kpis.get('Peak Trip Coil 2 Current (A)', None)
+    
+    if trip_coil1 is not None and trip_coil2 is not None:
+        # Check if BOTH coils failed
+        if trip_coil1 < TRIP_COIL_CURRENT_MIN and trip_coil2 < TRIP_COIL_CURRENT_MIN:
+            conf = 95.0
+            sev = "Critical"
+            desc = f"BOTH Trip Coils failed (TC1: {trip_coil1:.2f} A, TC2: {trip_coil2:.2f} A, normal: 4-7 A each). Breaker cannot trip - SAFETY CRITICAL."
+            all_faults.append(_build_result("Trip Coil Damage", f"{conf:.2f} %", sev, desc))
+        # If at least one coil works, NO fault (this is normal redundancy)
+    
+    # ========================================================================
+    # CLASS 5: ARCING CONTACT MISALIGNMENT
+    # Signature: Asymmetric curve + Reduced Phase 3 + Sinusoidal Bounces
+    # Probability Score: 0-100% based on signature strength
+    # ========================================================================
+    arcing_misalign_prob = 0.0
+    arcing_misalign_reasons = []
+    
+    # Factor 1: Timing asymmetry (CRITICAL SIGNATURE - 40 points max)
+    if features['asymmetry_ratio'] > ASYMMETRY_RATIO_CRITICAL:
+        arcing_misalign_prob += 40.0
+        arcing_misalign_reasons.append(f"Critical timing asymmetry: Opening phase {features['asymmetry_ratio']:.2f}x longer than closing (>3.0x indicates severe misalignment)")
+    elif features['asymmetry_ratio'] > ASYMMETRY_RATIO_SEVERE:
+        arcing_misalign_prob += 32.0
+        arcing_misalign_reasons.append(f"Severe timing asymmetry: Opening {features['asymmetry_ratio']:.2f}x longer (>2.2x threshold)")
+    elif features['asymmetry_ratio'] > ASYMMETRY_RATIO_MODERATE:
+        arcing_misalign_prob += 24.0
+        arcing_misalign_reasons.append(f"Moderate asymmetry: Timing ratio {features['asymmetry_ratio']:.2f} (normal <1.5)")
+    
+    # Factor 2: Reduced Phase 3 duration (20 points max)
+    if features['phase3_reduction'] < PHASE3_REDUCTION_RATIO:
+        reduction_pct = (1 - features['phase3_reduction']) * 100
+        arcing_misalign_prob += 20.0
+        arcing_misalign_reasons.append(f"Main contact duration reduced by {reduction_pct:.0f}% ({features['dur_main']} ms vs expected ~160 ms)")
+    elif features['phase3_reduction'] < 0.80:
+        arcing_misalign_prob += 12.0
+        arcing_misalign_reasons.append(f"Slightly reduced contact engagement ({features['dur_main']} ms)")
+    
+    # Factor 3: Sinusoidal bounces (25 points max)
+    if features['num_bounces'] >= 5:
+        arcing_misalign_prob += 25.0
+        arcing_misalign_reasons.append(f"Detected {features['num_bounces']} sinusoidal bounces during opening (indicates mechanical oscillation)")
+    elif features['num_bounces'] >= 3:
+        arcing_misalign_prob += 18.0
+        arcing_misalign_reasons.append(f"{features['num_bounces']} rounded bounces detected")
+    elif features['num_bounces'] >= 1:
+        arcing_misalign_prob += 10.0
+        arcing_misalign_reasons.append(f"{features['num_bounces']} bounce peak(s) in arcing phase")
+    
+    # Factor 4: Telegraph noise in arcing zones (15 points max)
+    if features['arcing_telegraph'] > 15:
+        arcing_misalign_prob += 15.0
+        arcing_misalign_reasons.append(f"High-frequency telegraph noise in arcing zones ({features['arcing_telegraph']} rapid transitions)")
+    elif features['arcing_telegraph'] > 8:
+        arcing_misalign_prob += 10.0
+        arcing_misalign_reasons.append(f"Telegraph noise detected ({features['arcing_telegraph']} events)")
+    
+    if arcing_misalign_prob >= 50.0:
+        prob_str = f"{min(99.0, arcing_misalign_prob):.2f} %"
+        sev = _get_severity(arcing_misalign_prob)
+        desc = ". ".join(arcing_misalign_reasons)
+        all_faults.append(_build_result("Arcing Contact Misalignment", prob_str, sev, desc))
+    
+    # ========================================================================
+    # CLASS 4: MAIN CONTACT MISALIGNMENT
+    # Signature: Square-wave telegraph + Stepped shelves + Initial jump
+    # Probability Score: 0-100% based on signature strength
+    # ========================================================================
+    main_misalign_prob = 0.0
+    main_misalign_reasons = []
+    
+    # Factor 1: Square-wave telegraph pattern (45 points max)
+    if (features['telegraph_jumps'] >= MISALIGNMENT_COUNT_MIN and 
+        features['jump_ratio'] > MISALIGNMENT_JUMP_RATIO and
+        features['main_std'] > MISALIGNMENT_STD_MIN and
+        features['is_square_wave'] == 1):
+        main_misalign_prob += 45.0
+        main_misalign_reasons.append(f"Square-wave telegraph pattern: {features['telegraph_jumps']} sharp jumps (>{MISALIGNMENT_JUMP_MIN} µΩ), duty cycle {features['square_wave_duty']:.2f}")
+    elif features['telegraph_jumps'] >= MISALIGNMENT_COUNT_MIN and features['main_std'] > MISALIGNMENT_STD_MIN:
+        main_misalign_prob += 35.0
+        main_misalign_reasons.append(f"Telegraph pattern detected: {features['telegraph_jumps']} jumps, Std={features['main_std']:.1f} µΩ")
+    elif features['telegraph_jumps'] >= 4:
+        main_misalign_prob += 20.0
+        main_misalign_reasons.append(f"Partial telegraph: {features['telegraph_jumps']} jumps")
+    
+    # Factor 2: Initial deviation/transient jump (20 points max)
+    if features['has_initial_jump'] == 1 and features['initial_deviation'] > 120:
+        main_misalign_prob += 20.0
+        main_misalign_reasons.append(f"High initial transient (Std={features['initial_deviation']:.1f} µΩ) then stabilizes - classic misalignment signature")
+    elif features['has_initial_jump'] == 1:
+        main_misalign_prob += 12.0
+        main_misalign_reasons.append(f"Initial deviation detected ({features['initial_deviation']:.1f} µΩ)")
+    
+    # Factor 3: Stepped shelf transitions (20 points max)
+    if features['num_shelves'] >= 4 and features['main_range'] > SHELF_DETECTION_THRESHOLD:
+        main_misalign_prob += 20.0
+        main_misalign_reasons.append(f"Stepped transitions: {features['num_shelves']} discrete resistance plateaus (range {features['main_range']:.1f} µΩ)")
+    elif features['num_shelves'] >= 3:
+        main_misalign_prob += 12.0
+        main_misalign_reasons.append(f"{features['num_shelves']} resistance shelves detected")
+    
+    # Factor 4: High variability (15 points max)
+    if features['main_std'] > MISALIGNMENT_STD_MIN * 2:
+        main_misalign_prob += 15.0
+        main_misalign_reasons.append(f"Very high variability (Std={features['main_std']:.1f} µΩ, normal <15 µΩ)")
+    elif features['main_std'] > MISALIGNMENT_STD_MIN:
+        main_misalign_prob += 10.0
+        main_misalign_reasons.append(f"Elevated variability (Std={features['main_std']:.1f} µΩ)")
+    
+    if main_misalign_prob >= 50.0:
+        prob_str = f"{min(99.0, main_misalign_prob):.2f} %"
+        sev = _get_severity(main_misalign_prob)
+        desc = ". ".join(main_misalign_reasons)
+        all_faults.append(_build_result("Main Contact Misalignment", prob_str, sev, desc))
+    
+    # ========================================================================
+    # CLASS 2: MAIN CONTACT WEAR
+    # Signature: Elevated resistance + Grassy noise + Uniform spikes
+    # Probability Score: 0-100% based on wear severity
+    # ========================================================================
+    main_wear_prob = 0.0
+    main_wear_reasons = []
+    
+    # Get DLRO value if available
+    dlro_value = kpis.get('DLRO Value (µΩ)', kpis.get('DLRO_Value_uOhm', kpis.get('dlro_uohm', None)))
+    
+    # Factor 1: Elevated resistance (50 points max - MOST CRITICAL)
+    if features['main_mean'] > R_WEAR_CRITICAL_MIN:
+        elevation = ((features['main_mean'] - R_HEALTHY_MEAN_IDEAL) / R_HEALTHY_MEAN_IDEAL) * 100
+        main_wear_prob += 50.0
+        main_wear_reasons.append(f"CRITICAL wear: Resistance {features['main_mean']:.1f} µΩ (healthy: 20-70 µΩ, {elevation:.0f}% above ideal). Severe erosion/material loss detected")
+        if dlro_value is not None and dlro_value > 250:
+            main_wear_prob += 8.0
+            main_wear_reasons.append(f"Confirmed by DLRO: {dlro_value:.1f} µΩ")
+    elif features['main_mean'] > R_WEAR_SEVERE_MIN:
+        elevation = ((features['main_mean'] - R_HEALTHY_MEAN_IDEAL) / R_HEALTHY_MEAN_IDEAL) * 100
+        main_wear_prob += 42.0
+        main_wear_reasons.append(f"SEVERE wear: Resistance {features['main_mean']:.1f} µΩ ({elevation:.0f}% above ideal). Significant contact degradation")
+        if dlro_value is not None and dlro_value > 180:
+            main_wear_prob += 8.0
+            main_wear_reasons.append(f"Confirmed by DLRO: {dlro_value:.1f} µΩ")
+    elif features['main_mean'] > R_WEAR_MODERATE_MIN:
+        main_wear_prob += 32.0
+        main_wear_reasons.append(f"MODERATE wear: Resistance {features['main_mean']:.1f} µΩ (healthy <70 µΩ). Contact wear progressing")
+        if dlro_value is not None and dlro_value > 100:
+            main_wear_prob += 8.0
+            main_wear_reasons.append(f"Confirmed by DLRO: {dlro_value:.1f} µΩ")
+    elif features['main_mean'] > R_WEAR_EARLY_MIN:
+        main_wear_prob += 20.0
+        main_wear_reasons.append(f"EARLY wear signs: Resistance {features['main_mean']:.1f} µΩ (healthy <70 µΩ)")
+        if dlro_value is not None and dlro_value > 70:
+            main_wear_prob += 8.0
+            main_wear_reasons.append(f"DLRO confirms: {dlro_value:.1f} µΩ")
+    
+    # Factor 2: Grassy/noisy pattern - Surface roughness (25 points max)
+    if features['main_std'] > WEAR_STD_SEVERE:
+        main_wear_prob += 25.0
+        main_wear_reasons.append(f"Severe surface roughness: Std={features['main_std']:.1f} µΩ (healthy <15 µΩ). Indicates pitting/erosion")
+    elif features['main_std'] > WEAR_STD_MODERATE:
+        main_wear_prob += 18.0
+        main_wear_reasons.append(f"Moderate roughness: Std={features['main_std']:.1f} µΩ (healthy <15 µΩ)")
+    elif features['main_std'] > WEAR_STD_EARLY:
+        main_wear_prob += 10.0
+        main_wear_reasons.append(f"Surface roughness detected: Std={features['main_std']:.1f} µΩ")
+    
+    # Factor 3: Uniform grassy spikes throughout plateau (15 points max)
+    if features['spike_density'] > 0.35:
+        main_wear_prob += 15.0
+        main_wear_reasons.append(f"Dense uniform spikes: {features['uniform_spikes']} spikes ({features['spike_density']*100:.1f}% density). Classic wear signature")
+    elif features['spike_density'] > 0.20:
+        main_wear_prob += 10.0
+        main_wear_reasons.append(f"Grassy pattern: {features['uniform_spikes']} spikes detected")
+    elif features['uniform_spikes'] > 10:
+        main_wear_prob += 5.0
+        main_wear_reasons.append(f"{features['uniform_spikes']} noise spikes in plateau")
+    
+    # Factor 4: Continuous noise level (10 points max)
+    if features['noise_rms'] > 40:
+        main_wear_prob += 10.0
+        main_wear_reasons.append(f"High continuous noise: RMS={features['noise_rms']:.1f} µΩ")
+    elif features['avg_noise'] > 25:
+        main_wear_prob += 6.0
+        main_wear_reasons.append(f"Elevated noise level: {features['avg_noise']:.1f} µΩ")
+    
+    if main_wear_prob >= 50.0:
+        prob_str = f"{min(99.0, main_wear_prob):.2f} %"
+        sev = _get_severity(main_wear_prob)
+        desc = ". ".join(main_wear_reasons)
+        all_faults.append(_build_result("Main Contact Wear", prob_str, sev, desc))
+    
+    # ========================================================================
+    # CLASS 3: ARCING CONTACT WEAR
+    # Signature: Sustained impulse spikes + Symmetric pattern + Healthy Phase 3
+    # Probability Score: 0-100% based on arc severity
+    # ========================================================================
+    arcing_wear_prob = 0.0
+    arcing_wear_reasons = []
+    
+    # Factor 1: Critical/Severe spikes in arcing zones (50 points max)
+    if features['total_critical_spikes'] >= ARCING_SPIKE_COUNT_CRITICAL:
+        arcing_wear_prob += 50.0
+        arcing_wear_reasons.append(f"CRITICAL: {features['total_critical_spikes']} severe arc flashes detected (>8000 µΩ). Arcing contact severely eroded")
+        if features['total_sustained_spikes'] >= 2:
+            arcing_wear_prob += 8.0
+            arcing_wear_reasons.append(f"{features['total_sustained_spikes']} sustained arc events (>3 samples width)")
+    elif features['total_severe_spikes'] >= ARCING_SPIKE_COUNT_SEVERE:
+        arcing_wear_prob += 40.0
+        arcing_wear_reasons.append(f"SEVERE: {features['total_severe_spikes']} high-energy spikes (>5000 µΩ) in arcing zones")
+        if features['total_sustained_spikes'] >= 2:
+            arcing_wear_prob += 8.0
+            arcing_wear_reasons.append(f"{features['total_sustained_spikes']} sustained arcs detected")
+    elif features['total_severe_spikes'] >= 2:
+        arcing_wear_prob += 28.0
+        arcing_wear_reasons.append(f"{features['total_severe_spikes']} arcing spikes detected (>5000 µΩ)")
+    elif features['total_moderate_spikes'] >= 5:
+        arcing_wear_prob += 20.0
+        arcing_wear_reasons.append(f"{features['total_moderate_spikes']} moderate arcing events (>3000 µΩ)")
+    
+    # Factor 2: Spike symmetry check (wear = symmetric; misalignment = asymmetric) (20 points max)
+    if features['spike_symmetry'] < 1.4 and features['total_severe_spikes'] > 0:
+        arcing_wear_prob += 20.0
+        arcing_wear_reasons.append(f"Symmetric spike distribution (ratio {features['spike_symmetry']:.2f}). Confirms uniform arcing wear on both contacts")
+    elif features['spike_symmetry'] < 1.8 and features['total_severe_spikes'] > 0:
+        arcing_wear_prob += 12.0
+        arcing_wear_reasons.append(f"Relatively symmetric pattern (ratio {features['spike_symmetry']:.2f})")
+    
+    # Factor 3: High arcing zone instability (15 points max)
+    max_arcing_std = max(features['closing_std'], features['opening_std'])
+    if max_arcing_std > ARCING_INSTABILITY_STD * 1.5:
+        arcing_wear_prob += 15.0
+        arcing_wear_reasons.append(f"Very high arcing instability: Std={max_arcing_std:.1f} µΩ (normal <500 µΩ)")
+    elif max_arcing_std > ARCING_INSTABILITY_STD:
+        arcing_wear_prob += 10.0
+        arcing_wear_reasons.append(f"Elevated arcing zone variability: Std={max_arcing_std:.1f} µΩ")
+    
+    # Factor 4: Phase 3 health check (15 points max - confirms isolation to arcing contacts)
+    if features['main_mean'] < R_HEALTHY_MAX and features['main_std'] < WEAR_STD_MODERATE:
+        arcing_wear_prob += 15.0
+        arcing_wear_reasons.append(f"Main contact healthy (Mean={features['main_mean']:.1f} µΩ, Std={features['main_std']:.1f} µΩ). Confirms wear isolated to arcing contacts")
+    else:
+        # If main contact also worn, arcing wear is secondary/co-existing
+        if features['main_mean'] > R_WEAR_MODERATE_MIN:
+            arcing_wear_prob -= 10.0  # Penalty: main wear likely primary
+    
+    # Disqualify if strong misalignment signature (asymmetric timing)
+    if features['asymmetry_ratio'] > ASYMMETRY_RATIO_MODERATE:
+        arcing_wear_prob -= 18.0
+        # Don't add reason - just reduce probability
+    
+    if arcing_wear_prob >= 50.0:
+        prob_str = f"{min(99.0, arcing_wear_prob):.2f} %"
+        sev = _get_severity(arcing_wear_prob)
+        desc = ". ".join(arcing_wear_reasons)
+        all_faults.append(_build_result("Arcing Contact Wear", prob_str, sev, desc))
+    
+    # ========================================================================
+    # CLASS 1: HEALTHY
+    # Signature: Low resistance + Low variability + Smooth transitions
+    # Probability Score: 100% minus penalties for any abnormalities
+    # ULTRA-STRICT: Only high score if ALL parameters ideal
+    # ========================================================================
+    healthy_prob = 100.0
+    healthy_reasons = []
+    
+    # Penalty 1: Elevated resistance (MOST CRITICAL - up to 55 points penalty)
+    if features['main_mean'] > R_WEAR_CRITICAL_MIN:
+        healthy_prob -= 55.0
+    elif features['main_mean'] > R_WEAR_SEVERE_MIN:
+        healthy_prob -= 48.0
+    elif features['main_mean'] > R_WEAR_MODERATE_MIN:
+        healthy_prob -= 40.0
+    elif features['main_mean'] > R_WEAR_EARLY_MIN:
+        healthy_prob -= 25.0
+    elif features['main_mean'] > R_HEALTHY_MAX:
+        healthy_prob -= 12.0
+    
+    # Penalty 2: High variability/noise (up to 30 points)
+    if features['main_std'] > WEAR_STD_SEVERE:
+        healthy_prob -= 30.0
+    elif features['main_std'] > WEAR_STD_MODERATE:
+        healthy_prob -= 22.0
+    elif features['main_std'] > R_HEALTHY_STD_MAX:
+        healthy_prob -= 12.0
+    
+    # Penalty 3: Telegraph/square wave pattern (up to 20 points)
+    if features['telegraph_jumps'] > 8:
+        healthy_prob -= 20.0
+    elif features['telegraph_jumps'] > 5:
+        healthy_prob -= 12.0
+    elif features['telegraph_jumps'] > 2:
+        healthy_prob -= 6.0
+    
+    # Penalty 4: Arcing spikes (up to 20 points)
+    if features['total_critical_spikes'] > 0:
+        healthy_prob -= 20.0
+    elif features['total_severe_spikes'] > 1:
+        healthy_prob -= 15.0
+    elif features['total_moderate_spikes'] > 3:
+        healthy_prob -= 10.0
+    
+    # Penalty 5: Timing asymmetry (up to 15 points)
+    if features['asymmetry_ratio'] > ASYMMETRY_RATIO_SEVERE:
+        healthy_prob -= 15.0
+    elif features['asymmetry_ratio'] > ASYMMETRY_RATIO_MODERATE:
+        healthy_prob -= 10.0
+    elif features['asymmetry_ratio'] > 1.5:
+        healthy_prob -= 5.0
+    
+    # Penalty 6: Bounces/oscillations (up to 12 points)
+    if features['num_bounces'] > 4:
+        healthy_prob -= 12.0
+    elif features['num_bounces'] > 2:
+        healthy_prob -= 7.0
+    
+    # Penalty 7: Grassy noise pattern (up to 10 points)
+    if features['spike_density'] > 0.30:
+        healthy_prob -= 10.0
+    elif features['spike_density'] > 0.15:
+        healthy_prob -= 5.0
+    
+    # Build healthy description if score is high
+    if healthy_prob >= 50.0:
+        healthy_reasons.append(f"Normal operation. Main Contact: Mean={features['main_mean']:.1f} µΩ (ideal: 20-70 µΩ), Std={features['main_std']:.1f} µΩ (smooth: <15 µΩ)")
+        healthy_reasons.append(f"Timing: {features['asymmetry_ratio']:.2f} ratio (balanced: <1.5)")
+        
+        if features['total_critical_spikes'] == 0 and features['total_severe_spikes'] == 0:
+            healthy_reasons.append("No abnormal arcing detected")
+        
+        if features['telegraph_jumps'] <= 2 and features['is_square_wave'] == 0:
+            healthy_reasons.append("Smooth transitions, no misalignment patterns")
+        
+        prob_str = f"{max(0.0, healthy_prob):.2f} %"
+        sev = "None" if healthy_prob >= 85.0 else "Low"
+        desc = ". ".join(healthy_reasons)
+        all_faults.append(_build_result("Healthy", prob_str, sev, desc))
+    
+    return all_faults
+
+
+def classify_secondary_faults(features, phases, kpis, primary_faults):
+    """
+    Detect SECONDARY MECHANICAL/OPERATIONAL DEFECTS (Classes 6-10).
+    Uses EXTREME STRICTNESS as per Gemini Agent 2 logic.
+    Only reports if confidence >75% AND overwhelming evidence.
+    """
+    secondary_faults = []
+    
+    # Get primary defect names for context
+    primary_names = [f['defect_name'] for f in primary_faults]
+    
+    # ========================================================================
+    # CLASS 6: OPERATING MECHANISM MALFUNCTION (Slow/Fast Operation)
+    # ========================================================================
+    closing_time = kpis.get('Closing Time (ms)', None)
+    opening_time = kpis.get('Opening Time (ms)', None)
+    contact_speed = kpis.get('Contact Speed (m/s)', None)
+    
+    mechanism_score = 0
+    mechanism_reasons = []
+    kpi_count = 0
+    
+    # Check Closing Time
+    if closing_time is not None:
+        if closing_time > CLOSING_TIME_NOM[1] * (1 + TIMING_DEVIATION_THRESHOLD):
+            deviation = ((closing_time - CLOSING_TIME_NOM[1]) / CLOSING_TIME_NOM[1]) * 100
+            mechanism_score += 35
+            mechanism_reasons.append(f"Slow closing: {closing_time:.1f} ms (nominal 80-100 ms, {deviation:.1f}% slower)")
+            kpi_count += 1
+        elif closing_time < CLOSING_TIME_NOM[0] * (1 - TIMING_DEVIATION_THRESHOLD):
+            deviation = ((CLOSING_TIME_NOM[0] - closing_time) / CLOSING_TIME_NOM[0]) * 100
+            mechanism_score += 35
+            mechanism_reasons.append(f"Fast closing: {closing_time:.1f} ms ({deviation:.1f}% faster)")
+            kpi_count += 1
+    
+    # Check Opening Time
+    if opening_time is not None:
+        if opening_time > OPENING_TIME_NOM[1] * (1 + TIMING_DEVIATION_THRESHOLD):
+            deviation = ((opening_time - OPENING_TIME_NOM[1]) / OPENING_TIME_NOM[1]) * 100
+            mechanism_score += 35
+            mechanism_reasons.append(f"Slow opening: {opening_time:.1f} ms (nominal 30-40 ms, {deviation:.1f}% slower)")
+            kpi_count += 1
+        elif opening_time < OPENING_TIME_NOM[0] * (1 - TIMING_DEVIATION_THRESHOLD):
+            deviation = ((OPENING_TIME_NOM[0] - opening_time) / OPENING_TIME_NOM[0]) * 100
+            mechanism_score += 35
+            mechanism_reasons.append(f"Fast opening: {opening_time:.1f} ms ({deviation:.1f}% faster)")
+            kpi_count += 1
+    
+    # Check Contact Speed
+    if contact_speed is not None:
+        if contact_speed < CONTACT_SPEED_NOM[0] * (1 - TIMING_DEVIATION_THRESHOLD):
+            deviation = ((CONTACT_SPEED_NOM[0] - contact_speed) / CONTACT_SPEED_NOM[0]) * 100
+            mechanism_score += 30
+            mechanism_reasons.append(f"Low contact speed: {contact_speed:.2f} m/s (nominal 4.5-6.5 m/s, {deviation:.1f}% slower)")
+            kpi_count += 1
+        elif contact_speed > CONTACT_SPEED_NOM[1] * (1 + TIMING_DEVIATION_THRESHOLD):
+            deviation = ((contact_speed - CONTACT_SPEED_NOM[1]) / CONTACT_SPEED_NOM[1]) * 100
+            mechanism_score += 30
+            mechanism_reasons.append(f"High contact speed: {contact_speed:.2f} m/s ({deviation:.1f}% faster)")
+            kpi_count += 1
+    
+    # Confidence boost if multiple KPIs affected
+    if kpi_count >= 2:
+        mechanism_score += 15
+        mechanism_reasons.append("Multiple timing parameters affected - confirms mechanism malfunction")
+    
+    if mechanism_score > 0:
+        conf = min(95.0, mechanism_score)
+        sev = _get_severity(conf)
+        desc = ". ".join(mechanism_reasons)
+        secondary_faults.append(_build_result("Operating Mechanism Malfunction", f"{conf:.2f} %", sev, desc))
+    
+    # ========================================================================
+    # CLASS 7: DAMPING SYSTEM FAULT (Excessive Bouncing/Oscillation)
+    # ========================================================================
+    damping_score = 0
+    damping_reasons = []
+    
+    # Count bounces in main contact zone (>5 distinct bounces with >100 µΩ amplitude)
+    if features['num_bounces'] > BOUNCE_COUNT_THRESHOLD:
+        damping_score += 50
+        damping_reasons.append(f"Excessive bouncing detected: {features['num_bounces']} distinct bounces in main contact zone (>5 indicates damper failure)")
+    elif features['num_bounces'] >= 5:
+        damping_score += 35
+        damping_reasons.append(f"{features['num_bounces']} bounces detected")
+    
+    # Check for oscillation pattern (not random noise)
+    if features['main_std'] > 50 and features['num_bounces'] >= 5:
+        damping_score += 25
+        damping_reasons.append(f"Oscillation pattern in main contact (Std={features['main_std']:.1f} µΩ with structured bounces)")
+    
+    if damping_score > 0:
+        conf = min(95.0, damping_score)
+        sev = _get_severity(conf)
+        desc = ". ".join(damping_reasons)
+        secondary_faults.append(_build_result("Damping System Fault", f"{conf:.2f} %", sev, desc))
+    
+    # ========================================================================
+    # CLASS 8: SF6 PRESSURE LEAKAGE
+    # ========================================================================
+    sf6_pressure = kpis.get('SF6 Pressure (bar)', None)
+    
+    sf6_score = 0
+    sf6_reasons = []
+    
+    if sf6_pressure is not None:
+        if sf6_pressure < SF6_PRESSURE_CRITICAL:
+            sf6_score += 60
+            sf6_reasons.append(f"SF6 pressure critically low: {sf6_pressure:.2f} bar (normal: 5.5-6.5 bar)")
+            
+            # Check for prolonged arc (secondary evidence)
+            if features['dur_opening'] > ARC_QUENCH_DURATION_MAX:
+                sf6_score += 25
+                sf6_reasons.append(f"Prolonged arc quenching ({features['dur_opening']} ms) confirms gas leak")
+            
+            # Check if primary defect is Arcing Wear (supports SF6 leak hypothesis)
+            if "Arcing Contact Wear" in primary_names:
+                sf6_score += 10
+                sf6_reasons.append("Arcing wear detected as primary defect - consistent with SF6 leak")
+    else:
+        # No SF6 KPI: Can only infer from waveform (low confidence)
+        if features['dur_opening'] > ARC_QUENCH_DURATION_MAX + 10:
+            if "Arcing Contact Wear" in primary_names:
+                # Get arcing wear confidence
+                arcing_conf = 0
+                for pf in primary_faults:
+                    if pf['defect_name'] == "Arcing Contact Wear":
+                        arcing_conf = float(pf['Confidence'].replace('%', '').strip())
+                
+                if arcing_conf > 85:
+                    sf6_score += 55
+                    sf6_reasons.append(f"Prolonged arc quenching ({features['dur_opening']} ms, normal <25 ms) with severe arcing wear - indicates possible SF6 leak")
+                    sf6_reasons.append("WARNING: No SF6 pressure sensor data. Confidence limited to 70%")
+                    sf6_score = min(sf6_score, 70)  # Cap at 70% without pressure KPI
+    
+    if sf6_score > 0:
+        conf = min(95.0, sf6_score)
+        sev = _get_severity(conf)
+        desc = ". ".join(sf6_reasons)
+        secondary_faults.append(_build_result("Pressure System Leakage (SF6 Gas Chamber)", f"{conf:.2f} %", sev, desc))
+    
+    # ========================================================================
+    # CLASS 9: LINKAGE/CONNECTING ROD OBSTRUCTION
+    # ========================================================================
+    linkage_score = 0
+    linkage_reasons = []
+    
+    # Detect "stutters" (flat plateaus within transitions)
+    # This requires analyzing slope changes in transitions (complex detection)
+    # Simplified: Use telegraph in main contact + increased duration as proxy
+    
+    if features['telegraph_jumps'] > STUTTER_COUNT_MIN and features['num_shelves'] > 3:
+        # Check if operating time is increased
+        total_op_time = features['dur_closing'] + features['dur_main'] + features['dur_opening']
+        expected_time = 250  # Nominal ~250 ms total
+        
+        if total_op_time > expected_time * 1.15:  # >15% longer
+            linkage_score += 50
+            linkage_reasons.append(f"Detected {features['telegraph_jumps']} mechanical stutters with {features['num_shelves']} stepped plateaus")
+            linkage_reasons.append(f"Total operation time {total_op_time} ms (expected ~{expected_time} ms, {((total_op_time/expected_time - 1)*100):.1f}% longer)")
+        elif features['num_shelves'] >= 5:
+            linkage_score += 35
+            linkage_reasons.append(f"Multiple stepped plateaus ({features['num_shelves']}) indicate mechanical impedance")
+    
+    if linkage_score > 0:
+        conf = min(95.0, linkage_score)
+        sev = _get_severity(conf)
+        desc = ". ".join(linkage_reasons)
+        secondary_faults.append(_build_result("Linkage/Connecting Rod Obstruction/Damage", f"{conf:.2f} %", sev, desc))
+    
+    # ========================================================================
+    # CLASS 10: FIXED CONTACT DAMAGE/DEFORMATION
+    # ========================================================================
+    dlro_value = kpis.get('DLRO Value (µΩ)', None)
+    
+    fixed_contact_score = 0
+    fixed_contact_reasons = []
+    
+    if dlro_value is not None:
+        if dlro_value > DLRO_CRITICAL:
+            # Check if curve is smooth (not wear)
+            if features['main_std'] < FIXED_CONTACT_STD_MAX:
+                fixed_contact_score += 50
+                fixed_contact_reasons.append(f"DLRO critically high: {dlro_value:.1f} µΩ (normal <50 µΩ, critical >100 µΩ)")
+                fixed_contact_reasons.append(f"Smooth plateau (Std={features['main_std']:.1f} µΩ) indicates fixed contact/connection issue, not wear")
+            else:
+                # High DLRO but noisy = likely Main Contact Wear already detected
+                if "Main Contact Wear" not in primary_names:
+                    fixed_contact_score += 40
+                    fixed_contact_reasons.append(f"DLRO high: {dlro_value:.1f} µΩ with noisy plateau")
+                else:
+                    # List as secondary with reduced confidence
+                    fixed_contact_score += 30
+                    fixed_contact_reasons.append(f"DLRO high: {dlro_value:.1f} µΩ (secondary to Main Contact Wear)")
+        
+        elif dlro_value > DLRO_MODERATE:
+            if features['main_std'] < FIXED_CONTACT_STD_MAX:
+                fixed_contact_score += 35
+                fixed_contact_reasons.append(f"DLRO moderately elevated: {dlro_value:.1f} µΩ (normal <50 µΩ)")
+    else:
+        # No DLRO KPI: Can infer from smooth elevated plateau
+        if features['main_mean'] > DLRO_MODERATE and features['main_std'] < FIXED_CONTACT_STD_MAX:
+            if "Main Contact Wear" not in primary_names:
+                fixed_contact_score += 30
+                fixed_contact_reasons.append(f"Elevated but smooth plateau (Mean={features['main_mean']:.1f} µΩ, Std={features['main_std']:.1f} µΩ) suggests fixed contact issue")
+                fixed_contact_reasons.append("WARNING: No DLRO sensor data. Confidence limited to 65%")
+                fixed_contact_score = min(fixed_contact_score, 65)
+    
+    if fixed_contact_score > 0:
+        conf = min(90.0, fixed_contact_score)
+        sev = _get_severity(conf)
+        desc = ". ".join(fixed_contact_reasons)
+        secondary_faults.append(_build_result("Fixed Contact Damage/Deformation", f"{conf:.2f} %", sev, desc))
+    
+    return secondary_faults
+
+
+def _get_severity(probability):
+    """
+    Determine severity based on defect probability score.
+    
+    Args:
+        probability: Float 0-100 representing defect probability
+    
+    Returns:
+        String: "Critical", "High", "Medium", "Low", or "None"
+    """
+    if probability >= 90:
+        return "Critical"
+    elif probability >= 75:
+        return "High"
+    elif probability >= 60:
+        return "Medium"
+    elif probability >= 50:
+        return "Low"
+    else:
+        return "None"
+
+
+def _build_result(name, conf, sev, desc):
+    """Helper to build fault result dictionary with proper Unicode handling"""
+    return {
+        "defect_name": name,
+        "Confidence": conf,
+        "Severity": sev,
+        "description": desc
+    }
+
+
+# =============================================================================
+# KPI HELPER FUNCTIONS
+# =============================================================================
+def parse_kpis_from_json(kpis_json):
+    """
+    Convert KPI JSON format to dictionary for internal use.
+    
+    Input format:
+    {
+        "kpis": [
+            {"name": "Closing Time", "unit": "ms", "value": 87.8},
+            ...
+        ]
+    }
+    
+    Output format:
+    {
+        "Closing Time (ms)": 87.8,
+        ...
+    }
+    """
+    if kpis_json is None:
+        return {}
+    
+    # If already in dict format, return as-is
+    if isinstance(kpis_json, dict) and "kpis" not in kpis_json:
+        return kpis_json
+    
+    # Parse from JSON format
+    kpi_dict = {}
+    kpis_list = kpis_json.get("kpis", [])
+    
+    for kpi in kpis_list:
+        name = kpi.get("name", "")
+        unit = kpi.get("unit", "")
+        value = kpi.get("value", None)
+        
+        # Create key in format "Name (unit)"
+        key = f"{name} ({unit})" if unit else name
+        kpi_dict[key] = value
+    
+    return kpi_dict
+
+
+# =============================================================================
+# CENTRAL PIPELINE FUNCTION
+# =============================================================================
+def analyze_dcrm_from_dataframe(df, kpis=None):
+    """
+    Central pipeline function to analyze DCRM data from DataFrame.
+    
+    Args:
+        df: DataFrame with Resistance column (401 points)
+        kpis: KPI data in JSON format or dict format
+              JSON format: {"kpis": [{"name": "...", "unit": "...", "value": ...}, ...]}
+              Dict format: {"Name (unit)": value, ...}
+    
+    Returns:
+        JSON with fault detection results and classifications
+    """
+    # Standardize input
+    df_standardized = standardize_input(df)
+    
+    # Extract time columns
+    time_cols = [c for c in df_standardized.columns if c.startswith('T_')]
+    
+    # Get first row values (for single waveform analysis)
+    row_values = df_standardized.iloc[0][time_cols].values
+    
+    # Parse KPIs to internal format
+    kpis_dict = parse_kpis_from_json(kpis)
+    
+    # Run analysis
+    result = analyze_dcrm_advanced(row_values, kpis=kpis_dict)
+    
+    return result
+
+
+if __name__ == "__main__":
+    df = pd.read_csv('C:\\Users\\rkhanke\\Downloads\\parallel_proccessing\\combined\\data\\df3_final.csv')
+
+    # New JSON format for KPIs
+    sample_kpis = {
+        "kpis": [
+            {
+                "name": "Closing Time",
+                "unit": "ms",
+                "value": 90.0
+            },
+            {
+                "name": "Opening Time",
+                "unit": "ms",
+                "value": 35.0
+            },
+            {
+                "name": "DLRO Value",
+                "unit": "µΩ",
+                "value": 299.93
+            },
+            {
+                "name": "Peak Resistance",
+                "unit": "µΩ",
+                "value": 408.0
+            },
+            {
+                "name": "Main Wipe",
+                "unit": "mm",
+                "value": 46.0
+            },
+            {
+                "name": "Arc Wipe",
+                "unit": "mm",
+                "value": 63.0
+            },
+            {
+                "name": "Contact Travel Distance",
+                "unit": "mm",
+                "value": 550.0
+            },
+            {
+                "name": "Contact Speed",
+                "unit": "m/s",
+                "value": 5.5
+            },
+            {
+                "name": "Peak Close Coil Current",
+                "unit": "A",
+                "value": 5.2
+            },
+            {
+                "name": "Peak Trip Coil 1 Current",
+                "unit": "A",
+                "value": 5.0
+            },
+            {
+                "name": "Peak Trip Coil 2 Current",
+                "unit": "A",
+                "value": 4.8
+            },
+            {
+                "name": "Ambient Temperature",
+                "unit": "°C",
+                "value": 28.4
+            }
+        ]
+    }
+    
+    result = analyze_dcrm_from_dataframe(df, kpis=sample_kpis)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+

core/models/vit_classifier.py

@@ -0,0 +1,261 @@
+# Previous Name: analysis/models/vit_classifier.py
+import os
+import matplotlib
+matplotlib.use('Agg')  # Set backend to non-interactive
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+import requests
+import google.generativeai as genai
+import json
+
+# Parameters
+IMG_HEIGHT = 224
+IMG_WIDTH = 224
+
+# Define classes (must match training - sorted alphabetically)
+CLASSES = sorted([
+    "Healthy",
+    "Arcing_Contact_Misalignment",
+    "Arcing_Contact_Wear",
+    "Main Contact Misalignment",
+    "main_contact_wear"
+])
+
+# Deployed ViT Model URL
+DEPLOYED_VIT_URL = "http://143.110.244.235/predict"
+
+def plot_resistance_for_vit(df, save_path="temp_vit_plot.png"):
+    """
+    Generates and saves the resistance plot in the format expected by the ViT model.
+    Plots all three curves: Green (Resistance), Blue (Current), Red (Travel)
+    """
+    fig, ax = plt.subplots(figsize=(10, 6))
+    
+    # Plot based on column availability
+    # Green: Resistance, Blue: Current, Red: Travel
+    if 'Resistance' in df.columns:
+        ax.plot(df['Resistance'], color='green', label='Resistance')
+    if 'Current' in df.columns:
+        ax.plot(df['Current'], color='blue', label='Current')
+    if 'Travel' in df.columns:
+        ax.plot(df['Travel'], color='red', label='Travel')
+        
+    ax.legend()
+    ax.set_title("DCRM Trace")
+    ax.set_xlabel("Time (Samples)")
+    ax.set_ylabel("Value")
+    ax.grid(True)
+    
+    # Save to file
+    plt.savefig(save_path)
+    plt.close(fig)
+    return True
+
+def get_remote_vit_probabilities(image_path):
+    """
+    Get probability distribution for all classes from the deployed ViT API.
+    Returns: dict of {class_name: probability}
+    """
+    try:
+        if not os.path.exists(image_path):
+            print(f"Error: Image file not found at {image_path}")
+            return {}
+
+        with open(image_path, "rb") as f:
+            # Explicitly set the filename and MIME type
+            files = {"file": (os.path.basename(image_path), f, "image/jpeg")}
+            # Add headers
+            headers = {"accept": "application/json"}
+            
+            print(f"Sending request to {DEPLOYED_VIT_URL}...")
+            response = requests.post(DEPLOYED_VIT_URL, headers=headers, files=files, timeout=10)
+            
+        if response.status_code != 200:
+            print(f"Error: API returned status code {response.status_code}")
+            print(f"Response: {response.text}")
+            return {}
+
+        data = response.json()
+        
+        if "probabilities" in data:
+            return data["probabilities"]
+        else:
+            print(f"Error: 'probabilities' key not found in response: {data}")
+            return {}
+
+    except requests.exceptions.RequestException as e:
+        print(f"Request Error: {e}")
+        return {}
+    except Exception as e:
+        print(f"Error processing image with remote API: {e}")
+        return {}
+
+
+def get_gemini_prediction(image, api_key=None):
+    """
+    Get Gemini's expert analysis of the DCRM trace.
+    Returns: (probabilities_dict, error_message)
+    """
+    if not api_key:
+        api_key = os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")
+    
+    if not api_key:
+        return None, "API Key missing"
+    
+    try:
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-2.0-flash')
+        prompt = f"""
+        System Role: Principal DCRM & Kinematic Analyst
+        Role:
+        You are an expert High-Voltage Circuit Breaker Diagnostician. Your task is to interpret Dynamic Contact Resistance (DCRM) traces to detect specific electrical and mechanical faults.
+        
+        The input image contains 3 line charts:
+        - Green: Resistance profile
+        - Blue: Current profile 
+        - Red: Travel profile
+        
+        1. Diagnostic Heuristics & Defect Taxonomy
+        Map the visual DCRM trace to ONLY the following defect types. Use the specific Visual Heuristics to confirm detection.
+        
+        Defect Type | Visual Heuristic (The "Hint") | Mechanical Significance (Root Cause)
+        --- | --- | ---
+        Main Contact Issue (Corrosion/Oxidation) | "The Significant Grass"<br>In the fully closed plateau, look for pronounced, erratic instability. <br>• Ignore: Uniform, low-amplitude fuzz (sensor noise).<br>• Flag: Jagged, irregular peaks/valleys with significant amplitude (e.g., > 15–20 μΩ variance). The trace looks like a "rough rocky road," not just a "gravel path." | Surface Pathology: The Silver (Ag) plating is compromised (fretting corrosion) or heavy oxidation has occurred. The current path is constantly shifting through microscopic non-conductive spots.
+        Arcing Contact Wear | "Big Spikes & Short Wipe"<br>Resistance spikes are frequent and significantly large (high amplitude). Crucially, the duration of the arcing zone (the time between first touch and main contact touch) is noticeably shorter than expected. | Ablation: The Tungsten-Copper (W-Cu) tips are heavily eroded. The contact length has physically diminished, risking failure to commutate current during opening.
+        Misalignment (Main) | "The Struggle to Settle"<br>There are significant, high-amplitude peaks just before the trace tries to settle into the stable plateau. These are not bounces; they are "struggles" to mate that persist longer than 3-5ms. | Mechanical Centering: The moving contact pin is hitting the side or edge of the stationary rosette fingers before forcing its way in. Caused by loose nuts, kinematic play, or guide ring failure.
+        Misalignment (Arcing) | "Rough Entry"<br>Erratic resistance spikes occurring specifically during the initial entry (commutation), well before the main contacts engage. | Tip Eccentricity: The arcing pin is not entering the nozzle concentrically. It is scraping the nozzle throat or hitting the side, indicating a bent rod or skewed interrupter.
+        Slow Mechanism | "Stretched Time"<br>The entire resistance profile is elongated along the X-axis. Events happen later than normal. | Energy Starvation: Low spring charge, hydraulic pressure loss, or high friction due to hardened grease in the linkage.
+        
+        2. Analysis Logic (The "Signal-to-Noise" Filter)
+        Before declaring a defect, run these logic checks:
+        The "Noise Floor" Test (For Main Contacts):
+        Is the plateau variance uniform and small (< 10 μΩ)? -> Classify as Healthy (Sensor/Manufacturing artifact).
+        Is the variance erratic, jagged, and large (> 15 μΩ)? -> Classify as Corrosion/Oxidation.
+        The "Duration" Test (For Misalignment):
+        Are the pre-plateau peaks < 2ms? -> Ignore (Benign Bounce).
+        Do the peaks persist > 3-5ms before settling? -> Classify as Misalignment.
+        The "Combination" Check:
+        Does the trace show both "Rough Entry" AND "Stretched Time"? -> Report Both (Misalignment + Slow Mechanism).
+        
+        3. Output Structure
+        You must return a JSON object containing the probability (confidence score between 0.0 and 1.0) for EACH of the following classes. The sum of probabilities should ideally be close to 1.0.
+        
+        Classes: {CLASSES}
+        
+        Example Output Format:
+        {{
+            "Healthy": 0.1,
+            "Arcing_Contact_Misalignment": 0.05,
+            "Arcing_Contact_Wear": 0.8,
+            "Main Contact Misalignment": 0.02,
+            "main_contact_wear": 0.03
+        }}
+        
+        RETURN ONLY THE JSON OBJECT. NO MARKDOWN. NO EXPLANATION.
+        """
+        response = model.generate_content([prompt, image])
+        
+        # Clean response to ensure valid JSON
+        text = response.text.strip()
+        # Remove markdown code blocks if present
+        if text.startswith("```json"):
+            text = text[7:]
+        if text.startswith("```"):
+            text = text[3:]
+        if text.endswith("```"):
+            text = text[:-3]
+        text = text.strip()
+        
+        probs = json.loads(text)
+        return probs, None
+    except Exception as e:
+        return None, str(e)
+
+
+def predict_dcrm_image(image_path, model_path=None, api_key=None):
+    """
+    Predicts the class of the DCRM image using Deployed ViT + Gemini Ensemble.
+    Returns: (predicted_class, confidence_score, details_dict)
+    
+    The details_dict contains:
+    - vit_probs: Dictionary of ViT probabilities for each class (from deployed API)
+    - gemini_probs: Dictionary of Gemini probabilities for each class
+    - ensemble_scores: Dictionary of combined scores for each class
+    """
+    try:
+        # Get API key from environment if not provided
+        if not api_key:
+            api_key = os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")
+        
+        # Load image for Gemini
+        image = Image.open(image_path).convert('RGB')
+        
+        # 1. ViT Prediction (Remote)
+        vit_probs = get_remote_vit_probabilities(image_path)
+        
+        if not vit_probs:
+            print("Warning: Failed to get ViT probabilities from remote API.")
+            # We can continue if we want to rely on Gemini, or return failure.
+            # For now, let's continue but note the failure.
+        
+        # 2. Gemini Prediction
+        gemini_probs, error = get_gemini_prediction(image, api_key)
+        
+        # Ensemble Logic
+        ensemble_scores = {}
+        
+        # Initialize with 0.0 for all classes
+        for cls in CLASSES:
+            ensemble_scores[cls] = 0.0
+            
+        # Add ViT scores
+        if vit_probs:
+            for cls, prob in vit_probs.items():
+                if cls in ensemble_scores:
+                    ensemble_scores[cls] += prob
+                    
+        # Add Gemini scores
+        if gemini_probs:
+            for cls, prob in gemini_probs.items():
+                if cls in ensemble_scores:
+                    ensemble_scores[cls] += prob
+                    
+        # If both failed, return error
+        if not vit_probs and not gemini_probs:
+            return None, 0.0, {}
+
+        # Sort classes by score (descending)
+        sorted_classes = sorted(ensemble_scores.items(), key=lambda item: item[1], reverse=True)
+        
+        best_class = sorted_classes[0][0]
+        best_score = sorted_classes[0][1]
+        
+        # Conditional Logic - Use fallback only when Healthy is at top with low score
+        if best_score < 1.0 and best_class == "Healthy" and best_score < 0.8:
+            if len(sorted_classes) > 1:
+                best_class = sorted_classes[1][0]
+                best_score = sorted_classes[1][1]
+        
+        # Normalize score
+        # If we had both models, max score is 2.0. If only one, max is 1.0.
+        divisor = 0.0
+        if vit_probs: divisor += 1.0
+        if gemini_probs: divisor += 1.0
+        
+        if divisor > 0:
+            normalized_confidence = best_score / divisor
+        else:
+            normalized_confidence = 0.0
+        
+        return best_class, normalized_confidence, {
+            "vit_probs": vit_probs,
+            "gemini_probs": gemini_probs,
+            "ensemble_scores": ensemble_scores
+        }
+            
+    except Exception as e:
+        print(f"Error in predict_dcrm_image: {e}")
+        import traceback
+        traceback.print_exc()
+        return None, 0.0, {}

core/signal/arcing.py

@@ -0,0 +1,143 @@
+# Previous Name: analysis/arcing_analysis.py
+import pandas as pd
+import numpy as np
+from .segmentation import identify_arcing_events
+
+def calculate_velocity(df, window=5):
+    """
+    Calculates velocity (m/s) from Travel (mm) and Time (ms).
+    """
+    # Ensure we work on a copy to avoid SettingWithCopyWarning
+    df = df.copy()
+    df['Travel_Smooth'] = df['Travel'].rolling(window=window, center=True).mean().fillna(df['Travel'])
+    dy = np.gradient(df['Travel_Smooth'])
+    dx = np.gradient(df['Time_ms'])
+    velocity = np.where(dx != 0, dy / dx, 0)
+    return np.abs(velocity)
+
+def calculate_arcing_parameters(df, llm=None):
+    """
+    Calculates T0, T1, T2, T3, T4 and derived arcing health metrics.
+    
+    If `llm` is provided, it uses the AI agent to identify the event timestamps (Robust).
+    Otherwise, it uses deterministic threshold logic (Fallback).
+    """
+    results = {
+        "events": {},
+        "metrics": {},
+        "status": "Unknown",
+        "method": "Deterministic"
+    }
+    
+    try:
+        # 1. Calculate Velocity
+        velocity = calculate_velocity(df)
+        df['Velocity'] = velocity
+        
+        t0, t1, t2, t4 = None, None, None, None
+        
+        # --- A. LLM-Based Detection (Preferred) ---
+        if llm:
+            try:
+                ai_result = identify_arcing_events(df, llm)
+                if "events" in ai_result:
+                    events = ai_result["events"]
+                    t0 = events.get("T0_breaker_closed")
+                    t1 = events.get("T1_motion_start")
+                    t2 = events.get("T2_main_separation")
+                    t4 = events.get("T4_arcing_separation")
+                    results["method"] = "AI-Enhanced"
+                    results["ai_reasoning"] = ai_result.get("reasoning", "")
+            except Exception as e:
+                print(f"AI Segmentation failed, falling back to deterministic: {e}")
+        
+        # --- B. Deterministic Fallback ---
+        if t2 is None or t4 is None:
+            # T0: Breaker Closed
+            t0_window = df[df['Time_ms'] < 10]
+            r_static = t0_window['Resistance'].mean() if not t0_window.empty else 0.0
+            t0 = 0.0 # Nominal
+            
+            # T1: Motion Starts
+            start_pos = df['Travel'].iloc[0]
+            motion_mask = abs(df['Travel'] - start_pos) > 1.0
+            if motion_mask.any():
+                t1 = float(df.loc[motion_mask.idxmax(), 'Time_ms'])
+            
+            # T2 & T4: State-Based
+            R_ARC_MIN = 150.0
+            R_OPEN_MIN = 1500.0
+            
+            search_start = t1 if t1 else 0
+            arcing_candidates = df[(df['Time_ms'] > search_start) & (df['Resistance'] >= R_ARC_MIN)]
+            
+            if not arcing_candidates.empty:
+                t2 = float(df.loc[arcing_candidates.index[0], 'Time_ms'])
+                
+                open_candidates = df[(df['Time_ms'] > t2) & (df['Resistance'] >= R_OPEN_MIN)]
+                if not open_candidates.empty:
+                    t4 = float(df.loc[open_candidates.index[0], 'Time_ms'])
+
+        # --- Store Events ---
+        results['events']['T0_static_resistance'] = 0.0 # Placeholder, calc below
+        if t0 is not None: results['events']['T0_time'] = t0
+        if t1 is not None: results['events']['T1_motion_start'] = t1
+        if t2 is not None: results['events']['T2_main_separation'] = t2
+        if t4 is not None: results['events']['T4_arcing_separation'] = t4
+        
+        # T3: Duration
+        if t2 and t4:
+            results['events']['T3_duration_ms'] = round(t4 - t2, 2)
+        
+        # --- Metric Calculation (Deterministic Math) ---
+        
+        if t2 and t4:
+            # T0 Resistance Value
+            t0_val = df[df['Time_ms'] < 10]['Resistance'].mean()
+            results['events']['T0_static_resistance'] = round(t0_val, 2) if not np.isnan(t0_val) else 0.0
+
+            # Ra: Average Arcing Resistance (Exclude T4 spike)
+            # We add a small buffer to T2 to avoid the rising edge
+            arcing_zone = df[(df['Time_ms'] >= t2 + 0.5) & (df['Time_ms'] < t4 - 0.5)]
+            
+            if not arcing_zone.empty:
+                ra = arcing_zone['Resistance'].mean()
+            else:
+                # Fallback if zone is too small (single point)
+                ra = df[(df['Time_ms'] >= t2) & (df['Time_ms'] <= t4)]['Resistance'].mean()
+                
+            results['metrics']['Ra_avg_arcing_res'] = round(ra, 2)
+            
+            # Speed at Separation
+            speed_during_arc = arcing_zone['Velocity'].mean() if not arcing_zone.empty else 0.0
+            results['metrics']['Speed_at_separation'] = round(speed_during_arc, 2)
+            
+            # Da: Arcing Contact Wipe
+            da = (t4 - t2) * speed_during_arc
+            results['metrics']['Da_arcing_wipe'] = round(da, 2)
+            
+            # Wear Index: Ra * Da
+            ra_mOhm = ra / 1000.0
+            wear_index = ra_mOhm * da
+            results['metrics']['Wear_Index'] = round(wear_index, 2)
+            
+            # --- Health Assessment ---
+            if da < 10.0: da_status = "Critical (Short Wipe)"
+            elif da < 15.0: da_status = "Warning (Low Wipe)"
+            else: da_status = "Healthy"
+            results['metrics']['Da_Status'] = da_status
+            
+            if wear_index > 10.0: wear_status = "Critical (Replace Interrupter)"
+            elif wear_index > 5.0: wear_status = "Warning (Worn)"
+            else: wear_status = "Healthy"
+            results['metrics']['Wear_Status'] = wear_status
+            
+            results['status'] = "Success"
+            
+        else:
+            results['status'] = "Incomplete Data (Could not find T2/T4)"
+            
+    except Exception as e:
+        results['status'] = f"Error: {str(e)}"
+        
+    return results

core/signal/phases.py

@@ -0,0 +1,687 @@
+# Previous Name: analysis/phase_analysis.py
+import pandas as pd
+import numpy as np
+import json
+from langchain_core.messages import HumanMessage
+
+def get_coil_state(coil_series, active_threshold=0.1):
+    """
+    Determines the state of a coil (Close, Trip 1, Trip 2) during a phase.
+
+    Args:
+        coil_series (pd.Series): Series of coil values for the phase.
+        active_threshold (float): Value above which a coil is considered active.
+
+    Returns:
+        str: 'Active' or 'Inactive'.
+    """
+    if coil_series.empty:
+        return "Unknown"
+    # A simple mean-based check is often sufficient for coil states in DCRM phases.
+    # If the average value is above the threshold, consider it active during that phase.
+    if coil_series.mean() > active_threshold:
+        return "Active"
+    return "Inactive"
+
+
+def generate_llm_description_prompt(phase_data_summary, phase_info):
+    """
+    Generates an optimized prompt for Gemini to describe a DCRM phase
+    and its diagnostic verdict based on numerical summary.
+
+    Args:
+        phase_data_summary (dict): A dictionary containing summarized numerical data.
+        phase_info (dict): A dictionary containing static phase information.
+
+    Returns:
+        str: The optimized prompt string.
+    """
+    # DCRM Phase-Wise Diagnostic Reference
+    dcrm_diagnostic_reference = """
+    **DCRM Phase-Wise Diagnostic Criteria Reference:**
+    
+    Phase 1 - Pre-Contact Travel:
+    Healthy: High/stable resistance (around open circuit baseline), zero/low current (around open circuit baseline), smooth increasing travel, clean close coil energization.
+    Unhealthy: Premature drop in resistance or current rise (leakage/insulation breakdown), erratic/non-linear travel (mechanical binding), hesitations/plateaus (obstructions), slow/incomplete close coil activation.
+    
+    Phase 2 - Arcing Contact Engagement:
+    Healthy: Rapid sharp resistance drop from high to low, rapid current rise from low to high, smooth travel with minimal bounce (<5% amplitude, <10ms duration).
+    Unhealthy: Slow/incomplete resistance drop (contamination/erosion/misalignment), excessive/prolonged bounce (worn contacts/weak springs), current fails to reach expected level or rises slowly, abnormal current oscillations.
+    
+    Phase 3 - Main Contact Conduction:
+    Healthy: Very low stable resistance (around closed circuit baseline, low StdDev), high constant current at test level (around closed circuit baseline, low StdDev), stable travel at maximum (fully closed, low StdDev).
+    Unhealthy: Elevated resistance (> 50-100 μΩ above baseline - severe erosion/contamination), fluctuating resistance (poor pressure/loose connections), gradual resistance increase (progressive degradation), unstable travel (insufficient overtravel).
+    
+    Phase 4 - Contact Parting & Arc Elongation:
+    Healthy: Smooth, near-linear resistance rise from low to high with moderate deviation (not excessive spikes), possible short intermediate plateau during main contact parting before arc elongation, steady current drop from high to low, smooth consistent travel decrease at expected opening speed, clean trip coil energization. Resistance should show controlled progressive increase without large erratic spikes.
+    Unhealthy: Excessively spiked resistance with large deviations (severe arcing/welding), abrupt or erratic resistance changes, current drop too slow or fails to decrease steadily, erratic/non-linear travel (binding/friction), hesitations in travel, slow/inconsistent opening speed, prolonged arcing indicated by chaotic resistance pattern.
+    
+    Phase 5 - Final Open State:
+    Healthy: High/stable resistance (around open circuit baseline), zero/low current (around open circuit baseline), stable travel at minimum (fully open position, no rebound/drift).
+    Unhealthy: Resistance not reaching open circuit baseline or current not reaching open circuit baseline (leakage/contaminated insulation), travel rebound/drift (damping issues), travel not reaching full open position (obstructions).
+    """
+    
+    # Reference key_characteristics for each phase
+    reference_key_characteristics = {
+        1: [
+            "Contacts are physically separated",
+            "No electrical conduction",
+            "Travel distance increasing as contacts approach",
+            "High resistance due to air gap"
+        ],
+        2: [
+            "Sharp drop in resistance",
+            "Current injection initiation",
+            "Initial contact touch point",
+            "Potential for contact bounce"
+        ],
+        3: [
+            "Minimum contact resistance",
+            "Maximum current flow",
+            "No mechanical movement",
+            "Trip coil energization initiated (towards end)"
+        ],
+        4: [
+            "Physical contact separation",
+            "Arc elongation",
+            "Current interruption",
+            "Rapid decrease in travel"
+        ],
+        5: [
+            "Circuit fully isolated",
+            "Contacts at rest position",
+            "Arc fully extinguished",
+            "Trip coil de-energization"
+        ]
+    }
+    
+    prompt = f"""
+    You are an expert in Dynamic Contact Resistance Measurement (DCRM) analysis for circuit breakers.
+    Your task is to generate FOUR specific outputs for a DCRM phase based on numerical data analysis:
+
+    1. "key_characteristics" - Output 3-4 short, direct phrases describing the main physical/electrical events of this phase.
+    2. "event_synopsis" - A concise 1-2 sentence summary of what actually occurred in this phase.
+    3. "diagnostic_verdict_details" - A detailed 2-4 sentence analysis explaining the health verdict with specific numerical evidence from the "Numerical Data Summary" and justifying it against the "DCRM Phase-Wise Diagnostic Criteria Reference". Be explicit with numbers and thresholds.
+    4. "confidence_score" - An integer from 0 to 100 indicating your confidence in the diagnostic verdict.
+
+    **Phase Context:**
+    - Phase Name: {phase_info['name']}
+    - Operation Title: {phase_info['phaseTitle']}
+    - Subheading: {phase_info['description']}
+    - Time Interval: {phase_data_summary['time_interval']}
+    - Phase ID: {phase_info['id']}
+
+    **Numerical Data Summary for this Phase:**
+    - Resistance: Min={phase_data_summary['resistance_min']:.2f} μΩ, Max={phase_data_summary['resistance_max']:.2f} μΩ, Avg={phase_data_summary['resistance_avg']:.2f} μΩ, StdDev={phase_data_summary['resistance_std']:.2f} μΩ
+    - Current: Min={phase_data_summary['current_min']:.2f} A, Max={phase_data_summary['current_max']:.2f} A, Avg={phase_data_summary['current_avg']:.2f} A, StdDev={phase_data_summary['current_std']:.2f} A
+    - Travel: Min={phase_data_summary['travel_min']:.2f} mm, Max={phase_data_summary['travel_max']:.2f} mm, Avg={phase_data_summary['travel_avg']:.2f} mm, StdDev={phase_data_summary['travel_std']:.2f} mm
+    - Close Coil: State = '{phase_data_summary['close_coil_state']}' (Avg: {phase_data_summary['close_coil_avg']:.2f} A)
+    - Trip Coil 1: State = '{phase_data_summary['trip_coil_1_state']}' (Avg: {phase_data_summary['trip_coil_1_avg']:.2f} A)
+    - Trip Coil 2: State = '{phase_data_summary['trip_coil_2_state']}' (Avg: {phase_data_summary['trip_coil_2_avg']:.2f} A)
+
+    **Programmatic Health Status:** {phase_data_summary['programmatic_health_status']}
+
+    {dcrm_diagnostic_reference}
+
+    **Reference key_characteristics for this phase:**
+    {reference_key_characteristics.get(phase_info['phaseNumber'], [])}
+
+    **Instructions:**
+    - Analyze the numerical data against the diagnostic criteria reference above for the specific phase.
+    - Focus the 'diagnostic_verdict_details' on explaining *why* the 'Programmatic Health Status' was assigned, using the specific measured values provided.
+    - For 'key_characteristics', output 3-4 short, direct phrases describing the main physical/electrical events of this phase.
+    - Provide specific numerical evidence in diagnostic_verdict_details.
+    - For 'confidence_score', assess how well the measured data aligns with the expected patterns for the given health status. Higher alignment = higher confidence.
+    - Output ONLY a valid JSON object with these exact keys:
+      {{"key_characteristics": ["characteristic1", "characteristic2"], "event_synopsis": "synopsis text", "diagnostic_verdict_details": "details text", "confidence_score": 85}}
+    """
+    return prompt
+
+# --- Core DCRM Analysis Function ---
+def analyze_dcrm_data(df, llm=None):
+    """
+    Analyzes DCRM DataFrame to segment phases, determine health, and format JSON output.
+
+    Args:
+        df (pd.DataFrame): Input DataFrame with DCRM data.
+                           Expected columns: Time_ms, Resistance, Current, Travel,
+                           Close_Coil, Trip_Coil_1, Trip_Coil_2.
+        llm (LangChain LLM object, optional): LLM to use for generating descriptions.
+
+    Returns:
+        dict: A dictionary representing the DCRM phase-wise interpretation in JSON format.
+    """
+
+    # Ensure Time_ms is the index for easier slicing
+    if 'Time_ms' in df.columns:
+        df = df.set_index('Time_ms')
+    else:
+        # If no Time_ms, assume index is time or create it
+        if df.index.name != 'Time_ms':
+             # Create Time_ms if not present, assuming 1ms steps
+             df['Time_ms'] = range(len(df))
+             df = df.set_index('Time_ms')
+
+    # Convert columns to numeric, coercing errors to NaN
+    numeric_cols = ['Resistance', 'Current', 'Travel', 'Close_Coil', 'Trip_Coil_1', 'Trip_Coil_2']
+    for col in numeric_cols:
+        if col in df.columns:
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+        else:
+            # Handle missing columns gracefully
+            df[col] = 0.0
+            
+    df = df.dropna() # Drop rows with any NaN created by coercion
+
+    if df.empty:
+        return {"error": "Input DataFrame is empty after cleaning."}
+
+    # --- Optimized Dynamic Phase Boundary Detection Thresholds ---
+    # Based on EHV DCRM domain knowledge and international standards (IEC, IEEE)
+    
+    # OPEN CIRCUIT THRESHOLDS (Phase 1 & 5)
+    OPEN_CIRCUIT_RESISTANCE_IDEAL = 100000     # Ideal infinite resistance (≥ 10⁵ μΩ) for perfect open circuit
+    OPEN_CIRCUIT_RESISTANCE_MIN = 750          # Minimum acceptable high resistance (straight line threshold for EHV)
+    OPEN_CIRCUIT_VARIATION_THRESHOLD = 30      # ±30 μΩ flat variation is healthy for open circuit (straight line)
+    
+    # CLOSED CIRCUIT THRESHOLDS (Phase 3 - Main Contact Plateau)
+    CLOSED_CIRCUIT_RESISTANCE_BASELINE = 200   # Typical ~200 μΩ for healthy main contact plateau in EHV
+    CLOSED_CIRCUIT_RESISTANCE_MAX = 350        # Upper limit for acceptable main contact (allowing tolerance for EHV)
+    CLOSED_CIRCUIT_VARIATION_THRESHOLD = 50    # ±50 μΩ deviation for healthy stable plateau
+    
+    # ARCING THRESHOLDS (Phase 2 & 4)
+    ARCING_RESISTANCE_MIN = 300                # Arcing typically starts around 300-500 μΩ
+    ARCING_RESISTANCE_MAX = 5000               # Arcing spikes can reach 3500-5000 μΩ in healthy operation
+    ARCING_STDDEV_HEALTHY_MIN = 80             # Minimum StdDev for healthy arcing (indicates arcing activity)
+    ARCING_SPIKE_FACTOR = 1.8                  # Max should be at least 1.8x Min for healthy arcing spikes
+    
+    # CURRENT & TRAVEL BASELINES (from observed data)
+    OPEN_CIRCUIT_CURRENT_BASELINE = 230        # Typical open circuit current (leakage/capacitive)
+    CLOSED_CIRCUIT_CURRENT_BASELINE = 715      # Test current injection level during conduction
+    TRAVEL_MIN_POSITION = 200                  # Fully open position (minimum travel)
+    TRAVEL_MAX_POSITION = 750                  # Fully closed position (maximum travel/overtravel)
+
+    # PHASE DETECTION THRESHOLDS (for boundary identification)
+    COIL_ACTIVE_THRESHOLD = 0.5                # Coil current above this indicates activation (A)
+    GRADIENT_R_CHANGE = 50                     # Minimum resistance gradient for phase transition detection (μΩ/ms)
+    GRADIENT_I_CHANGE = 50                     # Minimum current gradient for phase transition detection (A/ms)
+    TRAVEL_MOVEMENT_RATE_THRESHOLD = 1.0       # Minimum travel rate to detect active movement (mm/ms)
+
+    time_min = df.index.min()
+    time_max = df.index.max()
+    time_step = np.mean(np.diff(df.index)) if len(df.index) > 1 else 1.0 # Average time step, default to 1ms if only one point
+
+    # Initialize phase start and end times
+    phase_start_times = {1: time_min}
+    phase_end_times = {5: time_max} # Phase 5 always extends to the end of the data
+
+    # Helper to calculate rolling mean of differences (gradient)
+    def rolling_gradient(series, window=5):
+        if len(series) < window: # Handle cases where series is shorter than window
+            return series.diff()
+        return series.diff().rolling(window=window, min_periods=1).mean()
+
+    # --- Detection Logic (Refined) ---
+
+    # 1. Detect Contact Make (End of Phase 1 / Start of Phase 2)
+    # Look for a sharp drop in Resistance OR sharp rise in Current, AFTER Close_Coil activation.
+    close_coil_active_idx = df[df['Close_Coil'] > COIL_ACTIVE_THRESHOLD].index
+    close_op_start = close_coil_active_idx.min() if not close_coil_active_idx.empty else time_min # Start from beginning if no clear close coil activation
+
+    resistance_gradient_neg = rolling_gradient(df['Resistance'], window=3) # Smaller window for sharper detection
+    current_gradient_pos = rolling_gradient(df['Current'], window=3)
+
+    contact_make_candidates = df.loc[df.index >= close_op_start].index[
+        (resistance_gradient_neg.loc[df.index >= close_op_start] < -GRADIENT_R_CHANGE) | # Significant drop in R
+        (current_gradient_pos.loc[df.index >= close_op_start] > GRADIENT_I_CHANGE)     # Significant rise in I
+    ]
+
+    contact_make_time = time_max # Default to end
+    if not contact_make_candidates.empty:
+        contact_make_time = contact_make_candidates.min()
+    else: # Fallback: first time current is significantly active after close op start AND resistance has dropped
+        current_active_after_close_op = df.loc[df.index >= close_op_start].index[
+            (df['Current'].loc[df.index >= close_op_start] > OPEN_CIRCUIT_CURRENT_BASELINE + 50) & # Current rising significantly
+            (df['Resistance'].loc[df.index >= close_op_start] < OPEN_CIRCUIT_RESISTANCE_MIN) # Resistance has dropped significantly from open circuit
+        ]
+        if not current_active_after_close_op.empty:
+            contact_make_time = current_active_after_close_op.min()
+        else:
+            contact_make_time = df.index.min() + (df.index.max() - df.index.min()) * 0.20 # Fallback to 20% into data if no clear event
+
+    phase_end_times[1] = contact_make_time - time_step
+    phase_start_times[2] = contact_make_time
+
+    # 2. Detect Conduction Stabilization (End of Phase 2 / Start of Phase 3)
+    # Look for Resistance near CLOSED_CIRCUIT_RESISTANCE_BASELINE AND Current near CLOSED_CIRCUIT_CURRENT_BASELINE AND both are stable.
+    stable_conduction_candidates = df.loc[df.index >= phase_start_times[2]].index[
+        (df['Resistance'].loc[df.index >= phase_start_times[2]].between(CLOSED_CIRCUIT_RESISTANCE_BASELINE - 100, CLOSED_CIRCUIT_RESISTANCE_MAX + 50)) &
+        (df['Current'].loc[df.index >= phase_start_times[2]].between(CLOSED_CIRCUIT_CURRENT_BASELINE - 100, CLOSED_CIRCUIT_CURRENT_BASELINE + 50)) &
+        (df['Resistance'].loc[df.index >= phase_start_times[2]].rolling(window=10, min_periods=1).std() < 30) & # Low std dev for stability (increased tolerance)
+        (df['Current'].loc[df.index >= phase_start_times[2]].rolling(window=10, min_periods=1).std() < 30)
+    ]
+
+    conduction_start_time = time_max
+    if not stable_conduction_candidates.empty:
+        conduction_start_time = stable_conduction_candidates.min()
+    else: # Fallback: assume conduction starts when resistance first drops very low and current is high
+        low_res_high_curr_first_hit = df.loc[df.index >= phase_start_times[2]].index[
+            (df['Resistance'].loc[df.index >= phase_start_times[2]] < CLOSED_CIRCUIT_RESISTANCE_MAX) & # Clearly dropped to conduction level
+            (df['Current'].loc[df.index >= phase_start_times[2]] > CLOSED_CIRCUIT_CURRENT_BASELINE - 100) # Clearly risen to conduction level
+        ]
+        if not low_res_high_curr_first_hit.empty:
+            conduction_start_time = low_res_high_curr_first_hit.min()
+        else:
+            conduction_start_time = phase_start_times[2] + 10.0 # Ensure a minimum 10ms duration for phase 2 if no clear event
+
+    phase_end_times[2] = conduction_start_time - time_step
+    phase_start_times[3] = conduction_start_time
+
+    # 3. Detect Contact Break (End of Phase 3 / Start of Phase 4)
+    # Look for Trip_Coil_1 activation OR a sharp rise in Resistance OR sharp drop in Current.
+    trip_coil_active_idx = df[df['Trip_Coil_1'] > COIL_ACTIVE_THRESHOLD].index
+    trip_op_start = trip_coil_active_idx.min() if not trip_coil_active_idx.empty else phase_start_times[3] + (df.index.max() - phase_start_times[3]) * 0.5 # Midpoint if no trip coil
+
+    resistance_gradient_pos = rolling_gradient(df['Resistance'], window=3)
+    current_gradient_neg = rolling_gradient(df['Current'], window=3)
+
+    contact_break_candidates = df.loc[df.index >= trip_op_start].index[
+        (resistance_gradient_pos.loc[df.index >= trip_op_start] > GRADIENT_R_CHANGE) | # Significant rise in R
+        (current_gradient_neg.loc[df.index >= trip_op_start] < -GRADIENT_I_CHANGE)    # Significant drop in I
+    ]
+
+    contact_break_time = time_max
+    if not contact_break_candidates.empty:
+        contact_break_time = contact_break_candidates.min()
+    else: # Fallback: first time current is low again and resistance is high after trip op start
+        current_low_high_res_after_trip_op = df.loc[df.index >= trip_op_start].index[
+            (df['Current'].loc[df.index >= trip_op_start] < CLOSED_CIRCUIT_CURRENT_BASELINE - 100) & # Current dropping significantly
+            (df['Resistance'].loc[df.index >= trip_op_start] > CLOSED_CIRCUIT_RESISTANCE_BASELINE + 100) # Resistance rising significantly
+        ]
+        if not current_low_high_res_after_trip_op.empty:
+            contact_break_time = current_low_high_res_after_trip_op.min()
+        else:
+            contact_break_time = phase_start_times[3] + (df.index.max() - phase_start_times[3]) * 0.75 # Default to later if no clear break
+
+    phase_end_times[3] = contact_break_time - time_step
+    phase_start_times[4] = contact_break_time
+
+    # 4. Detect Final Open State Stabilization (End of Phase 4 / Start of Phase 5)
+    # Look for Resistance high AND Current near OPEN_CIRCUIT_CURRENT_BASELINE AND Travel is stable at min position.
+    final_open_stable_candidates = df.loc[df.index >= phase_start_times[4]].index[
+        (df['Resistance'].loc[df.index >= phase_start_times[4]] > OPEN_CIRCUIT_RESISTANCE_MIN - 50) & # High resistance
+        (df['Current'].loc[df.index >= phase_start_times[4]].between(OPEN_CIRCUIT_CURRENT_BASELINE - 50, OPEN_CIRCUIT_CURRENT_BASELINE + 50)) &
+        (df['Travel'].loc[df.index >= phase_start_times[4]].rolling(window=10, min_periods=1).std() < 2) # Travel stability
+    ]
+
+    final_open_time = time_max
+    if not final_open_stable_candidates.empty:
+        final_open_time = final_open_stable_candidates.min()
+    else: # Fallback: when travel stops moving after contact break
+        travel_still_moving = df.loc[df.index >= phase_start_times[4]].index[rolling_gradient(df['Travel']).loc[df.index >= phase_start_times[4]].abs() > TRAVEL_MOVEMENT_RATE_THRESHOLD]
+        if not travel_still_moving.empty:
+            final_open_time = travel_still_moving.max() + 5 * time_step # End of significant travel movement
+        else:
+            final_open_time = df.index.max() - 20.0 # Default to near end if no clear stabilization
+
+    phase_end_times[4] = final_open_time - time_step
+    phase_start_times[5] = final_open_time
+
+    # --- Ensure Phase Times are Valid and Sequential ---
+    current_end = df.index.min() - time_step
+    for p_id in sorted(phase_start_times.keys()):
+        start_time_candidate = phase_start_times[p_id]
+        end_time_candidate = phase_end_times[p_id]
+
+        start_idx_loc = df.index.get_indexer([start_time_candidate], method='nearest')[0]
+        end_idx_loc = df.index.get_indexer([end_time_candidate], method='nearest')[0]
+
+        phase_start_times[p_id] = df.index[start_idx_loc]
+        phase_end_times[p_id] = df.index[end_idx_loc]
+
+        if phase_start_times[p_id] < current_end:
+            phase_start_times[p_id] = current_end
+            if phase_start_times[p_id] >= phase_end_times[p_id]:
+                # Ensure minimum 5ms duration for a phase, or until max_time if near end
+                phase_end_times[p_id] = min(phase_start_times[p_id] + time_step * 5, time_max) 
+                # If still problematic, try to give it at least 1 point
+                if phase_start_times[p_id] == phase_end_times[p_id] and phase_start_times[p_id] < time_max:
+                    next_idx = df.index.get_indexer([phase_start_times[p_id] + time_step], method='nearest')[0]
+                    if next_idx < len(df.index):
+                        phase_end_times[p_id] = df.index[next_idx]
+
+        current_end = phase_end_times[p_id]
+
+    if 5 in phase_end_times:
+         phase_end_times[5] = time_max # Ensure the last phase always goes to the end
+
+
+    # --- JSON Structure Template (static definitions) ---
+    json_output_template = {
+      "phaseWiseAnalysis": [
+          {
+            "phaseNumber": 1,
+            "id": "pre-contact-travel",
+            "name": "Pre-Contact Travel",
+            "phaseTitle": "Closing Operation — Pre-Contact Travel",
+            "description": "Initial state before arc contact occurs",
+            "color": "#ff9800"
+          },
+          {
+            "phaseNumber": 2,
+            "id": "arcing-contact-engagement-arc-initiation",
+            "name": "Arcing Contact Engagement & Arc Initiation",
+            "phaseTitle": "Closing Operation — Arcing Contact Engagement & Arc Initiation",
+            "description": "Arcing contact engagement and arc initiation",
+            "color": "#ff26bd"
+          },
+          {
+            "phaseNumber": 3,
+            "id": "main-contact-conduction",
+            "name": "Main Contact Conduction",
+            "phaseTitle": "Fully Closed State — Main Contact Conduction",
+            "description": "Main contact conduction",
+            "color": "#4caf50"
+          },
+          {
+            "phaseNumber": 4,
+            "id": "main-contact-parting-arc-elongation",
+            "name": "Main Contact Parting & Arc Elongation",
+            "phaseTitle": "Opening Operation — Main Contact Parting & Arc Elongation",
+            "description": "Main contact parting and arc elongation",
+            "color": "#2196f3"
+          },
+          {
+            "phaseNumber": 5,
+            "id": "final-open-state",
+            "name": "Final Open State",
+            "phaseTitle": "Post-Interruption — Final Open State",
+            "description": "Final open state",
+            "color": "#a629ff"
+          }
+        ]
+    }
+
+    final_segmented_phases = []
+
+    # Populate the JSON structure dynamically
+    for phase_data_template in json_output_template['phaseWiseAnalysis']:
+        phase_id = phase_data_template['phaseNumber']
+        start_time = phase_start_times.get(phase_id)
+        end_time = phase_end_times.get(phase_id)
+
+        if start_time is None or end_time is None or start_time >= end_time:
+            continue
+
+        phase_data = df.loc[(df.index >= start_time) & (df.index <= end_time)]
+
+        if phase_data.empty:
+            continue
+
+        current_phase_entry = phase_data_template.copy()
+        current_phase_entry['startTime'] = int(start_time)
+        current_phase_entry['endTime'] = int(end_time)
+        current_phase_entry['details'] = {
+            "resistance": "",
+            "current": "",
+            "travel": "",
+            "characteristics": []
+        }
+        current_phase_entry['waveformAnalysis'] = {
+            "resistance": "",
+            "current": "",
+            "travel": "",
+            "coilAnalysis": {
+                "closeCoil": {"status": "", "description": "", "measuredValues": ""},
+                "tripCoil1": {"status": "", "description": "", "measuredValues": ""},
+                "tripCoil2": {"status": "", "description": "", "measuredValues": ""}
+            }
+        }
+        current_phase_entry['diagnosticVerdict'] = ""
+        current_phase_entry['eventSynopsis'] = ""
+        current_phase_entry['confidence'] = 0
+        current_phase_entry['status'] = "Unknown"
+
+        current_data_summary = {
+            'time_interval': f"{start_time:.1f}ms - {end_time:.1f}ms",
+            'resistance_min': phase_data['Resistance'].min(),
+            'resistance_max': phase_data['Resistance'].max(),
+            'resistance_avg': phase_data['Resistance'].mean(),
+            'resistance_std': phase_data['Resistance'].std() if len(phase_data) > 1 else 0,
+            'current_min': phase_data['Current'].min(),
+            'current_max': phase_data['Current'].max(),
+            'current_avg': phase_data['Current'].mean(),
+            'current_std': phase_data['Current'].std() if len(phase_data) > 1 else 0,
+            'travel_min': phase_data['Travel'].min(),
+            'travel_max': phase_data['Travel'].max(),
+            'travel_avg': phase_data['Travel'].mean(),
+            'travel_std': phase_data['Travel'].std() if len(phase_data) > 1 else 0,
+            'close_coil_avg': phase_data['Close_Coil'].mean(),
+            'trip_coil_1_avg': phase_data['Trip_Coil_1'].mean(),
+            'trip_coil_2_avg': phase_data['Trip_Coil_2'].mean(),
+            'close_coil_state': get_coil_state(phase_data['Close_Coil']),
+            'trip_coil_1_state': get_coil_state(phase_data['Trip_Coil_1']),
+            'trip_coil_2_state': get_coil_state(phase_data['Trip_Coil_2']),
+            'programmatic_health_status': "Unknown",
+            'resistance_status': "",
+            'current_status': "",
+            'travel_status': ""
+        }
+
+        # --- Health Verdict Logic (Optimized) ---
+        # (Same logic as backup_DCRM2.py, ensuring it populates current_data_summary and current_phase_entry)
+        
+        if phase_id == 1: # PRE-CONTACT TRAVEL
+            is_resistance_infinite = current_data_summary['resistance_avg'] >= OPEN_CIRCUIT_RESISTANCE_IDEAL
+            is_resistance_high_and_flat = (current_data_summary['resistance_avg'] >= OPEN_CIRCUIT_RESISTANCE_MIN and 
+                                           current_data_summary['resistance_std'] <= OPEN_CIRCUIT_VARIATION_THRESHOLD)
+            
+            if is_resistance_infinite or is_resistance_high_and_flat:
+                current_data_summary['programmatic_health_status'] = "Healthy"
+                current_data_summary['resistance_status'] = "High and Stable (Open Circuit)"
+                if is_resistance_infinite:
+                    resistance_desc = f"Resistance is infinite (Avg: {current_data_summary['resistance_avg']:.1f} μΩ ≥ {OPEN_CIRCUIT_RESISTANCE_IDEAL} μΩ) with minimal variation (StdDev: {current_data_summary['resistance_std']:.1f} μΩ), indicating proper open circuit with clean air gap and no premature contact."
+                else:
+                    resistance_desc = f"Resistance is high and stable (Avg: {current_data_summary['resistance_avg']:.1f} μΩ ≥ {OPEN_CIRCUIT_RESISTANCE_MIN} μΩ) with flat straight-line pattern (StdDev: {current_data_summary['resistance_std']:.1f} μΩ ≤ ±{OPEN_CIRCUIT_VARIATION_THRESHOLD} μΩ), indicating proper open circuit with clean separation and no premature contact."
+                
+                current_phase_entry['waveformAnalysis']['resistance'] = resistance_desc
+                current_phase_entry['waveformAnalysis']['current'] = f"Current remains stable around its open circuit baseline of {OPEN_CIRCUIT_CURRENT_BASELINE:.1f} A (Avg: {current_data_summary['current_avg']:.1f}), reinforcing no premature electrical connection."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel shows a smooth, continuous increase from {current_data_summary['travel_min']:.1f} mm to {current_data_summary['travel_max']:.1f} mm, representing unimpeded mechanical movement."
+                
+                current_phase_entry['details']['resistance'] = f"High resistance (~{current_data_summary['resistance_avg']:.0f} µΩ) - contacts are open"
+                current_phase_entry['details']['current'] = f"Low current (~{current_data_summary['current_avg']:.0f}) - no current flow"
+                current_phase_entry['details']['travel'] = f"Gradual increase from {current_data_summary['travel_min']:.0f} to {current_data_summary['travel_max']:.0f} - contact approaching"
+            else:
+                current_data_summary['programmatic_health_status'] = "Unhealthy - Pre-Contact Issues"
+                current_phase_entry['waveformAnalysis']['resistance'] = f"Resistance is too low (Avg: {current_data_summary['resistance_avg']:.1f} μΩ < {OPEN_CIRCUIT_RESISTANCE_MIN} μΩ) or shows excessive variation (StdDev: {current_data_summary['resistance_std']:.1f} μΩ > ±{OPEN_CIRCUIT_VARIATION_THRESHOLD} μΩ), suggesting premature contact, leakage, or insulation breakdown."
+                current_phase_entry['waveformAnalysis']['current'] = f"Current was not consistently around {OPEN_CIRCUIT_CURRENT_BASELINE:.1f} A (Avg: {current_data_summary['current_avg']:.1f} A), indicating a premature electrical connection or abnormal current path."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel was not smooth, failed to ramp up sufficiently (Range: {current_data_summary['travel_min']:.1f} to {current_data_summary['travel_max']:.1f} mm), or showed erratic movement, indicating mechanical binding or obstruction."
+                
+                current_phase_entry['details']['resistance'] = f"Abnormal resistance (~{current_data_summary['resistance_avg']:.0f} µΩ) - premature contact"
+                current_phase_entry['details']['current'] = f"Abnormal current (~{current_data_summary['current_avg']:.0f}) - unexpected flow"
+                current_phase_entry['details']['travel'] = f"Erratic travel from {current_data_summary['travel_min']:.0f} to {current_data_summary['travel_max']:.0f} - binding detected"
+
+        elif phase_id == 2: # Arcing Contact Engagement
+            resistance_range = current_data_summary['resistance_max'] - current_data_summary['resistance_min']
+            current_rise_magnitude = current_data_summary['current_max'] - current_data_summary['current_min']
+            
+            resistance_drops_significantly = (current_data_summary['resistance_max'] > 500 and 
+                                             current_data_summary['resistance_min'] < CLOSED_CIRCUIT_RESISTANCE_MAX + 100 and
+                                             resistance_range > 200)
+            
+            has_healthy_arcing_spikes = (current_data_summary['resistance_max'] > ARCING_RESISTANCE_MIN * 2 and
+                                         current_data_summary['resistance_std'] > 80 and
+                                         current_data_summary['resistance_max'] / max(current_data_summary['resistance_min'], 1) > 1.8)
+            
+            current_rises_properly = (current_rise_magnitude > 250 and
+                                     current_data_summary['current_max'] > CLOSED_CIRCUIT_CURRENT_BASELINE * 0.6)
+            
+            travel_increasing = (current_data_summary['travel_max'] - current_data_summary['travel_min']) > 100
+            
+            if resistance_drops_significantly and has_healthy_arcing_spikes and current_rises_properly and travel_increasing:
+                current_data_summary['programmatic_health_status'] = "Healthy"
+                current_phase_entry['waveformAnalysis']['resistance'] = f"Resistance exhibits healthy arcing behavior: sharp drop from {current_data_summary['resistance_max']:.1f} μΩ to {current_data_summary['resistance_min']:.1f} μΩ (Range: {resistance_range:.1f} μΩ) with prominent high-frequency arcing spikes (StdDev: {current_data_summary['resistance_std']:.1f} μΩ > 80), indicating proper arc initiation as arcing contacts engage."
+                current_phase_entry['waveformAnalysis']['current'] = f"Current rises sharply from {current_data_summary['current_min']:.1f} A to {current_data_summary['current_max']:.1f} A (Rise: {current_rise_magnitude:.1f} A), establishing conduction path."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel increases smoothly from {current_data_summary['travel_min']:.1f} mm to {current_data_summary['travel_max']:.1f} mm."
+                
+                current_phase_entry['details']['resistance'] = f"Highly variable ({current_data_summary['resistance_min']:.0f}-{current_data_summary['resistance_max']:.0f} µΩ) - arcing occurs"
+                current_phase_entry['details']['current'] = f"Sharp rise to ~{current_data_summary['current_max']:.0f} - current flow begins"
+                current_phase_entry['details']['travel'] = f"Continues to increase to ~{current_data_summary['travel_max']:.0f} - contacts closing"
+            else:
+                current_data_summary['programmatic_health_status'] = "Unhealthy - Arcing/Contact Issue"
+                if not has_healthy_arcing_spikes:
+                    current_phase_entry['waveformAnalysis']['resistance'] = f"CRITICAL ISSUE: Resistance pattern lacks expected high-frequency arcing spikes (Max: {current_data_summary['resistance_max']:.1f} μΩ, StdDev: {current_data_summary['resistance_std']:.1f} μΩ << 80 μΩ expected). This indicates SEVERELY WORN arcing contacts."
+                elif not resistance_drops_significantly:
+                    current_phase_entry['waveformAnalysis']['resistance'] = f"CRITICAL ISSUE: Resistance fails to drop adequately (Max: {current_data_summary['resistance_max']:.1f} μΩ, Min: {current_data_summary['resistance_min']:.1f} μΩ). This indicates CONTACT MISALIGNMENT or mechanical binding."
+                else:
+                    current_phase_entry['waveformAnalysis']['resistance'] = f"Resistance pattern shows abnormal arcing behavior (Range: {current_data_summary['resistance_min']:.1f} to {current_data_summary['resistance_max']:.1f} μΩ)."
+                
+                current_phase_entry['waveformAnalysis']['current'] = f"Current rise is inadequate or abnormal (Rise: {current_rise_magnitude:.1f} A)."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel pattern: {current_data_summary['travel_min']:.1f} to {current_data_summary['travel_max']:.1f} mm."
+                
+                current_phase_entry['details']['resistance'] = f"Abnormal ({current_data_summary['resistance_min']:.0f}-{current_data_summary['resistance_max']:.0f} µΩ) - contact issue"
+                current_phase_entry['details']['current'] = f"Poor rise to ~{current_data_summary['current_max']:.0f} - impedance detected"
+                current_phase_entry['details']['travel'] = f"Range to ~{current_data_summary['travel_max']:.0f} - issue detected"
+
+        elif phase_id == 3: # Main Contact Conduction
+            is_resistance_low = current_data_summary['resistance_avg'] <= CLOSED_CIRCUIT_RESISTANCE_MAX
+            is_resistance_flat_plateau = current_data_summary['resistance_std'] <= CLOSED_CIRCUIT_VARIATION_THRESHOLD
+            has_abnormal_spikes = current_data_summary['resistance_max'] > CLOSED_CIRCUIT_RESISTANCE_MAX + 100
+            is_current_stable = abs(current_data_summary['current_avg'] - CLOSED_CIRCUIT_CURRENT_BASELINE) < 50 and current_data_summary['current_std'] < 30
+            is_travel_stable = current_data_summary['travel_std'] < 5 and abs(current_data_summary['travel_avg'] - TRAVEL_MAX_POSITION) < 20
+
+            if is_resistance_low and is_resistance_flat_plateau and not has_abnormal_spikes and is_current_stable and is_travel_stable:
+                current_data_summary['programmatic_health_status'] = "Healthy"
+                current_phase_entry['waveformAnalysis']['resistance'] = f"Resistance maintains a healthy flat plateau at low values (Avg: {current_data_summary['resistance_avg']:.1f} μΩ) with minimal deviation."
+                current_phase_entry['waveformAnalysis']['current'] = f"Current remains high and stable, around {CLOSED_CIRCUIT_CURRENT_BASELINE:.1f} A (Avg: {current_data_summary['current_avg']:.1f})."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel remains perfectly stable at its maximum stroke of approximately {TRAVEL_MAX_POSITION:.1f} mm."
+                
+                current_phase_entry['details']['resistance'] = f"Stable low resistance (~{current_data_summary['resistance_avg']:.0f} µΩ) - good contact"
+                current_phase_entry['details']['current'] = f"Gradual decline from {current_data_summary['current_max']:.0f} to {current_data_summary['current_min']:.0f} - stable flow"
+                current_phase_entry['details']['travel'] = f"Constant at ~{current_data_summary['travel_avg']:.0f} - contacts fully closed"
+            else:
+                current_data_summary['programmatic_health_status'] = "Unhealthy - Contact Degradation"
+                current_phase_entry['waveformAnalysis']['resistance'] = f"Resistance is unhealthy: either elevated (Avg: {current_data_summary['resistance_avg']:.1f} μΩ), shows high abnormal spikes, or lacks flat plateau."
+                current_phase_entry['waveformAnalysis']['current'] = f"Current was unstable or lower than expected (Avg: {current_data_summary['current_avg']:.1f} A)."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel was not stable at its maximum (Avg: {current_data_summary['travel_avg']:.1f} mm)."
+                
+                current_phase_entry['details']['resistance'] = f"Elevated resistance (~{current_data_summary['resistance_avg']:.0f} µΩ) - degradation"
+                current_phase_entry['details']['current'] = f"Unstable current (~{current_data_summary['current_avg']:.0f}) - poor conduction"
+                current_phase_entry['details']['travel'] = f"Unstable at ~{current_data_summary['travel_avg']:.0f} - insufficient overtravel"
+
+        elif phase_id == 4: # Main Contact Parting
+            resistance_rise_magnitude = current_data_summary['resistance_max'] - current_data_summary['resistance_min']
+            current_drop_magnitude = current_data_summary['current_max'] - current_data_summary['current_min']
+            travel_drop_magnitude = current_data_summary['travel_max'] - current_data_summary['travel_min']
+            
+            resistance_rises_smoothly = (current_data_summary['resistance_min'] < CLOSED_CIRCUIT_RESISTANCE_MAX + 100 and
+                                        resistance_rise_magnitude > 300)
+            current_drops_steadily = current_drop_magnitude > 200
+            travel_decreases_properly = travel_drop_magnitude > 400
+            has_smooth_progressive_rise = current_data_summary['resistance_std'] < 250
+            
+            if resistance_rises_smoothly and current_drops_steadily and travel_decreases_properly and has_smooth_progressive_rise:
+                current_data_summary['programmatic_health_status'] = "Healthy"
+                current_phase_entry['waveformAnalysis']['resistance'] = f"Resistance rises smoothly and progressively from {current_data_summary['resistance_min']:.1f} μΩ to {current_data_summary['resistance_max']:.1f} μΩ."
+                current_phase_entry['waveformAnalysis']['current'] = f"Current drops steadily from {current_data_summary['current_max']:.1f} A to {current_data_summary['current_min']:.1f} A."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel decreases smoothly from {current_data_summary['travel_max']:.1f} mm to {current_data_summary['travel_min']:.1f} mm."
+                
+                current_phase_entry['details']['resistance'] = f"Rising from {current_data_summary['resistance_min']:.0f} to {current_data_summary['resistance_max']:.0f} µΩ - contacts separating"
+                current_phase_entry['details']['current'] = f"Sharp drop from {current_data_summary['current_max']:.0f} to {current_data_summary['current_min']:.0f} - current flow stops"
+                current_phase_entry['details']['travel'] = f"Sharp drop from {current_data_summary['travel_max']:.0f} to {current_data_summary['travel_min']:.0f} - contacts opening"
+            else:
+                current_data_summary['programmatic_health_status'] = "Unhealthy - Opening/Interruption Issue"
+                current_phase_entry['waveformAnalysis']['resistance'] = f"Resistance rise pattern is abnormal (Rise: {resistance_rise_magnitude:.1f} μΩ, StdDev: {current_data_summary['resistance_std']:.1f} μΩ)."
+                current_phase_entry['waveformAnalysis']['current'] = f"Current drop is insufficient or erratic (Drop: {current_drop_magnitude:.1f} A)."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel decrease is insufficient or erratic (Drop: {travel_drop_magnitude:.1f} mm)."
+                
+                current_phase_entry['details']['resistance'] = f"Abnormal rise {current_data_summary['resistance_min']:.0f} to {current_data_summary['resistance_max']:.0f} µΩ - issue detected"
+                current_phase_entry['details']['current'] = f"Erratic drop {current_data_summary['current_max']:.0f} to {current_data_summary['current_min']:.0f} - interruption problem"
+                current_phase_entry['details']['travel'] = f"Abnormal drop {current_data_summary['travel_max']:.0f} to {current_data_summary['travel_min']:.0f} - mechanical issue"
+
+        elif phase_id == 5: # Final Open State
+            is_resistance_infinite = current_data_summary['resistance_avg'] >= OPEN_CIRCUIT_RESISTANCE_IDEAL
+            is_resistance_high_and_flat = (current_data_summary['resistance_avg'] >= OPEN_CIRCUIT_RESISTANCE_MIN and 
+                                           current_data_summary['resistance_std'] <= OPEN_CIRCUIT_VARIATION_THRESHOLD)
+            is_current_healthy = abs(current_data_summary['current_avg'] - OPEN_CIRCUIT_CURRENT_BASELINE) < 20 and current_data_summary['current_std'] < 20
+            is_travel_low_stable = current_data_summary['travel_std'] < 5 and abs(current_data_summary['travel_avg'] - TRAVEL_MIN_POSITION) < 20
+
+            if (is_resistance_infinite or is_resistance_high_and_flat) and is_current_healthy and is_travel_low_stable:
+                current_data_summary['programmatic_health_status'] = "Healthy"
+                current_phase_entry['waveformAnalysis']['resistance'] = f"Resistance remains high and stable (Avg: {current_data_summary['resistance_avg']:.1f} μΩ)."
+                current_phase_entry['waveformAnalysis']['current'] = f"Current remains stable around its open circuit baseline."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel remains stable at the fully open position."
+                
+                current_phase_entry['details']['resistance'] = f"High resistance (~{current_data_summary['resistance_avg']:.0f} µΩ) - contacts fully open"
+                current_phase_entry['details']['current'] = f"Low current (~{current_data_summary['current_avg']:.0f}) - no current flow"
+                current_phase_entry['details']['travel'] = f"Constant at ~{current_data_summary['travel_avg']:.0f} - contacts fully separated"
+            else:
+                current_data_summary['programmatic_health_status'] = "Unhealthy - Final State Issue"
+                current_phase_entry['waveformAnalysis']['resistance'] = f"Resistance did not return to its expected high value or was unstable."
+                current_phase_entry['waveformAnalysis']['current'] = f"Current was not stable around its open circuit baseline."
+                current_phase_entry['waveformAnalysis']['travel'] = f"Travel was unstable or did not reach the full open position."
+                
+                current_phase_entry['details']['resistance'] = f"Abnormal resistance (~{current_data_summary['resistance_avg']:.0f} µΩ) - leakage detected"
+                current_phase_entry['details']['current'] = f"Abnormal current (~{current_data_summary['current_avg']:.0f}) - residual flow"
+                current_phase_entry['details']['travel'] = f"Unstable at ~{current_data_summary['travel_avg']:.0f} - rebound/drift"
+
+        # Update Coil Analysis with descriptions
+        current_phase_entry['waveformAnalysis']['coilAnalysis']['closeCoil']['status'] = current_data_summary['close_coil_state']
+        current_phase_entry['waveformAnalysis']['coilAnalysis']['closeCoil']['measuredValues'] = f"Avg: {current_data_summary['close_coil_avg']:.2f} A"
+        if current_data_summary['close_coil_state'] == 'Active':
+            current_phase_entry['waveformAnalysis']['coilAnalysis']['closeCoil']['description'] = "Close coil is energized, driving contacts to closed position"
+        else:
+            current_phase_entry['waveformAnalysis']['coilAnalysis']['closeCoil']['description'] = "Close coil is de-energized"
+            
+        current_phase_entry['waveformAnalysis']['coilAnalysis']['tripCoil1']['status'] = current_data_summary['trip_coil_1_state']
+        current_phase_entry['waveformAnalysis']['coilAnalysis']['tripCoil1']['measuredValues'] = f"Avg: {current_data_summary['trip_coil_1_avg']:.2f} A"
+        if current_data_summary['trip_coil_1_state'] == 'Active':
+            current_phase_entry['waveformAnalysis']['coilAnalysis']['tripCoil1']['description'] = "Trip coil 1 is energized, initiating opening operation"
+        else:
+            current_phase_entry['waveformAnalysis']['coilAnalysis']['tripCoil1']['description'] = "Trip coil 1 is de-energized"
+            
+        current_phase_entry['waveformAnalysis']['coilAnalysis']['tripCoil2']['status'] = current_data_summary['trip_coil_2_state']
+        current_phase_entry['waveformAnalysis']['coilAnalysis']['tripCoil2']['measuredValues'] = f"Avg: {current_data_summary['trip_coil_2_avg']:.2f} A"
+        if current_data_summary['trip_coil_2_state'] == 'Active':
+            current_phase_entry['waveformAnalysis']['coilAnalysis']['tripCoil2']['description'] = "Trip coil 2 is energized, providing redundant trip capability"
+        else:
+            # Check if it's failed or just inactive
+            if current_data_summary['trip_coil_2_avg'] == 0.0 and current_data_summary['trip_coil_1_state'] == 'Active':
+                current_phase_entry['waveformAnalysis']['coilAnalysis']['tripCoil2']['description'] = "Trip coil 2 appears non-functional - potential redundancy loss"
+            else:
+                current_phase_entry['waveformAnalysis']['coilAnalysis']['tripCoil2']['description'] = "Trip coil 2 is de-energized"
+
+        # --- LLM Enhancement ---
+        if llm:
+            try:
+                llm_prompt = generate_llm_description_prompt(current_data_summary, current_phase_entry)
+                
+                # Invoke LLM
+                response = llm.invoke([HumanMessage(content=llm_prompt)])
+                content = response.content.replace("```json", "").replace("```", "").strip()
+                llm_output = json.loads(content)
+                
+                current_phase_entry['details']['characteristics'] = llm_output.get('key_characteristics', [])
+                current_phase_entry['eventSynopsis'] = llm_output.get('event_synopsis', "")
+                current_phase_entry['diagnosticVerdict'] = llm_output.get('diagnostic_verdict_details', "")
+                
+                # Extract confidence score
+                llm_confidence = llm_output.get('confidence_score', 0)
+                if isinstance(llm_confidence, (int, float)):
+                    current_phase_entry['confidence'] = max(0, min(100, int(llm_confidence)))
+                else:
+                    current_phase_entry['confidence'] = 50
+                    
+            except Exception as e:
+                print(f"Error calling LLM for phase {phase_id}: {e}")
+                # Fallback is already set by programmatic logic or defaults
+                current_phase_entry['diagnosticVerdict'] = f"Analysis based on programmatic data: {current_data_summary['programmatic_health_status']}. (LLM enhancement failed)"
+                current_phase_entry['confidence'] = 50
+
+        # Assign status for CBHI calculation
+        current_phase_entry['status'] = current_data_summary.get('programmatic_health_status', "Unknown")
+
+        final_segmented_phases.append(current_phase_entry)
+
+    json_output_template['phaseWiseAnalysis'] = final_segmented_phases
+    return json_output_template

core/signal/segmentation.py

@@ -0,0 +1,134 @@
+# Previous Name: analysis/agents/arcing_segmentation.py
+import pandas as pd
+import json
+import matplotlib.pyplot as plt
+import io
+import base64
+from langchain_core.messages import HumanMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+def get_arcing_prompt(data_str):
+    return f"""
+    I have extracted data from a DCRM (Dynamic Contact Resistance Measurement) graph.
+    Data (Sampled): {data_str}
+    
+    The columns are:
+    - 'Time_ms': Time in milliseconds.
+    - 'Resistance': Contact resistance in micro-ohms (µΩ).
+    - 'Travel': Mechanical position/displacement (mm).
+    
+    I have also provided the image of the graph.
+    
+    === TASK: IDENTIFY ARCING CONTACT EVENTS (T0-T4) ===
+    
+    Your goal is to identify 5 specific timepoints (T0, T1, T2, T3, T4) that define the arcing contact behavior.
+    
+    **T0 (Breaker Closed)**:
+    - State: Main Contacts are fully closed.
+    - Signature: Resistance is LOW and STABLE (DLRO value, typically 30-60 µΩ).
+    - Time: t=0 or very early.
+    
+    **T1 (Motion Starts)**:
+    - Event: The breaker mechanism begins to move.
+    - Signature: First significant deviation in the TRAVEL curve (Red). Resistance might rise slightly due to vibration.
+    
+    **T2 (Main Contact Separation)**:
+    - Event: The Main Contacts (Silver) separate, forcing current to the Arcing Contacts (Tungsten).
+    - **VISUAL SIGNATURE**: Look for a sharp "STEP" increase in Resistance.
+    - **DATA SIGNATURE**: Resistance jumps from Low (~40 µΩ) to Medium (~150-300 µΩ).
+    - This is the START of the "Arcing Plateau".
+    
+    **T3 (Arcing Contact Wipe Zone)**:
+    - Event: Only Arcing Contacts are touching.
+    - Signature: The "Plateau" phase between T2 and T4.
+    - Healthy: Flat plateau. Unhealthy: Noisy/Spiky.
+    - **Action**: Return the approximate MIDPOINT time of this plateau.
+    
+    **T4 (Arcing Contact Separation)**:
+    - Event: The Arcing Contacts part.
+    - **VISUAL SIGNATURE**: Resistance shoots VERTICALLY to INFINITY (Open Circuit).
+    - **DATA SIGNATURE**: Resistance jumps from Medium (~200 µΩ) to High/Infinity (>2000 µΩ).
+    - This is the END of the electrical connection.
+    
+    === IMPORTANT: JSON FORMATTING ===
+    - You must return valid JSON.
+    - Do NOT include markdown formatting (like ```json).
+    - If you cannot find a point with certainty, return null.
+    
+    === OUTPUT FORMAT (Strict JSON) ===
+    {{
+      "events": {{
+        "T0_breaker_closed": float,
+        "T1_motion_start": float,
+        "T2_main_separation": float,
+        "T3_arcing_plateau_mid": float,
+        "T4_arcing_separation": float
+      }},
+      "confidence": "High"|"Medium"|"Low",
+      "reasoning": "Brief explanation of how you found T2 and T4"
+    }}
+    """
+
+def identify_arcing_events(df, llm):
+    """
+    Uses the LLM to identify T0-T4 events from the dataframe.
+    """
+    try:
+        # 1. Prepare Data Sample (downsample for token limit)
+        # We focus on the first 200ms where action happens
+        df_subset = df[df['Time_ms'] < 200].copy()
+        step = max(1, len(df_subset) // 100)
+        data_str = df_subset.iloc[::step][['Time_ms', 'Resistance', 'Travel']].to_string(index=False)
+        
+        # 2. Generate Plot Image
+        plt.figure(figsize=(10, 6))
+        
+        # Plot Travel (Red)
+        ax1 = plt.gca()
+        ax1.set_xlabel('Time (ms)')
+        ax1.set_ylabel('Travel (mm)', color='tab:red')
+        ax1.plot(df_subset['Time_ms'], df_subset['Travel'], color='tab:red', label='Travel')
+        ax1.tick_params(axis='y', labelcolor='tab:red')
+        
+        # Plot Resistance (Green) on secondary axis
+        ax2 = ax1.twinx()
+        ax2.set_ylabel('Resistance (µΩ)', color='tab:green')
+        ax2.plot(df_subset['Time_ms'], df_subset['Resistance'], color='tab:green', label='Resistance')
+        ax2.tick_params(axis='y', labelcolor='tab:green')
+        # Limit Resistance view to see the "step" (ignore infinity spike)
+        ax2.set_ylim(0, 2000) 
+        
+        plt.title("DCRM Signature: Identify T0, T1, T2, T4")
+        plt.grid(True, linestyle='--', alpha=0.7)
+        
+        # Save to buffer
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        image_data = base64.b64encode(buf.read()).decode('utf-8')
+        plt.close()
+        
+        # 3. Call LLM
+        prompt = get_arcing_prompt(data_str)
+        
+        message = HumanMessage(
+            content=[
+                {"type": "text", "text": prompt},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}}
+            ]
+        )
+        
+        response = llm.invoke([message])
+        content = response.content.strip()
+        
+        # Clean code blocks if present
+        if "```json" in content:
+            content = content.split("```json")[1].split("```")[0].strip()
+        elif "```" in content:
+            content = content.split("```")[1].strip()
+            
+        result = json.loads(content)
+        return result
+        
+    except Exception as e:
+        return {"error": str(e)}