feat(review): offer inspection-profile choices for untraceable batches

Qwen image-edit batches run several KSamplers, each with its own
TextEncodeQwenImageEdit prompt, all saved under one prefix. The scan's
default profile knows neither the encoder nor the string nodes, so every
candidate was unresolved and the files left Needs review as "could not be
traced", although the inspection profile resolves every text.

When the default profile is ambiguous without a choice and nothing links
the file, the scan now resolves it with the inspection profile and, with at
least two choosable candidates, queues the item from that evidence. The
evidence records profile "inspection" and the semantics table version
(SHA-256 of its canonical JSON); the item's resolver_version folds the
profile, RESOLVER_VERSION and the table version, so a table change is
handled like a resolver change (I2). Apply re-resolves the capture with the
recorded profile, re-checks the chosen candidate hash and links through the
compatible-only ingestion. The inspection profile never links on its own,
ingestion keeps the default profile, and the live monitor never queues.

py/api/admin.py

@@ -45,7 +45,7 @@ try:
         parse_page_json,
     )
     from ...utils.prompt_pair_resolver import resolve_prompt_pair
-    from ...utils.review_capture import reviewable
+    from ...utils.review_capture import inspection_offers_choice, reviewable
 except ImportError:
     from database.operations import PromptDatabase
     from database.pair_ingestion import ingest_resolved_pair
@@ -56,7 +56,7 @@ except ImportError:
         parse_page_json,
     )
     from utils.prompt_pair_resolver import resolve_prompt_pair
-    from utils.review_capture import reviewable
+    from utils.review_capture import inspection_offers_choice, reviewable
 
 
 try:
@@ -252,6 +252,22 @@ def _file_size(path):
         return None
 
 
+def _untraced_outcome(media_file, canonical, ambiguous, untraced):
+    """The status of an unlinked file the default profile found ambiguous
+    without a choice: ``"ambiguous"`` when the inspection profile offers one
+    (the file moves from ``untraced`` to ``ambiguous``), else ``"unresolved"``.
+
+    Asked only when ``ambiguous`` is a list (the scan, which records review
+    items), so other callers never pay for the heavier profile.
+    """
+    if ambiguous is None or not inspection_offers_choice(canonical):
+        return "unresolved"
+    if untraced is not None and media_file in untraced:
+        untraced.remove(media_file)
+    ambiguous.append(media_file)
+    return "ambiguous"
+
+
 def _with_file_size(canonical, media_file):
     """Record the file's size in ``file_info`` unless the metadata carries one.
 
@@ -1714,7 +1730,10 @@ class AdminRoutesMixin:
         ``"ambiguous"`` (nothing linked it) is a Needs review case. An
         ambiguous result with nothing to choose (``reviewable`` is False: fewer
         than two candidates carry a prompt) that nothing links returns
-        ``"unresolved"`` instead, and ``media_file`` goes to ``untraced``.
+        ``"unresolved"`` instead, and ``media_file`` goes to ``untraced``,
+        unless the inspection profile offers a choice (only asked when
+        ``ambiguous`` is a list, so only by the scan): then it is
+        ``"ambiguous"`` and goes to ``ambiguous``. That profile never links.
         """
         if not metadata:
             return None
@@ -1756,9 +1775,13 @@ class AdminRoutesMixin:
             # Graphs without a recognized sampler keep the legacy extractor below.
             prompt_text = self._graph_prompt_text(metadata)
             if not prompt_text:
-                return "unresolved" if unchoosable else resolution["state"]
+                if unchoosable:
+                    return _untraced_outcome(media_file, canonical, ambiguous, untraced)
+                return resolution["state"]
         elif resolution["state"] == "ambiguous":
-            return "unresolved" if unchoosable else "ambiguous"
+            if unchoosable:
+                return _untraced_outcome(media_file, canonical, ambiguous, untraced)
+            return "ambiguous"
         elif resolution["state"] == "unresolved" and not isinstance(
             canonical.get("parameters"), str
         ):

