Initial Halide Space: pipeline, UI, autumn theme

README.md

@@ -0,0 +1,50 @@
+---
+title: Project Halide
+emoji: "\U0001F525"
+colorFrom: orange
+colorTo: red
+sdk: gradio
+sdk_version: 6.16.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: Edge-native diagnostic engine for analog film scans
+---
+
+# Project Halide
+
+An edge-native diagnostic engine for analog film. Upload a film scan, fill in
+film stock + storage metadata, and Project Halide runs a two-stage analysis:
+
+1. **Vision Extraction** -- MiniCPM-V 4.6 (1.3B params, fine-tuned with LoRA on
+   the FilmDamageSimulator dataset) detects dust, dirt, scratches, and hair
+   artifacts as normalized bounding boxes.
+2. **Diagnostic Reasoning** -- Nemotron-Mini-4B-Instruct (4B params) with
+   3-shot prompting cross-references the defect report against your film stock
+   and storage metadata, and prescribes specific physical fixes a lab can
+   perform.
+
+The full pipeline runs locally in the Space. No external APIs. Models are
+loaded from a private Hugging Face repo at startup.
+
+## How to use
+
+1. Upload a film scan (PNG or JPEG, ideally 35mm or 120 frame).
+2. Select your film stock from the dropdown.
+3. Adjust the age and storage condition.
+4. Pick the scan resolution you used.
+5. Click **Diagnose scan**.
+
+Results are stored in a local SQLite database. The "Recent diagnoses" panel
+shows the last 10 runs in this Space session.
+
+## Models
+
+- Vision: `Lonelyguyse1/halide-vision` (private), based on
+  `openbmb/MiniCPM-V-4_6`.
+- Reasoning: `nvidia/Nemotron-Mini-4B-Instruct` (public, 4B params, few-shot
+  prompting only, no fine-tuning).
+
+## License
+
+Apache 2.0.

app.py

@@ -0,0 +1,27 @@
+"""Main entry point. Launches the Gradio app."""
+
+from __future__ import annotations
+
+import logging
+
+from ui.app import build_app
+
+
+def main() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+    )
+    from ui.theme import THEME_CSS, build_theme
+    app = build_app()
+    app.queue(max_size=8).launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        theme=build_theme(),
+        css=THEME_CSS,
+    )
+
+
+if __name__ == "__main__":
+    main()

models/__init__.py

@@ -0,0 +1 @@
+"""Model package. Vision and reasoning model wrappers."""

models/reasoning/__init__.py

@@ -0,0 +1 @@
+"""Reasoning model package. Nemotron-Mini wrapper for diagnosis."""

models/reasoning/inference.py

@@ -0,0 +1 @@
+"""Reasoning inference pipeline. Takes defect JSON and returns diagnosis."""

models/reasoning/nemotron_wrapper.py

