fix: KDMA delete button asymmetric behavior and slider race conditions

- Fix asymmetric KDMA delete button logic to properly validate single-KDMA experiments
- Add canRemoveSpecificKDMA function for per-KDMA validation instead of global check
- Fix decimal formatting in experiment key construction (0.0 vs 0)
- Add race condition guard to prevent concurrent reloadPinnedRun calls
- Add comprehensive test for asymmetric delete button behavior
- Ensure exactly one delete button enabled when valid single-KDMA experiments exist

Resolves issues where:
1. Both delete buttons remained disabled when one should be enabled
2. Rapid slider changes caused 404 errors from concurrent HTTP requests
3. Experiment key lookup failed due to decimal format mismatch

Author: PaulHax

align_browser/static/app.js

@@ -1286,8 +1286,17 @@ document.addEventListener("DOMContentLoaded", () => {
       return;
     }
 
+    // Prevent concurrent reloads for the same run
+    if (run.isReloading) {
+      console.log(`Skipping reload for run ${runId} - already in progress`);
+      return;
+    }
+    
     console.log(`Reloading data for run ${runId}`);
 
+    // Mark as reloading to prevent concurrent requests
+    run.isReloading = true;
+    
     // Show loading state
     run.loadStatus = 'loading';
     updateComparisonDisplay();
@@ -1327,6 +1336,9 @@ document.addEventListener("DOMContentLoaded", () => {
     } catch (error) {
       console.error(`Failed to reload data for run ${runId}:`, error);
       run.loadStatus = 'error';
+    } finally {
+      // Clear the reloading flag
+      run.isReloading = false;
     }
 
     // Re-render the comparison table (current run data is unaffected)
@@ -1729,6 +1741,91 @@ document.addEventListener("DOMContentLoaded", () => {
            experiments[baseKey].scenarios[run.scenario];
   }
 
+  // Check if a specific KDMA can be removed from a run
+  function canRemoveSpecificKDMA(runId, kdmaType) {
+    const run = appState.pinnedRuns.get(runId);
+    if (!run) return false;
+    
+    const currentKDMAs = run.kdmaValues || {};
+    
+    // Create a copy of current KDMAs without the one we want to remove
+    const remainingKDMAs = { ...currentKDMAs };
+    delete remainingKDMAs[kdmaType];
+    
+    // If no KDMAs would remain, use the original canRemoveKDMAsForRun check
+    if (Object.keys(remainingKDMAs).length === 0) {
+      return canRemoveKDMAsForRun(runId);
+    }
+    
+    // Check if experiments exist with the remaining KDMAs for this specific scenario
+    // We need to directly check the manifest instead of using getValidOptionsForConstraints
+    // because that function might be too permissive
+    return checkExperimentExistsForScenario(run.scenario, run.admType, run.llmBackbone, remainingKDMAs);
+  }
+  
+  // Check if experiments exist for a specific scenario with given parameters
+  function checkExperimentExistsForScenario(scenario, admType, llmBackbone, kdmas) {
+    const experiments = manifest.experiment_keys || manifest;
+    
+    // Build the experiment key pattern to look for
+    const kdmaKeys = Object.keys(kdmas).sort(); // Sort for consistent ordering
+    let experimentKey = `${admType}_${llmBackbone}`;
+    
+    // Add KDMAs to the key
+    for (const kdmaName of kdmaKeys) {
+      const kdmaValue = kdmas[kdmaName];
+      // Ensure decimal format for consistency with manifest keys  
+      const formattedValue = typeof kdmaValue === 'number' ? kdmaValue.toFixed(1) : kdmaValue;
+      experimentKey += `_${kdmaName}-${formattedValue}`;
+    }
+    
+    
+    // Check if this experiment exists and has the target scenario
+    if (experiments[experimentKey] && 
+        experiments[experimentKey].scenarios && 
+        experiments[experimentKey].scenarios[scenario]) {
+      return true;
+    }
+    
+    // If direct key lookup fails, try all possible orderings of KDMAs
+    // since the experiment keys might have different KDMA ordering
+    if (kdmaKeys.length > 1) {
+      const permutations = getKDMAPermutations(kdmaKeys);
+      for (const permutation of permutations) {
+        let altKey = `${admType}_${llmBackbone}`;
+        for (const kdmaName of permutation) {
+          const kdmaValue = kdmas[kdmaName];
+          // Ensure decimal format for consistency with manifest keys  
+          const formattedValue = typeof kdmaValue === 'number' ? kdmaValue.toFixed(1) : kdmaValue;
+          altKey += `_${kdmaName}-${formattedValue}`;
+        }
+        
+        if (experiments[altKey] && 
+            experiments[altKey].scenarios && 
+            experiments[altKey].scenarios[scenario]) {
+          return true;
+        }
+      }
+    }
+    
+    return false;
+  }
+  
+  // Generate all permutations of KDMA keys for experiment key lookup
+  function getKDMAPermutations(kdmaKeys) {
+    if (kdmaKeys.length <= 1) return [kdmaKeys];
+    
+    const permutations = [];
+    for (let i = 0; i < kdmaKeys.length; i++) {
+      const rest = kdmaKeys.slice(0, i).concat(kdmaKeys.slice(i + 1));
+      const restPermutations = getKDMAPermutations(rest);
+      for (const perm of restPermutations) {
+        permutations.push([kdmaKeys[i]].concat(perm));
+      }
+    }
+    return permutations;
+  }
+
   // Create KDMA controls HTML for table cells
   function createKDMAControlsForRun(runId, currentKDMAs) {
     const run = appState.pinnedRuns.get(runId);
@@ -1812,8 +1909,8 @@ document.addEventListener("DOMContentLoaded", () => {
         
         <button class="table-kdma-remove-btn" 
                 onclick="removeKDMAFromRun('${runId}', '${kdmaType}')" 
-                ${!canRemoveKDMAsForRun(runId) ? 'disabled' : ''}
-                title="${!canRemoveKDMAsForRun(runId) ? 'No experiments available without KDMAs' : 'Remove KDMA'}">×</button>
+                ${!canRemoveSpecificKDMA(runId, kdmaType) ? 'disabled' : ''}
+                title="${!canRemoveSpecificKDMA(runId, kdmaType) ? 'No valid experiments exist without this KDMA' : 'Remove KDMA'}">×</button>
       </div>
     `;
   }

align_browser/test_frontend_real_data.py

@@ -264,8 +264,9 @@ def test_kdma_combination_default_value_issue(page, real_data_test_server):
     scenario_values = [opt.get_attribute("value") for opt in scenario_options if opt.get_attribute("value")]
     print(f"Available scenarios: {scenario_values}")
 
-    # Find a June2025-AF-train scenario
+    # Find a June2025-AF-train scenario (required for this test)
     june_scenarios = [s for s in scenario_values if "June2025-AF-train" in s]
+    assert len(june_scenarios) > 0, f"June2025-AF-train scenarios required for this test, but only found: {scenario_values}"
 
     scenario_select.select_option(june_scenarios[0])
     # Wait for scenario selection to take effect
@@ -282,6 +283,9 @@ def test_kdma_combination_default_value_issue(page, real_data_test_server):
     # Look for "Add KDMA" button
     add_kdma_button = page.locator(".add-kdma-btn")
 
+    # This test requires the ability to add a second KDMA
+    assert add_kdma_button.count() > 0, "Add KDMA button must be available for this test"
+    
     # Click Add KDMA button
     add_kdma_button.click()
 
@@ -322,3 +326,90 @@ def test_kdma_combination_default_value_issue(page, real_data_test_server):
     assert scenario_select_value != "", "Scenario select should not go blank after adding KDMA"
     assert "June2025-AF-train" in scenario_select_value, "Should still have June2025-AF-train scenario selected"
 
+
+def test_kdma_delete_button_enabled_after_adding_second_kdma(page, real_data_test_server):
+    """Test that KDMA delete buttons become enabled after adding a second KDMA when valid single-KDMA experiments exist."""
+    page.goto(real_data_test_server)
+    
+    # Wait for table to load
+    page.wait_for_selector(".comparison-table", timeout=10000)
+    page.wait_for_function(
+        "document.querySelectorAll('.table-adm-select').length > 0", timeout=10000
+    )
+    
+    # Select pipeline_baseline ADM to enable KDMA functionality 
+    adm_select = page.locator(".table-adm-select").first
+    adm_select.select_option("pipeline_baseline")
+    page.wait_for_load_state("networkidle")
+    
+    # Select June2025-AF-train scenario to get multi-KDMA support
+    scenario_select = page.locator(".table-scenario-select").first
+    
+    # Check what scenarios are available
+    scenario_options = scenario_select.locator("option").all()
+    scenario_values = [opt.get_attribute("value") for opt in scenario_options if opt.get_attribute("value")]
+    
+    # Find a June2025-AF-train scenario (required for this test)
+    june_scenarios = [s for s in scenario_values if "June2025-AF-train" in s]
+    assert len(june_scenarios) > 0, f"June2025-AF-train scenarios required for this test, but only found: {scenario_values}"
+    
+    scenario_select.select_option(june_scenarios[0])
+    page.wait_for_load_state("networkidle")
+    
+    # Check initial KDMA delete buttons - should be disabled with single KDMA
+    initial_delete_buttons = page.locator(".table-kdma-remove-btn")
+    initial_delete_count = initial_delete_buttons.count()
+    
+    # This test requires at least one initial delete button
+    assert initial_delete_count > 0, "Should have at least one delete button with initial KDMA"
+    
+    initial_button = initial_delete_buttons.first
+    initial_disabled = initial_button.is_disabled()
+    print(f"Initial delete button disabled: {initial_disabled}")
+    
+    # With single KDMA, delete button should be disabled (can't remove all KDMAs)
+    assert initial_disabled, "Delete button should be disabled with single KDMA"
+    
+    # Look for "Add KDMA" button
+    add_kdma_button = page.locator(".add-kdma-btn")
+    
+    # This test requires the ability to add a second KDMA
+    assert add_kdma_button.count() > 0, "Add KDMA button must be available for this test"
+    
+    # Click Add KDMA button to add second KDMA
+    add_kdma_button.click()
+    
+    # Wait for new KDMA slider to be added
+    page.wait_for_function(
+        "document.querySelectorAll('.table-kdma-value-slider').length > 1",
+        timeout=5000
+    )
+    
+    # Now check delete buttons after adding second KDMA
+    updated_delete_buttons = page.locator(".table-kdma-remove-btn")
+    updated_delete_count = updated_delete_buttons.count()
+    
+    assert updated_delete_count > 1, "Should have delete buttons for multiple KDMAs"
+    
+    # Check delete button states for asymmetric KDMA deletion
+    # With two KDMAs (affiliation + merit) for June2025-AF-train scenario:
+    # - affiliation alone: experiments exist for this scenario ✅
+    # - merit alone: experiments DON'T exist for this scenario (they exist for June2025-MF-train) ❌
+    # Therefore: only merit KDMA should be deletable (leaving affiliation alone)
+    all_delete_buttons = updated_delete_buttons.all()
+    assert len(all_delete_buttons) == 2, f"Should have exactly 2 delete buttons for 2 KDMAs, got {len(all_delete_buttons)}"
+    
+    disabled_states = [btn.is_disabled() for btn in all_delete_buttons]
+    print(f"Delete buttons disabled states: {disabled_states}")
+    
+    # Expected behavior: exactly one delete button enabled, one disabled
+    # The merit KDMA should be deletable (disabled=False, leaving affiliation alone)
+    # The affiliation KDMA should NOT be deletable (disabled=True, merit alone doesn't exist for this scenario)
+    enabled_count = sum(1 for disabled in disabled_states if not disabled)
+    disabled_count = sum(1 for disabled in disabled_states if disabled)
+    
+    assert enabled_count == 1, f"Expected exactly 1 enabled delete button for June2025-AF-train scenario, but got {enabled_count} enabled buttons: {disabled_states}"
+    assert disabled_count == 1, f"Expected exactly 1 disabled delete button for June2025-AF-train scenario, but got {disabled_count} disabled buttons: {disabled_states}"
+    
+    print("✓ Correctly identified asymmetric KDMA deletion: one deletable, one not")
+