feat: ability to discard all reviews and clean history

Author: Specthram

server/routers/review.py

@@ -146,3 +146,15 @@ def decide_bulk(body: ReviewBulkDecideBody) -> dict:
     else:
         applied = storage.accept_rule_fixes(body.dataset_id, body.rule_id)
     return {"accepted": applied}
+
+
+@router.post("/findings/reject_all")
+def reject_all(body: ReviewBulkDecideBody) -> dict:
+    """Reject every pending finding of a dataset (captions untouched)."""
+    return {"rejected": storage.reject_all_findings(body.dataset_id)}
+
+
+@router.post("/findings/clear_history")
+def clear_history(body: ReviewBulkDecideBody) -> dict:
+    """Delete the decided findings (history); pending ones stay."""
+    return {"cleared": storage.clear_review_history(body.dataset_id)}

src/sqlite_store/__init__.py

@@ -223,6 +223,8 @@
     pending_for_media,
     rebase_finding,
     decide_finding,
+    reject_all_pending,
+    clear_decided_findings,
     reopen_finding,
     clear_dataset_findings,
     clear_media_findings,
@@ -356,6 +358,8 @@
     "pending_for_media",
     "rebase_finding",
     "decide_finding",
+    "reject_all_pending",
+    "clear_decided_findings",
     "reopen_finding",
     "clear_dataset_findings",
     "clear_media_findings",

src/sqlite_store/review_queue.py

@@ -313,6 +313,40 @@ def decide_finding(
     )
 
 