@@ -0,0 +1,96 @@
+"""Nemotron-Mini-4B wrapper. Loads the model and generates diagnoses.
+
+Per AGENTS.md, this is the second stage of the dual-model pipeline.
+Receives defect JSON from the vision model plus user metadata, returns
+root cause diagnosis and physical remediation steps.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+NEMOTRON_MODEL_ID = "nvidia/Nemotron-Mini-4B-Instruct"
+MAX_NEW_TOKENS = int(os.getenv("HALIDE_NEMOTRON_MAX_TOKENS", "512"))
+
+
+class NemotronReasoner:
+    """Lazy-loading wrapper around Nemotron-Mini-4B-Instruct."""
+
+    def __init__(self, model_path: str | None = None) -> None:
+        self._model_path = model_path or NEMOTRON_MODEL_ID
+        self._tokenizer: Any = None
+        self._model: Any = None
+        self._device: str = "cpu"
+        self._dtype: Any = None
+
+    @property
+    def model_path(self) -> str:
+        return self._model_path
+
+    def load(self) -> None:
+        if self._model is not None:
+            return
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+
+        logger.info("Loading Nemotron-Mini-4B from %s", self._model_path)
+        self._tokenizer = AutoTokenizer.from_pretrained(self._model_path)
+        self._dtype = torch.bfloat16
+        self._model = AutoModelForCausalLM.from_pretrained(
+            self._model_path,
+            torch_dtype=self._dtype,
+            device_map="auto",
+        )
+        self._device = str(next(self._model.parameters()).device)
+        logger.info("Nemotron loaded on %s", self._device)
+
+    def generate(self, prompt: str, system: str | None = None) -> str:
+        if self._model is None:
+            self.load()
+
+        import torch
+
+        if system:
+            messages = [
+                {"role": "system", "content": system},
+                {"role": "user", "content": prompt},
+            ]
+        else:
+            messages = [{"role": "user", "content": prompt}]
+
+        input_ids = self._tokenizer.apply_chat_template(
+            messages, add_generation_prompt=True, return_tensors="pt"
+        ).to(self._device)
+
+        with torch.inference_mode():
+            output = self._model.generate(
+                input_ids,
+                max_new_tokens=MAX_NEW_TOKENS,
+                do_sample=False,
+                pad_token_id=self._tokenizer.eos_token_id,
+            )
+
+        response_ids = output[0][input_ids.shape[-1]:]
+        return self._tokenizer.decode(response_ids, skip_special_tokens=True)
+
+    def close(self) -> None:
+        if self._model is not None:
+            del self._model
+            self._model = None
+        if self._tokenizer is not None:
+            del self._tokenizer
+            self._tokenizer = None
+
+
+_default_reasoner: NemotronReasoner | None = None
+
+
+def get_reasoner() -> NemotronReasoner:
+    global _default_reasoner
+    if _default_reasoner is None:
+        _default_reasoner = NemotronReasoner()
+    return _default_reasoner

models/reasoning/prompts.py

@@ -0,0 +1,194 @@
+"""Few-shot prompt templates for the Nemotron diagnostic reasoner."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+SYSTEM_PROMPT = (
+    "You are a senior analog film lab technician with 30 years of experience "
+    "in darkroom printing, negative inspection, and equipment repair. You are "
+    "diagnosing the physical root cause of degradation in a film scan and "
+    "prescribing specific, actionable physical fixes a lab can perform."
+)
+
+
+FEW_SHOT_EXAMPLES: list[dict[str, str]] = [
+    {
+        "role": "user",
+        "content": (
+            "## Defect report\n"
+            "{\n"
+            '  "film_type": "Kodak Portra 400 (35mm)",\n'
+            '  "film_age_years": 2,\n'
+            '  "storage": "fridge, sealed",\n'
+            '  "defects": [\n'
+            '    {"label": "dust", "bbox_count": 87},\n'
+            '    {"label": "dirt", "bbox_count": 12}\n'
+            '  ],\n'
+            '  "scan_resolution_dpi": 4000\n'
+            "}\n\n"
+            "What is the root cause and what physical fixes do you recommend?"
+        ),
+    },
+    {
+        "role": "assistant",
+        "content": (
+            "## Root cause\n"
+            "High dust and dirt count on a recently-shot, properly stored roll "
+            "indicates contamination accumulated on the negative during "
+            "scanning, not deterioration of the film itself. The scanner's "
+            "dust-removal hardware (ICE/DEEP) is either disabled or "
+            "ineffective at 4000 dpi.\n\n"
+            "## Physical fixes\n"
+            "1. Clean the scanner glass and film holder with an anti-static "
+            "cloth and PEC*PAD swabs; re-scan.\n"
+            "2. Enable hardware-based dust removal in the scanner software "
+            "(e.g., Digital ICE for Kodak, DEEP for Noritsu) at a moderate "
+            "strength (level 3 of 5).\n"
+            "3. If hardware removal is unavailable, apply careful digital "
+            "spotting in Photoshop using the healing brush; budget 30-60 "
+            "minutes per frame.\n"
+            "4. Inspect the original negative under a loupe for any residual "
+            "physical particles and gently blow off with a rocket air blower "
+            "before re-scanning."
+        ),
+    },
+    {
+        "role": "user",
+        "content": (
+            "## Defect report\n"
+            "{\n"
+            '  "film_type": "Ilford HP5 (120 medium format)",\n'
+            '  "film_age_years": 15,\n'
+            '  "storage": "shoe box, attic",\n'
+            '  "defects": [\n'
+            '    {"label": "long_hair", "bbox_count": 4},\n'
+            '    {"label": "scratch", "bbox_count": 1}\n'
+            '  ],\n'
+            '  "scan_resolution_dpi": 3200\n'
+            "}\n\n"
+            "What is the root cause and what physical fixes do you recommend?"
+        ),
+    },
+    {
+        "role": "assistant",
+        "content": (
+            "## Root cause\n"
+            "Long hair and scratches on an aged, poorly stored roll indicate "
+            "physical abrasion from dust and debris inside the storage "
+            "container. Attic storage subjects film to temperature and "
+            "humidity swings that warp the emulsion and make it brittle.\n\n"
+            "## Physical fixes\n"
+            "1. Inspect the negative under a 10x loupe to confirm hair is on "
+            "the emulsion side (matte) vs. base side (glossy). Emulsion-side "
+            "hair cannot be wet-wiped safely.\n"
+            "2. If base-side only: gently wipe with a PEC*PAD soaked in "
+            "Edwal Negative Cleaner, then PEC*PAD with distilled water, "
+            "then dry.\n"
+            "3. If emulsion-side: do not wipe. Use Print File archival "
+            "sleeves and ship to a lab with wet-mount scanning (e.g., "
+            "Northcoast Photographic).\n"
+            "4. The single scratch is most likely from a dirty film "
+            "transport. Have the scanner cleaned and the film path "
+            "inspected; consider wet-gate scanning to mask the scratch.\n"
+            "5. Long-term: transfer remaining unexposed rolls to a "
+            "freezer at -18C in sealed bags with desiccant."
+        ),
+    },
+    {
+        "role": "user",
+        "content": (
+            "## Defect report\n"
+            "{\n"
+            '  "film_type": "CineStill 800T (35mm)",\n'
+            '  "film_age_years": 0,\n'
+            '  "storage": "fresh, refrigerated by manufacturer",\n'
+            '  "defects": [\n'
+            '    {"label": "dust", "bbox_count": 156},\n'
+            '    {"label": "dirt", "bbox_count": 23},\n'
+            '    {"label": "short_hair", "bbox_count": 8}\n'
+            '  ],\n'
+            '  "scan_resolution_dpi": 6000\n'
+            "}\n\n"
+            "What is the root cause and what physical fixes do you recommend?"
+        ),
+    },
+    {
+        "role": "assistant",
+        "content": (
+            "## Root cause\n"
+            "Excessive dust and dirt on a brand-new refrigerated roll at 6000 "
+            "dpi scan suggests a combination of (a) the static-prone "
+            "CineStill base attracting particles during loading, and (b) "
+            "scanner-side contamination. The hair count points to the "
+            "scanner's film transport path.\n\n"
+            "## Physical fixes\n"
+            "1. Anti-static treatment is critical for CineStill: discharge "
+            "the negative with a Zerostat gun on low setting 30 cm from the "
+            "film before scanning.\n"
+            "2. Clean the scanner glass, film holder, and feed rollers with "
+            "PEC*PAD swabs and reagent-grade isopropyl alcohol.\n"
+            "3. Use a static-discharge ionizing bar (e.g., Simco-Ion) at the "
+            "scanner input if available.\n"
+            "4. Re-scan with hardware dust removal at level 4 of 5. "
+            "CineStill's halated emulsion responds well to Digital ICE.\n"
+            "5. For the short hairs, inspect the film path under magnification "
+            "and remove any visible lint from the rollers with tweezers."
+        ),
+    },
+]
+
+
+def build_user_prompt(
+    film_type: str,
+    film_age_years: int,
+    storage: str,
+    scan_resolution_dpi: int,
+    defect_summary: dict[str, int],
+    total_defects: int,
+) -> str:
+    """Build the user message for the current diagnosis request."""
+    payload = {
+        "film_type": film_type,
+        "film_age_years": film_age_years,
+        "storage": storage,
+        "defects": [
+            {"label": label, "bbox_count": count}
+            for label, count in sorted(defect_summary.items())
+        ],
+        "scan_resolution_dpi": scan_resolution_dpi,
+        "total_defect_count": total_defects,
+    }
+    return (
+        "## Defect report\n"
+        f"{json.dumps(payload, indent=2)}\n\n"
+        "What is the root cause and what physical fixes do you recommend?"
+    )
+
+
+def build_messages(
+    film_type: str,
+    film_age_years: int,
+    storage: str,
+    scan_resolution_dpi: int,
+    defect_summary: dict[str, int],
+    total_defects: int,
+) -> list[dict[str, str]]:
+    """Return full message list (few-shot + current request) for the reasoner."""
+    messages: list[dict[str, str]] = []
+    messages.extend(FEW_SHOT_EXAMPLES)
+    messages.append(
+        {
+            "role": "user",
+            "content": build_user_prompt(
+                film_type,
+                film_age_years,
+                storage,
+                scan_resolution_dpi,
+                defect_summary,
+                total_defects,
+            ),
+        }
+    )
+    return messages

models/vision/__init__.py

