Re-upload current cxr_auditor package with salvage parsing (robustness fix)

cxr_auditor/inference.py

@@ -18,9 +18,18 @@ the grounding turn). That same ``generate_fn`` shape is exactly what
 its documented injected-callable contract rather than re-implemented here, and the
 whole orchestration is testable with a fake ``generate_fn`` and no model.
 
-A retry-on-invalid-JSON loop (``run_with_retry``) wraps each generation so a
-single malformed completion is re-attempted (a fresh generation) before failing;
-the final ``SchemaParseError`` carries the last raw text for inspection.
+A retry-on-invalid-JSON ladder (``run_with_retry``) wraps each generation. Each
+attempt changes the conditions so a deterministic failure mode cannot simply
+repeat: attempt one decodes greedily with the base prompt, attempt two appends a
+corrective instruction (``RETRY_CORRECTIVE_SUFFIX``), and attempt three switches
+to sampling (``RETRY_SAMPLING_SETTINGS``). Every parse failure is logged to
+stdout with its full traceback and the offending raw model text, and the final
+``SchemaParseError`` carries the last raw text for inspection. Draft parsing
+degrades gracefully: when the draft cannot be parsed after its retries, the audit
+proceeds image-only and records ``AuditOutcome.draft_parse_note`` so the user
+interface can say so prominently. ``categorize_serving_error`` maps the
+exceptions an audit call can surface (including the string-transported ZeroGPU
+platform errors) to honest, user-facing messages.
 
 The heavy stack (torch, transformers) is imported lazily via ``importlib`` inside
 ``load_model`` and ``_generate_text`` so importing this module on a pure-logic
@@ -41,6 +50,8 @@ safe to call from a GPU worker.
 from __future__ import annotations
 
 import importlib
+import sys
+import traceback
 from collections.abc import Callable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
@@ -75,6 +86,99 @@ DEFAULT_MAX_NEW_TOKENS: int = 512
 # this many additional re-generations.
 DEFAULT_MAX_RETRIES: int = 2
 
+# Draft-parsing retry budget: one initial attempt plus this many retries. Smaller
+# than the grounding budget because draft parsing degrades gracefully (the audit
+# proceeds image-only), and the combined worst case of grounding plus draft
+# attempts must stay inside the GPU duration the serving app declares.
+DRAFT_MAX_RETRIES: int = 1
+
+# User-facing note recorded on the outcome when a supplied draft could not be
+# parsed after all retries and the audit proceeded image-only.
+DRAFT_PARSE_FAILURE_NOTE: str = "The draft text could not be parsed; results show image findings only."
+
+# Corrective instruction appended to the prompt on retry attempts, so a retry
+# never repeats the exact conditions that already failed deterministically.
+RETRY_CORRECTIVE_SUFFIX: str = (
+    "\nIMPORTANT: your previous reply was not one valid JSON array. "
+    "Reply with ONE complete JSON array, starting with '[' and ending with ']'. "
+    "Do not repeat elements. No prose."
+)
+
+# Truncation bound for raw model text echoed into stdout logs on parse failures.
+_RAW_TEXT_LOG_LIMIT: int = 2000
+
+
+@dataclass(frozen=True, slots=True)
+class GenerationSettings:
+    """Decoding settings for one model generation.
+
+    Attributes:
+        do_sample: Whether to sample instead of decoding greedily.
+        temperature: Sampling temperature; only forwarded when ``do_sample``.
+        top_p: Nucleus-sampling probability mass; only forwarded when
+            ``do_sample``.
+    """
+
+    do_sample: bool = False
+    temperature: float | None = None
+    top_p: float | None = None
+
+
+# Deterministic greedy decoding: the default for every first attempt.
+GREEDY_SETTINGS: GenerationSettings = GenerationSettings()
+
+# Mild sampling for the final retry attempt: enough randomness to escape a
+# deterministic degenerate completion while keeping the constrained JSON shape
+# likely.
+RETRY_SAMPLING_SETTINGS: GenerationSettings = GenerationSettings(do_sample=True, temperature=0.4, top_p=0.9)
+
+# A factory producing a ``GenerateFn`` bound to specific decoding settings. The
+# retry ladder requests a fresh ``GenerateFn`` per attempt so attempt three can
+# switch from greedy decoding to sampling.
+type GenerateFnFactory = Callable[[GenerationSettings], GenerateFn]
+
+
+def _attempt_settings(attempt: int) -> tuple[GenerationSettings, bool]:
+    """Return the decoding plan for a 1-based retry-ladder attempt.
+
+    Attempt 1 decodes greedily with the base prompt; attempt 2 keeps greedy
+    decoding but appends the corrective suffix; attempt 3 and beyond switch to
+    sampling (still with the suffix) so a deterministic failure cannot repeat
+    verbatim.
+
+    Args:
+        attempt: The 1-based attempt number.
+
+    Returns:
+        A ``(settings, append_corrective_suffix)`` pair.
+    """
+    if attempt == 1:
+        return GREEDY_SETTINGS, False
+    if attempt == 2:
+        return GREEDY_SETTINGS, True
+    return RETRY_SAMPLING_SETTINGS, True
+
+
+def _log_parse_failure(stage: str, attempt: int, error: SchemaParseError) -> None:
+    """Print a parse failure's traceback and raw model text to stdout.
+
+    Worker stdout reaches the serving platform's run logs, so this is the durable
+    diagnostic channel for malformed model output: the full traceback shows where
+    parsing failed and the delimited block shows exactly what the model emitted
+    (truncated to ``_RAW_TEXT_LOG_LIMIT`` characters to keep log entries bounded).
+
+    Args:
+        stage: The pipeline stage that failed (for example ``"image_grounding"``).
+        attempt: The 1-based attempt number that produced the failure.
+        error: The parse error carrying the offending raw model text.
+    """
+    print(f"[cxr-auditor] parse failure: stage={stage} attempt={attempt}", flush=True)
+    traceback.print_exception(error, file=sys.stdout)
+    raw = error.raw_text
+    if len(raw) > _RAW_TEXT_LOG_LIMIT:
+        raw = f"{raw[:_RAW_TEXT_LOG_LIMIT]} ...[truncated]"
+    print(f"[cxr-auditor] raw model text (stage={stage} attempt={attempt}) >>>\n{raw}\n<<<", flush=True)
+
 
 @dataclass(frozen=True, slots=True)
 class AuditOutcome:
@@ -89,10 +193,14 @@ class AuditOutcome:
         result: The canonical ``AuditResult`` (image findings, draft findings,
             label-only audit, disclaimer, box format).
         comparison: The per-item comparator detail (boxes, urgency, draft spans).
+        draft_parse_note: A user-facing note set when a supplied draft could not
+            be parsed after all retries, so the audit proceeded image-only.
+            ``None`` when no draft was supplied or the draft parsed.
     """
 
     result: AuditResult
     comparison: ComparisonReport
+    draft_parse_note: str | None = None
 
 
 def grounded_dicts_to_image_findings(grounded: list[dict[str, Any]]) -> list[ImageFinding]:
@@ -186,29 +294,34 @@ def _coerce_confidence(raw: Any) -> float | None:
 
 
 def run_with_retry(
-    generate_fn: GenerateFn,
+    generate_fn_factory: GenerateFnFactory,
     prompt: str,
     parse_fn: Callable[[str], list[Any]],
     max_retries: int = DEFAULT_MAX_RETRIES,
+    *,
+    stage: str = "generation",
 ) -> list[Any]:
-    """Generate then parse, retrying when the parse fails on invalid JSON.
+    """Generate then parse, escalating the retry conditions on each failure.
 
     The model occasionally emits prose, a truncated array, or otherwise
-    unparseable text. This re-invokes ``generate_fn`` with the same prompt up to
-    ``max_retries`` additional times, returning the first successful parse. If
-    every attempt fails, the last ``SchemaParseError`` is raised so its
-    ``raw_text`` (the final raw completion) is available to the caller.
-
-    The retry is a plain re-generation: a fresh model call is the cheapest
-    effective repair for transient malformed output. Callers wanting a stricter
-    repair can wrap ``generate_fn`` to append a corrective instruction on retry.
+    unparseable text - and a greedy decode of the same prompt fails the same way
+    every time. Each attempt therefore changes the conditions per
+    ``_attempt_settings``: attempt 1 is greedy with the base prompt, attempt 2 is
+    greedy with ``RETRY_CORRECTIVE_SUFFIX`` appended, and attempt 3 onward samples
+    (``RETRY_SAMPLING_SETTINGS``) with the suffix. Every failed attempt is logged
+    to stdout with its traceback and raw model text. If every attempt fails, the
+    last ``SchemaParseError`` is raised so its ``raw_text`` (the final raw
+    completion) is available to the caller.
 
     Args:
-        generate_fn: Callable mapping the prompt to the model's raw completion.
-        prompt: The rendered prompt to send on every attempt.
+        generate_fn_factory: Factory returning a ``GenerateFn`` for the decoding
+            settings of each attempt.
+        prompt: The rendered base prompt (the corrective suffix is appended to it
+            on retry attempts).
         parse_fn: A tolerant parser turning raw text into a list (raises
             ``SchemaParseError`` on unparseable text).
         max_retries: Number of additional attempts after the first. Must be >= 0.
+        stage: Stage label used in failure logs (keyword-only).
 
     Returns:
         The first successfully parsed list.
@@ -221,42 +334,75 @@ def run_with_retry(
         raise ValueError(f"max_retries must be non-negative, got {max_retries}")
 
     last_error: SchemaParseError | None = None
-    for _attempt in range(max_retries + 1):
-        raw_text = generate_fn(prompt)
+    for attempt in range(1, max_retries + 2):
+        settings, corrective = _attempt_settings(attempt)
+        generate_fn = generate_fn_factory(settings)
+        attempt_prompt = prompt + RETRY_CORRECTIVE_SUFFIX if corrective else prompt
+        raw_text = generate_fn(attempt_prompt)
         try:
             return parse_fn(raw_text)
         except SchemaParseError as exc:
             last_error = exc
+            _log_parse_failure(stage, attempt, exc)
     assert last_error is not None  # loop runs at least once, so an error was set
     raise last_error
 
 
-def make_generate_fn(model: Any, processor: Any, image: Image.Image) -> GenerateFn:
+def make_generate_fn(
+    model: Any,
+    processor: Any,
+    image: Image.Image,
+    settings: GenerationSettings = GREEDY_SETTINGS,
+) -> GenerateFn:
     """Build an image-bound ``generate_fn`` over a loaded model and processor.
 
-    The returned closure captures the model, processor, and image, exposing the
-    text-in/text-out ``GenerateFn`` shape that the grounding path, the retry loop,
-    and ``cxr_auditor.parser.parse_draft`` all consume. Binding the image into the
-    closure lets the draft parser - which only knows about a text-prompt
-    ``generate_fn`` - reuse the same single-turn multimodal model the grounding
-    step uses, satisfying the Gate C decision to parse the draft with the SAME
-    model.
+    The returned closure captures the model, processor, image, and decoding
+    settings, exposing the text-in/text-out ``GenerateFn`` shape that the
+    grounding path, the retry ladder, and ``cxr_auditor.parser.parse_draft`` all
+    consume. Binding the image into the closure lets the draft parser - which
+    only knows about a text-prompt ``generate_fn`` - reuse the same single-turn
+    multimodal model the grounding step uses, so the draft is parsed with the
+    SAME model rather than a separate text-only stack.
 
     Args:
         model: A loaded vision-language model exposing ``generate``.
         processor: The matching transformers processor.
         image: The chest X-ray bound to every generation through this closure.