py/api/review.py

@@ -38,13 +38,17 @@ try:
     from ...database.library_commands import LibraryCommandError
     from ...database.review_decisions import ReviewCommandError
     from ...utils.media_capture import CaptureError
-    from ...utils.review_capture import captured_review, review_evidence
+    from ...utils.review_capture import (
+        captured_review,
+        item_profile,
+        review_evidence,
+    )
 except ImportError:
     from database.library import display_title
     from database.library_commands import LibraryCommandError
     from database.review_decisions import ReviewCommandError
     from utils.media_capture import CaptureError
-    from utils.review_capture import captured_review, review_evidence
+    from utils.review_capture import captured_review, item_profile, review_evidence
 
 ITEMS_URL = "/prompt_manager/review/items"
 DEFAULT_LIMIT = 40
@@ -641,7 +645,8 @@ def _verify_and_read(store, capture, item, root, need_metadata: bool):
     """Worker thread: ``(relative, facts, captured)``, or None off the root.
 
     Formats the item's target under the capture's root (resolving the root's
-    real path), re-hashes the current file, then reads the capture.
+    real path), re-hashes the current file, then reads the capture and
+    resolves it with the profile the item's evidence was recorded with.
     """
     found = format_review_target(
         item["spelled_path"],
@@ -652,7 +657,9 @@ def _verify_and_read(store, capture, item, root, need_metadata: bool):
         return None
     relative = found[1]
     facts = store.verify(root, relative)
-    captured = captured_review(store, capture) if need_metadata else None
+    captured = None
+    if need_metadata:
+        captured = captured_review(store, capture, item_profile(item["evidence"]))
     return relative, facts, captured
 
 

py/api/review_recording.py

@@ -8,7 +8,8 @@ already. A file the fallback links, an exact pair the ingester stored and an
 already linked file are never queued. Neither is an ambiguous file with
 nothing to choose: fewer than two of its candidates carry a prompt
 (``utils.review_capture.reviewable``); the scan reports it unresolved ("could
-not be traced").
+not be traced") unless the inspection profile finds a choice in it. Only the
+scan asks that profile (``inspection=True``); the monitor never does.
 
 The queue heals itself: a pending item whose file is now linked (by the
 fallback, a later resolution or the monitor) is removed by the next scan
@@ -57,7 +58,9 @@ class ReviewRecordingMixin:
     def _record_scanned_review(self, media_file, roots, review=None):
         """Record one ambiguous, unlinked scanned file (logged and counted)."""
         try:
-            outcome = self._record_review_sync(media_file, roots, review)
+            outcome = self._record_review_sync(
+                media_file, roots, review, inspection=True
+            )
         except Exception:
             self.logger.warning(
                 f"{media_file.name} could not be added to Needs review",
@@ -73,9 +76,11 @@ class ReviewRecordingMixin:
         if outcome in QUEUED_OUTCOMES:
             review["queued"] += 1
 
-    def _record_review_sync(self, media_file, roots, review=None):
+    def _record_review_sync(self, media_file, roots, review=None, inspection=False):
         """``record_ambiguous_file`` for a file under one of ``roots`` (blocking).
 
+        ``inspection`` (the scan only) lets a file without a choice under the
+        default profile be recorded from the inspection profile's choices.
         An ``untraced`` file (its captured bytes offer nothing to choose) also
         loses its pending items that offer nothing either.
         """
@@ -84,7 +89,12 @@ class ReviewRecordingMixin:
             return "skipped"
         root, index, relative, _spelled = located
         outcome = record_ambiguous_file(
-            self.db, self._capture_store(), Path(root), index, relative
+            self.db,
+            self._capture_store(),
+            Path(root),
+            index,
+            relative,
+            inspection=inspection,
         )
         if outcome == "untraced":
             self._settle_untraced_reviews([media_file], roots, review)