@@ -0,0 +1 @@
+"""Vision model package. MiniCPM-V 4.6 wrapper for film defect detection."""

models/vision/inference.py

@@ -0,0 +1,78 @@
+"""Vision inference pipeline. Takes a film scan and returns defect JSON."""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+from typing import Any
+
+from models.vision.minicpm_wrapper import get_detector
+
+logger = logging.getLogger(__name__)
+
+ALLOWED_LABELS = {"dust", "dirt", "scratch", "long_hair", "short_hair"}
+
+
+def extract_defects(image: Any) -> dict:
+    """Run defect extraction on a PIL image. Returns defect dict + metadata."""
+    started = time.perf_counter()
+    detector = get_detector()
+    raw = detector.detect(image)
+    elapsed = time.perf_counter() - started
+
+    defects = raw.get("defects", [])
+    if not isinstance(defects, list):
+        logger.warning("Model output 'defects' is not a list: %r", type(defects))
+        defects = []
+
+    cleaned: list[dict] = []
+    dropped = 0
+    for d in defects:
+        if not isinstance(d, dict):
+            dropped += 1
+            continue
+        label = d.get("label")
+        bbox = d.get("bbox")
+        if label not in ALLOWED_LABELS:
+            dropped += 1
+            continue
+        if not isinstance(bbox, (list, tuple)) or len(bbox) != 4:
+            dropped += 1
+            continue
+        try:
+            x_min, y_min, x_max, y_max = (float(v) for v in bbox)
+        except (TypeError, ValueError):
+            dropped += 1
+            continue
+        if not (0.0 <= x_min <= 1.0 and 0.0 <= y_min <= 1.0):
+            dropped += 1
+            continue
+        if not (0.0 <= x_max <= 1.0 and 0.0 <= y_max <= 1.0):
+            dropped += 1
+            continue
+        if x_max <= x_min or y_max <= y_min:
+            dropped += 1
+            continue
+        cleaned.append({"label": label, "bbox": [x_min, y_min, x_max, y_max]})
+
+    label_counts: dict[str, int] = {}
+    for d in cleaned:
+        label_counts[d["label"]] = label_counts.get(d["label"], 0) + 1
+
+    return {
+        "defects": cleaned,
+        "defect_count": len(cleaned),
+        "label_counts": label_counts,
+        "dropped_count": dropped,
+        "inference_seconds": round(elapsed, 3),
+        "model_path": detector.model_path,
+    }
+
+
+def extract_defects_from_path(image_path: str | Path) -> dict:
+    """Convenience: open image from path and run extraction."""
+    from PIL import Image
+
+    img = Image.open(image_path).convert("RGB")
+    return extract_defects(img)

models/vision/minicpm_wrapper.py

@@ -0,0 +1,157 @@
+"""MiniCPM-V 4.6 wrapper. Loads the model and runs inference on film scans."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+LOCAL_MODEL_PATH = REPO_ROOT / "checkpoints" / "minicpm-v-4.6-merged"
+HF_MODEL_ID = "Lonelyguyse1/halide-vision"
+BASE_MODEL_ID = "openbmb/MiniCPM-V-4_6"
+
+DOWNSAMPLE_MODE = os.getenv("HALIDE_DOWNSAMPLE_MODE", "4x")
+MAX_SLICE_NUMS = int(os.getenv("HALIDE_MAX_SLICE_NUMS", "36"))
+MAX_NEW_TOKENS = int(os.getenv("HALIDE_MAX_NEW_TOKENS", "3072"))
+
+DETECTION_PROMPT = (
+    "You are a film defect detection engine. Analyze the film scan and detect "
+    "all visible defects. Output a JSON object with a 'defects' array. Each "
+    "defect has: 'label' (dust, dirt, scratch, long_hair, short_hair), 'bbox' "
+    "(normalized [x_min, y_min, x_max, y_max] from 0.0 to 1.0). Output JSON "
+    "only, no explanation."
+)
+
+
+def _resolve_model_path() -> str:
+    """Pick local merged model if present, else HF repo, else base model id."""
+    if LOCAL_MODEL_PATH.exists() and (LOCAL_MODEL_PATH / "config.json").exists():
+        logger.info("Using local merged model at %s", LOCAL_MODEL_PATH)
+        return str(LOCAL_MODEL_PATH)
+    if os.getenv("HF_TOKEN"):
+        logger.info("Using HF Hub repo %s", HF_MODEL_ID)
+        return HF_MODEL_ID
+    logger.info("Falling back to base model %s", BASE_MODEL_ID)
+    return BASE_MODEL_ID
+
+
+class MiniCPMVDetector:
+    """Lazy-loading wrapper around MiniCPM-V 4.6 for film defect detection."""
+
+    def __init__(self, model_path: str | None = None) -> None:
+        self._model_path = model_path or _resolve_model_path()
+        self._model: Any = None
+        self._processor: Any = None
+        self._dtype: Any = None
+        self._device: str = "cpu"
+
+    @property
+    def model_path(self) -> str:
+        return self._model_path
+
+    def load(self) -> None:
+        if self._model is not None:
+            return
+        import torch
+        from transformers import AutoModelForImageTextToText, AutoProcessor
+
+        logger.info("Loading MiniCPM-V 4.6 from %s", self._model_path)
+        self._processor = AutoProcessor.from_pretrained(
+            self._model_path, trust_remote_code=True
+        )
+        self._dtype = torch.bfloat16
+        self._model = AutoModelForImageTextToText.from_pretrained(
+            self._model_path,
+            torch_dtype=self._dtype,
+            device_map="auto",
+            trust_remote_code=True,
+        )
+        self._device = str(next(self._model.parameters()).device)
+        logger.info("Model loaded on %s", self._device)
+
+    def detect(self, image: Any) -> dict:
+        """Run defect detection on a PIL image. Returns parsed JSON dict."""
+        import torch
+
+        if self._model is None:
+            self.load()
+
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image},
+                    {"type": "text", "text": DETECTION_PROMPT},
+                ],
+            }
+        ]
+
+        inputs = self._processor.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_dict=True,
+            return_tensors="pt",
+            downsample_mode=DOWNSAMPLE_MODE,
+            max_slice_nums=MAX_SLICE_NUMS,
+        ).to(self._device)
+
+        with torch.inference_mode():
+            generated = self._model.generate(
+                **inputs,
+                downsample_mode=DOWNSAMPLE_MODE,
+                max_new_tokens=MAX_NEW_TOKENS,
+                do_sample=False,
+            )
+
+        trimmed = [out[len(inp):] for inp, out in zip(inputs.input_ids, generated)]
+        text = self._processor.batch_decode(
+            trimmed,
+            skip_special_tokens=True,
+            clean_up_tokenization_spaces=False,
+        )[0]
+
+        return _parse_defect_json(text)
+
+    def close(self) -> None:
+        if self._model is not None:
+            del self._model
+            self._model = None
+        if self._processor is not None:
+            del self._processor
+            self._processor = None
+
+
+def _parse_defect_json(text: str) -> dict:
+    """Extract and parse the first JSON object from model output."""
+    text = text.strip()
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+
+    match = re.search(r"\{[\s\S]*\}", text)
+    if not match:
+        logger.warning("No JSON found in model output: %r", text[:200])
+        return {"defects": [], "_raw": text, "_parse_error": "no_json_object"}
+    try:
+        return json.loads(match.group(0))
+    except json.JSONDecodeError as exc:
+        logger.warning("JSON parse error: %s; raw: %r", exc, text[:200])
+        return {"defects": [], "_raw": text, "_parse_error": str(exc)}
+
+
+_default_detector: MiniCPMVDetector | None = None
+
+
+def get_detector() -> MiniCPMVDetector:
+    global _default_detector
+    if _default_detector is None:
+        _default_detector = MiniCPMVDetector()
+    return _default_detector

pipeline/__init__.py

@@ -0,0 +1 @@
+"""Pipeline package. Orchestrates vision + reasoning stages."""

pipeline/diagnoser.py

@@ -0,0 +1,60 @@
+"""Diagnoser. Takes defect JSON and user metadata, returns diagnosis and fixes."""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from models.reasoning.nemotron_wrapper import get_reasoner
+from models.reasoning.prompts import SYSTEM_PROMPT, build_messages
+
+logger = logging.getLogger(__name__)
+
+
+def diagnose(
+    defect_result: dict,
+    film_type: str,
+    film_age_years: int,
+    storage: str,
+    scan_resolution_dpi: int,
+) -> dict:
+    """Run Nemotron reasoning over a defect result + user metadata.
+
+    Returns a dict with the raw text response and timing metadata.
+    """
+    started = time.perf_counter()
+    reasoner = get_reasoner()
+
+    label_counts = defect_result.get("label_counts", {}) or {}
+    total = defect_result.get("defect_count", 0) or sum(label_counts.values())
+
+    messages = build_messages(
+        film_type=film_type,
+        film_age_years=film_age_years,
+        storage=storage,
+        scan_resolution_dpi=scan_resolution_dpi,
+        defect_summary=label_counts,
+        total_defects=total,
+    )
+
+    logger.info(
+        "Running Nemotron diagnosis (film=%s, age=%d, storage=%s, total_defects=%d)",
+        film_type, film_age_years, storage, total,
+    )
+    text = reasoner.generate(prompt=messages, system=SYSTEM_PROMPT)
+    elapsed = time.perf_counter() - started
+
+    return {
+        "diagnosis_text": text,
+        "reasoning_seconds": round(elapsed, 3),
+        "model_path": reasoner.model_path,
+        "system_prompt": SYSTEM_PROMPT,
+        "input_defect_summary": {
+            "label_counts": label_counts,
+            "total": total,
+        },
+    }
+
+
+__all__ = ["diagnose"]

pipeline/extractor.py

@@ -0,0 +1,18 @@
+"""Defect extractor. Takes a film scan and returns structured defect JSON.
+
+This is a thin wrapper that re-exports `extract_defects` from the vision
+inference module so the pipeline layer has a stable interface.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from models.vision.inference import extract_defects, extract_defects_from_path
+
+__all__ = ["extract_defects", "extract_defects_from_path"]
+
+
+def extract(image: Any) -> dict:
+    """Top-level entry point used by the pipeline orchestrator."""
+    return extract_defects(image)