+        settings: Decoding settings bound to every generation through this
+            closure.
 
     Returns:
         A ``GenerateFn`` mapping a rendered prompt to the model's raw completion.
     """
 
     def _generate(prompt: str) -> str:
-        return _generate_text(model, processor, prompt, image)
+        return _generate_text(model, processor, prompt, image, settings=settings)
 
     return _generate
 
 
+def _generate_fn_factory(model: Any, processor: Any, image: Image.Image) -> GenerateFnFactory:
+    """Build a settings-to-``GenerateFn`` factory bound to one model and image.
+
+    This is the shape the retry ladder consumes: each attempt requests a
+    ``GenerateFn`` for its own decoding settings while the model, processor, and
+    image stay fixed.
+
+    Args:
+        model: A loaded vision-language model exposing ``generate``.
+        processor: The matching transformers processor.
+        image: The chest X-ray bound to every generation.
+
+    Returns:
+        A factory mapping ``GenerationSettings`` to an image-bound ``GenerateFn``.
+    """
+
+    def _factory(settings: GenerationSettings) -> GenerateFn:
+        return make_generate_fn(model, processor, image, settings=settings)
+
+    return _factory
+
+
 def generate_findings(
     image: Image.Image,
     *,
@@ -266,8 +412,8 @@ def generate_findings(
 ) -> list[ImageFinding]:
     """Ground an image into validated ``ImageFinding`` objects.
 
-    Builds the pinned image-grounding prompt, generates through the invalid-JSON
-    retry loop, and assembles validated findings. This is the image-side entry
+    Builds the pinned image-grounding prompt, generates through the escalating
+    retry ladder, and assembles validated findings. This is the image-side entry
     point the app uses when it wants only the grounded findings (for example to
     draw boxes before a draft is supplied).
 
