Switch checklist from Checkbox to Radio (Yes/No/Unsure)

- Each checklist item now has 3 options instead of binary check
- DB stores 1 (Yes), -1 (No), 0 (Unsure); backward compatible with old 0/1 data
- Analytics: count only Yes (=1) for check rates, show labels in table
- Score still counts only Yes answers out of 8

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app/db.py

@@ -70,10 +70,29 @@ def init_db():
     conn.close()
 
 
+def _radio_to_int(val) -> int:
+    """Convert Radio value to int: 'Yes'->1, 'No'->-1, 'Unsure'/other->0."""
+    if val == "Yes":
+        return 1
+    elif val == "No":
+        return -1
+    return 0
+
+
+def _int_to_radio(val) -> str:
+    """Convert stored int to Radio value."""
+    if val == 1:
+        return "Yes"
+    elif val == -1:
+        return "No"
+    return "Unsure"
+
+
 def save_annotation(paper_id: str, reviewer_id: str, conference: str,
-                    checklist: Dict[str, bool], notes: str = "",
+                    checklist: Dict[str, str], notes: str = "",
                     annotator_name: str = "") -> int:
-    score = sum(1 for v in checklist.values() if v)
+    vals = {k: _radio_to_int(v) for k, v in checklist.items()}
+    score = sum(1 for v in vals.values() if v == 1)
     now = datetime.now().isoformat()
 
     conn = sqlite3.connect(DB_PATH)