pipeline/pipeline.py

@@ -0,0 +1,62 @@
+"""Main pipeline. Orchestrates vision extraction and diagnostic reasoning."""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from pipeline.diagnoser import diagnose
+from pipeline.extractor import extract
+
+logger = logging.getLogger(__name__)
+
+
+def run_diagnosis(
+    image: Any,
+    film_type: str = "Unknown 35mm",
+    film_age_years: int = 1,
+    storage: str = "unknown",
+    scan_resolution_dpi: int = 4000,
+) -> dict:
+    """End-to-end: image -> defect JSON -> diagnosis + fixes.
+
+    Returns a single dict with both stages' outputs and timing info.
+    """
+    started = time.perf_counter()
+
+    logger.info("Stage 1: defect extraction")
+    defect_result = extract(image)
+
+    logger.info(
+        "Stage 1 complete: %d defects (%s) in %.2fs",
+        defect_result.get("defect_count", 0),
+        defect_result.get("label_counts", {}),
+        defect_result.get("inference_seconds", 0.0),
+    )
+
+    logger.info("Stage 2: Nemotron diagnosis")
+    diagnosis_result = diagnose(
+        defect_result,
+        film_type=film_type,
+        film_age_years=film_age_years,
+        storage=storage,
+        scan_resolution_dpi=scan_resolution_dpi,
+    )
+
+    total_elapsed = time.perf_counter() - started
+
+    return {
+        "film_metadata": {
+            "film_type": film_type,
+            "film_age_years": film_age_years,
+            "storage": storage,
+            "scan_resolution_dpi": scan_resolution_dpi,
+        },
+        "defects": defect_result,
+        "diagnosis": diagnosis_result,
+        "total_seconds": round(total_elapsed, 3),
+    }
+
+
+__all__ = ["run_diagnosis"]

requirements.txt

@@ -0,0 +1,16 @@
+# Project Halide Space Dependencies
+# Pinning to versions known to work with MiniCPM-V 4.6
+
+# Core
+gradio==6.16.0
+torch==2.7.0
+torchvision==0.22.0
+
+# HuggingFace stack
+transformers==5.7.0
+accelerate>=1.0.0
+huggingface_hub>=0.20.0
+pillow>=10.0.0
+
+# Nemotron reasoning uses default transformers tokenizer
+numpy>=1.24.0

storage/__init__.py

@@ -0,0 +1 @@
+"""Storage package. SQLite database and inference cache."""

storage/cache.py

