faultmesh 1.0.0 → 1.1.0

package/dist/dashboard/app.js

@@ -20,8 +20,11 @@ document.addEventListener('DOMContentLoaded', () => {
   const btnCloseResponse = document.getElementById('btnCloseResponse');
 
   const btnPresetSlowMobile = document.getElementById('btnPresetSlowMobile');
+  const btnPresetJitter = document.getElementById('btnPresetJitter');
   const btnPresetDisconnect = document.getElementById('btnPresetDisconnect');
+  const btnPresetRateLimit = document.getElementById('btnPresetRateLimit');
   const btnPresetOutage = document.getElementById('btnPresetOutage');
+  const btnPresetGatewayTimeout = document.getElementById('btnPresetGatewayTimeout');
   const btnPresetCorrupt = document.getElementById('btnPresetCorrupt');
   const btnClearAllRules = document.getElementById('btnClearAllRules');
 
@@ -46,12 +49,77 @@ document.addEventListener('DOMContentLoaded', () => {
   const scoreSubtitle = document.getElementById('scoreSubtitle');
   const diagnosticsResults = document.getElementById('diagnosticsResults');
 
+  const targetUrlInput = document.getElementById('targetUrlInput');
+  const btnSetTargetUrl = document.getElementById('btnSetTargetUrl');
+  const exportGroup = document.getElementById('exportGroup');
+  const btnExportMd = document.getElementById('btnExportMd');
+  const btnExportJson = document.getElementById('btnExportJson');
+  const rulePathPattern = document.getElementById('rulePathPattern');
+
+  // Auto-Healer Modal Elements
+  const btnOpenHealer = document.getElementById('btnOpenHealer');
+  const healerModal = document.getElementById('healerModal');
+  const btnCloseHealer = document.getElementById('btnCloseHealer');
+  const healerProjectDir = document.getElementById('healerProjectDir');
+  const btnHealerScan = document.getElementById('btnHealerScan');
+  const healerScanStatus = document.getElementById('healerScanStatus');
+  const healerDiffContainer = document.getElementById('healerDiffContainer');
+  const healerActionsBar = document.getElementById('healerActionsBar');
+  const healerBackupCheck = document.getElementById('healerBackupCheck');
+  const btnHealerApply = document.getElementById('btnHealerApply');
+  const btnHealerRollback = document.getElementById('btnHealerRollback');
+  const btnToggleAiSettings = document.getElementById('btnToggleAiSettings');
+  const healerAiSettingsPanel = document.getElementById('healerAiSettingsPanel');
+  const healerEngineBadge = document.getElementById('healerEngineBadge');
+  const healerEngineMode = document.getElementById('healerEngineMode');
+  const healerAiProvider = document.getElementById('healerAiProvider');
+  const healerAiKey = document.getElementById('healerAiKey');
+  const healerAiEndpoint = document.getElementById('healerAiEndpoint');
+  const aiKeyGroup = document.getElementById('aiKeyGroup');
+  const aiEndpointGroup = document.getElementById('aiEndpointGroup');
+
   const activityFeed = document.getElementById('activityFeed');
   const btnClearLog = document.getElementById('btnClearLog');
 
+  // Red Team Tactical Console Elements
+  const tabRedTeam = document.getElementById('tabRedTeam');
+  const standardAuditPanel = document.getElementById('standardAuditPanel');
+  const redTeamPanel = document.getElementById('redTeamPanel');
+  const redTeamPersonasGrid = document.getElementById('redTeamPersonasGrid');
+  const redTeamIntensitySelect = document.getElementById('redTeamIntensitySelect');
+  const btnLaunchRedTeam = document.getElementById('btnLaunchRedTeam');
+  const btnAbortRedTeam = document.getElementById('btnAbortRedTeam');
+  const redTeamHud = document.getElementById('redTeamHud');
+  const redTeamCurrentWaveText = document.getElementById('redTeamCurrentWaveText');
+  const redTeamProgressPercent = document.getElementById('redTeamProgressPercent');
+  const redTeamProgressBar = document.getElementById('redTeamProgressBar');
+  const redTeamProbesCount = document.getElementById('redTeamProbesCount');
+  const redTeamCritCount = document.getElementById('redTeamCritCount');
+  const redTeamHighCount = document.getElementById('redTeamHighCount');
+  const redTeamMedCount = document.getElementById('redTeamMedCount');
+  const redTeamActivePersonaPill = document.getElementById('redTeamActivePersonaPill');
+  const redTeamConsoleLogs = document.getElementById('redTeamConsoleLogs');
+  const redTeamDossier = document.getElementById('redTeamDossier');
+  const dossierScoreVal = document.getElementById('dossierScoreVal');
+  const dossierGradeVal = document.getElementById('dossierGradeVal');
+  const dossierTitle = document.getElementById('dossierTitle');
+  const dossierSummaryText = document.getElementById('dossierSummaryText');
+  const dossierFindingsCount = document.getElementById('dossierFindingsCount');
+  const dossierFindingsList = document.getElementById('dossierFindingsList');
+  const btnAutoHealBreaches = document.getElementById('btnAutoHealBreaches');
+  const btnExportDossierMd = document.getElementById('btnExportDossierMd');
+  const btnExportDossierJson = document.getElementById('btnExportDossierJson');
+
+  let lastRedTeamReport = null;
+  let redTeamPollingInterval = null;
+
+  let lastHealerScanResult = null;
+  let lastBackupDir = null;
+
   let activeRules = [];
   let isRunningDiagnostics = false;
   let currentDiagMode = 'resilience';
+  let lastScorecardData = null;
 
   // 1. Theme Management (Clean Light / Neutral Dark)
   function initTheme() {
@@ -67,6 +135,73 @@ document.addEventListener('DOMContentLoaded', () => {
   });
   initTheme();
 
+  // Target URL Management
+  async function loadTargetUrl() {
+    try {
+      const res = await fetch('/_faultmesh/config/target');
+      const data = await res.json();
+      if (data.targetUrl && targetUrlInput) {
+        targetUrlInput.value = data.targetUrl;
+      }
+    } catch (err) {
+      console.warn('Failed to load target URL:', err);
+    }
+  }
+
+  async function syncTargetUrl() {
+    if (!targetUrlInput) return;
+    const targetUrl = targetUrlInput.value.trim();
+    if (!targetUrl) return;
+    try {
+      await fetch('/_faultmesh/config/target', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ targetUrl }),
+      });
+    } catch (err) {
+      console.warn('Failed to auto-sync target URL:', err);
+    }
+  }
+
+  if (btnSetTargetUrl && targetUrlInput) {
+    targetUrlInput.addEventListener('keydown', (e) => {
+      if (e.key === 'Enter') {
+        e.preventDefault();
+        btnSetTargetUrl.click();
+      }
+    });
+
+    btnSetTargetUrl.addEventListener('click', async () => {
+      const targetUrl = targetUrlInput.value.trim();
+      if (!targetUrl) return;
+      btnSetTargetUrl.disabled = true;
+      btnSetTargetUrl.textContent = 'Updating...';
+      try {
+        const res = await fetch('/_faultmesh/config/target', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ targetUrl }),
+        });
+        const data = await res.json();
+        if (res.ok && data.success) {
+          btnSetTargetUrl.textContent = 'Updated!';
+          setTimeout(() => {
+            btnSetTargetUrl.textContent = 'Set Target';
+            btnSetTargetUrl.disabled = false;
+          }, 1500);
+        } else {
+          alert('Error: ' + (data.details || data.error || 'Failed to update target URL'));
+          btnSetTargetUrl.textContent = 'Set Target';
+          btnSetTargetUrl.disabled = false;
+        }
+      } catch (err) {
+        alert('Network error: ' + err.message);
+        btnSetTargetUrl.textContent = 'Set Target';
+        btnSetTargetUrl.disabled = false;
+      }
+    });
+  }
+
   // 2. Response Inspector Panel
   if (btnCloseResponse) {
     btnCloseResponse.addEventListener('click', () => {
@@ -75,7 +210,7 @@ document.addEventListener('DOMContentLoaded', () => {
         respStatusBadge.className = 'status-pill';
       }
       if (respDuration) respDuration.textContent = '-- ms';
-      if (respAppliedRule) respAppliedRule.textContent = 'Rule: None';
+      if (respAppliedRule) respAppliedRule.textContent = 'None';
       if (testFeedback) {
         testFeedback.textContent = 'Click "Send Test Request" or enable any scenario on the left to inspect responses.';
         testFeedback.style.color = 'var(--text-muted)';
@@ -93,8 +228,16 @@ document.addEventListener('DOMContentLoaded', () => {
     respStatusBadge.className = 'status-pill ' + (isError || status >= 500 ? 'code-5xx' : (status >= 400 ? 'code-4xx' : 'code-2xx'));
     respDuration.textContent = `${durationMs}ms`;
 
-    const ruleNames = appliedRules && appliedRules.length > 0 ? appliedRules.join(', ') : 'None (Normal Traffic)';
-    respAppliedRule.textContent = `Applied: ${ruleNames}`;
+    if (!appliedRules || appliedRules.length === 0) {
+      respAppliedRule.textContent = 'None';
+      respAppliedRule.removeAttribute('title');
+    } else if (appliedRules.length === 1) {
+      respAppliedRule.textContent = appliedRules[0];
+      respAppliedRule.title = `Injected: ${appliedRules[0]}`;
+    } else {
+      respAppliedRule.textContent = `${appliedRules[0]} (+${appliedRules.length - 1} more)`;
+      respAppliedRule.title = `Injected Faults:\n${appliedRules.map((r, i) => `${i + 1}. ${r}`).join('\n')}`;
+    }
 
     // Format body as formatted JSON if possible
     try {
@@ -208,10 +351,15 @@ document.addEventListener('DOMContentLoaded', () => {
       if (activeRules.length === 0) {
         activeRulesIndicator.textContent = 'Traffic: Normal';
         activeRulesIndicator.className = 'active-rules-pill';
+        activeRulesIndicator.removeAttribute('title');
+      } else if (activeRules.length === 1) {
+        activeRulesIndicator.textContent = `Simulating: ${activeRules[0].name}`;
+        activeRulesIndicator.className = 'active-rules-pill active';
+        activeRulesIndicator.title = `Simulating: ${activeRules[0].name}`;
       } else {
-        const names = activeRules.map(r => r.name).join(', ');
-        activeRulesIndicator.textContent = `Simulating: ${names}`;
+        activeRulesIndicator.textContent = `Simulating: ${activeRules[0].name} (+${activeRules.length - 1} more)`;
         activeRulesIndicator.className = 'active-rules-pill active';
+        activeRulesIndicator.title = `Active Simulation Rules:\n${activeRules.map((r, i) => `${i + 1}. ${r.name}`).join('\n')}`;
       }
     }
 
@@ -237,14 +385,19 @@ document.addEventListener('DOMContentLoaded', () => {
   function formatRuleDetail(r) {
     const c = r.config || {};
     const dir = r.direction === 'downstream' ? 'Responses' : 'Requests';
+    let detail = '';
     switch (r.type) {
-      case 'latency': return `${dir} delayed +${c.latencyMs}ms (${c.jitterMs ? `±${c.jitterMs}ms` : 'fixed'})`;
-      case 'bandwidth': return `${dir} capped at ${c.rateKbps} kbps`;
-      case 'cut': return `Socket dropped after ${c.cutAfterBytes} bytes`;
-      case 'corrupt': return `Corrupted response (${c.corruptType || 'truncate'})`;
-      case 'status': return `Returning HTTP ${c.statusCode}`;
-      default: return JSON.stringify(c);
+      case 'latency': detail = `${dir} delayed +${c.latencyMs}ms (${c.jitterMs ? `±${c.jitterMs}ms` : 'fixed'})`; break;
+      case 'bandwidth': detail = `${dir} capped at ${c.rateKbps} kbps`; break;
+      case 'cut': detail = `Socket dropped after ${c.cutAfterBytes} bytes`; break;
+      case 'corrupt': detail = `Corrupted response (${c.corruptType || 'truncate'})`; break;
+      case 'status': detail = `Returning HTTP ${c.statusCode}`; break;
+      default: detail = JSON.stringify(c);
+    }
+    if (r.pathPattern) {
+      detail += ` | Path: ${r.pathPattern}`;
     }
+    return detail;
   }
 
   window.deleteRule = async function(id) {
@@ -306,11 +459,16 @@ document.addEventListener('DOMContentLoaded', () => {
         break;
     }
 
+    const pathPattern = rulePathPattern ? (rulePathPattern.value.trim() || undefined) : undefined;
+    if (pathPattern) {
+      name += ` (${pathPattern})`;
+    }
+
     try {
       await fetch('/_faultmesh/rules', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ id, name, type, direction, enabled: true, config }),
+        body: JSON.stringify({ id, name, type, direction, enabled: true, config, pathPattern }),
       });
       await refreshStatus();
       executeTestRequest();
@@ -365,7 +523,7 @@ document.addEventListener('DOMContentLoaded', () => {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        id: `preset_bw_${Date.now()}`,
+        id: 'preset_slow_mobile_bw',
         name: 'Slow Mobile Internet (16 kbps limit)',
         type: 'bandwidth',
         direction: 'downstream',
@@ -377,7 +535,7 @@ document.addEventListener('DOMContentLoaded', () => {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        id: `preset_lat_${Date.now()}`,
+        id: 'preset_slow_mobile_lat',
         name: 'Mobile Delay (350ms)',
         type: 'latency',
         direction: 'downstream',
@@ -389,12 +547,31 @@ document.addEventListener('DOMContentLoaded', () => {
     executeTestRequest();
   });
 
+  if (btnPresetJitter) {
+    btnPresetJitter.addEventListener('click', async () => {
+      await fetch('/_faultmesh/rules', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          id: 'preset_jitter_lat',
+          name: 'Packet Jitter Spike (400ms ±250ms)',
+          type: 'latency',
+          direction: 'downstream',
+          enabled: true,
+          config: { latencyMs: 400, jitterMs: 250 },
+        }),
+      });
+      await refreshStatus();
+      executeTestRequest();
+    });
+  }
+
   btnPresetDisconnect.addEventListener('click', async () => {
     await fetch('/_faultmesh/rules', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        id: `preset_cut_${Date.now()}`,
+        id: 'preset_disconnect_cut',
         name: 'Connection Drop (after 30 bytes)',
         type: 'cut',
         direction: 'downstream',
@@ -406,12 +583,31 @@ document.addEventListener('DOMContentLoaded', () => {
     executeTestRequest();
   });
 
+  if (btnPresetRateLimit) {
+    btnPresetRateLimit.addEventListener('click', async () => {
+      await fetch('/_faultmesh/rules', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          id: 'preset_ratelimit_status',
+          name: 'Rate Limit Surge (HTTP 429)',
+          type: 'status',
+          direction: 'downstream',
+          enabled: true,
+          config: { statusCode: 429, statusMessage: 'Too Many Requests (Rate Limited - Retry After 15s)' },
+        }),
+      });
+      await refreshStatus();
+      executeTestRequest();
+    });
+  }
+
   btnPresetOutage.addEventListener('click', async () => {
     await fetch('/_faultmesh/rules', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        id: `preset_503_${Date.now()}`,
+        id: 'preset_outage_status',
         name: 'Server Outage (HTTP 503)',
         type: 'status',
         direction: 'downstream',
@@ -423,12 +619,43 @@ document.addEventListener('DOMContentLoaded', () => {
     executeTestRequest();
   });
 
+  if (btnPresetGatewayTimeout) {
+    btnPresetGatewayTimeout.addEventListener('click', async () => {
+      await fetch('/_faultmesh/rules', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          id: 'preset_gateway_lat',
+          name: 'Upstream Delay (2000ms)',
+          type: 'latency',
+          direction: 'downstream',
+          enabled: true,
+          config: { latencyMs: 2000, jitterMs: 0 },
+        }),
+      });
+      await fetch('/_faultmesh/rules', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          id: 'preset_gateway_status',
+          name: 'Gateway Timeout (HTTP 504)',
+          type: 'status',
+          direction: 'downstream',
+          enabled: true,
+          config: { statusCode: 504, statusMessage: 'Gateway Timeout (Upstream Deadlock)' },
+        }),
+      });
+      await refreshStatus();
+      executeTestRequest();
+    });
+  }
+
   btnPresetCorrupt.addEventListener('click', async () => {
     await fetch('/_faultmesh/rules', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        id: `preset_corrupt_${Date.now()}`,
+        id: 'preset_corrupt_data',
         name: 'Corrupted Response (Truncated JSON)',
         type: 'corrupt',
         direction: 'downstream',
@@ -440,7 +667,7 @@ document.addEventListener('DOMContentLoaded', () => {
     executeTestRequest();
   });
 
-  // 8. Diagnostics & Security Audit Suite Definitions
+  // 8. Diagnostics & Security Audit Suite Definitions (32 Checks Total)
   const RESILIENCE_CHECKS = [
     {
       num: '01',
@@ -476,6 +703,41 @@ document.addEventListener('DOMContentLoaded', () => {
       category: 'Availability',
       description: 'Tests if the application properly receives, traps, and gracefully responds to temporary upstream server downtime.',
       probe: 'Forces proxy to return HTTP 503 Service Unavailable.'
+    },
+    {
+      num: '06',
+      name: 'Packet Jitter & Latency Variance',
+      category: 'Jitter',
+      description: 'Injects fluctuating network latency variance (100ms-350ms) to evaluate client jitter buffering and prevent timeout crashes.',
+      probe: 'Applies latency with dynamic 70ms jitter variance.'
+    },
+    {
+      num: '07',
+      name: 'Half-Open Circuit Breaker Recovery',
+      category: 'Resilience',
+      description: 'Tests if client circuit breaker automatically recovers after a transient outage lifts without staying permanently latched in failure state.',
+      probe: 'Injects a transient 503 outage followed by immediate recovery probe.'
+    },
+    {
+      num: '08',
+      name: 'Downstream Socket Starvation & Slow Read',
+      category: 'Concurrency',
+      description: 'Evaluates if slow downstream readers starve the server worker pool or block concurrent health probe requests.',
+      probe: 'Holds slow stream at 8 kbps while concurrently probing /api/health.'
+    },
+    {
+      num: '09',
+      name: 'Zombie Connection Leak Probe',
+      category: 'Resources',
+      description: 'Verifies backend closes downstream descriptors and frees resources cleanly when client connections abort prematurely.',
+      probe: 'Dispatches aborted client socket and measures server recovery latency.'
+    },
+    {
+      num: '10',
+      name: 'Payload Truncation & Partial Transfer',
+      category: 'Integrity',
+      description: 'Tests whether clients safely identify incomplete HTTP body streams rather than treating truncated responses as valid.',
+      probe: 'Truncates TCP stream after 30 bytes to test stream termination validation.'
     }
   ];
 
@@ -535,6 +797,62 @@ document.addEventListener('DOMContentLoaded', () => {
       severity: 'critical',
       description: 'Probes input fields using harmless syntax markers (\' OR \'1\'=\'1) and non-executable canary tags (<faultmesh-canary-test>) to verify parameterization with 0 database mutation.',
       probe: 'Zero-damage canary probe verifying parameter escaping and schema validation.'
+    },
+    {
+      num: '08',
+      name: 'Host Header Poisoning & Reflection',
+      category: 'Headers',
+      severity: 'high',
+      description: 'Tests if server validates incoming Host and X-Forwarded-Host headers or echoes untrusted attacker domains into redirect URLs.',
+      probe: 'Inspects location redirects and response headers under spoofed Host headers.'
+    },
+    {
+      num: '09',
+      name: 'Client IP Spoofing & Rate-Limit Bypass',
+      category: 'Identity',
+      severity: 'medium',
+      description: 'Checks whether client IP determination blindly trusts unverified X-Forwarded-For headers to bypass rate limiters or security filters.',
+      probe: 'Dispatches forged upstream IP headers to evaluate trusted proxy configuration.'
+    },
+    {
+      num: '10',
+      name: 'HTTP Parameter Pollution (HPP)',
+      category: 'Parameters',
+      severity: 'medium',
+      description: 'Tests if server safely handles duplicate query parameters (?id=1&id=2) without array type confusion or unhandled 500 crashes.',
+      probe: 'Probes duplicate query parameters across API endpoints.'
+    },
+    {
+      num: '11',
+      name: 'Sensitive Cache-Control Verification',
+      category: 'Caching',
+      severity: 'high',
+      description: 'Verifies that endpoints returning authenticated or private user data enforce Cache-Control: no-store to prevent shared proxy and browser cache leaks.',
+      probe: 'Inspects Cache-Control and Pragma response directives on user routes.'
+    },
+    {
+      num: '12',
+      name: 'Unsigned & Broken Authorization Headers',
+      category: 'Auth Safety',
+      severity: 'high',
+      description: 'Tests if server safely rejects malformed or truncated Authorization headers (HTTP 401/400) without unhandled 500 crashes.',
+      probe: 'Submits malformed Bearer tokens to verify graceful rejection.'
+    },
+    {
+      num: '13',
+      name: 'Constant-Time Authentication & Timing Attacks',
+      category: 'Cryptography',
+      severity: 'medium',
+      description: 'Tests if credential and token verification exhibits significant latency variations (side-channel timing leaks).',
+      probe: 'Measures delta latency across varying token lengths to verify constant-time evaluation.'
+    },
+    {
+      num: '14',
+      name: 'Server Metadata & Secret Configuration Exposure',
+      category: 'Config Exposure',
+      severity: 'critical',
+      description: 'Probes for unintentional exposure of sensitive server files such as .env, .git, or unauthenticated internal configuration routes.',
+      probe: 'Probes /.env and dotfiles to confirm web server blocks configuration exposure.'
     }
   ];
 
@@ -570,6 +888,38 @@ document.addEventListener('DOMContentLoaded', () => {
       severity: 'critical',
       description: 'Verifies that concurrent duplicate POST requests sharing an Idempotency-Key are deduplicated to prevent double-billing and duplicate records.',
       probe: 'Dispatches concurrent POST requests with duplicate Idempotency-Key headers.'
+    },
+    {
+      num: '05',
+      name: 'ReDoS (Regex Denial of Service) Lockup Probe',
+      category: 'Regex Safety',
+      severity: 'critical',
+      description: 'Probes input fields with catastrophic backtracking pattern inputs to verify regular expressions do not lock up the server CPU event loop.',
+      probe: 'Sends nested quantifier string to test regex evaluation bounds.'
+    },
+    {
+      num: '06',
+      name: 'Concurrent Race Condition & Double Processing',
+      category: 'Concurrency',
+      severity: 'critical',
+      description: 'Dispatches concurrent parallel requests against transactional endpoints to evaluate atomic locking and double-spend protection.',
+      probe: 'Executes parallel burst with identical transaction keys to test lock safety.'
+    },
+    {
+      num: '07',
+      name: 'Chunked Request Drip & Slow POST Defense',
+      category: 'Body Timeouts',
+      severity: 'high',
+      description: 'Evaluates server defense against Slow POST drip attacks by checking requestTimeout limits on incomplete body deliveries.',
+      probe: 'Probes request body reception bounds with delayed chunk transfer.'
+    },
+    {
+      num: '08',
+      name: 'Resource Avalanche & Sudden Concurrency Flood',
+      category: 'Queue Saturation',
+      severity: 'high',
+      description: 'Sends an avalanche burst of parallel requests within a 50ms window to verify connection queuing and sub-second mean response latency.',
+      probe: 'Dispatches burst concurrency flood to test queue shedding and keep-alive stability.'
     }
   ];
 
@@ -609,46 +959,62 @@ document.addEventListener('DOMContentLoaded', () => {
     if (tabResilience) tabResilience.classList.remove('active');
     if (tabSecurity) tabSecurity.classList.remove('active');
     if (tabStorm) tabStorm.classList.remove('active');
+    if (tabRedTeam) tabRedTeam.classList.remove('active');
+    if (exportGroup) exportGroup.style.display = 'none';
+
+    if (mode === 'redteam') {
+      if (tabRedTeam) tabRedTeam.classList.add('active');
+      if (standardAuditPanel) standardAuditPanel.style.display = 'none';
+      if (redTeamPanel) redTeamPanel.style.display = 'flex';
+      if (diagHeaderTitle) diagHeaderTitle.textContent = 'Autonomous Red Chaos Team Engine';
+      if (diagHeaderSubtitle) diagHeaderSubtitle.textContent = 'Deploy autonomous agent personas armed with multi-wave fuzzing, compound network fault injections, and system survivability scoring.';
+      loadRedTeamPersonas();
+      refreshRedTeamStatus();
+      return;
+    }
+
+    if (standardAuditPanel) standardAuditPanel.style.display = 'block';
+    if (redTeamPanel) redTeamPanel.style.display = 'none';
 
     if (mode === 'storm') {
       if (tabStorm) tabStorm.classList.add('active');
-      if (diagHeaderTitle) diagHeaderTitle.textContent = 'Traffic Storms & DoS Defense Suite';
-      if (diagHeaderSubtitle) diagHeaderSubtitle.textContent = 'Evaluates rate limit backoff (429), oversized payload protection (413), slowloris drips, and idempotency deduplication.';
+      if (diagHeaderTitle) diagHeaderTitle.textContent = 'Traffic Storms & DoS Defense Suite (8 Checks)';
+      if (diagHeaderSubtitle) diagHeaderSubtitle.textContent = 'Evaluates rate limit backoff (429), oversized payloads (413), slowloris drips, idempotency, ReDoS lockup, race conditions, and avalanche floods.';
       if (testTargetProfile) {
         testTargetProfile.innerHTML = `
           <option value="resilient">Target: Resilient System (Grade A)</option>
           <option value="fragile">Target: Fragile System (Grade F)</option>
         `;
       }
-      if (btnRunDiagnostics) btnRunDiagnostics.textContent = 'Run Traffic Storm Benchmark';
+      if (btnRunDiagnostics) btnRunDiagnostics.textContent = 'Run 8-Point Storm Benchmark';
       scoreTitle.textContent = 'Ready for Traffic Storms & DoS evaluation';
-      scoreSubtitle.textContent = 'Click "Run Traffic Storm Benchmark" to test rate limit backoff, slowloris defense, and idempotency.';
+      scoreSubtitle.textContent = 'Click "Run 8-Point Storm Benchmark" to test rate limit backoff, slowloris defense, ReDoS, and concurrency floods.';
     } else if (mode === 'security') {
       if (tabSecurity) tabSecurity.classList.add('active');
-      if (diagHeaderTitle) diagHeaderTitle.textContent = 'Security & Protocol Audit';
-      if (diagHeaderSubtitle) diagHeaderSubtitle.textContent = 'Non-destructive 7-point audit evaluating defensive headers, CORS, URL tokens, response PII, path traversal, and canary injection.';
+      if (diagHeaderTitle) diagHeaderTitle.textContent = 'Security & Protocol Audit (14 Checks)';
+      if (diagHeaderSubtitle) diagHeaderSubtitle.textContent = 'Non-destructive 14-point audit evaluating headers, CORS, secrets, PII, path traversal, canary injection, host headers, IP spoofing, HPP, cache-control, and metadata.';
       if (testTargetProfile) {
         testTargetProfile.innerHTML = `
           <option value="secure">Target: Secure API (Grade A)</option>
           <option value="vulnerable">Target: Vulnerable API (Grade F)</option>
         `;
       }
-      if (btnRunDiagnostics) btnRunDiagnostics.textContent = 'Run Security Audit';
+      if (btnRunDiagnostics) btnRunDiagnostics.textContent = 'Run 14-Point Security Audit';
       scoreTitle.textContent = 'Ready to audit security';
-      scoreSubtitle.textContent = 'Click "Run Security Audit" to evaluate all 7 defensive security, CORS, PII, and injection probes.';
+      scoreSubtitle.textContent = 'Click "Run 14-Point Security Audit" to evaluate all 14 defensive security, CORS, PII, injection, and auth probes.';
     } else {
       if (tabResilience) tabResilience.classList.add('active');
-      if (diagHeaderTitle) diagHeaderTitle.textContent = 'Automated API Resilience Benchmark';
-      if (diagHeaderSubtitle) diagHeaderSubtitle.textContent = 'Automated 5-point test suite evaluating client resilience against network delay, throttling, cuts, corruptions, and 503 outages.';
+      if (diagHeaderTitle) diagHeaderTitle.textContent = 'Automated API Resilience Benchmark (10 Checks)';
+      if (diagHeaderSubtitle) diagHeaderSubtitle.textContent = 'Automated 10-point test suite evaluating client resilience against network delay, throttling, cuts, corruptions, 503 outages, jitter, circuit breakers, and starvation.';
       if (testTargetProfile) {
         testTargetProfile.innerHTML = `
           <option value="resilient">Target: Resilient App (Grade A)</option>
           <option value="fragile">Target: Fragile App (Grade F)</option>
         `;
       }
-      if (btnRunDiagnostics) btnRunDiagnostics.textContent = 'Run 5-Point Benchmark';
+      if (btnRunDiagnostics) btnRunDiagnostics.textContent = 'Run 10-Point Resilience Benchmark';
       scoreTitle.textContent = 'Ready to evaluate resilience';
-      scoreSubtitle.textContent = 'Click "Run 5-Point Benchmark" to evaluate client resilience against 5 real failure cases.';
+      scoreSubtitle.textContent = 'Click "Run 10-Point Resilience Benchmark" to evaluate client resilience against 10 real network failure cases.';
     }
     scoreValue.textContent = '--';
     scoreGrade.textContent = 'UNTESTED';
@@ -658,6 +1024,7 @@ document.addEventListener('DOMContentLoaded', () => {
   if (tabResilience) tabResilience.addEventListener('click', () => setDiagMode('resilience'));
   if (tabSecurity) tabSecurity.addEventListener('click', () => setDiagMode('security'));
   if (tabStorm) tabStorm.addEventListener('click', () => setDiagMode('storm'));
+  if (tabRedTeam) tabRedTeam.addEventListener('click', () => setDiagMode('redteam'));
 
   if (testTargetProfile) {
     testTargetProfile.addEventListener('change', () => {
@@ -670,95 +1037,497 @@ document.addEventListener('DOMContentLoaded', () => {
     });
   }
 
-  btnRunDiagnostics.addEventListener('click', async () => {
-    if (isRunningDiagnostics) return;
-    isRunningDiagnostics = true;
-    btnRunDiagnostics.disabled = true;
+  if (btnRunDiagnostics) {
+    btnRunDiagnostics.addEventListener('click', async () => {
+      if (isRunningDiagnostics) return;
+      await syncTargetUrl();
+      isRunningDiagnostics = true;
+      btnRunDiagnostics.disabled = true;
+
+      if (currentDiagMode === 'storm') {
+        btnRunDiagnostics.textContent = 'Auditing...';
+        scoreTitle.textContent = 'Running Traffic Storm Benchmark...';
+        scoreSubtitle.textContent = 'Auditing HTTP 429 rate limit backoff, oversized payloads (413), slowloris drips, and duplicate POST idempotency.';
+
+        const profile = testTargetProfile ? testTargetProfile.value : 'resilient';
+
+        try {
+          const res = await fetch(`/_faultmesh/storm/run?profile=${encodeURIComponent(profile)}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ profile }),
+          });
+          const report = await res.json();
+          renderTrafficStormReport(report);
+          refreshStatus();
+        } catch (err) {
+          console.error('Traffic storm error:', err);
+          scoreTitle.textContent = 'Traffic Storm Audit Failed';
+          scoreSubtitle.textContent = err.message;
+        } finally {
+          isRunningDiagnostics = false;
+          btnRunDiagnostics.disabled = false;
+          btnRunDiagnostics.textContent = 'Run 8-Point Storm Benchmark';
+        }
+      } else if (currentDiagMode === 'security') {
+        btnRunDiagnostics.textContent = 'Auditing...';
+        scoreTitle.textContent = 'Running 14-Point Security Audit...';
+        scoreSubtitle.textContent = 'Auditing defensive headers, CORS safety, query secret leakage, response PII, and inert canary probes.';
+
+        const profile = testTargetProfile ? testTargetProfile.value : 'secure';
+
+        try {
+          const res = await fetch(`/_faultmesh/security/run?profile=${encodeURIComponent(profile)}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ profile }),
+          });
+          const report = await res.json();
+          renderSecurityReport(report);
+          refreshStatus();
+        } catch (err) {
+          console.error('Security audit error:', err);
+          scoreTitle.textContent = 'Security Audit Failed';
+          scoreSubtitle.textContent = err.message;
+        } finally {
+          isRunningDiagnostics = false;
+          btnRunDiagnostics.disabled = false;
+          btnRunDiagnostics.textContent = 'Run 14-Point Security Audit';
+        }
+      } else {
+        btnRunDiagnostics.textContent = 'Running...';
+        scoreTitle.textContent = 'Running 10-Point Resilience Benchmark...';
+        scoreSubtitle.textContent = 'Evaluating delay, slow speed, cuts, corruption, 503 errors, jitter, circuit breakers, and starvation.';
+
+        const profile = testTargetProfile ? testTargetProfile.value : 'resilient';
+
+        try {
+          const res = await fetch(`/_faultmesh/diagnostics/run?profile=${encodeURIComponent(profile)}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ profile }),
+          });
+          const report = await res.json();
+          renderDiagnosticsReport(report);
+          refreshStatus();
+        } catch (err) {
+          console.error('Diagnostics error:', err);
+          scoreTitle.textContent = 'Diagnostics Failed';
+          scoreSubtitle.textContent = err.message;
+        } finally {
+          isRunningDiagnostics = false;
+          btnRunDiagnostics.disabled = false;
+          btnRunDiagnostics.textContent = 'Run 10-Point Resilience Benchmark';
+        }
+      }
+    });
+  }
+
+  // Remediation Code Snippets Catalog
+  const REMEDIATION_SNIPPETS = {
+    'Response Delay Handling (300ms)': {
+      express: `// Express / Node HTTP Client Timeout Handling
+const controller = new AbortController();
+const timeout = setTimeout(() => controller.abort(), 3000); // 3s SLA timeout
+
+try {
+  const res = await fetch('http://api.backend.internal/data', { signal: controller.signal });
+  return await res.json();
+} catch (err) {
+  if (err.name === 'AbortError') {
+    return { status: 'degraded', data: [] }; // Graceful degradation fallback
+  }
+  throw err;
+} finally {
+  clearTimeout(timeout);
+}`,
+      fastapi: `# Python / httpx Client SLA Timeout
+import httpx
+
+try:
+    async with httpx.AsyncClient(timeout=3.0) as client:
+        response = await client.get("http://api.backend.internal/data")
+        return response.json()
+except httpx.TimeoutException:
+    return {"status": "degraded", "data": []}  # Graceful fallback`
+    },
+
+    'Bandwidth Throttling (Speed Cap)': {
+      express: `// Streaming chunk processor with backpressure handling
+const res = await fetch(url);
+const reader = res.body.getReader();
+
+while (true) {
+  const { done, value } = await reader.read();
+  if (done) break;
+  processChunkProgressively(value);
+}`,
+      fastapi: `# Streaming response chunk processor
+import httpx
+
+async with httpx.AsyncClient() as client:
+    async with client.stream("GET", url) as response:
+        async for chunk in response.aiter_bytes():
+            process_chunk_incrementally(chunk)`
+    },
 
-    if (currentDiagMode === 'storm') {
-      btnRunDiagnostics.textContent = 'Auditing...';
-      scoreTitle.textContent = 'Running Traffic Storm Benchmark...';
-      scoreSubtitle.textContent = 'Auditing HTTP 429 rate limit backoff, oversized payloads (413), slowloris drips, and duplicate POST idempotency.';
+    'Connection Cut (Abrupt Socket Drop)': {
+      express: `// Retry with Exponential Backoff on Socket Drop / ECONNRESET
+async function fetchWithRetry(url, retries = 3, delay = 500) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await fetch(url);
+    } catch (err) {
+      if (i === retries - 1) throw err;
+      await new Promise(r => setTimeout(r, delay * Math.pow(2, i)));
+    }
+  }
+}`,
+      fastapi: `# Tenacity retry on connection errors
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+import httpx
+
+@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=0.5), retry=retry_if_exception_type(httpx.NetworkError))
+async def safe_fetch(url: str):
+    async with httpx.AsyncClient() as client:
+        return await client.get(url)`
+    },
 
-      const profile = testTargetProfile ? testTargetProfile.value : 'resilient';
+    'Corrupted / Truncated JSON Payload': {
+      express: `// Safe JSON Parser with Fallback Boundary
+let parsedData;
+try {
+  parsedData = JSON.parse(responseText);
+} catch (err) {
+  console.warn("Payload corrupted or truncated mid-stream. Triggering safe fallback.");
+  parsedData = { fallback: true, error: "Malformed payload received" };
+}`,
+      fastapi: `# Pydantic validation error boundary
+import json
+from pydantic import ValidationError
+
+try:
+    data = json.loads(response_text)
+    validated = MyResponseModel.model_validate(data)
+except (json.JSONDecodeError, ValidationError):
+    validated = MyResponseModel(fallback=True, items=[])`
+    },
 
-      try {
-        const res = await fetch(`/_faultmesh/storm/run?profile=${encodeURIComponent(profile)}`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ profile }),
-        });
-        const report = await res.json();
-        renderTrafficStormReport(report);
-        refreshStatus();
-      } catch (err) {
-        console.error('Traffic storm error:', err);
-        scoreTitle.textContent = 'Traffic Storm Audit Failed';
-        scoreSubtitle.textContent = err.message;
-      } finally {
-        isRunningDiagnostics = false;
-        btnRunDiagnostics.disabled = false;
-        btnRunDiagnostics.textContent = 'Run Traffic Storm Benchmark';
-      }
-    } else if (currentDiagMode === 'security') {
-      btnRunDiagnostics.textContent = 'Auditing...';
-      scoreTitle.textContent = 'Running Security Audit...';
-      scoreSubtitle.textContent = 'Auditing defensive headers, CORS safety, query secret leakage, response PII, and inert canary probes.';
+    'Server Outage (503 Service Unavailable)': {
+      express: `// 503 Circuit Breaker & Status Fallback
+if (res.status === 503) {
+  const retryAfter = res.headers.get('Retry-After') || '5';
+  console.info(\`Upstream busy. Backing off for \${retryAfter} seconds.\`);
+  return { degraded: true, message: "Service busy, please retry shortly" };
+}`,
+      fastapi: `# 503 Status Handler with Retry-After respect
+if response.status_code == 503:
+    retry_after = int(response.headers.get("Retry-After", 5))
+    logger.warning(f"Upstream service unavailable. Backing off for {retry_after}s.")
+    return {"degraded": True, "message": "Service unavailable"}`
+    },
 
-      const profile = testTargetProfile ? testTargetProfile.value : 'secure';
+    'Defensive Security Headers': {
+      express: `// Add Helmet.js to automatically inject defensive headers
+import helmet from 'helmet';
+app.use(helmet());
+
+// Or configure manually in Express:
+app.use((req, res, next) => {
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('X-Frame-Options', 'DENY');
+  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
+  next();
+});`,
+      fastapi: `# Custom Security Headers Middleware in FastAPI
+from starlette.middleware.base import BaseHTTPMiddleware
+
+class SecurityHeadersMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        response = await call_next(request)
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        response.headers["X-Frame-Options"] = "DENY"
+        response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
+        return response
+
+app.add_middleware(SecurityHeadersMiddleware)`
+    },
 
-      try {
-        const res = await fetch(`/_faultmesh/security/run?profile=${encodeURIComponent(profile)}`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ profile }),
-        });
-        const report = await res.json();
-        renderSecurityReport(report);
-        refreshStatus();
-      } catch (err) {
-        console.error('Security audit error:', err);
-        scoreTitle.textContent = 'Security Audit Failed';
-        scoreSubtitle.textContent = err.message;
-      } finally {
-        isRunningDiagnostics = false;
-        btnRunDiagnostics.disabled = false;
-        btnRunDiagnostics.textContent = 'Run Security Audit';
-      }
-    } else {
-      btnRunDiagnostics.textContent = 'Running...';
-      scoreTitle.textContent = 'Running 5-Point Benchmark...';
-      scoreSubtitle.textContent = 'Evaluating delay, slow speed, connection drops, corrupted JSON, and 503 errors.';
+    'CORS Origin & Credential Safety': {
+      express: `// Strict Whitelist CORS (Never use origin: '*' with credentials)
+import cors from 'cors';
+
+const allowedOrigins = ['https://app.yourdomain.com'];
+app.use(cors({
+  origin: (origin, callback) => {
+    if (!origin || allowedOrigins.includes(origin)) callback(null, true);
+    else callback(new Error('Blocked by CORS'));
+  },
+  credentials: true
+}));`,
+      fastapi: `# Strict CORS Middleware in FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://app.yourdomain.com"], # Explicit origin required
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["Authorization", "Content-Type"],
+)`
+    },
 
-      const profile = testTargetProfile ? testTargetProfile.value : 'resilient';
+    'URL Credential & Secret Exposure': {
+      express: `// Consume tokens via Authorization header, reject query tokens
+app.use((req, res, next) => {
+  if (req.query.token || req.query.apiKey) {
+    return res.status(400).json({ error: "Pass credentials in Authorization header, not in query string." });
+  }
+  next();
+});`,
+      fastapi: `# OAuth2 / Bearer Token Header Authentication
+from fastapi import Depends, HTTPException, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 
-      try {
-        const res = await fetch(`/_faultmesh/diagnostics/run?profile=${encodeURIComponent(profile)}`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ profile }),
-        });
-        const report = await res.json();
-        renderDiagnosticsReport(report);
-        refreshStatus();
-      } catch (err) {
-        console.error('Diagnostics error:', err);
-        scoreTitle.textContent = 'Diagnostics Failed';
-        scoreSubtitle.textContent = err.message;
-      } finally {
-        isRunningDiagnostics = false;
-        btnRunDiagnostics.disabled = false;
-        btnRunDiagnostics.textContent = 'Run 5-Point Benchmark';
-      }
-    }
+security = HTTPBearer()
+
+async def get_current_user(credentials: HTTPAuthorizationCredentials = Security(security)):
+    token = credentials.credentials
+    return verify_token(token)`
+    },
+
+    'Outbound Response PII & Secret Scanner': {
+      express: `// Exclude passwords and internal keys before serialization
+function sanitizeUser(user) {
+  const { passwordHash, internalSecret, ...safeUser } = user;
+  return safeUser;
+}
+
+res.json(sanitizeUser(userRecord));`,
+      fastapi: `# Use Pydantic response_model to prevent leaking private fields
+class UserPublic(BaseModel):
+    id: int
+    username: str
+    email: EmailStr
+    # password_hash and internal_token are excluded
+
+@app.get("/users/me", response_model=UserPublic)
+async def read_current_user():
+    return user_record`
+    },
+
+    'Error Sanitization & Stack Trace Exposure': {
+      express: `// Global Production Error Sanitizer (Hide stack traces from clients)
+app.use((err, req, res, next) => {
+  console.error(err); // Log internally to server stdout
+  res.status(500).json({
+    error: "Internal Server Error",
+    requestId: req.id
   });
+});`,
+      fastapi: `# Production Exception Handler
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    logger.error(f"Unhandled exception: {exc}", exc_info=True)
+    return JSONResponse(
+        status_code=500,
+        content={"error": "Internal Server Error", "requestId": request.state.request_id}
+    )`
+    },
+
+    'Path Traversal & Directory Escape (../)': {
+      express: `// Safe Path Resolution with Boundary Jailing
+import path from 'node:path';
+
+function getSafeFile(userPath) {
+  const baseDir = path.resolve('/var/www/uploads');
+  const safePath = path.resolve(baseDir, userPath);
+  if (!safePath.startsWith(baseDir + path.sep)) {
+    throw new Error('Access Denied: Path Traversal Detected');
+  }
+  return safePath;
+}`,
+      fastapi: `# Safe Path Resolution in Python
+from pathlib import Path
+
+def get_safe_filepath(user_filename: str) -> Path:
+    base_dir = Path("/var/www/uploads").resolve()
+    target_path = (base_dir / user_filename).resolve()
+    if not target_path.is_relative_to(base_dir):
+        raise HTTPException(status_code=400, detail="Invalid path")
+    return target_path`
+    },
+
+    'Safe SQL/NoSQL & Canary Input Probing': {
+      express: `// Use Parameterized Queries (e.g. pg, mysql2, or Prisma ORM)
+// NEVER do: db.query(\`SELECT * FROM users WHERE id = '\${userId}'\`)
+
+// ALWAYS do:
+const result = await pool.query('SELECT * FROM users WHERE id = $1', [userId]);`,
+      fastapi: `# Use SQLAlchemy / SQLModel Parameterized Statements
+from sqlalchemy import select
+
+# Safe parameterized query:
+stmt = select(User).where(User.username == username_input)
+result = await session.execute(stmt)`
+    },
+
+    'Rate Limit Back-off & Retry Storm Handling': {
+      express: `// Express Rate Limit Middleware
+import rateLimit from 'express-rate-limit';
+
+const limiter = rateLimit({
+  windowMs: 60 * 1000, // 1 minute
+  max: 60, // Limit each IP to 60 requests per minute
+  standardHeaders: true, // Return RateLimit-* headers
+  legacyHeaders: false,
+});
+
+app.use('/api/', limiter);`,
+      fastapi: `# SlowAPI Rate Limiting for FastAPI
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+@app.get("/api/data")
+@limiter.limit("60/minute")
+async def get_data(request: Request):
+    return {"status": "ok"}`
+    },
+
+    'Oversized Payload & Buffer OOM Defense (HTTP 413)': {
+      express: `// Restrict JSON Body Parsing Limit
+app.use(express.json({ limit: '2mb' }));
+app.use(express.urlencoded({ extended: true, limit: '2mb' }));`,
+      fastapi: `# Request Body Size Limiter Middleware in FastAPI
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse
+
+class ContentLengthLimitMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        content_length = request.headers.get("content-length")
+        if content_length and int(content_length) > 5 * 1024 * 1024: # 5 MB
+            return JSONResponse({"error": "Payload Too Large"}, status_code=413)
+        return await call_next(request)
+
+app.add_middleware(ContentLengthLimitMiddleware)`
+    },
+
+    'Slowloris Connection Drip Defense': {
+      express: `// Node HTTP Server Timeout Protection
+const server = app.listen(port);
+
+server.headersTimeout = 20000; // 20s
+server.requestTimeout = 30000; // 30s
+server.keepAliveTimeout = 5000; // 5s`,
+      fastapi: `# Uvicorn Timeout Configuration
+# Run uvicorn with strict timeout flags:
+# uvicorn main:app --timeout-keep-alive 5 --timeout-graceful-shutdown 30`
+    },
+
+    'Duplicate Request Idempotency Protection': {
+      express: `// Idempotency Middleware using Redis / In-Memory Cache
+app.post('/api/checkout', async (req, res) => {
+  const key = req.headers['idempotency-key'];
+  if (!key) return res.status(400).json({ error: "Missing Idempotency-Key" });
+
+  const cached = await redis.get(\`idemp:\${key}\`);
+  if (cached) return res.json(JSON.parse(cached));
+
+  const result = await processTransaction(req.body);
+  await redis.set(\`idemp:\${key}\`, JSON.stringify(result), 'EX', 86400);
+  res.json(result);
+});`,
+      fastapi: `# Idempotency Key Middleware
+from fastapi import Header, HTTPException
+
+@app.post("/api/checkout")
+async def checkout(idempotency_key: str = Header(None)):
+    if not idempotency_key:
+        raise HTTPException(status_code=400, detail="Missing Idempotency-Key")
+    
+    cached = await redis_client.get(f"idemp:{idempotency_key}")
+    if cached:
+        return json.loads(cached)
+        
+    result = await process_order()
+    await redis_client.set(f"idemp:{idempotency_key}", json.dumps(result), ex=86400)
+    return result`
+    }
+  };
+
+  function renderSnippetBlock(checkName, uniqueId) {
+    const snippet = REMEDIATION_SNIPPETS[checkName];
+    if (!snippet) return '';
+
+    return `
+      <button class="btn-toggle-snippet" type="button" onclick="window.toggleSnippet('${uniqueId}')">
+        View Remediation Snippet
+      </button>
+      <div id="${uniqueId}" class="snippet-container" style="display: none;">
+        <div class="snippet-header">
+          <div class="snippet-tabs">
+            <button class="snippet-tab-btn active" type="button" onclick="window.switchSnippetTab('${uniqueId}', 'express')">Express / Node</button>
+            <button class="snippet-tab-btn" type="button" onclick="window.switchSnippetTab('${uniqueId}', 'fastapi')">FastAPI / Python</button>
+          </div>
+          <button class="btn-copy-snippet" type="button" onclick="window.copySnippetCode('${uniqueId}', this)">Copy Code</button>
+        </div>
+        <pre class="snippet-code-content" data-express="${escapeHtml(snippet.express)}" data-fastapi="${escapeHtml(snippet.fastapi)}">${escapeHtml(snippet.express)}</pre>
+      </div>
+    `;
+  }
+
+  window.toggleSnippet = function(id) {
+    const el = document.getElementById(id);
+    if (!el) return;
+    el.style.display = el.style.display === 'none' ? 'block' : 'none';
+  };
+
+  window.switchSnippetTab = function(containerId, lang) {
+    const container = document.getElementById(containerId);
+    if (!container) return;
+    const pre = container.querySelector('.snippet-code-content');
+    const tabs = container.querySelectorAll('.snippet-tab-btn');
+    tabs.forEach(t => t.classList.remove('active'));
+    
+    const clicked = Array.from(tabs).find(t => t.textContent.toLowerCase().includes(lang === 'express' ? 'express' : 'fastapi'));
+    if (clicked) clicked.classList.add('active');
+
+    if (pre) {
+      pre.textContent = pre.getAttribute(`data-${lang}`) || '';
+    }
+  };
+
+  window.copySnippetCode = function(containerId, btnEl) {
+    const container = document.getElementById(containerId);
+    if (!container) return;
+    const pre = container.querySelector('.snippet-code-content');
+    if (!pre) return;
+    navigator.clipboard.writeText(pre.textContent).then(() => {
+      if (btnEl) {
+        const orig = btnEl.textContent;
+        btnEl.textContent = 'Copied!';
+        setTimeout(() => { btnEl.textContent = orig; }, 1500);
+      }
+    });
+  };
 
   function renderDiagnosticsReport(report) {
+    lastScorecardData = { mode: 'resilience', report, timestamp: new Date().toISOString() };
+    if (exportGroup) exportGroup.style.display = 'flex';
+
     scoreValue.textContent = `${report.score}/100`;
     scoreGrade.textContent = `GRADE ${report.grade}`;
 
     if (report.grade === 'A') {
-      scoreTitle.textContent = 'All 5 Resilience Checks Passed (Grade A)';
+      scoreTitle.textContent = 'All 10 Resilience Checks Passed (Grade A)';
     } else if (report.grade === 'B') {
       scoreTitle.textContent = 'Passed with Minor Issues (Grade B)';
     } else {
@@ -777,6 +1546,7 @@ document.addEventListener('DOMContentLoaded', () => {
       const num = String(idx + 1).padStart(2, '0');
       const rowClass = r.passed ? 'row-passed' : 'row-failed';
       const findingClass = r.passed ? 'finding-pass' : 'finding-fail';
+      const snippetHtml = !r.passed ? renderSnippetBlock(r.name, `snip_res_${idx}`) : '';
 
       return `
         <div class="test-row ${rowClass}">
@@ -791,6 +1561,7 @@ document.addEventListener('DOMContentLoaded', () => {
               <div class="test-finding-box ${findingClass}">
                 Finding: ${escapeHtml(r.details)}
               </div>
+              ${snippetHtml}
             </div>
           </div>
           <div class="test-row-aside">
@@ -812,11 +1583,14 @@ document.addEventListener('DOMContentLoaded', () => {
   }
 
   function renderSecurityReport(report) {
+    lastScorecardData = { mode: 'security', report, timestamp: new Date().toISOString() };
+    if (exportGroup) exportGroup.style.display = 'flex';
+
     scoreValue.textContent = `${report.score}/100`;
     scoreGrade.textContent = `GRADE ${report.grade}`;
 
     if (report.grade === 'A') {
-      scoreTitle.textContent = 'All 7 Security Checks Passed (Grade A)';
+      scoreTitle.textContent = 'All 14 Security Checks Passed (Grade A)';
     } else if (report.grade === 'B') {
       scoreTitle.textContent = 'Minor Security Issues Detected (Grade B)';
     } else {
@@ -834,6 +1608,7 @@ document.addEventListener('DOMContentLoaded', () => {
       const num = String(idx + 1).padStart(2, '0');
       const rowClass = c.passed ? 'row-passed' : 'row-failed';
       const findingClass = c.passed ? 'finding-pass' : 'finding-fail';
+      const snippetHtml = !c.passed ? renderSnippetBlock(c.name, `snip_sec_${idx}`) : '';
 
       return `
         <div class="test-row ${rowClass}">
@@ -849,6 +1624,7 @@ document.addEventListener('DOMContentLoaded', () => {
               <div class="test-finding-box ${findingClass}">
                 Finding: ${escapeHtml(c.details)}
               </div>
+              ${snippetHtml}
             </div>
           </div>
           <div class="test-row-aside">
@@ -870,11 +1646,14 @@ document.addEventListener('DOMContentLoaded', () => {
   }
 
   function renderTrafficStormReport(report) {
+    lastScorecardData = { mode: 'storm', report, timestamp: new Date().toISOString() };
+    if (exportGroup) exportGroup.style.display = 'flex';
+
     scoreValue.textContent = `${report.score}/100`;
     scoreGrade.textContent = `GRADE ${report.grade}`;
 
     if (report.grade === 'A') {
-      scoreTitle.textContent = 'All 4 Traffic Storm Checks Passed (Grade A)';
+      scoreTitle.textContent = 'All 8 Traffic Storm Checks Passed (Grade A)';
     } else if (report.grade === 'B') {
       scoreTitle.textContent = 'Passed with Minor Issues (Grade B)';
     } else {
@@ -892,6 +1671,7 @@ document.addEventListener('DOMContentLoaded', () => {
       const num = String(idx + 1).padStart(2, '0');
       const rowClass = c.passed ? 'row-passed' : 'row-failed';
       const findingClass = c.passed ? 'finding-pass' : 'finding-fail';
+      const snippetHtml = !c.passed ? renderSnippetBlock(c.name, `snip_storm_${idx}`) : '';
 
       return `
         <div class="test-row ${rowClass}">
@@ -907,6 +1687,7 @@ document.addEventListener('DOMContentLoaded', () => {
               <div class="test-finding-box ${findingClass}">
                 Finding: ${escapeHtml(c.details)}
               </div>
+              ${snippetHtml}
             </div>
           </div>
           <div class="test-row-aside">
@@ -927,45 +1708,588 @@ document.addEventListener('DOMContentLoaded', () => {
     `;
   }
 
-  // 9. Live Request SSE Stream
-  function setupSSE() {
-    const eventSource = new EventSource('/_faultmesh/telemetry/stream');
-
-    eventSource.addEventListener('snapshot', (e) => {
-      try {
-        const data = JSON.parse(e.data);
-        if (data.events && data.events.length > 0) {
-          activityFeed.innerHTML = '';
-          data.events.forEach(addLogRow);
-        }
-      } catch (err) {
-        console.warn('Snapshot parse error', err);
-      }
+  // Export functions
+  function exportMarkdownReport() {
+    if (!lastScorecardData || !lastScorecardData.report) {
+      alert('No audit report available to export. Run a benchmark first.');
+      return;
+    }
+    const { mode, report, timestamp } = lastScorecardData;
+    const checks = report.checks || report.results || [];
+
+    let md = `# FaultMesh Audit Report — ${mode.toUpperCase()}\n\n`;
+    md += `* **Timestamp:** ${new Date(timestamp).toUTCString()}\n`;
+    md += `* **Overall Score:** ${report.score} / 100 (Grade ${report.grade})\n`;
+    md += `* **Checks Passed:** ${report.passedChecks ?? report.passedAttacks} / ${report.totalChecks ?? report.totalAttacks}\n\n`;
+
+    md += `## Findings & Verification Summary\n\n`;
+    md += `| # | Check Name | Severity | Result | Finding Details |\n`;
+    md += `| :--- | :--- | :--- | :--- | :--- |\n`;
+    checks.forEach((c, idx) => {
+      const num = String(idx + 1).padStart(2, '0');
+      const sev = c.severity ? c.severity.toUpperCase() : 'STANDARD';
+      const res = c.passed ? 'PASSED' : 'FAILED';
+      const detail = (c.details || '').replace(/\|/g, '\\|');
+      md += `| ${num} | ${c.name} | ${sev} | ${res} | ${detail} |\n`;
     });
 
-    eventSource.addEventListener('telemetry', (e) => {
-      try {
-        const event = JSON.parse(e.data);
-        addLogRow(event);
-        refreshStatus();
-      } catch (err) {
-        console.warn('Telemetry parse error', err);
-      }
-    });
+    if (report.recommendations && report.recommendations.length > 0) {
+      md += `\n## Remediation Recommendations\n\n`;
+      report.recommendations.forEach(rec => {
+        md += `* ${rec}\n`;
+      });
+    }
+
+    md += `\n---\n*Report generated by FaultMesh Runtime Engine*\n`;
+
+    downloadFile(`faultmesh-${mode}-audit-${Date.now()}.md`, 'text/markdown', md);
   }
 
-  function addLogRow(ev) {
-    if (activityFeed.querySelector('.table-empty')) {
-      activityFeed.innerHTML = '';
+  function exportJsonReport() {
+    if (!lastScorecardData || !lastScorecardData.report) {
+      alert('No audit report available to export. Run a benchmark first.');
+      return;
     }
+    const jsonStr = JSON.stringify(lastScorecardData, null, 2);
+    downloadFile(`faultmesh-${lastScorecardData.mode}-audit-${Date.now()}.json`, 'application/json', jsonStr);
+  }
 
-    const tr = document.createElement('tr');
-    let codeClass = 'code-2xx';
-    if (ev.statusCode >= 500) codeClass = 'code-5xx';
-    else if (ev.statusCode >= 400) codeClass = 'code-4xx';
+  function downloadFile(filename, mimeType, content) {
+    const blob = new Blob([content], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+  }
 
-    const ruleText = ev.appliedToxics && ev.appliedToxics.length > 0
-      ? ev.appliedToxics.join(', ')
+  if (btnExportMd) {
+    btnExportMd.addEventListener('click', exportMarkdownReport);
+  }
+  if (btnExportJson) {
+    btnExportJson.addEventListener('click', exportJsonReport);
+  }
+
+  // 8.9 Auto-Healer Interactions
+  if (btnOpenHealer && healerModal) {
+    btnOpenHealer.addEventListener('click', () => {
+      if (healerProjectDir && (!healerProjectDir.value || healerProjectDir.value === '.' || healerProjectDir.value === './')) {
+        healerProjectDir.value = 'examples/vulnerable-backend';
+      }
+      healerModal.style.display = 'flex';
+      if (healerScanStatus && healerScanStatus.style.display === 'none') {
+        healerScanStatus.style.display = 'block';
+        healerScanStatus.textContent = 'Enter your backend project directory above and click "Scan Codebase".';
+      }
+    });
+  }
+
+  if (btnCloseHealer && healerModal) {
+    btnCloseHealer.addEventListener('click', () => {
+      healerModal.style.display = 'none';
+    });
+  }
+
+  // Close modal on backdrop click
+  if (healerModal) {
+    healerModal.addEventListener('click', (e) => {
+      if (e.target === healerModal) {
+        healerModal.style.display = 'none';
+      }
+    });
+  }
+
+  const btnDirPresetSample = document.getElementById('btnDirPresetSample');
+  const btnDirPresetRoot = document.getElementById('btnDirPresetRoot');
+  if (btnDirPresetSample && healerProjectDir) {
+    btnDirPresetSample.addEventListener('click', () => {
+      healerProjectDir.value = 'examples/vulnerable-backend';
+      if (btnHealerScan) btnHealerScan.click();
+    });
+  }
+  if (btnDirPresetRoot && healerProjectDir) {
+    btnDirPresetRoot.addEventListener('click', () => {
+      healerProjectDir.value = './';
+      healerProjectDir.focus();
+    });
+  }
+
+  // Target URL Management (Header Switchers)
+  const btnTarget5050 = document.getElementById('btnTarget5050');
+  const btnTarget4000 = document.getElementById('btnTarget4000');
+
+  async function applyTargetUrl(url) {
+    if (!url) return;
+    try {
+      const res = await fetch('/_faultmesh/config/target', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ targetUrl: url }),
+      });
+      const data = await res.json();
+      if (data.success) {
+        if (targetUrlInput) targetUrlInput.value = url;
+        if (testTargetProfile) {
+          testTargetProfile.textContent = url.includes(':5050') ? 'Sample Backend (:5050)' : (url.includes(':4000') ? 'Mock Echo (:4000)' : url);
+        }
+      }
+    } catch (err) {
+      console.warn('Failed to update target URL:', err);
+    }
+  }
+
+  if (btnSetTargetUrl && targetUrlInput) {
+    btnSetTargetUrl.addEventListener('click', () => {
+      applyTargetUrl(targetUrlInput.value.trim());
+    });
+  }
+  if (btnTarget5050) {
+    btnTarget5050.addEventListener('click', () => {
+      applyTargetUrl('http://127.0.0.1:5050');
+    });
+  }
+  if (btnTarget4000) {
+    btnTarget4000.addEventListener('click', () => {
+      applyTargetUrl('http://127.0.0.1:4000');
+    });
+  }
+
+  if (btnToggleAiSettings && healerAiSettingsPanel) {
+    btnToggleAiSettings.addEventListener('click', () => {
+      const isHidden = healerAiSettingsPanel.style.display === 'none';
+      healerAiSettingsPanel.style.display = isHidden ? 'block' : 'none';
+      btnToggleAiSettings.textContent = isHidden
+        ? 'Hide AI Healer Configuration'
+        : 'Configure AI Healer (Local LLM / Cloud AI Providers)';
+    });
+  }
+
+  if (healerAiProvider) {
+    healerAiProvider.addEventListener('change', () => {
+      const prov = healerAiProvider.value;
+      if (prov === 'ollama') {
+        if (aiKeyGroup) aiKeyGroup.style.display = 'none';
+        if (aiEndpointGroup) {
+          aiEndpointGroup.style.display = 'flex';
+          if (healerAiEndpoint) healerAiEndpoint.value = 'http://127.0.0.1:11434';
+        }
+      } else if (prov === 'custom') {
+        if (aiKeyGroup) aiKeyGroup.style.display = 'flex';
+        if (aiEndpointGroup) {
+          aiEndpointGroup.style.display = 'flex';
+          if (healerAiEndpoint) healerAiEndpoint.value = 'http://127.0.0.1:1234/v1';
+        }
+      } else {
+        if (aiKeyGroup) aiKeyGroup.style.display = 'flex';
+        if (aiEndpointGroup) aiEndpointGroup.style.display = 'none';
+      }
+    });
+  }
+
+  if (healerEngineMode && healerEngineBadge) {
+    healerEngineMode.addEventListener('change', () => {
+      const mode = healerEngineMode.value;
+      if (mode === 'ai') {
+        healerEngineBadge.textContent = 'Engine: AI Healer Agent (Universal)';
+        healerEngineBadge.className = 'engine-badge ai-agent';
+      } else if (mode === 'codemod') {
+        healerEngineBadge.textContent = 'Engine: Deterministic CodeMod';
+        healerEngineBadge.className = 'engine-badge codemod';
+      } else {
+        healerEngineBadge.textContent = 'Engine: CodeMod + AI Hybrid';
+        healerEngineBadge.className = 'engine-badge codemod';
+      }
+    });
+  }
+
+  function getAiConfigPayload() {
+    const engineMode = healerEngineMode ? healerEngineMode.value : 'hybrid';
+    const provider = healerAiProvider ? healerAiProvider.value : 'ollama';
+    const apiKey = healerAiKey ? healerAiKey.value.trim() : undefined;
+    const endpoint = healerAiEndpoint ? healerAiEndpoint.value.trim() : undefined;
+    return { engineMode, aiConfig: { provider, apiKey, endpoint } };
+  }
+
+  if (btnHealerScan) {
+    btnHealerScan.addEventListener('click', async () => {
+      let rawDir = healerProjectDir ? healerProjectDir.value.trim() : '';
+      if (!rawDir || rawDir === '.' || rawDir === './') {
+        rawDir = 'examples/vulnerable-backend';
+        if (healerProjectDir) healerProjectDir.value = rawDir;
+      }
+      const projectDir = rawDir;
+      const { engineMode, aiConfig } = getAiConfigPayload();
+
+      btnHealerScan.disabled = true;
+      btnHealerScan.textContent = 'Scanning...';
+      if (healerScanStatus) {
+        healerScanStatus.style.display = 'block';
+        healerScanStatus.textContent = `Scanning project at "${projectDir}" using ${engineMode.toUpperCase()} engine...`;
+      }
+      if (healerDiffContainer) healerDiffContainer.style.display = 'none';
+      if (healerActionsBar) healerActionsBar.style.display = 'none';
+
+      let failedChecks = [];
+      if (lastRedTeamReport && lastRedTeamReport.breachesFound && lastRedTeamReport.breachesFound.length > 0) {
+        failedChecks = Array.from(new Set(
+          lastRedTeamReport.breachesFound.map(b => b.autoHealCheckKey || b.category || b.title).filter(Boolean)
+        ));
+      } else if (lastScorecardData && lastScorecardData.report) {
+        const checks = lastScorecardData.report.checks || lastScorecardData.report.results || [];
+        failedChecks = checks.filter(c => !c.passed).map(c => c.name);
+      }
+
+      try {
+        const res = await fetch('/_faultmesh/healer/scan', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ projectDir, failedChecks, engineMode, aiConfig }),
+        });
+        const result = await res.json();
+        lastHealerScanResult = result;
+
+        if (!result.success) {
+          if (healerScanStatus) {
+            healerScanStatus.textContent = `Scan Notice: ${result.warnings.join('; ') || 'Could not locate server entry file'}`;
+            healerScanStatus.style.borderColor = 'var(--tag-red-fg)';
+          }
+          return;
+        }
+
+        if (result.patches.length === 0) {
+          if (healerScanStatus) {
+            healerScanStatus.innerHTML = `
+              <div style="display: flex; flex-direction: column; gap: 6px;">
+                <div><strong>Framework:</strong> ${escapeHtml(result.framework.toUpperCase())} (Entry: <code>${escapeHtml(result.entryFile)}</code>). All target defenses are already in place! Zero patches required.</div>
+                <div style="font-size: 11px; color: var(--text-muted);">The backend codebase already has defensive headers, payload size limits, CORS restrictions, error sanitizers, socket timeouts, host whitelist guards, path traversal guards, and idempotency protection applied.</div>
+                <div>
+                  <button id="btnQuickResetVulnerable" class="btn-secondary btn-sm" type="button" style="margin-top: 4px; font-weight: 600;">Reset Sample Backend to Vulnerable State (To Test Healing Again)</button>
+                </div>
+              </div>
+            `;
+            healerScanStatus.style.borderColor = 'var(--tag-green-fg)';
+            const quickReset = document.getElementById('btnQuickResetVulnerable');
+            if (quickReset && btnHealerResetSample) {
+              quickReset.addEventListener('click', () => btnHealerResetSample.click());
+            }
+          }
+          return;
+        }
+
+        if (healerScanStatus) {
+          const engineLabel = result.engineUsed === 'ai-agent' ? 'AI Agent' : (result.engineUsed === 'hybrid' ? 'Hybrid (CodeMod + AI)' : 'Deterministic CodeMod');
+          healerScanStatus.textContent = `Detected ${result.framework.toUpperCase()} in "${result.entryFile}". Found ${result.patches.length} applicable remediations (Engine: ${engineLabel}):`;
+          healerScanStatus.style.borderColor = 'var(--border-default)';
+        }
+
+        if (healerDiffContainer) {
+          healerDiffContainer.innerHTML = result.patches.map((p) => {
+            const diffLines = p.diff.split(/\r?\n/).map(line => {
+              if (line.startsWith('+') && !line.startsWith('+++')) {
+                return `<span class="diff-line add">${escapeHtml(line)}</span>`;
+              } else if (line.startsWith('-') && !line.startsWith('---')) {
+                return `<span class="diff-line del">${escapeHtml(line)}</span>`;
+              } else if (line.startsWith('@@')) {
+                return `<span class="diff-line info">${escapeHtml(line)}</span>`;
+              } else if (line.startsWith('---') || line.startsWith('+++')) {
+                return `<span class="diff-line file-header">${escapeHtml(line)}</span>`;
+              }
+              return `<span class="diff-line context">${escapeHtml(line)}</span>`;
+            }).join('');
+
+            const engineTagClass = p.engine === 'ai-agent' ? 'ai-agent' : 'codemod';
+            const engineTagLabel = p.engine === 'ai-agent' ? 'AI Agent' : 'CodeMod';
+
+            return `
+              <div class="diff-card">
+                <div class="diff-card-header">
+                  <div style="display: flex; align-items: center; gap: 8px;">
+                    <span class="diff-card-title">${escapeHtml(p.checkName)}</span>
+                    <span class="engine-badge ${engineTagClass}">${engineTagLabel}</span>
+                  </div>
+                  <span class="diff-card-file">${escapeHtml(p.relativePath)}</span>
+                </div>
+                <pre class="diff-pre"><code>${diffLines}</code></pre>
+              </div>
+            `;
+          }).join('');
+
+          healerDiffContainer.style.display = 'flex';
+        }
+
+        if (healerActionsBar) {
+          healerActionsBar.style.display = 'flex';
+        }
+      } catch (err) {
+        if (healerScanStatus) {
+          healerScanStatus.textContent = `Scan Error: ${err.message}`;
+          healerScanStatus.style.borderColor = 'var(--tag-red-fg)';
+        }
+      } finally {
+        btnHealerScan.disabled = false;
+        btnHealerScan.textContent = 'Scan Codebase';
+      }
+    });
+  }
+
+  if (btnHealerApply) {
+    btnHealerApply.addEventListener('click', async () => {
+      if (!lastHealerScanResult || !lastHealerScanResult.patches) return;
+      let rawDir = healerProjectDir ? healerProjectDir.value.trim() : '';
+      if (!rawDir || rawDir === '.' || rawDir === './') {
+        rawDir = 'examples/vulnerable-backend';
+        if (healerProjectDir) healerProjectDir.value = rawDir;
+      }
+      const projectDir = rawDir;
+      const createBackup = healerBackupCheck ? healerBackupCheck.checked : true;
+      const { engineMode, aiConfig } = getAiConfigPayload();
+
+      let failedChecks = [];
+      if (lastRedTeamReport && lastRedTeamReport.breachesFound && lastRedTeamReport.breachesFound.length > 0) {
+        failedChecks = Array.from(new Set(
+          lastRedTeamReport.breachesFound.map(b => b.autoHealCheckKey || b.category || b.title).filter(Boolean)
+        ));
+      } else if (lastScorecardData && lastScorecardData.report) {
+        const checks = lastScorecardData.report.checks || lastScorecardData.report.results || [];
+        failedChecks = checks.filter(c => !c.passed).map(c => c.name);
+      }
+
+      const patchIds = lastHealerScanResult.patches.map(p => p.id);
+
+      btnHealerApply.disabled = true;
+      btnHealerApply.textContent = 'Applying Remedies...';
+
+      try {
+        const res = await fetch('/_faultmesh/healer/apply', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ projectDir, patchIds, failedChecks, createBackup, engineMode, aiConfig }),
+        });
+        const result = await res.json();
+
+        if (result.success) {
+          if (result.appliedCount === 0) {
+            if (healerScanStatus) {
+              healerScanStatus.innerHTML = `<div>Notice: Zero patches were applied to disk. ${(result.errors || []).join('; ')}</div>`;
+              healerScanStatus.style.borderColor = 'var(--tag-amber-fg)';
+            }
+            return;
+          }
+
+          lastBackupDir = result.backupDir;
+          if (projectDir.includes('vulnerable-backend')) {
+            applyTargetUrl('http://127.0.0.1:5050');
+          }
+
+          if (healerScanStatus) {
+            healerScanStatus.textContent = `Successfully applied ${result.appliedCount} remedies! Target switched to healed backend on http://127.0.0.1:5050. Re-running validation...`;
+            healerScanStatus.style.borderColor = 'var(--tag-green-fg)';
+          }
+          if (healerDiffContainer) healerDiffContainer.style.display = 'none';
+          btnHealerApply.style.display = 'none';
+
+          if (btnHealerRollback && lastBackupDir) {
+            btnHealerRollback.style.display = 'inline-block';
+          }
+
+          // Trigger live re-test automatically
+          setTimeout(() => {
+            if (currentDiagMode === 'redteam') {
+              if (healerModal) healerModal.style.display = 'none';
+              startRedTeamCampaign();
+            } else if (btnRunDiagnostics) {
+              btnRunDiagnostics.click();
+            }
+          }, 800);
+        } else {
+          if (healerScanStatus) {
+            healerScanStatus.textContent = `Apply Error: ${(result.errors || []).join('; ')}`;
+            healerScanStatus.style.borderColor = 'var(--tag-red-fg)';
+          }
+        }
+      } catch (err) {
+        if (healerScanStatus) {
+          healerScanStatus.textContent = `Network Error: ${err.message}`;
+          healerScanStatus.style.borderColor = 'var(--tag-red-fg)';
+        }
+      } finally {
+        btnHealerApply.disabled = false;
+        btnHealerApply.textContent = 'Apply Remedies to Codebase';
+      }
+    });
+  }
+
+  if (btnHealerRollback) {
+    btnHealerRollback.addEventListener('click', async () => {
+      if (!lastBackupDir) return;
+      const projectDir = (healerProjectDir ? healerProjectDir.value.trim() : '') || '.';
+      btnHealerRollback.disabled = true;
+      btnHealerRollback.textContent = 'Rolling back...';
+
+      try {
+        const res = await fetch('/_faultmesh/healer/rollback', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ projectDir, backupDir: lastBackupDir }),
+        });
+        const result = await res.json();
+        if (result.success) {
+          if (healerScanStatus) {
+            healerScanStatus.textContent = `Rollback complete. Restored original files. Backend restarted on port 5050. Re-running live tests...`;
+            healerScanStatus.style.borderColor = 'var(--border-default)';
+          }
+          btnHealerRollback.style.display = 'none';
+          if (btnHealerApply) btnHealerApply.style.display = 'inline-block';
+
+          // Trigger live re-test automatically to reflect rolled-back state
+          setTimeout(() => {
+            if (btnRunDiagnostics) {
+              btnRunDiagnostics.click();
+            }
+          }, 600);
+        } else {
+          if (healerScanStatus) {
+            healerScanStatus.textContent = `Rollback error: ${(result.errors || []).join('; ')}`;
+          }
+        }
+      } catch (err) {
+        if (healerScanStatus) {
+          healerScanStatus.textContent = `Rollback failed: ${err.message}`;
+        }
+      } finally {
+        btnHealerRollback.disabled = false;
+        btnHealerRollback.textContent = 'Rollback Last Patch';
+      }
+    });
+  }
+
+  const btnHealerResetSample = document.getElementById('btnHealerResetSample');
+  if (btnHealerResetSample) {
+    btnHealerResetSample.addEventListener('click', async () => {
+      btnHealerResetSample.disabled = true;
+      btnHealerResetSample.textContent = 'Resetting...';
+      try {
+        const res = await fetch('/_faultmesh/sample/reset', { method: 'POST' });
+        const data = await res.json();
+        applyTargetUrl('http://127.0.0.1:5050');
+        if (healerProjectDir) healerProjectDir.value = 'examples/vulnerable-backend';
+        if (healerScanStatus) {
+          healerScanStatus.style.display = 'block';
+          healerScanStatus.textContent = 'Sample backend reset to vulnerable baseline! Re-scanning...';
+          healerScanStatus.style.borderColor = 'var(--tag-amber-fg)';
+        }
+        setTimeout(() => {
+          if (btnHealerScan) btnHealerScan.click();
+        }, 500);
+      } catch (err) {
+        alert('Failed to reset sample backend: ' + err.message);
+      } finally {
+        btnHealerResetSample.disabled = false;
+        btnHealerResetSample.textContent = 'Reset Sample to Vulnerable';
+      }
+    });
+  }
+
+  // 9. Live Request SSE Stream
+  function setupSSE() {
+    const eventSource = new EventSource('/_faultmesh/telemetry/stream');
+
+    eventSource.addEventListener('snapshot', (e) => {
+      try {
+        const data = JSON.parse(e.data);
+        if (data.events && data.events.length > 0) {
+          activityFeed.innerHTML = '';
+          data.events.forEach(addLogRow);
+        }
+      } catch (err) {
+        console.warn('Snapshot parse error', err);
+      }
+    });
+
+    eventSource.addEventListener('telemetry', (e) => {
+      try {
+        const event = JSON.parse(e.data);
+        addLogRow(event);
+        refreshStatus();
+      } catch (err) {
+        console.warn('Telemetry parse error', err);
+      }
+    });
+
+    eventSource.addEventListener('redteam-progress', (e) => {
+      try {
+        const status = JSON.parse(e.data);
+        updateRedTeamHud(status);
+      } catch (err) {
+        console.warn('Red team progress parse error', err);
+      }
+    });
+
+    eventSource.addEventListener('redteam-wave-start', (e) => {
+      try {
+        const payload = JSON.parse(e.data);
+        if (payload.wave) {
+          highlightActivePersona(payload.wave.personaId);
+        }
+        if (payload.status) {
+          updateRedTeamHud(payload.status);
+        }
+      } catch (err) {
+        console.warn('Red team wave start parse error', err);
+      }
+    });
+
+    eventSource.addEventListener('redteam-log', (e) => {
+      try {
+        const log = JSON.parse(e.data);
+        appendRedTeamLog(log);
+      } catch (err) {
+        console.warn('Red team log parse error', err);
+      }
+    });
+
+    eventSource.addEventListener('redteam-breach', (e) => {
+      try {
+        const payload = JSON.parse(e.data);
+        if (payload.status) {
+          updateRedTeamHud(payload.status);
+        }
+      } catch (err) {
+        console.warn('Red team breach parse error', err);
+      }
+    });
+
+    eventSource.addEventListener('redteam-complete', (e) => {
+      try {
+        const payload = JSON.parse(e.data);
+        if (payload.report) {
+          renderRedTeamDossier(payload.report);
+        }
+        if (payload.status) {
+          updateRedTeamHud(payload.status);
+        }
+        stopRedTeamPolling();
+      } catch (err) {
+        console.warn('Red team complete parse error', err);
+      }
+    });
+  }
+
+  function addLogRow(ev) {
+    if (activityFeed.querySelector('.table-empty')) {
+      activityFeed.innerHTML = '';
+    }
+
+    const tr = document.createElement('tr');
+    let codeClass = 'code-2xx';
+    if (ev.statusCode >= 500) codeClass = 'code-5xx';
+    else if (ev.statusCode >= 400) codeClass = 'code-4xx';
+
+    const ruleText = ev.appliedToxics && ev.appliedToxics.length > 0
+      ? ev.appliedToxics.join(', ')
       : 'None';
 
     tr.innerHTML = `
@@ -986,13 +2310,456 @@ document.addEventListener('DOMContentLoaded', () => {
     activityFeed.innerHTML = '<tr><td colspan="5" class="table-empty">Log cleared. Listening for requests...</td></tr>';
   });
 
+  // =========================================================================
+  // AUTONOMOUS RED CHAOS TEAM ENGINE CONTROLLER
+  // =========================================================================
+
+  async function loadRedTeamPersonas() {
+    if (!redTeamPersonasGrid) return;
+    try {
+      const res = await fetch('/_faultmesh/redteam/personas');
+      if (!res.ok) return;
+      const data = await res.json();
+      if (data.personas && data.personas.length > 0) {
+        redTeamPersonasGrid.innerHTML = data.personas.map(p => `
+          <div class="persona-card" data-persona="${escapeHtml(p.id)}">
+            <div class="persona-top">
+              <span class="persona-callsign">${escapeHtml(p.callSign || 'AGENT')}</span>
+              <span class="persona-role-tag">${escapeHtml(p.specialty || 'Chaos')}</span>
+            </div>
+            <strong class="persona-name">${escapeHtml(p.name)}</strong>
+            <p class="persona-desc">${escapeHtml(p.description)}</p>
+          </div>
+        `).join('');
+      }
+    } catch (err) {
+      console.warn('Failed to load personas from bridge:', err);
+    }
+  }
+
+  async function refreshRedTeamStatus() {
+    try {
+      const res = await fetch('/_faultmesh/redteam/status');
+      if (!res.ok) return;
+      const status = await res.json();
+      if (status.active) {
+        if (redTeamHud) redTeamHud.style.display = 'flex';
+        if (redTeamDossier) redTeamDossier.style.display = 'none';
+        if (btnLaunchRedTeam) btnLaunchRedTeam.style.display = 'none';
+        if (btnAbortRedTeam) btnAbortRedTeam.style.display = 'inline-flex';
+        updateRedTeamHud(status);
+        startRedTeamPolling();
+      } else if (status.phase === 'complete') {
+        const repRes = await fetch('/_faultmesh/redteam/report');
+        if (repRes.ok) {
+          const report = await repRes.json();
+          if (report.campaignId) {
+            renderRedTeamDossier(report);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn('Failed to check red team status:', err);
+    }
+  }
+
+  async function startRedTeamCampaign() {
+    if (!btnLaunchRedTeam) return;
+    const intensity = redTeamIntensitySelect ? redTeamIntensitySelect.value : 'sustained';
+    // Probes must route through the Chaos Proxy so wave toxics are actively engaged
+    const targetUrl = 'http://127.0.0.1:3001';
+
+    btnLaunchRedTeam.style.display = 'none';
+    if (btnAbortRedTeam) btnAbortRedTeam.style.display = 'inline-flex';
+    if (redTeamHud) redTeamHud.style.display = 'flex';
+    if (redTeamDossier) redTeamDossier.style.display = 'none';
+
+    seenLogKeys.clear();
+    if (redTeamConsoleLogs) {
+      redTeamConsoleLogs.innerHTML = '';
+      appendRedTeamLog({
+        timestamp: Date.now(),
+        waveNumber: 0,
+        persona: 'RED-COMMAND',
+        message: `Deploying Autonomous Red Chaos Team [${intensity.toUpperCase()} assault mode] against ${targetUrl}...`,
+        type: 'info',
+      });
+    }
+
+    try {
+      const res = await fetch('/_faultmesh/redteam/start', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ intensity, targetUrl }),
+      });
+      const data = await res.json();
+      if (!res.ok || !data.success) {
+        alert('Failed to launch Red Team: ' + (data.error || 'Server error'));
+        btnLaunchRedTeam.style.display = 'inline-flex';
+        if (btnAbortRedTeam) btnAbortRedTeam.style.display = 'none';
+        return;
+      }
+      if (data.status) {
+        updateRedTeamHud(data.status);
+      }
+      startRedTeamPolling();
+    } catch (err) {
+      alert('Network error launching Red Team: ' + err.message);
+      btnLaunchRedTeam.style.display = 'inline-flex';
+      if (btnAbortRedTeam) btnAbortRedTeam.style.display = 'none';
+    }
+  }
+
+  async function abortRedTeamCampaign() {
+    if (btnAbortRedTeam) {
+      btnAbortRedTeam.disabled = true;
+      btnAbortRedTeam.textContent = 'Aborting...';
+    }
+    try {
+      await fetch('/_faultmesh/redteam/abort', { method: 'POST' });
+      stopRedTeamPolling();
+      appendRedTeamLog({
+        timestamp: Date.now(),
+        waveNumber: 0,
+        persona: 'COMMAND-ABORT',
+        message: 'Abort requested. Neutralized assault waves and flushed toxic proxy pipeline.',
+        type: 'warn',
+      });
+    } catch (err) {
+      console.warn('Abort error:', err);
+    } finally {
+      if (btnAbortRedTeam) {
+        btnAbortRedTeam.style.display = 'none';
+        btnAbortRedTeam.disabled = false;
+        btnAbortRedTeam.textContent = 'Abort Mission';
+      }
+      if (btnLaunchRedTeam) btnLaunchRedTeam.style.display = 'inline-flex';
+    }
+  }
+
+  function startRedTeamPolling() {
+    if (redTeamPollingInterval) return;
+    redTeamPollingInterval = setInterval(async () => {
+      try {
+        const res = await fetch('/_faultmesh/redteam/status');
+        if (!res.ok) return;
+        const status = await res.json();
+        updateRedTeamHud(status);
+        if (!status.active) {
+          stopRedTeamPolling();
+          if (btnLaunchRedTeam) btnLaunchRedTeam.style.display = 'inline-flex';
+          if (btnAbortRedTeam) btnAbortRedTeam.style.display = 'none';
+          if (status.phase === 'complete') {
+            const repRes = await fetch('/_faultmesh/redteam/report');
+            if (repRes.ok) {
+              const rep = await repRes.json();
+              if (rep.campaignId) renderRedTeamDossier(rep);
+            }
+          }
+        }
+      } catch (err) {
+        console.warn('Polling error:', err);
+      }
+    }, 1000);
+  }
+
+  function stopRedTeamPolling() {
+    if (redTeamPollingInterval) {
+      clearInterval(redTeamPollingInterval);
+      redTeamPollingInterval = null;
+    }
+  }
+
+  function updateRedTeamHud(status) {
+    if (!status) return;
+
+    if (redTeamProgressBar) {
+      redTeamProgressBar.style.width = `${status.progressPercent}%`;
+    }
+    if (redTeamProgressPercent) {
+      redTeamProgressPercent.textContent = `${status.progressPercent}%`;
+    }
+    if (redTeamCurrentWaveText) {
+      redTeamCurrentWaveText.textContent = status.currentWaveName || `Phase: ${status.phase}`;
+    }
+    if (redTeamActivePersonaPill) {
+      redTeamActivePersonaPill.textContent = status.activePersona ? `Active: ${status.activePersona}` : 'Standby';
+    }
+
+    if (redTeamProbesCount) redTeamProbesCount.textContent = status.probesSent;
+    if (status.breachesCount) {
+      if (redTeamCritCount) redTeamCritCount.textContent = status.breachesCount.critical;
+      if (redTeamHighCount) redTeamHighCount.textContent = status.breachesCount.high;
+      if (redTeamMedCount) redTeamMedCount.textContent = status.breachesCount.medium;
+    }
+
+    // Update phase step breadcrumbs
+    const steps = document.querySelectorAll('.phase-step');
+    const phaseOrder = ['recon', 'weaponize', 'assault', 'debrief', 'complete'];
+    const currentIdx = phaseOrder.indexOf(status.phase);
+
+    steps.forEach((step) => {
+      const p = step.getAttribute('data-phase');
+      const stepIdx = phaseOrder.indexOf(p);
+      step.classList.remove('active', 'completed');
+      if (stepIdx < currentIdx || status.phase === 'complete') {
+        step.classList.add('completed');
+      } else if (p === status.phase) {
+        step.classList.add('active');
+      }
+    });
+
+    if (status.latestLog && redTeamConsoleLogs) {
+      appendRedTeamLog(status.latestLog);
+    }
+  }
+
+  function highlightActivePersona(personaId) {
+    const cards = document.querySelectorAll('.persona-card');
+    cards.forEach(card => {
+      if (card.getAttribute('data-persona') === personaId) {
+        card.classList.add('persona-active');
+      } else {
+        card.classList.remove('persona-active');
+      }
+    });
+  }
+
+  const seenLogKeys = new Set();
+
+  function appendRedTeamLog(log) {
+    if (!redTeamConsoleLogs || !log || !log.message) return;
+    const logKey = `${log.timestamp || ''}_${log.waveNumber ?? ''}_${log.persona || ''}_${log.message}`;
+    if (seenLogKeys.has(logKey)) {
+      return;
+    }
+    seenLogKeys.add(logKey);
+    if (seenLogKeys.size > 200) {
+      const first = seenLogKeys.values().next().value;
+      if (first) seenLogKeys.delete(first);
+    }
+
+    const time = new Date(log.timestamp || Date.now()).toTimeString().split(' ')[0];
+    const line = document.createElement('div');
+    line.className = `terminal-line log-${log.type || 'info'}`;
+    line.textContent = `[${time}] [${log.persona || 'RED-TEAM'}] ${log.message}`;
+
+    redTeamConsoleLogs.appendChild(line);
+    while (redTeamConsoleLogs.children.length > 80) {
+      redTeamConsoleLogs.removeChild(redTeamConsoleLogs.firstChild);
+    }
+    redTeamConsoleLogs.scrollTop = redTeamConsoleLogs.scrollHeight;
+  }
+
+  function renderRedTeamDossier(report) {
+    lastRedTeamReport = report;
+    if (!redTeamDossier) return;
+
+    redTeamDossier.style.display = 'flex';
+    if (btnLaunchRedTeam) btnLaunchRedTeam.style.display = 'inline-flex';
+    if (btnAbortRedTeam) btnAbortRedTeam.style.display = 'none';
+
+    if (dossierScoreVal) dossierScoreVal.textContent = `${report.survivabilityScore}/100`;
+    if (dossierGradeVal) {
+      dossierGradeVal.textContent = `GRADE ${report.survivabilityGrade}`;
+      dossierGradeVal.className = `dossier-grade-tag grade-${report.survivabilityGrade}`;
+    }
+
+    if (dossierTitle) {
+      dossierTitle.textContent = `Mission Debrief: ${report.breachesFound.length} Breaches Identified`;
+    }
+    if (dossierSummaryText) {
+      dossierSummaryText.textContent = `System survivability score: ${report.survivabilityScore}/100 [Grade ${report.survivabilityGrade}]. Dispatched ${report.totalProbes} adversarial probes across ${report.totalWaves} compound assault waves in ${Math.round(report.durationMs / 1000)}s.`;
+    }
+    if (dossierFindingsCount) {
+      dossierFindingsCount.textContent = `${report.breachesFound.length} breaches found`;
+    }
+
+    if (dossierFindingsList) {
+      if (report.breachesFound.length === 0) {
+        dossierFindingsList.innerHTML = '<div class="empty-state">Zero breaches detected. Target system sustained all adversarial compound assault waves!</div>';
+      } else {
+        dossierFindingsList.innerHTML = report.breachesFound.map(b => `
+          <div class="breach-card severity-${b.severity}">
+            <div class="breach-card-top">
+              <div class="breach-title-wrap">
+                <span class="severity-pill severity-${b.severity}">${b.severity.toUpperCase()}</span>
+                <span class="breach-title">${escapeHtml(b.title)}</span>
+                <span class="category-pill">${escapeHtml(b.category)}</span>
+              </div>
+              <span class="persona-callsign">${escapeHtml(b.callSign || 'EXPLOIT')}</span>
+            </div>
+            <div class="breach-desc">${escapeHtml(b.impact)}</div>
+            <div class="breach-proof-box">
+              <div><strong>Target Endpoint:</strong> ${escapeHtml(b.endpoint)}</div>
+              <div><strong>Probe Response:</strong> Status ${b.proofOfBreach.responseStatus} in ${b.proofOfBreach.responseDurationMs}ms</div>
+              <div><strong>Evidence Snippet:</strong> ${escapeHtml(b.proofOfBreach.snippet || '(empty)')}</div>
+            </div>
+            <div>
+              <span class="breach-remedy"><strong>Remedy:</strong> ${escapeHtml(b.remediation)}</span>
+            </div>
+          </div>
+        `).join('');
+      }
+    }
+
+    redTeamDossier.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+  }
+
+  function autoHealDiscoveredBreaches() {
+    if (!lastRedTeamReport || !lastRedTeamReport.breachesFound || lastRedTeamReport.breachesFound.length === 0) {
+      alert('No active breaches in report to heal.');
+      return;
+    }
+
+    const failedCheckNames = Array.from(new Set(
+      lastRedTeamReport.breachesFound
+        .map(b => b.autoHealCheckKey)
+        .filter(Boolean)
+    ));
+
+    // Open healer modal and configure
+    if (healerProjectDir && (!healerProjectDir.value || healerProjectDir.value === '.')) {
+      healerProjectDir.value = 'examples/vulnerable-backend';
+    }
+    if (healerModal) {
+      healerModal.style.display = 'flex';
+    }
+    if (healerScanStatus) {
+      healerScanStatus.style.display = 'block';
+      healerScanStatus.innerHTML = `Loaded <strong>${failedCheckNames.length}</strong> targeted breaches from Red Team Dossier: <code>${failedCheckNames.join(', ')}</code>. Initializing CodeMod scanner...`;
+    }
+
+    setTimeout(() => {
+      if (btnHealerScan) {
+        btnHealerScan.click();
+      }
+    }, 400);
+  }
+
+  function exportDossier(format) {
+    if (!lastRedTeamReport) {
+      alert('No completed campaign report to export.');
+      return;
+    }
+
+    let content = '';
+    let filename = `faultmesh-redteam-dossier-${lastRedTeamReport.campaignId}.${format === 'json' ? 'json' : 'md'}`;
+    let type = format === 'json' ? 'application/json' : 'text/markdown';
+
+    if (format === 'json') {
+      content = JSON.stringify(lastRedTeamReport, null, 2);
+    } else {
+      content = [
+        `# FaultMesh Red Team Mission Debrief Dossier`,
+        ``,
+        `**Campaign ID:** ${lastRedTeamReport.campaignId}`,
+        `**Target URL:** ${lastRedTeamReport.targetUrl}`,
+        `**Intensity:** ${lastRedTeamReport.intensity.toUpperCase()}`,
+        `**Survivability Score:** ${lastRedTeamReport.survivabilityScore}/100 (Grade ${lastRedTeamReport.survivabilityGrade})`,
+        `**Probes Dispatched:** ${lastRedTeamReport.totalProbes}`,
+        `**Breaches Discovered:** ${lastRedTeamReport.breachesFound.length}`,
+        `**Duration:** ${Math.round(lastRedTeamReport.durationMs / 1000)} seconds`,
+        ``,
+        `## Active Personas`,
+        ...lastRedTeamReport.activePersonas.map(p => `- ${p}`),
+        ``,
+        `## Discovered Breaches`,
+        ...lastRedTeamReport.breachesFound.map((b, i) => [
+          `### ${i + 1}. [${b.severity.toUpperCase()}] ${b.title}`,
+          `- **Category:** ${b.category}`,
+          `- **Persona:** ${b.personaName} (${b.callSign})`,
+          `- **Endpoint:** ${b.endpoint}`,
+          `- **Impact:** ${b.impact}`,
+          `- **Remediation:** ${b.remediation}`,
+          `- **Evidence:** Status ${b.proofOfBreach.responseStatus} in ${b.proofOfBreach.responseDurationMs}ms - \`${b.proofOfBreach.snippet}\``,
+          ``,
+        ].join('\n')),
+      ].join('\n');
+    }
+
+    const blob = new Blob([content], { type });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+  }
+
+  if (btnLaunchRedTeam) btnLaunchRedTeam.addEventListener('click', startRedTeamCampaign);
+  if (btnAbortRedTeam) btnAbortRedTeam.addEventListener('click', abortRedTeamCampaign);
+  if (btnAutoHealBreaches) btnAutoHealBreaches.addEventListener('click', autoHealDiscoveredBreaches);
+  if (btnExportDossierMd) btnExportDossierMd.addEventListener('click', () => exportDossier('md'));
+  if (btnExportDossierJson) btnExportDossierJson.addEventListener('click', () => exportDossier('json'));
+
   function escapeHtml(str) {
     return String(str || '').replace(/[&<>"']/g, m => ({
       '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
     }[m]));
   }
 
+  // Synchronize Workbench Heights: Right column matches Left column perfectly
+  function syncWorkbenchHeights() {
+    const presetsCard = document.querySelector('.presets-card');
+    const customRuleCard = document.querySelector('.custom-rule-card');
+    const activeRulesCard = document.querySelector('.active-rules-card');
+    const responseInspector = document.getElementById('responseInspector');
+    const liveLogCard = document.querySelector('.live-log-card');
+    const leftWorkbenchCol = document.getElementById('leftWorkbenchCol');
+
+    if (!presetsCard || !customRuleCard || !activeRulesCard || !responseInspector || !liveLogCard) {
+      return;
+    }
+
+    if (window.innerWidth <= 1024) {
+      responseInspector.style.height = 'auto';
+      liveLogCard.style.height = 'auto';
+      return;
+    }
+
+    const presetsHeight = presetsCard.offsetHeight;
+    const customHeight = customRuleCard.offsetHeight;
+    const activeHeight = activeRulesCard.offsetHeight;
+
+    // Detect gap between cards in left column (default 16px)
+    let gap = 16;
+    if (leftWorkbenchCol) {
+      const colStyle = window.getComputedStyle(leftWorkbenchCol);
+      const parsedGap = parseFloat(colStyle.rowGap || colStyle.gap);
+      if (!isNaN(parsedGap) && parsedGap > 0) {
+        gap = parsedGap;
+      }
+    }
+
+    // 1. Response Inspector height matches the 1-Click Quick Presets card exactly
+    responseInspector.style.height = `${presetsHeight}px`;
+
+    // 2. Live Traffic Log starts at Custom Rule card and ends at Active Simulation Rules card
+    const targetLogHeight = customHeight + gap + activeHeight;
+    liveLogCard.style.height = `${targetLogHeight}px`;
+  }
+
+  if (typeof ResizeObserver !== 'undefined') {
+    const workbenchResizeObserver = new ResizeObserver(() => {
+      syncWorkbenchHeights();
+    });
+    const presetsEl = document.querySelector('.presets-card');
+    const customEl = document.querySelector('.custom-rule-card');
+    const activeEl = document.querySelector('.active-rules-card');
+    if (presetsEl) workbenchResizeObserver.observe(presetsEl);
+    if (customEl) workbenchResizeObserver.observe(customEl);
+    if (activeEl) workbenchResizeObserver.observe(activeEl);
+  }
+
+  window.addEventListener('resize', syncWorkbenchHeights);
+
   setDiagMode('resilience');
+  loadTargetUrl();
   refreshStatus();
   setupSSE();
+  // Initial height synchronization after DOM render
+  setTimeout(syncWorkbenchHeights, 50);
 });