Deploy Project Halide Gradio Space

README.md

@@ -29,8 +29,10 @@ Project Halide is an edge-native diagnostic workbench for analog film scans by
 [Lonelyguyse1](https://huggingface.co/Lonelyguyse1).
 
 The runtime uses MiniCPM-V 4.6 for defect extraction and
-Nemotron-Mini-4B-Instruct for diagnostic reasoning. Model inference runs on the
-Space GPU runtime without cloud inference APIs.
+Nemotron-Mini-4B-Instruct for diagnostic reasoning. The vision pass combines
+full-frame inspection with a tiled fallback for large scans where crack
+networks are too small in the global image. Model inference runs on the Space
+GPU runtime without cloud inference APIs.
 
 Fine-tuned vision model:
 <https://huggingface.co/Lonelyguyse1/halide-vision>
@@ -38,6 +40,14 @@ Fine-tuned vision model:
 Source repository:
 <https://github.com/Lonelyguyse1/Project-Halide>
 
-Demo video: pending final evaluation run.
+Held-out validation summary:
 
-Social post: pending final evaluation run.
+- Four visibly damaged private negatives were detected with scratch and
+  emulsion-damage evidence.
+- One near-clean private negative returned zero defects.
+- A broad lifted crack network that failed full-frame inference was recovered by
+  the tiled fallback.
+
+Demo video: pending publication.
+
+Social post: pending publication.

config.py

@@ -37,6 +37,13 @@ def env_int(name: str, default: int) -> int:
     return int(value)
 
 
+def env_float(name: str, default: float) -> float:
+    value = os.getenv(name)
+    if value is None or value.strip() == "":
+        return default
+    return float(value)
+
+
 def env_path(name: str, default: Path) -> Path:
     value = os.getenv(name)
     return Path(value) if value else default
@@ -56,6 +63,12 @@ class VisionConfig:
     max_slice_nums: int
     max_new_tokens: int
     max_input_pixels: int
+    tile_fallback_enabled: bool
+    tile_fallback_min_defects: int
+    tile_min_side: int
+    tile_max_side: int
+    tile_overlap: float
+    tile_max_tiles: int
 
 
 @dataclass(frozen=True)
@@ -90,6 +103,12 @@ def get_vision_config() -> VisionConfig:
         max_slice_nums=env_int("HALIDE_MAX_SLICE_NUMS", 36),
         max_new_tokens=env_int("HALIDE_MAX_NEW_TOKENS", 2048),
         max_input_pixels=env_int("HALIDE_MAX_INPUT_PIXELS", 4_000_000),
+        tile_fallback_enabled=env_bool("HALIDE_ENABLE_TILE_FALLBACK", True),
+        tile_fallback_min_defects=env_int("HALIDE_TILE_FALLBACK_MIN_DEFECTS", 1),
+        tile_min_side=env_int("HALIDE_TILE_MIN_SIDE", 900),
+        tile_max_side=env_int("HALIDE_TILE_MAX_SIDE", 960),
+        tile_overlap=env_float("HALIDE_TILE_OVERLAP", 0.35),
+        tile_max_tiles=env_int("HALIDE_TILE_MAX_TILES", 9),
     )
 
 