@@ -0,0 +1,89 @@
+"""Caching. In-process LRU cache for diagnosis results keyed by image hash.
+
+For privacy, we hash the image bytes; the image itself is never persisted
+in the cache. Identical scans produce identical hashes, giving us a simple
+content-addressed cache.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import time
+from collections import OrderedDict
+from threading import Lock
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class DiagnosisCache:
+    """Thread-safe LRU cache for diagnosis results."""
+
+    def __init__(self, max_size: int = 64, ttl_seconds: int = 3600) -> None:
+        self._max_size = max_size
+        self._ttl = ttl_seconds
+        self._store: OrderedDict[str, tuple[float, dict]] = OrderedDict()
+        self._lock = Lock()
+        self._hits = 0
+        self._misses = 0
+
+    @staticmethod
+    def hash_image(image_bytes: bytes) -> str:
+        return hashlib.sha256(image_bytes).hexdigest()
+
+    def get(self, image_bytes: bytes) -> dict | None:
+        key = self.hash_image(image_bytes)
+        now = time.time()
+        with self._lock:
+            entry = self._store.get(key)
+            if entry is None:
+                self._misses += 1
+                return None
+            ts, value = entry
+            if now - ts > self._ttl:
+                del self._store[key]
+                self._misses += 1
+                return None
+            self._store.move_to_end(key)
+            self._hits += 1
+            logger.info("Cache hit for %s", key[:12])
+            return value
+
+    def put(self, image_bytes: bytes, value: dict) -> None:
+        key = self.hash_image(image_bytes)
+        now = time.time()
+        with self._lock:
+            self._store[key] = (now, value)
+            self._store.move_to_end(key)
+            while len(self._store) > self._max_size:
+                self._store.popitem(last=False)
+
+    def stats(self) -> dict:
+        with self._lock:
+            return {
+                "size": len(self._store),
+                "max_size": self._max_size,
+                "hits": self._hits,
+                "misses": self._misses,
+            }
+
+    def clear(self) -> None:
+        with self._lock:
+            self._store.clear()
+            self._hits = 0
+            self._misses = 0
+
+
+_default_cache: DiagnosisCache | None = None
+
+
+def get_cache() -> DiagnosisCache:
+    global _default_cache
+    if _default_cache is None:
+        _default_cache = DiagnosisCache()
+    return _default_cache
+
+
+__all__ = ["DiagnosisCache", "get_cache"]

storage/database.py

@@ -0,0 +1,177 @@
+"""SQLite database. Stores diagnostic history and user sessions.
+
+Schema:
+  sessions(id, started_at, film_type, film_age_years, storage, scan_dpi)
+  diagnoses(id, session_id, created_at, defect_count, label_counts_json,
+            diagnosis_text, vision_seconds, reasoning_seconds, total_seconds,
+            vision_model, reasoning_model, raw_json)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+import time
+import uuid
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Iterator
+
+logger = logging.getLogger(__name__)
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_DB_PATH = REPO_ROOT / "storage" / "halide.db"
+
+
+def get_db_path() -> Path:
+    import os
+    custom = os.getenv("HALIDE_DB_PATH")
+    if custom:
+        return Path(custom)
+    DEFAULT_DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    return DEFAULT_DB_PATH
+
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    started_at REAL NOT NULL,
+    film_type TEXT NOT NULL,
+    film_age_years INTEGER NOT NULL,
+    storage TEXT NOT NULL,
+    scan_dpi INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS diagnoses (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    created_at REAL NOT NULL,
+    defect_count INTEGER NOT NULL,
+    label_counts_json TEXT NOT NULL,
+    diagnosis_text TEXT NOT NULL,
+    vision_seconds REAL NOT NULL,
+    reasoning_seconds REAL NOT NULL,
+    total_seconds REAL NOT NULL,
+    vision_model TEXT NOT NULL,
+    reasoning_model TEXT NOT NULL,
+    raw_json TEXT NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_diagnoses_session ON diagnoses(session_id);
+CREATE INDEX IF NOT EXISTS idx_diagnoses_created ON diagnoses(created_at);
+"""
+
+
+@contextmanager
+def connect() -> Iterator[sqlite3.Connection]:
+    db_path = get_db_path()
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        yield conn
+        conn.commit()
+    finally:
+        conn.close()
+
+
+def init_db() -> None:
+    with connect() as conn:
+        conn.executescript(SCHEMA)
+    logger.info("DB initialized at %s", get_db_path())
+
+
+def record_diagnosis(result: dict) -> str:
+    """Persist a full pipeline result. Returns the diagnosis id."""
+    diagnosis_id = str(uuid.uuid4())
+    session_id = str(uuid.uuid4())
+    now = time.time()
+
+    meta = result.get("film_metadata", {}) or {}
+    defects = result.get("defects", {}) or {}
+    diagnosis = result.get("diagnosis", {}) or {}
+
+    with connect() as conn:
+        conn.execute(
+            """
+            INSERT INTO sessions (id, started_at, film_type, film_age_years,
+                                  storage, scan_dpi)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                session_id,
+                now,
+                meta.get("film_type", "Unknown"),
+                int(meta.get("film_age_years", 0) or 0),
+                meta.get("storage", "unknown"),
+                int(meta.get("scan_resolution_dpi", 0) or 0),
+            ),
+        )
+        conn.execute(
+            """
+            INSERT INTO diagnoses (id, session_id, created_at, defect_count,
+                                   label_counts_json, diagnosis_text,
+                                   vision_seconds, reasoning_seconds,
+                                   total_seconds, vision_model, reasoning_model,
+                                   raw_json)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                diagnosis_id,
+                session_id,
+                now,
+                int(defects.get("defect_count", 0) or 0),
+                json.dumps(defects.get("label_counts", {}) or {}),
+                diagnosis.get("diagnosis_text", ""),
+                float(defects.get("inference_seconds", 0.0) or 0.0),
+                float(diagnosis.get("reasoning_seconds", 0.0) or 0.0),
+                float(result.get("total_seconds", 0.0) or 0.0),
+                defects.get("model_path", ""),
+                diagnosis.get("model_path", ""),
+                json.dumps(result),
+            ),
+        )
+    logger.info("Recorded diagnosis %s (session %s)", diagnosis_id, session_id)
+    return diagnosis_id
+
+
+def list_recent(limit: int = 20) -> list[dict]:
+    with connect() as conn:
+        rows = conn.execute(
+            """
+            SELECT d.id, d.created_at, s.film_type, s.film_age_years,
+                   s.storage, s.scan_dpi, d.defect_count, d.label_counts_json,
+                   d.diagnosis_text, d.total_seconds
+            FROM diagnoses d
+            JOIN sessions s ON s.id = d.session_id
+            ORDER BY d.created_at DESC
+            LIMIT ?
+            """,
+            (limit,),
+        ).fetchall()
+    out: list[dict] = []
+    for r in rows:
+        out.append(
+            {
+                "id": r["id"],
+                "created_at": r["created_at"],
+                "film_type": r["film_type"],
+                "film_age_years": r["film_age_years"],
+                "storage": r["storage"],
+                "scan_dpi": r["scan_dpi"],
+                "defect_count": r["defect_count"],
+                "label_counts": json.loads(r["label_counts_json"]),
+                "diagnosis_text": r["diagnosis_text"],
+                "total_seconds": r["total_seconds"],
+            }
+        )
+    return out
+
+
+__all__ = [
+    "init_db",
+    "record_diagnosis",
+    "list_recent",
+    "get_db_path",
+]

ui/__init__.py

@@ -0,0 +1 @@
+"""UI package. Gradio app, theme, and components."""

ui/app.py

@@ -0,0 +1,219 @@
+"""Gradio app. Main UI definition and layout."""
+
+from __future__ import annotations
+
+import html
+import io
+import logging
+from typing import Any
+
+import gradio as gr
+
+from pipeline.pipeline import run_diagnosis
+from storage.cache import get_cache
+from storage.database import init_db, list_recent, record_diagnosis
+from ui.components import (
+    HEADER_HTML,
+    THEME_CSS,
+    defect_pills_html,
+    diagnosis_html,
+    render_history,
+    stats_html,
+)
+from ui.theme import build_theme
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+DEFAULT_FILM_TYPES = [
+    "Kodak Portra 400 (35mm)",
+    "Kodak Tri-X 400 (35mm)",
+    "Kodak Ektar 100 (35mm)",
+    "Ilford HP5 Plus (35mm)",
+    "Ilford Delta 100 (35mm)",
+    "Ilford FP4 Plus (120)",
+    "CineStill 800T (35mm)",
+    "Fujifilm Pro 400H (35mm)",
+    "Fomapan 400 (35mm)",
+    "Other / Unknown",
+]
+
+STORAGE_OPTIONS = [
+    "fridge, sealed",
+    "freezer, sealed",
+    "room temp, sealed",
+    "room temp, loose",
+    "shoe box, attic",
+    "shoe box, basement",
+    "unknown",
+]
+
+RESOLUTION_OPTIONS = [2000, 3000, 4000, 5000, 6000, 8000]
+
+
+def _image_to_bytes(pil_image: Any) -> bytes:
+    buf = io.BytesIO()
+    pil_image.save(buf, format="PNG")
+    return buf.getvalue()
+
+
+def run_pipeline(
+    image: Any,
+    film_type: str,
+    film_age_years: int,
+    storage: str,
+    scan_dpi: int,
+    progress: gr.Progress = gr.Progress(),
+) -> tuple[str, str, str, str]:
+    """Gradio handler for the diagnose button."""
+    if image is None:
+        empty = '<p style="color: var(--halide-crimson);">No image provided.</p>'
+        return empty, empty, empty, render_history(list_recent(limit=10))
+
+    try:
+        progress(0.0, "Hashing image for cache lookup...")
+        cache = get_cache()
+        image_bytes = _image_to_bytes(image)
+        cached = cache.get(image_bytes)
+        if cached is not None:
+            logger.info("Returning cached diagnosis")
+            result = cached
+        else:
+            progress(0.1, "Stage 1/2: running vision defect extraction...")
+            result = run_diagnosis(
+                image=image,
+                film_type=film_type or "Unknown 35mm",
+                film_age_years=int(film_age_years or 0),
+                storage=storage or "unknown",
+                scan_resolution_dpi=int(scan_dpi or 4000),
+            )
+            progress(0.85, "Stage 2/2: persisting diagnosis...")
+            try:
+                record_diagnosis(result)
+            except Exception as exc:  # pragma: no cover
+                logger.warning("Failed to record diagnosis: %s", exc)
+            cache.put(image_bytes, result)
+
+        progress(1.0, "Done.")
+
+        counts = result.get("defects", {}).get("label_counts", {}) or {}
+        stats = stats_html(result)
+        pills = defect_pills_html(counts)
+        diag = diagnosis_html(result.get("diagnosis", {}).get("diagnosis_text", ""))
+        history = render_history(list_recent(limit=10))
+        return stats, pills, diag, history
+    except Exception as exc:  # pragma: no cover
+        logger.exception("Pipeline failed")
+        err = (
+            '<div class="halide-card" style="border-color: var(--halide-crimson);">'
+            f'<div class="halide-section-title" style="color: var(--halide-red);">'
+            f"Pipeline error</div>"
+            f"<pre style=\"color: var(--halide-parchment); white-space: pre-wrap;\">"
+            f"{html.escape(str(exc))}</pre></div>"
+        )
+        return err, "", "", render_history(list_recent(limit=10))
+
+
+def refresh_history() -> str:
+    return render_history(list_recent(limit=10))
+
+
+def build_app() -> gr.Blocks:
+    init_db()
+    theme = build_theme()
+
+    with gr.Blocks(title="Project Halide") as app:
+        gr.HTML(HEADER_HTML)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                with gr.Group(elem_classes="halide-card"):
+                    gr.Markdown('<div class="halide-section-title">Scan upload</div>')
+                    image_input = gr.Image(
+                        label="Film scan",
+                        type="pil",
+                        height=380,
+                        sources=["upload", "clipboard"],
+                    )
+
+                with gr.Group(elem_classes="halide-card"):
+                    gr.Markdown('<div class="halide-section-title">Film metadata</div>')
+                    film_type = gr.Dropdown(
+                        choices=DEFAULT_FILM_TYPES,
+                        value=DEFAULT_FILM_TYPES[0],
+                        label="Film stock",
+                    )
+                    with gr.Row():
+                        film_age = gr.Slider(
+                            minimum=0,
+                            maximum=80,
+                            step=1,
+                            value=2,
+                            label="Age (years)",
+                        )
+                        scan_dpi = gr.Dropdown(
+                            choices=RESOLUTION_OPTIONS,
+                            value=4000,
+                            label="Scan resolution (dpi)",
+                        )
+                    storage = gr.Radio(
+                        choices=STORAGE_OPTIONS,
+                        value=STORAGE_OPTIONS[0],
+                        label="Storage condition",
+                    )
+
+                run_btn = gr.Button("Diagnose scan", variant="primary", size="lg")
+
+            with gr.Column(scale=2):
+                with gr.Group(elem_classes="halide-card"):
+                    gr.Markdown('<div class="halide-section-title">Defect summary</div>')
+                    defect_summary = gr.HTML(
+                        value='<p style="color: var(--halide-slate);">Awaiting scan.</p>'
+                    )
+
+                with gr.Group(elem_classes="halide-card"):
+                    gr.Markdown('<div class="halide-section-title">Diagnosis & fixes</div>')
+                    diagnosis_output = gr.HTML(
+                        value='<p style="color: var(--halide-slate);">Awaiting scan.</p>'
+                    )
+
+                with gr.Group(elem_classes="halide-card"):
+                    gr.Markdown('<div class="halide-section-title">Session stats</div>')
+                    stats_output = gr.HTML(
+                        value='<p style="color: var(--halide-slate);">Awaiting scan.</p>'
+                    )
+
+            with gr.Column(scale=1):
+                with gr.Group(elem_classes="halide-card"):
+                    gr.Markdown('<div class="halide-section-title">Recent diagnoses</div>')
+                    history_output = gr.HTML(value=render_history(list_recent(limit=10)))
+                    refresh_btn = gr.Button("Refresh history", size="sm")
+
+        gr.HTML(
+            "<footer>Project Halide. Edge-native, no cloud APIs. "
+            "Vision: MiniCPM-V 4.6 (1.3B). Reasoning: Nemotron-Mini-4B-Instruct (few-shot).</footer>"
+        )
+
+        run_btn.click(
+            fn=run_pipeline,
+            inputs=[image_input, film_type, film_age, storage, scan_dpi],
+            outputs=[stats_output, defect_summary, diagnosis_output, history_output],
+        )
+        refresh_btn.click(fn=refresh_history, outputs=[history_output])
+
+    return app
+
+
+def main() -> None:
+    app = build_app()
+    app.queue(max_size=8).launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        theme=build_theme(),
+        css=THEME_CSS,
+    )
+
+
+if __name__ == "__main__":
+    main()

ui/components.py

@@ -0,0 +1,104 @@
+"""UI components. Defect list rendering and shared visual helpers."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from ui.theme import THEME_CSS
+
+
+HEADER_HTML = """
+<div id="halide-header">
+  <h1>Project Halide</h1>
+  <p>Edge-native diagnostic engine for analog film scans</p>
+</div>
+"""
+
+
+def defect_pills_html(label_counts: dict[str, int]) -> str:
+    """Render defect counts as colored pills."""
+    if not label_counts:
+        return '<p style="color: var(--halide-slate);">No defects detected.</p>'
+    pills: list[str] = []
+    for label, count in sorted(label_counts.items(), key=lambda kv: -kv[1]):
+        pills.append(
+            f'<span class="halide-defect-pill {label}">{label}: {count}</span>'
+        )
+    return '<div>' + "".join(pills) + "</div>"
+
+
+def stats_html(result: dict) -> str:
+    """Render a stats card with defect counts and timing."""
+    defects = result.get("defects", {}) or {}
+    diagnosis = result.get("diagnosis", {}) or {}
+    total = result.get("total_seconds", 0.0) or 0.0
+    vision_s = defects.get("inference_seconds", 0.0) or 0.0
+    reasoning_s = diagnosis.get("reasoning_seconds", 0.0) or 0.0
+
+    rows: list[str] = []
+    rows.append(_stat_row("Total defects", str(defects.get("defect_count", 0))))
+    rows.append(_stat_row("Dropped (invalid)", str(defects.get("dropped_count", 0))))
+    rows.append(_stat_row("Vision inference", f"{vision_s:.2f}s"))
+    rows.append(_stat_row("Reasoning", f"{reasoning_s:.2f}s"))
+    rows.append(_stat_row("Total", f"{total:.2f}s"))
+    rows.append(_stat_row("Vision model", _truncate(defects.get("model_path", ""), 50)))
+    rows.append(_stat_row("Reasoning model", _truncate(diagnosis.get("model_path", ""), 50)))
+    return f'<div class="halide-card">{"".join(rows)}</div>'
+
+
+def _stat_row(label: str, value: str) -> str:
+    return (
+        '<div class="halide-stat">'
+        f'<span class="halide-stat-label">{label}</span>'
+        f'<span>{value}</span>'
+        "</div>"
+    )
+
+
+def _truncate(s: str, n: int) -> str:
+    if len(s) <= n:
+        return s
+    return "..." + s[-(n - 3):]
+
+
+def diagnosis_html(text: str) -> str:
+    """Wrap diagnosis text in the styled card."""
+    safe = (text or "(no diagnosis produced)").replace("\n", "<br>")
+    return f'<div class="halide-diagnosis">{safe}</div>'
+
+
+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
+    return (
+        f'<div class="halide-card" style="margin-bottom: 0.6rem;">'
+        f'<div class="halide-section-title" style="font-size: 0.95rem;">'
+        f"{film} (age {age}y, {storage})</div>"
+        f"{defect_pills_html(counts)}"
+        f'<div style="color: var(--halide-slate); font-size: 0.8rem; margin-top: 0.4rem;">'
+        f"defects: {total} | {seconds:.2f}s | {ts:.0f}"
+        f"</div></div>"
+    )
+
+
+def render_history(entries: Iterable[dict]) -> str:
+    items = "".join(history_row_html(e) for e in entries)
+    if not items:
+        return '<p style="color: var(--halide-slate);">No diagnoses yet.</p>'
+    return items
+
+
+__all__ = [
+    "HEADER_HTML",
+    "THEME_CSS",
+    "defect_pills_html",
+    "stats_html",
+    "diagnosis_html",
+    "render_history",
+]

ui/static/style.css

@@ -0,0 +1 @@
+/* Custom CSS for the autumn theme. Inlined into Gradio Blocks at runtime. */

ui/theme.py

@@ -0,0 +1,224 @@
+"""Autumn theme. Colors derived from the project logo (orange-to-red on black)."""
+
+from __future__ import annotations
+
+import gradio as gr
+
+AMBER = "#d97706"
+AMBER_DEEP = "#b45309"
+ORANGE = "#ea580c"
+RED = "#dc2626"
+CRIMSON = "#991b1b"
+EMBER = "#f59e0b"
+
+INK = "#0c0a09"
+INK_SOFT = "#1c1917"
+PARCHMENT = "#fef3c7"
+PARCHMENT_DEEP = "#fde68a"
+SLATE = "#44403c"
+
+THEME_CSS = f"""
+:root {{
+  --halide-amber: {AMBER};
+  --halide-amber-deep: {AMBER_DEEP};
+  --halide-orange: {ORANGE};
+  --halide-red: {RED};
+  --halide-crimson: {CRIMSON};
+  --halide-ember: {EMBER};
+  --halide-ink: {INK};
+  --halide-ink-soft: {INK_SOFT};
+  --halide-parchment: {PARCHMENT};
+  --halide-parchment-deep: {PARCHMENT_DEEP};
+  --halide-slate: {SLATE};
+}}
+
+body, .gradio-container {{
+  background: linear-gradient(180deg, #0c0a09 0%, #1c1917 50%, #0c0a09 100%);
+  color: var(--halide-parchment);
+  font-family: "Iowan Old Style", "Palatino Linotype", Palatino, Georgia, serif;
+}}
+
+#halide-header {{
+  background: linear-gradient(90deg, var(--halide-crimson) 0%, var(--halide-orange) 50%, var(--halide-amber) 100%);
+  padding: 1.4rem 2rem;
+  border-radius: 0 0 18px 18px;
+  margin-bottom: 1.5rem;
+  box-shadow: 0 8px 32px rgba(217, 119, 6, 0.25);
+  border-bottom: 1px solid var(--halide-amber);
+}}
+
+#halide-header h1 {{
+  color: var(--halide-parchment);
+  font-size: 2.4rem;
+  margin: 0;
+  letter-spacing: 0.02em;
+  text-shadow: 0 2px 4px rgba(0,0,0,0.4);
+}}
+
+#halide-header p {{
+  color: var(--halide-parchment-deep);
+  margin: 0.4rem 0 0 0;
+  font-size: 1.05rem;
+  font-style: italic;
+}}
+
+.halide-card {{
+  background: rgba(28, 25, 23, 0.85);
+  border: 1px solid var(--halide-amber-deep);
+  border-radius: 12px;
+  padding: 1.2rem;
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4);
+}}
+
+.halide-section-title {{
+  color: var(--halide-amber);
+  font-size: 1.15rem;
+  font-weight: 600;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+  margin-bottom: 0.6rem;
+  border-bottom: 1px solid var(--halide-amber-deep);
+  padding-bottom: 0.3rem;
+}}
+
+.halide-stat {{
+  display: flex;
+  justify-content: space-between;
+  padding: 0.4rem 0;
+  border-bottom: 1px dotted var(--halide-slate);
+  color: var(--halide-parchment);
+}}
+
+.halide-stat-label {{
+  color: var(--halide-amber);
+  font-weight: 600;
+}}
+
+.halide-diagnosis {{
+  background: rgba(217, 119, 6, 0.08);
+  border-left: 4px solid var(--halide-amber);
+  padding: 1rem 1.2rem;
+  border-radius: 6px;
+  white-space: pre-wrap;
+  font-size: 0.98rem;
+  line-height: 1.6;
+  color: var(--halide-parchment);
+}}
+
+.halide-defect-pill {{
+  display: inline-block;
+  background: var(--halide-amber);
+  color: var(--halide-ink);
+  padding: 0.2rem 0.7rem;
+  border-radius: 999px;
+  font-size: 0.85rem;
+  font-weight: 600;
+  margin: 0 0.3rem 0.3rem 0;
+}}
+
+.halide-defect-pill.dust {{ background: var(--halide-amber); color: var(--halide-ink); }}
+.halide-defect-pill.dirt {{ background: var(--halide-orange); color: var(--halide-parchment); }}
+.halide-defect-pill.scratch {{ background: var(--halide-red); color: var(--halide-parchment); }}
+.halide-defect-pill.long_hair {{ background: var(--halide-crimson); color: var(--halide-parchment); }}
+.halide-defect-pill.short_hair {{ background: var(--halide-ember); color: var(--halide-ink); }}
+
+button.primary, .primary button {{
+  background: linear-gradient(135deg, var(--halide-orange), var(--halide-red)) !important;
+  color: var(--halide-parchment) !important;
+  border: 1px solid var(--halide-amber) !important;
+  font-weight: 600 !important;
+  letter-spacing: 0.02em !important;
+  box-shadow: 0 2px 12px rgba(234, 88, 12, 0.4) !important;
+}}
+
+button.primary:hover, .primary button:hover {{
+  background: linear-gradient(135deg, var(--halide-red), var(--halide-crimson)) !important;
+}}
+
+input, textarea, select {{
+  background: var(--halide-ink-soft) !important;
+  color: var(--halide-parchment) !important;
+  border: 1px solid var(--halide-amber-deep) !important;
+}}
+
+input:focus, textarea:focus, select:focus {{
+  border-color: var(--halide-amber) !important;
+  box-shadow: 0 0 0 2px rgba(217, 119, 6, 0.3) !important;
+}}
+
+label, .label, .gradio-radio label, .gradio-checkbox label {{
+  color: var(--halide-parchment-deep) !important;
+  font-weight: 500 !important;
+}}
+
+footer {{
+  color: var(--halide-slate) !important;
+  text-align: center;
+  padding: 1rem;
+  font-size: 0.85rem;
+}}
+"""
+
+
+def build_theme() -> gr.Theme:
+    """Build the autumn-themed Gradio theme."""
+    return gr.themes.Base(
+        primary_hue=gr.themes.Color(
+            c50="#fef3c7",
+            c100="#fde68a",
+            c200="#fcd34d",
+            c300="#fbbf24",
+            c400="#f59e0b",
+            c500=AMBER,
+            c600=AMBER_DEEP,
+            c700="#92400e",
+            c800="#78350f",
+            c900=CRIMSON,
+            c950="#7c2d12",
+        ),
+        secondary_hue=gr.themes.Color(
+            c50="#fef3c7",
+            c100="#fde68a",
+            c200="#fcd34d",
+            c300="#fbbf24",
+            c400=EMBER,
+            c500=AMBER,
+            c600=ORANGE,
+            c700=RED,
+            c800=CRIMSON,
+            c900="#7c2d12",
+            c950="#431407",
+        ),
+        neutral_hue=gr.themes.Color(
+            c50="#fafaf9",
+            c100="#f5f5f4",
+            c200="#e7e5e4",
+            c300="#d6d3d1",
+            c400=SLATE,
+            c500="#57534e",
+            c600="#44403c",
+            c700="#292524",
+            c800=INK_SOFT,
+            c900=INK,
+            c950="#0c0a09",
+        ),
+        font=gr.themes.GoogleFont("Iowan Old Style"),
+        font_mono=gr.themes.GoogleFont("JetBrains Mono"),
+    ).set(
+        body_background_fill=INK,
+        body_background_fill_dark=INK,
+        body_text_color=PARCHMENT,
+        body_text_color_dark=PARCHMENT,
+        button_primary_background_fill=ORANGE,
+        button_primary_background_fill_dark=ORANGE,
+        button_primary_text_color=PARCHMENT,
+        button_primary_text_color_dark=PARCHMENT,
+        block_background_fill=INK_SOFT,
+        block_background_fill_dark=INK_SOFT,
+        block_border_color=AMBER_DEEP,
+        block_border_color_dark=AMBER_DEEP,
+        input_background_fill=INK,
+        input_background_fill_dark=INK,
+        input_border_color=AMBER_DEEP,
+        input_border_color_dark=AMBER_DEEP,
+    )