+def reject_all_pending(dataset_id: int) -> int:
+    """Reject every pending finding of a dataset; return how many.
+
+    Rejecting never touches a caption, so one UPDATE is enough — no
+    per-finding apply pass like the bulk accepts.
+    """
+    with closing(db.connect()) as conn:
+        with conn:
+            cursor = conn.execute(
+                "UPDATE review_finding SET status = ?, "
+                "decided_at = datetime('now') "
+                "WHERE status = ? AND run_id IN "
+                "(SELECT id FROM review_run WHERE dataset_id = ?)",
+                (STATUS_REJECTED, STATUS_PENDING, dataset_id),
+            )
+            return cursor.rowcount
+
+
+def clear_decided_findings(dataset_id: int) -> int:
+    """Delete a dataset's decided findings (the history); return how many.
+
+    Pending findings stay; accepted captions keep their revisions (this
+    only clears the queue's history, never a caption).
+    """
+    with closing(db.connect()) as conn:
+        with conn:
+            cursor = conn.execute(
+                "DELETE FROM review_finding WHERE status != ? AND run_id IN "
+                "(SELECT id FROM review_run WHERE dataset_id = ?)",
+                (STATUS_PENDING, dataset_id),
+            )
+            return cursor.rowcount
+
+
 def reopen_finding(finding_id: int) -> None:
     """Return a decided finding to ``pending`` (the undo path)."""
     _write(

src/storage.py

@@ -956,11 +956,8 @@ def record_review_finding(
 def _apply_accept(finding: dict, caption: str = None) -> None:
     """Write the accepted caption as a new revision for a finding's media.
 
-    The finding's fix is merged into the *live* caption
-    (:func:`src.caption_judge.apply_fix`), never written verbatim: accepting
-    a second finding must not resurrect the run-time caption and erase the
-    first accept (or a manual edit made since the run). An explicit
-    ``caption`` (inline edit before accept) still wins as-is.
+    The fix is merged into the *live* caption (never written verbatim) so a
+    second accept keeps the first; an explicit ``caption`` wins as-is.
     """
     type_row = store.get_caption_type(finding["caption_type_id"])
     caption_type = type_row["name"] if type_row else ""
@@ -980,8 +977,7 @@ def _apply_accept(finding: dict, caption: str = None) -> None:
         finding["id"], store.STATUS_ACCEPTED, applied_caption=final
     )
     # Rebase the media's other pending findings onto the new caption: their
-    # "original" then shows this accept applied, and their proposal is the
-    # same fix re-applied on top — the next accept diffs against reality.
+    # "original" shows this accept applied, their proposal the fix on top.
     for sibling in store.pending_for_media(
         finding["dataset_id"],
         finding["media_id"],
@@ -996,10 +992,7 @@ def _apply_accept(finding: dict, caption: str = None) -> None:
 def decide_review_finding(
     finding_id: int, action: str, caption: str = None
 ) -> dict:
-    """Accept (write a new revision) or reject one finding; return it.
-
-    ``caption`` overrides the proposed text (an inline edit before accept).
-    """
+    """Accept (``caption`` = inline-edit override) or reject one finding."""
     finding = store.get_finding(finding_id)
     if finding is None:
         return {}
@@ -1050,6 +1043,20 @@ def accept_rule_fixes(dataset_ref, rule_id: int) -> int:
     return len(findings)
 
 
+def reject_all_findings(dataset_ref) -> int:
+    """Reject every pending finding of a dataset; return the count."""
+    dataset_id = _dataset_id(dataset_ref)
+    return 0 if dataset_id is None else store.reject_all_pending(dataset_id)
+
+
+def clear_review_history(dataset_ref) -> int:
+    """Delete the dataset's decided findings (history); return the count."""
+    dataset_id = _dataset_id(dataset_ref)
+    if dataset_id is None:
+        return 0
+    return store.clear_decided_findings(dataset_id)
+
+
 def media_path(dataset_ref, key: str) -> str | None:
     """Return the effective media file path for a key, or None when unset.
 

tests/test_review_queue.py

@@ -163,6 +163,25 @@ def test_second_accept_merges_with_the_first(self, dataset):
         )
         assert caption == "a crimson ball on the lawn."
 
+    def test_reject_all_then_clear_history(self, dataset):
+        """Reject-all rejects every pending row; clear drops the decided."""
+        _run_det(dataset["dataset_id"])
+        assert storage.reject_all_findings(dataset["dataset_id"]) == 1
+        counts = store.findings_counts(dataset["dataset_id"])
+        assert counts["pending"] == 0
+        assert counts["rejected"] == 1
+        # The caption was never touched by the rejection.
+        caption = storage.read_caption(
+            dataset["dataset_id"], dataset["key"], "txt"
+        )
+        assert caption == "a red ball on the grass."
+        assert storage.clear_review_history(dataset["dataset_id"]) == 1
+        assert store.findings_counts(dataset["dataset_id"]) == {
+            "pending": 0,
+            "accepted": 0,
+            "rejected": 0,
+        }
+
     def test_undo_restores_caption(self, dataset):
         """Undo restores the original caption and reopens the finding."""
         _run_det(dataset["dataset_id"])

web/src/api/hooks.ts

@@ -908,6 +908,26 @@ export function useUndoFinding() {
   });
 }
 
+/** Reject every pending finding of the dataset (captions untouched). */
+export function useRejectAll() {
+  const invalidate = useReviewInvalidator();
+  return useMutation({
+    mutationFn: (vars: { dataset_id: number }) =>
+      api.post<{ rejected: number }>("/review/findings/reject_all", vars),
+    onSuccess: (_data, vars) => invalidate(vars.dataset_id),
+  });
+}
+
+/** Delete the decided findings (the history); pending ones stay. */
+export function useClearReviewHistory() {
+  const invalidate = useReviewInvalidator();
+  return useMutation({
+    mutationFn: (vars: { dataset_id: number }) =>
+      api.post<{ cleared: number }>("/review/findings/clear_history", vars),
+    onSuccess: (_data, vars) => invalidate(vars.dataset_id),
+  });
+}
+
 /** Accept every safe finding, or every pending finding of one rule. */
 export function useDecideBulk() {
   const invalidate = useReviewInvalidator();

web/src/components/organisms/ReviewView.tsx

@@ -13,8 +13,10 @@ import { useEffect, useMemo, useState } from "react";
 import { useQueryClient } from "@tanstack/react-query";
 import {
   useCreateReviewRule,
+  useClearReviewHistory,
   useDecideBulk,
   useDecideFinding,
+  useRejectAll,
   useDeleteReviewRule,
   useProfiles,
   useReviewFindings,
@@ -441,6 +443,9 @@ function Queue({
   onOpenWizard: (index: number) => void;
 }) {
   const decideBulk = useDecideBulk();
+  const rejectAll = useRejectAll();
+  const clearHistory = useClearReviewHistory();
+  const decidedCount = counts.accepted + counts.rejected;
   const safeCount = list.filter(
     (f) => f.status === "pending" && SAFE_KINDS.has(f.rule_kind),
   ).length;
@@ -485,6 +490,43 @@ function Queue({
         <CountChip n={counts.accepted} label="accepted" color={colors.ok} />
         <CountChip n={counts.rejected} label="rejected" color={colors.danger} />
         <div style={{ flex: 1 }} />
+        {decidedCount > 0 && (
+          <Button
+            variant="ghost"
+            onClick={() => {
+              if (
+                window.confirm(
+                  `Clear the review history (${decidedCount} decided ` +
+                    "findings)? Captions are not touched.",
+                )
+              ) {
+                clearHistory.mutate({ dataset_id: datasetId });
+              }
+            }}
+            loading={clearHistory.isPending}
+          >
+            🗑 Clear history · {decidedCount}
+          </Button>
+        )}
+        {counts.pending > 0 && (
+          <Button
+            variant="ghost"
+            style={{ color: colors.danger, borderColor: colors.danger }}
+            onClick={() => {
+              if (
+                window.confirm(
+                  `Reject all ${counts.pending} pending findings? ` +
+                    "Captions are not touched.",
+                )
+              ) {
+                rejectAll.mutate({ dataset_id: datasetId });
+              }
+            }}
+            loading={rejectAll.isPending}
+          >
+            ✕ Reject all · {counts.pending}
+          </Button>
+        )}
         {safeCount > 0 && (
           <Button
             variant="ghost"