@@ -145,6 +164,7 @@ __all__ = [
     "STORAGE_DIR",
     "VisionConfig",
     "env_bool",
+    "env_float",
     "env_int",
     "env_path",
     "get_app_config",

data/preprocessing.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import hashlib
 import io
+import base64
 from pathlib import Path
 from typing import Any, Iterable
 
@@ -46,6 +47,30 @@ def image_to_png_bytes(image: Image.Image) -> bytes:
     return buf.getvalue()
 
 
+def image_to_data_uri(
+    image: Image.Image,
+    *,
+    max_side: int = 1800,
+    image_format: str = "JPEG",
+    quality: int = 92,
+) -> str:
+    """Return a browser-openable image data URI for review previews."""
+    pil = resize_for_preview(load_image(image), max_side=max_side)
+    fmt = image_format.upper()
+    buf = io.BytesIO()
+    if fmt in {"JPG", "JPEG"}:
+        pil = pil.convert("RGB")
+        pil.save(buf, format="JPEG", quality=quality, optimize=True)
+        mime = "image/jpeg"
+    elif fmt == "PNG":
+        pil.save(buf, format="PNG", optimize=True)
+        mime = "image/png"
+    else:
+        raise ValueError(f"unsupported image_format: {image_format}")
+    encoded = base64.b64encode(buf.getvalue()).decode("ascii")
+    return f"data:{mime};base64,{encoded}"
+
+
 def image_sha256(image: Image.Image | bytes) -> str:
     if isinstance(image, bytes):
         payload = image
@@ -106,6 +131,7 @@ __all__ = [
     "LABEL_STYLE",
     "draw_defects",
     "image_sha256",
+    "image_to_data_uri",
     "image_to_png_bytes",
     "load_image",
     "resize_for_preview",

data/schemas.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 from dataclasses import dataclass
 from typing import Any, Iterable
 
@@ -18,7 +19,6 @@ ALLOWED_LABELS = frozenset(
     }
 )
 
-MIN_DEFECT_CONFIDENCE = 0.35
 DEDUP_IOU_THRESHOLD = 0.72
 
 LABEL_DISPLAY_NAMES = {
@@ -46,6 +46,17 @@ DEFECT_CLASSES_KNOWN = {
 BBox = tuple[float, float, float, float]
 
 
+def _env_float(name: str, default: float) -> float:
+    try:
+        return float(os.getenv(name, str(default)))
+    except (TypeError, ValueError):
+        return default
+
+
+SUBJECT_HAIR_CONFIDENCE_MAX = 0.5
+MIN_DEFECT_CONFIDENCE = _env_float("HALIDE_MIN_DEFECT_CONFIDENCE", 0.45)
+
+
 @dataclass(frozen=True)
 class Defect:
     label: str
@@ -102,6 +113,12 @@ def normalize_bbox(bbox: Any) -> BBox | None:
         y_min /= scale
         x_max /= scale
         y_max /= scale
+        if not all(-0.001 <= v <= 1.002 for v in (x_min, y_min, x_max, y_max)):
+            return None
+        x_min = max(0.0, min(1.0, x_min))
+        y_min = max(0.0, min(1.0, y_min))
+        x_max = max(0.0, min(1.0, x_max))
+        y_max = max(0.0, min(1.0, y_max))
 
     if not all(0.0 <= v <= 1.0 for v in (x_min, y_min, x_max, y_max)):
         return None
@@ -133,9 +150,38 @@ def validate_defect(raw: Any, min_confidence: float = MIN_DEFECT_CONFIDENCE) ->
             confidence = None
     if confidence is not None and confidence < min_confidence:
         return None
+    if is_likely_subject_hair(label, bbox, confidence):
+        return None
     return Defect(label=label, bbox=bbox, confidence=confidence)
 
 
+def is_likely_subject_hair(
+    label: str,
+    bbox: BBox,
+    confidence: float | None,
+) -> bool:
+    """Drop central hair-like subject detail before it reaches diagnosis."""
+    if label not in {"long_hair", "short_hair"}:
+        return False
+    if confidence is not None and confidence >= SUBJECT_HAIR_CONFIDENCE_MAX:
+        return False
+
+    x_min, y_min, x_max, y_max = bbox
+    width = x_max - x_min
+    height = y_max - y_min
+    if width <= 0 or height <= 0:
+        return False
+
+    aspect_ratio = max(width / height, height / width)
+    fully_inside_subject_zone = (
+        x_min > 0.16
+        and x_max < 0.84
+        and y_min > 0.10
+        and y_max < 0.90
+    )
+    return fully_inside_subject_zone and aspect_ratio >= 7.5
+
+
 def clean_defects(
     raw_defects: Any,
     min_confidence: float = MIN_DEFECT_CONFIDENCE,

models/vision/inference.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import Any
 
 from config import get_vision_config
-from data.schemas import clean_defects, dedupe_defects, label_counts
+from data.schemas import BBox, clean_defects, dedupe_defects, label_counts, normalize_bbox
 from data.preprocessing import load_image
 from models.vision.minicpm_wrapper import get_detector
 
@@ -21,15 +21,48 @@ def extract_defects(image: Any) -> dict:
     input_image = load_image(image)
     model_image, resized_for_model = _resize_for_model(input_image)
     raw = detector.detect(model_image)
-    elapsed = time.perf_counter() - started
 
     if not isinstance(raw, dict):
         logger.warning("Model output is not a dict: %r", type(raw))
         raw = {"defects": [], "_parse_error": "non_dict_output"}
 
     cleaned, dropped = clean_defects(raw.get("defects", []))
+    full_frame_count = len(cleaned)
+    tile_fallback_used = False
+    tile_count = 0
+    tile_parse_errors: list[str] = []
+
+    cfg = get_vision_config()
+    if _should_run_tile_fallback(input_image, cleaned):
+        tile_fallback_used = True
+        tile_defects: list[dict[str, Any]] = list(cleaned)
+        for tile_index, (tile_image, tile_box) in enumerate(_iter_tiles(input_image), start=1):
+            tile_count = tile_index
+            tile_model_image, tile_resized = _resize_for_model(tile_image)
+            resized_for_model = resized_for_model or tile_resized
+            tile_raw = detector.detect(tile_model_image)
+            if not isinstance(tile_raw, dict):
+                tile_parse_errors.append("non_dict_output")
+                dropped += 1
+                continue
+            if tile_raw.get("_parse_error"):
+                tile_parse_errors.append(str(tile_raw.get("_parse_error")))
+            tile_cleaned, tile_dropped = clean_defects(tile_raw.get("defects", []))
+            dropped += tile_dropped
+            tile_defects.extend(
+                _remap_tile_defects(
+                    tile_cleaned,
+                    tile_box=tile_box,
+                    image_size=input_image.size,
+                )
+            )
+            if tile_count >= max(1, int(cfg.tile_max_tiles)):
+                break
+        cleaned = tile_defects
+
     cleaned, duplicate_count = dedupe_defects(cleaned)
     counts = label_counts(cleaned)
+    elapsed = time.perf_counter() - started
 
     return {
         "defects": cleaned,
@@ -41,6 +74,10 @@ def extract_defects(image: Any) -> dict:
         "model_path": detector.model_path,
         "parse_error": raw.get("_parse_error"),
         "resized_for_model": resized_for_model,
+        "tile_fallback_used": tile_fallback_used,
+        "tile_count": tile_count,
+        "full_frame_defect_count": full_frame_count,
+        "tile_parse_errors": tile_parse_errors,
     }
 
 
@@ -64,3 +101,105 @@ def _resize_for_model(image: Any) -> tuple[Any, bool]:
         max(1, int(round(height * scale))),
     )
     return image.resize(new_size), True
+
+
+def _should_run_tile_fallback(image: Any, defects: list[dict[str, Any]]) -> bool:
+    cfg = get_vision_config()
+    if not cfg.tile_fallback_enabled:
+        return False
+    if len(defects) >= max(0, int(cfg.tile_fallback_min_defects)):
+        return False
+    width, height = image.size
+    if max(width, height) < max(1, int(cfg.tile_min_side)):
+        return False
+    return True
+
+
+def _iter_tiles(image: Any) -> list[tuple[Any, tuple[int, int, int, int]]]:
+    cfg = get_vision_config()
+    width, height = image.size
+    tile_side = min(max(1, int(cfg.tile_max_side)), max(width, height))
+    tile_width = min(width, tile_side)
+    tile_height = min(height, tile_side)
+    overlap = max(0.0, min(0.85, float(cfg.tile_overlap)))
+    xs = _axis_positions(width, tile_width, overlap)
+    ys = _axis_positions(height, tile_height, overlap)
+    tiles: list[tuple[Any, tuple[int, int, int, int]]] = []
+    center = ((width - tile_width) // 2, (height - tile_height) // 2)
+    ordered_positions = [(x, y) for y in ys for x in xs]
+    ordered_positions.insert(0, center)
+    seen: set[tuple[int, int]] = set()
+    for x, y in ordered_positions:
+        x = max(0, min(width - tile_width, x))
+        y = max(0, min(height - tile_height, y))
+        if (x, y) in seen:
+            continue
+        seen.add((x, y))
+        box = (x, y, x + tile_width, y + tile_height)
+        tiles.append((image.crop(box), box))
+        if len(tiles) >= max(1, int(cfg.tile_max_tiles)):
+            break
+    return tiles
+
+
+def _axis_positions(length: int, tile_length: int, overlap: float) -> list[int]:
+    if length <= tile_length:
+        return [0]
+    stride = max(1, int(round(tile_length * (1.0 - overlap))))
+    limit = length - tile_length
+    positions = list(range(0, limit + 1, stride))
+    positions.extend([limit, limit // 2])
+    return sorted(set(max(0, min(limit, pos)) for pos in positions))
+
+
+def _remap_tile_defects(
+    defects: list[dict[str, Any]],
+    *,
+    tile_box: tuple[int, int, int, int],
+    image_size: tuple[int, int],
+) -> list[dict[str, Any]]:
+    image_width, image_height = image_size
+    x0, y0, x1, y1 = tile_box
+    tile_width = max(1, x1 - x0)
+    tile_height = max(1, y1 - y0)
+    remapped: list[dict[str, Any]] = []
+    for defect in defects:
+        bbox = normalize_bbox(defect.get("bbox"))
+        if bbox is None:
+            continue
+        gx0, gy0, gx1, gy1 = _remap_bbox(
+            bbox,
+            x0=x0,
+            y0=y0,
+            tile_width=tile_width,
+            tile_height=tile_height,
+            image_width=image_width,
+            image_height=image_height,
+        )
+        out = {
+            "label": defect.get("label"),
+            "bbox": [gx0, gy0, gx1, gy1],
+        }
+        if defect.get("confidence") is not None:
+            out["confidence"] = defect.get("confidence")
+        remapped.append(out)
+    return remapped
+
+
+def _remap_bbox(
+    bbox: BBox,
+    *,
+    x0: int,
+    y0: int,
+    tile_width: int,
+    tile_height: int,
+    image_width: int,
+    image_height: int,
+) -> BBox:
+    bx0, by0, bx1, by1 = bbox
+    return (
+        round((x0 + bx0 * tile_width) / image_width, 6),
+        round((y0 + by0 * tile_height) / image_height, 6),
+        round((x0 + bx1 * tile_width) / image_width, 6),
+        round((y0 + by1 * tile_height) / image_height, 6),
+    )

models/vision/minicpm_wrapper.py

@@ -9,33 +9,11 @@ import re
 from typing import Any
 
 from config import CHECKPOINT_DIR, get_vision_config, require_gpu_for_inference
+from models.vision.prompts import DETECTION_PROMPT_INT
 
 logger = logging.getLogger(__name__)
 
-DETECTION_PROMPT = (
-    "You are a film defect detection engine. Analyze the film scan and detect "
-    "only physical defects that are on the film, scanner glass, holder, or "
-    "scan surface. The image may be a positive film scan of an ordinary scene, "
-    "a negative, a slide, a contact sheet, or a film scanner output. Detect "
-    "defects that appear as dust spots, dirt blobs, thin abrasion lines, "
-    "hair-like overlays, emulsion loss, chemical stains, or light leaks on "
-    "top of the photographed content. If no clear "
-    "surface artifact is visible, return {\"defects\": []}. Do not label "
-    "subject matter as defects. Do not label grass, tree branches, eyelashes, "
-    "fabric fibers, texture, grain, wires, shadows, printed text, or real hair "
-    "inside the photographed scene as long_hair or short_hair. Use scratch "
-    "only for thin physical abrasion or scan-surface lines, not object edges, "
-    "stems, typography, or composition lines. Output a JSON object with a "
-    "'defects' array. Each defect has: "
-    "'label' (dust, dirt, scratch, long_hair, short_hair, emulsion_damage, "
-    "chemical_stain, light_leak), "
-    "optional 'confidence' from 0.0 to 1.0, "
-    "'bbox' as 4 integers in the [0, 999] grid "
-    "[x_min, y_min, x_max, y_max] (multiply by image width/height to get pixels). "
-    "Return at most 150 defects. Prefer the clearest defects. Do not repeat "
-    "the same label and bbox. If uncertain, return an empty defects array. "
-    "Output JSON only, no explanation."
-)
+DETECTION_PROMPT = DETECTION_PROMPT_INT
 
 
 def _resolve_model_path() -> str:

models/vision/prompts.py

@@ -0,0 +1,52 @@
+"""Shared prompts for MiniCPM-V film defect extraction."""
+
+from __future__ import annotations
+
+DEFECT_LABELS = (
+    "dust, dirt, scratch, long_hair, short_hair, emulsion_damage, "
+    "chemical_stain, light_leak"
+)
+
+DETECTION_PROMPT_BASE = (
+    "You are a film defect detection engine. Analyze the film scan and detect "
+    "only physical defects that are on the film, scanner glass, holder, or "
+    "scan surface. The image may be a positive film scan of an ordinary scene, "
+    "a negative, a slide, a contact sheet, or a film scanner output. Detect "
+    "defects that appear as dust spots, dirt blobs, thin abrasion lines, "
+    "hair-like overlays, emulsion loss, chemical stains, or light leaks on "
+    "top of the photographed content. Return {\"defects\": []} only when no "
+    "visible surface artifact is present. Do not return an empty array when "
+    "obvious dark or light scratches, cracks, abrasion lines, peeled emulsion, "
+    "or opaque dirt cross the subject content. Do not label subject matter as "
+    "defects. Do not label grass, tree branches, eyelashes, fabric fibers, "
+    "texture, grain, wires, shadows, printed text, or real hair inside the "
+    "photographed scene as long_hair or short_hair. Use scratch only for thin "
+    "physical abrasion or scan-surface lines, not object edges, stems, "
+    "typography, or composition lines. Transparent or semi-transparent crack "
+    "networks, lifted film bands, broken coating sheets, and fracture lines "
+    "crossing a face or subject are defects, not scene content. Use "
+    "emulsion_damage for broad peeled, cracked, torn, lifted, or missing "
+    "emulsion regions. Use scratch for fine crack branches and abrasion "
+    "lines. Output a JSON object with a "
+    "'defects' array. Each defect has: "
+    f"'label' ({DEFECT_LABELS}), "
+    "optional 'confidence' from 0.0 to 1.0, "
+)
+
+DETECTION_PROMPT_SUFFIX = (
+    "Return at most 150 defects. Prefer the clearest defects. Do not repeat "
+    "the same label and bbox. Output JSON only, no explanation."
+)
+
+DETECTION_PROMPT_INT = (
+    DETECTION_PROMPT_BASE
+    + "'bbox' as 4 integers in the [0, 999] grid "
+    + "[x_min, y_min, x_max, y_max] (multiply by image width/height to get pixels). "
+    + DETECTION_PROMPT_SUFFIX
+)
+
+DETECTION_PROMPT_FLOAT = (
+    DETECTION_PROMPT_BASE
+    + "'bbox' (normalized [x_min, y_min, x_max, y_max] from 0.0 to 1.0). "
+    + DETECTION_PROMPT_SUFFIX
+)

ui/app.py

@@ -7,16 +7,22 @@ import logging
 from typing import Any
 
 import gradio as gr
-from PIL import Image, ImageDraw, ImageFont
 
 from config import get_app_config
-from data.preprocessing import draw_defects, image_to_png_bytes, load_image
+from data.preprocessing import (
+    draw_defects,
+    image_to_data_uri,
+    image_to_png_bytes,
+    load_image,
+)
 from pipeline.pipeline import run_diagnosis
 from storage.cache import get_cache
 from storage.database import get_diagnosis, init_db, list_recent, record_diagnosis
 from ui.components import (
     EMPTY_STATE,
     HEADER_HTML,
+    LIGHTTABLE_EMPTY_STATE,
+    LIGHTTABLE_RUNNING_STATE,
     REPORT_EMPTY_STATE,
     confidence_notice_html,
     defect_table_rows,
@@ -26,8 +32,8 @@ from ui.components import (
     history_detail_html,
     history_table_rows,
     metadata_html,
-    render_history,
     raw_json_text,
+    review_frame_html,
     run_state_html,
     stats_html,
 )
@@ -77,6 +83,24 @@ METADATA_CONFIDENCE_OPTIONS = [
     "High, verified from notes or edge marks",
 ]
 
+PipelineOutputs = tuple[
+    Any,
+    Any,
+    Any,
+    Any,
+    str,
+    str,
+    str,
+    str,
+    str,
+    str,
+    str,
+    list[list[str]],
+    str,
+    Any,
+    list[list[str]],
+]
+
 
 def normalize_metadata_confidence(value: str | None) -> str:
     text = (value or "low").strip().lower()
@@ -89,24 +113,26 @@ def normalize_metadata_confidence(value: str | None) -> str:
 
 def _history_state(
     selected_id: str | None = None,
-) -> tuple[str, dict | None, Any, list[list[str]]]:
+) -> tuple[dict | None, Any, list[list[str]]]:
     entries = list_recent(limit=get_app_config().max_history_items)
     choices = history_choices(entries)
     ids = [value for _label, value in choices]
     value = selected_id if selected_id in ids else (ids[0] if ids else None)
     selected = next((entry for entry in entries if entry.get("id") == value), None)
-    return render_history(entries), selected, gr.update(choices=choices, value=value), history_table_rows(entries)
+    return selected, gr.update(choices=choices, value=value), history_table_rows(entries)
 
 
 def _empty_outputs(
     message: str = "Awaiting scan.",
-) -> tuple[Any, Any, str, str, str, str, str, str, str, list[list[str]], str, str, Any, list[list[str]]]:
-    history_html, selected_entry, selector_update, history_rows = _history_state()
+) -> PipelineOutputs:
+    selected_entry, selector_update, history_rows = _history_state()
     empty = f'<p class="halide-muted">{html.escape(message)}</p>'
     hidden_html = gr.update(value="", visible=False)
     return (
-        None,
+        gr.update(value=LIGHTTABLE_EMPTY_STATE, visible=True),
+        gr.update(value=None, visible=False),
         gr.update(value=[], visible=False),
+        hidden_html,
         run_state_html(None),
         empty,
         empty,
@@ -115,7 +141,6 @@ def _empty_outputs(
         "",
         "{}",
         [],
-        history_html,
         history_detail_html(selected_entry),
         selector_update,
         history_rows,
@@ -129,42 +154,48 @@ def _review_gallery(pil_image: Any, annotated: Any) -> list[tuple[Any, str]]:
     ]
 
 
-def _placeholder_image() -> Image.Image:
-    image = Image.new("RGB", (1200, 760), (5, 5, 5))
-    draw = ImageDraw.Draw(image)
-    frame = (28, 28, 1172, 732)
-    draw.rectangle(frame, outline=(68, 62, 52), width=2)
-    draw.rectangle((48, 48, 1152, 712), outline=(28, 27, 25), width=1)
-    try:
-        font = ImageFont.load_default(size=32)
-        small = ImageFont.load_default(size=18)
-    except TypeError:
-        font = ImageFont.load_default()
-        small = font
-    title = "Awaiting scan"
-    subtitle = "Validated overlay will appear here"
-    title_box = draw.textbbox((0, 0), title, font=font)
-    subtitle_box = draw.textbbox((0, 0), subtitle, font=small)
-    center_x = image.width // 2
-    center_y = image.height // 2
-    draw.text(
-        (center_x - (title_box[2] - title_box[0]) // 2, center_y - 26),
-        title,
-        fill=(243, 234, 219),
-        font=font,
-    )
-    draw.text(
-        (center_x - (subtitle_box[2] - subtitle_box[0]) // 2, center_y + 18),
-        subtitle,
-        fill=(169, 155, 136),
-        font=small,
+def _running_button_state() -> tuple[Any, str, Any]:
+    return (
+        gr.update(interactive=False, value="Diagnosing..."),
+        (
+            '<div class="halide-run-state active">'
+            '<span class="halide-run-eyebrow">Running</span>'
+            "<strong>GPU inspection in progress</strong>"
+            "<span>Vision extraction, validation, and report generation are running.</span>"
+            "</div>"
+        ),
+        gr.update(value=LIGHTTABLE_RUNNING_STATE, visible=True),
     )
-    return image
 
 
-def _placeholder_pair() -> tuple[Image.Image, Image.Image]:
-    placeholder = _placeholder_image()
-    return placeholder, placeholder.copy()
+def _attach_preview(result: dict, pil_image: Any, annotated: Any) -> dict:
+    result = dict(result)
+    if not isinstance(result.get("preview"), dict):
+        result["preview"] = {
+            "original": image_to_data_uri(pil_image, max_side=720, quality=86),
+            "overlay": image_to_data_uri(annotated, max_side=720, quality=86),
+        }
+    return result
+
+
+def pipeline_error_html(exc: Exception) -> str:
+    text = str(exc)
+    lower = text.lower()
+    if "no cuda gpu" in lower or "cuda" in lower or "gpu" in lower:
+        title = "GPU unavailable"
+        body = (
+            "The diagnosis needs a live GPU slot. Please retry in a moment, "
+            "or run the app on a GPU-backed Space."
+        )
+    else:
+        title = "Pipeline error"
+        body = text or "The diagnostic pipeline stopped unexpectedly."
+    return (
+        '<div class="halide-panel" style="border-color: var(--halide-red);">'
+        f'<div class="halide-section-title" style="color: var(--halide-red);">'
+        f"{html.escape(title)}</div>"
+        f"<p class=\"halide-muted\">{html.escape(body)}</p></div>"
+    )
 
 
 @_gpu_decorator()
@@ -176,7 +207,7 @@ def run_pipeline(
     scan_dpi: int,
     metadata_confidence: str = "low",
     progress: gr.Progress = gr.Progress(),
-) -> tuple[Any, Any, str, str, str, str, str, str, str, list[list[str]], str, str, Any, list[list[str]]]:
+) -> PipelineOutputs:
     """Gradio handler for the diagnose button."""
     if image is None:
         return _empty_outputs("No image provided.")
@@ -194,10 +225,12 @@ def run_pipeline(
             "metadata_confidence": normalize_metadata_confidence(metadata_confidence),
         }
         cached = cache.get(image_bytes, metadata=metadata)
+        was_cached = cached is not None
         if cached is not None:
             logger.info("Returning cached diagnosis")
             result = cached
         else:
+            progress(0.05, "Loading GPU models if needed...")
             progress(0.1, "Stage 1/2: running vision defect extraction...")
             result = run_diagnosis(
                 image=pil_image,
@@ -208,12 +241,6 @@ def run_pipeline(
                 metadata_confidence=metadata["metadata_confidence"],
             )
             progress(0.85, "Stage 2/2: persisting diagnosis...")
-            try:
-                diagnosis_id = record_diagnosis(result)
-                result["diagnosis_id"] = diagnosis_id
-            except Exception as exc:  # pragma: no cover
-                logger.warning("Failed to record diagnosis: %s", exc)
-            cache.put(image_bytes, result, metadata=metadata)
 
         progress(1.0, "Done.")
 
@@ -224,8 +251,24 @@ def run_pipeline(
             defects,
             title=f"Halide: {len(defects)} validated defects",
         )
+        result = _attach_preview(result, pil_image, annotated)
+        if not was_cached:
+            try:
+                diagnosis_id = record_diagnosis(result)
+                result["diagnosis_id"] = diagnosis_id
+            except Exception as exc:  # pragma: no cover
+                logger.warning("Failed to record diagnosis: %s", exc)
+            cache.put(image_bytes, result, metadata=metadata)
+        elif not result.get("diagnosis_id"):
+            cache.put(image_bytes, result, metadata=metadata)
+
         image_pair = (pil_image, annotated)
+        compare = gr.update(value=image_pair, visible=True)
         gallery = gr.update(value=_review_gallery(pil_image, annotated), visible=True)
+        review_links = gr.update(
+            value=review_frame_html(pil_image, annotated),
+            visible=True,
+        )
         run_state = run_state_html(result)
         stats = stats_html(result)
         notice = confidence_notice_html(result)
@@ -237,10 +280,12 @@ def run_pipeline(
         meta = metadata_html(result)
         raw_json = raw_json_text(result)
         table_rows = defect_table_rows(result)
-        history, selected_entry, selector_update, history_rows = _history_state(result.get("diagnosis_id"))
+        selected_entry, selector_update, history_rows = _history_state(result.get("diagnosis_id"))
         return (
-            image_pair,
+            gr.update(value="", visible=False),
+            compare,
             gallery,
+            review_links,
             run_state,
             stats,
             notice,
@@ -249,25 +294,20 @@ def run_pipeline(
             meta,
             raw_json,
             table_rows,
-            history,
             history_detail_html(selected_entry),
             selector_update,
             history_rows,
         )
     except Exception as exc:  # pragma: no cover
         logger.exception("Pipeline failed")
-        err = (
-            '<div class="halide-panel" style="border-color: var(--halide-red);">'
-            f'<div class="halide-section-title" style="color: var(--halide-red);">'
-            f"Pipeline error</div>"
-            f"<pre style=\"color: var(--halide-text); white-space: pre-wrap;\">"
-            f"{html.escape(str(exc))}</pre></div>"
-        )
-        history, selected_entry, selector_update, history_rows = _history_state()
+        err = pipeline_error_html(exc)
+        selected_entry, selector_update, history_rows = _history_state()
         hidden_html = gr.update(value="", visible=False)
         return (
-            None,
+            gr.update(value=LIGHTTABLE_EMPTY_STATE, visible=True),
+            gr.update(value=None, visible=False),
             gr.update(value=[], visible=False),
+            hidden_html,
             err,
             err,
             "",
@@ -276,18 +316,16 @@ def run_pipeline(
             "",
             "{}",
             [],
-            history,
             history_detail_html(selected_entry),
             selector_update,
             history_rows,
         )
 
 
-def refresh_history(selected_id: str | None = None) -> tuple[Any, str, str, str, list[list[str]]]:
-    history, selected_entry, selector_update, history_rows = _history_state(selected_id)
+def refresh_history(selected_id: str | None = None) -> tuple[Any, str, str, list[list[str]]]:
+    selected_entry, selector_update, history_rows = _history_state(selected_id)
     return (
         selector_update,
-        history,
         history_detail_html(selected_entry),
         raw_json_text(selected_entry),
         history_rows,
@@ -299,9 +337,35 @@ def open_history(diagnosis_id: str | None) -> tuple[str, str]:
     return history_detail_html(entry), raw_json_text(entry)
 
 
+def _history_id_from_selection(rows: list[list[str]] | None, index: Any) -> str | None:
+    if rows is None:
+        return None
+    row_index: int | None = None
+    if isinstance(index, (list, tuple)) and index:
+        try:
+            row_index = int(index[0])
+        except (TypeError, ValueError):
+            row_index = None
+    elif isinstance(index, int):
+        row_index = index
+    if row_index is None or row_index < 0 or row_index >= len(rows):
+        return None
+    row = rows[row_index]
+    if len(row) < 5:
+        return None
+    diagnosis_id = str(row[4] or "").strip()
+    return diagnosis_id or None
+
+
+def open_history_from_table(rows: list[list[str]] | None, evt: gr.SelectData) -> tuple[Any, str, str]:
+    diagnosis_id = _history_id_from_selection(rows, getattr(evt, "index", None))
+    entry = get_diagnosis(diagnosis_id or "") if diagnosis_id else None
+    return gr.update(value=diagnosis_id), history_detail_html(entry), raw_json_text(entry)
+
+
 def build_app() -> gr.Blocks:
     init_db()
-    history_html, selected_entry, selector_update, initial_history_rows = _history_state()
+    selected_entry, selector_update, initial_history_rows = _history_state()
     initial_choices = selector_update["choices"] if isinstance(selector_update, dict) else []
     initial_value = selector_update["value"] if isinstance(selector_update, dict) else None
 
@@ -322,7 +386,7 @@ def build_app() -> gr.Blocks:
                 image_input = gr.Image(
                     label="Film scan",
                     type="pil",
-                    height=300,
+                    height=330,
                     sources=["upload", "clipboard"],
                     buttons=["download", "fullscreen"],
                     elem_classes="halide-upload",
@@ -333,29 +397,30 @@ def build_app() -> gr.Blocks:
                     label="Film stock",
                     allow_custom_value=True,
                 )
-                with gr.Row(elem_classes="halide-inline-controls"):
-                    film_age = gr.Slider(
-                        minimum=0,
-                        maximum=80,
-                        step=1,
-                        value=0,
-                        label="Age",
-                        buttons=["reset"],
-                    )
-                    scan_dpi = gr.Dropdown(
-                        choices=RESOLUTION_OPTIONS,
-                        value=4000,
-                        label="DPI",
-                    )
+                film_age = gr.Slider(
+                    minimum=0,
+                    maximum=80,
+                    step=1,
+                    value=0,
+                    label="Age (years)",
+                    buttons=["reset"],
+                )
+                scan_dpi = gr.Dropdown(
+                    choices=RESOLUTION_OPTIONS,
+                    value=4000,
+                    label="DPI",
+                    allow_custom_value=True,
+                )
                 storage = gr.Radio(
                     choices=STORAGE_OPTIONS,
                     value=STORAGE_OPTIONS[0],
                     label="Storage",
                 )
-                metadata_confidence = gr.Radio(
+                metadata_confidence = gr.Dropdown(
                     choices=METADATA_CONFIDENCE_OPTIONS,
                     value=METADATA_CONFIDENCE_OPTIONS[0],
                     label="Metadata confidence",
+                    interactive=True,
                 )
                 run_btn = gr.Button(
                     "Diagnose scan",
@@ -381,16 +446,18 @@ def build_app() -> gr.Blocks:
                         '<small>Review</small>'
                         "</div>"
                     )
+                    lighttable_empty = gr.HTML(value=LIGHTTABLE_EMPTY_STATE)
                     compare_output = gr.ImageSlider(
-                        value=_placeholder_pair(),
+                        value=None,
                         label="Original / overlay",
                         type="pil",
-                        height="54vh",
-                        max_height=760,
+                        height=620,
+                        max_height=680,
                         slider_position=52,
                         interactive=False,
                         buttons=["download", "fullscreen"],
                         elem_id="halide-compare",
+                        visible=False,
                     )
                     review_gallery = gr.Gallery(
                         value=[],
@@ -404,6 +471,7 @@ def build_app() -> gr.Blocks:
                         elem_classes="halide-review-gallery",
                         visible=False,
                     )
+                    review_links_output = gr.HTML(value="", visible=False)
 
             with gr.Column(scale=3, min_width=390, elem_classes="halide-inspector"):
                 with gr.Tabs(selected="report", elem_classes="halide-inspector-tabs"):
@@ -425,13 +493,18 @@ def build_app() -> gr.Blocks:
                             max_height=300,
                         )
                     with gr.Tab("History", id="history"):
+                        gr.HTML(
+                            '<div class="halide-tab-note">Select a row or choose a saved run.</div>'
+                        )
                         history_select = gr.Dropdown(
                             choices=initial_choices,
                             value=initial_value,
                             label="Saved diagnosis",
                             interactive=True,
                         )
-                        refresh_btn = gr.Button("Refresh", size="sm")
+                        with gr.Row(elem_classes="halide-history-actions"):
+                            open_history_btn = gr.Button("Open selected", size="sm")
+                            refresh_btn = gr.Button("Refresh", size="sm")
                         history_table = gr.Dataframe(
                             value=initial_history_rows,
                             headers=["Saved", "Film stock", "Defects", "Labels", "ID"],
@@ -441,14 +514,11 @@ def build_app() -> gr.Blocks:
                             interactive=False,
                             wrap=True,
                             max_height=260,
+                            elem_classes="halide-history-table",
                         )
                         history_detail = gr.HTML(
                             value=history_detail_html(selected_entry)
                         )
-                        history_output = gr.HTML(
-                            value=history_html,
-                            elem_classes="halide-history-feed",
-                        )
                     with gr.Tab("JSON", id="json"):
                         raw_output = gr.Code(
                             value="{}",
@@ -466,8 +536,8 @@ def build_app() -> gr.Blocks:
         )
 
         run_event = run_btn.click(
-            fn=lambda: gr.update(interactive=False, value="Diagnosing..."),
-            outputs=[run_btn],
+            fn=_running_button_state,
+            outputs=[run_btn, run_state_output, lighttable_empty],
             queue=False,
         )
         run_event.then(
@@ -481,8 +551,10 @@ def build_app() -> gr.Blocks:
                 metadata_confidence,
             ],
             outputs=[
+                lighttable_empty,
                 compare_output,
                 review_gallery,
+                review_links_output,
                 run_state_output,
                 stats_output,
                 notice_output,
@@ -491,7 +563,6 @@ def build_app() -> gr.Blocks:
                 metadata_output,
                 raw_output,
                 defect_table,
-                history_output,
                 history_detail,
                 history_select,
                 history_table,
@@ -504,13 +575,23 @@ def build_app() -> gr.Blocks:
         refresh_btn.click(
             fn=refresh_history,
             inputs=[history_select],
-            outputs=[history_select, history_output, history_detail, raw_output, history_table],
+            outputs=[history_select, history_detail, raw_output, history_table],
+        )
+        open_history_btn.click(
+            fn=open_history,
+            inputs=[history_select],
+            outputs=[history_detail, raw_output],
         )
         history_select.change(
             fn=open_history,
             inputs=[history_select],
             outputs=[history_detail, raw_output],
         )
+        history_table.select(
+            fn=open_history_from_table,
+            inputs=[history_table],
+            outputs=[history_select, history_detail, raw_output],
+        )
 
     return app
 

ui/components.py

@@ -11,6 +11,7 @@ import re
 from typing import Iterable
 
 from data.schemas import LABEL_DISPLAY_NAMES
+from data.preprocessing import image_to_data_uri
 
 
 def _logo_html() -> str:
@@ -50,6 +51,30 @@ REPORT_EMPTY_STATE = (
     '<p>Results, evidence counts, and physical fixes will appear here after a GPU run.</p>'
     "</div>"
 )
+LIGHTTABLE_EMPTY_STATE = (
+    '<div class="halide-empty-lighttable">'
+    '<div class="halide-empty-frame-grid">'
+    '<div><span>Original</span></div>'
+    '<div><span>Validated overlay</span></div>'
+    "</div>"
+    '<div class="halide-empty-center">'
+    '<span>Ready</span>'
+    '<strong>No scan loaded</strong>'
+    "</div>"
+    "</div>"
+)
+LIGHTTABLE_RUNNING_STATE = (
+    '<div class="halide-empty-lighttable active">'
+    '<div class="halide-empty-frame-grid">'
+    '<div><span>Vision extraction</span></div>'
+    '<div><span>Diagnostic report</span></div>'
+    "</div>"
+    '<div class="halide-empty-center">'
+    '<span>Running</span>'
+    '<strong>GPU inspection in progress</strong>'
+    "</div>"
+    "</div>"
+)
 
 REPORT_SECTIONS = {
     "root cause": "Root cause",
@@ -89,6 +114,8 @@ def defect_table_rows(result: dict | None) -> list[list[str]]:
     if not result:
         return []
     defects = (result.get("defects", {}) or {}).get("defects", []) or []
+    if not defects:
+        return [["", "No validated defects", "", ""]]
     rows: list[list[str]] = []
     for index, defect in enumerate(defects, start=1):
         label = str(defect.get("label", ""))
@@ -148,6 +175,22 @@ def diagnosis_html(text: str) -> str:
     return render_markdown_report(text or "(no diagnosis produced)")
 
 
+def review_frame_html(original, annotated) -> str:
+    """Render reliable full-size image links independent of Gradio fullscreen."""
+    original_uri = image_to_data_uri(original, max_side=1800, quality=92)
+    overlay_uri = image_to_data_uri(annotated, max_side=1800, quality=92)
+    return (
+        '<div class="halide-review-actions">'
+        '<a href="'
+        + original_uri
+        + '" target="_blank" rel="noreferrer">Open original</a>'
+        '<a href="'
+        + overlay_uri
+        + '" target="_blank" rel="noreferrer">Open overlay</a>'
+        "</div>"
+    )
+
+
 def render_markdown_report(text: str) -> str:
     """Render the constrained diagnosis Markdown used by Nemotron.
 
@@ -198,7 +241,7 @@ def _render_report_lines(lines: list[str]) -> str:
         if paragraph:
             blocks.append(
                 "<p>"
-                + " ".join(html.escape(part) for part in paragraph if part)
+                + " ".join(_render_inline(part) for part in paragraph if part)
                 + "</p>"
             )
             paragraph.clear()
@@ -221,15 +264,23 @@ def _render_report_lines(lines: list[str]) -> str:
             flush_bullets()
             flush_ordered()
             continue
+        if line.startswith("### "):
+            flush_paragraph()
+            flush_bullets()
+            flush_ordered()
+            blocks.append(
+                f'<h4 class="halide-report-subheading">{_render_inline(line[4:].strip())}</h4>'
+            )
+            continue
         numbered = re.match(r"^\d+\.\s+(.*)$", line)
         if line.startswith("- "):
             flush_paragraph()
             flush_ordered()
-            bullet_items.append(html.escape(line[2:].strip()))
+            bullet_items.append(_render_inline(line[2:].strip()))
         elif numbered:
             flush_paragraph()
             flush_bullets()
-            ordered_items.append(html.escape(numbered.group(1).strip()))
+            ordered_items.append(_render_inline(numbered.group(1).strip()))
         else:
             flush_bullets()
             flush_ordered()
@@ -241,6 +292,16 @@ def _render_report_lines(lines: list[str]) -> str:
     return "".join(blocks) or '<p class="halide-muted">No report text.</p>'
 
 
+def _render_inline(text: str) -> str:
+    escaped = html.escape(text)
+    escaped = re.sub(r"`([^`]+)`", r"<code>\1</code>", escaped)
+    escaped = re.sub(r"\*\*([^*]+)\*\*", r"<strong>\1</strong>", escaped)
+    escaped = re.sub(r"__([^_]+)__", r"<strong>\1</strong>", escaped)
+    escaped = re.sub(r"(?<!\*)\*([^*]+)\*(?!\*)", r"<em>\1</em>", escaped)
+    escaped = re.sub(r"(?<!_)_([^_]+)_(?!_)", r"<em>\1</em>", escaped)
+    return escaped
+
+
 def metadata_html(result: dict) -> str:
     """Render a compact metadata strip for the current run."""
     meta = result.get("film_metadata", {}) or {}
@@ -350,41 +411,36 @@ def history_choices(entries: Iterable[dict]) -> list[tuple[str, str]]:
     return [(history_label(e), str(e.get("id", ""))) for e in entries if e.get("id")]
 
 
-def history_row_html(entry: dict) -> str:
-    """Render a single row in the recent-diagnoses sidebar."""
-    counts = entry.get("label_counts", {}) or {}
-    total = entry.get("defect_count", 0) or 0
-    film = entry.get("film_type", "Unknown")
-    age = entry.get("film_age_years", "?")
-    storage = entry.get("storage", "?")
-    ts = entry.get("created_at", 0)
-    seconds = entry.get("total_seconds", 0.0) or 0.0
-    stamp = time.strftime("%Y-%m-%d %H:%M", time.localtime(float(ts or 0)))
-    return (
-        f'<div class="halide-history-item">'
-        f'<div class="halide-history-title">{html.escape(str(film))}</div>'
-        f'<div class="halide-history-meta">age {html.escape(str(age))}y, '
-        f"{html.escape(str(storage))}, {html.escape(stamp)}</div>"
-        f"{defect_pills_html(counts)}"
-        f'<div class="halide-history-meta">defects {int(total)} | {seconds:.2f}s</div>'
-        f"</div>"
-    )
-
-
-def render_history(entries: Iterable[dict]) -> str:
-    items = "".join(history_row_html(e) for e in entries)
-    if not items:
-        return '<p class="halide-muted">No diagnoses yet.</p>'
-    return items
-
-
 def history_detail_html(entry: dict | None) -> str:
     if not entry:
         return '<p class="halide-muted">Select a diagnosis to review details.</p>'
 
     counts = entry.get("label_counts", {}) or {}
-    meta = entry.get("raw_json", {}).get("film_metadata", {}) if entry.get("raw_json") else {}
+    raw = entry.get("raw_json", {}) or {}
+    meta = raw.get("film_metadata", {}) if raw else {}
     confidence = meta.get("metadata_confidence", entry.get("metadata_confidence", "low"))
+    preview = raw.get("preview", {}) if raw else {}
+    preview_html = ""
+    overlay_uri = str(preview.get("overlay", "") or "")
+    original_uri = str(preview.get("original", "") or "")
+    if overlay_uri.startswith("data:image/") or original_uri.startswith("data:image/"):
+        hero_uri = overlay_uri if overlay_uri.startswith("data:image/") else original_uri
+        preview_html = (
+            '<div class="halide-history-preview">'
+            f'<img src="{html.escape(hero_uri, quote=True)}" alt="" />'
+            '<div class="halide-history-preview-actions">'
+        )
+        if original_uri.startswith("data:image/"):
+            preview_html += (
+                f'<a href="{html.escape(original_uri, quote=True)}" '
+                'target="_blank" rel="noreferrer">Original</a>'
+            )
+        if overlay_uri.startswith("data:image/"):
+            preview_html += (
+                f'<a href="{html.escape(overlay_uri, quote=True)}" '
+                'target="_blank" rel="noreferrer">Overlay</a>'
+            )
+        preview_html += "</div></div>"
     stamp = time.strftime(
         "%Y-%m-%d %H:%M",
         time.localtime(float(entry.get("created_at", 0) or 0)),
@@ -401,6 +457,7 @@ def history_detail_html(entry: dict | None) -> str:
     ]
     return (
         '<div class="halide-history-detail">'
+        f"{preview_html}"
         f'<div class="halide-stats compact">{"".join(header_rows)}</div>'
         '<div class="halide-subsection">Defects</div>'
         f"{defect_pills_html(counts)}"
@@ -417,12 +474,31 @@ def raw_json_text(result_or_entry: dict | None) -> str:
         payload = result_or_entry.get("raw_json") or {}
     else:
         payload = result_or_entry
+    payload = _strip_preview(payload)
     return json.dumps(payload, indent=2, sort_keys=True)
 
 
+def _strip_preview(payload: dict) -> dict:
+    if not isinstance(payload, dict):
+        return {}
+    clean = dict(payload)
+    if "preview" in clean:
+        preview = clean.get("preview") or {}
+        if isinstance(preview, dict):
+            clean["preview"] = {
+                key: "[image data URI omitted from JSON view]"
+                for key in preview
+            }
+        else:
+            clean["preview"] = "[image data URI omitted from JSON view]"
+    return clean
+
+
 __all__ = [
     "HEADER_HTML",
     "EMPTY_STATE",
+    "LIGHTTABLE_EMPTY_STATE",
+    "LIGHTTABLE_RUNNING_STATE",
     "REPORT_EMPTY_STATE",
     "compact_label_counts",
     "confidence_notice_html",
@@ -435,8 +511,8 @@ __all__ = [
     "history_table_rows",
     "metadata_html",
     "render_markdown_report",
-    "render_history",
     "run_state_html",
     "raw_json_text",
+    "review_frame_html",
     "stats_html",
 ]

ui/theme.py

@@ -266,6 +266,109 @@ body::before {{
   box-shadow: 0 22px 52px rgba(0, 0, 0, 0.42) !important;
 }}
 
+.halide-empty-lighttable {{
+  position: relative;
+  min-height: clamp(360px, 54vh, 760px);
+  overflow: hidden;
+  display: grid;
+  place-items: center;
+  border-radius: 7px;
+  border: 1px solid rgba(243, 234, 219, 0.26);
+  background:
+    linear-gradient(180deg, rgba(33, 31, 28, 0.76), rgba(5, 5, 5, 0.96)),
+    repeating-linear-gradient(
+      0deg,
+      rgba(243, 234, 219, 0.035) 0,
+      rgba(243, 234, 219, 0.035) 1px,
+      transparent 1px,
+      transparent 24px
+    );
+}}
+
+.halide-empty-lighttable::after {{
+  content: "";
+  position: absolute;
+  inset: 24px;
+  border: 1px solid rgba(243, 234, 219, 0.12);
+  box-shadow: inset 0 0 0 1px rgba(5, 5, 5, 0.82);
+  pointer-events: none;
+}}
+
+.halide-empty-frame-grid {{
+  position: absolute;
+  inset: 18px;
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 1px;
+  opacity: 0.86;
+}}
+
+.halide-empty-frame-grid > div {{
+  position: relative;
+  min-width: 0;
+  background:
+    linear-gradient(135deg, rgba(17, 17, 17, 0.9), rgba(44, 41, 36, 0.46)),
+    repeating-linear-gradient(
+      90deg,
+      rgba(197, 154, 82, 0.06) 0,
+      rgba(197, 154, 82, 0.06) 1px,
+      transparent 1px,
+      transparent 38px
+    );
+  border: 1px solid rgba(58, 53, 46, 0.92);
+}}
+
+.halide-empty-frame-grid span {{
+  position: absolute;
+  top: 12px;
+  left: 12px;
+  color: rgba(243, 234, 219, 0.72);
+  font-size: 0.7rem;
+  font-weight: 860;
+  letter-spacing: 0.1em !important;
+  text-transform: uppercase;
+}}
+
+.halide-empty-center {{
+  position: relative;
+  z-index: 2;
+  display: grid;
+  gap: 8px;
+  min-width: min(22rem, calc(100% - 48px));
+  padding: 18px 20px;
+  text-align: center;
+  border-radius: 8px;
+  border: 1px solid rgba(197, 154, 82, 0.42);
+  background: rgba(10, 10, 10, 0.78);
+  box-shadow: 0 18px 50px rgba(0, 0, 0, 0.46);
+}}
+
+.halide-empty-center span {{
+  color: var(--halide-brass);
+  font-size: 0.68rem;
+  font-weight: 880;
+  letter-spacing: 0.12em !important;
+  text-transform: uppercase;
+}}
+
+.halide-empty-center strong {{
+  color: var(--halide-paper);
+  font-size: clamp(1.05rem, 1.8vw, 1.6rem);
+  line-height: 1.12;
+}}
+
+.halide-empty-lighttable.active {{
+  border-color: rgba(102, 212, 193, 0.34);
+}}
+
+.halide-empty-lighttable.active .halide-empty-center {{
+  border-color: rgba(102, 212, 193, 0.42);
+}}
+
+.halide-empty-lighttable.active .halide-empty-center span {{
+  color: var(--halide-teal);
+}}
+
 .halide-section-header {{
   display: flex;
   align-items: flex-start;
@@ -316,10 +419,6 @@ body::before {{
   object-fit: contain !important;
 }}
 
-.halide-inline-controls {{
-  gap: 8px !important;
-}}
-
 #halide-run-button,
 button.primary,
 .primary button {{
@@ -571,38 +670,11 @@ button {{
   border-color: rgba(244, 114, 182, 0.36);
 }}
 
-.halide-history-item {{
-  background: rgba(33, 31, 28, 0.82);
-  border: 1px solid rgba(58, 53, 46, 0.94);
-  border-radius: 8px;
-  margin-bottom: 9px;
-  padding: 11px;
-}}
-
-.halide-history-title {{
-  color: var(--halide-paper);
-  font-weight: 860;
-  margin-bottom: 4px;
-  overflow-wrap: anywhere;
-}}
-
-.halide-history-meta {{
-  color: var(--halide-muted);
-  font-size: 0.78rem;
-  line-height: 1.36;
-  margin: 4px 0;
-}}
-
 .halide-history-detail {{
   display: grid;
   gap: 8px;
 }}
 
-.halide-history-feed {{
-  max-height: 18rem;
-  overflow: auto;
-}}
-
 .halide-intake-panel .block,
 .halide-inspector .block,
 .halide-lighttable .block {{
@@ -610,6 +682,23 @@ button {{
   border-color: rgba(58, 53, 46, 0.95) !important;
   border-radius: 8px !important;
   box-shadow: none !important;
+  outline: none !important;
+  overflow: hidden !important;
+}}
+
+.halide-intake-panel .block:focus-within,
+.halide-inspector .block:focus-within,
+.halide-lighttable .block:focus-within {{
+  border-color: rgba(197, 154, 82, 0.48) !important;
+  box-shadow: 0 0 0 1px rgba(197, 154, 82, 0.16) !important;
+}}
+
+.halide-intake-panel .form,
+.halide-inspector .form,
+.halide-lighttable .form {{
+  background: transparent !important;
+  border-color: transparent !important;
+  overflow: visible !important;
 }}
 
 input,
@@ -621,6 +710,8 @@ select,
 .prose {{
   background-color: var(--halide-surface-soft) !important;
   color: var(--halide-paper) !important;
+  border-color: rgba(58, 53, 46, 0.95) !important;
+  outline: none !important;
 }}
 
 label,
@@ -709,9 +800,190 @@ footer {{
   font-size: 0.82rem;
 }}
 
-@media (max-width: 1180px) {{
+#halide-header {{
+  background: rgba(17, 17, 17, 0.86);
+  border: 1px solid rgba(197, 154, 82, 0.28);
+  border-top: 0;
+  border-radius: 0 0 8px 8px;
+  padding: 16px 18px 15px;
+  box-shadow: 0 18px 48px rgba(0, 0, 0, 0.35);
+}}
+
+.halide-intake-panel,
+.halide-inspector {{
+  position: sticky;
+  top: 14px;
+  max-height: calc(100vh - 32px);
+  overflow-y: auto;
+  scrollbar-color: rgba(197, 154, 82, 0.48) rgba(17, 17, 17, 0.88);
+}}
+
+.halide-main-stage {{
+  align-self: stretch;
+}}
+
+.halide-lighttable {{
+  position: relative;
+  overflow: hidden;
+  padding: 16px 20px !important;
+  background:
+    linear-gradient(180deg, rgba(17, 17, 17, 0.98), rgba(5, 5, 5, 0.98)),
+    repeating-linear-gradient(
+      90deg,
+      rgba(243, 234, 219, 0.026) 0,
+      rgba(243, 234, 219, 0.026) 1px,
+      transparent 1px,
+      transparent 28px
+    ) !important;
+}}
+
+.halide-lighttable::before {{
+  content: "";
+  position: absolute;
+  inset: 14px 8px;
+  pointer-events: none;
+  border-left: 1px solid rgba(197, 154, 82, 0.22);
+  border-right: 1px solid rgba(197, 154, 82, 0.22);
+  background:
+    repeating-linear-gradient(
+      0deg,
+      rgba(197, 154, 82, 0.24) 0,
+      rgba(197, 154, 82, 0.24) 7px,
+      transparent 7px,
+      transparent 22px
+    ) left center / 5px 100% no-repeat,
+    repeating-linear-gradient(
+      0deg,
+      rgba(197, 154, 82, 0.24) 0,
+      rgba(197, 154, 82, 0.24) 7px,
+      transparent 7px,
+      transparent 22px
+    ) right center / 5px 100% no-repeat;
+  opacity: 0.55;
+}}
+
+.halide-lighttable > * {{
+  position: relative;
+  z-index: 1;
+}}
+
+#halide-compare {{
+  min-height: 520px !important;
+  border: 1px solid rgba(243, 234, 219, 0.16) !important;
+}}
+
+.halide-review-actions {{
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 12px;
+}}
+
+.halide-review-actions a,
+.halide-history-preview-actions a {{
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 36px;
+  padding: 0 12px;
+  border-radius: 8px;
+  border: 1px solid rgba(102, 212, 193, 0.34);
+  background: rgba(102, 212, 193, 0.08);
+  color: #dffcf6 !important;
+  text-decoration: none !important;
+  font-size: 0.78rem;
+  font-weight: 820;
+}}
+
+.halide-review-actions a:hover,
+.halide-history-preview-actions a:hover {{
+  border-color: rgba(102, 212, 193, 0.62);
+  background: rgba(102, 212, 193, 0.13);
+}}
+
+.halide-report-subheading {{
+  color: var(--halide-teal);
+  font-size: 0.82rem;
+  font-weight: 860;
+  margin: 10px 0 6px;
+}}
+
+.halide-report-body strong {{
+  color: var(--halide-paper);
+}}
+
+.halide-report-body em {{
+  color: var(--halide-paper-soft);
+}}
+
+.halide-report-body code {{
+  color: #dffcf6;
+  background: rgba(102, 212, 193, 0.10);
+  border: 1px solid rgba(102, 212, 193, 0.22);
+  border-radius: 5px;
+  padding: 1px 5px;
+}}
+
+.halide-tab-note {{
+  color: var(--halide-muted);
+  font-size: 0.8rem;
+  line-height: 1.35;
+  margin: 0 0 8px;
+}}
+
+.halide-history-actions {{
+  gap: 8px !important;
+  margin: 6px 0 8px !important;
+}}
+
+.halide-history-actions button {{
+  min-height: 36px !important;
+}}
+
+.halide-history-table tbody tr {{
+  cursor: pointer;
+}}
+
+.halide-history-table tbody tr:hover td {{
+  background: rgba(197, 154, 82, 0.10) !important;
+}}
+
+.halide-history-preview {{
+  border: 1px solid rgba(197, 154, 82, 0.26);
+  background: rgba(5, 5, 5, 0.74);
+  border-radius: 8px;
+  padding: 8px;
+  display: grid;
+  gap: 8px;
+}}
+
+.halide-history-preview img {{
+  width: 100%;
+  max-height: 220px;
+  object-fit: contain;
+  background: var(--halide-black);
+  border-radius: 6px;
+}}
+
+.halide-history-preview-actions {{
+  display: flex;
+  flex-wrap: wrap;
+  gap: 7px;
+}}
+
+.halide-inspector-tabs {{
+  min-width: 0;
+}}
+
+.halide-inspector-tabs .tab-nav,
+.halide-inspector-tabs [role="tablist"] {{
+  overflow-x: auto;
+}}
+
+@media (max-width: 1380px) {{
   .halide-workbench {{
     flex-direction: column !important;
+    gap: 12px !important;
   }}
 
   .halide-intake-panel,
@@ -719,6 +991,20 @@ footer {{
   .halide-inspector {{
     width: 100% !important;
   }}
+
+  .halide-inspector {{
+    min-width: 0 !important;
+  }}
+
+  .halide-lighttable {{
+    padding: 11px !important;
+  }}
+
+  .halide-intake-panel,
+  .halide-inspector {{
+    position: static;
+    max-height: none;
+  }}
 }}
 
 @media (max-width: 760px) {{
@@ -729,11 +1015,26 @@ footer {{
   #halide-header {{
     align-items: flex-start;
     flex-direction: column;
+    gap: 12px;
+    padding-top: 14px;
+  }}
+
+  #halide-header h1 {{
+    font-size: 1.42rem;
+    max-width: 11rem;
   }}
 
   .halide-model-strip {{
     justify-content: flex-start;
     min-width: 0;
+    width: 100%;
+    gap: 6px;
+  }}
+
+  .halide-model-strip span,
+  .halide-model-strip a {{
+    padding: 7px 8px;
+    font-size: 0.68rem;
   }}
 
   .halide-brand-mark {{
@@ -741,6 +1042,58 @@ footer {{
     height: 40px;
   }}
 
+  .halide-intake-panel,
+  .halide-inspector {{
+    padding: 10px;
+  }}
+
+  .halide-run-state {{
+    min-height: 68px;
+    padding: 12px;
+  }}
+
+  .halide-empty-lighttable {{
+    min-height: 370px;
+  }}
+
+  .halide-empty-frame-grid {{
+    inset: 10px;
+  }}
+
+  .halide-empty-lighttable::after {{
+    inset: 16px;
+  }}
+
+  .halide-empty-frame-grid span {{
+    top: 10px;
+    left: 10px;
+    font-size: 0.62rem;
+  }}
+
+  .halide-empty-center {{
+    min-width: calc(100% - 40px);
+    padding: 15px 16px;
+  }}
+
+  .tabs button {{
+    min-height: 42px !important;
+    padding: 9px 10px !important;
+  }}
+
+  .halide-review-gallery {{
+    height: 190px !important;
+  }}
+
+  #halide-compare {{
+    min-height: 360px !important;
+  }}
+
+  #halide-run-button,
+  button.primary,
+  .primary button {{
+    min-height: 48px !important;
+  }}
+
   .halide-stat {{
     grid-template-columns: 1fr;
     gap: 3px;