Enhance backend API and frontend components to support full scores for classified items. Updated the database schema to include a new column for full scores, modified the item retrieval logic to optionally include these scores, and added a new endpoint for fetching item scores. Updated the frontend to display score debug information and improved state management for score loading. Enhanced tests to cover new functionality.

backend/app/api.py

@@ -60,7 +60,7 @@ def _settings_from_db() -> AppSettings:
     )
 
 
-def _item_from_row(row: dict) -> ClassifiedItem:
+def _item_from_row(row: dict, include_full_scores: bool = False) -> ClassifiedItem:
     return ClassifiedItem(
         id=row["id"],
         run_id=row["run_id"],
@@ -69,6 +69,11 @@ def _item_from_row(row: dict) -> ClassifiedItem:
         primary_tag=row["primary_tag"],
         primary_score=row["primary_score"],
         secondary_suggestions=from_json(row.get("secondary_json") or "[]", default=[]),
+        full_scores=(
+            from_json(row.get("full_scores_json") or "{}", default={})
+            if include_full_scores
+            else None
+        ),
         suggested_destination=row["suggested_destination"],
         final_tag=row["final_tag"],
         final_destination=row["final_destination"],
@@ -146,7 +151,7 @@ def _execute_run(
                 reason = None
             except Exception:
                 logger.exception("inference_failed run_id=%d image=%s", run_id, image_path)
-                primary_tag, primary_score, secondary = None, None, []
+                scores, primary_tag, primary_score, secondary = {}, None, None, []
                 needs_review = True
                 reason = "Inference failed for this image; requires manual review."
                 failed += 1
@@ -169,8 +174,8 @@ def _execute_run(
                 """
                 INSERT INTO items (
                     run_id, file_path, relative_path, primary_tag, primary_score, secondary_json,
-                    suggested_destination, final_tag, final_destination, status, needs_review, review_reason
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    full_scores_json, suggested_destination, final_tag, final_destination, status, needs_review, review_reason
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     run_id,
@@ -179,6 +184,7 @@ def _execute_run(
                     primary_tag,
                     primary_score,
                     to_json(secondary),
+                    to_json(scores),
                     suggested_destination,
                     primary_tag,
                     suggested_destination,
@@ -330,6 +336,7 @@ def get_run_items(
     run_id: int,
     status: str | None = None,
     needs_review: bool | None = None,
+    include_scores: bool = Query(False),
 ) -> list[ClassifiedItem]:
     query = "SELECT * FROM items WHERE run_id = ?"
     params: list = [run_id]
@@ -341,7 +348,7 @@ def get_run_items(
         params.append(1 if needs_review else 0)
     query += " ORDER BY id ASC"
     rows = fetch_all(query, tuple(params))
-    return [_item_from_row(r) for r in rows]
+    return [_item_from_row(r, include_full_scores=include_scores) for r in rows]
 
 
 @router.patch("/items/{item_id}", response_model=ClassifiedItem)
@@ -375,6 +382,17 @@ def update_item(item_id: int, payload: UpdateItemRequest) -> ClassifiedItem:
     return _item_from_row(updated)
 
 
+@router.get("/items/{item_id}/scores")
+def get_item_scores(item_id: int) -> dict:
+    row = fetch_one("SELECT id, full_scores_json FROM items WHERE id = ?", (item_id,))
+    if not row:
+        raise HTTPException(status_code=404, detail="Item not found")
+    return {
+        "item_id": row["id"],
+        "full_scores": from_json(row.get("full_scores_json") or "{}", default={}),
+    }
+
+
 @router.get("/items/{item_id}/preview")
 def get_item_preview(item_id: int) -> FileResponse:
     row = fetch_one("SELECT file_path FROM items WHERE id = ?", (item_id,))

backend/app/schemas.py

@@ -56,6 +56,7 @@ class ClassifiedItem(BaseModel):
     primary_tag: str | None
     primary_score: float | None
     secondary_suggestions: list[SecondarySuggestion] = Field(default_factory=list)
+    full_scores: dict[str, float] | None = None
     suggested_destination: str | None
     final_tag: str | None
     final_destination: str | None

backend/app/services.py

@@ -30,7 +30,7 @@ def normalize_tag_name(value: str) -> str:
     for ch in text:
         if ch.isalnum():
             normalized.append(ch)
-        elif ch in {" ", "-", ".", "/"}:
+        elif ch in {" ", "-", ".", "/", "_"}:
             normalized.append("_")
     return "".join(normalized).strip("_")
 
@@ -130,7 +130,7 @@ def extract_scores(image_path: Path) -> dict[str, float]:
         threshold=0.0,
         size=448,
         keep_ratio=True,
-        drop_overlap=True,
+        drop_overlap=False,
         use_real_name=False,
     )
 
@@ -150,7 +150,16 @@ def extract_scores(image_path: Path) -> dict[str, float]:
 def choose_best_tags(
     scores: dict[str, float], allowed_tags: set[str], max_secondary: int = 3
 ) -> tuple[str | None, float | None, list[dict[str, float]]]:
-    candidates = [(tag, score) for tag, score in scores.items() if tag in allowed_tags]
+    allowed_by_normalized = {normalize_tag_name(tag): tag for tag in allowed_tags}
+    best_by_allowed: dict[str, float] = {}
+    for tag, score in scores.items():
+        resolved = allowed_by_normalized.get(tag) or allowed_by_normalized.get(normalize_tag_name(tag))
+        if resolved is None:
+            continue
+        current = best_by_allowed.get(resolved)
+        if current is None or score > current:
+            best_by_allowed[resolved] = float(score)
+    candidates = list(best_by_allowed.items())
     candidates.sort(key=lambda x: x[1], reverse=True)
     if not candidates:
         return None, None, []

backend/app/storage.py

@@ -68,6 +68,7 @@ def init_db() -> None:
             """
             )
             _ensure_runs_columns(conn)
+            _ensure_items_columns(conn)
     except sqlite3.DatabaseError:
         logger.exception("failed to initialize database")
         raise
@@ -92,6 +93,18 @@ def _ensure_runs_columns(conn: sqlite3.Connection) -> None:
         conn.execute(f"ALTER TABLE runs ADD COLUMN {name} {definition}")
 
 
+def _ensure_items_columns(conn: sqlite3.Connection) -> None:
+    expected_columns = {
+        "full_scores_json": "TEXT NOT NULL DEFAULT '{}'",
+    }
+    rows = conn.execute("PRAGMA table_info(items)").fetchall()
+    existing = {row[1] for row in rows}
+    for name, definition in expected_columns.items():
+        if name in existing:
+            continue
+        conn.execute(f"ALTER TABLE items ADD COLUMN {name} {definition}")
+
+
 def fetch_one(query: str, params: tuple[Any, ...] = ()) -> dict[str, Any] | None:
     try:
         with get_connection() as conn:

backend/tests/test_api_run_progress.py

@@ -139,6 +139,135 @@ def test_item_preview_returns_image(monkeypatch, tmp_path: Path):
         assert preview_resp.content == b"fake-image-bytes"
 
 
+def test_selected_tag_wins_when_global_top_not_selected(monkeypatch, tmp_path: Path):
+    root = tmp_path / "root_selected"
+    cats = tmp_path / "cats_selected"
+    root.mkdir()
+    cats.mkdir()
+    (cats / "monster_girl").mkdir()
+    (cats / "slime_girl").mkdir()
+    file_path = root / "s.png"
+    file_path.write_text("fake", encoding="utf-8")
+
+    def fake_scan_images(_root):
+        return ScanOutput(
+            image_paths=[file_path],
+            stats=ScanStats(
+                total_files=1,
+                eligible_images=1,
+                ignored_unsupported=0,
+                ignored_gif=0,
+                failed_to_read=0,
+            ),
+        )
+
+    monkeypatch.setattr("app.api.scan_images", fake_scan_images)
+    monkeypatch.setattr(
+        "app.api.extract_scores",
+        lambda _p: {"1girl": 0.99, "monster_girl": 0.85, "slime_girl": 0.82},
+    )
+    monkeypatch.setattr("app.api.load_known_tags", lambda _p: {"1girl", "monster_girl", "slime_girl"})
+    monkeypatch.setattr(
+        "app.api.discover_tag_folders",
+        lambda _root, _tags, _selected: [
+            FolderMapping(
+                folder_name="monster_girl",
+                normalized_name="monster_girl",
+                matched_tag="monster_girl",
+                matched=True,
+            ),
+            FolderMapping(
+                folder_name="slime_girl",
+                normalized_name="slime_girl",
+                matched_tag="slime_girl",
+                matched=True,
+            ),
+        ],
+    )
+
+    with TestClient(app) as client:
+        start_resp = client.post(
+            "/api/runs/start",
+            json={
+                "root_repo": str(root),
+                "categories_root": str(cats),
+                "confidence_threshold": 0.8,
+                "selected_folders": ["monster_girl", "slime_girl"],
+            },
+        )
+        start_resp.raise_for_status()
+        run_id = start_resp.json()["run_id"]
+        final = _wait_for_status(client, run_id, {"completed", "failed", "cancelled"})
+        assert final is not None
+        assert final["status"] == "completed"
+        items_resp = client.get(f"/api/runs/{run_id}/items")
+        items_resp.raise_for_status()
+        item = items_resp.json()[0]
+        assert item["primary_tag"] == "monster_girl"
+        assert item["status"] == "approved"
+        assert item["needs_review"] is False
+
+
+def test_item_scores_debug_endpoint(monkeypatch, tmp_path: Path):
+    root = tmp_path / "root_scores"
+    cats = tmp_path / "cats_scores"
+    root.mkdir()
+    cats.mkdir()
+    (cats / "1girl").mkdir()
+    file_path = root / "z.jpg"
+    file_path.write_text("fake", encoding="utf-8")
+
+    def fake_scan_images(_root):
+        return ScanOutput(
+            image_paths=[file_path],
+            stats=ScanStats(
+                total_files=1,
+                eligible_images=1,
+                ignored_unsupported=0,
+                ignored_gif=0,
+                failed_to_read=0,
+            ),
+        )
+
+    monkeypatch.setattr("app.api.scan_images", fake_scan_images)
+    monkeypatch.setattr("app.api.extract_scores", lambda _p: {"1girl": 0.92, "solo": 0.88})
+    monkeypatch.setattr("app.api.load_known_tags", lambda _p: {"1girl", "solo"})
+    monkeypatch.setattr(
+        "app.api.discover_tag_folders",
+        lambda _root, _tags, _selected: [
+            FolderMapping(
+                folder_name="1girl", normalized_name="1girl", matched_tag="1girl", matched=True
+            )
+        ],
+    )
+
+    with TestClient(app) as client:
+        start_resp = client.post(
+            "/api/runs/start",
+            json={
+                "root_repo": str(root),
+                "categories_root": str(cats),
+                "confidence_threshold": 0.6,
+                "selected_folders": ["1girl"],
+            },
+        )
+        start_resp.raise_for_status()
+        run_id = start_resp.json()["run_id"]
+        final = _wait_for_status(client, run_id, {"completed", "failed", "cancelled"})
+        assert final is not None
+        assert final["status"] == "completed"
+
+        items_resp = client.get(f"/api/runs/{run_id}/items")
+        items_resp.raise_for_status()
+        item_id = items_resp.json()[0]["id"]
+        debug_resp = client.get(f"/api/items/{item_id}/scores")
+        debug_resp.raise_for_status()
+        payload = debug_resp.json()
+        assert payload["item_id"] == item_id
+        assert payload["full_scores"]["1girl"] == 0.92
+        assert payload["full_scores"]["solo"] == 0.88
+
+
 def test_run_cancel_sets_cancelled(monkeypatch, tmp_path: Path):
     root = tmp_path / "root_cancel"
     cats = tmp_path / "cats_cancel"

backend/tests/test_services.py

@@ -56,6 +56,22 @@ def test_choose_best_tags_single_primary_and_secondary() -> None:
     assert secondary[0]["tag"] == "solo"
 
 
+def test_choose_best_tags_ignores_non_selected_high_score() -> None:
+    scores = {"1girl": 0.99, "monster_girl": 0.81, "slime_girl": 0.77}
+    primary_tag, primary_score, secondary = choose_best_tags(scores, {"monster_girl", "slime_girl"})
+    assert primary_tag == "monster_girl"
+    assert primary_score == 0.81
+    assert secondary == [{"tag": "slime_girl", "score": 0.77}]
+
+
+def test_choose_best_tags_matches_normalized_selected_tags() -> None:
+    scores = {"monster girl": 0.88, "slime-girl": 0.84}
+    primary_tag, primary_score, secondary = choose_best_tags(scores, {"monster_girl", "slime_girl"})
+    assert primary_tag == "monster_girl"
+    assert primary_score == 0.88
+    assert secondary == [{"tag": "slime_girl", "score": 0.84}]
+
+
 def test_migrate_file_copy_with_collision_suffix(tmp_path: Path) -> None:
     src = tmp_path / "sample.jpg"
     src.write_text("abc", encoding="utf-8")

frontend/src/App.jsx

@@ -24,6 +24,9 @@ function App() {
   const [tagOptions, setTagOptions] = useState([]);
   const [selectedTags, setSelectedTags] = useState([]);
   const [previewErrors, setPreviewErrors] = useState({});
+  const [expandedScoreRows, setExpandedScoreRows] = useState({});
+  const [scoreDebugByItem, setScoreDebugByItem] = useState({});
+  const [scoreLoadingByItem, setScoreLoadingByItem] = useState({});
   const [finalTagDrafts, setFinalTagDrafts] = useState({});
   const [opsLoading, setOpsLoading] = useState({
     saving: false,
@@ -277,10 +280,28 @@ function App() {
     }
   }
 
+  async function toggleScoreDebug(itemId) {
+    const isExpanded = Boolean(expandedScoreRows[itemId]);
+    if (isExpanded) {
+      setExpandedScoreRows((prev) => ({ ...prev, [itemId]: false }));
+      return;
+    }
+    setExpandedScoreRows((prev) => ({ ...prev, [itemId]: true }));
+    if (scoreDebugByItem[itemId]) return;
+    setScoreLoadingByItem((prev) => ({ ...prev, [itemId]: true }));
+    try {
+      const response = await api.getItemScores(itemId);
+      setScoreDebugByItem((prev) => ({ ...prev, [itemId]: response.full_scores || {} }));
+    } catch (err) {
+      setError(`Failed to load score debug JSON: ${err.message}`);
+    } finally {
+      setScoreLoadingByItem((prev) => ({ ...prev, [itemId]: false }));
+    }
+  }
+
   function addSelectedTag(value) {
     if (!value) return;
-    if (selectedTags.includes(value)) return;
-    setSelectedTags([...selectedTags, value]);
+    setSelectedTags((prev) => (prev.includes(value) ? prev : [...prev, value]));
   }
 
   async function addValidatedTag(rawValue) {
@@ -317,7 +338,7 @@ function App() {
   }
 
   function removeSelectedTag(value) {
-    setSelectedTags(selectedTags.filter((t) => t !== value));
+    setSelectedTags((prev) => prev.filter((t) => t !== value));
   }
 
   return (
@@ -491,11 +512,12 @@ function App() {
               <tr>
                 <th>Select</th>
                 <th>Image</th>
-                <th>Primary</th>
+                <th>Primary (Selected)</th>
                 <th>Score</th>
-                <th>Secondary</th>
+                <th>Secondary (Selected)</th>
                 <th>Status</th>
                 <th>Final Tag</th>
+                <th>Debug Scores</th>
                 <th>Review</th>
               </tr>
             </thead>
@@ -548,6 +570,18 @@ function App() {
                       onChange={(e) => queueFinalTagUpdate(item.id, e.target.value)}
                     />
                   </td>
+                  <td>
+                    <button onClick={() => toggleScoreDebug(item.id)}>
+                      {expandedScoreRows[item.id] ? "Hide JSON" : "Show JSON"}
+                    </button>
+                    {expandedScoreRows[item.id] && (
+                      <pre className="debug-json">
+                        {scoreLoadingByItem[item.id]
+                          ? "Loading..."
+                          : JSON.stringify(scoreDebugByItem[item.id] || {}, null, 2)}
+                      </pre>
+                    )}
+                  </td>
                   <td>
                     <button
                       disabled={opsLoading.updatingStatus}

frontend/src/api.js

@@ -137,10 +137,16 @@ function makeMockItems(runId, selectedFolders, threshold) {
       suggested_destination: `${mockState.settings.categories_root || "/mock/categories"}/${tag}`,
       final_tag: tag,
       final_destination: `${mockState.settings.categories_root || "/mock/categories"}/${tag}`,
-      status: "proposed",
+      status: needsReview ? "proposed" : "approved",
       needs_review: needsReview,
       review_reason: needsReview ? `Below threshold (${score.toFixed(3)} < ${threshold.toFixed(3)})` : null,
       migrated_to: null,
+      full_scores: Object.fromEntries(
+        [tag, ...pool.filter((x) => x !== tag)].map((name, i) => [
+          name,
+          Math.max(0.1, score - i * 0.08),
+        ])
+      ),
     };
   });
 }
@@ -289,6 +295,13 @@ function mockRequest(path, options = {}) {
     persistMockState();
     return Promise.resolve(item);
   }
+  if (path.match(/^\/items\/\d+\/scores$/) && method === "GET") {
+    const itemId = Number(path.split("/")[2]);
+    const run = Object.values(mockState.runs).find((r) => r.items.some((i) => i.id === itemId));
+    if (!run) return Promise.reject(new Error("Item not found"));
+    const item = run.items.find((i) => i.id === itemId);
+    return Promise.resolve({ item_id: item.id, full_scores: item.full_scores || {} });
+  }
   if (path.match(/^\/runs\/\d+\/batch$/) && method === "POST") {
     const runId = Number(path.split("/")[2]);
     const run = mockState.runs[runId];
@@ -367,9 +380,13 @@ export const api = {
     if (filters.needs_review !== undefined) {
       params.set("needs_review", String(filters.needs_review));
     }
+    if (filters.include_scores) {
+      params.set("include_scores", "true");
+    }
     const query = params.toString();
     return request(`/runs/${runId}/items${query ? `?${query}` : ""}`);
   },
+  getItemScores: (itemId) => request(`/items/${itemId}/scores`),
   updateItem: (itemId, payload) =>
     request(`/items/${itemId}`, {
       method: "PATCH",

frontend/src/styles.css

@@ -106,3 +106,16 @@ td {
   font-size: 12px;
   overflow-wrap: anywhere;
 }
+
+.debug-json {
+  margin-top: 6px;
+  max-width: 360px;
+  max-height: 220px;
+  overflow: auto;
+  font-size: 11px;
+  line-height: 1.35;
+  background: #0f172a;
+  color: #e2e8f0;
+  border-radius: 8px;
+  padding: 8px;
+}