@@ -275,7 +421,7 @@ def generate_findings(
         image: The chest X-ray as a PIL image.
         model: A loaded vision-language model (keyword-only).
         processor: The matching transformers processor (keyword-only).
-        max_retries: Retry budget for the invalid-JSON loop (keyword-only).
+        max_retries: Retry budget for the invalid-JSON ladder (keyword-only).
 
     Returns:
         The image-grounded findings with bounding-box evidence.
@@ -283,8 +429,13 @@ def generate_findings(
     Raises:
         SchemaParseError: If grounding output cannot be parsed after all retries.
     """
-    generate_fn = make_generate_fn(model, processor, image)
-    grounded = run_with_retry(generate_fn, build_image_grounding_prompt(), extract_finding_list, max_retries=max_retries)
+    grounded = run_with_retry(
+        _generate_fn_factory(model, processor, image),
+        build_image_grounding_prompt(),
+        extract_finding_list,
+        max_retries=max_retries,
+        stage="image_grounding",
+    )
     return grounded_dicts_to_image_findings(grounded)
 
 
@@ -300,10 +451,13 @@ def run_audit(
 
     Steps:
         1. Ground the image into validated ``ImageFinding`` objects
-           (``generate_findings``), through the invalid-JSON retry loop.
+           (``generate_findings``), through the escalating retry ladder.
         2. If a non-blank draft is supplied, parse it into the same label space via
            ``cxr_auditor.parser.parse_draft``, driven by an image-bound
-           ``generate_fn`` and wrapped in the same retry loop.
+           ``generate_fn`` through the same ladder (with the ``DRAFT_MAX_RETRIES``
+           budget). A draft that still cannot be parsed never fails the audit: the
+           audit proceeds image-only and ``AuditOutcome.draft_parse_note`` records
+           the degradation for the user interface.
         3. Run the deterministic comparator (``cxr_auditor.comparator.compare``) and
            bundle everything into an ``AuditOutcome``.
 
@@ -318,15 +472,17 @@ def run_audit(
             image-side findings (and urgent flags).
         model: A loaded vision-language model exposing ``generate`` (keyword-only).
         processor: The matching transformers processor (keyword-only).
-        max_retries: Retry budget for both invalid-JSON loops (keyword-only).
+        max_retries: Retry budget for the image-grounding ladder (keyword-only).
+            Draft parsing uses the fixed ``DRAFT_MAX_RETRIES`` budget because it
+            degrades gracefully instead of failing.
 
     Returns:
-        An ``AuditOutcome`` carrying the canonical ``AuditResult`` and the per-item
-        ``ComparisonReport``.
+        An ``AuditOutcome`` carrying the canonical ``AuditResult``, the per-item
+        ``ComparisonReport``, and the draft-degradation note when it applies.
 
     Raises:
         ValueError: If ``model`` or ``processor`` is not supplied.
-        SchemaParseError: If the model emits text that cannot be parsed into a
+        SchemaParseError: If the image-grounding output cannot be parsed into a
             finding list after all retries.
     """
     if model is None or processor is None:
@@ -335,10 +491,16 @@ def run_audit(
     image_findings = generate_findings(image, model=model, processor=processor, max_retries=max_retries)
 
     draft_findings: list[DraftFinding] = []
+    draft_parse_note: str | None = None
     cleaned_draft = (draft_text or "").strip()
     if cleaned_draft:
-        generate_fn = make_generate_fn(model, processor, image)
-        draft_findings = _parse_draft_with_retry(cleaned_draft, generate_fn, max_retries=max_retries)
+        try:
+            draft_findings = _parse_draft_with_retry(cleaned_draft, _generate_fn_factory(model, processor, image))
+        except SchemaParseError:
+            # Per-attempt details are already logged by _log_parse_failure; the
+            # audit degrades to image-only rather than failing on the draft.
+            print("[cxr-auditor] draft parsing failed after all retries; auditing image only", flush=True)
+            draft_parse_note = DRAFT_PARSE_FAILURE_NOTE
 
     comparison = compare(image_findings, draft_findings)
     result = AuditResult(
@@ -346,24 +508,46 @@ def run_audit(
         draft_findings=draft_findings,
         audit=comparison.audit,
     )
-    return AuditOutcome(result=result, comparison=comparison)
+    return AuditOutcome(result=result, comparison=comparison, draft_parse_note=draft_parse_note)
+
+
+def _with_corrective_suffix(generate_fn: GenerateFn) -> GenerateFn:
+    """Wrap a ``GenerateFn`` so every prompt carries the corrective suffix.
+
+    ``parser.parse_draft`` builds its prompt internally, so retry attempts inject
+    ``RETRY_CORRECTIVE_SUFFIX`` by wrapping the callable rather than editing the
+    prompt directly.
+
+    Args:
+        generate_fn: The inner ``GenerateFn`` to wrap.
+
+    Returns:
+        A ``GenerateFn`` that appends the corrective suffix to every prompt.
+    """
+
+    def _generate(prompt: str) -> str:
+        return generate_fn(prompt + RETRY_CORRECTIVE_SUFFIX)
+
+    return _generate
 
 
 def _parse_draft_with_retry(
     draft_text: str,
-    generate_fn: GenerateFn,
-    max_retries: int = DEFAULT_MAX_RETRIES,
+    generate_fn_factory: GenerateFnFactory,
+    max_retries: int = DRAFT_MAX_RETRIES,
 ) -> list[DraftFinding]:
-    """Parse a draft through ``parser.parse_draft`` with invalid-JSON retries.
+    """Parse a draft through ``parser.parse_draft`` with the escalating ladder.
 
-    Wraps the draft parser's injected-callable contract in the same
-    re-generation retry policy the grounding path uses: each attempt re-runs the
-    full ``parse_draft`` (build prompt, generate, validate); the first successful
-    parse wins, and the final ``SchemaParseError`` propagates if all attempts fail.
+    Wraps the draft parser's injected-callable contract in the same attempt plan
+    the grounding path uses (``_attempt_settings``): each attempt re-runs the full
+    ``parse_draft`` (build prompt, generate, validate), retry attempts append the
+    corrective suffix via a wrapped ``GenerateFn``, the first successful parse
+    wins, and the final ``SchemaParseError`` propagates if all attempts fail.
 
     Args:
         draft_text: The non-empty draft impression to parse.
-        generate_fn: The image-bound ``generate_fn`` driving the parser.
+        generate_fn_factory: Factory returning an image-bound ``GenerateFn`` for
+            each attempt's decoding settings.
         max_retries: Number of additional attempts after the first. Must be >= 0.
 
     Returns:
@@ -377,11 +561,16 @@ def _parse_draft_with_retry(
         raise ValueError(f"max_retries must be non-negative, got {max_retries}")
 
     last_error: SchemaParseError | None = None
-    for _attempt in range(max_retries + 1):
+    for attempt in range(1, max_retries + 2):
+        settings, corrective = _attempt_settings(attempt)
+        generate_fn = generate_fn_factory(settings)
+        if corrective:
+            generate_fn = _with_corrective_suffix(generate_fn)
         try:
             return parse_draft(draft_text, generate_fn)
         except SchemaParseError as exc:
             last_error = exc
+            _log_parse_failure("draft_parsing", attempt, exc)
     assert last_error is not None
     raise last_error
 
@@ -451,15 +640,23 @@ def load_model(model_id: str = DEFAULT_MODEL_ID) -> tuple[Any, Any]:
     return model, processor
 
 
-def _generate_text(model: Any, processor: Any, prompt: str, image: Image.Image) -> str:
+def _generate_text(
+    model: Any,
+    processor: Any,
+    prompt: str,
+    image: Image.Image,
+    settings: GenerationSettings = GREEDY_SETTINGS,
+) -> str:
     """Run one single-turn multimodal generation and return the decoded reply.
 
     This is the only function that touches the model at inference time, and the
     single seam tests patch to drive the orchestration without a real model. It
     builds a single-turn chat message with the image and the prompt text, applies
-    the processor's chat template, generates greedily, and decodes only the newly
-    generated tokens (slicing off the prompt) so the returned text is just the
-    model's reply (a plain ``str``, never a tensor across a worker boundary).
+    the processor's chat template, generates with the supplied decoding settings,
+    and decodes only the newly generated tokens (slicing off the prompt) so the
+    returned text is just the model's reply (a plain ``str``, never a tensor
+    across a worker boundary). ``pad_token_id`` is pinned to the tokenizer's
+    end-of-sequence token so generation runs without a pad-token warning.
 
     Heavy imports are local to keep module import free of the vision stack. The
     chat-message construction follows the transformers image-text-to-text
@@ -471,6 +668,7 @@ def _generate_text(model: Any, processor: Any, prompt: str, image: Image.Image)
         processor: The matching processor.
         prompt: The fully rendered text prompt.
         image: The chest X-ray as a PIL image.
+        settings: Decoding settings for this generation.
 
     Returns:
         The model's decoded reply text (prompt tokens stripped).
@@ -494,19 +692,135 @@ def _generate_text(model: Any, processor: Any, prompt: str, image: Image.Image)
         return_tensors="pt",
     ).to(model.device)
 
+    generate_kwargs: dict[str, Any] = {
+        "max_new_tokens": DEFAULT_MAX_NEW_TOKENS,
+        "do_sample": settings.do_sample,
+        "pad_token_id": processor.tokenizer.eos_token_id,
+    }
+    # Sampling knobs are forwarded only when sampling; transformers warns when
+    # they accompany greedy decoding.
+    if settings.do_sample:
+        if settings.temperature is not None:
+            generate_kwargs["temperature"] = settings.temperature
+        if settings.top_p is not None:
+            generate_kwargs["top_p"] = settings.top_p
+
     input_len = inputs["input_ids"].shape[-1]
     with torch.inference_mode():
-        generated = model.generate(**inputs, max_new_tokens=DEFAULT_MAX_NEW_TOKENS, do_sample=False)
+        generated = model.generate(**inputs, **generate_kwargs)
     new_tokens = generated[0][input_len:]
     return processor.decode(new_tokens, skip_special_tokens=True)
 
 
+# Titles the ZeroGPU scheduler attaches to the quota and scheduling errors it
+# raises in the serving app's main process. These failures are platform-side: the
+# uploaded image is never the cause, so the user message must not blame it.
+_GPU_SCHEDULING_ERROR_TITLES: frozenset[str] = frozenset(
+    {
+        "ZeroGPU quota exceeded",
+        "ZeroGPU illegal duration",
+        "ZeroGPU pending credits exceeded",
+        "ZeroGPU queue timeout",
+        "ZeroGPU client error",
+    }
+)
+
+# Title the ZeroGPU platform attaches when a worker exception was converted to a
+# string-transported error whose message body is the worker exception class name.
+_WORKER_ERROR_TITLE: str = "ZeroGPU worker error"
+
+# Worker exception class names that mean "the model output could not be parsed".
+_PARSE_ERROR_CLASS_NAMES: frozenset[str] = frozenset({"SchemaParseError"})
+
+# Message body the ZeroGPU platform uses when it cuts a GPU task short.
+_GPU_TASK_ABORTED_BODY: str = "GPU task aborted"
+
+_GPU_QUOTA_MESSAGE: str = (
+    "**GPU quota reached.** Free ZeroGPU time is temporarily exhausted, so this audit could not get a "
+    "GPU slot - the image is not the problem. Wait a few minutes and press Run audit again."
+)
+
+_GPU_INTERRUPTED_MESSAGE: str = (
+    "**GPU task was interrupted.** The platform cut the GPU run short before the audit finished. "
+    "Please press Run audit again."
+)
+
+
+def _parse_failure_message(class_name: str) -> str:
+    """Return the user-facing message for an unparseable-model-output failure."""
+    return (
+        f"**Could not analyze this image.** The model returned output that could not be parsed ({class_name}). "
+        "Please try again, or use a clearer frontal chest X-ray."
+    )
+
+
+def _generic_failure_message(detail: str) -> str:
+    """Return the user-facing message for an uncategorized failure."""
+    return (
+        f"**Audit failed.** An unexpected error occurred ({detail}). "
+        "Please try again; if this keeps happening, check the Space logs."
+    )
+
+
+def categorize_serving_error(error: Exception) -> str:
+    """Map an audit-time exception to an honest, user-facing Markdown message.
+
+    The ZeroGPU platform never pickles worker exceptions across the process
+    boundary: it transports the worker exception's class name as the message body
+    of a gradio error object whose own class ``__name__`` is literally ``"Error"``
+    and whose ``title`` attribute names the failure source. This categorizer
+    therefore classifies on the exception's class name, ``title`` attribute, and
+    message body - never on ``isinstance`` against gradio types - so it stays
+    importable and unit-testable without gradio installed.
+
+    Categories:
+        - Quota and scheduling errors (a title in the known ZeroGPU set, or any
+          title or body mentioning "quota") produce a GPU-quota message that
+          never blames the image.
+        - An aborted GPU task (body ``"GPU task aborted"``) produces a transient
+          interrupted-please-retry message.
+        - A worker error whose body names a parse-failure class, or a directly
+          raised ``SchemaParseError``, produces the could-not-parse message
+          naming the real exception class.
+        - Anything else produces a generic failure message naming the true type.
+
+    Args:
+        error: The exception caught around the GPU audit call.
+
+    Returns:
+        A Markdown message suitable for the audit panel.
+    """
+    if isinstance(error, SchemaParseError):
+        return _parse_failure_message(type(error).__name__)
+
+    body = str(error)
+    if type(error).__name__ == "Error":
+        title = str(getattr(error, "title", ""))
+        if title in _GPU_SCHEDULING_ERROR_TITLES or "quota" in title.lower() or "quota" in body.lower():
+            return _GPU_QUOTA_MESSAGE
+        if _GPU_TASK_ABORTED_BODY in body:
+            return _GPU_INTERRUPTED_MESSAGE
+        if title == _WORKER_ERROR_TITLE:
+            if body in _PARSE_ERROR_CLASS_NAMES:
+                return _parse_failure_message(body)
+            return _generic_failure_message(body or type(error).__name__)
+    return _generic_failure_message(type(error).__name__)
+
+
 __all__ = [
     "DEFAULT_MAX_NEW_TOKENS",
     "DEFAULT_MAX_RETRIES",
     "DEFAULT_MODEL_ID",
+    "DRAFT_MAX_RETRIES",
+    "DRAFT_PARSE_FAILURE_NOTE",
+    "GREEDY_SETTINGS",
+    "RETRY_CORRECTIVE_SUFFIX",
+    "RETRY_SAMPLING_SETTINGS",
     "AuditOutcome",
+    "GenerateFnFactory",
+    "GenerationSettings",
     "audit",
+    "categorize_serving_error",
     "generate_findings",
     "grounded_dicts_to_image_findings",
     "load_model",

cxr_auditor/parser.py

@@ -1,7 +1,7 @@
 """
 Draft-report parser: map a draft impression into the canonical label space.
 
-This is Gate C's PRIMARY parser. It prompts the same MedGemma model (via the
+This is the PRIMARY draft parser. It prompts the same MedGemma model (via the
 pinned draft-parsing prompt) to extract which canonical findings a draft
 impression asserts present and which it explicitly denies, then validates the
 model's JSON list into ``DraftFinding`` objects.

cxr_auditor/render.py

@@ -32,12 +32,22 @@ the others. ``cluster_overlay_boxes`` merges spatially-overlapping boxes into on
 is drawn exactly once with the correct, order-independent color and a single
 combined label.
 
+Label collision avoidance
+-------------------------
+Distinct regions can still carry long labels at nearly the same height (for
+example bilateral opacities over the two lung fields), where independently
+placed label bands would overlap and clip each other. Each band is therefore
+checked against the bands already drawn on the canvas and nudged vertically
+(below its own box first) until it overlaps none of them, always staying
+clamped on-image; a lone label keeps its exact anchored position.
+
 Unsupported claims are draft-only and have no image box, so they appear in the
 table and the audit panel rather than as overlay boxes.
 """
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
 
@@ -64,6 +74,13 @@ _MAX_OVERLAY_LONG_SIDE = 1280
 _MIN_LABEL_FONT_SIZE = 14
 _MAX_LABEL_FONT_SIZE = 28
 
+# Vertical search budget for nudging a colliding label band: this many
+# band-height steps downward and again upward. At the tallest band a capped
+# canvas produces (about 37 px) eight steps sweep roughly 300 px each way -
+# ample clearance for the handful of labels one audit draws - while keeping
+# the candidate count, and therefore the worst-case drawing work, bounded.
+_LABEL_NUDGE_ATTEMPTS = 8
+
 # RGB colors for each evidence category. Chosen for contrast on a grayscale X-ray.
 _SUPPORTED_COLOR = (46, 204, 113)
 _MISSING_COLOR = (243, 156, 18)
@@ -317,6 +334,64 @@ def _combined_label(cluster: OverlayBox) -> str:
     return text
 
 
+def _rects_overlap(a: XYXYBox, b: XYXYBox) -> bool:
+    """Return whether two pixel rectangles share interior area.
+
+    Rectangles are ``(left, top, right, bottom)``. Edge-touching rectangles do
+    not count as overlapping, so nudged label bands may sit flush against one
+    another without triggering a further nudge.
+    """
+    a_left, a_top, a_right, a_bottom = a
+    b_left, b_top, b_right, b_bottom = b
+    return a_left < b_right and b_left < a_right and a_top < b_bottom and b_top < a_bottom
+
+
+def _resolve_band_rect(
+    desired: XYXYBox,
+    box_xyxy: XYXYBox,
+    image_height: int,
+    placed_bands: Sequence[XYXYBox],
+) -> XYXYBox:
+    """Return the label-band rectangle to draw, nudged vertically clear of placed bands.
+
+    A desired rectangle that overlaps no already-placed band is returned
+    unchanged, so a lone label renders exactly at its anchored position. On
+    collision the band keeps its horizontal extent (it stays anchored to its
+    box) and tries vertical positions in order: just below the box's bottom
+    edge, then band-height steps downward from there, then band-height steps
+    upward from the desired position, up to ``_LABEL_NUDGE_ATTEMPTS`` steps per
+    direction. Every candidate is clamped fully on-image; when no candidate
+    clears all placed bands the last clamped candidate is returned, so the
+    result is always an on-image rectangle and rendering never fails.
+
+    Args:
+        desired: The preferred band rectangle ``(left, top, right, bottom)``,
+            already clamped on-image by the caller.
+        box_xyxy: The owning box in absolute pixels ``(x_min, y_min, x_max,
+            y_max)``, anchoring the below-box candidate.
+        image_height: The canvas height in pixels, for vertical clamping.
+        placed_bands: Band rectangles already drawn on this canvas.
+
+    Returns:
+        The chosen band rectangle ``(left, top, right, bottom)``.
+    """
+    left, desired_top, right, desired_bottom = desired
+    band_height = desired_bottom - desired_top
+    lowest_top = max(0.0, image_height - band_height)
+    below_box_top = min(box_xyxy[3], lowest_top)
+
+    candidate_tops = [desired_top, below_box_top]
+    candidate_tops.extend(min(below_box_top + step * band_height, lowest_top) for step in range(1, _LABEL_NUDGE_ATTEMPTS + 1))
+    candidate_tops.extend(max(0.0, desired_top - step * band_height) for step in range(1, _LABEL_NUDGE_ATTEMPTS + 1))
+
+    band = desired
+    for top in candidate_tops:
+        band = (left, top, right, top + band_height)
+        if not any(_rects_overlap(band, placed) for placed in placed_bands):
+            return band
+    return band
+
+
 def _draw_label(
     draw: ImageDraw.ImageDraw,
     box_xyxy: XYXYBox,
@@ -325,14 +400,17 @@ def _draw_label(
     color: tuple[int, int, int],
     font: LoadedFont,
     image_size: tuple[int, int],
-) -> None:
+    placed_bands: Sequence[XYXYBox],
+) -> XYXYBox:
     """Draw a filled, high-contrast label band anchored to a box, clamped on-image.
 
     The label sits just above the box top by default, but flips to just below the
     box top when there is no room above (the box touches the top edge), and its
     left edge is clamped so the band never runs off the right side of the image.
-    The band is filled with ``color`` and the text is drawn in a contrasting ink so
-    it is legible over a grayscale X-ray.
+    When the resulting band would overlap a band already drawn on this canvas it
+    is nudged vertically clear (see ``_resolve_band_rect``) so neighboring labels
+    never clip each other. The band is filled with ``color`` and the text is
+    drawn in a contrasting ink so it is legible over a grayscale X-ray.
 
     Args:
         draw: The active drawing context.
@@ -341,6 +419,11 @@ def _draw_label(
         color: The band fill color (the cluster's status color).
         font: The scaled font to measure and render with.
         image_size: ``(width, height)`` of the canvas, for on-image clamping.
+        placed_bands: Band rectangles already drawn on this canvas, used to
+            resolve collisions; the caller records the returned rectangle.
+
+    Returns:
+        The band rectangle ``(left, top, right, bottom)`` actually drawn.
     """
     image_width, image_height = image_size
     x_min, y_min, _x_max, _y_max = box_xyxy
@@ -361,11 +444,12 @@ def _draw_label(
         band_left = max(0, image_width - band_width)
     band_top = max(0, min(band_top, image_height - band_height))
 
-    draw.rectangle(
-        (band_left, band_top, band_left + band_width, band_top + band_height),
-        fill=color,
-    )
-    draw.text((band_left + pad, band_top + pad), text, fill=_contrast_ink(color), font=font)
+    desired = (band_left, band_top, band_left + band_width, band_top + band_height)
+    band = _resolve_band_rect(desired, box_xyxy, image_height, placed_bands)
+
+    draw.rectangle(band, fill=color)
+    draw.text((band[0] + pad, band[1] + pad), text, fill=_contrast_ink(color), font=font)
+    return band
 
 
 def _contrast_ink(color: tuple[int, int, int]) -> tuple[int, int, int]:
@@ -390,7 +474,9 @@ def annotate_evidence(image: Image.Image, outcome: AuditOutcome) -> Image.Image:
     (see ``cluster_overlay_boxes``) so each region is drawn exactly once, colored by
     audit status (see the module color legend). Urgent regions are drawn in red with
     a doubled, thicker border and an "(URGENT)" tag so they stand out. Every label
-    uses the human-readable display name. Findings without a localizable box
+    uses the human-readable display name, and label bands that would overlap an
+    earlier band are nudged vertically clear of it (see ``_resolve_band_rect``) so
+    neighboring labels stay readable. Findings without a localizable box
     contribute no drawing (they still appear in the table and panel).
 
     Args:
@@ -414,6 +500,8 @@ def annotate_evidence(image: Image.Image, outcome: AuditOutcome) -> Image.Image:
     # stay proportionate on both tiny test fixtures and canvas-capped X-rays.
     base_width = max(2, round(max(width, height) / 320))
 
+    # Bands already drawn on this canvas; each new label is nudged clear of them.
+    placed_bands: list[XYXYBox] = []
     for cluster in cluster_overlay_boxes(categorize_image_findings(outcome)):
         box_xyxy = normalized_to_xyxy_abs(cluster.box, width, height)
         x_min, y_min, x_max, y_max = box_xyxy
@@ -428,7 +516,17 @@ def annotate_evidence(image: Image.Image, outcome: AuditOutcome) -> Image.Image:
                 outline=color,
                 width=max(1, base_width),
             )
-        _draw_label(draw, box_xyxy, _combined_label(cluster), color=color, font=font, image_size=(width, height))
+        placed_bands.append(
+            _draw_label(
+                draw,
+                box_xyxy,
+                _combined_label(cluster),
+                color=color,
+                font=font,
+                image_size=(width, height),
+                placed_bands=placed_bands,
+            )
+        )
 
     return canvas
 
@@ -495,11 +593,13 @@ def _status_word(status: FindingStatus) -> str:
 def audit_panel_markdown(outcome: AuditOutcome) -> str:
     """Render the audit verdict as a plain-English Markdown panel.
 
-    Leads with a short "How to read this" orientation line, then lists urgent
-    flags first (most important), then missing findings, then unsupported claims,
-    with per-item detail (draft spans for unsupported claims). Every finding is
-    shown by its human-readable display name. When nothing is flagged, reports
-    agreement.
+    When the outcome carries a draft-degradation note (the draft could not be
+    parsed and the audit proceeded image-only), that note leads the panel so the
+    user re-checks the draft manually. Then comes a short "How to read this"
+    orientation line, urgent flags first (most important), missing findings,
+    and unsupported claims, with per-item detail (draft spans for unsupported
+    claims). Every finding is shown by its human-readable display name. When
+    nothing is flagged, reports agreement.
 
     Args:
         outcome: The audit outcome.
@@ -508,11 +608,22 @@ def audit_panel_markdown(outcome: AuditOutcome) -> str:
         A Markdown string.
     """
     audit = outcome.result.audit
-    lines: list[str] = [
-        "**How to read this:** this panel compares what the AI sees in the image against the draft text. "
-        "It is a research aid, not a diagnosis - always confirm with a qualified radiologist.",
-        "",
-    ]
+    lines: list[str] = []
+    if outcome.draft_parse_note is not None:
+        lines.extend(
+            [
+                f"**Draft not analyzed:** {outcome.draft_parse_note} "
+                "This audit reflects the image only - re-check the draft text manually.",
+                "",
+            ]
+        )
+    lines.extend(
+        [
+            "**How to read this:** this panel compares what the AI sees in the image against the draft text. "
+            "It is a research aid, not a diagnosis - always confirm with a qualified radiologist.",
+            "",
+        ]
+    )
 
     if audit.urgent_review_flags:
         lines.append("### URGENT - needs radiologist review")

cxr_auditor/schema.py

@@ -202,33 +202,39 @@ class SchemaParseError(ValueError):
         super().__init__(message)
         self.raw_text = raw_text
 
+    def __reduce__(self) -> tuple[type[SchemaParseError], tuple[str, str]]:
+        """Support pickling across process boundaries (for example a GPU worker).
 
-def extract_first_json_object(text: str) -> dict[str, Any]:
-    """Extract the first balanced top-level JSON object from raw model text.
+        The default exception reduction re-invokes the class with ``self.args``
+        only, which omits the required ``raw_text`` argument; returning both
+        constructor arguments keeps the error fully reconstructable.
 
-    Vision-language models frequently wrap their JSON in prose, markdown code
-    fences, or trailing commentary. This scans for the first ``{`` and walks the
-    string tracking brace depth (while respecting JSON string literals and escape
-    sequences) to find the matching close brace, then parses that slice.
+        Returns:
+            The ``(callable, args)`` pair pickle uses to rebuild the error.
+        """
+        return (type(self), (str(self.args[0]) if self.args else "", self.raw_text))
+
+
+def _find_balanced_end(text: str, start: int, open_char: str, close_char: str) -> int:
+    """Find the index of the close delimiter balancing ``text[start]``.
+
+    Walks the string from ``start`` (which must point at ``open_char``) tracking
+    nesting depth while respecting JSON string literals and escape sequences, so
+    a delimiter inside a quoted string never affects the depth count.
 
     Args:
-        text: Raw model output that contains a JSON object somewhere inside it.
+        text: The text to scan.
+        start: Index of the opening delimiter to balance.
+        open_char: The opening delimiter (for example ``"{"`` or ``"["``).
+        close_char: The matching closing delimiter (``"}"`` or ``"]"``).
 
     Returns:
-        The parsed object as a dict.
-
-    Raises:
-        SchemaParseError: If no balanced JSON object is found, or the candidate
-            slice is not valid JSON, or the top-level value is not an object.
+        The index of the balancing close delimiter, or ``-1`` when the text ends
+        before the delimiter closes.
     """
-    start = text.find("{")
-    if start == -1:
-        raise SchemaParseError("no JSON object found in model text", text)
-
     depth = 0
     in_string = False
     escaped = False
-    end = -1
     for index in range(start, len(text)):
         char = text[index]
         if in_string:
@@ -241,14 +247,38 @@ def extract_first_json_object(text: str) -> dict[str, Any]:
             continue
         if char == '"':
             in_string = True
-        elif char == "{":
+        elif char == open_char:
             depth += 1
-        elif char == "}":
+        elif char == close_char:
             depth -= 1
             if depth == 0:
-                end = index
-                break
+                return index
+    return -1
+
+
+def extract_first_json_object(text: str) -> dict[str, Any]:
+    """Extract the first balanced top-level JSON object from raw model text.
+
+    Vision-language models frequently wrap their JSON in prose, markdown code
+    fences, or trailing commentary. This scans for the first ``{`` and walks the
+    string tracking brace depth (while respecting JSON string literals and escape
+    sequences) to find the matching close brace, then parses that slice.
 
+    Args:
+        text: Raw model output that contains a JSON object somewhere inside it.
+
+    Returns:
+        The parsed object as a dict.
+
+    Raises:
+        SchemaParseError: If no balanced JSON object is found, or the candidate
+            slice is not valid JSON, or the top-level value is not an object.
+    """
+    start = text.find("{")
+    if start == -1:
+        raise SchemaParseError("no JSON object found in model text", text)
+
+    end = _find_balanced_end(text, start, "{", "}")
     if end == -1:
         raise SchemaParseError("no balanced JSON object found in model text", text)
 
@@ -295,13 +325,70 @@ def _strip_code_fences(text: str) -> str:
     return text
 
 
+# Upper bound on elements recovered by ``salvage_finding_list``. A degenerate
+# repetition loop can emit the same element until the token budget is exhausted;
+# the cap bounds the salvage work while comfortably exceeding any realistic
+# finding count for one image.
+_SALVAGE_MAX_ELEMENTS: int = 64
+
+
+def salvage_finding_list(text: str) -> list[dict[str, Any]]:
+    """Recover the complete leading elements of a truncated or malformed array.
+
+    A generation that exhausts its token budget mid-array leaves the JSON array
+    unclosed (or its tail malformed), which would otherwise discard every element
+    the model emitted. This walks the array's elements from the first ``[``,
+    extracting each balanced ``{...}`` slice and parsing it independently, and
+    stops at the first incomplete or invalid element, at the array's closing
+    bracket, or after ``_SALVAGE_MAX_ELEMENTS`` elements - so the complete
+    leading elements survive a broken tail. Markdown code fences are stripped
+    before scanning.
+
+    Args:
+        text: Raw model output containing at least the head of a JSON array.
+
+    Returns:
+        The successfully recovered element dicts, possibly empty.
+    """
+    stripped = _strip_code_fences(text)
+    array_start = stripped.find("[")
+    if array_start == -1:
+        return []
+
+    elements: list[dict[str, Any]] = []
+    cursor = array_start + 1
+    while len(elements) < _SALVAGE_MAX_ELEMENTS:
+        element_start = stripped.find("{", cursor)
+        if element_start == -1:
+            break
+        # A closing bracket between elements means the array ended; anything
+        # after it lies outside the array and must not be salvaged into it.
+        if "]" in stripped[cursor:element_start]:
+            break
+        element_end = _find_balanced_end(stripped, element_start, "{", "}")
+        if element_end == -1:
+            break
+        candidate = stripped[element_start : element_end + 1]
+        try:
+            parsed = json.loads(candidate)
+        except json.JSONDecodeError:
+            break
+        if not isinstance(parsed, dict):
+            break
+        elements.append(parsed)
+        cursor = element_end + 1
+    return elements
+
+
 def extract_finding_list(text: str) -> list[dict[str, Any]]:
     """Extract a JSON array of finding dicts from raw model text.
 
     MedGemma's native grounding output is a JSON *list* of ``{label, box_2d}``
     objects rather than a wrapping object. This finds the first balanced
     top-level JSON array and parses it. A bare object is tolerated and wrapped in
-    a single-element list.
+    a single-element list. When the array never closes or its slice is invalid
+    JSON (a truncated or degenerate generation), the complete leading elements
+    are recovered via ``salvage_finding_list`` before declaring failure.
 
     Args:
         text: Raw model output containing a JSON array (or a single object).
@@ -310,8 +397,9 @@ def extract_finding_list(text: str) -> list[dict[str, Any]]:
         A list of dicts (one per finding). Non-dict array elements are rejected.
 
     Raises:
-        SchemaParseError: If no balanced JSON array/object is found, the slice is
-            invalid JSON, or an array element is not an object.
+        SchemaParseError: If no balanced JSON array/object is found and nothing
+            can be salvaged, the slice is invalid JSON and nothing can be
+            salvaged, or a well-formed array contains a non-object element.
     """
     stripped = _strip_code_fences(text)
 
@@ -322,37 +410,20 @@ def extract_finding_list(text: str) -> list[dict[str, Any]]:
     if array_start == -1 or (object_start != -1 and object_start < array_start):
         return [extract_first_json_object(stripped)]
 
-    depth = 0
-    in_string = False
-    escaped = False
-    end = -1
-    for index in range(array_start, len(stripped)):
-        char = stripped[index]
-        if in_string:
-            if escaped:
-                escaped = False
-            elif char == "\\":
-                escaped = True
-            elif char == '"':
-                in_string = False
-            continue
-        if char == '"':
-            in_string = True
-        elif char == "[":
-            depth += 1
-        elif char == "]":
-            depth -= 1
-            if depth == 0:
-                end = index
-                break
-
+    end = _find_balanced_end(stripped, array_start, "[", "]")
     if end == -1:
+        salvaged = salvage_finding_list(text)
+        if salvaged:
+            return salvaged
         raise SchemaParseError("no balanced JSON array found in model text", text)
 
     candidate = stripped[array_start : end + 1]
     try:
         parsed = json.loads(candidate)
     except json.JSONDecodeError as exc:
+        salvaged = salvage_finding_list(text)
+        if salvaged:
+            return salvaged
         raise SchemaParseError(f"candidate JSON array is invalid: {exc}", text) from exc
 
     if not isinstance(parsed, list):