Fix UI tag-button desync and add regression smoke coverage

app.py

@@ -4,7 +4,6 @@ import logging
 import time
 import json
 import csv
-import base64
 from datetime import datetime
 from functools import lru_cache
 from PIL import Image
@@ -68,53 +67,9 @@ def _normalize_selection_origin(origin: str) -> str:
     return "selection"
 
 
-@lru_cache(maxsize=1)
-def _load_tag_wiki_defs() -> Dict[str, str]:
-    p = Path("data/tag_wiki_defs.json")
-    if not p.exists():
-        return {}
-    try:
-        with p.open("r", encoding="utf-8") as f:
-            data = json.load(f)
-        out: Dict[str, str] = {}
-        if isinstance(data, dict):
-            for k, v in data.items():
-                tag = _norm_tag_for_lookup(str(k))
-                text = " ".join(str(v or "").split())
-                if tag and text:
-                    out[tag] = text
-        return out
-    except Exception:
-        return {}
-
-
-def _tooltip_text_for_tag(tag: str) -> str:
-    t = _norm_tag_for_lookup(tag)
-    parts: List[str] = []
-
-    try:
-        count = get_tag_counts().get(t)
-    except Exception:
-        count = None
-    if isinstance(count, int):
-        parts.append(f"Count: {count:,}")
-
-    d = _load_tag_wiki_defs().get(t, "")
-    if d:
-        parts.append(d)
-
-    return "\n".join(parts).strip()
-
-
 def _choice_label_with_source_meta(tag: str, *, origin: str, preselected: bool) -> str:
-    # Marker is stripped client-side and converted into data attributes for CSS-driven colors/tooltips.
-    origin_norm = _normalize_selection_origin(origin)
-    pre = "1" if preselected else "0"
-    tooltip = _tooltip_text_for_tag(tag)
-    tip_b64 = ""
-    if tooltip:
-        tip_b64 = base64.urlsafe_b64encode(tooltip.encode("utf-8")).decode("ascii")
-    return f"{_display_tag_text(tag)} [[psq:{origin_norm}:{pre}:{tip_b64}]]"
+    # Keep labels plain to avoid frontend text/value desynchronization.
+    return _display_tag_text(tag)
 
 
 def _selection_source_rank(origin: str) -> int:
@@ -219,20 +174,15 @@ def _escape_prompt_tag(tag: str) -> str:
     )
 
 
-def _ordered_selected_for_prompt(selected: Set[str], row_defs: List[Dict[str, Any]]) -> List[str]:
-    out: List[str] = []
-    seen: Set[str] = set()
-    for row in row_defs:
-        for tag in row.get("tags", []):
-            if tag in selected and tag not in seen:
-                out.append(tag)
-                seen.add(tag)
-    # Fallback for any selected tags not present in current rows.
-    for tag in sorted(selected):
-        if tag not in seen:
-            out.append(tag)
-            seen.add(tag)
-    return out
+def _ordered_selected_for_prompt(selected: Set[str], row_defs: List[Dict[str, Any]]) -> List[str]:
+    out: List[str] = []
+    seen: Set[str] = set()
+    for row in row_defs:
+        for tag in row.get("tags", []):
+            if tag in selected and tag not in seen:
+                out.append(tag)
+                seen.add(tag)
+    return out
 
 
 def _compose_toggle_prompt_text(selected_tags: List[str], row_defs: List[Dict[str, Any]]) -> str:
@@ -308,7 +258,7 @@ def _filter_min_count_tags(tags: List[str], min_count: int) -> Tuple[List[str],
     return keep, sorted(set(removed))
 
 
-def _filter_excluded_recommendation_tags(tags: List[str]) -> Tuple[List[str], List[str]]:
+def _filter_excluded_recommendation_tags(tags: List[str]) -> Tuple[List[str], List[str]]:
     excluded = _load_excluded_recommendation_tags()
     if not excluded:
         return list(dict.fromkeys(_norm_tag_for_lookup(t) for t in (tags or []) if t)), []
@@ -327,9 +277,79 @@ def _filter_excluded_recommendation_tags(tags: List[str]) -> Tuple[List[str], Li
             continue
         seen.add(t)
         keep.append(t)
-    return keep, sorted(set(removed))
-
-
+    return keep, sorted(set(removed))
+
+
+def _dedupe_norm_tags(tags: List[str]) -> List[str]:
+    out: List[str] = []
+    seen: Set[str] = set()
+    for raw in (tags or []):
+        t = _norm_tag_for_lookup(str(raw))
+        if not t or t in seen:
+            continue
+        seen.add(t)
+        out.append(t)
+    return out
+
+
+def _collect_visible_tags(row_defs: List[Dict[str, Any]]) -> Set[str]:
+    out: Set[str] = set()
+    for row in (row_defs or []):
+        for t in _dedupe_norm_tags(row.get("tags", []) if isinstance(row, dict) else []):
+            out.add(t)
+    return out
+
+
+def _collect_selected_from_state(
+    selected_tags_state: List[str],
+    row_defs: List[Dict[str, Any]],
+) -> List[str]:
+    visible_tags = _collect_visible_tags(row_defs)
+    if not visible_tags:
+        return []
+    selected: List[str] = []
+    seen: Set[str] = set()
+    visible_by_norm = {_norm_tag_for_lookup(t): t for t in visible_tags}
+    for raw in (selected_tags_state or []):
+        t = _norm_tag_for_lookup(str(raw))
+        if not t:
+            continue
+        mapped = t if t in visible_tags else visible_by_norm.get(t)
+        if not mapped or mapped in seen:
+            continue
+        seen.add(mapped)
+        selected.append(mapped)
+    return selected
+
+
+def _collect_selected_from_row_values(
+    row_defs: List[Dict[str, Any]],
+    row_values_state: List[List[str]],
+) -> List[str]:
+    selected: List[str] = []
+    seen: Set[str] = set()
+    values = list(row_values_state or [])
+    for idx, row in enumerate(row_defs or []):
+        row_tags = _dedupe_norm_tags(row.get("tags", []) if isinstance(row, dict) else [])
+        if not row_tags:
+            continue
+        row_tag_set = set(row_tags)
+        row_tag_by_norm = {_norm_tag_for_lookup(t): t for t in row_tags}
+        raw_vals = values[idx] if 0 <= idx < len(values) else []
+        for raw in (raw_vals or []):
+            if raw in row_tag_set:
+                if raw not in seen:
+                    seen.add(raw)
+                    selected.append(raw)
+                continue
+            raw_norm = _norm_tag_for_lookup(str(raw))
+            mapped = row_tag_by_norm.get(raw_norm)
+            if mapped and mapped not in seen:
+                seen.add(mapped)
+                selected.append(mapped)
+    return selected
+
+
 def _build_toggle_rows(
     *,
     seed_terms: List[str],
@@ -400,6 +420,7 @@ def _build_toggle_rows(
         merged_retrieved_other = selected_in_retrieved_other + [
             t for t in retrieved_uncategorized_ranked if t not in selected_in_retrieved_other
         ]
+        merged_retrieved_other = _dedupe_norm_tags(merged_retrieved_other)
         keep_n = max(max(1, int(top_tags_per_group)), len(selected_in_retrieved_other))
         merged_retrieved_other = merged_retrieved_other[:keep_n]
         retrieved_other_meta = {
@@ -428,6 +449,7 @@ def _build_toggle_rows(
         tag_selection_origins=tag_selection_origins,
         implied_parent_map=implied_parent_map,
     )
+    selected_other = _dedupe_norm_tags(selected_other)
     selected_other_meta = {
         t: {
             "origin": _normalize_selection_origin(tag_selection_origins.get(t, "selection")),
@@ -454,12 +476,14 @@ def _build_toggle_rows(
             tag_selection_origins=tag_selection_origins,
             implied_parent_map=implied_parent_map,
         )
-        ranked_tags = [
-            t
-            for t, _ in row.tags
-            if not _is_artist_tag(t) and not _is_excluded_recommendation_tag(t)
-        ]
+        ranked_tags = [
+            _norm_tag_for_lookup(t)
+            for t, _ in row.tags
+            if t and not _is_artist_tag(t) and not _is_excluded_recommendation_tag(t)
+        ]
+        ranked_tags = _dedupe_norm_tags(ranked_tags)
         merged = selected_in_group + [t for t in ranked_tags if t not in selected_in_group]
+        merged = _dedupe_norm_tags(merged)
         keep_n = max(max(1, int(top_tags_per_group)), len(selected_in_group))
         merged = merged[:keep_n]
         tag_meta = {
@@ -545,17 +569,18 @@ def _build_display_audit_line(
 def _build_row_component_updates(
     row_defs: List[Dict[str, Any]],
     selected_tags: List[str],
-    max_rows: int,
-):
-    selected = {t for t in (selected_tags or []) if t}
-    row_values_state: List[List[str]] = []
-    header_updates = []
-    checkbox_updates = []
-
-    for idx in range(max_rows):
-        if idx < len(row_defs):
-            row = row_defs[idx]
-            tags = list(dict.fromkeys(row.get("tags", [])))
+    max_rows: int,
+):
+    selected = {t for t in (selected_tags or []) if t}
+    row_defs_ui = (row_defs or [])[: max(0, int(max_rows))]
+    row_values_state: List[List[str]] = []
+    header_updates = []
+    checkbox_updates = []
+
+    for idx in range(max_rows):
+        if idx < len(row_defs_ui):
+            row = row_defs_ui[idx]
+            tags = _dedupe_norm_tags(row.get("tags", []))
             values = [t for t in tags if t in selected]
             row_values_state.append(values)
             visible = bool(tags)
@@ -574,33 +599,51 @@ def _build_row_component_updates(
                     visible=visible,
                 )
             )
-        else:
-            header_updates.append(gr.update(value="", visible=False))
-            checkbox_updates.append(gr.update(choices=[], value=[], visible=False))
-
-    prompt_text = _compose_toggle_prompt_text(list(selected), row_defs)
-    return prompt_text, row_values_state, header_updates, checkbox_updates
+        else:
+            header_updates.append(gr.update(value="", visible=False))
+            checkbox_updates.append(gr.update(choices=[], value=[], visible=False))
+
+    prompt_text = _compose_toggle_prompt_text(list(selected), row_defs_ui)
+    return prompt_text, row_values_state, header_updates, checkbox_updates
 
 
 def _on_toggle_row(
     row_idx: int,
     changed_values: List[str],
     selected_tags_state: List[str],
-    row_defs_state: List[Dict[str, Any]],
-    row_values_state: List[List[str]],
-    max_rows: int,
+    rows_dirty_state: bool,
+    row_defs_state: List[Dict[str, Any]],
+    row_values_state: List[List[str]],
+    max_rows: int,
 ):
     row_defs = row_defs_state or []
     row_defs_ui = row_defs[: max(0, int(max_rows))]
-    selected = set(selected_tags_state or [])
+    prev_values = list(row_values_state or [])
+    selected_from_state = _collect_selected_from_state(selected_tags_state, row_defs_ui)
+    selected_from_rows = _collect_selected_from_row_values(row_defs_ui, prev_values)
+    # Prefer row-value state as source-of-truth (closest to visible UI), with selected-state as fallback.
+    selected: Set[str] = set(selected_from_rows or selected_from_state)
+
     row = row_defs_ui[row_idx] if 0 <= row_idx < len(row_defs_ui) else {}
-    row_tags = list(dict.fromkeys(row.get("tags", [])))
+    row_tags = _dedupe_norm_tags(row.get("tags", []))
+    row_label = str(row.get("label", ""))
     row_tag_set = set(row_tags)
     row_tag_by_norm = {_norm_tag_for_lookup(t): t for t in row_tags}
 
+    # Be tolerant to UI payload forms: canonical tag values, display labels, normalized variants,
+    # and occasional single-string payloads from frontend events.
+    if changed_values is None:
+        changed_iter: List[Any] = []
+    elif isinstance(changed_values, str):
+        changed_iter = [changed_values]
+    elif isinstance(changed_values, (list, tuple, set)):
+        changed_iter = list(changed_values)
+    else:
+        changed_iter = [changed_values]
+
     # Be tolerant to UI payload forms: canonical tag values, display labels, or normalized variants.
     new_set: Set[str] = set()
-    for raw in (changed_values or []):
+    for raw in changed_iter:
         if raw in row_tag_set:
             new_set.add(raw)
             continue
@@ -609,23 +652,13 @@ def _on_toggle_row(
         if mapped:
             new_set.add(mapped)
 
-    prev_values = list(row_values_state or [])
-    prev_row_values = prev_values[row_idx] if 0 <= row_idx < len(prev_values) else []
-    prev_row_selected = set()
-    for raw in (prev_row_values or []):
-        if raw in row_tag_set:
-            prev_row_selected.add(raw)
-            continue
-        raw_norm = _norm_tag_for_lookup(str(raw))
-        mapped = row_tag_by_norm.get(raw_norm)
-        if mapped:
-            prev_row_selected.add(mapped)
+    prev_row_selected = {t for t in row_tags if t in selected}
 
     # Ignore non-user/no-op events (e.g., programmatic value re-sets) deterministically.
     if new_set == prev_row_selected:
         prompt_text = _compose_toggle_prompt_text(sorted(selected), row_defs_ui)
         checkbox_updates = [gr.skip() for _ in range(max_rows)]
-        return [sorted(selected), prev_values, prompt_text, *checkbox_updates]
+        return [sorted(selected), rows_dirty_state, gr.skip(), prev_values, prompt_text, *checkbox_updates]
 
     selected.difference_update(row_tag_set)
     selected.update(new_set)
@@ -634,7 +667,7 @@ def _on_toggle_row(
     new_row_values_state: List[List[str]] = []
     affected_rows: Set[int] = {row_idx}
     for idx, row_item in enumerate(row_defs_ui):
-        tags = list(dict.fromkeys(row_item.get("tags", [])))
+        tags = _dedupe_norm_tags(row_item.get("tags", []))
         values = [t for t in tags if t in selected]
         new_row_values_state.append(values)
         if toggled_tags and any(t in toggled_tags for t in tags):
@@ -651,7 +684,14 @@ def _on_toggle_row(
             checkbox_updates.append(gr.skip())
 
     prompt_text = _compose_toggle_prompt_text(sorted(selected), row_defs_ui)
-    return [sorted(selected), new_row_values_state, prompt_text, *checkbox_updates]
+    return [
+        sorted(selected),
+        True,
+        gr.update(visible=True, interactive=True),
+        new_row_values_state,
+        prompt_text,
+        *checkbox_updates,
+    ]
 
 
 def _build_ui_payload(
@@ -660,20 +700,30 @@ def _build_ui_payload(
     row_defs: List[Dict[str, Any]],
     selected_tags: List[str],
 ):
-    prompt_text, row_values_state, header_updates, checkbox_updates = _build_row_component_updates(
-        row_defs=row_defs,
-        selected_tags=selected_tags,
-        max_rows=display_max_rows_default,
-    )
+    prompt_text, row_values_state, header_updates, checkbox_updates = _build_row_component_updates(
+        row_defs=row_defs,
+        selected_tags=selected_tags,
+        max_rows=display_max_rows_default,
+    )
+    selected_ui: List[str] = []
+    selected_ui_seen: Set[str] = set()
+    for vals in row_values_state:
+        for t in vals:
+            if t in selected_ui_seen:
+                continue
+            selected_ui_seen.add(t)
+            selected_ui.append(t)
     return [
         console_text,
         gr.update(visible=bool(row_defs)),
         prompt_text,
-        sorted(set(selected_tags or [])),
+        selected_ui,
+        False,
+        gr.update(visible=False, interactive=False),
         row_defs,
         row_values_state,
         *header_updates,
-        *checkbox_updates,
+        *checkbox_updates,
     ]
 
 
@@ -688,6 +738,8 @@ def _prepare_run_ui() -> List[Any]:
         gr.skip(),
         "Running... usually completes in about 20 seconds.",
         [],
+        False,
+        gr.update(visible=False, interactive=False),
         [],
         [],
         *header_updates,
@@ -695,6 +747,93 @@ def _prepare_run_ui() -> List[Any]:
     ]
 
 
+def _rebuild_rows_from_selected(
+    selected_tags_state: List[str],
+    row_defs_state: List[Dict[str, Any]],
+    row_values_state: List[List[str]],
+    display_top_groups: float,
+    display_top_tags_per_group: float,
+    display_rank_top_k: float,
+):
+    existing_rows = row_defs_state or []
+    existing_values = list(row_values_state or [])
+    selected_from_state = _collect_selected_from_state(selected_tags_state, existing_rows)
+    selected_from_rows = _collect_selected_from_row_values(existing_rows, existing_values)
+    # Rebuild source-of-truth is current row checkbox values; fall back only when unavailable.
+    selected_seed = selected_from_rows if existing_values else selected_from_state
+    selected_active = list(
+        dict.fromkeys(
+            _norm_tag_for_lookup(t)
+            for t in selected_seed
+            if t and not _is_artist_tag(t) and not _is_excluded_recommendation_tag(t)
+        )
+    )
+
+    retrieved_candidate_tags: List[str] = []
+    tag_selection_origins: Dict[str, str] = {}
+    for row in existing_rows:
+        row_tags = row.get("tags", []) if isinstance(row, dict) else []
+        row_meta = row.get("tag_meta", {}) if isinstance(row, dict) else {}
+        if not isinstance(row_meta, dict):
+            row_meta = {}
+        for t in row_tags:
+            tn = _norm_tag_for_lookup(t)
+            if not tn or _is_artist_tag(tn) or _is_excluded_recommendation_tag(tn):
+                continue
+            retrieved_candidate_tags.append(tn)
+            if tn not in tag_selection_origins:
+                meta = row_meta.get(t, {}) if isinstance(row_meta.get(t, {}), dict) else {}
+                tag_selection_origins[tn] = _normalize_selection_origin(str(meta.get("origin", "selection")))
+
+    for t in selected_active:
+        tag_selection_origins.setdefault(t, "user")
+        retrieved_candidate_tags.append(t)
+
+    implied_selected_tags = [t for t in selected_active if tag_selection_origins.get(t) == "implied"]
+    implied_set = set(implied_selected_tags)
+    direct_selected_tags = [t for t in selected_active if t not in implied_set]
+    direct_idx = {t: i for i, t in enumerate(direct_selected_tags)}
+    direct_selected_tags.sort(
+        key=lambda t: (
+            _selection_source_rank(tag_selection_origins.get(t, "selection")),
+            direct_idx.get(t, 10**9),
+        )
+    )
+    implied_parent_map = _build_implied_parent_map(
+        direct_tags_ordered=direct_selected_tags,
+        implied_tags=implied_selected_tags,
+    )
+
+    toggle_rows = _build_toggle_rows(
+        seed_terms=list(selected_active),
+        selected_tags=selected_active,
+        retrieved_candidate_tags=list(dict.fromkeys(retrieved_candidate_tags)),
+        tag_selection_origins=tag_selection_origins,
+        implied_parent_map=implied_parent_map,
+        top_groups=max(1, int(display_top_groups)),
+        top_tags_per_group=max(1, int(display_top_tags_per_group)),
+        group_rank_top_k=max(1, int(display_rank_top_k)),
+    )
+
+    prompt_text, row_values_state, header_updates, checkbox_updates = _build_row_component_updates(
+        row_defs=toggle_rows,
+        selected_tags=selected_active,
+        max_rows=display_max_rows_default,
+    )
+
+    return [
+        gr.update(visible=bool(toggle_rows)),
+        prompt_text,
+        sorted(selected_active),
+        False,
+        gr.update(visible=False, interactive=False),
+        toggle_rows,
+        row_values_state,
+        *header_updates,
+        *checkbox_updates,
+    ]
+
+
 def _build_selection_query(
     prompt_in: str,
     rewritten: str,
@@ -1116,55 +1255,18 @@ css = """
 """
 
 client_js = """
-() => {
-  const markerRe = /\\s*\\[\\[psq:([a-z_]+):(0|1):([A-Za-z0-9_\\-=]*)\\]\\]\\s*$/;
-  const decodeTip = (b64) => {
-    if (!b64) return "";
-    try {
-      const binary = atob((b64 || "").replace(/-/g, "+").replace(/_/g, "/"));
-      const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
-      return new TextDecoder("utf-8").decode(bytes);
-    } catch (_) {
-      return "";
-    }
-  };
-  const applyTagMeta = () => {
-    const labels = document.querySelectorAll(".lego-tags label");
-    labels.forEach((label) => {
-      const span = label.querySelector("span");
-      if (!span) return;
-      const text = span.textContent || "";
-      const match = text.match(markerRe);
-      if (!match) return;
-      label.dataset.psqOrigin = match[1];
-      label.dataset.psqPreselected = match[2];
-      const tip = decodeTip(match[3] || "");
-      if (tip) {
-        label.title = tip;
-        span.title = tip;
-      } else {
-        label.removeAttribute("title");
-        span.removeAttribute("title");
-      }
-      span.textContent = text.replace(markerRe, "");
-    });
-  };
-
-  applyTagMeta();
-  const observer = new MutationObserver(() => applyTagMeta());
-  observer.observe(document.body, { childList: true, subtree: true, characterData: true });
-}
+() => {}
 """
 
 
 def rag_pipeline_ui(
-    user_prompt: str,
-    display_top_groups: float,
-    display_top_tags_per_group: float,
-    display_rank_top_k: float,
-):
-    logs = []
-    def log(s): logs.append(s)
+    user_prompt: str,
+    display_top_groups: float,
+    display_top_tags_per_group: float,
+    display_rank_top_k: float,
+):
+    logs = []
+    def log(s): logs.append(s)
 
     try:
         stage_timings = {}
@@ -1618,9 +1720,9 @@ def rag_pipeline_ui(
             top_tags_per_group=max(1, int(display_top_tags_per_group)),
             group_rank_top_k=max(1, int(display_rank_top_k)),
         )
-        dt = time.perf_counter()-t0
-        _record_timing("group_display", dt)
-        log(f"Ranked group display: {dt:.2f}s ({len(toggle_rows)} rows)")
+        dt = time.perf_counter()-t0
+        _record_timing("group_display", dt)
+        log(f"Ranked group display: {dt:.2f}s ({len(toggle_rows)} rows)")
         log(
             _build_display_audit_line(
                 toggle_rows,
@@ -1629,6 +1731,9 @@ def rag_pipeline_ui(
                 implied_selected_tags=implied_selected_tags,
             )
         )
+        for idx, row in enumerate(toggle_rows[: max(0, int(display_max_rows_default))]):
+            tags_preview = ", ".join(row.get("tags", []))
+            log(f"UI Row {idx}: {row.get('label', '')} :: {tags_preview}")
 
         total_dt = time.perf_counter()-t_total0
         _emit_timing_summary(total_dt)
@@ -1690,6 +1795,7 @@ with gr.Blocks(css=css, js=client_js) as app:
             gr.Markdown("Typical runtime: up to ~20 seconds.", elem_classes=["run-hint"])
 
     selected_tags_state = gr.State([])
+    rows_dirty_state = gr.State(False)
     row_defs_state = gr.State([])
     row_values_state = gr.State([])
 
@@ -1716,20 +1822,29 @@ with gr.Blocks(css=css, js=client_js) as app:
                     )
                 )
 
-    gr.HTML(
-        """
-        <div class="source-legend">
-          <span class="legend-title">Legend:</span>
-          <span class="chip rewrite">Rewrite phrase</span>
-          <span class="chip selection">General selection</span>
-          <span class="chip probe">Probe query</span>
-          <span class="chip structural">Structural query</span>
-          <span class="chip implied">Implied</span>
-          <span class="chip user">User-toggled</span>
-          <span class="chip unselected">Unselected</span>
-        </div>
-        """
-    )
+    with gr.Row():
+        with gr.Column(scale=10):
+            gr.HTML(
+                """
+                <div class="source-legend">
+                  <span class="legend-title">Legend:</span>
+                  <span class="chip rewrite">Rewrite phrase</span>
+                  <span class="chip selection">General selection</span>
+                  <span class="chip probe">Probe query</span>
+                  <span class="chip structural">Structural query</span>
+                  <span class="chip implied">Implied</span>
+                  <span class="chip user">User-toggled</span>
+                  <span class="chip unselected">Unselected</span>
+                </div>
+                """
+            )
+        with gr.Column(scale=2, min_width=180):
+            rebuild_rows_button = gr.Button(
+                "Rebuild Rows",
+                variant="primary",
+                visible=False,
+                interactive=False,
+            )
 
     with gr.Accordion("Display Settings", open=False):
         with gr.Row():
@@ -1765,11 +1880,13 @@ with gr.Blocks(css=css, js=client_js) as app:
         toggle_instruction,
         suggested_prompt,
         selected_tags_state,
+        rows_dirty_state,
+        rebuild_rows_button,
         row_defs_state,
         row_values_state,
-        *row_headers,
-        *row_checkboxes,
-    ]
+        *row_headers,
+        *row_checkboxes,
+    ]
 
     submit_button.click(
         _prepare_run_ui,
@@ -1796,17 +1913,36 @@ with gr.Blocks(css=css, js=client_js) as app:
     )
 
     for idx, row_cb in enumerate(row_checkboxes):
-        row_cb.select(
-            fn=lambda changed_values, selected_state, row_defs, row_values, i=idx: _on_toggle_row(
+        row_cb.change(
+            fn=lambda changed_values, selected_state, rows_dirty, row_defs, row_values, i=idx: _on_toggle_row(
                 i,
                 changed_values,
                 selected_state,
+                rows_dirty,
                 row_defs,
-                row_values,
-                display_max_rows_default,
+                row_values,
+                display_max_rows_default,
             ),
-            inputs=[row_cb, selected_tags_state, row_defs_state, row_values_state],
-            outputs=[selected_tags_state, row_values_state, suggested_prompt, *row_checkboxes],
+            inputs=[row_cb, selected_tags_state, rows_dirty_state, row_defs_state, row_values_state],
+            outputs=[selected_tags_state, rows_dirty_state, rebuild_rows_button, row_values_state, suggested_prompt, *row_checkboxes],
+            queue=False,
+            show_progress="hidden",
+        )
+
+    rebuild_rows_button.click(
+        _rebuild_rows_from_selected,
+        inputs=[selected_tags_state, row_defs_state, row_values_state, display_top_groups, display_top_tags_per_group, display_rank_top_k],
+        outputs=[
+            toggle_instruction,
+            suggested_prompt,
+            selected_tags_state,
+            rows_dirty_state,
+            rebuild_rows_button,
+            row_defs_state,
+            row_values_state,
+            *row_headers,
+            *row_checkboxes,
+        ],
             queue=False,
             show_progress="hidden",
         )

scripts/smoke_ui_state.py

@@ -0,0 +1,196 @@
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import app
+
+
+def _assert(cond: bool, msg: str) -> None:
+    if not cond:
+        raise AssertionError(msg)
+
+
+def test_prompt_uses_visible_rows_only() -> None:
+    # If selected state contains stale hidden tags, prompt should still reflect visible-row selections only.
+    row_defs = [
+        {"name": "r1", "label": "R1", "tags": ["solo", "female"], "tag_meta": {}},
+        {"name": "r2", "label": "R2", "tags": ["cub"], "tag_meta": {}},
+    ]
+    payload = app._build_ui_payload(
+        console_text="x",
+        row_defs=row_defs,
+        selected_tags=["solo", "rosalina_(mario)"],
+    )
+    prompt_text = payload[2]
+    selected_state = payload[3]
+    _assert("rosalina \\(mario\\)" not in prompt_text, "stale hidden tag leaked into prompt")
+    _assert("solo" in prompt_text, "visible selected tag missing from prompt")
+    _assert("rosalina_(mario)" not in selected_state, "stale hidden tag leaked into selected state")
+
+
+def test_row_deduping() -> None:
+    row_defs = [
+        {
+            "name": "other_retrieved",
+            "label": "Other (Retrieved)",
+            "tags": ["cub", "expressions", "invalid_tag", "cub", "expressions"],
+            "tag_meta": {},
+        }
+    ]
+    prompt_text, row_values_state, _, checkbox_updates = app._build_row_component_updates(
+        row_defs=row_defs,
+        selected_tags=["cub", "expressions"],
+        max_rows=app.display_max_rows_default,
+    )
+    _assert(prompt_text == "cub, expressions", "prompt should be deduped and ordered from row")
+    _assert(row_values_state[0] == ["cub", "expressions"], "row selected values should be deduped")
+    first_choices = checkbox_updates[0]["choices"]
+    first_values = [v for _, v in first_choices]
+    _assert(first_values == ["cub", "expressions", "invalid_tag"], "row choices should be deduped")
+
+
+def test_rebuild_ignores_stale_selected_state() -> None:
+    row_defs = [
+        {"name": "selected_other", "label": "Selected (Other)", "tags": ["solo", "female", "anthro"], "tag_meta": {}},
+        {"name": "other_retrieved", "label": "Other (Retrieved)", "tags": ["cub", "expressions"], "tag_meta": {}},
+    ]
+    # Simulate UI state where user has deselected anthro, but stale selected state still contains it.
+    selected_state = ["solo", "female", "anthro", "cub"]
+    row_values_state = [["solo", "female"], ["cub"]]
+    out = app._rebuild_rows_from_selected(
+        selected_state,
+        row_defs,
+        row_values_state,
+        app.display_top_groups_default,
+        app.display_top_tags_per_group_default,
+        app.display_rank_top_k_default,
+    )
+    prompt = out[1]
+    selected_after = out[2]
+    _assert("anthro" not in selected_after, "rebuild should not resurrect stale deselected tags")
+    _assert("anthro" not in prompt, "prompt should not include stale deselected tags")
+    _assert("solo" in prompt and "female" in prompt and "cub" in prompt, "rebuild should retain current row selections")
+
+
+def test_toggle_then_rebuild_does_not_resurrect_removed_tag() -> None:
+    row_defs = [
+        {"name": "selected_other", "label": "Selected (Other)", "tags": ["solo", "anthro", "female"], "tag_meta": {}},
+        {"name": "other_retrieved", "label": "Other (Retrieved)", "tags": ["cub", "expressions"], "tag_meta": {}},
+    ]
+    selected_state = ["solo", "anthro", "female", "cub"]
+    row_values_state = [["solo", "anthro", "female"], ["cub"]]
+
+    # User unchecks anthro in row 0.
+    toggle_out = app._on_toggle_row(
+        0,
+        ["solo", "female"],
+        selected_state,
+        False,
+        row_defs,
+        row_values_state,
+        app.display_max_rows_default,
+    )
+    selected_after_toggle = toggle_out[0]
+    row_values_after_toggle = toggle_out[3]
+    _assert("anthro" not in selected_after_toggle, "toggle should remove anthro from selected state")
+
+    # Rebuild from current row values must preserve the user-toggle result.
+    rebuild_out = app._rebuild_rows_from_selected(
+        selected_after_toggle,
+        row_defs,
+        row_values_after_toggle,
+        app.display_top_groups_default,
+        app.display_top_tags_per_group_default,
+        app.display_rank_top_k_default,
+    )
+    prompt_after_rebuild = rebuild_out[1]
+    selected_after_rebuild = rebuild_out[2]
+    _assert("anthro" not in selected_after_rebuild, "rebuild should not resurrect deselected anthro")
+    _assert("anthro" not in prompt_after_rebuild, "prompt should not contain deselected anthro after rebuild")
+    _assert("solo" in prompt_after_rebuild and "female" in prompt_after_rebuild, "kept selections should remain")
+    _assert("cub" in prompt_after_rebuild, "other retrieved selection should remain")
+
+
+def test_toggle_does_not_cross_activate_unrelated_row_tag() -> None:
+    row_defs = [
+        {"name": "organization", "label": "Organization", "tags": ["pinup", "close-up"], "tag_meta": {}},
+        {"name": "color_markings", "label": "Color Markings", "tags": ["shoulder_markings", "black_markings"], "tag_meta": {}},
+    ]
+    selected_state = []
+    row_values_state = [[], []]
+
+    # User enables close-up in organization row.
+    out = app._on_toggle_row(
+        0,
+        ["close-up"],
+        selected_state,
+        False,
+        row_defs,
+        row_values_state,
+        app.display_max_rows_default,
+    )
+    selected_after = out[0]
+    row_values_after = out[3]
+    _assert("close-up" in selected_after, "close-up should be selected")
+    _assert("shoulder_markings" not in selected_after, "unrelated row tag should not be auto-selected")
+    _assert(row_values_after[0] == ["close-up"], "organization row values should include close-up only")
+    _assert(row_values_after[1] == [], "color markings row should remain unselected")
+
+
+def test_shared_tag_mirrors_without_unrelated_cross_toggle() -> None:
+    row_defs = [
+        {"name": "objects_props", "label": "Objects Props", "tags": ["holding_face", "holding_clothing"], "tag_meta": {}},
+        {"name": "expression_detail", "label": "Expression Detail", "tags": ["open_mouth", "closed_smile"], "tag_meta": {}},
+        {"name": "pose_action_detail", "label": "Pose Action Detail", "tags": ["holding_face", "walking"], "tag_meta": {}},
+    ]
+    selected_state = []
+    row_values_state = [[], [], []]
+
+    # Enable open_mouth; should not affect holding_face rows.
+    out1 = app._on_toggle_row(
+        1,
+        ["open_mouth"],
+        selected_state,
+        False,
+        row_defs,
+        row_values_state,
+        app.display_max_rows_default,
+    )
+    sel1 = out1[0]
+    vals1 = out1[3]
+    _assert("open_mouth" in sel1, "open_mouth should be selected")
+    _assert("holding_face" not in sel1, "holding_face must remain unselected")
+    _assert(vals1[0] == [], "objects props row should remain unselected")
+    _assert(vals1[1] == ["open_mouth"], "expression row should select open_mouth")
+    _assert(vals1[2] == [], "pose row should remain unselected")
+
+    # Enable holding_face in objects row; should mirror only to pose row, not expression row.
+    out2 = app._on_toggle_row(
+        0,
+        ["holding_face"],
+        sel1,
+        True,
+        row_defs,
+        vals1,
+        app.display_max_rows_default,
+    )
+    sel2 = out2[0]
+    vals2 = out2[3]
+    _assert("holding_face" in sel2 and "open_mouth" in sel2, "both explicitly selected tags should be present")
+    _assert(vals2[0] == ["holding_face"], "objects row should select holding_face")
+    _assert(vals2[1] == ["open_mouth"], "expression row should keep open_mouth only")
+    _assert(vals2[2] == ["holding_face"], "pose row should mirror holding_face")
+
+
+def main() -> None:
+    test_prompt_uses_visible_rows_only()
+    test_row_deduping()
+    test_rebuild_ignores_stale_selected_state()
+    test_toggle_then_rebuild_does_not_resurrect_removed_tag()
+    test_toggle_does_not_cross_activate_unrelated_row_tag()
+    test_shared_tag_mirrors_without_unrelated_cross_toggle()
+    print("ui state smoke: ok")
+
+
+if __name__ == "__main__":
+    main()