Improve runs table UX and fix decider batch naming

- Rename "Add Selected to Comparison" to "Compare Selected" and replace
  existing runs instead of appending
- Rename "Clear All" to "Delete All" for consistency
- Add "Clear Filters" button in toolbar and no-data state
- Fix decider naming to use batch folder name consistently
- Improve alignment comparison by comparing only value and score

Author: PaulHax

align_app/adm/decider_definitions.py

@@ -237,7 +237,7 @@ def get_system_prompt(
     """Generate system prompt for a decider with given alignment target."""
     decider_main_config = all_deciders.get(decider)
     if not decider_main_config:
-        raise ValueError(f"Decider '{decider}' not found in all_deciders configuration")
+        return "Decider configuration not available"
 
     generate_sys_prompt = decider_main_config.get("system_prompt_generator")
     if not generate_sys_prompt:

align_app/adm/experiment_converters.py

@@ -1,8 +1,5 @@
 """Pure functions to convert experiment data to domain types."""
 
-import copy
-import hashlib
-import json
 import uuid
 from pathlib import Path
 from typing import List, Dict, Any, Optional
@@ -22,6 +19,21 @@
 from .run_models import Run, RunDecision
 
 
+def get_decider_batch_name(experiment_path: Path, root_path: Path) -> str:
+    """Derive decider batch name from experiment path depth relative to root.
+
+    Depth 1: experiment folder IS the batch (flat structure)
+    Depth 2+: parent folder is the batch (nested with alignment subdirs)
+    """
+    relative = experiment_path.relative_to(root_path)
+    depth = len(relative.parts)
+
+    if depth == 1:
+        return experiment_path.name
+    else:
+        return experiment_path.parent.name
+
+
 def probes_from_experiment_items(items: List[ExperimentItem]) -> List[Probe]:
     """Convert experiment items to probes, deduping by probe_id."""
     seen = set()
@@ -36,79 +48,46 @@ def probes_from_experiment_items(items: List[ExperimentItem]) -> List[Probe]:
 
 def deciders_from_experiments(
     experiments: List[ExperimentData],
+    root_path: Path,
 ) -> Dict[str, Dict[str, Any]]:
-    """Extract unique decider configs from experiments.
+    """Extract deciders from experiments, one per unique decider batch name.
 
     Returns dict: {decider_name: decider_entry}
     """
-    seen_hashes: Dict[str, tuple] = {}
+    deciders: Dict[str, Dict[str, Any]] = {}
 
     sorted_experiments = sorted(experiments, key=lambda e: str(e.experiment_path))
     for exp in sorted_experiments:
+        decider_batch = get_decider_batch_name(exp.experiment_path, root_path)
+        if decider_batch in deciders:
+            continue
+
         adm_config = load_experiment_adm_config(exp.experiment_path)
         if adm_config is None:
             continue
 
-        normalized = _normalize_adm_config(adm_config)
-        config_hash = _hash_config(normalized)
-
-        if config_hash not in seen_hashes:
-            exp_name = exp.experiment_path.parent.name
-
-            if "structured_inference_engine" in adm_config:
-                experiment_llm = adm_config["structured_inference_engine"].get(
-                    "model_name"
-                )
-                llm_backbones = (
-                    [experiment_llm]
-                    + [llm for llm in LLM_BACKBONES if llm != experiment_llm]
-                    if experiment_llm
-                    else list(LLM_BACKBONES)
-                )
-            else:
-                llm_backbones = []
-
-            decider_entry = {
-                "experiment_path": str(exp.experiment_path),
-                "experiment_config": True,
-                "llm_backbones": llm_backbones,
-                "max_alignment_attributes": 10,
-            }
-            seen_hashes[config_hash] = (exp_name, decider_entry)
-
-    return {name: entry for name, entry in seen_hashes.values()}
-
-
-def _normalize_adm_config(config: Dict[str, Any]) -> Dict[str, Any]:
-    """Normalize config for comparison by stripping absolute paths to filenames."""
-    normalized = copy.deepcopy(config)
-    _normalize_paths_recursive(normalized)
-    return normalized
-
-
-def _normalize_paths_recursive(obj: Any) -> None:
-    """Recursively normalize path-like strings to just filenames."""
-    if isinstance(obj, dict):
-        for key, value in obj.items():
-            if isinstance(value, str) and "/" in value and value.endswith(".json"):
-                obj[key] = Path(value).name
-            else:
-                _normalize_paths_recursive(value)
-    elif isinstance(obj, list):
-        for i, item in enumerate(obj):
-            if isinstance(item, str) and "/" in item and item.endswith(".json"):
-                obj[i] = Path(item).name
-            else:
-                _normalize_paths_recursive(item)
-
-
-def _hash_config(config: Dict[str, Any]) -> str:
-    """Create deterministic hash of config dict."""
-    config_str = json.dumps(config, sort_keys=True)
-    return hashlib.sha256(config_str.encode()).hexdigest()[:16]
-
-
-def run_from_experiment_item(item: ExperimentItem) -> Optional[Run]:
+        if "structured_inference_engine" in adm_config:
+            experiment_llm = adm_config["structured_inference_engine"].get("model_name")
+            llm_backbones = (
+                [experiment_llm]
+                + [llm for llm in LLM_BACKBONES if llm != experiment_llm]
+                if experiment_llm
+                else list(LLM_BACKBONES)
+            )
+        else:
+            llm_backbones = []
+
+        deciders[decider_batch] = {
+            "experiment_path": str(exp.experiment_path),
+            "experiment_config": True,
+            "llm_backbones": llm_backbones,
+            "max_alignment_attributes": 10,
+        }
+
+    return deciders
+
+
+def run_from_experiment_item(item: ExperimentItem, root_path: Path) -> Optional[Run]:
     """Convert ExperimentItem to Run with decision populated."""
     if not item.item.output:
         return None
@@ -134,19 +113,21 @@ def run_from_experiment_item(item: ExperimentItem) -> Optional[Run]:
         choice_index=output.choice,
     )
 
-    decider_name = item.experiment_path.parent.name
+    decider_batch = get_decider_batch_name(item.experiment_path, root_path)
 
     return Run(
         id=str(uuid.uuid4()),
         probe_id=probe_id,
-        decider_name=decider_name,
+        decider_name=decider_batch,
         llm_backbone_name=item.config.adm.llm_backbone or "N/A",
         system_prompt="",
         decider_params=decider_params,
         decision=decision,
     )
 
 
-def runs_from_experiment_items(items: List[ExperimentItem]) -> List[Run]:
+def runs_from_experiment_items(
+    items: List[ExperimentItem], root_path: Path
+) -> List[Run]:
     """Convert experiment items to runs, filtering out items without output."""
-    return [run for item in items if (run := run_from_experiment_item(item))]
+    return [run for item in items if (run := run_from_experiment_item(item, root_path))]

align_app/app/import_experiments.py

@@ -20,6 +20,7 @@
 
 from ..adm.experiment_converters import (
     deciders_from_experiments,
+    get_decider_batch_name,
     probes_from_experiment_items,
 )
 from ..adm.experiment_config_loader import load_experiment_adm_config
@@ -36,6 +37,7 @@ class StoredExperimentItem:
     item: ExperimentItem
     resolved_config: Dict
     cache_key: str
+    decider_batch: str
 
 
 @dataclass
@@ -59,13 +61,18 @@ def import_experiments(experiments_path: Path) -> ExperimentImportResult:
     ]
 
     probes = probes_from_experiment_items(all_items)
-    deciders = deciders_from_experiments(experiments)
+    deciders = deciders_from_experiments(experiments, experiments_path)
 
     items: Dict[str, StoredExperimentItem] = {}
     for item in all_items:
         resolved_config = load_experiment_adm_config(item.experiment_path) or {}
-        cache_key = compute_experiment_item_cache_key(item, resolved_config)
-        items[cache_key] = StoredExperimentItem(item, resolved_config, cache_key)
+        decider_batch = get_decider_batch_name(item.experiment_path, experiments_path)
+        cache_key = compute_experiment_item_cache_key(
+            item, resolved_config, decider_batch
+        )
+        items[cache_key] = StoredExperimentItem(
+            item, resolved_config, cache_key, decider_batch
+        )
 
     print(f"Loaded {len(items)} experiment items from {len(experiments)} experiments")
     return ExperimentImportResult(probes, deciders, items)
@@ -114,12 +121,10 @@ def run_from_stored_experiment_item(stored: StoredExperimentItem) -> Optional[Ru
         choice_index=output.choice,
     )
 
-    decider_name = item.experiment_path.parent.name
-
     return Run(
         id=str(uuid.uuid4()),
         probe_id=probe_id,
-        decider_name=decider_name,
+        decider_name=stored.decider_batch,
         llm_backbone_name=item.config.adm.llm_backbone or "N/A",
         system_prompt="",
         decider_params=decider_params,

align_app/app/runs_presentation.py

@@ -17,13 +17,13 @@
 def compute_experiment_item_cache_key(
     item: ExperimentItem,
     resolved_config: Dict[str, Any],
+    decider_batch: str,
 ) -> str:
     """Compute cache_key for an experiment item (same as Run.compute_cache_key).
 
     Takes resolved_config as param since it must be loaded while paths are valid.
     """
     probe_id = get_probe_id(item.item)
-    decider_name = item.experiment_path.parent.name
     llm_backbone = item.config.adm.llm_backbone or "N/A"
 
     decider_params = DeciderParams(
@@ -32,11 +32,11 @@ def compute_experiment_item_cache_key(
         resolved_config=resolved_config,
     )
 
-    return hash_run_params(probe_id, decider_name, llm_backbone, decider_params)
+    return hash_run_params(probe_id, decider_batch, llm_backbone, decider_params)
 
 
 def experiment_item_to_table_row(
-    item: ExperimentItem, cache_key: str
+    item: ExperimentItem, cache_key: str, decider_batch: str
 ) -> Dict[str, Any]:
     """Convert ExperimentItem to table row format."""
     scene_id = ""
@@ -52,7 +52,7 @@ def experiment_item_to_table_row(
 
     kdma_values = item.config.alignment_target.kdma_values
     alignment_summary = (
-        ", ".join(f"{kv.kdma} {kv.value}" for kv in kdma_values)
+        ", ".join(f"{readable(kv.kdma)} {kv.value}" for kv in kdma_values)
         if kdma_values
         else "None"
     )
@@ -66,7 +66,7 @@ def experiment_item_to_table_row(
         "scenario_id": item.item.input.scenario_id,
         "scene_id": scene_id,
         "probe_text": display_state,
-        "decider_name": item.config.adm.name,
+        "decider_name": decider_batch,
         "llm_backbone_name": item.config.adm.llm_backbone or "N/A",
         "alignment_summary": alignment_summary,
         "decision_text": decision_text,

align_app/app/runs_state_adapter.py

@@ -80,7 +80,7 @@ def _sync_from_runs_data(self, runs_dict: Dict[str, Run]):
         stored_items = self.runs_registry.get_all_experiment_items()
         experiment_table_rows = [
             runs_presentation.experiment_item_to_table_row(
-                stored.item, stored.cache_key
+                stored.item, stored.cache_key, stored.decider_batch
             )
             for cache_key, stored in stored_items.items()
             if cache_key not in active_cache_keys
@@ -607,7 +607,7 @@ def add_selected_runs_to_compare(self):
         if not selected:
             return
 
-        existing = list(self.state.runs_to_compare)
+        new_runs_to_compare = []
 
         for item in selected:
             cache_key = item["id"] if isinstance(item, dict) else item
@@ -617,10 +617,10 @@ def add_selected_runs_to_compare(self):
             if not run:
                 run = self.runs_registry.materialize_experiment_item(cache_key)
 
-            if run and run.id not in existing:
-                existing.append(run.id)
+            if run and run.id not in new_runs_to_compare:
+                new_runs_to_compare.append(run.id)
 
-        self.state.runs_to_compare = existing
+        self.state.runs_to_compare = new_runs_to_compare
         self.state.runs_table_modal_open = False
         self.state.runs_table_selected = []
         self._sync_from_runs_data(self.runs_registry.get_all_runs())

align_app/app/runs_table_filter.py

@@ -66,6 +66,7 @@ class RunsTableFilter:
     def __init__(self, server):
         self.server = server
         self._all_rows: List[Dict[str, Any]] = []
+        self.controller = server.controller
 
         self.state.runs_table_filter_scenario = []
         self.state.runs_table_filter_scene = []
@@ -74,6 +75,8 @@ def __init__(self, server):
         self.state.runs_table_filter_alignment = []
         self.state.runs_table_filter_decision = []
 
+        self.controller.set("clear_all_table_filters")(self.clear_all_filters)
+
         self.state.runs_table_scenario_options = []
         self.state.runs_table_scene_options = []
         self.state.runs_table_decider_options = []
@@ -112,3 +115,12 @@ def _apply_filters(self):
             for state_key, col_key in FILTER_COLUMNS
         ]
         self.state.runs_table_items = filter_rows(self._all_rows, filters)
+
+    def clear_all_filters(self):
+        self.state.runs_table_filter_scenario = []
+        self.state.runs_table_filter_scene = []
+        self.state.runs_table_filter_decider = []
+        self.state.runs_table_filter_llm = []
+        self.state.runs_table_filter_alignment = []
+        self.state.runs_table_filter_decision = []
+        self.state.runs_table_search = ""