UI fixed and DetectGPT renamed

README.md

@@ -5,7 +5,6 @@
 
 ![Python](https://img.shields.io/badge/python-3.8+-blue.svg)
 ![FastAPI](https://img.shields.io/badge/FastAPI-0.104+-green.svg)
-![Accuracy](https://img.shields.io/badge/accuracy-~90%25+-success.svg)
 ![License](https://img.shields.io/badge/license-MIT-blue.svg)
 ![Code Style](https://img.shields.io/badge/code%20style-black-black.svg)
 
@@ -52,7 +51,7 @@ This README is research‑grade (detailed math, methodology, and benchmarks) whi
 
 **Problem.** AI generation tools increasingly produce publishable text, creating integrity and verification challenges in education, hiring, publishing, and enterprise content systems.
 
-**Solution.** A domain‑aware detector combining six orthogonal metrics (Perplexity, Entropy, Structural, Semantic, Linguistic, DetectGPT perturbation stability) into a confidence‑calibrated ensemble. Outputs are explainable with sentence‑level highlighting, attribution probabilities, and downloadable reports (JSON/PDF).
+**Solution.** A domain‑aware detector combining six orthogonal metrics (Perplexity, Entropy, Structural, Semantic, Linguistic, Multi-perturbation stability) into a confidence‑calibrated ensemble. Outputs are explainable with sentence‑level highlighting, attribution probabilities, and downloadable reports (JSON/PDF).
 
 **MVP Scope.** End‑to‑end FastAPI backend, lightweight HTML UI, modular metrics, Hugging Face model auto‑download, and a prototype ensemble classifier. Model weights are not committed to the repo; they are fetched at first run.
 
@@ -99,7 +98,7 @@ flowchart LR
         P3[Structural]
         P4[Linguistic]
         P5[Semantic]
-        P6[DetectGPT]
+        P6[MultiPerturbationStability]
     end
 
     G[Ensemble Classifier]
@@ -157,12 +156,14 @@ This section provides the exact metric definitions implemented in `metrics/` and
 - Structural — 15%
 - Semantic — 15%
 - Linguistic — 15%
-- DetectGPT (perturbation stability) — 10%
+- Multi-perturbation Stability — 10%
 
 ### 1) Perplexity (25% weight)
 
 **Definition**
-\(\displaystyle Perplexity = \exp\left(-\frac{1}{N}\sum_{i=1}^N \log P(w_i\mid context)\right)\)
+```math
+Perplexity = \exp\left(-\frac{1}{N}\sum_{i=1}^N \log P(w_i\mid context)\right)
+```
 
 **Implementation sketch**
 ```python
@@ -187,7 +188,9 @@ elif domain == Domain.SOCIAL_MEDIA:
 ### 2) Entropy (20% weight)
 
 **Shannon entropy (token level)**
-\(\;H(X) = -\sum_{i} p(x_i)\log_2 p(x_i)\)
+```math
+H(X) = -Σ p(x_i) * log₂ p(x_i)
+```
 
 **Implementation sketch**
 ```python
@@ -203,10 +206,23 @@ def calculate_text_entropy(text):
 ### 3) Structural Metric (15% weight)
 
 **Burstiness**
-\(\displaystyle Burstiness=\frac{\sigma-\mu}{\sigma+\mu}\) where \(\mu\)=mean sentence length, \(\sigma\)=std dev
+```math
+Burstiness = \frac{\sigma - \mu}{\sigma + \mu}
+```
+
+where:
+- μ = mean sentence length
+- σ = standard deviation of sentence length
 
 **Uniformity**
-\(\displaystyle Uniformity = 1 - \frac{\sigma}{\mu}\)
+```math
+Uniformity = 1 - \frac{\sigma}{\mu}
+```
+
+where:
+- μ = mean sentence length
+- σ = standard deviation of sentence length
+
 
 **Sketch**
 ```python
@@ -223,7 +239,9 @@ def calculate_burstiness(text):
 ### 4) Semantic Analysis (15% weight)
 
 **Coherence (sentence embedding cosine similarity)**
-\(\displaystyle Coherence=\frac{1}{n}\sum_{i=1}^{n-1} \cos(e_i, e_{i+1})\)
+```math
+Coherence = \frac{1}{n} \sum_{i=1}^{n-1} \cos(e_i, e_{i+1})
+```
 
 **Sketch**
 ```python
@@ -247,13 +265,15 @@ def calculate_linguistic_features(text, nlp_model):
     return {'pos_diversity': pos_diversity, 'mean_tree_depth': np.mean(depths)}
 ```
 
-### 6) DetectGPT (10% weight)
+### 6) MultiPerturbationStability (10% weight)
 
 **Stability under perturbation** (curvature principle)
-\(\displaystyle Stability = \frac{1}{n}\sum_{j} \left|\log P(x) - \log P(x_{perturbed}^j)\right|\)
+```math
+Stability = \frac{1}{n} \sum_{j} \left| \log P(x) - \log P(x_{perturbed_j}) \right|
+```
 
 ```python
-def detect_gpt_score(text, model, num_perturbations=20):
+def multi_perturbation_stability_score(text, model, num_perturbations=20):
     original = model.get_log_probability(text)
     diffs = []
     for _ in range(num_perturbations):
@@ -298,10 +318,10 @@ Domain weights and thresholds are configurable. Example weights (in `config/thre
 
 ```python
 DOMAIN_WEIGHTS = {
-  'academic': {'perplexity':0.22,'entropy':0.18,'structural':0.15,'linguistic':0.20,'semantic':0.15,'detect_gpt':0.10},
-  'technical': {'perplexity':0.20,'entropy':0.18,'structural':0.12,'linguistic':0.18,'semantic':0.22,'detect_gpt':0.10},
-  'creative': {'perplexity':0.25,'entropy':0.25,'structural':0.20,'linguistic':0.12,'semantic':0.10,'detect_gpt':0.08},
-  'social_media': {'perplexity':0.30,'entropy':0.22,'structural':0.15,'linguistic':0.10,'semantic':0.13,'detect_gpt':0.10}
+  'academic': {'perplexity':0.22,'entropy':0.18,'structural':0.15,'linguistic':0.20,'semantic':0.15,'multi_perturbation_stability':0.10},
+  'technical': {'perplexity':0.20,'entropy':0.18,'structural':0.12,'linguistic':0.18,'semantic':0.22,'multi_perturbation_stability':0.10},
+  'creative': {'perplexity':0.25,'entropy':0.25,'structural':0.20,'linguistic':0.12,'semantic':0.10,'multi_perturbation_stability':0.08},
+  'social_media': {'perplexity':0.30,'entropy':0.22,'structural':0.15,'linguistic':0.10,'semantic':0.13,'multi_perturbation_stability':0.10}
 }
 ```
 
@@ -348,7 +368,7 @@ text_auth/
 │   └── orchestrator.py
 ├── metrics/
 │   ├── base_metric.py
-│   ├── detect_gpt.py
+│   ├── multi_perturbation_stability.py
 │   ├── entropy.py
 │   ├── linguistic.py
 │   ├── perplexity.py

config/model_config.py

@@ -98,16 +98,16 @@ MODEL_REGISTRY : Dict[str, ModelConfig] = {"perplexity_gpt2"            : ModelC
                                                                                       batch_size        = 16,
                                                                                       quantizable       = True,
                                                                                      ),
-                                           "detectgpt_base"             : ModelConfig(model_id          = "gpt2",
+                                           "multi_perturbation_base"    : ModelConfig(model_id          = "gpt2",
                                                                                       model_type        = ModelType.GPTMASK,
-                                                                                      description       = "DetectGPT perturbation model (reuses gpt2)",
+                                                                                      description       = "MultiPerturbationStability model (reuses gpt2)",
                                                                                       size_mb           = 0,  
                                                                                       required          = True,  
                                                                                       download_priority = 4,
                                                                                       max_length        = 1024,
                                                                                       batch_size        = 4,
                                                                                      ),
-                                           "detectgpt_mask"             : ModelConfig(model_id          = "distilroberta-base",
+                                           "multi_perturbation_mask"    : ModelConfig(model_id          = "distilroberta-base",
                                                                                       model_type        = ModelType.TRANSFORMER,
                                                                                       description       = "Masked LM for text perturbation",
                                                                                       size_mb           = 330,
@@ -131,18 +131,18 @@ MODEL_REGISTRY : Dict[str, ModelConfig] = {"perplexity_gpt2"            : ModelC
 # MODEL GROUPS FOR BATCH DOWNLOADING 
 MODEL_GROUPS                            = {"minimal"   : ["perplexity_gpt2", "domain_classifier"],
                                            "essential" : ["perplexity_gpt2", "semantic_primary", "linguistic_spacy", "domain_classifier"],
-                                           "extended"  : ["semantic_secondary", "detectgpt_mask", "domain_classifier_fallback"],
+                                           "extended"  : ["semantic_secondary", "multi_perturbation_mask", "domain_classifier_fallback"],
                                            "optional"  : ["language_detector"],
                                           }
 
 
 # MODEL WEIGHTS FOR ENSEMBLE : For 6 metrics implemented
-DEFAULT_MODEL_WEIGHTS                   = {"statistical"         : 0.20,  # No model needed
-                                           "perplexity"          : 0.20,  # gpt2
-                                           "entropy"             : 0.15,  # gpt2 (reused)
-                                           "semantic_analysis"   : 0.20,  # all-MiniLM-L6-v2
-                                           "linguistic"          : 0.15,  # spacy
-                                           "detect_gpt"          : 0.10,  # gpt2 + distilroberta (optional)
+DEFAULT_MODEL_WEIGHTS                   = {"statistical"                  : 0.20,  # No model needed
+                                           "perplexity"                   : 0.20,  # gpt2
+                                           "entropy"                      : 0.15,  # gpt2 (reused)
+                                           "semantic_analysis"            : 0.20,  # all-MiniLM-L6-v2
+                                           "linguistic"                   : 0.15,  # spacy
+                                           "multi_perturbation_stability" : 0.10,  # gpt2 + distilroberta (optional)
                                           }
 
 

config/settings.py

@@ -34,13 +34,13 @@ class Settings(BaseSettings):
     
     # File Upload Settings
     MAX_UPLOAD_SIZE         : int           = 10 * 1024 * 1024  # 10MB
-    ALLOWED_EXTENSIONS      : list          = [".txt", ".pdf", ".docx", ".doc"]
+    ALLOWED_EXTENSIONS      : list          = [".txt", ".pdf", ".docx", ".doc", ".md"]
     
     # Processing Settings
-    MAX_TEXT_LENGTH         : int           = 50000  # Maximum characters to process
-    MIN_TEXT_LENGTH         : int           = 50     # Minimum characters for analysis
-    CHUNK_SIZE              : int           = 512    # Tokens per chunk
-    CHUNK_OVERLAP           : int           = 50     # Overlap between chunks
+    MAX_TEXT_LENGTH         : int           = 500000  # Maximum characters to process
+    MIN_TEXT_LENGTH         : int           = 50      # Minimum characters for analysis
+    CHUNK_SIZE              : int           = 512     # Tokens per chunk
+    CHUNK_OVERLAP           : int           = 50      # Overlap between chunks
     
     # Model Settings
     DEVICE                  : str           = Field(default = "cpu", env = "DEVICE")  # "cuda" or "cpu"
@@ -87,12 +87,12 @@ class Settings(BaseSettings):
     REQUEST_TIMEOUT         : int           = 300  # seconds (5 minutes)
     
     # Metrics Configuration
-    METRICS_ENABLED         : dict          = {"semantic_analysis"   : True,
-                                               "detect_gpt"          : True,
-                                               "perplexity"          : True,
-                                               "statistical"         : True,
-                                               "entropy"             : True,
-                                               "linguistic"          : True,
+    METRICS_ENABLED         : dict          = {"semantic_analysis"            : True,
+                                               "multi_perturbation_stability" : True,
+                                               "perplexity"                   : True,
+                                               "statistical"                  : True,
+                                               "entropy"                      : True,
+                                               "linguistic"                   : True,
                                               }
     
     class Config:

config/threshold_config.py

@@ -55,191 +55,191 @@ class DomainThresholds:
     """
     Thresholds for 6 metrics in a specific domain
     """
-    domain             : Domain
-    structural         : MetricThresholds
-    perplexity         : MetricThresholds
-    entropy            : MetricThresholds
-    semantic_analysis  : MetricThresholds
-    linguistic         : MetricThresholds
-    detect_gpt         : MetricThresholds
-    ensemble_threshold : float = 0.5
+    domain                       : Domain
+    structural                   : MetricThresholds
+    perplexity                   : MetricThresholds
+    entropy                      : MetricThresholds
+    semantic_analysis            : MetricThresholds
+    linguistic                   : MetricThresholds
+    multi_perturbation_stability : MetricThresholds
+    ensemble_threshold           : float = 0.5
 
 
 # ==================== DOMAIN-SPECIFIC THRESHOLDS ====================
 # GENERAL (Default fallback)
-DEFAULT_THRESHOLDS       = DomainThresholds(domain             = Domain.GENERAL,
-                                            structural         = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.45, weight = 0.20),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.25),
-                                            entropy            = MetricThresholds(ai_threshold = 0.48, human_threshold = 0.52, weight = 0.15),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.45, weight = 0.18),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.12),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.10),
-                                            ensemble_threshold = 0.40,
+DEFAULT_THRESHOLDS       = DomainThresholds(domain                       = Domain.GENERAL,
+                                            structural                   = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.45, weight = 0.20),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.25),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.48, human_threshold = 0.52, weight = 0.15),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.45, weight = 0.18),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.12),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.10),
+                                            ensemble_threshold           = 0.40,
                                            )
 
 # ACADEMIC
-ACADEMIC_THRESHOLDS      = DomainThresholds(domain             = Domain.ACADEMIC,
-                                            structural         = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.45, weight = 0.26),
-                                            entropy            = MetricThresholds(ai_threshold = 0.45, human_threshold = 0.50, weight = 0.14),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.14),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.65, human_threshold = 0.35, weight = 0.08),
-                                            ensemble_threshold = 0.42,
+ACADEMIC_THRESHOLDS      = DomainThresholds(domain                       = Domain.ACADEMIC,
+                                            structural                   = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.45, weight = 0.26),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.45, human_threshold = 0.50, weight = 0.14),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.14),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.65, human_threshold = 0.35, weight = 0.08),
+                                            ensemble_threshold           = 0.42,
                                            )
 
 # CREATIVE WRITING
-CREATIVE_THRESHOLDS      = DomainThresholds(domain             = Domain.CREATIVE,
-                                            structural         = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.50, weight = 0.22),
-                                            entropy            = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.55, weight = 0.16),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.45, weight = 0.16),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.08),
-                                            ensemble_threshold = 0.38,
+CREATIVE_THRESHOLDS      = DomainThresholds(domain                       = Domain.CREATIVE,
+                                            structural                   = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.50, weight = 0.22),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.55, weight = 0.16),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.45, weight = 0.16),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.08),
+                                            ensemble_threshold           = 0.38,
                                            )
 
 # AI/ML/DATA SCIENCE
-AI_ML_THRESHOLDS         = DomainThresholds(domain             = Domain.AI_ML,
-                                            structural         = MetricThresholds(ai_threshold = 0.57, human_threshold = 0.43, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.51, human_threshold = 0.46, weight = 0.26),
-                                            entropy            = MetricThresholds(ai_threshold = 0.47, human_threshold = 0.50, weight = 0.14),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.57, human_threshold = 0.43, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.61, human_threshold = 0.39, weight = 0.14),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.64, human_threshold = 0.36, weight = 0.08),
-                                            ensemble_threshold = 0.41,
+AI_ML_THRESHOLDS         = DomainThresholds(domain                       = Domain.AI_ML,
+                                            structural                   = MetricThresholds(ai_threshold = 0.57, human_threshold = 0.43, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.51, human_threshold = 0.46, weight = 0.26),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.47, human_threshold = 0.50, weight = 0.14),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.57, human_threshold = 0.43, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.61, human_threshold = 0.39, weight = 0.14),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.64, human_threshold = 0.36, weight = 0.08),
+                                            ensemble_threshold           = 0.41,
                                            )
 
 # SOFTWARE DEVELOPMENT
-SOFTWARE_DEV_THRESHOLDS  = DomainThresholds(domain             = Domain.SOFTWARE_DEV,
-                                            structural         = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.17),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.45, weight = 0.27),
-                                            entropy            = MetricThresholds(ai_threshold = 0.46, human_threshold = 0.50, weight = 0.14),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.14),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.63, human_threshold = 0.37, weight = 0.08),
-                                            ensemble_threshold = 0.41,
+SOFTWARE_DEV_THRESHOLDS  = DomainThresholds(domain                       = Domain.SOFTWARE_DEV,
+                                            structural                   = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.17),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.45, weight = 0.27),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.46, human_threshold = 0.50, weight = 0.14),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.14),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.63, human_threshold = 0.37, weight = 0.08),
+                                            ensemble_threshold           = 0.41,
                                            )
 
-# TECHNICAL DOCUMENTATION
-TECHNICAL_DOC_THRESHOLDS = DomainThresholds(domain             = Domain.TECHNICAL_DOC,
-                                            structural         = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.49, human_threshold = 0.44, weight = 0.27),
-                                            entropy            = MetricThresholds(ai_threshold = 0.45, human_threshold = 0.49, weight = 0.13),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.14),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.65, human_threshold = 0.35, weight = 0.08),
-                                            ensemble_threshold = 0.42,
+# TECHNICAL DOCUMENTATION 
+TECHNICAL_DOC_THRESHOLDS = DomainThresholds(domain                       = Domain.TECHNICAL_DOC,
+                                            structural                   = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.49, human_threshold = 0.44, weight = 0.27),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.45, human_threshold = 0.49, weight = 0.13),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.14),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.65, human_threshold = 0.35, weight = 0.08),
+                                            ensemble_threshold           = 0.42,
                                            )
 
 # ENGINEERING
-ENGINEERING_THRESHOLDS   = DomainThresholds(domain             = Domain.ENGINEERING,
-                                            structural         = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.45, weight = 0.26),
-                                            entropy            = MetricThresholds(ai_threshold = 0.46, human_threshold = 0.50, weight = 0.14),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.61, human_threshold = 0.39, weight = 0.14),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.64, human_threshold = 0.36, weight = 0.08),
-                                            ensemble_threshold = 0.41,
+ENGINEERING_THRESHOLDS   = DomainThresholds(domain                       = Domain.ENGINEERING,
+                                            structural                   = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.45, weight = 0.26),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.46, human_threshold = 0.50, weight = 0.14),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.61, human_threshold = 0.39, weight = 0.14),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.64, human_threshold = 0.36, weight = 0.08),
+                                            ensemble_threshold           = 0.41,
                                            )
 
 # SCIENCE (Physics, Chemistry, Biology)
-SCIENCE_THRESHOLDS       = DomainThresholds(domain             = Domain.SCIENCE,
-                                            structural         = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.51, human_threshold = 0.46, weight = 0.26),
-                                            entropy            = MetricThresholds(ai_threshold = 0.46, human_threshold = 0.50, weight = 0.14),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.14),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.64, human_threshold = 0.36, weight = 0.08),
-                                            ensemble_threshold = 0.42,
+SCIENCE_THRESHOLDS       = DomainThresholds(domain                       = Domain.SCIENCE,
+                                            structural                   = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.51, human_threshold = 0.46, weight = 0.26),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.46, human_threshold = 0.50, weight = 0.14),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.14),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.64, human_threshold = 0.36, weight = 0.08),
+                                            ensemble_threshold           = 0.42,
                                            )
 
 # BUSINESS
-BUSINESS_THRESHOLDS      = DomainThresholds(domain             = Domain.BUSINESS,
-                                            structural         = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.24),
-                                            entropy            = MetricThresholds(ai_threshold = 0.48, human_threshold = 0.52, weight = 0.15),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.19),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.15),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.09),
-                                            ensemble_threshold = 0.40,
+BUSINESS_THRESHOLDS      = DomainThresholds(domain                       = Domain.BUSINESS,
+                                            structural                   = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.24),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.48, human_threshold = 0.52, weight = 0.15),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.19),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.15),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.09),
+                                            ensemble_threshold           = 0.40,
                                            )
 
 # LEGAL
-LEGAL_THRESHOLDS         = DomainThresholds(domain             = Domain.LEGAL,
-                                            structural         = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.17),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.44, weight = 0.27),
-                                            entropy            = MetricThresholds(ai_threshold = 0.44, human_threshold = 0.48, weight = 0.13),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.63, human_threshold = 0.37, weight = 0.15),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.66, human_threshold = 0.34, weight = 0.08),
-                                            ensemble_threshold = 0.43,
+LEGAL_THRESHOLDS         = DomainThresholds(domain                       = Domain.LEGAL,
+                                            structural                   = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.17),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.44, weight = 0.27),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.44, human_threshold = 0.48, weight = 0.13),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.63, human_threshold = 0.37, weight = 0.15),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.66, human_threshold = 0.34, weight = 0.08),
+                                            ensemble_threshold           = 0.43,
                                            )
 
 # MEDICAL
-MEDICAL_THRESHOLDS       = DomainThresholds(domain             = Domain.MEDICAL,
-                                            structural         = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.17),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.45, weight = 0.27),
-                                            entropy            = MetricThresholds(ai_threshold = 0.45, human_threshold = 0.49, weight = 0.13),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.15),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.65, human_threshold = 0.35, weight = 0.08),
-                                            ensemble_threshold = 0.43,
+MEDICAL_THRESHOLDS       = DomainThresholds(domain                       = Domain.MEDICAL,
+                                            structural                   = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.17),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.45, weight = 0.27),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.45, human_threshold = 0.49, weight = 0.13),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.15),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.65, human_threshold = 0.35, weight = 0.08),
+                                            ensemble_threshold           = 0.43,
                                            )
 
 # JOURNALISM
-JOURNALISM_THRESHOLDS    = DomainThresholds(domain             = Domain.JOURNALISM,
-                                            structural         = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.24),
-                                            entropy            = MetricThresholds(ai_threshold = 0.48, human_threshold = 0.52, weight = 0.15),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.20),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.15),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.08),
-                                            ensemble_threshold = 0.40,
+JOURNALISM_THRESHOLDS    = DomainThresholds(domain                       = Domain.JOURNALISM,
+                                            structural                   = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.24),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.48, human_threshold = 0.52, weight = 0.15),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.20),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.58, human_threshold = 0.42, weight = 0.15),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.08),
+                                            ensemble_threshold           = 0.40,
                                            )
 
 # MARKETING
-MARKETING_THRESHOLDS     = DomainThresholds(domain             = Domain.MARKETING,
-                                            structural         = MetricThresholds(ai_threshold = 0.54, human_threshold = 0.46, weight = 0.19),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.53, human_threshold = 0.49, weight = 0.23),
-                                            entropy            = MetricThresholds(ai_threshold = 0.49, human_threshold = 0.53, weight = 0.15),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.54, human_threshold = 0.46, weight = 0.19),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.57, human_threshold = 0.43, weight = 0.16),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.61, human_threshold = 0.39, weight = 0.08),
-                                            ensemble_threshold = 0.39,
+MARKETING_THRESHOLDS     = DomainThresholds(domain                       = Domain.MARKETING,
+                                            structural                   = MetricThresholds(ai_threshold = 0.54, human_threshold = 0.46, weight = 0.19),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.53, human_threshold = 0.49, weight = 0.23),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.49, human_threshold = 0.53, weight = 0.15),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.54, human_threshold = 0.46, weight = 0.19),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.57, human_threshold = 0.43, weight = 0.16),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.61, human_threshold = 0.39, weight = 0.08),
+                                            ensemble_threshold           = 0.39,
                                            )
 
 # SOCIAL MEDIA
-SOCIAL_MEDIA_THRESHOLDS  = DomainThresholds(domain             = Domain.SOCIAL_MEDIA,
-                                            structural         = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.54, human_threshold = 0.50, weight = 0.20),
-                                            entropy            = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.54, weight = 0.17),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.18),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.45, weight = 0.18),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.09),
-                                            ensemble_threshold = 0.36,
+SOCIAL_MEDIA_THRESHOLDS  = DomainThresholds(domain                       = Domain.SOCIAL_MEDIA,
+                                            structural                   = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.54, human_threshold = 0.50, weight = 0.20),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.54, weight = 0.17),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.18),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.55, human_threshold = 0.45, weight = 0.18),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.60, human_threshold = 0.40, weight = 0.09),
+                                            ensemble_threshold           = 0.36,
                                            )
 
 # PERSONAL BLOG
-BLOG_PERSONAL_THRESHOLDS = DomainThresholds(domain             = Domain.BLOG_PERSONAL,
-                                            structural         = MetricThresholds(ai_threshold = 0.53, human_threshold = 0.47, weight = 0.19),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.54, human_threshold = 0.50, weight = 0.22),
-                                            entropy            = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.54, weight = 0.16),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.53, human_threshold = 0.47, weight = 0.19),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.16),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.08),
-                                            ensemble_threshold = 0.38,
+BLOG_PERSONAL_THRESHOLDS = DomainThresholds(domain                       = Domain.BLOG_PERSONAL,
+                                            structural                   = MetricThresholds(ai_threshold = 0.53, human_threshold = 0.47, weight = 0.19),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.54, human_threshold = 0.50, weight = 0.22),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.50, human_threshold = 0.54, weight = 0.16),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.53, human_threshold = 0.47, weight = 0.19),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.16),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.08),
+                                            ensemble_threshold           = 0.38,
                                            )
 
 # TUTORIAL/HOW-TO
-TUTORIAL_THRESHOLDS      = DomainThresholds(domain             = Domain.TUTORIAL,
-                                            structural         = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.18),
-                                            perplexity         = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.25),
-                                            entropy            = MetricThresholds(ai_threshold = 0.48, human_threshold = 0.52, weight = 0.15),
-                                            semantic_analysis  = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.19),
-                                            linguistic         = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.15),
-                                            detect_gpt         = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.08),
-                                            ensemble_threshold = 0.40,
+TUTORIAL_THRESHOLDS      = DomainThresholds(domain                       = Domain.TUTORIAL,
+                                            structural                   = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.18),
+                                            perplexity                   = MetricThresholds(ai_threshold = 0.52, human_threshold = 0.48, weight = 0.25),
+                                            entropy                      = MetricThresholds(ai_threshold = 0.48, human_threshold = 0.52, weight = 0.15),
+                                            semantic_analysis            = MetricThresholds(ai_threshold = 0.56, human_threshold = 0.44, weight = 0.19),
+                                            linguistic                   = MetricThresholds(ai_threshold = 0.59, human_threshold = 0.41, weight = 0.15),
+                                            multi_perturbation_stability = MetricThresholds(ai_threshold = 0.62, human_threshold = 0.38, weight = 0.08),
+                                            ensemble_threshold           = 0.40,
                                            )
 
 
@@ -322,14 +322,14 @@ def interpolate_thresholds(domain1: Domain, domain2: Domain, weight1: float = 0.
                                 weight          = m1.weight * weight1 + m2.weight * weight2,
                                )
     
-    return DomainThresholds(domain              = domain1,
-                            structural          = interpolate_metric(thresh1.structural, thresh2.structural),
-                            perplexity          = interpolate_metric(thresh1.perplexity, thresh2.perplexity),
-                            entropy             = interpolate_metric(thresh1.entropy, thresh2.entropy),
-                            semantic_analysis   = interpolate_metric(thresh1.semantic_analysis, thresh2.semantic_analysis),
-                            linguistic          = interpolate_metric(thresh1.linguistic, thresh2.linguistic),
-                            detect_gpt          = interpolate_metric(thresh1.detect_gpt, thresh2.detect_gpt),
-                            ensemble_threshold  = thresh1.ensemble_threshold * weight1 + thresh2.ensemble_threshold * weight2,
+    return DomainThresholds(domain                       = domain1,
+                            structural                   = interpolate_metric(thresh1.structural, thresh2.structural),
+                            perplexity                   = interpolate_metric(thresh1.perplexity, thresh2.perplexity),
+                            entropy                      = interpolate_metric(thresh1.entropy, thresh2.entropy),
+                            semantic_analysis            = interpolate_metric(thresh1.semantic_analysis, thresh2.semantic_analysis),
+                            linguistic                   = interpolate_metric(thresh1.linguistic, thresh2.linguistic),
+                            multi_perturbation_stability = interpolate_metric(thresh1.multi_perturbation_stability, thresh2.multi_perturbation_stability),
+                            ensemble_threshold           = thresh1.ensemble_threshold * weight1 + thresh2.ensemble_threshold * weight2,
                            )
 
 
@@ -339,12 +339,12 @@ def get_active_metric_weights(domain: Domain, enabled_metrics: Dict[str, bool])
     """
     thresholds     = get_threshold_for_domain(domain = domain)
     
-    metric_mapping = {"structural"        : thresholds.structural,
-                      "perplexity"        : thresholds.perplexity,
-                      "entropy"           : thresholds.entropy,
-                      "semantic_analysis" : thresholds.semantic_analysis,
-                      "linguistic"        : thresholds.linguistic,
-                      "detect_gpt"        : thresholds.detect_gpt,
+    metric_mapping = {"structural"                   : thresholds.structural,
+                      "perplexity"                   : thresholds.perplexity,
+                      "entropy"                      : thresholds.entropy,
+                      "semantic_analysis"            : thresholds.semantic_analysis,
+                      "linguistic"                   : thresholds.linguistic,
+                      "multi_perturbation_stability" : thresholds.multi_perturbation_stability,
                      }
     
     active_weights = dict()

detector/attribution.py

@@ -78,12 +78,12 @@ class ModelAttributor:
     - Explainable reasoning
     """
     # DOCUMENT-ALIGNED: Metric weights from technical specification
-    METRIC_WEIGHTS           = {"perplexity"       : 0.25,  
-                                "structural"       : 0.15,   
-                                "semantic_analysis": 0.15,  
-                                "entropy"          : 0.20,  
-                                "linguistic"       : 0.15,  
-                                "detect_gpt"       : 0.10,  
+    METRIC_WEIGHTS           = {"perplexity"                   : 0.25,  
+                                "structural"                   : 0.15,   
+                                "semantic_analysis"            : 0.15,  
+                                "entropy"                      : 0.20,  
+                                "linguistic"                   : 0.15,  
+                                "multi_perturbation_stability" : 0.10,  
                                }
     
     # DOMAIN-AWARE model patterns for ALL 16 DOMAINS
@@ -441,13 +441,17 @@ class ModelAttributor:
             domain_preferences                    = self.DOMAIN_MODEL_PREFERENCES.get(domain, [AIModel.GPT_4, AIModel.CLAUDE_3_SONNET])
             
             # Fingerprint analysis
-            fingerprint_scores                    = self._calculate_fingerprint_scores(text, domain)
+            fingerprint_scores                    = self._calculate_fingerprint_scores(text   = text,
+                                                                                       domain = domain,
+                                                                                      )
             
             # Statistical pattern analysis
-            statistical_scores                    = self._analyze_statistical_patterns(text, domain)
+            statistical_scores                    = self._analyze_statistical_patterns(text   = text, 
+                                                                                       domain = domain,
+                                                                                      )
             
             # Metric-based attribution using all 6 metrics
-            metric_scores                         = self._analyze_metric_patterns(metric_results, domain) if metric_results else {}
+            metric_scores                         = self._analyze_metric_patterns(metric_results = metric_results, domain = domain) if metric_results else {}
             
             # Ensemble Combination
             combined_scores, metric_contributions = self._combine_attribution_scores(fingerprint_scores = fingerprint_scores,
@@ -462,7 +466,7 @@ class ModelAttributor:
                                                                                        domain_preferences = domain_preferences,
                                                                                       )
             
-            # Reasoning with domain context
+            # Reasoning with domain context - FIXED
             reasoning                             = self._generate_detailed_reasoning(predicted_model      = predicted_model,
                                                                                       confidence           = confidence,
                                                                                       domain               = domain,
@@ -650,22 +654,22 @@ class ModelAttributor:
             return scores
         
         # DOMAIN-AWARE: Adjust metric sensitivity based on domain 
-        domain_metric_weights = {Domain.GENERAL       : {"perplexity": 1.0, "structural": 1.0, "entropy": 1.0, "semantic_analysis": 1.0, "linguistic": 1.0, "detect_gpt": 1.0},
-                                 Domain.ACADEMIC      : {"perplexity": 1.2, "structural": 1.0, "entropy": 0.9, "semantic_analysis": 1.1, "linguistic": 1.3, "detect_gpt": 0.8},
-                                 Domain.TECHNICAL_DOC : {"perplexity": 1.2, "structural": 1.1, "entropy": 0.9, "semantic_analysis": 1.2, "linguistic": 1.1, "detect_gpt": 0.8},
-                                 Domain.AI_ML         : {"perplexity": 1.3, "structural": 1.0, "entropy": 0.9, "semantic_analysis": 1.2, "linguistic": 1.2, "detect_gpt": 0.8},
-                                 Domain.SOFTWARE_DEV  : {"perplexity": 1.2, "structural": 1.1, "entropy": 0.9, "semantic_analysis": 1.1, "linguistic": 1.0, "detect_gpt": 0.9},
-                                 Domain.ENGINEERING   : {"perplexity": 1.2, "structural": 1.1, "entropy": 0.9, "semantic_analysis": 1.1, "linguistic": 1.2, "detect_gpt": 0.8},
-                                 Domain.SCIENCE       : {"perplexity": 1.2, "structural": 1.0, "entropy": 0.9, "semantic_analysis": 1.2, "linguistic": 1.3, "detect_gpt": 0.8},
-                                 Domain.BUSINESS      : {"perplexity": 1.1, "structural": 1.0, "entropy": 1.0, "semantic_analysis": 1.2, "linguistic": 1.1, "detect_gpt": 0.9},
-                                 Domain.LEGAL         : {"perplexity": 1.2, "structural": 1.1, "entropy": 0.9, "semantic_analysis": 1.3, "linguistic": 1.3, "detect_gpt": 0.8},
-                                 Domain.MEDICAL       : {"perplexity": 1.2, "structural": 1.0, "entropy": 0.9, "semantic_analysis": 1.2, "linguistic": 1.2, "detect_gpt": 0.8},
-                                 Domain.JOURNALISM    : {"perplexity": 1.1, "structural": 1.0, "entropy": 1.0, "semantic_analysis": 1.1, "linguistic": 1.1, "detect_gpt": 0.9},
-                                 Domain.CREATIVE      : {"perplexity": 0.9, "structural": 0.9, "entropy": 1.2, "semantic_analysis": 1.0, "linguistic": 1.3, "detect_gpt": 0.9},
-                                 Domain.MARKETING     : {"perplexity": 1.0, "structural": 1.0, "entropy": 1.1, "semantic_analysis": 1.1, "linguistic": 1.2, "detect_gpt": 0.8},
-                                 Domain.SOCIAL_MEDIA  : {"perplexity": 1.0, "structural": 0.8, "entropy": 1.3, "semantic_analysis": 0.9, "linguistic": 0.9, "detect_gpt": 0.9},
-                                 Domain.BLOG_PERSONAL : {"perplexity": 1.0, "structural": 0.9, "entropy": 1.2, "semantic_analysis": 1.0, "linguistic": 1.1, "detect_gpt": 0.8},
-                                 Domain.TUTORIAL      : {"perplexity": 1.1, "structural": 1.0, "entropy": 1.0, "semantic_analysis": 1.1, "linguistic": 1.1, "detect_gpt": 0.9},
+        domain_metric_weights = {Domain.GENERAL       : {"perplexity": 1.0, "structural": 1.0, "entropy": 1.0, "semantic_analysis": 1.0, "linguistic": 1.0, "multi_perturbation_stability": 1.0},
+                                 Domain.ACADEMIC      : {"perplexity": 1.2, "structural": 1.0, "entropy": 0.9, "semantic_analysis": 1.1, "linguistic": 1.3, "multi_perturbation_stability": 0.8},
+                                 Domain.TECHNICAL_DOC : {"perplexity": 1.2, "structural": 1.1, "entropy": 0.9, "semantic_analysis": 1.2, "linguistic": 1.1, "multi_perturbation_stability": 0.8},
+                                 Domain.AI_ML         : {"perplexity": 1.3, "structural": 1.0, "entropy": 0.9, "semantic_analysis": 1.2, "linguistic": 1.2, "multi_perturbation_stability": 0.8},
+                                 Domain.SOFTWARE_DEV  : {"perplexity": 1.2, "structural": 1.1, "entropy": 0.9, "semantic_analysis": 1.1, "linguistic": 1.0, "multi_perturbation_stability": 0.9},
+                                 Domain.ENGINEERING   : {"perplexity": 1.2, "structural": 1.1, "entropy": 0.9, "semantic_analysis": 1.1, "linguistic": 1.2, "multi_perturbation_stability": 0.8},
+                                 Domain.SCIENCE       : {"perplexity": 1.2, "structural": 1.0, "entropy": 0.9, "semantic_analysis": 1.2, "linguistic": 1.3, "multi_perturbation_stability": 0.8},
+                                 Domain.BUSINESS      : {"perplexity": 1.1, "structural": 1.0, "entropy": 1.0, "semantic_analysis": 1.2, "linguistic": 1.1, "multi_perturbation_stability": 0.9},
+                                 Domain.LEGAL         : {"perplexity": 1.2, "structural": 1.1, "entropy": 0.9, "semantic_analysis": 1.3, "linguistic": 1.3, "multi_perturbation_stability": 0.8},
+                                 Domain.MEDICAL       : {"perplexity": 1.2, "structural": 1.0, "entropy": 0.9, "semantic_analysis": 1.2, "linguistic": 1.2, "multi_perturbation_stability": 0.8},
+                                 Domain.JOURNALISM    : {"perplexity": 1.1, "structural": 1.0, "entropy": 1.0, "semantic_analysis": 1.1, "linguistic": 1.1, "multi_perturbation_stability": 0.9},
+                                 Domain.CREATIVE      : {"perplexity": 0.9, "structural": 0.9, "entropy": 1.2, "semantic_analysis": 1.0, "linguistic": 1.3, "multi_perturbation_stability": 0.9},
+                                 Domain.MARKETING     : {"perplexity": 1.0, "structural": 1.0, "entropy": 1.1, "semantic_analysis": 1.1, "linguistic": 1.2, "multi_perturbation_stability": 0.8},
+                                 Domain.SOCIAL_MEDIA  : {"perplexity": 1.0, "structural": 0.8, "entropy": 1.3, "semantic_analysis": 0.9, "linguistic": 0.9, "multi_perturbation_stability": 0.9},
+                                 Domain.BLOG_PERSONAL : {"perplexity": 1.0, "structural": 0.9, "entropy": 1.2, "semantic_analysis": 1.0, "linguistic": 1.1, "multi_perturbation_stability": 0.8},
+                                 Domain.TUTORIAL      : {"perplexity": 1.1, "structural": 1.0, "entropy": 1.0, "semantic_analysis": 1.1, "linguistic": 1.1, "multi_perturbation_stability": 0.9},
                                 }
         
         domain_weights        = domain_metric_weights.get(domain, domain_metric_weights[Domain.GENERAL])
@@ -733,16 +737,16 @@ class ModelAttributor:
                 scores[AIModel.CLAUDE_3_OPUS] += 0.5 * self.METRIC_WEIGHTS["linguistic"] * domain_weight
                 scores[AIModel.GPT_4]         += 0.4 * self.METRIC_WEIGHTS["linguistic"] * domain_weight
         
-        # DETECTGPT ANALYSIS (10% weight)
-        if ("detect_gpt" in metric_results):
-            detectgpt_result = metric_results["detect_gpt"]
-            stability        = detectgpt_result.details.get("stability_score", 0.5)
-            curvature        = detectgpt_result.details.get("curvature_score", 0.5)
+        # MULTI-PERTURBATION STABILITY ANALYSIS (10% weight)
+        if ("multi_perturbation_stability" in metric_results):
+            multi_perturbation_stability_result = metric_results["multi_perturbation_stability"]
+            stability                           = multi_perturbation_stability_result.details.get("stability_score", 0.5)
+            curvature                           = multi_perturbation_stability_result.details.get("curvature_score", 0.5)
             
             # Specific stability patterns for different model families
             if (0.4 <= stability <= 0.6):
-                scores[AIModel.MIXTRAL] += 0.4 * self.METRIC_WEIGHTS["detect_gpt"]
-                scores[AIModel.LLAMA_3] += 0.3 * self.METRIC_WEIGHTS["detect_gpt"]
+                scores[AIModel.MIXTRAL] += 0.4 * self.METRIC_WEIGHTS["multi_perturbation_stability"]
+                scores[AIModel.LLAMA_3] += 0.3 * self.METRIC_WEIGHTS["multi_perturbation_stability"]
         
         # Normalize scores
         for model in scores:
@@ -823,7 +827,7 @@ class ModelAttributor:
         
         # FIXED: Only return UNKNOWN if the best score is very low
         # Use a more reasonable threshold for attribution
-        if best_score < 0.08:  # Changed from 0.15 to 0.08 to be less restrictive
+        if best_score < 0.05:  # Changed from 0.08 to 0.05 to be less restrictive
             return AIModel.UNKNOWN, best_score
         
         # FIXED: Don't override with domain preferences if there's a clear winner
@@ -868,62 +872,62 @@ class ModelAttributor:
     def _generate_detailed_reasoning(self, predicted_model: AIModel, confidence: float, domain: Domain, metric_contributions: Dict[str, float], 
                                      combined_scores: Dict[str, float]) -> List[str]:
         """
-        Generate Explainable reasoning - FIXED to show proper ordering
+        Generate Explainable reasoning - FIXED to show proper formatting
         """
-        reasoning = list()
+        reasoning = []
         
-        reasoning.append("## AI Model Attribution Analysis")
+        reasoning.append("**AI Model Attribution Analysis**")
+        reasoning.append("")
         reasoning.append(f"**Domain**: {domain.value.replace('_', ' ').title()}")
+        reasoning.append("")
         
+        # Show prediction with confidence
         if (predicted_model == AIModel.UNKNOWN):
-            reasoning.append("**Most Likely**: UNKNOWN")
-            # Show the actual highest probability even if it's UNKNOWN
-            if combined_scores:
-                sorted_models = sorted(combined_scores.items(), key=lambda x: x[1], reverse=True)
-                if sorted_models and sorted_models[0][1] > 0:
-                    top_model_name = sorted_models[0][0].replace("-", " ").replace("_", " ").title()
-                    top_score = sorted_models[0][1] * 100
-                    reasoning.append(f"**{top_model_name}**")
-                    reasoning.append(f"{top_score:.1f}%")
+            reasoning.append("**Most Likely**: Unable to determine with high confidence")
+            reasoning.append("")
+            reasoning.append("**Top Candidates:**")
+        
         else:
             model_name = predicted_model.value.replace("-", " ").replace("_", " ").title()
-            reasoning.append(f"**Most Likely**: {model_name}")
-            # Show the actual probability for the predicted model
-            model_key = predicted_model.value
-            if model_key in combined_scores:
-                score = combined_scores[model_key] * 100
-                reasoning.append(f"{score:.1f}%")
-        
-        # Show top model candidates with ACTUAL percentages in proper order
+            reasoning.append(f"**Predicted Model**: {model_name}")
+            reasoning.append(f"**Confidence**: {confidence*100:.1f}%")
+            reasoning.append("")
+            reasoning.append("**Model Probability Distribution:**")
+        
         reasoning.append("")
+        
+        # Show top candidates in proper format
         if combined_scores:
-            sorted_models = sorted(combined_scores.items(), key=lambda x: x[1], reverse=True)
+            sorted_models = sorted(combined_scores.items(), key = lambda x: x[1], reverse = True)
             
-            for model_name, score in sorted_models[:6]:  # Show top 6 models
-                if score < 0.01:  # Skip very low probability models
+            for i, (model_name, score) in enumerate(sorted_models[:6]):
+                # Skip very low probability models
+                if (score < 0.01):  
                     continue
-                    
+                
                 display_name = model_name.replace("-", " ").replace("_", " ").title()
-                # Multiply by 100 to show as percentage (score is already 0-1)
-                percentage = score * 100
+                percentage   = score * 100
                 
-                # Use proper markdown formatting for the list
-                reasoning.append(f"**{display_name}**")
-                reasoning.append(f"{percentage:.1f}%")
-                reasoning.append("")
+                # Single line format: "• Model Name: XX.X%"
+                reasoning.append(f"• **{display_name}**: {percentage:.1f}%")
         
-        # Domain-specific insights
-        reasoning.append("## AI Model Attribution Analysis")
-        reasoning.append(f"Analysis calibrated for {domain.value.replace('_', ' ')} content")
+        reasoning.append("")
+        
+        # Domain-specific insights - FIXED: Removed duplicate header
+        reasoning.append("**Analysis Notes:**")
+        reasoning.append(f"• Calibrated for {domain.value.replace('_', ' ')} domain")
         
         if (domain in [Domain.ACADEMIC, Domain.TECHNICAL_DOC, Domain.AI_ML, Domain.SOFTWARE_DEV, Domain.ENGINEERING, Domain.SCIENCE]):
-            reasoning.append("Higher weight given to coherence and structural patterns")
+            reasoning.append("• Higher weight on structural coherence and technical patterns")
         
         elif (domain in [Domain.CREATIVE, Domain.MARKETING, Domain.SOCIAL_MEDIA, Domain.BLOG_PERSONAL]):
-            reasoning.append("Higher weight given to linguistic diversity and stylistic patterns")
+            reasoning.append("• Emphasis on linguistic diversity and stylistic variation")
         
         elif (domain in [Domain.LEGAL, Domain.MEDICAL]):
-            reasoning.append("Emphasis on formal language patterns and technical terminology")
+            reasoning.append("• Focus on formal language and specialized terminology")
+        
+        elif (domain in [Domain.BUSINESS, Domain.JOURNALISM, Domain.TUTORIAL]):
+            reasoning.append("• Balanced analysis across multiple attribution factors")
         
         return reasoning
 

detector/ensemble.py

@@ -103,7 +103,7 @@ class EnsembleClassifier:
             
         Returns:
         --------
-            { EnsembleResult }        : EnsembleResult object with final prediction
+            { EnsembleResult }       : EnsembleResult object with final prediction
         """
         try:
             # Filter and validate metrics
@@ -114,76 +114,94 @@ class EnsembleClassifier:
                 return self._create_fallback_result(domain, metric_results, "insufficient_metrics")
             
             # Get domain-specific base weights
-            enabled_metrics = {name: True for name in valid_results.keys()}
-            base_weights    = get_active_metric_weights(domain, enabled_metrics)
+            enabled_metrics    = {name: True for name in valid_results.keys()}
+            base_weights       = get_active_metric_weights(domain, enabled_metrics)
             
-            # Try primary aggregation method
+            # Try primary aggregation method : Initialize in case all methods fail unexpectedly
+            calculated_weights = dict()
+            aggregated         = {"ai_probability"    : 0.5, 
+                                  "human_probability" : 0.5, 
+                                  "mixed_probability" : 0.0,
+                                 }
+
             try:
                 if (self.primary_method == "confidence_calibrated"):
-                    aggregated, weights = self._confidence_calibrated_aggregation(results      = valid_results, 
-                                                                                  base_weights = base_weights,
-                                                                                  domain       = domain,
-                                                                                 )
+                    aggregated, calculated_weights = self._confidence_calibrated_aggregation(results      = valid_results, 
+                                                                                             base_weights = base_weights,
+                                                                                             domain       = domain,
+                                                                                            )
                 
                 elif (self.primary_method == "domain_adaptive"):
-                    aggregated, weights = self._domain_adaptive_aggregation(results      = valid_results, 
-                                                                            base_weights = base_weights, 
-                                                                            domain       = domain,
-                                                                           )
+                    aggregated, calculated_weights = self._domain_adaptive_aggregation(results      = valid_results, 
+                                                                                       base_weights = base_weights, 
+                                                                                       domain       = domain,
+                                                                                      )
                 
                 elif (self.primary_method == "consensus_based"):
-                    aggregated, weights = self._consensus_based_aggregation(results      = valid_results, 
-                                                                            base_weights = base_weights,
-                                                                           )
+                    aggregated, calculated_weights = self._consensus_based_aggregation(results      = valid_results, 
+                                                                                       base_weights = base_weights,
+                                                                                       domain       = domain,
+                                                                                      )
                 
                 elif ((self.primary_method == "ml_ensemble") and self.use_ml_ensemble):
-                    aggregated, weights = self._ml_ensemble_aggregation(results      = valid_results, 
-                                                                        base_weights = base_weights,
-                                                                       )
+                    aggregated, calculated_weights = self._ml_ensemble_aggregation(results      = valid_results, 
+                                                                                   base_weights = base_weights,
+                                                                                   domain       = domain,
+                                                                                  )
                 
                 else:
                     # Fallback to domain weighted
-                    aggregated, weights = self._domain_weighted_aggregation(results      = valid_results, 
-                                                                            base_weights = base_weights,
-                                                                           )
+                    aggregated, calculated_weights = self._domain_weighted_aggregation(results      = valid_results, 
+                                                                                       base_weights = base_weights,
+                                                                                       domain       = domain,
+                                                                                      )
             
             except Exception as e:
                 logger.warning(f"Primary aggregation failed: {e}, using fallback")
-                aggregated, weights = self._apply_fallback_aggregation(results      = valid_results, 
-                                                                       base_weights = base_weights,
-                                                                      )
+                aggregated, calculated_weights = self._apply_fallback_aggregation(results      = valid_results, 
+                                                                                  base_weights = base_weights,
+                                                                                 )
             
-            # Calculate advanced metrics
-            overall_confidence = self._calculate_advanced_confidence(results    = valid_results, 
-                                                                     weights    = weights, 
-                                                                     aggregated = aggregated,
-                                                                    )
+            # Start with the calculated weights (from valid_results)
+            final_metric_weights = calculated_weights.copy() 
+
+            # Iterate through the *original* metric_results input to the ensemble
+            for original_metric_name in metric_results.keys():
+                # If a metric from the original input wasn't included in calculated_weights :assign it a weight of 0.0.
+                if original_metric_name not in final_metric_weights:
+                    final_metric_weights[original_metric_name] = 0.0
+
+            # Calculate advanced metrics using the CALCULATED weights (from valid_results), not the final ones
+            overall_confidence   = self._calculate_advanced_confidence(results    = valid_results, 
+                                                                       weights    = calculated_weights, 
+                                                                       aggregated = aggregated,
+                                                                      )
 
-            uncertainty_score  = self._calculate_uncertainty(results    = valid_results, 
-                                                             weights    = weights, 
-                                                             aggregated = aggregated,
-                                                            )
+            uncertainty_score    = self._calculate_uncertainty(results    = valid_results, 
+                                                               weights    = calculated_weights, 
+                                                               aggregated = aggregated,
+                                                              )
 
-            consensus_level    = self._calculate_consensus_level(results = valid_results)
+            consensus_level      = self._calculate_consensus_level(results = valid_results)
             
             # Apply domain-specific threshold with uncertainty consideration
-            domain_thresholds  = get_threshold_for_domain(domain = domain)
-            final_verdict      = self._apply_adaptive_threshold(aggregated     = aggregated, 
-                                                                base_threshold = domain_thresholds.ensemble_threshold,
-                                                                uncertainty    = uncertainty_score,
-                                                               )
+            domain_thresholds    = get_threshold_for_domain(domain = domain)
+            final_verdict        = self._apply_adaptive_threshold(aggregated     = aggregated, 
+                                                                  base_threshold = domain_thresholds.ensemble_threshold,
+                                                                  uncertainty    = uncertainty_score,
+                                                                 )
             
-            # Generate detailed reasoning
-            reasoning          = self._generate_detailed_reasoning(results     = valid_results, 
-                                                                   weights     = weights, 
-                                                                   aggregated  = aggregated, 
-                                                                   verdict     = final_verdict, 
-                                                                   uncertainty = uncertainty_score, 
-                                                                   consensus   = consensus_level,
-                                                                  )
+            # Generate detailed reasoning using the CALCULATED weights
+            reasoning            = self._generate_detailed_reasoning(results     = valid_results, 
+                                                                     weights     = calculated_weights,
+                                                                     aggregated  = aggregated, 
+                                                                     verdict     = final_verdict, 
+                                                                     uncertainty = uncertainty_score, 
+                                                                     consensus   = consensus_level,
+                                                                    )
             
-            # Calculate weighted scores
-            weighted_scores    = {name: result.ai_probability * weights.get(name, 0.0) for name, result in valid_results.items()}
+            # Calculate weighted scores based on the CALCULATED weights (from valid_results)
+            weighted_scores      = {name: result.ai_probability * calculated_weights.get(name, 0.0) for name, result in valid_results.items()}
             
             return EnsembleResult(final_verdict      = final_verdict,
                                   ai_probability     = aggregated["ai_probability"],
@@ -192,7 +210,7 @@ class EnsembleClassifier:
                                   overall_confidence = overall_confidence,
                                   domain             = domain,
                                   metric_results     = metric_results,
-                                  metric_weights     = weights,
+                                  metric_weights     = final_metric_weights,
                                   weighted_scores    = weighted_scores,
                                   reasoning          = reasoning,
                                   uncertainty_score  = uncertainty_score,
@@ -202,8 +220,8 @@ class EnsembleClassifier:
         except Exception as e:
             logger.error(f"Error in advanced ensemble prediction: {e}")
             return self._create_fallback_result(domain, metric_results, str(e))
-    
 
+    
     def _validate_metrics(self, results: Dict[str, MetricResult]) -> tuple:
         """
         Validate metrics and return quality information
@@ -454,126 +472,126 @@ class EnsembleClassifier:
         Get domain-specific performance weights (would come from validation data)
         """
         # Placeholder - in practice, this would be based on historical performance per domain : FUTURE WORK
-        performance_weights = {'structural'        : 1.0, 
-                               'entropy'           : 1.0, 
-                               'semantic_analysis' : 1.0,
-                               'linguistic'        : 1.0, 
-                               'perplexity'        : 1.0, 
-                               'detect_gpt'        : 1.0,
+        performance_weights = {'structural'                   : 1.0, 
+                               'entropy'                      : 1.0, 
+                               'semantic_analysis'            : 1.0,
+                               'linguistic'                   : 1.0, 
+                               'perplexity'                   : 1.0, 
+                               'multi_perturbation_stability' : 1.0,
                               }
         
         # Domain-specific adjustments for all 16 domains
-        domain_adjustments  = {Domain.GENERAL       : {'structural'        : 1.0,
-                                                       'perplexity'        : 1.0,
-                                                       'entropy'           : 1.0,
-                                                       'semantic_analysis' : 1.0,
-                                                       'linguistic'        : 1.0,
-                                                       'detect_gpt'        : 1.0,
+        domain_adjustments  = {Domain.GENERAL       : {'structural'                   : 1.0,
+                                                       'perplexity'                   : 1.0,
+                                                       'entropy'                      : 1.0,
+                                                       'semantic_analysis'            : 1.0,
+                                                       'linguistic'                   : 1.0,
+                                                       'multi_perturbation_stability' : 1.0,
                                                       },
-                               Domain.ACADEMIC      : {'structural'        : 1.2, 
-                                                       'perplexity'        : 1.3,
-                                                       'entropy'           : 0.9,
-                                                       'semantic_analysis' : 1.1,
-                                                       'linguistic'        : 1.3, 
-                                                       'detect_gpt'        : 0.8,
+                               Domain.ACADEMIC      : {'structural'                   : 1.2, 
+                                                       'perplexity'                   : 1.3,
+                                                       'entropy'                      : 0.9,
+                                                       'semantic_analysis'            : 1.1,
+                                                       'linguistic'                   : 1.3, 
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.CREATIVE      : {'structural'        : 0.9,
-                                                       'perplexity'        : 1.1,
-                                                       'entropy'           : 1.2, 
-                                                       'semantic_analysis' : 1.0,
-                                                       'linguistic'        : 1.1,
-                                                       'detect_gpt'        : 0.9,
+                               Domain.CREATIVE      : {'structural'                   : 0.9,
+                                                       'perplexity'                   : 1.1,
+                                                       'entropy'                      : 1.2, 
+                                                       'semantic_analysis'            : 1.0,
+                                                       'linguistic'                   : 1.1,
+                                                       'multi_perturbation_stability' : 0.9,
                                                       },
-                               Domain.AI_ML         : {'structural'        : 1.2,
-                                                       'perplexity'        : 1.3,
-                                                       'entropy'           : 0.9,
-                                                       'semantic_analysis' : 1.1,
-                                                       'linguistic'        : 1.2,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.AI_ML         : {'structural'                   : 1.2,
+                                                       'perplexity'                   : 1.3,
+                                                       'entropy'                      : 0.9,
+                                                       'semantic_analysis'            : 1.1,
+                                                       'linguistic'                   : 1.2,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.SOFTWARE_DEV  : {'structural'        : 1.2,
-                                                       'perplexity'        : 1.3,
-                                                       'entropy'           : 0.9,
-                                                       'semantic_analysis' : 1.1,
-                                                       'linguistic'        : 1.2,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.SOFTWARE_DEV  : {'structural'                   : 1.2,
+                                                       'perplexity'                   : 1.3,
+                                                       'entropy'                      : 0.9,
+                                                       'semantic_analysis'            : 1.1,
+                                                       'linguistic'                   : 1.2,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.TECHNICAL_DOC : {'structural'        : 1.3, 
-                                                       'perplexity'        : 1.3,
-                                                       'entropy'           : 0.9,
-                                                       'semantic_analysis' : 1.2,
-                                                       'linguistic'        : 1.2,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.TECHNICAL_DOC : {'structural'                   : 1.3, 
+                                                       'perplexity'                   : 1.3,
+                                                       'entropy'                      : 0.9,
+                                                       'semantic_analysis'            : 1.2,
+                                                       'linguistic'                   : 1.2,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.ENGINEERING   : {'structural'        : 1.2,
-                                                       'perplexity'        : 1.3,
-                                                       'entropy'           : 0.9,
-                                                       'semantic_analysis' : 1.1,
-                                                       'linguistic'        : 1.2,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.ENGINEERING   : {'structural'                   : 1.2,
+                                                       'perplexity'                   : 1.3,
+                                                       'entropy'                      : 0.9,
+                                                       'semantic_analysis'            : 1.1,
+                                                       'linguistic'                   : 1.2,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.SCIENCE       : {'structural'        : 1.2,
-                                                       'perplexity'        : 1.3,
-                                                       'entropy'           : 0.9,
-                                                       'semantic_analysis' : 1.1,
-                                                       'linguistic'        : 1.2,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.SCIENCE       : {'structural'                   : 1.2,
+                                                       'perplexity'                   : 1.3,
+                                                       'entropy'                      : 0.9,
+                                                       'semantic_analysis'            : 1.1,
+                                                       'linguistic'                   : 1.2,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.BUSINESS      : {'structural'        : 1.1,
-                                                       'perplexity'        : 1.2,
-                                                       'entropy'           : 1.0,
-                                                       'semantic_analysis' : 1.1,
-                                                       'linguistic'        : 1.1,
-                                                       'detect_gpt'        : 0.9,
+                               Domain.BUSINESS      : {'structural'                   : 1.1,
+                                                       'perplexity'                   : 1.2,
+                                                       'entropy'                      : 1.0,
+                                                       'semantic_analysis'            : 1.1,
+                                                       'linguistic'                   : 1.1,
+                                                       'multi_perturbation_stability' : 0.9,
                                                       },
-                               Domain.LEGAL         : {'structural'        : 1.3,
-                                                       'perplexity'        : 1.3,
-                                                       'entropy'           : 0.9,
-                                                       'semantic_analysis' : 1.2,
-                                                       'linguistic'        : 1.3,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.LEGAL         : {'structural'                   : 1.3,
+                                                       'perplexity'                   : 1.3,
+                                                       'entropy'                      : 0.9,
+                                                       'semantic_analysis'            : 1.2,
+                                                       'linguistic'                   : 1.3,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.MEDICAL       : {'structural'        : 1.2,
-                                                       'perplexity'        : 1.3,
-                                                       'entropy'           : 0.9,
-                                                       'semantic_analysis' : 1.2,
-                                                       'linguistic'        : 1.2,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.MEDICAL       : {'structural'                   : 1.2,
+                                                       'perplexity'                   : 1.3,
+                                                       'entropy'                      : 0.9,
+                                                       'semantic_analysis'            : 1.2,
+                                                       'linguistic'                   : 1.2,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.JOURNALISM    : {'structural'        : 1.1,
-                                                       'perplexity'        : 1.2,
-                                                       'entropy'           : 1.0,
-                                                       'semantic_analysis' : 1.1,
-                                                       'linguistic'        : 1.1,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.JOURNALISM    : {'structural'                   : 1.1,
+                                                       'perplexity'                   : 1.2,
+                                                       'entropy'                      : 1.0,
+                                                       'semantic_analysis'            : 1.1,
+                                                       'linguistic'                   : 1.1,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.MARKETING     : {'structural'        : 1.0,
-                                                       'perplexity'        : 1.1,
-                                                       'entropy'           : 1.1,
-                                                       'semantic_analysis' : 1.0,
-                                                       'linguistic'        : 1.2,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.MARKETING     : {'structural'                   : 1.0,
+                                                       'perplexity'                   : 1.1,
+                                                       'entropy'                      : 1.1,
+                                                       'semantic_analysis'            : 1.0,
+                                                       'linguistic'                   : 1.2,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.SOCIAL_MEDIA  : {'structural'        : 0.8,
-                                                       'perplexity'        : 1.0,
-                                                       'entropy'           : 1.3, 
-                                                       'semantic_analysis' : 0.9,
-                                                       'linguistic'        : 0.7,
-                                                       'detect_gpt'        : 0.9,
+                               Domain.SOCIAL_MEDIA  : {'structural'                   : 0.8,
+                                                       'perplexity'                   : 1.0,
+                                                       'entropy'                      : 1.3, 
+                                                       'semantic_analysis'            : 0.9,
+                                                       'linguistic'                   : 0.7,
+                                                       'multi_perturbation_stability' : 0.9,
                                                       },
-                               Domain.BLOG_PERSONAL : {'structural'        : 0.9,
-                                                       'perplexity'        : 1.1,
-                                                       'entropy'           : 1.2,
-                                                       'semantic_analysis' : 1.0,
-                                                       'linguistic'        : 1.0,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.BLOG_PERSONAL : {'structural'                   : 0.9,
+                                                       'perplexity'                   : 1.1,
+                                                       'entropy'                      : 1.2,
+                                                       'semantic_analysis'            : 1.0,
+                                                       'linguistic'                   : 1.0,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
-                               Domain.TUTORIAL      : {'structural'        : 1.1,
-                                                       'perplexity'        : 1.2,
-                                                       'entropy'           : 1.0,
-                                                       'semantic_analysis' : 1.1,
-                                                       'linguistic'        : 1.1,
-                                                       'detect_gpt'        : 0.8,
+                               Domain.TUTORIAL      : {'structural'                   : 1.1,
+                                                       'perplexity'                   : 1.2,
+                                                       'entropy'                      : 1.0,
+                                                       'semantic_analysis'            : 1.1,
+                                                       'linguistic'                   : 1.1,
+                                                       'multi_perturbation_stability' : 0.8,
                                                       },
                               }
         

detector/highlighter.py

@@ -48,7 +48,7 @@ class TextHighlighter:
     - Explainable tooltips
     - Highlighting metrics calculation
     """
-    # Color thresholds with mixed content support - FIXED RANGES
+    # Color thresholds with mixed content support
     COLOR_THRESHOLDS = [(0.00, 0.10, "very-high-human", "#dcfce7", "Very likely human-written"),
                         (0.10, 0.25, "high-human", "#bbf7d0", "Likely human-written"),
                         (0.25, 0.40, "medium-human", "#86efac", "Possibly human-written"),
@@ -61,7 +61,7 @@ class TextHighlighter:
     # Mixed content pattern
     MIXED_THRESHOLD  = 0.25
 
-    # GPTZero-like risk weights
+    # Risk weights
     RISK_WEIGHTS     = {'very-high-ai'    : 1.0,
                         'high-ai'         : 0.8,
                         'medium-ai'       : 0.6,
@@ -189,7 +189,7 @@ class TextHighlighter:
     def _calculate_sentence_ensemble_probability(self, sentence: str, metric_results: Dict[str, MetricResult], weights: Dict[str, float], 
                                                  ensemble_result: Optional[EnsembleResult] = None) -> Tuple[float, float, float, float, Dict[str, float]]:
         """
-        Calculate sentence probabilities using ensemble methods with domain calibration - FIXED
+        Calculate sentence probabilities using ensemble methods with domain calibration
         """
         sentence_length = len(sentence.split())
         
@@ -289,7 +289,7 @@ class TextHighlighter:
 
     def _calculate_weighted_probability(self, metric_results: Dict[str, MetricResult], weights: Dict[str, float], breakdown: Dict[str, float]) -> Tuple[float, float, float, float, Dict[str, float]]:
         """
-        Fallback weighted probability calculation - FIXED
+        Fallback weighted probability calculation
         """
         weighted_ai_probs    = list()
         weighted_human_probs = list()
@@ -456,8 +456,8 @@ class TextHighlighter:
             if self._has_repetition(sentence):
                 return min(1.0, base_prob * 1.2)
         
-        elif (metric_name == "detect_gpt"):
-            # DetectGPT adjustments for sentence level
+        elif (metric_name == "multi_perturbation_stability"):
+            # MultiPerturbationStability adjustments for sentence level
             if (sentence_length > 15):
                 return min(1.0, base_prob * 1.1)
         
@@ -466,7 +466,7 @@ class TextHighlighter:
 
     def _get_color_for_probability(self, probability: float, is_mixed_content: bool = False, mixed_prob: float = 0.0) -> Tuple[str, str, str]:
         """
-        Get color class with mixed content support - FIXED
+        Get color class with mixed content support
         """
         # Check mixed content first
         if (is_mixed_content and (mixed_prob > self.MIXED_THRESHOLD)):
@@ -687,7 +687,7 @@ class TextHighlighter:
             
             include_legend         { bool }                     : Whether to include legend (set to False to avoid duplicates)
             
-            include_metrics        { bool }                     : Whether to include GPTZero-like metrics summary
+            include_metrics        { bool }                     : Whether to include metrics summary
             
         Returns:
         --------
@@ -732,7 +732,7 @@ class TextHighlighter:
 
     def _generate_enhanced_css(self) -> str:
         """
-        Generate CSS for highlighting - FIXED: Better readability
+        Generate CSS for highlighting for Better readability
         """
         return """
         <style>
@@ -863,7 +863,7 @@ class TextHighlighter:
 
     def _generate_metrics_summary(self, sentences: List[HighlightedSentence]) -> str:
         """
-        Generate summary statistics for highlighted sentences - FIXED to calculate like GPTZero
+        Generate summary statistics for highlighted sentences
         """
         if not sentences:
             return ""
@@ -893,7 +893,7 @@ class TextHighlighter:
         avg_ai_prob        = sum(s.ai_probability for s in sentences) / total_sentences
         avg_human_prob     = sum(s.human_probability for s in sentences) / total_sentences
         
-        # GPTZero-like sentence counts
+        # Sentence counts
         ai_sentences       = very_high_ai + high_ai + medium_ai
         human_sentences    = very_high_human + high_human + medium_human
         
@@ -994,7 +994,7 @@ class TextHighlighter:
             
         Returns:
         --------
-            { Dict[str, float] } : Dictionary with GPTZero-like metrics
+                         { Dict[str, float] }                   : Dictionary with metrics
         """
         if not highlighted_sentences:
             return {}

detector/orchestrator.py

@@ -11,7 +11,6 @@ from metrics.entropy import EntropyMetric
 from config.threshold_config import Domain
 from metrics.base_metric import MetricResult
 from detector.ensemble import EnsembleResult
-from metrics.detect_gpt import DetectGPTMetric
 from metrics.perplexity import PerplexityMetric
 from metrics.linguistic import LinguisticMetric
 from metrics.structural import StructuralMetric
@@ -23,7 +22,7 @@ from processors.domain_classifier import DomainPrediction
 from processors.language_detector import LanguageDetector
 from metrics.semantic_analysis import SemanticAnalysisMetric
 from processors.language_detector import LanguageDetectionResult
-
+from metrics.multi_perturbation_stability import MultiPerturbationStabilityMetric
 
 
 @dataclass
@@ -179,13 +178,13 @@ class DetectionOrchestrator:
         except Exception as e:
             logger.error(f"Failed to initialize linguistic metric: {repr(e)}")
         
-        # DetectGPT metric (expensive)
+        # MultiPerturbationStability metric (expensive)
         try:
-            metrics["detect_gpt"] = DetectGPTMetric()
-            logger.debug("DetectGPT metric initialized")
+            metrics["multi_perturbation_stability"] = MultiPerturbationStabilityMetric()
+            logger.debug("MultiPerturbationStability metric initialized")
         
         except Exception as e:
-            logger.error(f"Failed to initialize DetectGPT metric: {repr(e)}")
+            logger.error(f"Failed to initialize MultiPerturbationStability metric: {repr(e)}")
         
         logger.info(f"Initialized {len(metrics)} metrics: {list(metrics.keys())}")
         return metrics
@@ -328,7 +327,7 @@ class DetectionOrchestrator:
                
                 try:
                     # Check if we should skip expensive metrics
-                    if (self.skip_expensive_metrics and (name == "detect_gpt")):
+                    if (self.skip_expensive_metrics and (name == "multi_perturbation_stability")):
                         logger.info(f"Skipping expensive metric: {name}")
                         continue
                     

metrics/{detect_gpt.py → multi_perturbation_stability.py}

@@ -15,18 +15,26 @@ from config.threshold_config import get_threshold_for_domain
 
 
 
-class DetectGPTMetric(BaseMetric):
+class MultiPerturbationStabilityMetric(BaseMetric):
     """
-    DetectGPT implementation for text stability analysis under perturbations
+    Multi-Perturbation Stability Metric (MPSM) 
+    
+    A hybrid approach for combining multiple perturbation techniques for robust AI-generated text detection
     
     Measures:
     - Text stability under random perturbations
     - Likelihood curvature analysis
     - Masked token prediction analysis
+
+    Perturbation Methods:
+    - Word deletation & swapping
+    - RoBERTa mask filling
+    - Synonym replacement
+    - Chunk-based stability Analysis
     """
     def __init__(self):
-        super().__init__(name        = "detect_gpt",
-                         description = "Text stability analysis under perturbations (DetectGPT method)",
+        super().__init__(name        = "multi_perturbation_stability",
+                         description = "Text stability analysis under multi-perturbations techniques",
                         )
         
         self.gpt_model      = None
@@ -38,14 +46,14 @@ class DetectGPTMetric(BaseMetric):
 
     def initialize(self) -> bool:
         """
-        Initialize the DetectGPT metric
+        Initialize the MultiPerturbationStability metric
         """
         try:
-            logger.info("Initializing DetectGPT metric...")
+            logger.info("Initializing MultiPerturbationStability metric...")
             
             # Load GPT-2 model for likelihood calculation
             model_manager = get_model_manager()
-            gpt_result    = model_manager.load_model("detectgpt_base")
+            gpt_result    = model_manager.load_model(model_name = "multi_perturbation_base")
             
             if isinstance(gpt_result, tuple):
                 self.gpt_model, self.gpt_tokenizer = gpt_result
@@ -53,11 +61,11 @@ class DetectGPTMetric(BaseMetric):
                 self.gpt_model.to(self.device)
            
             else:
-                logger.error("Failed to load GPT-2 model for DetectGPT")
+                logger.error("Failed to load GPT-2 model for MultiPerturbationStability")
                 return False
             
             # Load masked language model for perturbations
-            mask_result = model_manager.load_model("detectgpt_mask")
+            mask_result = model_manager.load_model("multi_perturbation_mask")
             
             if (isinstance(mask_result, tuple)):
                 self.mask_model, self.mask_tokenizer = mask_result
@@ -73,17 +81,17 @@ class DetectGPTMetric(BaseMetric):
             
             self.is_initialized = True
             
-            logger.success("DetectGPT metric initialized successfully")
+            logger.success("MultiPerturbationStability metric initialized successfully")
             return True
             
         except Exception as e:
-            logger.error(f"Failed to initialize DetectGPT metric: {repr(e)}")
+            logger.error(f"Failed to initialize MultiPerturbationStability metric: {repr(e)}")
             return False
     
 
     def compute(self, text: str, **kwargs) -> MetricResult:
         """
-        Compute DetectGPT analysis with FULL DOMAIN THRESHOLD INTEGRATION
+        Compute MultiPerturbationStability analysis with FULL DOMAIN THRESHOLD INTEGRATION
         """
         try:
             if ((not text) or (len(text.strip()) < 100)):
@@ -92,17 +100,17 @@ class DetectGPTMetric(BaseMetric):
                                     human_probability = 0.5,
                                     mixed_probability = 0.0,
                                     confidence        = 0.1,
-                                    error             = "Text too short for DetectGPT analysis",
+                                    error             = "Text too short for MultiPerturbationStability analysis",
                                    )
             
             # Get domain-specific thresholds
-            domain               = kwargs.get('domain', Domain.GENERAL)
-            domain_thresholds    = get_threshold_for_domain(domain)
-            detectgpt_thresholds = domain_thresholds.detect_gpt
+            domain                                  = kwargs.get('domain', Domain.GENERAL)
+            domain_thresholds                       = get_threshold_for_domain(domain)
+            multi_perturbation_stability_thresholds = domain_thresholds.multi_perturbation_stability
             
             # Check if we should run this computationally expensive metric
             if (kwargs.get('skip_expensive', False)):
-                logger.info("Skipping DetectGPT due to computational constraints")
+                logger.info("Skipping MultiPerturbationStability due to computational constraints")
                 
                 return MetricResult(metric_name       = self.name,
                                     ai_probability    = 0.5,
@@ -112,17 +120,17 @@ class DetectGPTMetric(BaseMetric):
                                     error             = "Skipped for performance",
                                    )
             
-            # Calculate DetectGPT features
-            features                        = self._calculate_detectgpt_features(text)
+            # Calculate MultiPerturbationStability features
+            features                        = self._calculate_stability_features(text)
             
-            # Calculate raw DetectGPT score (0-1 scale)
-            raw_detectgpt_score, confidence = self._analyze_detectgpt_patterns(features)
+            # Calculate raw MultiPerturbationStability score (0-1 scale)
+            raw_stability_score, confidence = self._analyze_stability_patterns(features)
             
             # Apply domain-specific thresholds to convert raw score to probabilities
-            ai_prob, human_prob, mixed_prob = self._apply_domain_thresholds(raw_detectgpt_score, detectgpt_thresholds, features)
+            ai_prob, human_prob, mixed_prob = self._apply_domain_thresholds(raw_stability_score, multi_perturbation_stability_thresholds, features)
             
             # Apply confidence multiplier from domain thresholds
-            confidence                     *= detectgpt_thresholds.confidence_multiplier
+            confidence                     *= multi_perturbation_stability_thresholds.confidence_multiplier
             confidence                      = max(0.0, min(1.0, confidence))
             
             return MetricResult(metric_name       = self.name,
@@ -132,14 +140,14 @@ class DetectGPTMetric(BaseMetric):
                                 confidence        = confidence,
                                 details           = {**features, 
                                                      'domain_used'     : domain.value,
-                                                     'ai_threshold'    : detectgpt_thresholds.ai_threshold,
-                                                     'human_threshold' : detectgpt_thresholds.human_threshold,
-                                                     'raw_score'       : raw_detectgpt_score,
+                                                     'ai_threshold'    : multi_perturbation_stability_thresholds.ai_threshold,
+                                                     'human_threshold' : multi_perturbation_stability_thresholds.human_threshold,
+                                                     'raw_score'       : raw_stability_score,
                                                     },
                                )
             
         except Exception as e:
-            logger.error(f"Error in DetectGPT computation: {repr(e)}")
+            logger.error(f"Error in MultiPerturbationStability computation: {repr(e)}")
 
             return MetricResult(metric_name       = self.name,
                                 ai_probability    = 0.5,
@@ -201,9 +209,9 @@ class DetectGPTMetric(BaseMetric):
         return ai_prob, human_prob, mixed_prob
     
 
-    def _calculate_detectgpt_features(self, text: str) -> Dict[str, Any]:
+    def _calculate_stability_features(self, text: str) -> Dict[str, Any]:
         """
-        Calculate comprehensive DetectGPT features
+        Calculate comprehensive MultiPerturbationStability features
         """
         if not self.gpt_model or not self.gpt_tokenizer:
             return self._get_default_features()
@@ -267,7 +275,7 @@ class DetectGPTMetric(BaseMetric):
                    }
             
         except Exception as e:
-            logger.warning(f"DetectGPT feature calculation failed: {repr(e)}")
+            logger.warning(f"MultiPerturbationStability feature calculation failed: {repr(e)}")
             return self._get_default_features()
     
 
@@ -652,9 +660,9 @@ class DetectGPTMetric(BaseMetric):
         return stabilities
     
 
-    def _analyze_detectgpt_patterns(self, features: Dict[str, Any]) -> tuple:
+    def _analyze_stability_patterns(self, features: Dict[str, Any]) -> tuple:
         """
-        Analyze DetectGPT patterns to determine RAW DetectGPT score (0-1 scale) : Higher score = more AI-like
+        Analyze MultiPerturbationStability patterns to determine RAW MultiPerturbationStability score (0-1 scale) : Higher score = more AI-like
         """
         # Check feature validity first
         required_features = ['stability_score', 'curvature_score', 'normalized_likelihood_ratio', 'stability_variance', 'perturbation_variance']
@@ -781,7 +789,7 @@ class DetectGPTMetric(BaseMetric):
 
     def _preprocess_text_for_analysis(self, text: str) -> str:
         """
-        Preprocess text for DetectGPT analysis
+        Preprocess text for MultiPerturbationStability analysis
         """
         if not text:
             return ""
@@ -882,4 +890,4 @@ class DetectGPTMetric(BaseMetric):
 
 
 # Export
-__all__ = ["DetectGPTMetric"]
+__all__ = ["MultiPerturbationStabilityMetric"]

processors/language_detector.py

@@ -1,5 +1,6 @@
 # DEPENDENCIES
 import re
+import torch
 import string
 from enum import Enum
 from typing import Dict
@@ -17,6 +18,7 @@ try:
     # Seed for reproducibility
     DetectorFactory.seed = 0
     LANGDETECT_AVAILABLE = True
+
 except ImportError:
     logger.warning("langdetect not available. Install: pip install langdetect")
     LANGDETECT_AVAILABLE = False
@@ -24,6 +26,7 @@ except ImportError:
 try:
     from models.model_manager import get_model_manager
     MODEL_MANAGER_AVAILABLE = True
+    
 except ImportError:
     logger.warning("model_manager not available, using fallback methods")
     MODEL_MANAGER_AVAILABLE = False
@@ -251,7 +254,7 @@ class LanguageDetector:
         # Method 1 : ML Model
         if self.use_model and self.is_initialized:
             try:
-                result                  = self._detect_with_model(cleaned_text)
+                result                  = self._detect_with_model(text = cleaned_text)
                 result.detection_method = "xlm-roberta-model"
             
             except Exception as e:
@@ -261,7 +264,7 @@ class LanguageDetector:
         # Method 2 : langdetect library
         if result is None and LANGDETECT_AVAILABLE:
             try:
-                result                  = self._detect_with_langdetect(cleaned_text)
+                result                  = self._detect_with_langdetect(text = cleaned_text)
                 result.detection_method = "langdetect-library"
             
             except Exception as e:
@@ -292,35 +295,203 @@ class LanguageDetector:
 
     def _detect_with_model(self, text: str) -> LanguageDetectionResult:
         """
-        Detect language using XLM-RoBERTa model
+        Detect language using XLM-RoBERTa model with sentence-based chunking for more accurate detection on long texts
         """
         if not self.is_initialized:
             if not self.initialize():
                 raise RuntimeError("Model not initialized")
         
-        # Conservative truncation for long texts
-        if (len(text) > 2000):  
-            text = text[:2000]
-            logger.warning(f"Text too long, truncated to {len(text)} characters for language detection")
+        try:
+            # Strategy: Use multiple text chunks for better accuracy
+            chunks            = self._split_text_into_chunks(text = text)
+            logger.info(f"Split text into {len(chunks)} chunks for language detection")
+            
+            all_chunk_results = list()
+            
+            for i, chunk in enumerate(chunks):
+                try:
+                    chunk_result = self._process_single_chunk(chunk = chunk)
+                    all_chunk_results.append(chunk_result)
+                    
+                except Exception as e:
+                    logger.warning(f"Chunk {i+1} processing failed: {repr(e)}")
+                    continue
+            
+            if not all_chunk_results:
+                raise RuntimeError("All chunks failed processing")
+            
+            # Aggregate results from all chunks
+            return self._aggregate_chunk_results(chunk_results = all_chunk_results)
+            
+        except Exception as e:
+            logger.error(f"Chunk-based model detection failed: {repr(e)}")
+            raise
+
+
+    def _split_text_into_chunks(self, text: str, max_chunk_length: int = 500, min_chunk_length: int = 50) -> List[str]:
+        """
+        Split text into meaningful chunks for language detection
+        
+        Arguments:
+        ----------
+            text             { str } : Input text
+
+            max_chunk_length { int } : Maximum characters per chunk
+            
+            min_chunk_length { int } : Minimum characters per chunk
+            
+        Returns:
+        --------
+            List of text chunks
+        """
+        if (len(text) <= max_chunk_length):
+            return [text]
         
-        # Get prediction
-        predictions   = self.classifier(text, top_k = 5)
+        # Strategy 1: Split by sentences first
+        sentences     = re.split(r'[.!?]+', text)
+        sentences     = [s.strip() for s in sentences if s.strip()]
         
-        # Parse results
-        all_languages = dict()
-        primary_lang  = None
-        primary_conf  = 0.0
+        chunks        = list()
+
+        current_chunk = ""
+        
+        for sentence in sentences:
+            # If adding this sentence doesn't exceed max length
+            if len(current_chunk) + len(sentence) + 1 <= max_chunk_length:
+                if current_chunk:
+                    current_chunk += " " + sentence
+                
+                else:
+                    current_chunk = sentence
+            
+            else:
+                # Current chunk is full, save it
+                if current_chunk and len(current_chunk) >= min_chunk_length:
+                    chunks.append(current_chunk)
+                
+                # Start new chunk with current sentence
+                current_chunk = sentence
+        
+        # Add the last chunk if it meets minimum length
+        if (current_chunk and (len(current_chunk) >= min_chunk_length)):
+            chunks.append(current_chunk)
+        
+        # Strategy 2: If sentence splitting didn't work well, use fixed-length chunks
+        if ((len(chunks) == 0) or ((len(chunks) == 1 )and (len(chunks[0]) > max_chunk_length))):
+            chunks = self._split_fixed_length(text, max_chunk_length)
+        
+        logger.debug(f"Split {len(text)} chars into {len(chunks)} chunks: {[len(c) for c in chunks]}")
+        return chunks
+
+
+    def _split_fixed_length(self, text: str, chunk_size: int = 1000) -> List[str]:
+        """
+        Fallback: Split text into fixed-length chunks
+        """
+        chunks = list()
+
+        for i in range(0, len(text), chunk_size):
+            chunk = text[i:i + chunk_size]
+            # Try to break at word boundaries
+            if ((i + chunk_size) < len(text)):
+                last_space = chunk.rfind(' ')
+                # If we found a space in the last 30%
+                if (last_space > chunk_size * 0.7):  
+                    chunk = chunk[:last_space].strip()
+
+            chunks.append(chunk)
+        return chunks
+
+
+    def _process_single_chunk(self, chunk: str) -> Dict:
+        """
+        Process a single chunk through the language detection model
+        """
+        # Get the tokenizer from the pipeline
+        tokenizer = self.classifier.tokenizer
+        
+        # Tokenize with explicit length limits
+        inputs    = tokenizer(chunk,
+                              return_tensors     = "pt",
+                              truncation         = True,
+                              max_length         = 512,
+                              padding            = True,
+                              add_special_tokens = True,
+                             )
+        
+        # Get model from pipeline
+        model     = self.classifier.model
+        device    = next(model.parameters()).device
+        
+        # Move inputs to correct device
+        inputs    = {k: v.to(device) for k, v in inputs.items()}
+        
+        with torch.no_grad():
+            outputs     = model(**inputs)
+            predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        
+        # Get top predictions for this chunk
+        top_predictions = torch.topk(predictions[0], k = 3)
         
-        for pred in predictions:
-            lang_code = pred['label']
-            score     = pred['score']
+        chunk_results   = dict()
+
+        for i in range(len(top_predictions.indices)):
+            lang_idx  = top_predictions.indices[i].item()
+            score     = top_predictions.values[i].item()
+            
+            # Get language label from model config
+            lang_code = model.config.id2label[lang_idx]
             
-            # Handle model output format (might be like "en_XX" or just "en")
+            # Handle model output format
             if ('_' in lang_code):
                 lang_code = lang_code.split('_')[0]
             
-            all_languages[lang_code] = score
+            chunk_results[lang_code] = score
+        
+        return chunk_results
+
+
+    def _aggregate_chunk_results(self, chunk_results: List[Dict]) -> LanguageDetectionResult:
+        """
+        Aggregate results from multiple chunks using weighted averaging
+        """
+        # Combine scores from all chunks
+        all_scores    = dict()
+        chunk_weights = list()
+        
+        for chunk_result in chunk_results:
+            # Calculate chunk weight based on confidence and diversity
+            top_score    = max(chunk_result.values()) if chunk_result else 0
+            # Weight by confidence
+            chunk_weight = top_score  
+            
+            chunk_weights.append(chunk_weight)
             
+            for lang_code, score in chunk_result.items():
+                if lang_code not in all_scores:
+                    all_scores[lang_code] = list()
+
+                all_scores[lang_code].append(score)
+        
+        # Calculate weighted average for each language
+        weighted_scores = dict()
+
+        for lang_code, scores in all_scores.items():
+            if (len(scores) != len(chunk_weights)):
+                # Use simple average if weight mismatch
+                weighted_scores[lang_code] = sum(scores) / len(scores)
+
+            else:
+                # Weighted average
+                weighted_sum               = sum(score * weight for score, weight in zip(scores, chunk_weights))
+                total_weight               = sum(chunk_weights)
+                weighted_scores[lang_code] = weighted_sum / total_weight if total_weight > 0 else sum(scores) / len(scores)
+        
+        # Find primary language
+        primary_lang = None
+        primary_conf = 0.0
+        
+        for lang_code, score in weighted_scores.items():
             if (score > primary_conf):
                 primary_conf = score
                 primary_lang = lang_code
@@ -332,17 +503,64 @@ class LanguageDetector:
         except ValueError:
             primary_language = Language.UNKNOWN
         
+        # Calculate detection quality metrics
+        detection_quality = self._assess_detection_quality(chunk_results, weighted_scores)
+        
+        warnings          = list()
+
+        if detection_quality.get('low_confidence', False):
+            warnings.append("Low confidence across multiple chunks")
+
+        if detection_quality.get('inconsistent', False):
+            warnings.append("Inconsistent language detection across chunks")
+        
         return LanguageDetectionResult(primary_language = primary_language,
                                        confidence       = primary_conf,
-                                       all_languages    = all_languages,
+                                       all_languages    = weighted_scores,
                                        script           = Script.UNKNOWN,
-                                       is_multilingual  = False,
-                                       detection_method = "model",
+                                       is_multilingual  = detection_quality.get('multilingual', False),
+                                       detection_method = "model-chunked",
                                        char_count       = 0,
                                        word_count       = 0,
-                                       warnings         = [],
+                                       warnings         = warnings,
                                       )
 
+
+    def _assess_detection_quality(self, chunk_results: List[Dict], final_scores: Dict[str, float]) -> Dict[str, bool]:
+        """
+        Assess the quality and consistency of language detection across chunks
+        """
+        quality_metrics = {'low_confidence' : False,
+                           'inconsistent'   : False,
+                           'multilingual'   : False,
+                          }
+        
+        if not chunk_results:
+            return quality_metrics
+        
+        # Check for low confidence
+        avg_top_confidence = sum(max(chunk.values()) for chunk in chunk_results) / len(chunk_results)
+        if (avg_top_confidence < 0.6):
+            quality_metrics['low_confidence'] = True
+        
+        # Check for inconsistency (different primary languages across chunks)
+        chunk_primaries = list()
+
+        for chunk in chunk_results:
+            if chunk:
+                primary = max(chunk.items(), key=lambda x: x[1])[0]
+                chunk_primaries.append(primary)
+        
+        if (len(set(chunk_primaries)) > 1):
+            quality_metrics['inconsistent'] = True
+        
+        # Check for multilingual content
+        strong_languages = [lang for lang, score in final_scores.items() if score > 0.2]
+        if (len(strong_languages) > 1):
+            quality_metrics['multilingual'] = True
+        
+        return quality_metrics
+
     
     def _detect_with_langdetect(self, text: str) -> LanguageDetectionResult:
         """
@@ -357,7 +575,7 @@ class LanguageDetector:
             all_languages[prob.lang] = prob.prob
         
         # Primary language
-        primary = lang_probs[0]
+        primary       = lang_probs[0]
         
         try:
             primary_language = Language(primary.lang)
@@ -542,14 +760,14 @@ class LanguageDetector:
             { bool }        : True if text is in target language with sufficient confidence
         """
         result = self.detect(text)
-        return (result.primary_language == target_language and (result.confidence >= threshold))
+        return ((result.primary_language == target_language) and (result.confidence >= threshold))
 
     
     def get_supported_languages(self) -> List[str]:
         """
         Get list of supported language codes
         """
-        return [lang.value for lang in Language if lang != Language.UNKNOWN]
+        return [lang.value for lang in Language if (lang != Language.UNKNOWN)]
     
 
     def cleanup(self):
@@ -560,7 +778,7 @@ class LanguageDetector:
         self.is_initialized = False
 
 
-# ==================== Convenience Functions ====================
+# Convenience Functions 
 def quick_detect(text: str, **kwargs) -> LanguageDetectionResult:
     """
     Quick language detection with default settings
@@ -602,42 +820,3 @@ __all__ = ['Script',
            'LanguageDetector',
            'LanguageDetectionResult',
           ]
-
-
-# ==================== Testing ====================
-if __name__ == "__main__":
-    # Test cases
-    test_texts = {"English" : "This is a sample text written in English. It contains multiple sentences to test the language detection system.",
-                  "Spanish" : "Este es un texto de ejemplo escrito en español. Contiene múltiples oraciones para probar el sistema de detección de idiomas.",
-                  "French"  : "Ceci est un exemple de texte écrit en français. Il contient plusieurs phrases pour tester le système de détection de langue.",
-                  "German"  : "Dies ist ein Beispieltext in deutscher Sprache. Es enthält mehrere Sätze zum Testen des Spracherkennungssystems.",
-                  "Chinese" : "这是用中文写的示例文本。它包含多个句子来测试语言检测系统。",
-                  "Russian" : "Это пример текста, написанного на русском языке. Он содержит несколько предложений для проверки системы определения языка.",
-                  "Mixed"   : "This is English. Este es español. C'est français.",
-                  "Short"   : "Hello",
-                 }
-    
-    detector   = LanguageDetector(use_model = True)  # Use fast mode for testing
-    
-    for name, text in test_texts.items():
-        print(f"\n{'='*70}")
-        print(f"Testing: {name}")
-        print(f"{'='*70}")
-        print(f"Text: {text[:80]}...")
-        
-        result = detector.detect(text)
-        
-        print(f"\nPrimary Language: {result.primary_language.value}")
-        print(f"Confidence: {result.confidence:.2f}")
-        print(f"Script: {result.script.value}")
-        print(f"Method: {result.detection_method}")
-        print(f"Multilingual: {result.is_multilingual}")
-        
-        if result.warnings:
-            print(f"Warnings: {result.warnings}")
-        
-        if (len(result.all_languages) > 1):
-            print("\nAll detected languages:")
-            for lang, conf in sorted(result.all_languages.items(), key = lambda x: x[1], reverse = True)[:3]:
-                print(f"  {lang}: {conf:.2f}")
-

processors/text_processor.py

@@ -75,7 +75,7 @@ class TextProcessor:
     MULTIPLE_NEWLINES = re.compile(r'\n{3,}')
     
 
-    def __init__(self, min_text_length: int = 50, max_text_length: int = 50000, preserve_formatting: bool = False, remove_urls: bool = True, remove_emails: bool = True,
+    def __init__(self, min_text_length: int = 50, max_text_length: int = 500000, preserve_formatting: bool = False, remove_urls: bool = True, remove_emails: bool = True,
                  normalize_unicode: bool = True, fix_encoding: bool = True):
         """
         Initialize text processor

reporter/reasoning_generator.py

@@ -61,13 +61,13 @@ class ReasoningGenerator:
     - Metric contribution analysis
     - Actionable recommendations
     """
-    # Enhanced metric descriptions aligned with current architecture
-    METRIC_DESCRIPTIONS = {"structural"        : "analyzes sentence structure, length patterns, and statistical features",
-                           "perplexity"        : "measures text predictability using language model cross-entropy",
-                           "entropy"           : "evaluates token diversity and sequence unpredictability",
-                           "semantic_analysis" : "examines semantic coherence, topic consistency, and logical flow",
-                           "linguistic"        : "assesses grammatical patterns, syntactic complexity, and style markers",
-                           "detect_gpt"        : "tests text stability under perturbation using curvature analysis",
+    # Metric descriptions 
+    METRIC_DESCRIPTIONS = {"structural"                   : "analyzes sentence structure, length patterns, and statistical features",
+                           "perplexity"                   : "measures text predictability using language model cross-entropy",
+                           "entropy"                      : "evaluates token diversity and sequence unpredictability",
+                           "semantic_analysis"            : "examines semantic coherence, topic consistency, and logical flow",
+                           "linguistic"                   : "assesses grammatical patterns, syntactic complexity, and style markers",
+                           "multi_perturbation_stability" : "tests text stability under perturbation using curvature analysis",
                           }
     
     # Ensemble method descriptions
@@ -338,7 +338,7 @@ class ReasoningGenerator:
             elif (not is_ai and (pos_diversity > 0.55)):
                 return f"Rich grammatical variety ({pos_diversity:.2f})"
                 
-        elif (metric_name == "detect_gpt"):
+        elif (metric_name == "multi_perturbation_stability"):
             stability = details.get("stability_score", 0.5)
             curvature = details.get("curvature_score", 0.5)
             

reporter/report_generator.py

@@ -207,12 +207,12 @@ class ReportGenerator:
         """
         Get description for each metric type
         """
-        descriptions = {"structural"        : "Analyzes sentence structure, length patterns, and statistical features",
-                        "perplexity"        : "Measures text predictability using language model cross-entropy",
-                        "entropy"           : "Evaluates token diversity and sequence unpredictability",
-                        "semantic_analysis" : "Examines semantic coherence, topic consistency, and logical flow",
-                        "linguistic"        : "Assesses grammatical patterns, syntactic complexity, and style markers",
-                        "detect_gpt"        : "Tests text stability under perturbation using curvature analysis",
+        descriptions = {"structural"                   : "Analyzes sentence structure, length patterns, and statistical features",
+                        "perplexity"                   : "Measures text predictability using language model cross-entropy",
+                        "entropy"                      : "Evaluates token diversity and sequence unpredictability",
+                        "semantic_analysis"            : "Examines semantic coherence, topic consistency, and logical flow",
+                        "linguistic"                   : "Assesses grammatical patterns, syntactic complexity, and style markers",
+                        "multi_perturbation_stability" : "Tests text stability under perturbation using curvature analysis",
                        }
 
         return descriptions.get(metric_name, "Advanced text analysis metric.")

text_auth_app.py

@@ -767,7 +767,7 @@ async def analyze_text(request: TextAnalysisRequest):
                                                                         use_sentence_level = request.use_sentence_level,
                                                                        )
 
-                # FIXED: Set include_legend=False to prevent duplicate legends
+                # Set include_legend=False to prevent duplicate legends
                 highlighted_html      = highlighter.generate_html(highlighted_sentences = highlighted_sentences,
                                                                   include_legend        = False,  # UI already has its own legend
                                                                   include_metrics       = request.include_metrics_summary,
@@ -794,8 +794,6 @@ async def analyze_text(request: TextAnalysisRequest):
         
         processing_time = time.time() - start_time
         
-        #logger.success(f"[{analysis_id}] Analysis complete: {detection_result.ensemble_result.final_verdict} ({processing_time:.2f}s)")
-        
         # Log the detection event
         log_detection_event(analysis_id         = analysis_id,
                             text_length         = len(request.text),
@@ -806,7 +804,7 @@ async def analyze_text(request: TextAnalysisRequest):
                             enable_attribution  = request.enable_attribution,
                             enable_highlighting = request.enable_highlighting,
                            )
-                           
+        
         return TextAnalysisResponse(status           = "success",
                                     analysis_id      = analysis_id,
                                     detection_result = detection_dict,
@@ -905,7 +903,7 @@ async def analyze_file(file: UploadFile = File(...), domain: Optional[str] = For
                                                                         use_sentence_level = use_sentence_level,
                                                                        )
 
-                # FIXED: Set include_legend=False to prevent duplicate legends
+                # Set include_legend=False to prevent duplicate legends
                 highlighted_html      = highlighter.generate_html(highlighted_sentences = highlighted_sentences,
                                                                   include_legend        = False,  # UI already has its own legend
                                                                   include_metrics       = include_metrics_summary,
@@ -1119,16 +1117,23 @@ async def generate_report(background_tasks: BackgroundTasks, analysis_id: str =
                 logger.warning(f"Highlight generation for report failed: {e}")
         
         # Generate reports
-        report_files = reporter.generate_complete_report(detection_result      = detection_result,
-                                                         attribution_result    = attribution_result,
-                                                         highlighted_sentences = highlighted_sentences,
-                                                         formats               = requested_formats,
-                                                         filename_prefix       = analysis_id,
-                                                        )
+        report_files     = reporter.generate_complete_report(detection_result      = detection_result,
+                                                             attribution_result    = attribution_result,
+                                                             highlighted_sentences = highlighted_sentences,
+                                                             formats               = requested_formats,
+                                                             filename_prefix       = analysis_id,
+                                                            )
+
+        # Extract only the filename from the full path for the response
+        report_filenames = dict()
+
+        for fmt, full_path in report_files.items():
+            # Get the filename part            
+            report_filenames[fmt] = Path(full_path).name
         
         return ReportGenerationResponse(status      = "success",
                                         analysis_id = analysis_id,
-                                        reports     = report_files,
+                                        reports     = report_filenames,
                                         timestamp   = datetime.now().isoformat(),
                                        )
         

ui/static/index.html

@@ -273,6 +273,16 @@ body {
     padding: 2rem;
     border: 1px solid var(--border);
     backdrop-filter: blur(10px);
+    /* Changed from fixed height to use available space */
+    height: 850px;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+}
+.panel-content {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem 0;
 }
 .panel-title {
     font-size: 1.5rem;
@@ -611,7 +621,6 @@ input[type="checkbox"] {
     color: var(--text-secondary);
     line-height: 1.7;
 }
-
 /* Enhanced Reasoning Styles */
 .reasoning-box.enhanced {
     background: linear-gradient(135deg, rgba(30, 41, 59, 0.95) 0%, rgba(15, 23, 42, 0.95) 100%);
@@ -621,25 +630,21 @@ input[type="checkbox"] {
     margin-top: 2rem;
     backdrop-filter: blur(10px);
 }
-
 .reasoning-header {
     display: flex;
     align-items: center;
     gap: 0.75rem;
     margin-bottom: 1rem;
 }
-
 .reasoning-icon {
     font-size: 1.5rem;
 }
-
 .reasoning-title {
     font-size: 1.1rem;
     font-weight: 700;
     color: var(--primary);
     flex: 1;
 }
-
 .confidence-tag {
     padding: 0.25rem 0.75rem;
     border-radius: 20px;
@@ -647,25 +652,21 @@ input[type="checkbox"] {
     font-weight: 600;
     text-transform: uppercase;
 }
-
 .high-confidence {
     background: rgba(16, 185, 129, 0.2);
     color: var(--success);
     border: 1px solid rgba(16, 185, 129, 0.3);
 }
-
 .medium-confidence {
     background: rgba(245, 158, 11, 0.2);
     color: var(--warning);
     border: 1px solid rgba(245, 158, 11, 0.3);
 }
-
 .low-confidence {
     background: rgba(239, 68, 68, 0.2);
     color: var(--danger);
     border: 1px solid rgba(239, 68, 68, 0.3);
 }
-
 .verdict-summary {
     display: flex;
     justify-content: space-between;
@@ -675,27 +676,22 @@ input[type="checkbox"] {
     background: rgba(51, 65, 85, 0.3);
     border-radius: 8px;
 }
-
 .verdict-text {
     font-size: 1.3rem;
     font-weight: 800;
     color: var(--warning);
 }
-
 .probability {
     color: var(--text-secondary);
     font-size: 0.95rem;
 }
-
 .probability-value {
     color: var(--text-primary);
     font-weight: 700;
 }
-
 .metrics-breakdown {
     margin-bottom: 1.5rem;
 }
-
 .breakdown-header {
     font-size: 0.9rem;
     font-weight: 600;
@@ -704,7 +700,6 @@ input[type="checkbox"] {
     text-transform: uppercase;
     letter-spacing: 0.5px;
 }
-
 .metric-indicator {
     display: flex;
     justify-content: space-between;
@@ -714,24 +709,20 @@ input[type="checkbox"] {
     border-radius: 8px;
     transition: all 0.2s ease;
 }
-
 .metric-indicator:hover {
     background: rgba(51, 65, 85, 0.4);
     transform: translateX(4px);
 }
-
 .metric-name {
     font-weight: 600;
     color: var(--text-primary);
     min-width: 140px;
 }
-
 .metric-details {
     display: flex;
     gap: 1rem;
     align-items: center;
 }
-
 .verdict-badge {
     padding: 0.2rem 0.6rem;
     border-radius: 6px;
@@ -741,25 +732,21 @@ input[type="checkbox"] {
     min-width: 60px;
     text-align: center;
 }
-
 .ai-badge {
     background: rgba(239, 68, 68, 0.2);
     color: var(--danger);
     border: 1px solid rgba(239, 68, 68, 0.3);
 }
-
 .human-badge {
     background: rgba(16, 185, 129, 0.2);
     color: var(--success);
     border: 1px solid rgba(16, 185, 129, 0.3);
 }
-
 .confidence, .weight {
     font-size: 0.8rem;
     color: var(--text-muted);
     min-width: 100px;
 }
-
 .agreement-indicator {
     display: flex;
     align-items: center;
@@ -770,16 +757,13 @@ input[type="checkbox"] {
     border-radius: 8px;
     color: var(--success);
 }
-
 .agreement-icon {
     font-weight: 700;
 }
-
 .agreement-text {
     font-size: 0.9rem;
     font-weight: 600;
 }
-
 /* Attribution Section */
 .attribution-section {
     margin-top: 2rem;
@@ -967,6 +951,66 @@ input[type="checkbox"] {
     text-align: center;
     color: var(--text-muted);
 }
+/* Metrics Carousel */
+.metrics-carousel-container {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+}
+.metrics-carousel-content {
+    flex: 1;
+    /* Removed padding and centering to allow content to fill space */
+    padding: 0;
+    /* Removed align-items: center; justify-content: center; to let content take natural space */
+    display: flex;
+    align-items: flex-start;
+    justify-content: flex-start;
+    overflow-y: auto;
+    /* Added some internal spacing for readability */
+    padding: 1rem;
+    /* min-height: 600px; */
+}
+.metric-slide {
+    display: none;
+    width: 100%;
+    /* Reduced padding to make card tighter */
+    padding: 1rem;
+}
+.metric-slide.active {
+    display: block;
+}
+.metrics-carousel-nav {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1rem;
+    border-top: 1px solid var(--border);
+    background: rgba(15, 23, 42, 0.8);
+}
+.carousel-btn {
+    padding: 0.75rem 1.5rem;
+    background: linear-gradient(135deg, var(--primary) 0%, var(--secondary) 100%);
+    color: #fff;
+    border: none;
+    border-radius: 8px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: transform 0.3s, box-shadow 0.3s;
+}
+.carousel-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 20px rgba(6, 182, 212, 0.4);
+}
+.carousel-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+    transform: none;
+}
+.carousel-position {
+    font-size: 0.9rem;
+    color: var(--text-secondary);
+    font-weight: 600;
+}
 /* Responsive */
 @media (max-width: 1200px) {
     .interface-grid {
@@ -1001,6 +1045,10 @@ input[type="checkbox"] {
         flex-direction: column;
         gap: 0.75rem;
     }
+    .panel {
+        height: auto;
+        min-height: 600px;
+    }
 }
 /* Scroll Behavior */
 html {
@@ -1066,7 +1114,7 @@ html {
             <div class="feature-icon">🔬</div>
             <h3 class="feature-title">6-Metric Ensemble</h3>
             <p class="feature-description">
-                Combines Perplexity, Entropy, Statistical, Linguistic, Semantic Analysis, and DetectGPT for comprehensive detection with orthogonal signal capture.
+                Combines Perplexity, Entropy, Statistical, Linguistic, Semantic Analysis, and Multi-Perturbation Stability for comprehensive detection with orthogonal signal capture.
             </p>
         </div>
         <div class="feature-card">
@@ -1109,7 +1157,7 @@ html {
         <div class="metric-icon-box">📊</div>
         <div class="metric-content">
             <h3>Perplexity <span class="metric-weight">Weight: 25%</span></h3>
-            <p>Measures how predictable the text is using GPT-2 XL language model. AI-generated text typically has lower perplexity (more predictable) than human writing, which tends to be more varied and surprising.</p>
+            <p>Measures how predictable the text is using GPT-2 language model. AI-generated text typically has lower perplexity (more predictable) than human writing, which tends to be more varied and surprising.</p>
         </div>
     </div>
     <div class="metric-card">
@@ -1143,7 +1191,7 @@ html {
     <div class="metric-card">
         <div class="metric-icon-box">🔍</div>
         <div class="metric-content">
-            <h3>DetectGPT <span class="metric-weight">Weight: 10%</span></h3>
+            <h3>Multi-Perturbation Stability <span class="metric-weight">Weight: 10%</span></h3>
             <p>Tests text stability under random perturbations. AI-generated text tends to maintain higher likelihood scores even when slightly modified, while human text shows more variation.</p>
         </div>
     </div>
@@ -1160,132 +1208,138 @@ html {
     <!-- Left Panel: Input -->
     <div class="panel">
         <h2 class="panel-title">Submit Content for Analysis</h2>
-        <div class="input-tabs">
-            <button class="input-tab active" data-tab="paste">
-                📋 Paste Text
-            </button>
-            <button class="input-tab" data-tab="upload">
-                📁 Upload File
-            </button>
-        </div>
-        <div id="paste-tab" class="tab-content active">
-            <textarea 
-                id="text-input" 
-                class="text-input" 
-                placeholder="Paste your text here for analysis...
-The more text you provide (minimum 50 characters), the more accurate the detection will be. Our system analyzes linguistic patterns, statistical features, and semantic structures to determine authenticity."
-            ></textarea>
-        </div>
-        <div id="upload-tab" class="tab-content">
-            <div class="file-upload-area" id="file-upload-area">
-                <input type="file" id="file-input" class="file-input" accept=".txt,.pdf,.docx,.doc,.md">
-                <div class="file-upload-icon">📄</div>
-                <div style="font-size: 1.1rem; font-weight: 600; margin-bottom: 0.5rem;">
-                    Click to upload or drag and drop
-                </div>
-                <div style="color: var(--text-muted); font-size: 0.9rem;">
-                    Supported formats: TXT, PDF, DOCX, DOC, MD
-                </div>
-                <div style="color: var(--text-muted); font-size: 0.85rem; margin-top: 0.5rem;">
-                    Maximum file size: 10MB
-                </div>
+        <div class="panel-content">
+            <div class="input-tabs">
+                <button class="input-tab active" data-tab="paste">
+                    📋 Paste Text
+                </button>
+                <button class="input-tab" data-tab="upload">
+                    📁 Upload File
+                </button>
             </div>
-            <div id="file-name-display" class="file-name-display"></div>
-        </div>
-        <div class="options-section">
-            <div class="option-row">
-                <label class="option-label">Content Domain:</label>
-                <select id="domain-select">
-                    <option value="">Auto-detect</option>
-                    <option value="academic">Academic</option>
-                    <option value="technical_doc">Technical/Medical</option>
-                    <option value="creative">Creative Writing</option>
-                    <option value="social_media">Social Media</option>
-                </select>
+            <div id="paste-tab" class="tab-content active">
+                <textarea 
+                    id="text-input" 
+                    class="text-input" 
+                    placeholder="Paste your text here for analysis...
+The more text you provide (minimum 50 characters), the more accurate the detection will be. Our system analyzes linguistic patterns, statistical features, and semantic structures to determine authenticity."
+                ></textarea>
             </div>
-            <div class="option-row">
-                <label class="option-label">Enable AI Model Attribution:</label>
-                <div class="checkbox-wrapper">
-                    <input type="checkbox" id="enable-attribution" checked>
-                    <span style="font-size: 0.85rem; color: var(--text-muted);">Identify which AI model generated the text</span>
+            <div id="upload-tab" class="tab-content">
+                <div class="file-upload-area" id="file-upload-area">
+                    <input type="file" id="file-input" class="file-input" accept=".txt,.pdf,.docx,.doc,.md">
+                    <div class="file-upload-icon">📄</div>
+                    <div style="font-size: 1.1rem; font-weight: 600; margin-bottom: 0.5rem;">
+                        Click to upload or drag and drop
+                    </div>
+                    <div style="color: var(--text-muted); font-size: 0.9rem;">
+                        Supported formats: TXT, PDF, DOCX, DOC, MD
+                    </div>
+                    <div style="color: var(--text-muted); font-size: 0.85rem; margin-top: 0.5rem;">
+                        Maximum file size: 10MB
+                    </div>
                 </div>
+                <div id="file-name-display" class="file-name-display"></div>
             </div>
-            <div class="option-row">
-                <label class="option-label">Enable Sentence Highlighting:</label>
-                <div class="checkbox-wrapper">
-                    <input type="checkbox" id="enable-highlighting" checked>
-                    <span style="font-size: 0.85rem; color: var(--text-muted);">Show suspicious sentences</span>
+            <div class="options-section">
+                <div class="option-row">
+                    <label class="option-label">Content Domain:</label>
+                    <select id="domain-select">
+                        <option value="">Auto-detect</option>
+                        <option value="academic">Academic</option>
+                        <option value="technical_doc">Technical/Medical</option>
+                        <option value="creative">Creative Writing</option>
+                        <option value="social_media">Social Media</option>
+                    </select>
                 </div>
-            </div>
-            <!-- NEW OPTIONS -->
-            <div class="option-row">
-                <label class="option-label">Sentence-Level Analysis:</label>
-                <div class="checkbox-wrapper">
-                    <input type="checkbox" id="use-sentence-level" checked>
-                    <span style="font-size: 0.85rem; color: var(--text-muted);">More accurate but slower analysis</span>
+                <div class="option-row">
+                    <label class="option-label">Enable AI Model Attribution:</label>
+                    <div class="checkbox-wrapper">
+                        <input type="checkbox" id="enable-attribution" checked>
+                        <span style="font-size: 0.85rem; color: var(--text-muted);">Identify which AI model generated the text</span>
+                    </div>
                 </div>
-            </div>
-            <div class="option-row">
-                <label class="option-label">Include Metrics Summary:</label>
-                <div class="checkbox-wrapper">
-                    <input type="checkbox" id="include-metrics-summary" checked>
-                    <span style="font-size: 0.85rem; color: var(--text-muted);">Show text analysis statistics</span>
+                <div class="option-row">
+                    <label class="option-label">Enable Sentence Highlighting:</label>
+                    <div class="checkbox-wrapper">
+                        <input type="checkbox" id="enable-highlighting" checked>
+                        <span style="font-size: 0.85rem; color: var(--text-muted);">Show suspicious sentences</span>
+                    </div>
+                </div>
+                <!-- NEW OPTIONS -->
+                <div class="option-row">
+                    <label class="option-label">Sentence-Level Analysis:</label>
+                    <div class="checkbox-wrapper">
+                        <input type="checkbox" id="use-sentence-level" checked>
+                        <span style="font-size: 0.85rem; color: var(--text-muted);">More accurate but slower analysis</span>
+                    </div>
+                </div>
+                <div class="option-row">
+                    <label class="option-label">Include Metrics Summary:</label>
+                    <div class="checkbox-wrapper">
+                        <input type="checkbox" id="include-metrics-summary" checked>
+                        <span style="font-size: 0.85rem; color: var(--text-muted);">Show text analysis statistics</span>
+                    </div>
                 </div>
             </div>
         </div>
-        <button id="analyze-btn" class="analyze-btn">
-            🔍 Analyze Text
-        </button>
-        <div class="action-buttons">
-            <button id="refresh-btn" class="action-btn refresh">
-                🔄 Refresh
-            </button>
-            <button id="try-next-btn" class="action-btn">
-                ➕ Try Next
+        <div style="display: flex; flex-direction: column; gap: 1rem;">
+            <button id="analyze-btn" class="analyze-btn">
+                🔍 Analyze Text
             </button>
+            <div class="action-buttons">
+                <button id="refresh-btn" class="action-btn refresh">
+                    🔄 Refresh
+                </button>
+                <button id="try-next-btn" class="action-btn">
+                    ➕ Try Next
+                </button>
+            </div>
         </div>
     </div>
     <!-- Right Panel: Results -->
     <div class="panel">
         <h2 class="panel-title">Analysis Report</h2>
-        <div class="report-tabs">
-            <button class="report-tab active" data-report="summary">
-                📊 Summary
-            </button>
-            <button class="report-tab" data-report="highlighted">
-                📝 Highlighted Text
-            </button>
-            <button class="report-tab" data-report="metrics">
-                ℹ️ Detailed Metrics
-            </button>
-        </div>
-        <!-- Summary Report -->
-        <div id="summary-report" class="report-content active">
-            <div class="empty-state">
-                <div class="empty-icon">✓</div>
-                <h3 class="empty-title">Ready for Analysis</h3>
-                <p class="empty-description">
-                    Paste text or upload a document to begin comprehensive AI detection analysis.
-                    Our 6-metric ensemble will provide detailed insights.
-                </p>
+        <div class="panel-content">
+            <div class="report-tabs">
+                <button class="report-tab active" data-report="summary">
+                    📊 Summary
+                </button>
+                <button class="report-tab" data-report="highlighted">
+                    📝 Highlighted Text
+                </button>
+                <button class="report-tab" data-report="metrics">
+                    ℹ️ Detailed Metrics
+                </button>
             </div>
-        </div>
-        <!-- Highlighted Text Report -->
-        <div id="highlighted-report" class="report-content">
-            <div class="empty-state">
-                <div class="empty-icon">📝</div>
-                <p class="empty-description">
-                    Run an analysis to see sentence-level highlighting
-                </p>
+            <!-- Summary Report -->
+            <div id="summary-report" class="report-content active">
+                <div class="empty-state">
+                    <div class="empty-icon">✓</div>
+                    <h3 class="empty-title">Ready for Analysis</h3>
+                    <p class="empty-description">
+                        Paste text or upload a document to begin comprehensive AI detection analysis.
+                        Our 6-metric ensemble will provide detailed insights.
+                    </p>
+                </div>
             </div>
-        </div>
-        <!-- Metrics Report -->
-        <div id="metrics-report" class="report-content">
-            <div class="empty-state">
-                <div class="empty-icon">📊</div>
-                <p class="empty-description">
-                    Run an analysis to see detailed metric breakdowns
-                </p>
+            <!-- Highlighted Text Report -->
+            <div id="highlighted-report" class="report-content">
+                <div class="empty-state">
+                    <div class="empty-icon">📝</div>
+                    <p class="empty-description">
+                        Run an analysis to see sentence-level highlighting
+                    </p>
+                </div>
+            </div>
+            <!-- Metrics Report -->
+            <div id="metrics-report" class="report-content">
+                <div class="empty-state">
+                    <div class="empty-icon">📊</div>
+                    <p class="empty-description">
+                        Run an analysis to see detailed metric breakdowns
+                    </p>
+                </div>
             </div>
         </div>
     </div>
@@ -1295,50 +1349,44 @@ The more text you provide (minimum 50 characters), the more accurate the detecti
 // Configuration
 const API_BASE = '';
 let currentAnalysisData = null;
-
+let currentMetricIndex = 0;
+let totalMetrics = 0;
 // Navigation
 function showLanding() {
     document.getElementById('landing-page').style.display = 'block';
     document.getElementById('analysis-interface').style.display = 'none';
     window.scrollTo(0, 0);
 }
-
 function showAnalysis() {
     document.getElementById('landing-page').style.display = 'none';
     document.getElementById('analysis-interface').style.display = 'block';
     window.scrollTo(0, 0);
     resetAnalysisInterface();
 }
-
 // Reset analysis interface
 function resetAnalysisInterface() {
     // Clear text input
     document.getElementById('text-input').value = '';
-    
     // Clear file input and display
     document.getElementById('file-input').value = '';
     document.getElementById('file-name-display').style.display = 'none';
     document.getElementById('file-name-display').innerHTML = '';
-    
     // Reset tabs to paste
     document.querySelectorAll('.input-tab').forEach(t => t.classList.remove('active'));
     document.querySelector('.input-tab[data-tab="paste"]').classList.add('active');
     document.querySelectorAll('.tab-content').forEach(content => content.classList.remove('active'));
     document.getElementById('paste-tab').classList.add('active');
-    
     // Reset options to defaults
     document.getElementById('domain-select').value = '';
     document.getElementById('enable-attribution').checked = true;
     document.getElementById('enable-highlighting').checked = true;
     document.getElementById('use-sentence-level').checked = true;
     document.getElementById('include-metrics-summary').checked = true;
-    
     // Reset report tabs to summary
     document.querySelectorAll('.report-tab').forEach(t => t.classList.remove('active'));
     document.querySelector('.report-tab[data-report="summary"]').classList.add('active');
     document.querySelectorAll('.report-content').forEach(content => content.classList.remove('active'));
     document.getElementById('summary-report').classList.add('active');
-    
     // Show empty state
     document.getElementById('summary-report').innerHTML = `
         <div class="empty-state">
@@ -1366,11 +1414,11 @@ function resetAnalysisInterface() {
             </p>
         </div>
     `;
-    
     // Clear current analysis data
     currentAnalysisData = null;
+    currentMetricIndex = 0;
+    totalMetrics = 0;
 }
-
 // Input Tab Switching
 document.querySelectorAll('.input-tab').forEach(tab => {
     tab.addEventListener('click', () => {
@@ -1383,7 +1431,6 @@ document.querySelectorAll('.input-tab').forEach(tab => {
         document.getElementById(`${tabName}-tab`).classList.add('active');
     });
 });
-
 // Report Tab Switching
 document.querySelectorAll('.report-tab').forEach(tab => {
     tab.addEventListener('click', () => {
@@ -1396,30 +1443,24 @@ document.querySelectorAll('.report-tab').forEach(tab => {
         document.getElementById(`${reportName}-report`).classList.add('active');
     });
 });
-
 // File Upload Handling
 const fileInput = document.getElementById('file-input');
 const fileUploadArea = document.getElementById('file-upload-area');
 const fileNameDisplay = document.getElementById('file-name-display');
-
 fileUploadArea.addEventListener('click', () => {
     fileInput.click();
 });
-
 fileInput.addEventListener('change', (e) => {
     handleFileSelect(e.target.files[0]);
 });
-
 // Drag and Drop
 fileUploadArea.addEventListener('dragover', (e) => {
     e.preventDefault();
     fileUploadArea.classList.add('drag-over');
 });
-
 fileUploadArea.addEventListener('dragleave', () => {
     fileUploadArea.classList.remove('drag-over');
 });
-
 fileUploadArea.addEventListener('drop', (e) => {
     e.preventDefault();
     fileUploadArea.classList.remove('drag-over');
@@ -1429,77 +1470,61 @@ fileUploadArea.addEventListener('drop', (e) => {
         handleFileSelect(file);
     }
 });
-
 function handleFileSelect(file) {
     if (!file) return;
-    
     const allowedTypes = ['.txt', '.pdf', '.docx', '.doc', '.md'];
     const fileExt = '.' + file.name.split('.').pop().toLowerCase();
-    
     if (!allowedTypes.includes(fileExt)) {
         alert('Unsupported file type. Please upload: TXT, PDF, DOCX, DOC, or MD files.');
         return;
     }
-    
     if (file.size > 10 * 1024 * 1024) {
         alert('File size exceeds 10MB limit.');
         return;
     }
-    
     fileNameDisplay.style.display = 'block';
     fileNameDisplay.innerHTML = `
         <strong>Selected file:</strong> ${file.name} 
         <span style="color: var(--text-muted);">(${formatFileSize(file.size)})</span>
     `;
 }
-
 function formatFileSize(bytes) {
     if (bytes < 1024) return bytes + ' B';
     if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
     return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
 }
-
 // Analyze Button
 document.getElementById('analyze-btn').addEventListener('click', async () => {
     const activeTab = document.querySelector('.input-tab.active').dataset.tab;
     const textInput = document.getElementById('text-input').value.trim();
     const fileInput = document.getElementById('file-input').files[0];
-    
     if (activeTab === 'paste' && !textInput) {
         alert('Please paste some text to analyze (minimum 50 characters).');
         return;
     }
-    
     if (activeTab === 'paste' && textInput.length < 50) {
         alert('Text must be at least 50 characters long for accurate analysis.');
         return;
     }
-    
     if (activeTab === 'upload' && !fileInput) {
         alert('Please select a file to upload.');
         return;
     }
-    
     await performAnalysis(activeTab, textInput, fileInput);
 });
-
 // Refresh Button - clears everything and shows empty state
 document.getElementById('refresh-btn').addEventListener('click', () => {
     resetAnalysisInterface();
 });
-
 // Try Next Button - same as refresh but keeps the interface ready
 document.getElementById('try-next-btn').addEventListener('click', () => {
     resetAnalysisInterface();
 });
-
 async function performAnalysis(mode, text, file) {
     const analyzeBtn = document.getElementById('analyze-btn');
     analyzeBtn.disabled = true;
     analyzeBtn.innerHTML = '⏳ Analyzing...';
-    
     showLoading();
-    
     try {
         let response;
         if (mode === 'paste') {
@@ -1507,7 +1532,6 @@ async function performAnalysis(mode, text, file) {
         } else {
             response = await analyzeFile(file);
         }
-        
         currentAnalysisData = response;
         displayResults(response);
     } catch (error) {
@@ -1518,14 +1542,12 @@ async function performAnalysis(mode, text, file) {
         analyzeBtn.innerHTML = '🔍 Analyze Text';
     }
 }
-
 async function analyzeText(text) {
     const domain = document.getElementById('domain-select').value || null;
     const enableAttribution = document.getElementById('enable-attribution').checked;
     const enableHighlighting = document.getElementById('enable-highlighting').checked;
     const useSentenceLevel = document.getElementById('use-sentence-level').checked;
     const includeMetricsSummary = document.getElementById('include-metrics-summary').checked;
-    
     const response = await fetch(`${API_BASE}/api/analyze`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -1539,21 +1561,17 @@ async function analyzeText(text) {
             skip_expensive_metrics: false
         })
     });
-    
     if (!response.ok) {
         const error = await response.json();
         throw new Error(error.error || 'Analysis failed');
     }
-    
     return await response.json();
 }
-
 async function analyzeFile(file) {
     const domain = document.getElementById('domain-select').value || null;
     const enableAttribution = document.getElementById('enable-attribution').checked;
     const useSentenceLevel = document.getElementById('use-sentence-level').checked;
     const includeMetricsSummary = document.getElementById('include-metrics-summary').checked;
-    
     const formData = new FormData();
     formData.append('file', file);
     if (domain) formData.append('domain', domain);
@@ -1561,20 +1579,16 @@ async function analyzeFile(file) {
     formData.append('use_sentence_level', useSentenceLevel.toString());
     formData.append('include_metrics_summary', includeMetricsSummary.toString());
     formData.append('skip_expensive_metrics', 'false');
-    
     const response = await fetch(`${API_BASE}/api/analyze/file`, {
         method: 'POST',
         body: formData
     });
-    
     if (!response.ok) {
         const error = await response.json();
         throw new Error(error.error || 'File analysis failed');
     }
-    
     return await response.json();
 }
-
 function showLoading() {
     document.getElementById('summary-report').innerHTML = `
         <div class="loading">
@@ -1586,7 +1600,6 @@ function showLoading() {
         </div>
     `;
 }
-
 function showError(message) {
     document.getElementById('summary-report').innerHTML = `
         <div class="empty-state">
@@ -1596,10 +1609,8 @@ function showError(message) {
         </div>
     `;
 }
-
 function displayResults(data) {
     console.log('Response data:', data);
-    
     // Handle different response structures
     const detection = data.detection_result;
     if (!detection) {
@@ -1607,16 +1618,13 @@ function displayResults(data) {
         console.error('Full response:', data);
         return;
     }
-    
     // Extract data based on your actual API structure
     const ensemble = detection.ensemble_result || detection.ensemble;
     const prediction = detection.prediction || {};
     const metrics = detection.metric_results || detection.metrics;
     const analysis = detection.analysis || {};
-    
     // Display Summary with enhanced reasoning
     displaySummary(ensemble, prediction, analysis, data.attribution, data.reasoning);
-    
     // Display Highlighted Text with enhanced features
     if (data.highlighted_html) {
         displayHighlightedText(data.highlighted_html);
@@ -1627,10 +1635,9 @@ function displayResults(data) {
             </div>
         `;
     }
-    
-    // Display Metrics with full details
+    // Display Metrics with carousel
     if (metrics && Object.keys(metrics).length > 0) {
-        displayMetrics(metrics, analysis, ensemble);
+        displayMetricsCarousel(metrics, analysis, ensemble);
     } else {
         document.getElementById('metrics-report').innerHTML = `
             <div class="empty-state">
@@ -1639,7 +1646,6 @@ function displayResults(data) {
         `;
     }
 }
-
 function displaySummary(ensemble, prediction, analysis, attribution, reasoning) {
     // Use ensemble values from your actual API response
     const aiProbability = ensemble.ai_probability !== undefined ? 
@@ -1651,12 +1657,10 @@ function displaySummary(ensemble, prediction, analysis, attribution, reasoning)
     const isAI = verdict.toLowerCase().includes('ai');
     const gaugeColor = isAI ? 'var(--danger)' : 'var(--success)';
     const gaugeDegree = aiProbability * 3.6;
-    
     const confidenceLevel = parseFloat(confidence) >= 70 ? 'HIGH' :
                            parseFloat(confidence) >= 40 ? 'MEDIUM' : 'LOW';
     const confidenceClass = confidenceLevel === 'HIGH' ? 'confidence-high' : 
                            confidenceLevel === 'MEDIUM' ? 'confidence-medium' : 'confidence-low';
-
     let attributionHTML = '';
     if (attribution && attribution.predicted_model) {
         const modelName = attribution.predicted_model.replace(/_/g, ' ').replace(/-/g, ' ').toUpperCase();
@@ -1677,17 +1681,12 @@ function displaySummary(ensemble, prediction, analysis, attribution, reasoning)
         attributionHTML = `
             <div class="attribution-section">
                 <div class="attribution-title">🤖 AI Model Attribution</div>
-                <div class="model-match">
-                    <span class="model-name">Most Likely: ${modelName}</span>
-                    <span class="model-confidence">${modelConf}%</span>
-                </div>
                 ${topModels}
                 ${attribution.reasoning && attribution.reasoning.length > 0 ? 
                     `<p style="color: var(--text-secondary); margin-top: 1rem; font-size: 0.9rem;">${attribution.reasoning[0]}</p>` : ''}
             </div>
         `;
     }
-
     document.getElementById('summary-report').innerHTML = `
         <div class="result-summary">
             <div class="gauge-container">
@@ -1727,10 +1726,12 @@ function displaySummary(ensemble, prediction, analysis, attribution, reasoning)
         </div>
     `;
 }
-
 function createEnhancedReasoningHTML(ensemble, analysis, reasoning) {
     // Use actual reasoning data if available
     if (reasoning && reasoning.summary) {
+        // Process markdown-style *text* to <strong> tags
+        let processedSummary = reasoning.summary;
+        processedSummary = processedSummary.replace(/\*([^*]+)\*/g, '<strong>$1</strong>');
         return `
             <div class="reasoning-box enhanced">
                 <div class="reasoning-header">
@@ -1740,30 +1741,30 @@ function createEnhancedReasoningHTML(ensemble, analysis, reasoning) {
                         ${ensemble.overall_confidence >= 0.7 ? 'High Confidence' : ensemble.overall_confidence >= 0.4 ? 'Medium Confidence' : 'Low Confidence'}
                     </div>
                 </div>
-                
                 <div class="verdict-summary">
                     <div class="verdict-text">${ensemble.final_verdict}</div>
                     <div class="probability">AI Probability: <span class="probability-value">${(ensemble.ai_probability * 100).toFixed(2)}%</span></div>
                 </div>
-
-                <div style="color: var(--text-secondary); line-height: 1.6; margin-bottom: 1.5rem;">
-                    ${reasoning.summary}
+                <div class="reasoning-text-content">
+                    ${processedSummary}
                 </div>
-
                 ${reasoning.key_indicators && reasoning.key_indicators.length > 0 ? `
                     <div class="metrics-breakdown">
                         <div class="breakdown-header">Key Indicators</div>
-                        ${reasoning.key_indicators.map(indicator => `
-                            <div class="metric-indicator">
-                                <div class="metric-name">${indicator.split(':')[0]}</div>
-                                <div class="metric-details">
-                                    <span style="color: var(--text-secondary); font-size: 0.9rem;">${indicator.split(':')[1]}</span>
+                        ${reasoning.key_indicators.map(indicator => {
+                            let processedIndicator = indicator;
+                            processedIndicator = processedIndicator.replace(/\*([^*]+)\*/g, '<strong>$1</strong>');
+                            return `
+                                <div class="metric-indicator">
+                                    <div class="metric-name">${processedIndicator.split(':')[0]}</div>
+                                    <div class="metric-details">
+                                        <span class="reasoning-text-content">${processedIndicator.split(':')[1]}</span>
+                                    </div>
                                 </div>
-                            </div>
-                        `).join('')}
+                            `;
+                        }).join('')}
                     </div>
                 ` : ''}
-
                 ${ensemble.consensus_level > 0.7 ? `
                     <div class="agreement-indicator">
                         <div class="agreement-icon">✓</div>
@@ -1773,7 +1774,6 @@ function createEnhancedReasoningHTML(ensemble, analysis, reasoning) {
             </div>
         `;
     }
-
     // Fallback to basic reasoning if no reasoning data
     return `
         <div class="reasoning-box">
@@ -1786,7 +1786,6 @@ function createEnhancedReasoningHTML(ensemble, analysis, reasoning) {
         </div>
     `;
 }
-
 function displayHighlightedText(html) {
     document.getElementById('highlighted-report').innerHTML = `
         ${createDefaultLegend()}
@@ -1796,7 +1795,6 @@ function displayHighlightedText(html) {
         ${getHighlightStyles()}
     `;
 }
-
 function createDefaultLegend() {
     return `
         <div class="highlight-legend">
@@ -1835,7 +1833,6 @@ function createDefaultLegend() {
         </div>
     `;
 }
-
 function getHighlightStyles() {
     return `
         <style>
@@ -1891,87 +1888,118 @@ function getHighlightStyles() {
         </style>
     `;
 }
-
-function displayMetrics(metrics, analysis, ensemble) {
-    const metricOrder = ['structural', 'perplexity', 'entropy', 'semantic_analysis', 'linguistic', 'detect_gpt'];
-    
-    let metricsHTML = `
-        <div style="margin-bottom: 2rem; padding: 1.5rem; background: rgba(51, 65, 85, 0.3); border-radius: 10px;">
-            <h3 style="color: var(--primary); margin-bottom: 1rem;">📊 Ensemble Analysis</h3>
-            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem;">
-                <div>
-                    <div style="font-size: 0.85rem; color: var(--text-secondary);">Method</div>
-                    <div style="font-size: 1.1rem; font-weight: 700; color: #fff;">Confidence Calibrated</div>
-                </div>
-                <div>
-                    <div style="font-size: 0.85rem; color: var(--text-secondary);">Consensus</div>
-                    <div style="font-size: 1.1rem; font-weight: 700; color: #fff;">${(ensemble.consensus_level * 100).toFixed(1)}%</div>
-                </div>
-                <div>
-                    <div style="font-size: 0.85rem; color: var(--text-secondary);">Uncertainty</div>
-                    <div style="font-size: 1.1rem; font-weight: 700; color: #fff;">${(ensemble.uncertainty_score * 100).toFixed(1)}%</div>
-                </div>
+function displayMetricsCarousel(metrics, analysis, ensemble) {
+    const metricOrder = ['structural', 'perplexity', 'entropy', 'semantic_analysis', 'linguistic', 'multi_perturbation_stability'];
+    const availableMetrics = metricOrder.filter(key => metrics[key]);
+    totalMetrics = availableMetrics.length;
+    if (totalMetrics === 0) {
+        document.getElementById('metrics-report').innerHTML = `
+            <div class="empty-state">
+                <p class="empty-description">No metric details available</p>
             </div>
-        </div>
+        `;
+        return;
+    }
+    let carouselHTML = `
+        <div class="metrics-carousel-container">
+            <div class="metrics-carousel-content">
     `;
-
-    metricOrder.forEach(metricKey => {
+    availableMetrics.forEach((metricKey, index) => {
         const metric = metrics[metricKey];
         if (!metric) return;
-        
         const aiProb = (metric.ai_probability * 100).toFixed(1);
         const humanProb = (metric.human_probability * 100).toFixed(1);
         const confidence = (metric.confidence * 100).toFixed(1);
-        const weight = ensemble.metric_weights && ensemble.metric_weights[metricKey] ? 
-            (ensemble.metric_weights[metricKey] * 100).toFixed(1) : '0.0';
-        
+        const weight = ensemble.metric_contributions && ensemble.metric_contributions[metricKey] ?
+              (ensemble.metric_contributions[metricKey].weight * 100).toFixed(1) : '0.0';
         const color = metric.ai_probability >= 0.6 ? 'var(--danger)' : 
                      metric.ai_probability >= 0.4 ? 'var(--warning)' : 'var(--success)';
         const verdictText = metric.ai_probability >= 0.6 ? 'AI' :
                            metric.ai_probability >= 0.4 ? 'UNCERTAIN' : 'HUMAN';
         const verdictClass = verdictText === 'AI' ? 'verdict-ai' :
                             verdictText === 'UNCERTAIN' ? 'verdict-uncertain' : 'verdict-human';
-        
-        metricsHTML += `
-            <div class="metric-result-card" style="margin-bottom: 1.5rem;">
-                <div class="metric-header">
-                    <div class="metric-name">${formatMetricName(metricKey)}</div>
-                    <div class="metric-score" style="color: ${color};">${aiProb}%</div>
-                </div>
-                <div style="display: flex; gap: 1rem; margin: 1rem 0;">
-                    <div style="flex: 1;">
-                        <div style="font-size: 0.75rem; color: var(--text-muted); margin-bottom: 0.25rem;">AI</div>
-                        <div style="background: rgba(51, 65, 85, 0.5); height: 8px; border-radius: 4px; overflow: hidden;">
-                            <div style="background: var(--danger); height: 100%; width: ${aiProb}%; transition: width 0.5s;"></div>
-                        </div>
-                        <div style="font-size: 0.85rem; font-weight: 600; margin-top: 0.25rem;">${aiProb}%</div>
+        carouselHTML += `
+            <div class="metric-slide ${index === 0 ? 'active' : ''}" data-metric-index="${index}">
+                <div class="metric-result-card">
+                    <div class="metric-header">
+                        <div class="metric-name">${formatMetricName(metricKey)}</div>
                     </div>
-                    <div style="flex: 1;">
-                        <div style="font-size: 0.75rem; color: var(--text-muted); margin-bottom: 0.25rem;">Human</div>
-                        <div style="background: rgba(51, 65, 85, 0.5); height: 8px; border-radius: 4px; overflow: hidden;">
-                            <div style="background: var(--success); height: 100%; width: ${humanProb}%; transition: width 0.5s;"></div>
+                    <div class="metric-description">
+                        ${getMetricDescription(metricKey)}
+                    </div>
+                    <div style="display: flex; gap: 1rem; margin: 1rem 0;">
+                        <div style="flex: 1;">
+                            <div style="font-size: 0.75rem; color: var(--text-muted); margin-bottom: 0.25rem;">AI</div>
+                            <div style="background: rgba(51, 65, 85, 0.5); height: 8px; border-radius: 4px; overflow: hidden;">
+                                <div style="background: var(--danger); height: 100%; width: ${aiProb}%; transition: width 0.5s;"></div>
+                            </div>
+                            <div style="font-size: 0.85rem; font-weight: 600; margin-top: 0.25rem;">${aiProb}%</div>
+                        </div>
+                        <div style="flex: 1;">
+                            <div style="font-size: 0.75rem; color: var(--text-muted); margin-bottom: 0.25rem;">Human</div>
+                            <div style="background: rgba(51, 65, 85, 0.5); height: 8px; border-radius: 4px; overflow: hidden;">
+                                <div style="background: var(--success); height: 100%; width: ${humanProb}%; transition: width 0.5s;"></div>
+                            </div>
+                            <div style="font-size: 0.85rem; font-weight: 600; margin-top: 0.25rem;">${humanProb}%</div>
                         </div>
-                        <div style="font-size: 0.85rem; font-weight: 600; margin-top: 0.25rem;">${humanProb}%</div>
                     </div>
+                    <div style="display: flex; justify-content: space-between; align-items: center; margin: 0.75rem 0;">
+                        <span class="metric-verdict ${verdictClass}">${verdictText}</span>
+                        <span style="font-size: 0.85rem; color: var(--text-secondary);">Confidence: ${confidence}% | Weight: ${weight}%</span>
+                    </div>
+                    
+                    ${metric.details ? renderMetricDetails(metricKey, metric.details) : ''}
                 </div>
-                <div style="display: flex; justify-content: space-between; align-items: center; margin: 0.75rem 0;">
-                    <span class="metric-verdict ${verdictClass}">${verdictText}</span>
-                    <span style="font-size: 0.85rem; color: var(--text-secondary);">Confidence: ${confidence}% | Weight: ${weight}%</span>
-                </div>
-                <div class="metric-description">
-                    ${getMetricDescription(metricKey)}
-                </div>
-                ${metric.details ? renderMetricDetails(metricKey, metric.details) : ''}
             </div>
         `;
     });
-    
-    document.getElementById('metrics-report').innerHTML = metricsHTML;
+    carouselHTML += `
+            </div>
+            <div class="metrics-carousel-nav">
+                <button class="carousel-btn prev-btn" onclick="navigateMetrics(-1)" ${currentMetricIndex === 0 ? 'disabled' : ''}>← Previous</button>
+                <div class="carousel-position">${currentMetricIndex + 1} / ${totalMetrics}</div>
+                <button class="carousel-btn next-btn" onclick="navigateMetrics(1)" ${currentMetricIndex === totalMetrics - 1 ? 'disabled' : ''}>Next →</button>
+            </div>
+        </div>
+    `;
+    document.getElementById('metrics-report').innerHTML = carouselHTML;
+    updateCarouselButtons();
+}
+function navigateMetrics(direction) {
+    const newMetricIndex = currentMetricIndex + direction;
+    if (newMetricIndex >= 0 && newMetricIndex < totalMetrics) {
+        currentMetricIndex = newMetricIndex;
+        updateMetricCarousel();
+    }
+}
+function updateMetricCarousel() {
+    const slides = document.querySelectorAll('.metric-slide');
+    slides.forEach((slide, index) => {
+        if (index === currentMetricIndex) {
+            slide.classList.add('active');
+        } else {
+            slide.classList.remove('active');
+        }
+    });
+    updateCarouselButtons();
+    // Update position indicator
+    const positionElement = document.querySelector('.carousel-position');
+    if (positionElement) {
+        positionElement.textContent = `${currentMetricIndex + 1} / ${totalMetrics}`;
+    }
+}
+function updateCarouselButtons() {
+    const prevBtn = document.querySelector('.prev-btn');
+    const nextBtn = document.querySelector('.next-btn');
+    if (prevBtn) {
+        prevBtn.disabled = currentMetricIndex === 0;
+    }
+    if (nextBtn) {
+        nextBtn.disabled = currentMetricIndex === totalMetrics - 1;
+    }
 }
-
 function renderMetricDetails(metricName, details) {
     if (!details || Object.keys(details).length === 0) return '';
-    
     // Key metrics to show for each type
     const importantKeys = {
         'structural': ['burstiness_score', 'length_uniformity', 'avg_sentence_length', 'std_sentence_length'],
@@ -1979,14 +2007,12 @@ function renderMetricDetails(metricName, details) {
         'entropy': ['token_diversity', 'sequence_unpredictability', 'char_entropy'],
         'semantic_analysis': ['coherence_score', 'consistency_score', 'repetition_score'],
         'linguistic': ['pos_diversity', 'syntactic_complexity', 'grammatical_consistency'],
-        'detect_gpt': ['stability_score', 'curvature_score', 'likelihood_ratio']
+        'multi_perturbation_stability': ['stability_score', 'curvature_score', 'likelihood_ratio']
     };
-    
     const keysToShow = importantKeys[metricName] || Object.keys(details).slice(0, 6);
     let detailsHTML = '<div style="margin-top: 1rem; padding-top: 1rem; border-top: 1px solid var(--border);">';
     detailsHTML += '<div style="font-size: 0.9rem; font-weight: 600; color: var(--text-secondary); margin-bottom: 0.75rem;">📈 Detailed Metrics:</div>';
     detailsHTML += '<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 0.75rem; font-size: 0.85rem;">';
-    
     keysToShow.forEach(key => {
         if (details[key] !== undefined && details[key] !== null) {
             const value = typeof details[key] === 'number' ? 
@@ -2001,11 +2027,9 @@ function renderMetricDetails(metricName, details) {
             `;
         }
     });
-    
     detailsHTML += '</div></div>';
     return detailsHTML;
 }
-
 function getMetricDescription(metricName) {
     const descriptions = {
         structural: 'Analyzes sentence structure, length patterns, and statistical features.',
@@ -2013,11 +2037,10 @@ function getMetricDescription(metricName) {
         entropy: 'Evaluates token diversity and sequence unpredictability.',
         semantic_analysis: 'Examines semantic coherence, topic consistency, and logical flow.',
         linguistic: 'Assesses grammatical patterns, syntactic complexity, and style markers.',
-        detect_gpt: 'Tests text stability under perturbation using curvature analysis.'
+        multi_perturbation_stability: 'Tests text stability under perturbation using curvature analysis.'
     };
     return descriptions[metricName] || 'Metric analysis complete.';
 }
-
 function formatMetricName(name) {
     const names = {
         structural: 'Structural Analysis',
@@ -2025,25 +2048,21 @@ function formatMetricName(name) {
         entropy: 'Entropy',
         semantic_analysis: 'Semantic Analysis',
         linguistic: 'Linguistic Analysis',
-        detect_gpt: 'DetectGPT'
+        multi_perturbation_stability: 'Multi-Perturbation Stability'
     };
     return names[name] || name.split('_').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
 }
-
 function formatDomainName(domain) {
     return domain.split('_').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
 }
-
 async function downloadReport(format) {
     if (!currentAnalysisData) {
         alert('No analysis data available');
         return;
     }
-    
     try {
         const analysisId = currentAnalysisData.analysis_id;
         const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        
         // For JSON, download directly from current data
         if (format === 'json') {
             const data = {
@@ -2058,7 +2077,6 @@ async function downloadReport(format) {
             await downloadBlob(blob, filename);
             return;
         }
-        
         // Get the original text for report generation
         const activeTab = document.querySelector('.input-tab.active').dataset.tab;
         let textToSend = '';
@@ -2068,23 +2086,19 @@ async function downloadReport(format) {
             textToSend = currentAnalysisData.detection_result?.processed_text?.text || 
                         'Uploaded file content - see analysis for details';
         }
-        
         // For PDF, request from server
         const formData = new FormData();
         formData.append('analysis_id', analysisId);
         formData.append('text', textToSend);
         formData.append('formats', format);
         formData.append('include_highlights', document.getElementById('enable-highlighting').checked.toString());
-        
         const response = await fetch(`${API_BASE}/api/report/generate`, {
             method: 'POST',
             body: formData
         });
-        
         if (!response.ok) {
             throw new Error('Report generation failed');
         }
-        
         const result = await response.json();
         if (result.reports && result.reports[format]) {
             const filename = result.reports[format];
@@ -2103,7 +2117,6 @@ async function downloadReport(format) {
         alert('Failed to download report. Please try again.');
     }
 }
-
 async function downloadBlob(blob, filename) {
     try {
         const url = URL.createObjectURL(blob);
@@ -2113,7 +2126,6 @@ async function downloadBlob(blob, filename) {
         a.style.display = 'none';
         document.body.appendChild(a);
         a.click();
-        
         setTimeout(() => {
             document.body.removeChild(a);
             URL.revokeObjectURL(url);
@@ -2124,7 +2136,6 @@ async function downloadBlob(blob, filename) {
         alert('Download failed. Please try again.');
     }
 }
-
 function showDownloadSuccess(filename) {
     const notification = document.createElement('div');
     notification.style.cssText = `
@@ -2147,7 +2158,6 @@ function showDownloadSuccess(filename) {
         </div>
     `;
     document.body.appendChild(notification);
-    
     if (!document.querySelector('#download-animation')) {
         const style = document.createElement('style');
         style.id = 'download-animation';
@@ -2159,14 +2169,12 @@ function showDownloadSuccess(filename) {
         `;
         document.head.appendChild(style);
     }
-    
     setTimeout(() => {
         if (notification.parentNode) {
             notification.parentNode.removeChild(notification);
         }
     }, 3000);
 }
-
 // Smooth scrolling for anchor links
 document.querySelectorAll('a[href^="#"]').forEach(anchor => {
     anchor.addEventListener('click', function (e) {
@@ -2180,7 +2188,6 @@ document.querySelectorAll('a[href^="#"]').forEach(anchor => {
         }
     });
 });
-
 // Initialize - show landing page by default
 showLanding();
 </script>