@@ -90,10 +109,10 @@ def save_annotation(paper_id: str, reviewer_id: str, conference: str,
             score=excluded.score, notes=excluded.notes,
             updated_at=excluded.updated_at
     """, (paper_id, reviewer_id, conference, annotator_name,
-          int(checklist.get("A1", False)), int(checklist.get("A2", False)),
-          int(checklist.get("B1", False)), int(checklist.get("B2", False)),
-          int(checklist.get("C1", False)), int(checklist.get("C2", False)),
-          int(checklist.get("D1", False)), int(checklist.get("D2", False)),
+          vals.get("A1", 0), vals.get("A2", 0),
+          vals.get("B1", 0), vals.get("B2", 0),
+          vals.get("C1", 0), vals.get("C2", 0),
+          vals.get("D1", 0), vals.get("D2", 0),
           score, notes, now, now))
     conn.commit()
     conn.close()
@@ -138,10 +157,12 @@ def get_stats() -> dict:
     ).fetchall()
     stats["score_dist"] = {r[0]: r[1] for r in rows}
 
-    # Per-item check rates
+    # Per-item check rates (count rows where item == 1, i.e. "Yes")
     for item_id in CHECKLIST_ITEMS:
-        total = conn.execute(f"SELECT SUM({item_id}) FROM annotations").fetchone()[0]
-        stats[f"rate_{item_id}"] = total or 0
+        cnt = conn.execute(
+            f"SELECT COUNT(*) FROM annotations WHERE {item_id} = 1"
+        ).fetchone()[0]
+        stats[f"rate_{item_id}"] = cnt or 0
 
     # Per-conference
     rows = conn.execute(

app/tab_analytics.py

@@ -8,7 +8,7 @@ import tempfile
 import os
 from data_loader import DataStore
 from db import (CHECKLIST_ITEMS, DIMENSIONS, get_all_annotations_df,
-                get_stats, export_csv)
+                get_stats, export_csv, _int_to_radio)
 
 
 def _empty_fig(msg="No annotation data yet"):
@@ -175,6 +175,10 @@ def build_analytics_tab(store: DataStore):
                         "A1", "A2", "B1", "B2", "C1", "C2", "D1", "D2",
                         "score", "notes", "updated_at"]
         table_df = df[display_cols] if not df.empty else pd.DataFrame()
+        # Convert integer codes to readable labels in table
+        if not table_df.empty:
+            for col in ["A1", "A2", "B1", "B2", "C1", "C2", "D1", "D2"]:
+                table_df[col] = table_df[col].apply(_int_to_radio)
 
         return (summary, fig_hist, fig_items, fig_conf_count, fig_conf_score,
                 fig_corr, fig_dim, table_df)

app/tab_annotation.py

@@ -3,8 +3,10 @@
 import gradio as gr
 from data_loader import DataStore
 from db import (CHECKLIST_ITEMS, DIMENSIONS, save_annotation,
-                get_annotation, get_annotated_set, get_global_annotated_count)
+                get_annotation, get_annotated_set, get_global_annotated_count,
+                _int_to_radio)
 
+RADIO_CHOICES = ["Yes", "No", "Unsure"]
 
 # Server-side queue storage (avoids sending 70K tuples to browser)
 _queues = {}  # queue_key -> list of (paper_id, reviewer_id, conference)
@@ -108,44 +110,52 @@ def build_annotation_tab(store: DataStore):
 
     gr.Markdown("---")
 
-    # --- Checklist ---
+    # --- Checklist (Radio buttons: Yes / No / Unsure) ---
     gr.Markdown("### Checklist")
-    checkboxes = {}
+    radios = {}
 
     gr.Markdown("**A. Evidence & Counterfactual**")
     with gr.Row():
-        checkboxes["A1"] = gr.Checkbox(
-            label=f"A1: {CHECKLIST_ITEMS['A1']}", value=False, interactive=True,
+        radios["A1"] = gr.Radio(
+            choices=RADIO_CHOICES, value="Unsure", interactive=True,
+            label=f"A1: {CHECKLIST_ITEMS['A1']}",
         )
-        checkboxes["A2"] = gr.Checkbox(
-            label=f"A2: {CHECKLIST_ITEMS['A2']}", value=False, interactive=True,
+        radios["A2"] = gr.Radio(
+            choices=RADIO_CHOICES, value="Unsure", interactive=True,
+            label=f"A2: {CHECKLIST_ITEMS['A2']}",
         )
 
     gr.Markdown("**B. Causal Reasoning**")
     with gr.Row():
-        checkboxes["B1"] = gr.Checkbox(
-            label=f"B1: {CHECKLIST_ITEMS['B1']}", value=False, interactive=True,
+        radios["B1"] = gr.Radio(
+            choices=RADIO_CHOICES, value="Unsure", interactive=True,
+            label=f"B1: {CHECKLIST_ITEMS['B1']}",
         )
-        checkboxes["B2"] = gr.Checkbox(
-            label=f"B2: {CHECKLIST_ITEMS['B2']}", value=False, interactive=True,
+        radios["B2"] = gr.Radio(
+            choices=RADIO_CHOICES, value="Unsure", interactive=True,
+            label=f"B2: {CHECKLIST_ITEMS['B2']}",
         )
 
     gr.Markdown("**C. Effort Investment**")
     with gr.Row():
-        checkboxes["C1"] = gr.Checkbox(
-            label=f"C1: {CHECKLIST_ITEMS['C1']}", value=False, interactive=True,
+        radios["C1"] = gr.Radio(
+            choices=RADIO_CHOICES, value="Unsure", interactive=True,
+            label=f"C1: {CHECKLIST_ITEMS['C1']}",
         )
-        checkboxes["C2"] = gr.Checkbox(
-            label=f"C2: {CHECKLIST_ITEMS['C2']}", value=False, interactive=True,
+        radios["C2"] = gr.Radio(
+            choices=RADIO_CHOICES, value="Unsure", interactive=True,
+            label=f"C2: {CHECKLIST_ITEMS['C2']}",
         )
 
     gr.Markdown("**D. Belief Update**")
     with gr.Row():
-        checkboxes["D1"] = gr.Checkbox(
-            label=f"D1: {CHECKLIST_ITEMS['D1']}", value=False, interactive=True,
+        radios["D1"] = gr.Radio(
+            choices=RADIO_CHOICES, value="Unsure", interactive=True,
+            label=f"D1: {CHECKLIST_ITEMS['D1']}",
         )
-        checkboxes["D2"] = gr.Checkbox(
-            label=f"D2: {CHECKLIST_ITEMS['D2']}", value=False, interactive=True,
+        radios["D2"] = gr.Radio(
+            choices=RADIO_CHOICES, value="Unsure", interactive=True,
+            label=f"D2: {CHECKLIST_ITEMS['D2']}",
         )
 
     # --- Score + Notes + Status ---
@@ -159,14 +169,15 @@ def build_annotation_tab(store: DataStore):
 
     # ========== Callbacks ==========
 
-    all_cb = [checkboxes[k] for k in ["A1", "A2", "B1", "B2", "C1", "C2", "D1", "D2"]]
+    ITEM_KEYS = ["A1", "A2", "B1", "B2", "C1", "C2", "D1", "D2"]
+    all_radios = [radios[k] for k in ITEM_KEYS]
 
     # All outputs that get updated when navigating to a review
     review_outputs = [
         paper_dd, reviewer_dd,
         conf_display, init_score_display, final_score_display, change_display,
         review_display, rebuttal_display,
-        *all_cb,
+        *all_radios,
         notes_box, score_display, status_msg,
         idx_display, progress_md,
         idx_state,
@@ -184,7 +195,8 @@ def build_annotation_tab(store: DataStore):
                 gr.update(), gr.update(),
                 "", "", "", "",
                 "", "",
-                False, False, False, False, False, False, False, False,
+                "Unsure", "Unsure", "Unsure", "Unsure",
+                "Unsure", "Unsure", "Unsure", "Unsure",
                 "", _score_bar(0), "Queue is empty",
                 "**Review 0** / 0", _progress_bar(0, 0),
                 idx,
@@ -237,12 +249,12 @@ def build_annotation_tab(store: DataStore):
         # Load existing annotation
         ann = get_annotation(paper_id, reviewer_id, annotator_name or "")
         if ann:
-            cb_vals = [bool(ann.get(k, 0)) for k in ["A1", "A2", "B1", "B2", "C1", "C2", "D1", "D2"]]
+            radio_vals = [_int_to_radio(ann.get(k, 0)) for k in ITEM_KEYS]
             notes = ann.get("notes", "")
             score = ann.get("score", 0)
             status = f"Loaded existing annotation (score: {score}/8)"
         else:
-            cb_vals = [False] * 8
+            radio_vals = ["Unsure"] * 8
             notes = ""
             score = 0
             status = "No existing annotation — start checking items below"
@@ -257,7 +269,7 @@ def build_annotation_tab(store: DataStore):
             conference,
             str(init_rating), str(final_rating), change_str,
             review_text, rebuttal_text,
-            *cb_vals,
+            *radio_vals,
             notes, _score_bar(score), status,
             idx_text, _progress_bar(done, total),
             idx,
@@ -333,14 +345,15 @@ def build_annotation_tab(store: DataStore):
             gr.update(), gr.update(),
             "", "", "", "",
             "", "",
-            False, False, False, False, False, False, False, False,
+            "Unsure", "Unsure", "Unsure", "Unsure",
+            "Unsure", "Unsure", "Unsure", "Unsure",
             "", _score_bar(0), "Paper not found",
             "**Review 0** / 0", _progress_bar(0, 0),
             0,
         )
 
-    def live_score(*cb_values):
-        score = sum(1 for v in cb_values if v)
+    def live_score(*radio_values):
+        score = sum(1 for v in radio_values if v == "Yes")
         return _score_bar(score)
 
     # ========== Wire Events ==========
@@ -352,7 +365,7 @@ def build_annotation_tab(store: DataStore):
     save_next_btn.click(
         fn=save_and_next,
         inputs=[idx_state, queue_key_state, annotator_input,
-                paper_dd, reviewer_dd, *all_cb, notes_box],
+                paper_dd, reviewer_dd, *all_radios, notes_box],
         outputs=review_outputs,
     )
 
@@ -370,9 +383,9 @@ def build_annotation_tab(store: DataStore):
         outputs=review_outputs,
     )
 
-    # Live score update on any checkbox change
-    for cb in all_cb:
-        cb.change(fn=live_score, inputs=all_cb, outputs=[score_display])
+    # Live score update on any radio change
+    for r in all_radios:
+        r.change(fn=live_score, inputs=all_radios, outputs=[score_display])
 
     # Return progress component and init function for demo.load()
     def init_progress():