Release: display score + provenance fix + heatmap spotlight + web bundle with policy pages (a-eye f1f73c2edcd4)

.gitattributes

@@ -1,12 +1,2 @@
 *.pt filter=lfs diff=lfs merge=lfs -text
-webapp/assets/assets/logo.9add05631c93e895ff3b380bf07ae0b0.png filter=lfs diff=lfs merge=lfs -text
-webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/AntDesign.3f78af31cca60105799838a1a7a59fbd.ttf filter=lfs diff=lfs merge=lfs -text
-webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome.b06871f281fee6b241d60582ae9369b9.ttf filter=lfs diff=lfs merge=lfs -text
-webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome5_Brands.3b89dd103490708d19a95adcae52210e.ttf filter=lfs diff=lfs merge=lfs -text
-webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome5_Solid.605ed7926cf39a2ad5ec2d1f9d391d3d.ttf filter=lfs diff=lfs merge=lfs -text
-webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome6_Brands.56c8d80832e37783f12c05db7c8849e2.ttf filter=lfs diff=lfs merge=lfs -text
-webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome6_Solid.adec7d6f310bc577f05e8fe06a5daccf.ttf filter=lfs diff=lfs merge=lfs -text
-webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/Fontisto.b49ae8ab2dbccb02c4d11caaacf09eab.ttf filter=lfs diff=lfs merge=lfs -text
 webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/Ionicons.b4eb097d35f44ed943676fd56f6bdc51.ttf filter=lfs diff=lfs merge=lfs -text
-webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/MaterialCommunityIcons.6e435534bd35da5fef04168860a9b8fa.ttf filter=lfs diff=lfs merge=lfs -text
-webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/MaterialIcons.4e85bc9ebe07e0340c9c4fc2f6c38908.ttf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -35,9 +35,11 @@ USER appuser
 # authenticated HTTPS request instead. Check any change here with `python tools/live_check.py --mode hub`.
 # Guard defaults target the free CPU tier (2 vCPU / 16 GB): one inference at a time,
 # 2 intra-op threads; see guards.py / SECURITY.md for every AEYE_* knob.
+# AEYE_HEATMAP_STYLE: spotlight (app request 2026-09-24) | jet; a Space variable `jet` rolls the look back.
 ENV AEYE_DEVICE=cpu \
     AEYE_TORCH_THREADS=2 \
     AEYE_MAX_CONCURRENCY=1 \
+    AEYE_HEATMAP_STYLE=spotlight \
     TRANSFORMERS_OFFLINE=1
 
 # S6: where the weights come from when models/*.pt are not in this (public) repo. None of this is secret - the

crop_geometry.py

@@ -0,0 +1,121 @@
+"""Crop geometry plane (GPT round 3, 2026-09-26): WHERE each native-resolution v6 crop sits in its image.
+
+Why: the ChatGPT-renderer lattice (model.lattice_features, src/models/lattice_features.py) is a period-2 pattern whose
+frequency (0.5 * n0 / n cycles/px, n0 = 16 * floor(n / 16)) and phase are fixed in IMAGE coordinates. A statistic computed
+in a crop's own coordinates cannot see it (wf_r3 measure: crop-anchored phase .01-.16 TPR@1% vs .88-1.00 in image
+coordinates), so the model needs, per crop, its offset in the image, the image size and whether the view was mirrored.
+
+Transport: the geometry travels INSIDE the crops tensor as a fourth channel ("geometry plane"), so every loader, collate,
+pair batch, `.to(device)` and evaluator that already moves `crops` around carries it without a code change and it can
+never be paired with the wrong crop:
+    crops [..., 4, S, S]:  channels 0-2 = the CLIP-normalised pixels (unchanged)
+                           channel 3    = zeros except row 0, columns 0..6 = (MAGIC, x0, y0, width, height, hflip, vflip)
+  x0, y0         top-left of the crop in the image's own pixel frame (negative inside pad_to's reflect padding)
+  width, height  the image the crop was cut from, AFTER every pipeline op that changes pixels geometrically (the
+                 post-`pre` image in training, the delivered / decoded image in evaluation and in the service) and
+                 BEFORE the pad_to padding
+  hflip, vflip   1 when the crop's pixels are mirrored relative to the image (training's per-view RandomHorizontalFlip);
+                 column j of a mirrored crop is image column x0 + (S - 1 - j)
+Only a model built with lattice_features reads the plane (ZeroShotV6Detector splits it off before any other branch); a
+model without it rejects a 4-channel crop tensor (the CLIP de-normalisation cannot broadcast), and a lattice model rejects
+crops WITHOUT the plane (split_geometry raises) - a statistic silently computed in crop coordinates is the failure mode
+this plane exists to prevent. The magic value also fails when the tensor was cast below float32 or mirrored as a tensor
+(the plane's row 0 would move) after it was built.
+
+Byte-identical copies: 4_model_training/src/data/crop_geometry.py and 1_deployed_service/crop_geometry.py
+(1_deployed_service/tests/test_lattice_service.py pins it). torch only - no torchvision / PIL / package imports, so the
+DataLoader workers and the service import it for free.
+"""
+from __future__ import annotations
+
+import torch
+
+GEOM_MAGIC = 4099.0                      # exactly representable in float32; 4096 in bfloat16 -> a lossy cast is caught
+GEOM_FIELDS = ("x0", "y0", "width", "height", "hflip", "vflip")
+PIXEL_CHANNELS = 3
+PLANE_CHANNELS = PIXEL_CHANNELS + 1
+_ROW = 1 + len(GEOM_FIELDS)              # magic + fields, stored in row 0 of the plane
+_MAX_COORD = 1 << 23                     # integers up to 2**24 are exact in float32; keep a margin
+
+
+def geometry_row(x0: int, y0: int, width: int, height: int, hflip: bool = False, vflip: bool = False) -> list[float]:
+    """One crop's geometry as the plane stores it (floats of exact integers)."""
+    row = [float(int(x0)), float(int(y0)), float(int(width)), float(int(height)), float(bool(hflip)), float(bool(vflip))]
+    if row[2] < 1 or row[3] < 1:
+        raise ValueError(f"crop geometry: image size {row[2]:g}x{row[3]:g} must be >= 1")
+    if max(abs(v) for v in row) >= _MAX_COORD:
+        raise ValueError(f"crop geometry: {row} out of the exactly representable range")
+    return row
+
+
+def has_geometry(crops: torch.Tensor) -> bool:
+    return torch.is_tensor(crops) and crops.dim() >= 3 and crops.shape[-3] == PLANE_CHANNELS
+
+
+def attach_geometry(pixels: torch.Tensor, geom) -> torch.Tensor:
+    """pixels [..., 3, S, S] + geometry [..., 6] (tensor or nested lists of geometry_row values) -> crops [..., 4, S, S].
+    The pixel channels are copied bit for bit; the plane is float32 whatever the pixel dtype (float32 in every caller)."""
+    if pixels.dim() < 3 or pixels.shape[-3] != PIXEL_CHANNELS:
+        raise ValueError(f"attach_geometry: expected [..., 3, S, S] pixels, got {tuple(pixels.shape)}")
+    h, w = int(pixels.shape[-2]), int(pixels.shape[-1])
+    if w < _ROW:
+        raise ValueError(f"attach_geometry: crops narrower than {_ROW} px cannot hold the geometry row")
+    g = torch.as_tensor(geom, dtype=torch.float64)
+    lead = tuple(pixels.shape[:-3])
+    if tuple(g.shape) != lead + (len(GEOM_FIELDS),):
+        raise ValueError(f"attach_geometry: geometry shape {tuple(g.shape)} != {lead + (len(GEOM_FIELDS),)}")
+    _validate(g)
+    plane = torch.zeros(lead + (1, h, w), dtype=torch.float32, device=pixels.device)
+    plane[..., 0, 0, 0] = GEOM_MAGIC
+    plane[..., 0, 0, 1:_ROW] = g.to(device=pixels.device, dtype=torch.float32)
+    return torch.cat([pixels, plane.to(pixels.dtype)], dim=-3)
+
+
+def own_frame_geometry(pixels: torch.Tensor) -> torch.Tensor:
+    """Geometry [..., 6] (float64, on the pixels' device) for crops that ARE their whole image: x0 = y0 = 0, size = the crop
+    size, not mirrored. Used for the global view that v6 feeds as a single crop when no native crops are given (aux
+    batches); that view is a resize, so no renderer lattice survives in it anyway."""
+    lead = tuple(pixels.shape[:-3])
+    g = torch.zeros(lead + (len(GEOM_FIELDS),), dtype=torch.float64, device=pixels.device)
+    g[..., 2] = float(pixels.shape[-1])
+    g[..., 3] = float(pixels.shape[-2])
+    return g
+
+
+def split_geometry(crops: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    """crops [..., 4, S, S] -> (pixels [..., 3, S, S] (a view, bit-identical), geometry [..., 6] float64).
+    Raises ValueError when the plane is missing or damaged."""
+    if not has_geometry(crops):
+        shape = tuple(crops.shape) if torch.is_tensor(crops) else type(crops).__name__
+        raise ValueError(
+            f"model.lattice_features needs the crop geometry plane (crops [..., 4, S, S], src/data/crop_geometry.py) but got "
+            f"{shape}: a loader / evaluator / service path that cuts native crops must attach it (MultiViewDataset("
+            f"crop_geometry=True), eval_sealed, main_hybrid._native_crops) - the lattice statistic is only defined in image "
+            f"coordinates")
+    if crops.shape[-1] < _ROW:
+        raise ValueError(f"crop geometry plane: crops narrower than {_ROW} px")
+    plane = crops[..., PIXEL_CHANNELS, :, :]
+    meta = plane[..., 0, :_ROW].to(torch.float64)
+    if not bool((meta[..., 0] == GEOM_MAGIC).all()):
+        raise ValueError("crop geometry plane: magic value missing - the plane was damaged after it was built (a cast below "
+                         "float32, a tensor-level flip / crop / resize of the crops, or a 4-channel tensor that is not a plane)")
+    if bool(plane[..., 0, _ROW:].ne(0).any()) or bool(plane[..., 1:, :].ne(0).any()):
+        raise ValueError("crop geometry plane: non-zero values outside the geometry row (not a plane, or it was mixed with "
+                         "pixel data)")
+    g = meta[..., 1:]
+    _validate(g)
+    return crops[..., :PIXEL_CHANNELS, :, :], g
+
+
+def _validate(g: torch.Tensor) -> None:
+    if g.numel() == 0:
+        return
+    if not bool(torch.isfinite(g).all()) or not bool((g == torch.round(g)).all()):
+        raise ValueError("crop geometry: offsets / sizes / flips must be finite integers")
+    if bool((g[..., 2] < 1).any()) or bool((g[..., 3] < 1).any()):
+        raise ValueError("crop geometry: image width / height must be >= 1")
+    flips = g[..., 4:6]
+    if not bool(((flips == 0) | (flips == 1)).all()):
+        raise ValueError("crop geometry: hflip / vflip must be 0 or 1")
+    if bool((g.abs() >= _MAX_COORD).any()):
+        raise ValueError("crop geometry: value out of the exactly representable range")

heatmap_nextgen.py

@@ -7,13 +7,17 @@ The heatmap is the PatchGuard patch-probability map, refined for localization:
     (kills scattered noise so only the suspected insert lights up),
   * intensity-gated by the calibrated image confidence, so weak/uncertain maps
     stay faint instead of painting the photo with noise.
-Pure numpy / PIL / scipy. New file; nothing existing is modified.
+Two overlay styles share that map: `overlay` (jet colours painted on the photo) and `spotlight` (no colour: the
+suspect region stays the original photo, the rest is darkened, one white edge line) - AEYE_HEATMAP_STYLE picks.
+Pure numpy / PIL / scipy.
 """
 from __future__ import annotations
 
 import numpy as np
 from PIL import Image
-from scipy.ndimage import gaussian_filter, label, uniform_filter
+from scipy.ndimage import binary_dilation, binary_erosion, gaussian_filter, label, uniform_filter
+
+HEATMAP_STYLES = ("spotlight", "jet")
 
 
 def jet(values: np.ndarray) -> np.ndarray:
@@ -96,3 +100,52 @@ def overlay(
     alpha = max_alpha * c * (norm ** gamma)
     blended = rgb * (1.0 - alpha[..., None]) + jet(big) * alpha[..., None]
     return Image.fromarray((np.clip(blended, 0.0, 1.0) * 255).astype(np.uint8))
+
+
+def spotlight(
+    image: Image.Image,
+    loc: np.ndarray,
+    blanket: bool = False,
+    dim: float = 0.5,
+    ramp: tuple[float, float] = (0.35, 0.5),
+    line_px: int = 2,
+    line_alpha: float = 0.9,
+    shadow_px: int = 1,
+    shadow_alpha: float = 0.25,
+    ref_side: int = 768,
+) -> Image.Image:
+    """Spotlight on the photo (app request 2026-09-24, owner-approved; _collab/REQUEST_server_heatmap_spotlight.md).
+
+    No new colour: the jet overlay painted green and yellow over photos the app calls AI, and in the app green means
+    'real' and amber 'uncertain'. Same focus map as overlay() (one strongest blob), normalised so its peak is 1:
+      * norm >= ramp[1]: the original pixels, untouched;
+      * norm <= ramp[0]: brightness x `dim` (a plain multiply, so hue and saturation stay);
+      * in between: a linear ramp, so the edge of the dark area is soft;
+      * the contour norm = ramp[1]: a white line of `line_px` px (at a `ref_side` px display, scaled with the image;
+        half outside, half inside the region) at `line_alpha`, with a `shadow_px` black rim at `shadow_alpha` just
+        inside it so the line still shows on a bright photo.
+    `blanket=True` or a map with no blob returns the photo unchanged: there is no region to point at."""
+    if blanket:
+        return image.convert("RGB").copy()
+    rgb = np.asarray(image.convert("RGB"), np.float32) / 255.0
+    h, w = rgb.shape[:2]
+    big = _big(_focus(loc), (w, h))
+    peak = float(big.max())
+    if peak < 1e-6:
+        return image.convert("RGB").copy()
+    norm = big / peak
+    lo, hi = ramp
+    gain = dim + (1.0 - dim) * np.clip((norm - lo) / (hi - lo), 0.0, 1.0)
+    out = rgb * gain[..., None]
+    inside = norm >= hi
+    scale = max(1, int(round(max(w, h) / float(ref_side))))
+    line_w, shadow_w = line_px * scale, shadow_px * scale
+    out_half = line_w // 2
+    grown = binary_dilation(inside, iterations=out_half) if out_half else inside
+    # border_value=1: a region that touches the image edge gets no line along the edge of the picture
+    core = binary_erosion(inside, iterations=line_w - out_half, border_value=1)
+    line = grown & ~core
+    shadow = core & ~binary_erosion(core, iterations=shadow_w, border_value=1)
+    out[shadow] *= 1.0 - shadow_alpha
+    out[line] = out[line] * (1.0 - line_alpha) + line_alpha
+    return Image.fromarray(np.rint(np.clip(out, 0.0, 1.0) * 255.0).astype(np.uint8))

lattice_features.py

@@ -0,0 +1,237 @@
+"""ChatGPT-renderer lattice statistics as per-crop v6 artifact features (GPT round 3, 2026-09-26; model.lattice_features).
+
+What (wf_r3 measurement, owner TRAIN images only): pristine ChatGPT-app outputs carry a deterministic period-2 "lattice".
+Each axis of length n is rendered on a grid n0 = 16 * floor(n / 16) and then slightly UP-sampled to n, so the lattice
+sits at 0.5 * n0 / n cycles/px (334/334 train axes within 0.0002 c/px) with a phase fixed at the image origin (circular
+mean +0.3 / +0.2 deg, resultant length 1.000). Its 8x8 template T_REF (19 train images of 16-multiple size, leave-one-out
+cosine 0.995) puts 96% of its energy on the axis Nyquist terms and 2.7% on the (1/4, -1/4) anti-diagonal pair, a period-4
+term a Bayer demosaic does not make. The current recipes (fft_nyquist included) did not learn it: the radial FFT ring
+dilutes a 1-4 bin line to ~1e-4 of its ring mean, and the phase only exists in IMAGE coordinates, which random crops and
+flips hide from the network.
+
+Statistics (per 224 crop, on the RAW 0-1 crop pixels the model receives - after every pipeline op, before any resize -,
+in the image's own coordinates given by the crop geometry plane, src/data/crop_geometry.py):
+  luma Y = 255 * (0.299 R + 0.587 G + 0.114 B); residual r = Y - median3x3(Y) (edge-replicate border = scipy 'reflect').
+  x_in(x) = (x + 0.5) * n0(W) / W - 0.5 for image column x (and the same for rows with H).
+  nyq_x_img  signed z of the column sums of r projected on cos(pi * x_in + PHI0[0]); noise = mean over the 8 lower-frequency
+             controls pi * x_in * (1 + eps), eps = -0.015 - 0.01 k, of the quadrature energy / 2.
+  nyq_y_img  the same for the row sums and PHI0[1].
+  nyq_min_img  min(nyq_x_img, nyq_y_img): the lattice with the reference phase on BOTH axes (camera demosaic lattices
+             often have the origin phase on one axis only). Recommendation #1 (crop_nyqmin_img: 1.00 / .97 / .88 TPR@1% FPR
+             on owner held-out full scenes, pristine / q95 / q85; .00 on social and messenger_x2 - the resize removes it).
+  d4_img     signed z of T_REF restricted to its (1/4, -1/4) pair under the same resample model: sum r cos(psi + THETA_D4),
+             psi = (pi / 2) (x_in - y_in); noise = RMS of the same sum at the 8 frequency-scaled controls. Recommendation #2,
+             the camera gate (per crop; the measured whole-image version gates Dresden better - 0.7% vs 4.9% - but the
+             model only sees crops).
+Each selected z is passed as clamp(log1p(max(z, 0)), 0, clip) (`sides: positive`, the default) or, for an ablation only,
+clamp(sign(z) * log1p(|z|), -clip, clip) (`sides: signed`). Why one-sided (wf_r3 review, 2026-09-26): the renderer is never
+on the negative side (owner / gpt-image-1.5: 0% of images with mean z < -3), but the NEGATIVE side is where camera demosaic
+lattices (owner iPhone cal: 32% of crops z < -4 at orig, 29% after JPEG q85; Dresden 28%) and SD-family / GAN decoder
+lattices (sd15, wukong, vqdm, firefly, ...) sit. Through the exact 95 train loader on a uniform v7.2i train sample, crops
+with z < -4 are 0.85% of real vs 4.3% of fake crops (likelihood ratio 5.1; 7.1 on the pristine branch): a signed feature
+hands the head "strong anti-phase lattice = fake", which lands on a third of the protected owner-iPhone photos. The positive
+part keeps everything the measurement used (every TPR@FPR statistic thresholds the positive side).
+The reference is three fixed constants from owner
+train: PHI0, T_REF (-> THETA_D4) and the n0 rule. Identical code for both classes; no parameters (nothing to train, nothing
+in a checkpoint); computed under no_grad in float32 (pixels) / float64 (projections: immune to TF32 matmuls and autocast).
+
+Byte-identical copies: 4_model_training/src/models/lattice_features.py and 1_deployed_service/lattice_features.py
+(1_deployed_service/tests/test_lattice_service.py pins it; the import below works in both layouts).
+"""
+from __future__ import annotations
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+try:  # training package layout (src.models -> src.data)
+    from ..data.crop_geometry import (GEOM_FIELDS, attach_geometry, geometry_row, has_geometry,  # noqa: F401
+                                      own_frame_geometry, split_geometry)
+except ImportError:  # service: flat modules
+    from crop_geometry import (GEOM_FIELDS, attach_geometry, geometry_row, has_geometry,  # noqa: F401
+                               own_frame_geometry, split_geometry)
+
+# ---- reference (wf_r3 measure/ref.json, sha256 648bd485f9121afc197c3950bd927f2404408761c0eea4ca679c7a7535c56818,
+#      learned from the 167 owner TRAIN images; held-out and public packs were never used to fit it) ------------------
+PHI0 = (0.005224707587257661, 0.003667792028783213)        # radians, x / y, at the image origin
+T_REF = (                                                   # 8x8 zero-mean lattice template, rows = y mod 8, cols = x mod 8
+    (0.17269160274461814, 0.016624810023089433, 0.18758460622056203, -0.027523961101165936, 0.14382515421100395, 0.010407459922983272, 0.22656217773376325, -0.04924261285800926),
+    (4.117843771012356e-05, -0.20775218375052468, 0.018273811741025364, -0.14531792563384296, -0.007125371135598881, -0.19250900379480274, 0.011853639378828587, -0.15534194826915765),
+    (0.21871752243500459, -0.041426545193588266, 0.15513920077363727, 0.00981277178155932, 0.18862573156031762, -0.02502035730420058, 0.16482270033206348, -0.006749445513922211),
+    (0.02603878721645228, -0.13637760279564196, -0.02078179072234321, -0.1671030130249308, 0.02701412394689342, -0.13616309110290123, 0.009209601740110585, -0.18093331853537442),
+    (0.14200447990246007, -0.018297584224412827, 0.18252467048327578, -0.033059550544393856, 0.13405059346250559, 0.006831903648010557, 0.1963587313220746, -0.052682036739672894),
+    (0.01117447391168055, -0.20319086173560147, 0.008779578605276629, -0.13356437311264927, -0.014971437140206703, -0.178110895003855, 0.03181750290914937, -0.1503561100517138),
+    (0.22419278170968648, -0.037280988420779794, 0.1560292920928076, 0.0016715735350392035, 0.20854080743872597, -0.03821453011186845, 0.1570347879658586, 0.009063247694749367),
+    (0.031853372606417844, -0.15298436141156935, -0.02837693990464353, -0.18054482745022435, -0.005528327933958054, -0.1497548713314285, -0.009564785696936069, -0.20332203945750849),
+)
+RENDER_GRID = 16                                            # n0 = RENDER_GRID * floor(n / RENDER_GRID)
+CTRL_EPS = tuple(-0.015 - 0.01 * k for k in range(8))       # lower-frequency controls (both statistics)
+Z_EPS = 1e-12                                               # as the measurement (0-255 luma scale)
+LUMA = (0.299, 0.587, 0.114)
+
+
+def _theta_d4() -> float:
+    """Phase of the (l, k) = (-2, +2) DFT coefficient of T_REF (numpy fft2 convention: sum T exp(-2 pi i (l y + k x) / 8)
+    = sum T exp(-i pi/2 (x - y))). Pure python: the same float on every machine."""
+    re = sum(T_REF[y][x] * math.cos(-0.5 * math.pi * (x - y)) for y in range(8) for x in range(8))
+    im = sum(T_REF[y][x] * math.sin(-0.5 * math.pi * (x - y)) for y in range(8) for x in range(8))
+    return math.atan2(im, re)
+
+
+THETA_D4 = _theta_d4()                                      # -2.5207698601217063
+
+# ---- config contract ------------------------------------------------------------------------------------------------
+LATTICE_KEYS = ("stats", "per_crop", "clip", "sides")
+LATTICE_STATS = ("nyq_min_img", "d4_img", "nyq_x_img", "nyq_y_img")
+LATTICE_SIDES = ("positive", "signed")
+DEFAULT_STATS = ("nyq_min_img", "d4_img")
+DEFAULT_CLIP = 4.0                                          # |z| up to e^4 - 1 = 53.6 (per-crop z: owner pristine p99 ~22 / 63)
+DEFAULT_SIDES = "positive"                                  # the renderer phase only (see the module docstring)
+
+
+def parse_lattice_features(spec) -> dict | None:
+    """Validated spec {stats: tuple, per_crop: True, clip: float, sides: 'positive' | 'signed'}, or None when the features
+    are off (absent / None / False / 'none' / {} / {stats: []}). Unknown keys, unknown or duplicated stats, per_crop: false,
+    clip <= 0 and an unknown `sides` are errors: a misspelt key must not train a silent copy of the recipe without the
+    features."""
+    if spec is None or spec is False:
+        return None
+    if isinstance(spec, str):
+        if spec.strip().lower() in ("", "none", "off"):
+            return None
+        raise ValueError(f"model.lattice_features must be a mapping {{stats, per_crop, clip}}, got {spec!r}")
+    if not isinstance(spec, dict):
+        raise ValueError(f"model.lattice_features must be a mapping, got {type(spec).__name__}")
+    unknown = sorted(set(spec) - set(LATTICE_KEYS))
+    if unknown:
+        raise ValueError(f"model.lattice_features: unknown key(s) {unknown} (allowed: {list(LATTICE_KEYS)})")
+    if not spec:
+        return None
+    stats = spec.get("stats", DEFAULT_STATS)
+    if isinstance(stats, str) or not isinstance(stats, (list, tuple)):
+        raise ValueError(f"model.lattice_features.stats must be a list, got {stats!r}")
+    stats = tuple(str(s) for s in stats)
+    if not stats:
+        return None
+    bad = [s for s in stats if s not in LATTICE_STATS]
+    if bad or len(set(stats)) != len(stats):
+        raise ValueError(f"model.lattice_features.stats {list(stats)}: unknown {bad} or duplicated (allowed: {list(LATTICE_STATS)})")
+    per_crop = spec.get("per_crop", True)
+    if per_crop is not True:
+        raise ValueError("model.lattice_features.per_crop must be true: the model only sees crops (an image-level statistic "
+                         "would have to be computed by every loader / evaluator / the service outside the model)")
+    clip = float(spec.get("clip", DEFAULT_CLIP))
+    if not (clip > 0 and math.isfinite(clip)):
+        raise ValueError(f"model.lattice_features.clip must be a positive number, got {spec.get('clip')!r}")
+    sides = spec.get("sides", DEFAULT_SIDES)
+    if not isinstance(sides, str) or sides.strip().lower() not in LATTICE_SIDES:
+        raise ValueError(f"model.lattice_features.sides must be one of {list(LATTICE_SIDES)}, got {sides!r}")
+    return {"stats": stats, "per_crop": True, "clip": clip, "sides": sides.strip().lower()}
+
+
+def render_grid(n: torch.Tensor) -> torch.Tensor:
+    """n0 = max(16, 16 * floor(n / 16)) for integer-valued float64 sizes."""
+    return torch.clamp(torch.floor(n / RENDER_GRID) * RENDER_GRID, min=float(RENDER_GRID))
+
+
+def median3x3(y: torch.Tensor) -> torch.Tensor:
+    """3x3 median of [N, H, W] with an edge-replicate border (= scipy.ndimage.median_filter(size=3, mode='reflect')).
+    Exact order statistic via the 19-exchange median-of-9 network (elementwise min / max only: deterministic, no sort)."""
+    h, w = y.shape[-2:]
+    p = F.pad(y.unsqueeze(1), (1, 1, 1, 1), mode="replicate").squeeze(1)
+    v = [p[:, i:i + h, j:j + w] for i in range(3) for j in range(3)]
+    for a, b in ((1, 2), (4, 5), (7, 8), (0, 1), (3, 4), (6, 7), (1, 2), (4, 5), (7, 8), (0, 3), (5, 8), (4, 7), (3, 6),
+                 (1, 4), (2, 5), (4, 7), (4, 2), (6, 4), (4, 2)):
+        v[a], v[b] = torch.minimum(v[a], v[b]), torch.maximum(v[a], v[b])
+    return v[4]
+
+
+def _image_coords(start: torch.Tensor, flip: torch.Tensor, length: int, n_full: torch.Tensor) -> torch.Tensor:
+    """[N, length] generation-grid coordinate x_in of the crop's pixel columns (or rows), float64."""
+    j = torch.arange(length, dtype=torch.float64, device=start.device).unsqueeze(0)
+    pos = torch.where(flip.unsqueeze(1) > 0.5, (length - 1) - j, j) + start.unsqueeze(1)   # image column of crop column j
+    s = (render_grid(n_full) / n_full).unsqueeze(1)
+    return (pos + 0.5) * s - 0.5
+
+
+class LatticeFeatures(nn.Module):
+    """raw 0-1 crops [N, 3, H, W] + geometry [N, 6] (crop_geometry fields) -> [N, len(stats)] float32 features.
+    No parameters and no buffers: nothing is added to a state dict."""
+
+    CHUNK = 64   # crops per pass: bounds the transient memory of the median network (~20 MB per crop-chunk of 224^2)
+
+    def __init__(self, spec: dict) -> None:
+        super().__init__()
+        spec = parse_lattice_features(spec)   # idempotent on an already parsed spec
+        if spec is None:
+            raise ValueError("LatticeFeatures needs an enabled lattice_features spec")
+        self.stats = tuple(spec["stats"])
+        self.clip = float(spec["clip"])
+        self.sides = str(spec["sides"])
+        self.out_dim = len(self.stats)
+
+    def extra_repr(self) -> str:
+        return f"stats={list(self.stats)}, clip={self.clip:g}, sides={self.sides}"
+
+    @staticmethod
+    def transform(z: torch.Tensor, clip: float, sides: str) -> torch.Tensor:
+        """positive: clamp(log1p(max(z, 0)), 0, clip) - an anti-phase lattice reads as 'no lattice';
+        signed: clamp(sign(z) * log1p(|z|), -clip, clip)."""
+        if sides == "positive":
+            return torch.clamp(torch.log1p(torch.clamp(z, min=0.0)), 0.0, clip)
+        if sides == "signed":
+            return torch.clamp(torch.sign(z) * torch.log1p(z.abs()), -clip, clip)
+        raise ValueError(f"lattice transform: unknown sides {sides!r}")
+
+    def forward(self, raw: torch.Tensor, geom: torch.Tensor) -> torch.Tensor:
+        z = self.z_scores(raw, geom)
+        out = torch.stack([self.transform(z[s], self.clip, self.sides) for s in self.stats], dim=1)
+        return out.to(torch.float32)
+
+    @torch.no_grad()
+    def z_scores(self, raw: torch.Tensor, geom: torch.Tensor) -> dict[str, torch.Tensor]:
+        """{stat: [N] float64 signed z} for every statistic (the features before the log / clip transform)."""
+        if raw.dim() != 4 or raw.shape[1] != 3:
+            raise ValueError(f"LatticeFeatures: expected raw crops [N, 3, H, W], got {tuple(raw.shape)}")
+        n = raw.shape[0]
+        geom = torch.as_tensor(geom).to(device=raw.device, dtype=torch.float64).reshape(n, len(GEOM_FIELDS))
+        dev_type = raw.device.type if raw.device.type in ("cuda", "cpu") else "cpu"
+        parts: dict[str, list] = {k: [] for k in LATTICE_STATS}
+        with torch.autocast(device_type=dev_type, enabled=False):
+            for i in range(0, n, self.CHUNK):
+                zs = self._z_chunk(raw[i:i + self.CHUNK].detach().float(), geom[i:i + self.CHUNK])
+                for k in LATTICE_STATS:
+                    parts[k].append(zs[k])
+        return {k: torch.cat(v) for k, v in parts.items()}
+
+    @staticmethod
+    def _z_chunk(raw: torch.Tensor, geom: torch.Tensor) -> dict[str, torch.Tensor]:
+        n, _, h, w = raw.shape
+        y = (raw[:, 0] * LUMA[0] + raw[:, 1] * LUMA[1] + raw[:, 2] * LUMA[2]) * 255.0
+        r = (y - median3x3(y)).to(torch.float64)                                    # [n, h, w]
+        x0, y0, wimg, himg, hf, vf = geom.unbind(dim=1)
+        xin = _image_coords(x0, hf, w, wimg)                                        # [n, w]
+        yin = _image_coords(y0, vf, h, himg)                                        # [n, h]
+        eps = torch.tensor(CTRL_EPS, dtype=torch.float64, device=raw.device)       # [8]
+
+        def axis_z(prof: torch.Tensor, xi: torch.Tensor, phi: float) -> torch.Tensor:
+            sc = (prof * torch.cos(math.pi * xi + phi)).sum(dim=1)
+            a = math.pi * xi.unsqueeze(1) * (1.0 + eps).view(1, -1, 1)             # [n, 8, len]
+            pc = (prof.unsqueeze(1) * torch.cos(a)).sum(dim=2)
+            ps = (prof.unsqueeze(1) * torch.sin(a)).sum(dim=2)
+            noise = ((pc * pc + ps * ps) / 2.0).mean(dim=1) + Z_EPS
+            return sc / torch.sqrt(noise)
+
+        zx = axis_z(r.sum(dim=1), xin, PHI0[0])                                     # column sums
+        zy = axis_z(r.sum(dim=2), yin, PHI0[1])                                     # row sums
+
+        scales = torch.cat([torch.zeros(1, dtype=torch.float64, device=raw.device), eps])   # [9]: 0 = the reference
+        a = 0.5 * math.pi * xin.unsqueeze(2) * (1.0 + scales).view(1, 1, -1) + THETA_D4    # [n, w, 9]
+        b = 0.5 * math.pi * yin.unsqueeze(2) * (1.0 + scales).view(1, 1, -1)               # [n, h, 9]
+        # sum_{y,x} r cos(A(x) - B(y)) = sum_y [cos B (r @ cos A) + sin B (r @ sin A)]  (float64 bmm: no TF32)
+        s = (torch.cos(b) * torch.bmm(r, torch.cos(a)) + torch.sin(b) * torch.bmm(r, torch.sin(a))).sum(dim=1)   # [n, 9]
+        noise = torch.sqrt((s[:, 1:] ** 2).mean(dim=1)) + Z_EPS
+        zd4 = s[:, 0] / noise
+        return {"nyq_min_img": torch.minimum(zx, zy), "d4_img": zd4, "nyq_x_img": zx, "nyq_y_img": zy}

main_hybrid.py

@@ -56,8 +56,10 @@ import fusion
 import guards
 import multiview
 import provenance_gate
+import score_display
 import synthid_gate
-from heatmap_nextgen import overlay as render_overlay, pure_heatmap, residual_var
+from heatmap_nextgen import HEATMAP_STYLES, overlay as render_overlay, pure_heatmap, residual_var
+from heatmap_nextgen import spotlight as render_spotlight
 from patchguard import PATCHGUARD_ARCH, PatchGuardDetector
 from schemas import AnalyzeResponse, HealthResponse, VersionResponse
 from zero_shot_v4 import CLIP_MEAN, CLIP_STD, ZeroShotV4Detector
@@ -232,6 +234,20 @@ def fusion_decision(band: str, source: str, fused: float | None, model) -> tuple
 
 
 FUSION_MODE = parse_fusion_mode(os.getenv("AEYE_FUSION", "auto"))       # auto | on | off
+
+
+def parse_heatmap_style(value: str | None) -> str:
+    """AEYE_HEATMAP_STYLE: spotlight (default since the 2026-09-24 app request) | jet (the old colour overlay).
+    Rolling the look back is this one variable. An unknown value is logged and served as spotlight rather than
+    stopping the start-up: it only changes how the overlay looks, never a verdict."""
+    style = (value or "").strip().lower() or "spotlight"
+    if style not in HEATMAP_STYLES:
+        print(f"[hybrid] AEYE_HEATMAP_STYLE={value!r} is not one of {HEATMAP_STYLES} - serving spotlight", flush=True)
+        return "spotlight"
+    return style
+
+
+HEATMAP_STYLE = parse_heatmap_style(os.getenv("AEYE_HEATMAP_STYLE"))
 FUSION_PATH = os.getenv("AEYE_FUSION_PATH", os.path.join(os.path.dirname(os.path.abspath(__file__)), "fusion",
                                                           "fusion_v7.2.json"))
 
@@ -429,9 +445,71 @@ def _resolve_weights(path: str) -> str:
 
 
 _V5_KEYS = ("clip_layers", "anchor_layer", "clip_adapter", "adapter_rank", "adapter_targets", "adapter_layers")
-_V4_KEYS = ("clip_backbone", "clip_layer", "semantic_dim", "forensic_dim", "frequency_dim", "fft_bins", "image_size", "num_classes")
+# fft_nyquist (C3, 2026-09-24): a checkpoint trained with the Nyquist ring must be rebuilt with it; absent = historic rings
+_V4_KEYS = ("clip_backbone", "clip_layer", "semantic_dim", "forensic_dim", "frequency_dim", "fft_bins", "image_size", "num_classes",
+            "fft_nyquist")
 _V6_KEYS = ("patch_backbone", "patch_dim", "n_crops_train", "n_crops_eval", "crop_pool", "crop_head",
-            "semantic_dropout_p", "artifact_dropout_p", "attribution_classes")
+            "semantic_dropout_p", "artifact_dropout_p", "attribution_classes",
+            # GPT round 3 (2026-09-26): per-crop renderer-lattice statistics; ZeroShotV6Detector refuses an unknown stat and
+            # _native_crops then attaches the crop geometry plane (crop_geometry.py) the statistics are defined on
+            "lattice_features")
+# patch_adapter (R2C, 2026-09-24) is deliberately NOT a constructor key here: a verdict trained with an Effort adapter on
+# its DINOv2 linears is served MERGED. The export (tools/merge_patch_adapter.py; tools/package_release.py does it) folds
+# W_p + U_k diag(s_k) V_k into plain weights stored under the frozen backbone's own names, the service builds the plain
+# v6 and its ordinary strict loader puts them into the frozen DINOv2 - no adapter code, no SVD at start-up, the CPU cost
+# of a frozen-DINOv2 model. _check_patch_adapter proves the stored tensors are exactly the ones the config announces.
+# Target -> module path in a Dinov2Layer: a copy of the training table (src/models/zero_shot_v6.PATCH_ADAPTER_TARGETS);
+# tests/test_patch_adapter_merge.py pins that the two agree.
+_PATCH_ADAPTER_TARGETS = {
+    "query": "attention.attention.query",
+    "key": "attention.attention.key",
+    "value": "attention.attention.value",
+    "dense": "attention.output.dense",
+    "fc1": "mlp.fc1",
+    "fc2": "mlp.fc2",
+}
+
+
+def _patch_adapter_spec(mcfg) -> dict | None:
+    """The checkpoint's MERGED patch adapter spec, None without one. An unmerged adapter is refused (fail closed): the
+    service has no adapter code path, and the factors alone would be dropped as unknown tensors anyway."""
+    pa = mcfg.get("patch_adapter") if isinstance(mcfg, dict) else None
+    if pa is None or pa is False or (isinstance(pa, str) and pa.strip().lower() in ("", "none", "off")):
+        return None
+    if not isinstance(pa, dict):
+        raise ValueError(f"verdict checkpoint: model.patch_adapter {pa!r} is not a mapping")
+    if str(pa.get("kind", "none")).strip().lower() in ("", "none", "off"):
+        return None
+    if not pa.get("merged"):
+        raise ValueError("verdict checkpoint carries an UNMERGED DINOv2 patch adapter (model.patch_adapter): this service "
+                         "serves merged weights only - export it with tools/merge_patch_adapter.py (package_release does)")
+    targets = pa.get("targets")
+    if not targets or isinstance(targets, str) or any(t not in _PATCH_ADAPTER_TARGETS for t in targets):
+        raise ValueError(f"verdict checkpoint: model.patch_adapter.targets {targets!r} not understood by this service build")
+    return pa
+
+
+def _check_patch_adapter(model: torch.nn.Module, mcfg, state: dict, label: str) -> int:
+    """The DINOv2 tensors a checkpoint stores must be EXACTLY the merged adapter weights its config announces (every
+    targeted linear of every layer, nothing else) - otherwise a half-merged export, or merged weights with the config
+    flag lost, would serve a silently different backbone. Returns the number of merged tensors (0 without an adapter)."""
+    spec = _patch_adapter_spec(mcfg)
+    patch_keys = sorted(k for k in state if k.startswith("patch."))
+    if spec is None:
+        if patch_keys:
+            raise RuntimeError(f"{label}: checkpoint carries {len(patch_keys)} DINOv2 tensor(s) {patch_keys[:3]} but its config "
+                               f"has no patch_adapter - refusing to serve an undeclared backbone change")
+        return 0
+    layers = getattr(getattr(getattr(model, "patch", None), "encoder", None), "layer", None)
+    if layers is None:
+        raise RuntimeError(f"{label}: model.patch_adapter is set but the model has no DINOv2 patch backbone")
+    want = sorted(f"patch.encoder.layer.{i}.{_PATCH_ADAPTER_TARGETS[t]}.weight"
+                  for i in range(len(layers)) for t in spec["targets"])
+    if patch_keys != want:
+        missing, extra = sorted(set(want) - set(patch_keys)), sorted(set(patch_keys) - set(want))
+        raise RuntimeError(f"{label}: merged patch adapter does not match its config ({list(spec['targets'])} x {len(layers)} "
+                           f"layers): {len(missing)} missing {missing[:3]}, {len(extra)} unexpected {extra[:3]}")
+    return len(want)
 
 
 def _source_head_width(state) -> int | None:
@@ -486,6 +564,7 @@ def _verdict_kwargs_from_checkpoint(ck) -> tuple[str, dict]:
         for k in _V6_KEYS:
             if k in mcfg:
                 kwargs[k] = mcfg[k]
+        _patch_adapter_spec(mcfg)  # R2C: an unmerged DINOv2 adapter is refused here, before anything is built
         return "v6", kwargs
     return "v5", kwargs
 
@@ -520,6 +599,21 @@ def _load_state_strict(model: torch.nn.Module, state: dict, label: str) -> int:
     return len(state)
 
 
+def _check_fft_rings(model: torch.nn.Module, label: str) -> None:
+    """The radial-FFT rings are a PERSISTENT buffer, so a checkpoint carries its own copy and loading it overrides the
+    rings the constructor built. Prove that what was loaded is exactly the geometry the checkpoint's config describes
+    (fft_nyquist on or off): a Nyquist-trained checkpoint served through a config without the flag - or the reverse -
+    would otherwise either compute silently different features or silently match only by accident. Every pre-C3
+    checkpoint (best49, best63, best69, best69_loc) stores exactly the historic rings (checked 2026-09-24)."""
+    fb = getattr(model, "frequency_branch", None)
+    if fb is None or not hasattr(fb, "masks"):
+        return
+    want = fb._make_radial_masks(fb.image_size, fb.bins, nyquist=bool(getattr(fb, "nyquist", False)))
+    if not torch.equal(fb.masks.detach().cpu(), want):
+        raise RuntimeError(f"{label}: frequency_branch.masks do not match the rings of fft_nyquist="
+                           f"{bool(getattr(fb, 'nyquist', False))} - checkpoint and config disagree")
+
+
 def _read_threshold(path: str, default: float) -> float:
     try:
         ck = torch.load(path, map_location="cpu", weights_only=True)  # never unpickle arbitrary objects
@@ -633,23 +727,36 @@ class HybridDetector:
             model = ZeroShotV4Detector(**kwargs)
         state = ck.get("model_trainable_state_dict", ck.get("model_state_dict", ck))
         n = _load_state_strict(model, state, f"verdict({arch})")
+        _check_fft_rings(model, f"verdict({arch})")
+        mcfg = ((ck.get("config") or {}).get("model") or {}) if isinstance(ck, dict) else {}
+        n_patch = _check_patch_adapter(model, mcfg, state, f"verdict({arch})") if arch == "v6" else 0
         # needed by the fusion gate (v6 only) and by the band binding (AEYE_BANDS_FOR); hashing ~30 MB of tensors is
         # not free, so only then
         wanted = (arch == "v6" and FUSION_MODE != "off") or bool(BANDS_FOR)
         self.verdict_fingerprint = fusion.state_fingerprint(state) if wanted else None
         _log(f"[verdict] arch={arch} clip_layers={kwargs.get('clip_layers', kwargs.get('clip_layer'))} "
              f"adapter={kwargs.get('clip_adapter', 'none')} tensors={n} "
-             f"crops={self.verdict_crops} decode<={self.verdict_decode_box or 'guard default'}")
+             + (f"patch_adapter=merged({n_patch} DINOv2 weights) " if n_patch else "")
+             + f"crops={self.verdict_crops} decode<={self.verdict_decode_box or 'guard default'}")
         return model.to(self.device).eval()
 
     def _native_crops(self, pil: Image.Image) -> torch.Tensor:
         """[1, K, 3, 224, 224] windows cut at the image's own resolution — the second half of a v6 input.
-        Same grid and same padding as dataset_v7/eval_sealed.py (see multiview.py)."""
+        Same grid and same padding as dataset_v7/eval_sealed.py (see multiview.py). A verdict with lattice_features gets
+        [1, K, 4, 224, 224]: + the geometry plane (crop_geometry.py) = each window's offset in the decoded image (before
+        the padding) and that image's size, exactly as eval_sealed.RecordSet(crop_geometry=True) attaches it."""
+        w0, h0 = pil.size
         padded = multiview.pad_to(pil, INPUT_SIZE)
         w, h = padded.size
-        crops = [self.transform_crop(padded.crop((cx, cy, cx + INPUT_SIZE, cy + INPUT_SIZE)))
-                 for cx, cy in multiview.grid_boxes(w, h, INPUT_SIZE, self.verdict_crops)]
-        return torch.stack(crops).unsqueeze(0).to(self.device)
+        boxes = multiview.grid_boxes(w, h, INPUT_SIZE, self.verdict_crops)
+        crops = torch.stack([self.transform_crop(padded.crop((cx, cy, cx + INPUT_SIZE, cy + INPUT_SIZE))) for cx, cy in boxes])
+        if getattr(self.verdict, "lattice_spec", None) is not None:
+            import crop_geometry
+
+            ox, oy = max(0, INPUT_SIZE - w0) // 2, max(0, INPUT_SIZE - h0) // 2
+            crops = crop_geometry.attach_geometry(
+                crops, [crop_geometry.geometry_row(cx - ox, cy - oy, w0, h0) for cx, cy in boxes])
+        return crops.unsqueeze(0).to(self.device)
 
     @torch.no_grad()
     def _dense_patch(self, pil: Image.Image) -> np.ndarray:
@@ -811,7 +918,8 @@ class HybridDetector:
             # confidence dimming (product preference: heatmap should never look faint).
             conf = 1.0
             heatmap_b64 = _png_b64(pure_heatmap(loc, display.size, conf, blanket=False))
-            overlay_b64 = _png_b64(render_overlay(display, loc, conf, blanket=False))
+            overlay_b64 = _png_b64(render_spotlight(display, loc) if HEATMAP_STYLE == "spotlight"
+                                   else render_overlay(display, loc, conf, blanket=False))
             flat = np.sort(patch.ravel())[::-1]
             k = max(1, int(round(flat.size * 0.08)))
             structure_score = float(flat[:k].mean())
@@ -833,6 +941,13 @@ class HybridDetector:
         if c2pa.get("present") or signals:
             provenance_status = "unverified"  # string scan only; no signature / trust-chain validation
         taxonomy = "EDITED" if (source == "patchguard_rescue" or partial_edit_suspect) else verdict
+        # additive display fields (score_display.py, owner 2026-09-28): the pixel score stretched onto the FINAL
+        # band's range (REAL 0-10, UNCERTAIN 40-60, AI 90-100); nothing above reads them back
+        display_band = score_display.final_band(verdict, verdict_band, source)
+        # a filename export pattern alone is weak evidence: shown as the pixel score inside the AI range, not 100
+        filename_only = bool(filename_signals) and not c2pa.get("present") and set(signals) <= set(filename_signals)
+        display_score = score_display.display_score(score49, display_band, source, t5, t1, self.threshold,
+                                                    filename_only=filename_only)
         return {
             "score": score,
             "verdict": verdict,
@@ -840,6 +955,7 @@ class HybridDetector:
             "band_thresholds": {"t5": t5, "t1": t1},
             "heatmap_b64": heatmap_b64,
             "overlay_b64": overlay_b64,
+            "heatmap_style": HEATMAP_STYLE,
             "model_version": self.model_version + ("+provenance" if source == "provenance" else "") + ("+rescue" if rescued else ""),
             "elapsed_ms": int((time.perf_counter() - started) * 1000),
             "structure_score": structure_score,
@@ -862,6 +978,8 @@ class HybridDetector:
                         "max_band": self.fusion.max_band}
                        # the detailed reason (paths, fingerprints) stays in the start-up log, not in every response
                        if fused is not None else {"enabled": False, "status": "disabled"}),
+            "display_score": display_score,
+            "display_band": display_band,
         }
 
 
@@ -889,7 +1007,7 @@ def startup_banner(s: "guards.Settings", threshold: float, arch: str, crops: int
     the pixel-bomb patch had split that field in two, and since every unit test runs the app WITHOUT the
     lifespan, `uvicorn main_hybrid:app` died at "Application startup" while the suite stayed green."""
     return (f"[hybrid] ready: verdict={arch}" + (f" crops={crops}" if crops else "") + f" thr={threshold} "
-            f"heatmap=dense | guards: max_upload={s.max_upload_bytes}B "
+            f"heatmap=dense/{HEATMAP_STYLE} | guards: max_upload={s.max_upload_bytes}B "
             f"max_pixels jpeg={s.max_pixels_jpeg}/other={s.max_pixels_other} decoded<={s.max_decoded_pixels} "
             f"concurrency={s.max_concurrency}/queue={s.max_queue} wait={s.queue_timeout_s}s "
             f"anon={s.anon_per_minute}/min,{s.anon_per_day}/day keys={len(s.api_keys)} "
@@ -1078,6 +1196,7 @@ async def predict(request: Request, image: UploadFile = File(...)) -> dict[str,
         "reason": result.get("reason"),
         "heatmap_b64": result.get("heatmap_b64"),
         "overlay_b64": result.get("overlay_b64"),
+        "heatmap_style": result.get("heatmap_style"),
     }
 
 

provenance_gate.py

@@ -40,7 +40,9 @@ BARE_C2PA_IS_AI = os.getenv("AEYE_BARE_C2PA_IS_AI", "0") == "1"
 # sources in captions and filenames.
 SIGNATURES: dict[str, tuple[bytes, ...]] = {
     "OpenAI": (b"openai", b"dall-e", b"dall\xc2\xb7e", b"dalle", b"gpt-image", b"chatgpt"),
-    "Adobe/Firefly": (b"adobe firefly", b"firefly image", b"firefly", b"xmlns:cai=", b"cai:"),
+    # b"cai:" alone was dropped 2026-09-29: it matched by chance inside the APP6 tuning blob of Motorola Moto Z2 Play
+    # camera originals (4 Dresden/Forchheim real photos -> "Adobe/Firefly" -> forced AI); the namespace declaration stays
+    "Adobe/Firefly": (b"adobe firefly", b"firefly image", b"firefly", b"xmlns:cai="),
     "StableDiffusion/Comfy": (b"stable diffusion", b"stable-diffusion", b"sd-webui", b"automatic1111",
                                b"comfyui", b"negative prompt", b"stability ai", b"stability.ai"),
     "Midjourney": (b"midjourney", b"nijijourney", b"niji journey", b"niji\xc2\xb7journey", b"--niji"),
@@ -65,6 +67,11 @@ C2PA_AI_GENERATORS = (b"openai", b"dall-e", b"chatgpt", b"gpt-image", b"firefly"
                       b"imagen", b"gemini", b"microsoft designer", b"bing image creator", b"ideogram",
                       b"leonardo", b"black forest labs", b"flux.1", b"grok", b"emu image")
 PROVENANCE_REGIONS = ("APP11/JUMBF", "caBX", "C2PA", "APP1/XMP", "APP1/XMP-ext", "XMP")
+# JPEG APPn segments that carry vendor BINARY data (camera tuning / maker blobs, Adobe DCT info), never generator text:
+# generator-signature tokens are not searched there, because long runs of bytes that happen to be printable occur in such
+# blobs and a short token then matches by chance (2026-09-29, Moto Z2 Play APP6: "CAI:" -> false "Adobe/Firefly").
+# APP1 (EXIF / XMP), APP11 (JUMBF / C2PA), APP13 (Photoshop IRB / IPTC text) and COM are still searched.
+BINARY_APP_LABELS = frozenset(f"APP{n}" for n in (0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15))
 
 _EXIF_TAGS = {v: k for k, v in ExifTags.TAGS.items()}
 
@@ -211,7 +218,7 @@ def scan_metadata(raw: bytes) -> dict:
     capture = False                     # wrote the manifest is not proof the pixels were generated)
     for label, data in regions:
         low = data.lower()
-        for sig_label, toks in SIGNATURES.items():
+        for sig_label, toks in (() if label in BINARY_APP_LABELS else SIGNATURES.items()):
             for tok in _find_tokens(low, toks):
                 bucket = matches.setdefault(sig_label, [])
                 if tok not in bucket:

renderer_trace.py

@@ -0,0 +1,269 @@
+"""Size-gated ChatGPT-renderer trace: the 'renderer_trace' verdict basis (GPT round 4, _collab/prereg_gpt_round4.json 'trace').
+
+Byte-identical copies: tools/renderer_trace.py and 1_deployed_service/renderer_trace.py
+(1_deployed_service/tests/test_renderer_trace.py pins both). numpy + scipy + PIL only: no torch, no import from tools/ or
+from 4_model_training, so the service copy stands alone.
+
+What it measures (frozen before any round-4 data, prereg 'trace.statistic'; constants NOT refit):
+  s = min( mean_k nyq_min_img_k / 1.08 , mean_k d4_img_k / 4.42 )
+over the 9 native 224-px crops grid_boxes(W, H, 224, 9) of the decoded image (an image smaller than 224 on a side is first
+padded by pad_to exactly as wf_r3 did, and the crop geometry is then taken in the PADDED frame, as wf_r3 did).
+  nyq_min_img = min(z_x, z_y) of the signed Nyquist matched filter in IMAGE coordinates (renderer resample model
+                x_in = (x + 0.5) * n0 / n - 0.5 with n0 = 16 * floor(n / 16), fixed reference phase PHI0), z-scored by 8
+                lower-frequency controls                                     (= wf_r3 measure/supp.py 'crop_nyqmin_img')
+  d4_img      = the signed z of the owner-TRAIN template T_REF restricted to its (1/4, -1/4) pair, same resample model,
+                z-scored by 8 frequency-scaled controls                     (= wf_r3 measure/d4all.py 'crop_d4_img')
+1.08 and 4.42 are the reals' pooled p99 of the two statistics (wf_r3 final_tables.md).
+
+Why this is a PORT of the wf_r3 numpy code and not LatticeFeatures.z_scores (lattice_features.py sha16 c5970908a11b32ff):
+the prereg asks for |dz| < 1e-4 against the wf_r3 jsonl values. LatticeFeatures computes luma as (u8 / 255 * w) * 255 in
+float32 and reproduces nyq_min_img to ~1e-5 but d4_img only to 1.1e-4 (owner_edit_train IMG pristine, 81 crop-variants
+checked, 2026-09-28), so the rule's fallback applies: latlib.py (wf_r3/measure, sha256 70fb858c...) is ported verbatim
+below (grid_boxes, pad_to, luma, resid, n0_of, x_in, nyq_mf, template_coeffs, tmpl_mf, camguard.restricted). PHI0 and
+T_REF are the ref.json values (sha256 648bd485...), identical to lattice_features.PHI0 / T_REF.
+
+Gate (prereg 'trace.gate'): decoded long side <= 2048 px after EXIF transpose. Above it the statistic is not computed and
+the trace never fires. Decoding (decode()) is the evaluator's / service's rule: JPEG/MPO DCT draft to a 2048 box
+(eval_sealed.RecordSet with multi-view, guards.native_draft_target), EXIF transpose, RGB.
+One-sided: fires iff s > t (t = t* from tools/trace_calib.py). The trace can only ADD an AI verdict.
+v2 (_collab/prereg_gpt_round4_trace_v2.json): an optional lower bound, gate_min = 1024 -> the gate is 1024 <= long side
+<= 2048. gate_min = 0 (the default) is v1, bit for bit; the statistic and its fingerprint do not change.
+
+  python renderer_trace.py <image> [<image> ...] [--t 0.2] [--gate-min 1024]   per-image JSON (s, means, long side, gate, fires)
+"""
+from __future__ import annotations
+
+import hashlib
+import io
+import json
+import math
+import sys
+
+import numpy as np
+from PIL import Image, ImageOps
+from scipy import ndimage
+
+TRACE_VERSION = "renderer_trace/1: min(mean9 crop_nyqmin_img / 1.08, mean9 crop_d4_img / 4.42), gate long side <= 2048"
+SCALE_NYQ = 1.08            # reals' pooled p99 of mean_k nyq_min_img (wf_r3 final_tables.md)
+SCALE_D4 = 4.42             # reals' pooled p99 of mean_k d4_img
+GATE_LONG_SIDE = 2048       # decoded long side (after EXIF transpose) above which the trace is not computed
+CROP = 224
+N_CROPS = 9
+DECODE_BOX = 2048           # JPEG DCT draft box of the evaluator / the v6 service
+
+# ---- reference (wf_r3 measure/ref.json, sha256 648bd485f9121afc197c3950bd927f2404408761c0eea4ca679c7a7535c56818) ----
+PHI0 = (0.005224707587257661, 0.003667792028783213)        # radians, x / y, at the image origin
+T_REF = (                                                   # 8x8 zero-mean lattice template, rows = y mod 8, cols = x mod 8
+    (0.17269160274461814, 0.016624810023089433, 0.18758460622056203, -0.027523961101165936, 0.14382515421100395, 0.010407459922983272, 0.22656217773376325, -0.04924261285800926),
+    (4.117843771012356e-05, -0.20775218375052468, 0.018273811741025364, -0.14531792563384296, -0.007125371135598881, -0.19250900379480274, 0.011853639378828587, -0.15534194826915765),
+    (0.21871752243500459, -0.041426545193588266, 0.15513920077363727, 0.00981277178155932, 0.18862573156031762, -0.02502035730420058, 0.16482270033206348, -0.006749445513922211),
+    (0.02603878721645228, -0.13637760279564196, -0.02078179072234321, -0.1671030130249308, 0.02701412394689342, -0.13616309110290123, 0.009209601740110585, -0.18093331853537442),
+    (0.14200447990246007, -0.018297584224412827, 0.18252467048327578, -0.033059550544393856, 0.13405059346250559, 0.006831903648010557, 0.1963587313220746, -0.052682036739672894),
+    (0.01117447391168055, -0.20319086173560147, 0.008779578605276629, -0.13356437311264927, -0.014971437140206703, -0.178110895003855, 0.03181750290914937, -0.1503561100517138),
+    (0.22419278170968648, -0.037280988420779794, 0.1560292920928076, 0.0016715735350392035, 0.20854080743872597, -0.03821453011186845, 0.1570347879658586, 0.009063247694749367),
+    (0.031853372606417844, -0.15298436141156935, -0.02837693990464353, -0.18054482745022435, -0.005528327933958054, -0.1497548713314285, -0.009564785696936069, -0.20332203945750849),
+)
+CTRL_EPS = np.array([-0.015 - 0.01 * k for k in range(8)])  # lower-frequency controls for the matched filters
+KSET = np.arange(-4, 5)
+KW = np.where(np.abs(KSET) == 4, 0.5, 1.0)
+
+
+# ---------------------------------------------------------------- v6 eval geometry (latlib copy of multiview.py)
+def grid_boxes(w: int, h: int, size: int, k: int) -> list[tuple[int, int]]:
+    k = max(1, int(k))
+    cols = int(round(math.sqrt(k * max(w, 1) / max(h, 1))))
+    cols = max(1, min(k, cols))
+    rows = max(1, int(math.ceil(k / cols)))
+    cols = max(1, min(cols, max(1, w - size + 1)))
+    rows = max(1, min(rows, max(1, h - size + 1)))
+    xs = [int(round(i * (w - size) / (cols - 1))) if cols > 1 else (w - size) // 2 for i in range(cols)]
+    ys = [int(round(j * (h - size) / (rows - 1))) if rows > 1 else (h - size) // 2 for j in range(rows)]
+    boxes: list[tuple[int, int]] = []
+    for y in ys:
+        for x in xs:
+            if (x, y) not in boxes:
+                boxes.append((x, y))
+    if len(boxes) > k:
+        idx = np.linspace(0, len(boxes) - 1, k).round().astype(int)
+        boxes = [boxes[i] for i in idx]
+    while len(boxes) < k:
+        boxes.append(boxes[len(boxes) % max(1, len(boxes))])
+    return boxes
+
+
+def pad_to(arr: np.ndarray, size: int) -> np.ndarray:
+    h, w = arr.shape[:2]
+    if w >= size and h >= size:
+        return arr
+    pw, ph = max(0, size - w), max(0, size - h)
+    pads = ((ph // 2, ph - ph // 2), (pw // 2, pw - pw // 2)) + ((0, 0),) * (arr.ndim - 2)
+    mode = "reflect" if (ph < h and pw < w) else "edge"
+    return np.pad(arr, pads, mode=mode)
+
+
+# ---------------------------------------------------------------- basics (latlib verbatim)
+def luma(rgb_u8: np.ndarray) -> np.ndarray:
+    a = rgb_u8.astype(np.float32)
+    return a[..., 0] * 0.299 + a[..., 1] * 0.587 + a[..., 2] * 0.114
+
+
+def resid(Y: np.ndarray) -> np.ndarray:
+    return Y - ndimage.median_filter(Y, size=3, mode="reflect")
+
+
+def n0_of(n: int) -> int:
+    return max(16, 16 * (n // 16))
+
+
+def x_in(n_full: int, start: int, length: int, model: bool = True) -> np.ndarray:
+    """generation-grid coordinate of output pixels start..start+length-1 of an axis of full length n_full."""
+    x = np.arange(start, start + length, dtype=np.float64)
+    if not model:
+        return x - start
+    s = n0_of(n_full) / float(n_full)
+    return (x + 0.5) * s - 0.5
+
+
+# ---------------------------------------------------------------- matched filters (latlib verbatim)
+def nyq_mf(r: np.ndarray, W_full: int, H_full: int, x0: int = 0, y0: int = 0, phi=(0.0, 0.0), model: bool = True):
+    """signed z per axis + quadrature magnitude, predicted Nyquist field of the renderer model."""
+    H, W = r.shape
+    res = {}
+    for ax, (n_full, start, prof, ph0) in {"x": (W_full, x0, r.sum(axis=0, dtype=np.float64), phi[0]),
+                                            "y": (H_full, y0, r.sum(axis=1, dtype=np.float64), phi[1])}.items():
+        xi = x_in(n_full, start, len(prof), model)
+        arg = np.pi * xi + ph0
+        sc, ss = float(prof @ np.cos(arg)), float(prof @ np.sin(arg))
+        nz = []
+        for e in CTRL_EPS:
+            a2 = np.pi * xi * (1.0 + e)
+            nz.append(((prof @ np.cos(a2)) ** 2 + (prof @ np.sin(a2)) ** 2) / 2.0)
+        noise = float(np.mean(nz)) + 1e-12
+        res[ax] = (sc / math.sqrt(noise), math.sqrt((sc * sc + ss * ss) / noise), math.degrees(math.atan2(-ss, sc)))
+    return res
+
+
+def template_coeffs(T: np.ndarray) -> np.ndarray:
+    """8x8 template -> 9x9 weighted Fourier coefficients on KSET x KSET (rows = l (y), cols = k (x)); DC removed."""
+    C8 = np.fft.fft2(T) / 64.0  # C8[l,k]: T(y,x) = sum C8[l,k] exp(2 pi i (l y + k x)/8)
+    C = np.zeros((9, 9), complex)
+    for a, l in enumerate(KSET):
+        for b, k in enumerate(KSET):
+            C[a, b] = C8[l % 8, k % 8] * KW[a] * KW[b]
+    C[4, 4] = 0.0
+    return C
+
+
+def tmpl_mf(r: np.ndarray, C: np.ndarray, W_full: int, H_full: int, x0: int = 0, y0: int = 0, model: bool = True):
+    """signed z of <r, P_ref> and phase-agnostic ratio; controls = frequency-scaled templates (x_in * (1+eps))."""
+    H, W = r.shape
+    xi = x_in(W_full, x0, W, model)
+    yi = x_in(H_full, y0, H, model)
+    scales = np.concatenate([[0.0], CTRL_EPS])
+    # U: W x (9*S) complex, V: H x (9*S)
+    U = np.exp(2j * np.pi * np.outer(xi, KSET)[:, None, :] * (1.0 + scales)[None, :, None] / 8.0).reshape(W, -1)
+    V = np.exp(2j * np.pi * np.outer(yi, KSET)[:, None, :] * (1.0 + scales)[None, :, None] / 8.0)  # H x S x 9
+    rr = r.astype(np.float64)
+    RU = rr @ U.real + 1j * (rr @ U.imag)  # H x (S*9)
+    RU = RU.reshape(H, len(scales), 9)
+    S_vals, A_vals = [], []
+    for s in range(len(scales)):
+        R = V[:, s, :].T @ RU[:, s, :]  # 9(l) x 9(k): sum_y v_l(y) sum_x r u_k(x)
+        S_vals.append(float(np.real(np.sum(C * R))))
+        A_vals.append(float(np.sum(np.abs(C) * np.abs(R))))
+    S_vals, A_vals = np.array(S_vals), np.array(A_vals)
+    noise = math.sqrt(np.mean(S_vals[1:] ** 2)) + 1e-12
+    return float(S_vals[0] / noise), float(A_vals[0] / (A_vals[1:].mean() + 1e-12))
+
+
+def _restricted(keep) -> np.ndarray:
+    """wf_r3 camguard.restricted: T_REF keeping only the listed (l, k) DFT terms, as 9x9 template coefficients."""
+    C8 = np.fft.fft2(np.array(T_REF))
+    M = np.zeros_like(C8)
+    for (l, k) in keep:
+        M[l % 8, k % 8] = C8[l % 8, k % 8]
+    return template_coeffs(np.real(np.fft.ifft2(M)))
+
+
+C_D4 = _restricted([(-2, 2), (2, -2)])      # the (1/4, -1/4) anti-diagonal pair
+
+
+# ---------------------------------------------------------------- decode / statistic
+def decode(src) -> Image.Image:
+    """Pixels as the evaluator and the v6 service decode an upload: JPEG/MPO DCT draft to a 2048 box (PIL picks the largest
+    scale s in 8/4/2/1 with s <= min(w // 2048, h // 2048), so files below 4096 px on a side decode at full size), EXIF
+    transpose, RGB. `src` = path or bytes."""
+    im = Image.open(io.BytesIO(src) if isinstance(src, (bytes, bytearray)) else src)
+    if im.format in ("JPEG", "MPO"):
+        im.draft("RGB", (DECODE_BOX, DECODE_BOX))
+    return ImageOps.exif_transpose(im).convert("RGB")
+
+
+def crop_z(img: Image.Image) -> tuple[list[float], list[float]]:
+    """Per-crop (nyq_min_img, d4_img) z over the 9 grid crops of the (padded) image, image coordinates of the padded frame."""
+    arr = np.asarray(img.convert("RGB") if img.mode != "RGB" else img)
+    H, W = arr.shape[:2]
+    if W < CROP or H < CROP:
+        arr = pad_to(arr, CROP)
+        H, W = arr.shape[:2]
+    nyq, d4 = [], []
+    for (x0, y0) in grid_boxes(W, H, CROP, N_CROPS):
+        r = resid(luma(arr[y0:y0 + CROP, x0:x0 + CROP])).astype(np.float32)
+        m = nyq_mf(r, W, H, x0, y0, phi=PHI0, model=True)
+        nyq.append(min(m["x"][0], m["y"][0]))
+        d4.append(tmpl_mf(r, C_D4, W, H, x0, y0)[0])
+    return nyq, d4
+
+
+def outside_gate(long_side: int, gate_min: int = 0) -> bool:
+    """True when the trace is not computed: long side > 2048, or (v2, _collab/prereg_gpt_round4_trace_v2.json) long side
+    < gate_min. gate_min = 0 is the v1 gate."""
+    return long_side > GATE_LONG_SIDE or long_side < int(gate_min)
+
+
+def trace_stat(img: Image.Image, force: bool = False, gate_min: int = 0) -> dict:
+    """{s, nyq_min_img_mean, d4_img_mean, long_side, gated}. gated=True: long side outside [gate_min, 2048] (v1: gate_min
+    = 0, only > 2048), the statistic is not computed (s = None) and the trace cannot fire; force=True computes it anyway
+    (diagnostics / reproduction tests only)."""
+    long_side = int(max(img.size))
+    gated = outside_gate(long_side, gate_min)
+    if gated and not force:
+        return {"s": None, "nyq_min_img_mean": None, "d4_img_mean": None, "long_side": long_side, "gated": True}
+    nyq, d4 = crop_z(img)
+    a, d = float(np.mean(nyq)), float(np.mean(d4))
+    return {"s": float(min(a / SCALE_NYQ, d / SCALE_D4)), "nyq_min_img_mean": a, "d4_img_mean": d,
+            "long_side": long_side, "gated": gated}
+
+
+def fires(img: Image.Image, t: float, gate_min: int = 0) -> bool:
+    """The renderer_trace basis: inside the gate and s > t (strict, one-sided). v2: gate_min = 1024."""
+    st = trace_stat(img, gate_min=gate_min)
+    return (not st["gated"]) and st["s"] is not None and st["s"] > float(t)
+
+
+def statistic_fingerprint() -> str:
+    """sha256[:16] of everything that defines the statistic and the gate (for AEYE_TRACE_JSON / reports)."""
+    spec = {"version": TRACE_VERSION, "scale_nyq": SCALE_NYQ, "scale_d4": SCALE_D4, "gate_long_side": GATE_LONG_SIDE,
+            "crop": CROP, "n_crops": N_CROPS, "decode_box": DECODE_BOX, "phi0": list(PHI0), "t_ref": [list(r) for r in T_REF],
+            "ctrl_eps": [float(e) for e in CTRL_EPS]}
+    return hashlib.sha256(json.dumps(spec, sort_keys=True).encode("utf-8")).hexdigest()[:16]
+
+
+def main(argv: list[str]) -> int:
+    import argparse
+    ap = argparse.ArgumentParser(description="renderer trace statistic of image files (decoded as the service decodes)")
+    ap.add_argument("images", nargs="+")
+    ap.add_argument("--t", type=float, default=None, help="threshold t*: also print whether the trace fires")
+    ap.add_argument("--force", action="store_true", help="compute above the gate too (diagnostics)")
+    ap.add_argument("--gate-min", type=int, default=0, help="v2 lower gate bound on the long side (0 = v1)")
+    a = ap.parse_args(argv)
+    for p in a.images:
+        st = trace_stat(decode(p), force=a.force, gate_min=a.gate_min)
+        if a.t is not None:
+            st["fires"] = (not st["gated"]) and st["s"] is not None and st["s"] > a.t
+        print(json.dumps({"path": p, **st}))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

schemas.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import BaseModel, Field
 
@@ -32,6 +32,13 @@ class AnalyzeResponse(BaseModel):
     # classifier + localiser fusion (fusion.py). Declared here because FastAPI drops every undeclared key.
     partial_edit_suspect: bool | None = None  # the fusion found a likely local edit the classifier alone did not call AI
     fusion: dict[str, Any] | None = None       # {enabled, score, threshold, hit, calibration, max_band} or {enabled, status}
+    # what the app prints (score_display.py): whole percent inside the final band's range - real 0-10,
+    # uncertain 40-60, ai 90-100 - and that band. Additive: every field above is unchanged.
+    display_score: int | None = Field(default=None, ge=0, le=100)
+    display_band: str | None = None           # real | uncertain | ai
+    # how overlay_b64 was drawn (AEYE_HEATMAP_STYLE): the app picks its caption and overlay opacity from this, so an
+    # app build and a Space deploy no longer have to land on the same day. Absent (older servers) = jet.
+    heatmap_style: Literal["jet", "spotlight"] | None = None
 
 
 class VersionResponse(BaseModel):

score_display.py

@@ -0,0 +1,100 @@
+"""The number the app shows: the pixel model's score mapped onto the calibrated verdict bands (owner decision 2026-09-28).
+
+"Real photos read 0-10 %, AI images 90-100 %, the ambiguous ones 40-60 %, and within each range the score still differs
+point by point." The raw model score cannot be shown as it is: RC1's real photos sit at 0.2-0.4 (0.39 median after a
+messenger re-share) while its UNCERTAIN edge t5 is 0.84 and its AI edge t1 is 0.97, so "AI일 확률 39%" on a photo the
+service calls REAL contradicted the verdict, and a fixed cut on the raw score would turn re-shared real photos red.
+Instead each calibrated band is stretched linearly onto its own display range:
+
+    s <  t5        -> REAL_MAX * s / t5                                 (0 .. 10)
+    t5 <= s < t1   -> UNC_MIN + (UNC_MAX - UNC_MIN) * (s - t5) / (t1 - t5)  (40 .. 60)
+    s >= t1        -> AI_MIN + (100 - AI_MIN) * (s - t1) / (1 - t1)     (90 .. 100)
+
+rounded half up to an integer, then CLAMPED into the range of the FINAL band the service answered with — the band a
+provenance record, a rescue, the real guard or the fusion decided, not only the pixel score's own band. So a REAL-band
+score the fusion lifted to UNCERTAIN ('local_edit') shows 40, a rescued AI shows at least 90, and an AI-declaring
+provenance record shows 100. Without calibrated bands (legacy v4 checkpoints, AEYE_BAND_* unset: t5 == t1 == thr) the
+decision threshold is the single line: s < thr -> 0..10, s >= thr -> 90..100, and 40..60 is used only when the final
+band itself is UNCERTAIN.
+
+On screen (owner 2026-09-29) the number is called "AI 판별 점수" in points (점, out of 100) - a score, not a probability - and
+the internal ranges are not shown to users; the fields and values here are unchanged by that naming decision.
+
+Pure and dependency-free so tools/probe_service.py and the tests can import it without loading a model. It is an
+additive display field: verdicts, bands, thresholds and bases are computed elsewhere and never read back from here.
+"""
+from __future__ import annotations
+
+import math
+
+# display ranges, in whole percent — change them here and nowhere else
+REAL_MAX = 10
+UNC_MIN = 40
+UNC_MAX = 60
+AI_MIN = 90
+
+BANDS = ("real", "uncertain", "ai")
+RANGES = {"real": (0, REAL_MAX), "uncertain": (UNC_MIN, UNC_MAX), "ai": (AI_MIN, 100)}
+
+# bases whose AI verdict rests on a record in the file, not on the pixels: shown as 100
+PROVENANCE_BASES = frozenset({"provenance"})
+# bases for which a verdict_band of UNCERTAIN is the answer the user gets (same rule as the app's lib/verdict.ts):
+# a provenance hit, a rescue or the real guard decided the binary verdict instead
+UNCERTAIN_BASES = frozenset({"model", "local_edit"})
+
+
+def final_band(verdict: str | None, verdict_band: str | None, basis: str | None) -> str:
+    """'real' | 'uncertain' | 'ai': the band the service's answer falls in after every override.
+
+    verdict_band is the pixel score's band (possibly lifted to UNCERTAIN by the fusion); an override (provenance,
+    PatchGuard/SigLIP rescue, real guard) decides through the binary verdict and wins over it."""
+    if str(verdict_band or "").upper() == "UNCERTAIN" and (basis or "model") in UNCERTAIN_BASES:
+        return "uncertain"
+    return "ai" if str(verdict or "").upper() == "AI" else "real"
+
+
+def _unit(x: float) -> float:
+    return min(1.0, max(0.0, x))
+
+
+def mapped_score(model_score: float, t5: float | None, t1: float | None, thr: float | None) -> float:
+    """The unrounded, unclamped piecewise-linear display value (0..100) of a pixel score."""
+    s = _unit(float(model_score))
+    if t5 is not None and t1 is not None and 0.0 < t5 < t1 < 1.0:
+        if s < t5:
+            return REAL_MAX * s / t5
+        if s < t1:
+            return UNC_MIN + (UNC_MAX - UNC_MIN) * (s - t5) / (t1 - t5)
+        return AI_MIN + (100 - AI_MIN) * (s - t1) / (1.0 - t1)
+    # no uncertain band: the decision threshold is the only line (t1 == thr whenever bands are unset)
+    line = thr if thr is not None else t1
+    if line is None or not 0.0 < line < 1.0:
+        return 100.0 * s
+    if s < line:
+        return REAL_MAX * s / line
+    return AI_MIN + (100 - AI_MIN) * (s - line) / (1.0 - line)
+
+
+def display_score(model_score: float, band: str, basis: str | None, t5: float | None, t1: float | None,
+                  thr: float | None, filename_only: bool = False) -> int:
+    """Whole-percent display score (0..100) that always lies inside `band`'s display range.
+
+    model_score: the pixel model's own P(AI) (the response's `model_score`, before any override).
+    band:        the final band ('real' | 'uncertain' | 'ai', case-insensitive; see final_band()).
+    basis:       the response's `basis`; an AI verdict resting on provenance shows 100.
+    t5, t1:      the band edges the service used (`band_thresholds`); thr: the decision threshold (`threshold`).
+    filename_only: the provenance evidence is only a generator-export filename pattern (weak): the AI verdict stands but
+                   the number is the pixel score mapped into the AI range (so at least AI_MIN), not 100."""
+    key = str(band).lower()
+    if key not in RANGES:
+        raise ValueError(f"unknown band {band!r}; expected one of {BANDS}")
+    lo, hi = RANGES[key]
+    if key == "ai" and basis in PROVENANCE_BASES and not filename_only:
+        return 100
+    try:
+        raw = mapped_score(model_score, t5, t1, thr)
+    except (TypeError, ValueError):
+        raw = float("nan")
+    if not math.isfinite(raw):
+        return lo
+    return int(min(hi, max(lo, math.floor(raw + 0.5))))

tests/fixtures/display_regression_golden.json

@@ -0,0 +1,505 @@
+{
+ "note": "analyze() of main_hybrid.py at e8463904 (before display_score), RC1 pair, CPU, 2 threads",
+ "rows": [
+  {
+   "tag": "real_galaxy",
+   "path": "data_v7/owner_phone_s20/s20_camera_cal/20180716_155445.jpg",
+   "filename": "20180716_155445.jpg",
+   "strip": false,
+   "out": {
+    "score": 0.19636252522468567,
+    "verdict": "REAL",
+    "verdict_band": "REAL",
+    "band_thresholds": {
+     "t5": 0.842605,
+     "t1": 0.973393
+    },
+    "heatmap_b64": "sha256:10591806514ed3ecc015cee6455137a87eab51c904e7f7409c1a3eb3f1a1f764",
+    "overlay_b64": "sha256:10591806514ed3ecc015cee6455137a87eab51c904e7f7409c1a3eb3f1a1f764",
+    "model_version": "best(v6)+best",
+    "structure_score": 0.19636252522468567,
+    "context_score": 0.19636252522468567,
+    "detail_score": 0.19636252522468567,
+    "threshold": 0.973393,
+    "reason": "model 49 verdict - real, heatmap suppressed",
+    "source": "model",
+    "basis": "model",
+    "model_score": 0.19636252522468567,
+    "model_verdict": "REAL",
+    "taxonomy": "REAL",
+    "provenance_status": "none",
+    "provenance_class": null,
+    "provenance": {
+     "signals": [],
+     "details": {
+      "regions": [
+       "APP1/Exif"
+      ],
+      "matched": {},
+      "c2pa": {
+       "present": false,
+       "class": null,
+       "markers": [],
+       "generator_hints": [],
+       "capture": false,
+       "status": "unverified"
+      },
+      "format": "JPEG",
+      "exif": {
+       "Make": "samsung",
+       "Model": "SM-J510L",
+       "Software": "J510LKLU1APE2"
+      }
+     }
+    },
+    "ensemble": {
+     "model49_score": 0.19636252522468567,
+     "siglip53_score": 0.0,
+     "patchguard_score": 0.4258074164390564,
+     "patch_peak": 0.2928650975227356,
+     "rescue_threshold": 0.72
+    },
+    "partial_edit_suspect": false,
+    "fusion": {
+     "enabled": true,
+     "score": -2.2946649981325047,
+     "threshold": 2.3288784941598424,
+     "hit": false,
+     "calibration": "traffic",
+     "max_band": "UNCERTAIN"
+    }
+   }
+  },
+  {
+   "tag": "real_galaxy_filename_hint",
+   "path": "data_v7/owner_phone_s20/s20_camera_cal/20180716_155445.jpg",
+   "filename": "ChatGPT Image 2026.jpg",
+   "strip": false,
+   "out": {
+    "score": 0.99,
+    "verdict": "AI",
+    "verdict_band": "REAL",
+    "band_thresholds": {
+     "t5": 0.842605,
+     "t1": 0.973393
+    },
+    "heatmap_b64": "sha256:4f4e06c7122c7b17e86b04a5df4eebed1297496f6fd2e8219db5253a04172765",
+    "overlay_b64": "sha256:54cc92969a310043e5de6919b040b2e397ed4bd27cbd2027ed9c0a3a2439c1fd",
+    "model_version": "best(v6)+best+provenance",
+    "structure_score": 0.21456266939640045,
+    "context_score": 0.99,
+    "detail_score": 0.2928650975227356,
+    "threshold": 0.973393,
+    "reason": "AI provenance found (Filename:AI-export, OpenAI)",
+    "source": "provenance",
+    "basis": "provenance",
+    "model_score": 0.19636252522468567,
+    "model_verdict": "REAL",
+    "taxonomy": "AI",
+    "provenance_status": "unverified",
+    "provenance_class": null,
+    "provenance": {
+     "signals": [
+      "Filename:AI-export",
+      "OpenAI"
+     ],
+     "details": {
+      "regions": [
+       "APP1/Exif"
+      ],
+      "matched": {},
+      "c2pa": {
+       "present": false,
+       "class": null,
+       "markers": [],
+       "generator_hints": [],
+       "capture": false,
+       "status": "unverified"
+      },
+      "format": "JPEG",
+      "exif": {
+       "Make": "samsung",
+       "Model": "SM-J510L",
+       "Software": "J510LKLU1APE2"
+      },
+      "filename_hint": "ChatGPT Image 2026.jpg"
+     }
+    },
+    "ensemble": {
+     "model49_score": 0.19636252522468567,
+     "siglip53_score": 0.0,
+     "patchguard_score": 0.4258074164390564,
+     "patch_peak": 0.2928650975227356,
+     "rescue_threshold": 0.72
+    },
+    "partial_edit_suspect": false,
+    "fusion": {
+     "enabled": true,
+     "score": -2.2946649981325047,
+     "threshold": 2.3288784941598424,
+     "hit": false,
+     "calibration": "traffic",
+     "max_band": "UNCERTAIN"
+    }
+   }
+  },
+  {
+   "tag": "gpt25_c2pa",
+   "path": "data_v7/user_gpt25/new_full/new_full_001_greenhouse_bench.png",
+   "filename": "img_0001.png",
+   "strip": false,
+   "out": {
+    "score": 0.99,
+    "verdict": "AI",
+    "verdict_band": "REAL",
+    "band_thresholds": {
+     "t5": 0.842605,
+     "t1": 0.973393
+    },
+    "heatmap_b64": "sha256:a6a0fb1d3d1bf220254862ff8867c7ac63643c8d580d91fa5f39a268b5008d8f",
+    "overlay_b64": "sha256:626f3e178875cad06aff8ffcca95891a8af9a4454162406789b7cd4cfddef051",
+    "model_version": "best(v6)+best+provenance",
+    "structure_score": 0.3269358277320862,
+    "context_score": 0.99,
+    "detail_score": 0.41130611300468445,
+    "threshold": 0.973393,
+    "reason": "AI provenance found (AIGC-generic, C2PA:AI, OpenAI)",
+    "source": "provenance",
+    "basis": "provenance",
+    "model_score": 0.2907660901546478,
+    "model_verdict": "REAL",
+    "taxonomy": "AI",
+    "provenance_status": "unverified",
+    "provenance_class": "ai",
+    "provenance": {
+     "signals": [
+      "AIGC-generic",
+      "C2PA:AI",
+      "OpenAI"
+     ],
+     "details": {
+      "regions": [
+       "IHDR",
+       "caBX"
+      ],
+      "matched": {
+       "OpenAI": [
+        "openai",
+        "gpt-image",
+        "chatgpt"
+       ],
+       "AIGC-generic": [
+        "trainedalgorithmicmedia"
+       ]
+      },
+      "c2pa": {
+       "present": true,
+       "class": "ai",
+       "markers": [
+        "trainedalgorithmicmedia"
+       ],
+       "generator_hints": [
+        "chatgpt",
+        "gpt-image",
+        "openai"
+       ],
+       "capture": false,
+       "status": "unverified"
+      },
+      "format": "PNG"
+     }
+    },
+    "ensemble": {
+     "model49_score": 0.2907660901546478,
+     "siglip53_score": 0.0,
+     "patchguard_score": 0.5787836909294128,
+     "patch_peak": 0.41130611300468445,
+     "rescue_threshold": 0.72
+    },
+    "partial_edit_suspect": false,
+    "fusion": {
+     "enabled": true,
+     "score": -1.6157930262798303,
+     "threshold": 2.3288784941598424,
+     "hit": false,
+     "calibration": "traffic",
+     "max_band": "UNCERTAIN"
+    }
+   }
+  },
+  {
+   "tag": "receipt_c2pa",
+   "path": "D:/hf_cache/hub/datasets--Scam-AI--gpt4o-receipt/snapshots/ba43bd74c4a3ab69df803941eb0a2d52a8e4aac0/receipt_0001.png",
+   "filename": "img_0002.png",
+   "strip": false,
+   "out": {
+    "score": 0.9928823709487915,
+    "verdict": "AI",
+    "verdict_band": "AI",
+    "band_thresholds": {
+     "t5": 0.842605,
+     "t1": 0.973393
+    },
+    "heatmap_b64": "sha256:385b3770270944c91a470bfaa2844f5821ffa3d49478126cf46ee8738baa597f",
+    "overlay_b64": "sha256:58ab96ebf41925b440204a2427d5acc1b6b83a7b687301d684680803b1d14a29",
+    "model_version": "best(v6)+best+provenance",
+    "structure_score": 0.9992738962173462,
+    "context_score": 0.9928823709487915,
+    "detail_score": 0.999677300453186,
+    "threshold": 0.973393,
+    "reason": "AI provenance found (AIGC-generic, C2PA:AI, OpenAI); pixel model also positive",
+    "source": "provenance",
+    "basis": "provenance",
+    "model_score": 0.9928823709487915,
+    "model_verdict": "AI",
+    "taxonomy": "AI",
+    "provenance_status": "unverified",
+    "provenance_class": "ai",
+    "provenance": {
+     "signals": [
+      "AIGC-generic",
+      "C2PA:AI",
+      "OpenAI"
+     ],
+     "details": {
+      "regions": [
+       "IHDR",
+       "caBX"
+      ],
+      "matched": {
+       "OpenAI": [
+        "openai",
+        "chatgpt"
+       ],
+       "AIGC-generic": [
+        "trainedalgorithmicmedia"
+       ]
+      },
+      "c2pa": {
+       "present": true,
+       "class": "ai",
+       "markers": [
+        "trainedalgorithmicmedia"
+       ],
+       "generator_hints": [
+        "chatgpt",
+        "openai"
+       ],
+       "capture": false,
+       "status": "unverified"
+      },
+      "format": "PNG"
+     }
+    },
+    "ensemble": {
+     "model49_score": 0.9928823709487915,
+     "siglip53_score": 0.0,
+     "patchguard_score": 0.9748627543449402,
+     "patch_peak": 0.999677300453186,
+     "rescue_threshold": 0.72
+    },
+    "partial_edit_suspect": false,
+    "fusion": {
+     "enabled": true,
+     "score": 4.492686495995523,
+     "threshold": 2.3288784941598424,
+     "hit": true,
+     "calibration": "traffic",
+     "max_band": "UNCERTAIN"
+    }
+   }
+  },
+  {
+   "tag": "receipt_pixels_only",
+   "path": "D:/hf_cache/hub/datasets--Scam-AI--gpt4o-receipt/snapshots/ba43bd74c4a3ab69df803941eb0a2d52a8e4aac0/receipt_0001.png",
+   "filename": "img_0003.png",
+   "strip": true,
+   "out": {
+    "score": 0.9928823709487915,
+    "verdict": "AI",
+    "verdict_band": "AI",
+    "band_thresholds": {
+     "t5": 0.842605,
+     "t1": 0.973393
+    },
+    "heatmap_b64": "sha256:385b3770270944c91a470bfaa2844f5821ffa3d49478126cf46ee8738baa597f",
+    "overlay_b64": "sha256:58ab96ebf41925b440204a2427d5acc1b6b83a7b687301d684680803b1d14a29",
+    "model_version": "best(v6)+best",
+    "structure_score": 0.9992738962173462,
+    "context_score": 0.9928823709487915,
+    "detail_score": 0.999677300453186,
+    "threshold": 0.973393,
+    "reason": "model 49 verdict",
+    "source": "model",
+    "basis": "model",
+    "model_score": 0.9928823709487915,
+    "model_verdict": "AI",
+    "taxonomy": "AI",
+    "provenance_status": "none",
+    "provenance_class": null,
+    "provenance": {
+     "signals": [],
+     "details": {
+      "regions": [
+       "IHDR"
+      ],
+      "matched": {},
+      "c2pa": {
+       "present": false,
+       "class": null,
+       "markers": [],
+       "generator_hints": [],
+       "capture": false,
+       "status": "unverified"
+      },
+      "format": "PNG"
+     }
+    },
+    "ensemble": {
+     "model49_score": 0.9928823709487915,
+     "siglip53_score": 0.0,
+     "patchguard_score": 0.9748627543449402,
+     "patch_peak": 0.999677300453186,
+     "rescue_threshold": 0.72
+    },
+    "partial_edit_suspect": false,
+    "fusion": {
+     "enabled": true,
+     "score": 4.492686495995523,
+     "threshold": 2.3288784941598424,
+     "hit": true,
+     "calibration": "traffic",
+     "max_band": "UNCERTAIN"
+    }
+   }
+  },
+  {
+   "tag": "cord_uncertain",
+   "path": "data_v7/probe/cord_v2/test_0084.png",
+   "filename": "img_0004.png",
+   "strip": false,
+   "out": {
+    "score": 0.8605962991714478,
+    "verdict": "REAL",
+    "verdict_band": "UNCERTAIN",
+    "band_thresholds": {
+     "t5": 0.842605,
+     "t1": 0.973393
+    },
+    "heatmap_b64": "sha256:657d71db8b8a9a2faf13fc0dee82abddfa588efb320923dc8a50f83b4e467b10",
+    "overlay_b64": "sha256:657d71db8b8a9a2faf13fc0dee82abddfa588efb320923dc8a50f83b4e467b10",
+    "model_version": "best(v6)+best",
+    "structure_score": 0.8605962991714478,
+    "context_score": 0.8605962991714478,
+    "detail_score": 0.8605962991714478,
+    "threshold": 0.973393,
+    "reason": "model 49 verdict - real, heatmap suppressed",
+    "source": "model",
+    "basis": "model",
+    "model_score": 0.8605962991714478,
+    "model_verdict": "REAL",
+    "taxonomy": "REAL",
+    "provenance_status": "none",
+    "provenance_class": null,
+    "provenance": {
+     "signals": [],
+     "details": {
+      "regions": [
+       "IHDR"
+      ],
+      "matched": {},
+      "c2pa": {
+       "present": false,
+       "class": null,
+       "markers": [],
+       "generator_hints": [],
+       "capture": false,
+       "status": "unverified"
+      },
+      "format": "PNG"
+     }
+    },
+    "ensemble": {
+     "model49_score": 0.8605962991714478,
+     "siglip53_score": 0.0,
+     "patchguard_score": 0.8612217307090759,
+     "patch_peak": 0.9601179957389832,
+     "rescue_threshold": 0.72
+    },
+    "partial_edit_suspect": false,
+    "fusion": {
+     "enabled": true,
+     "score": 5.078632616781172,
+     "threshold": 2.3288784941598424,
+     "hit": true,
+     "calibration": "traffic",
+     "max_band": "UNCERTAIN"
+    }
+   }
+  },
+  {
+   "tag": "cord_local_edit",
+   "path": "data_v7/probe/cord_v2/test_0096.png",
+   "filename": "img_0005.png",
+   "strip": false,
+   "out": {
+    "score": 0.4749445915222168,
+    "verdict": "REAL",
+    "verdict_band": "UNCERTAIN",
+    "band_thresholds": {
+     "t5": 0.842605,
+     "t1": 0.973393
+    },
+    "heatmap_b64": "sha256:1694e0113b8422c598309eed858384f9d3c279b5b1f92de0f7afbe4d11ea7d68",
+    "overlay_b64": "sha256:d1e13529346d881a53f4ba47728a486896c7fed4a2ddab4a0afe33701f40e691",
+    "model_version": "best(v6)+best",
+    "structure_score": 0.898382306098938,
+    "context_score": 0.4749445915222168,
+    "detail_score": 0.9623211622238159,
+    "threshold": 0.973393,
+    "reason": "classifier + localiser fusion: possible local edit",
+    "source": "local_edit",
+    "basis": "local_edit",
+    "model_score": 0.4749445915222168,
+    "model_verdict": "REAL",
+    "taxonomy": "EDITED",
+    "provenance_status": "none",
+    "provenance_class": null,
+    "provenance": {
+     "signals": [],
+     "details": {
+      "regions": [
+       "IHDR"
+      ],
+      "matched": {},
+      "c2pa": {
+       "present": false,
+       "class": null,
+       "markers": [],
+       "generator_hints": [],
+       "capture": false,
+       "status": "unverified"
+      },
+      "format": "PNG"
+     }
+    },
+    "ensemble": {
+     "model49_score": 0.4749445915222168,
+     "siglip53_score": 0.0,
+     "patchguard_score": 0.8260679841041565,
+     "patch_peak": 0.9623211622238159,
+     "rescue_threshold": 0.72
+    },
+    "partial_edit_suspect": true,
+    "fusion": {
+     "enabled": true,
+     "score": 2.743159158373138,
+     "threshold": 2.3288784941598424,
+     "hit": true,
+     "calibration": "traffic",
+     "max_band": "UNCERTAIN"
+    }
+   }
+  }
+ ]
+}

tests/test_display_score.py

@@ -0,0 +1,364 @@
+"""display_score / display_band (score_display.py): the owner's 0-10 / 40-60 / 90-100 display (2026-09-28).
+
+Fast tests pin the mapping (edges, monotonicity, clamping for every basis x band, the legacy no-band path, the schema).
+The slow test replays analyze() on real images with the RC1 pair and proves every pre-existing response field is
+bit-identical to the output recorded from main_hybrid.py BEFORE the display fields existed
+(fixtures/display_regression_golden.json, recorded at e8463904 on CPU with 2 torch threads). It runs with
+AEYE_HEATMAP_STYLE=jet (the RC1 overlay); a second slow test proves the spotlight changes overlay_b64 and nothing else.
+"""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import io
+import json
+import math
+import os
+import sys
+
+import pytest
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+REPO = os.path.dirname(ROOT)
+sys.path.insert(0, ROOT)
+
+import score_display as sd  # noqa: E402
+from score_display import AI_MIN, REAL_MAX, UNC_MAX, UNC_MIN, display_score, final_band, mapped_score  # noqa: E402
+
+# RC1 (Dockerfile): traffic-calibrated bands bound to 69_v23f_effort_v7.2; the decision threshold IS t1
+T5, T1 = 0.842605, 0.973393
+LEGACY_THR = 0.4625                     # best49-era default: no bands, t5 == t1 == thr
+BASES = ("model", "local_edit", "provenance", "patchguard_rescue", "siglip_rescue", "real_guard")
+RANGE = {"real": (0, REAL_MAX), "uncertain": (UNC_MIN, UNC_MAX), "ai": (AI_MIN, 100)}
+
+
+def _below(x: float) -> float:
+    return math.nextafter(x, 0.0)
+
+
+def _grid(n: int = 4001) -> list[float]:
+    pts = {i / (n - 1) for i in range(n)}
+    for e in (T5, T1, LEGACY_THR):
+        pts.update({e, _below(e), math.nextafter(e, 1.0), e - 1e-4, e + 1e-4})
+    return sorted(p for p in pts if 0.0 <= p <= 1.0)
+
+
+def _pixel_band(s: float, t5: float, t1: float) -> str:
+    import main_hybrid as mh
+    return mh.band_for(s, t5, t1).lower()
+
+
+# --------------------------------------------------------------------------- the three ranges and their edges
+def test_range_constants_are_the_owner_decision():
+    assert (REAL_MAX, UNC_MIN, UNC_MAX, AI_MIN) == (10, 40, 60, 90)
+    assert sd.RANGES == RANGE
+
+
+@pytest.mark.parametrize("s, band, want", [
+    (0.0, "real", 0),
+    (T5 / 2, "real", 5),
+    (_below(T5), "real", 10),          # just below t5: top of REAL, never 40
+    (T5, "uncertain", 40),             # t5 exactly: bottom of UNCERTAIN
+    (math.nextafter(T5, 1.0), "uncertain", 40),
+    ((T5 + T1) / 2, "uncertain", 50),
+    (_below(T1), "uncertain", 60),     # just below t1: top of UNCERTAIN, never 90
+    (T1, "ai", 90),                    # t1 exactly: bottom of AI
+    (math.nextafter(T1, 1.0), "ai", 90),
+    ((T1 + 1.0) / 2, "ai", 95),
+    (1.0, "ai", 100),
+])
+def test_edges_of_the_three_ranges(s, band, want):
+    assert _pixel_band(s, T5, T1) == band
+    assert display_score(s, band, "model", T5, T1, T1) == want
+
+
+def test_mapped_score_is_continuous_inside_each_band_and_jumps_only_at_the_edges():
+    assert mapped_score(_below(T5), T5, T1, T1) == pytest.approx(REAL_MAX, abs=1e-9)
+    assert mapped_score(T5, T5, T1, T1) == pytest.approx(UNC_MIN)
+    assert mapped_score(_below(T1), T5, T1, T1) == pytest.approx(UNC_MAX, abs=1e-9)
+    assert mapped_score(T1, T5, T1, T1) == pytest.approx(AI_MIN)
+    assert mapped_score(1.0, T5, T1, T1) == pytest.approx(100)
+    assert mapped_score(-0.5, T5, T1, T1) == 0 and mapped_score(1.5, T5, T1, T1) == 100   # out-of-range input
+
+
+def test_the_galaxy_median_real_photo_reads_low():
+    # measured RC1 medians on 700 owner Galaxy photos: 0.24 originals, 0.39 after a messenger re-share
+    assert display_score(0.24, "real", "model", T5, T1, T1) == 3
+    assert display_score(0.39, "real", "model", T5, T1, T1) == 5
+
+
+# --------------------------------------------------------------------------- monotonic, and rounding never crosses an edge
+@pytest.mark.parametrize("t5, t1, thr", [(T5, T1, T1), (LEGACY_THR, LEGACY_THR, LEGACY_THR), (None, None, LEGACY_THR)])
+def test_monotonic_non_decreasing_and_consistent_with_the_service_band(t5, t1, thr):
+    e5, e1 = (t5, t1) if t5 is not None else (thr, thr)
+    prev = {}
+    for s in _grid():
+        band = _pixel_band(s, e5, e1)
+        v = display_score(s, band, "model", t5, t1, thr)
+        lo, hi = RANGE[band]
+        assert lo <= v <= hi, (s, band, v)
+        # the pixel score's own band never needs the clamp: rounding alone stays inside the range
+        assert v == math.floor(mapped_score(s, t5, t1, thr) + 0.5), (s, band, v)
+        if band in prev:
+            assert v >= prev[band], (s, band, v, prev[band])
+        prev[band] = v
+    # and across bands the display order follows the score order
+    assert display_score(0.0, "real", "model", t5, t1, thr) <= display_score(1.0, "ai", "model", t5, t1, thr)
+
+
+def test_one_point_steps_inside_each_band():
+    seen = {b: set() for b in RANGE}
+    for s in _grid(20001):
+        b = _pixel_band(s, T5, T1)
+        seen[b].add(display_score(s, b, "model", T5, T1, T1))
+    assert seen == {b: set(range(lo, hi + 1)) for b, (lo, hi) in RANGE.items()}
+
+
+# --------------------------------------------------------------------------- clamping for every basis x band
+@pytest.mark.parametrize("basis", BASES)
+@pytest.mark.parametrize("band", list(RANGE))
+@pytest.mark.parametrize("t5, t1, thr", [(T5, T1, T1), (None, None, LEGACY_THR), (LEGACY_THR, LEGACY_THR, LEGACY_THR)])
+def test_every_basis_band_combination_lands_in_its_range(basis, band, t5, t1, thr):
+    lo, hi = RANGE[band]
+    for s in _grid(401):
+        v = display_score(s, band, basis, t5, t1, thr)
+        assert isinstance(v, int) and lo <= v <= hi, (basis, band, s, v)
+        if basis == "provenance" and band == "ai":
+            assert v == 100
+
+
+def test_named_override_cases():
+    # the fusion lifted a REAL-band photo to UNCERTAIN ('local_edit'): bottom of the uncertain range
+    assert display_score(0.47, "uncertain", "local_edit", T5, T1, T1) == 40
+    # an AI-declaring provenance record: 100 whatever the pixels say
+    assert display_score(0.19, "ai", "provenance", T5, T1, T1) == 100
+    assert display_score(0.90, "ai", "provenance", T5, T1, T1) == 100
+    # a rescue that called AI on a REAL-band pixel score: bottom of AI
+    assert display_score(0.30, "ai", "patchguard_rescue", LEGACY_THR, LEGACY_THR, LEGACY_THR) == 90
+    # the real guard that called REAL on an AI-band pixel score: top of REAL
+    assert display_score(0.55, "real", "real_guard", LEGACY_THR, LEGACY_THR, LEGACY_THR) == 10
+    # an UNCERTAIN-band pixel score a provenance marker decided: AI 100
+    assert display_score(0.90, final_band("AI", "UNCERTAIN", "provenance"), "provenance", T5, T1, T1) == 100
+
+
+@pytest.mark.parametrize("verdict, verdict_band, basis, want", [
+    ("REAL", "REAL", "model", "real"),
+    ("REAL", "UNCERTAIN", "model", "uncertain"),
+    ("AI", "AI", "model", "ai"),
+    ("REAL", "UNCERTAIN", "local_edit", "uncertain"),
+    ("AI", "REAL", "provenance", "ai"),
+    ("AI", "UNCERTAIN", "provenance", "ai"),
+    ("AI", "AI", "provenance", "ai"),
+    ("AI", "REAL", "patchguard_rescue", "ai"),
+    ("AI", "UNCERTAIN", "siglip_rescue", "ai"),
+    ("REAL", "AI", "real_guard", "real"),
+    ("REAL", "UNCERTAIN", "real_guard", "real"),
+    ("REAL", None, None, "real"),
+    ("AI", None, None, "ai"),
+])
+def test_final_band_follows_the_override_rules(verdict, verdict_band, basis, want):
+    assert final_band(verdict, verdict_band, basis) == want
+
+
+def test_band_names_are_case_insensitive_and_unknown_bands_fail():
+    assert display_score(0.5, "REAL", "model", T5, T1, T1) == display_score(0.5, "real", "model", T5, T1, T1)
+    with pytest.raises(ValueError):
+        display_score(0.5, "maybe", "model", T5, T1, T1)
+    assert display_score(float("nan"), "uncertain", "model", T5, T1, T1) == UNC_MIN
+
+
+# --------------------------------------------------------------------------- legacy: no calibrated bands
+def test_legacy_single_line_at_the_decision_threshold():
+    for t5, t1 in ((None, None), (LEGACY_THR, LEGACY_THR)):
+        assert display_score(0.0, "real", "model", t5, t1, LEGACY_THR) == 0
+        assert display_score(_below(LEGACY_THR), "real", "model", t5, t1, LEGACY_THR) == 10
+        assert display_score(LEGACY_THR, "ai", "model", t5, t1, LEGACY_THR) == 90
+        assert display_score(1.0, "ai", "model", t5, t1, LEGACY_THR) == 100
+        assert mapped_score(LEGACY_THR / 2, t5, t1, LEGACY_THR) == pytest.approx(5)
+        # the uncertain range only through the final band (a fusion lift), then clamped into 40..60
+        assert display_score(0.1, "uncertain", "local_edit", t5, t1, LEGACY_THR) == 40
+        assert display_score(0.9, "uncertain", "model", t5, t1, LEGACY_THR) == 60
+
+
+# --------------------------------------------------------------------------- the fields reach the client
+def test_schema_declares_the_display_fields():
+    from schemas import AnalyzeResponse
+    base = {"score": 0.1, "verdict": "REAL", "heatmap_b64": "", "overlay_b64": "", "model_version": "x", "elapsed_ms": 1}
+    assert AnalyzeResponse(**base).display_score is None               # legacy dicts still validate
+    r = AnalyzeResponse(**base, display_score=7, display_band="real")
+    assert (r.display_score, r.display_band) == (7, "real")
+    with pytest.raises(Exception):
+        AnalyzeResponse(**base, display_score=101, display_band="ai")
+
+
+def test_display_fields_survive_the_api_response():
+    import httpx
+    from PIL import Image
+    import guards
+    import main_hybrid as mh
+
+    class Stub:
+        model_version = "stub"
+
+        def analyze(self, raw: bytes, filename: str | None = None) -> dict:
+            return {"score": 0.3, "verdict": "REAL", "heatmap_b64": "", "overlay_b64": "", "model_version": "stub",
+                    "elapsed_ms": 1, "threshold": T1, "source": "model", "basis": "model", "model_score": 0.3,
+                    "verdict_band": "REAL", "band_thresholds": {"t5": T5, "t1": T1},
+                    "display_score": display_score(0.3, "real", "model", T5, T1, T1), "display_band": "real"}
+
+    buf = io.BytesIO()
+    Image.new("RGB", (64, 64), (90, 120, 150)).save(buf, "PNG")
+    old = (guards.SETTINGS, mh._detector)
+    guards.configure(guards.Settings(anon_per_minute=1000, anon_per_day=100000, max_concurrency=1, max_queue=4,
+                                     queue_timeout_s=1.0, trusted_proxy_hops=1))
+    mh._detector = Stub()
+
+    async def go():
+        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=mh.app), base_url="http://test") as c:
+            return await c.post("/api/analyze", files={"image": ("x.png", buf.getvalue(), "image/png")})
+    try:
+        body = asyncio.run(go()).json()
+    finally:
+        guards.configure(old[0])
+        mh._detector = old[1]
+    assert body["display_score"] == 4 and body["display_band"] == "real"
+
+
+# --------------------------------------------------------------------------- regression: pre-existing fields unchanged
+GOLDEN = os.path.join(os.path.dirname(os.path.abspath(__file__)), "fixtures", "display_regression_golden.json")
+EXP = os.path.join(REPO, "4_model_training", "experiments")
+CHAMPION = os.path.join(EXP, "69_v23f_effort_v7.2", "checkpoints", "best.pt")
+LOC70 = os.path.join(EXP, "70_v24_dense_v7loc_v7.2", "checkpoints", "best.pt")
+DISPLAY_KEYS = {"display_score", "display_band", "heatmap_style"}      # added after the golden was recorded
+
+
+def _canon(out: dict) -> dict:
+    """What the golden stores: every key but the wall clock, image payloads as digests."""
+    c = {}
+    for k, v in out.items():
+        if k == "elapsed_ms":
+            continue
+        c[k] = "sha256:" + hashlib.sha256(v.encode("ascii")).hexdigest() if k.endswith("_b64") else v
+    return c
+
+
+def _load(path: str, strip: bool) -> bytes:
+    raw = open(os.path.join(REPO, path), "rb").read()
+    if not strip:
+        return raw
+    from PIL import Image
+    buf = io.BytesIO()
+    Image.open(io.BytesIO(raw)).save(buf, format="PNG")      # lossless: same pixels, no metadata
+    return buf.getvalue()
+
+
+@pytest.fixture(scope="module")
+def rc1_detector():
+    missing = [p for p in (CHAMPION, LOC70, GOLDEN) if not os.path.exists(p)]
+    if missing:
+        pytest.skip(f"not on this machine: {missing[:2]}")
+    import torch
+    import main_hybrid as mh
+    threads = torch.get_num_threads()
+    torch.set_num_threads(2)                                  # as recorded (and as AEYE_TORCH_THREADS in production)
+    mp = pytest.MonkeyPatch()
+    for name, value in (("VERDICT_PATH", CHAMPION), ("HEATMAP_PATH", LOC70), ("DEVICE", "cpu"), ("FUSION_MODE", "on"),
+                        ("BAND_T5", T5), ("BAND_T1", T1), ("BANDS_FOR", "3509c0e7b189bda5"),
+                        ("HEATMAP_STYLE", "jet")):    # the golden overlays are RC1's jet overlays
+        mp.setattr(mh, name, value)
+    try:
+        yield mh.HybridDetector()
+    finally:
+        mp.undo()
+        torch.set_num_threads(threads)
+
+
+@pytest.mark.slow
+def test_every_pre_existing_field_is_bit_identical(rc1_detector):
+    golden = json.load(open(GOLDEN, encoding="utf-8"))["rows"]
+    checked, bases = 0, set()
+    for row in golden:
+        if not os.path.exists(os.path.join(REPO, row["path"])):
+            continue
+        out = rc1_detector.analyze(_load(row["path"], row["strip"]), row["filename"])
+        assert set(out) == set(row["out"]) | {"elapsed_ms"} | DISPLAY_KEYS, row["tag"]
+        before = row["out"]
+        after = {k: v for k, v in _canon(out).items() if k not in DISPLAY_KEYS}
+        assert json.dumps(after, sort_keys=True) == json.dumps(before, sort_keys=True), row["tag"]
+        band = final_band(out["verdict"], out["verdict_band"], out["basis"])
+        assert out["display_band"] == band
+        lo, hi = RANGE[band]
+        assert isinstance(out["display_score"], int) and lo <= out["display_score"] <= hi, row["tag"]
+        # filename-only provenance (a generator-export name, no C2PA): the AI verdict stands, the number is not 100
+        import provenance_gate
+        fn_sig = set(provenance_gate.check_filename(row["filename"]))
+        sigs = set((out.get("provenance") or {}).get("signals") or [])
+        c2pa_present = bool((((out.get("provenance") or {}).get("details") or {}).get("c2pa") or {}).get("present"))
+        filename_only = bool(fn_sig) and not c2pa_present and sigs <= fn_sig
+        assert out["display_score"] == display_score(out["model_score"], band, out["basis"],
+                                                     out["band_thresholds"]["t5"], out["band_thresholds"]["t1"],
+                                                     out["threshold"], filename_only=filename_only)
+        checked += 1
+        bases.add((out["basis"], band))
+    if checked == 0:
+        pytest.skip("no golden fixture image on this machine")
+    if checked == len(golden):
+        # the recorded set covers every basis RC1 can answer with
+        assert {("model", "real"), ("model", "uncertain"), ("model", "ai"), ("local_edit", "uncertain"),
+                ("provenance", "ai")} <= bases
+
+
+@pytest.mark.slow
+def test_spotlight_changes_the_overlay_and_nothing_else(rc1_detector):
+    """App request 2026-09-24: with AEYE_HEATMAP_STYLE=spotlight every field but overlay_b64 / heatmap_style is what the
+    jet run returns; the overlay differs exactly where a heatmap is drawn (AI verdict or a partial-edit suspect)."""
+    import main_hybrid as mh
+    golden = json.load(open(GOLDEN, encoding="utf-8"))["rows"]
+    drawn = 0
+    for row in golden:
+        if not os.path.exists(os.path.join(REPO, row["path"])):
+            continue
+        raw = _load(row["path"], row["strip"])
+        out = {}
+        for style in ("jet", "spotlight"):
+            mp = pytest.MonkeyPatch()
+            mp.setattr(mh, "HEATMAP_STYLE", style)
+            try:
+                out[style] = rc1_detector.analyze(raw, row["filename"])
+            finally:
+                mp.undo()
+        jet, spot = (_canon(out[s]) for s in ("jet", "spotlight"))
+        assert (jet["heatmap_style"], spot["heatmap_style"]) == ("jet", "spotlight")
+        same = lambda c: {k: v for k, v in c.items() if k not in ("overlay_b64", "heatmap_style")}  # noqa: E731
+        assert json.dumps(same(jet), sort_keys=True) == json.dumps(same(spot), sort_keys=True), row["tag"]
+        heat = out["jet"]["verdict"] == "AI" or bool(out["jet"].get("partial_edit_suspect"))
+        assert (jet["overlay_b64"] != spot["overlay_b64"]) == heat, row["tag"]
+        drawn += heat
+    if drawn == 0:
+        pytest.skip("no golden image with a drawn heatmap on this machine")
+
+
+def test_filename_only_provenance_is_not_100():
+    """Owner-review 2026-09-28: a generator-export filename alone is weak evidence - the AI verdict stands, the number is
+    the pixel score mapped into the AI range (never below AI_MIN), while a C2PA / metadata record still shows 100."""
+    import score_display as sd
+    t5, t1 = 0.842605, 0.973393
+    assert sd.display_score(0.36, "ai", "provenance", t5, t1, t1) == 100
+    assert sd.display_score(0.36, "ai", "provenance", t5, t1, t1, filename_only=True) == sd.AI_MIN
+    v = sd.display_score(0.99, "ai", "provenance", t5, t1, t1, filename_only=True)
+    assert sd.AI_MIN <= v < 100
+
+
+def test_vendor_binary_app_segments_do_not_carry_generator_signals():
+    """2026-09-29: a Motorola Moto Z2 Play camera original has an APP6 tuning blob whose printable bytes contained 'CAI:'
+    -> the old gate reported 'Adobe/Firefly' and forced AI. Generator tokens are no longer searched in vendor binary APPn
+    segments, and the bare 'cai:' token is gone; XMP and C2PA are still searched."""
+    import provenance_gate as pg
+    def seg(marker, payload):
+        return bytes([0xFF, marker]) + (len(payload) + 2).to_bytes(2, "big") + payload
+    blob = b"x" * 40 + b"ADOBE FIREFLY CAI:OO6=?SHIJZ9=68ILRcNbEVF@9PJ<=>^ULO" + b"y" * 40
+    jpg = b"\xff\xd8" + seg(0xE6, blob) + b"\xff\xda\x00\x02" + b"\x00" * 16 + b"\xff\xd9"
+    assert pg.check_bytes(jpg)["signals"] == []
+    xmp = b"http://ns.adobe.com/xap/1.0/\x00<x:xmpmeta><rdf:Description xmlns:cai=\"http://ns.adobe.com/cai/1.0/\"/></x:xmpmeta>"
+    jpg2 = b"\xff\xd8" + seg(0xE1, xmp) + b"\xff\xda\x00\x02" + b"\x00" * 16 + b"\xff\xd9"
+    assert "Adobe/Firefly" in pg.check_bytes(jpg2)["signals"]

tests/test_fft_nyquist_parity.py

@@ -0,0 +1,147 @@
+"""fft_nyquist (C3, 2026-09-24) in the service. Run:  .venv\\Scripts\\python -m pytest 1_deployed_service/tests/test_fft_nyquist_parity.py -q
+
+The radial-FFT branch historically clamped the radius to 1.0 and required r < 1 for its last ring, so the exact-Nyquist
+row/column and the spectrum corners fell in no ring. `fft_nyquist=True` makes the last ring [edges[-2], sqrt 2]. These
+tests pin what the service must do with it:
+  * without the flag the rings are the historic ones, bit for bit (every served checkpoint stores exactly those);
+  * the service's RadialFFTBranch is the training class, textually and numerically (masks and forward);
+  * a checkpoint's config flag reaches the model (_verdict_kwargs_from_checkpoint), and a checkpoint whose stored rings
+    disagree with its config is a start-up error (_load_state_strict / _check_fft_rings), never a silent switch.
+"""
+from __future__ import annotations
+
+import inspect
+import os
+import sys
+
+import pytest
+import torch
+import torch.nn as nn
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+REPO = os.path.dirname(ROOT)
+sys.path.insert(0, ROOT)
+
+import main_hybrid as mh  # noqa: E402
+from zero_shot_v4 import RadialFFTBranch  # noqa: E402
+
+
+def historic_masks(size: int, bins: int) -> torch.Tensor:
+    """The pre-C3 _make_radial_masks, verbatim."""
+    axis = torch.linspace(-1.0, 1.0, size)
+    yy, xx = torch.meshgrid(axis, axis, indexing="ij")
+    rr = torch.sqrt(xx.square() + yy.square()).clamp(max=1.0)
+    edges = torch.linspace(0.0, 1.0, bins + 1)
+    masks = []
+    for idx in range(bins):
+        mask = ((rr >= edges[idx]) & (rr < edges[idx + 1])).float()
+        denom = mask.sum().clamp_min(1.0)
+        masks.append(mask / denom)
+    return torch.stack(masks, dim=0)
+
+
+def _radius(size: int) -> torch.Tensor:
+    axis = torch.linspace(-1.0, 1.0, size)
+    yy, xx = torch.meshgrid(axis, axis, indexing="ij")
+    return torch.sqrt(xx.square() + yy.square())
+
+
+def _training_branch_cls():
+    training = os.path.join(REPO, "4_model_training")
+    if not os.path.isdir(training):
+        pytest.skip("4_model_training not present (service image): nothing to compare against")
+    if training not in sys.path:
+        sys.path.insert(0, training)
+    from src.models.zero_shot_v4 import RadialFFTBranch as TrainingBranch
+    return TrainingBranch
+
+
+class _Holder(nn.Module):
+    """Just enough model for _load_state_strict / _check_fft_rings: a `frequency_branch` like v4/v5/v6 have."""
+
+    def __init__(self, nyquist: bool) -> None:
+        super().__init__()
+        self.frequency_branch = RadialFFTBranch(image_size=224, bins=48, out_dim=192, nyquist=nyquist)
+
+
+def test_default_rings_are_the_historic_rings_bit_for_bit():
+    assert torch.equal(RadialFFTBranch._make_radial_masks(224, 48), historic_masks(224, 48))
+    assert torch.equal(RadialFFTBranch(image_size=224, bins=48).masks, historic_masks(224, 48))
+    assert torch.equal(RadialFFTBranch._make_radial_masks(64, 16, nyquist=False), historic_masks(64, 16))
+
+
+def test_nyquist_rings_cover_the_whole_spectrum_and_only_move_the_last_ring():
+    old, new = historic_masks(224, 48), RadialFFTBranch._make_radial_masks(224, 48, nyquist=True)
+    assert torch.equal(new[:-1], old[:-1]), "rings 0..46 must not move (warm starts depend on it)"
+    rr = _radius(224)
+    last = new[-1] > 0
+    assert torch.equal(last, rr >= torch.linspace(0.0, 1.0, 49)[-2])
+    support = (new > 0).sum(dim=0)
+    assert int(support.min()) == 1 and int(support.max()) == 1, "every frequency in exactly one ring"
+    dropped_before = int(((old > 0).sum(dim=0) == 0).sum())
+    assert dropped_before == int((rr >= 1.0).sum()) > 0  # what the historic rings never saw (Nyquist row/col + corners)
+    assert bool(last[0].all()) and bool(last[:, 0].all()), "the exact-Nyquist row and column (fftshift index 0) are in"
+    for ring in new:
+        assert torch.isclose(ring.sum(), torch.tensor(1.0), atol=1e-5)
+
+
+def test_service_ring_class_is_the_training_class():
+    TrainingBranch = _training_branch_cls()
+    assert inspect.getsource(RadialFFTBranch) == inspect.getsource(TrainingBranch)
+    torch.manual_seed(0)
+    x = torch.rand(3, 3, 224, 224)
+    for nyquist in (False, True):
+        svc = RadialFFTBranch(image_size=224, bins=48, out_dim=192, nyquist=nyquist).eval()
+        trn = TrainingBranch(image_size=224, bins=48, out_dim=192, nyquist=nyquist).eval()
+        trn.load_state_dict(svc.state_dict())
+        assert torch.equal(svc.masks, trn.masks)
+        with torch.no_grad():
+            assert torch.equal(svc(x), trn(x))
+
+
+def test_nyquist_changes_the_features_only_through_the_last_ring():
+    torch.manual_seed(1)
+    old = RadialFFTBranch(image_size=224, bins=48, nyquist=False).eval()
+    new = RadialFFTBranch(image_size=224, bins=48, nyquist=True).eval()
+    new.load_state_dict(old.state_dict())  # warm start: the nyquist branch keeps its own rings
+    assert new.ignored_checkpoint_masks and not torch.equal(new.masks, old.masks)
+    x = torch.rand(2, 3, 224, 224)
+    with torch.no_grad():
+        assert not torch.equal(old(x), new(x))
+
+
+def test_verdict_kwargs_carry_the_flag():
+    base = {"type": "zero_shot_v6", "clip_backbone": "clip-vit-l-14", "clip_layers": [13], "fft_bins": 48}
+    _, kw = mh._verdict_kwargs_from_checkpoint({"config": {"model": dict(base, fft_nyquist=True)}, "model_trainable_state_dict": {}})
+    assert kw["fft_nyquist"] is True
+    _, kw = mh._verdict_kwargs_from_checkpoint({"config": {"model": dict(base)}, "model_trainable_state_dict": {}})
+    assert "fft_nyquist" not in kw  # absent = the constructor default = historic rings
+
+
+def test_a_nyquist_model_refuses_clamped_rings_from_a_checkpoint():
+    legacy_state = _Holder(nyquist=False).state_dict()
+    with pytest.raises(RuntimeError, match="did not survive loading"):
+        mh._load_state_strict(_Holder(nyquist=True), legacy_state, "verdict")
+
+
+def test_rings_that_disagree_with_the_config_are_a_startup_error():
+    model = _Holder(nyquist=False)
+    mh._load_state_strict(model, _Holder(nyquist=True).state_dict(), "verdict")  # historic loading takes the buffer
+    with pytest.raises(RuntimeError, match="checkpoint and config disagree"):
+        mh._check_fft_rings(model, "verdict")
+    ok = _Holder(nyquist=True)
+    mh._load_state_strict(ok, _Holder(nyquist=True).state_dict(), "verdict")
+    mh._check_fft_rings(ok, "verdict")
+    mh._check_fft_rings(nn.Linear(2, 2), "no fft branch")  # models without the branch are not checked
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("name", ["best49.pt", "best63.pt", "best69.pt", "best69_loc.pt"])
+def test_shipped_checkpoints_store_the_historic_rings(name):
+    path = os.path.join(ROOT, "models", name)
+    if not os.path.exists(path):
+        pytest.skip(f"{name} not present")
+    ck = torch.load(path, map_location="cpu", weights_only=True)
+    state = ck.get("model_trainable_state_dict", ck.get("model_state_dict", ck))
+    assert not (ck.get("config") or {}).get("model", {}).get("fft_nyquist")
+    assert torch.equal(state["frequency_branch.masks"], historic_masks(224, 48))

tests/test_heatmap_spotlight.py

@@ -0,0 +1,169 @@
+"""Heatmap spotlight (app request 2026-09-24, owner-approved; _collab/REQUEST_server_heatmap_spotlight.md).
+
+The jet overlay painted green / yellow over photos the app calls AI, and in the app green means 'real' and amber
+'uncertain'. The spotlight adds no colour: the suspect region stays the original photo, the rest is darkened to 50 %,
+one white line on the edge. AEYE_HEATMAP_STYLE picks the style and every response says which one it got
+(heatmap_style), so the app can choose its caption without an app build and a deploy landing on the same day.
+"""
+from __future__ import annotations
+
+import asyncio
+import io
+import os
+import sys
+
+import numpy as np
+import pytest
+from PIL import Image
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, ROOT)
+
+import heatmap_nextgen as hn  # noqa: E402
+
+
+def _photo(w: int = 768, h: int = 512) -> Image.Image:
+    """A smooth colour photo stand-in (no pure black / white, so dimming and the white line are measurable)."""
+    y, x = np.mgrid[0:h, 0:w].astype(np.float32)
+    r = 60 + 150 * x / w
+    g = 70 + 120 * y / h
+    b = 90 + 80 * (1 - x / w)
+    return Image.fromarray(np.stack([r, g, b], -1).astype(np.uint8))
+
+
+def _blob_map(grid: int = 24, cx: int = 16, cy: int = 8, radius: float = 3.5) -> np.ndarray:
+    y, x = np.mgrid[0:grid, 0:grid].astype(np.float32)
+    return np.exp(-((x - cx) ** 2 + (y - cy) ** 2) / (2 * radius ** 2)).astype(np.float32)
+
+
+def _norm(loc: np.ndarray, size: tuple[int, int]) -> np.ndarray:
+    big = hn._big(hn._focus(loc), size)
+    return big / big.max()
+
+
+def test_region_is_the_original_photo_and_the_rest_is_half_as_bright():
+    img, loc = _photo(), _blob_map()
+    out = np.asarray(hn.spotlight(img, loc), np.int32)
+    src = np.asarray(img, np.int32)
+    norm = _norm(loc, img.size)
+    deep_inside = norm >= 0.8                       # far from the edge line and its shadow
+    far_outside = norm <= 0.2
+    assert deep_inside.sum() > 500 and far_outside.sum() > 100_000
+    assert np.array_equal(out[deep_inside], src[deep_inside])                     # untouched, pixel for pixel
+    half = np.rint(src[far_outside] * 0.5)
+    assert np.abs(out[far_outside] - half).max() <= 1                              # 50 % brightness
+
+
+def test_dimming_keeps_hue_and_adds_no_colour():
+    img, loc = _photo(), _blob_map()
+    out = np.asarray(hn.spotlight(img, loc), np.float32)
+    src = np.asarray(img, np.float32)
+    norm = _norm(loc, img.size)
+    ramp = (norm > 0.36) & (norm < 0.45)            # inside the soft ramp, away from the line
+    for mask in (norm <= 0.3, ramp):
+        assert mask.sum() > 50
+        ratio = out[mask] / src[mask]
+        assert np.abs(ratio - ratio.mean(axis=1, keepdims=True)).max() < 0.02  # same factor on R, G and B
+
+
+def test_edge_line_is_white_with_a_dark_rim_inside():
+    from scipy.ndimage import binary_dilation, binary_erosion
+    img, loc = _photo(), _blob_map()
+    out = np.asarray(hn.spotlight(img, loc), np.int32)
+    src = np.asarray(img, np.int32)
+    inside = _norm(loc, img.size) >= 0.5
+    line = binary_dilation(inside, iterations=1) & ~binary_erosion(inside, iterations=1, border_value=1)
+    assert line.sum() > 100
+    assert out[line].min() >= int(0.9 * 255)        # 0.9 white over any photo: at least 229
+    shadow = binary_erosion(inside, iterations=1, border_value=1) & ~binary_erosion(inside, iterations=2, border_value=1)
+    assert np.abs(out[shadow] - np.rint(src[shadow] * 0.75)).max() <= 1
+
+
+def test_line_scales_with_the_display_size():
+    loc = _blob_map()
+
+    def white(img: Image.Image) -> int:
+        return int((np.asarray(hn.spotlight(img, loc), np.int32).min(axis=-1) >= 228).sum())
+    # twice the side: twice the perimeter and twice the line width -> about four times the white pixels
+    assert 3.0 < white(_photo(1536, 1024)) / white(_photo(768, 512)) < 5.0
+
+
+def test_nothing_to_point_at_returns_the_photo_unchanged():
+    img = _photo()
+    assert np.array_equal(np.asarray(hn.spotlight(img, _blob_map(), blanket=True)), np.asarray(img))
+    assert np.array_equal(np.asarray(hn.spotlight(img, np.full((24, 24), 0.4, np.float32))), np.asarray(img))
+
+
+def test_jet_overlay_is_unchanged_by_the_new_style():
+    """overlay() is the rollback path (AEYE_HEATMAP_STYLE=jet): its pixels must be what RC1 served."""
+    img, loc = _photo(), _blob_map()
+    rgb = np.asarray(img.convert("RGB"), np.float32) / 255.0
+    big = hn._big(hn._focus(loc), img.size)
+    alpha = 0.92 * np.clip((big - 0.30) / 0.70, 0.0, 1.0) ** 0.55
+    want = (np.clip(rgb * (1 - alpha[..., None]) + hn.jet(big) * alpha[..., None], 0, 1) * 255).astype(np.uint8)
+    assert np.array_equal(np.asarray(hn.overlay(img, loc, 1.0, blanket=False)), want)
+
+
+# --------------------------------------------------------------------------- configuration
+def test_style_variable_parsing():
+    import main_hybrid as mh
+    assert mh.parse_heatmap_style(None) == "spotlight"
+    assert mh.parse_heatmap_style("") == "spotlight"
+    assert mh.parse_heatmap_style(" JET ") == "jet"
+    assert mh.parse_heatmap_style("spotlight") == "spotlight"
+    assert mh.parse_heatmap_style("rainbow") == "spotlight"      # logged, never a start-up failure
+
+
+def test_dockerfile_serves_spotlight():
+    with open(os.path.join(ROOT, "Dockerfile"), encoding="utf-8") as fh:
+        assert "AEYE_HEATMAP_STYLE=spotlight" in fh.read()
+
+
+def test_startup_banner_names_the_style():
+    import guards
+    import main_hybrid as mh
+    assert f"heatmap=dense/{mh.HEATMAP_STYLE}" in mh.startup_banner(guards.Settings(), 0.5, "v6", 9)
+
+
+# --------------------------------------------------------------------------- the field reaches the client
+def test_schema_declares_heatmap_style():
+    from schemas import AnalyzeResponse
+    base = {"score": 0.1, "verdict": "REAL", "heatmap_b64": "", "overlay_b64": "", "model_version": "x", "elapsed_ms": 1}
+    assert AnalyzeResponse(**base).heatmap_style is None
+    assert AnalyzeResponse(**base, heatmap_style="spotlight").heatmap_style == "spotlight"
+    with pytest.raises(Exception):
+        AnalyzeResponse(**base, heatmap_style="rainbow")
+
+
+@pytest.mark.parametrize("path", ["/api/analyze", "/predict"])
+def test_heatmap_style_survives_the_api_response(path):
+    """FastAPI drops every key the response model does not declare (HANDOFF trap 28d) - only an HTTP-level test
+    shows the field actually reaches the app."""
+    import httpx
+    import guards
+    import main_hybrid as mh
+
+    class Stub:
+        model_version = "stub"
+
+        def analyze(self, raw: bytes, filename: str | None = None) -> dict:
+            return {"score": 0.99, "verdict": "AI", "heatmap_b64": "", "overlay_b64": "", "model_version": "stub",
+                    "elapsed_ms": 1, "threshold": 0.97, "source": "model", "basis": "model", "model_score": 0.99,
+                    "verdict_band": "AI", "display_score": 99, "display_band": "ai", "heatmap_style": "spotlight"}
+
+    buf = io.BytesIO()
+    Image.new("RGB", (64, 64), (90, 120, 150)).save(buf, "PNG")
+    old = (guards.SETTINGS, mh._detector)
+    guards.configure(guards.Settings(anon_per_minute=1000, anon_per_day=100000, max_concurrency=1, max_queue=4,
+                                     queue_timeout_s=1.0, trusted_proxy_hops=1))
+    mh._detector = Stub()
+
+    async def go():
+        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=mh.app), base_url="http://test") as c:
+            return await c.post(path, files={"image": ("x.png", buf.getvalue(), "image/png")})
+    try:
+        body = asyncio.run(go()).json()
+    finally:
+        guards.configure(old[0])
+        mh._detector = old[1]
+    assert body["heatmap_style"] == "spotlight"

tests/test_lattice_service.py

@@ -0,0 +1,284 @@
+"""GPT round 3 lattice features (checkpoint config model.lattice_features) in the service. Run:
+    .venv\\Scripts\\python -m pytest 1_deployed_service/tests/test_lattice_service.py -q
+
+Pinned here (CPU, a tiny random CLIP stands in for CLIP-L in both copies; the DINOv2 case skips without the pinned cache):
+  * lattice_features.py and crop_geometry.py are BYTE-identical to the training copies (4_model_training/src/models,
+    4_model_training/src/data) - the statistic the service computes is the one the model was trained on;
+  * a checkpoint without the key builds the historic v6 (no constructor key); with it the key reaches ZeroShotV6Detector;
+    an unknown statistic fails closed before CLIP is loaded;
+  * flags off: the service ZeroShotV6Detector is bit-identical to the pinned pre-change service module (slow: also with the
+    deployed RC1 checkpoint models/best69.pt, real CLIP-L + DINOv2-S);
+  * PARITY: the service model (built by _verdict_kwargs_from_checkpoint + _load_state_strict) equals the training model
+    with the same weights on 9 native crops with the geometry plane: logits / p_ai / artifact vector |diff| < 1e-5 on CPU,
+    and the lattice features themselves bit for bit;
+  * _native_crops attaches exactly eval_sealed's plane for a lattice verdict (the evaluator's grid, the decoded image's
+    frame, pad_to offsets for small images) and nothing for any other verdict.
+The training-side comparisons skip in the service image (no 4_model_training).
+"""
+from __future__ import annotations
+
+import copy
+import importlib.util
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+import torch
+from PIL import Image
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+REPO = os.path.dirname(ROOT)
+sys.path.insert(0, ROOT)
+GIT_REPO = os.environ.get("AEYE_REPO", REPO)
+BASE_COMMIT = "0905ac8"   # the tree before lattice_features (flags-off reference)
+
+import crop_geometry as svc_cg  # noqa: E402
+import lattice_features as svc_lf  # noqa: E402
+import main_hybrid as mh  # noqa: E402
+import multiview  # noqa: E402
+import zero_shot_v4 as svc_v4  # noqa: E402
+from zero_shot_v6 import ZeroShotV6Detector as ServiceV6  # noqa: E402
+
+TOL = 1e-5
+SPEC = {"stats": ["nyq_min_img", "d4_img"], "per_crop": True, "clip": 4.0, "sides": "positive"}
+V6_MODEL = {
+    "type": "zero_shot_v6", "clip_backbone": "clip-vit-l-14", "clip_layers": [13], "anchor_layer": 13,
+    "clip_adapter": "effort", "adapter_rank": 4, "adapter_targets": ["q_proj", "k_proj", "v_proj", "out_proj"],
+    "semantic_dim": 32, "forensic_dim": 16, "frequency_dim": 24, "fft_bins": 8, "fft_nyquist": True, "num_classes": 2,
+    "dropout": 0.26, "source_grl_lambda": 0.0, "patch_backbone": "none", "patch_dim": 16, "n_crops_train": 4,
+    "n_crops_eval": 9, "crop_pool": "mean", "grad_checkpointing": True, "num_sources": 3,
+}
+
+
+def _training():
+    training = os.path.join(REPO, "4_model_training")
+    if not os.path.isdir(training):
+        pytest.skip("4_model_training not present (service image): nothing to compare against")
+    if training not in sys.path:
+        sys.path.insert(0, training)
+    from src.models import factory
+    import src.models.zero_shot_v4 as trn_v4
+    return factory, trn_v4
+
+
+class _TinyCLIP:
+    base = None
+
+    @classmethod
+    def from_pretrained(cls, *_a, **_k):
+        if cls.base is None:
+            from transformers import CLIPVisionConfig, CLIPVisionModelWithProjection
+
+            with torch.random.fork_rng():
+                torch.manual_seed(1234)
+                cls.base = CLIPVisionModelWithProjection(CLIPVisionConfig(
+                    hidden_size=64, intermediate_size=128, num_hidden_layers=13, num_attention_heads=4, image_size=224,
+                    patch_size=32, projection_dim=32))
+        return copy.deepcopy(cls.base)
+
+
+def _renderer_image(w=1086, h=725, seed=0, amp=3.0):
+    """Content + the owner-train lattice on the 16-multiple grid, slightly up-sampled to (w, h)."""
+    rng = np.random.default_rng(seed)
+    w0, h0 = 16 * (w // 16), 16 * (h // 16)
+    base = np.asarray(Image.fromarray(rng.integers(20, 236, (h0 // 8 + 1, w0 // 8 + 1, 3), dtype=np.uint8)).resize(
+        (w0, h0), Image.Resampling.BICUBIC)).astype(np.float64)
+    t = np.asarray(svc_lf.T_REF)
+    tile = np.tile(t, (h0 // 8 + 1, w0 // 8 + 1))[:h0, :w0] / np.abs(t).max()
+    img = Image.fromarray(np.clip(np.round(base + amp * tile[..., None]), 0, 255).astype(np.uint8))
+    return img.resize((w, h), Image.Resampling.BICUBIC)
+
+
+def _plane_crops(img: Image.Image, k: int = 9) -> torch.Tensor:
+    """eval_sealed.RecordSet(crop_geometry=True)'s crops, rebuilt here from multiview.py (== the evaluator's grid)."""
+    import torchvision.transforms as T
+
+    tf = T.Compose([T.ToTensor(), T.Normalize(svc_v4.CLIP_MEAN, svc_v4.CLIP_STD)])
+    w0, h0 = img.size
+    p = multiview.pad_to(img, 224)
+    w, h = p.size
+    boxes = multiview.grid_boxes(w, h, 224, k)
+    pix = torch.stack([tf(p.crop((x, y, x + 224, y + 224))) for x, y in boxes])
+    ox, oy = max(0, 224 - w0) // 2, max(0, 224 - h0) // 2
+    return svc_cg.attach_geometry(pix, [svc_cg.geometry_row(x - ox, y - oy, w0, h0) for x, y in boxes])
+
+
+# --------------------------------------------------------------------------- copies and config
+@pytest.mark.parametrize("name,training_rel", [("lattice_features.py", ("src", "models", "lattice_features.py")),
+                                               ("crop_geometry.py", ("src", "data", "crop_geometry.py"))])
+def test_service_copies_are_byte_identical_to_the_training_modules(name, training_rel):
+    trn = os.path.join(REPO, "4_model_training", *training_rel)
+    if not os.path.isfile(trn):
+        pytest.skip("4_model_training not present (service image)")
+    with open(os.path.join(ROOT, name), "rb") as a, open(trn, "rb") as b:
+        assert a.read().replace(b"\r\n", b"\n") == b.read().replace(b"\r\n", b"\n")
+
+
+def test_checkpoints_without_lattice_features_are_untouched():
+    for mcfg in (dict(V6_MODEL), dict(V6_MODEL, lattice_features=None)):
+        arch, kwargs = mh._verdict_kwargs_from_checkpoint({"config": {"model": mcfg}})
+        assert arch == "v6" and kwargs.get("lattice_features") is None
+    arch, kwargs = mh._verdict_kwargs_from_checkpoint({"config": {"model": dict(V6_MODEL, lattice_features=SPEC)}})
+    assert arch == "v6" and kwargs["lattice_features"] == SPEC and "lattice_features" in mh._V6_KEYS
+
+
+def test_an_unknown_statistic_fails_closed_before_clip_loads(monkeypatch):
+    def boom(*_a, **_k):  # CLIP must not even be built
+        raise AssertionError("CLIP was loaded before the lattice spec was validated")
+
+    monkeypatch.setattr(svc_v4.CLIPVisionModelWithProjection, "from_pretrained", boom)
+    for bad in ({"stats": ["nyq16"]}, {"stats": ["d4_img"], "per_crop": False}, {"statz": ["d4_img"]}):
+        _, kwargs = mh._verdict_kwargs_from_checkpoint({"config": {"model": dict(V6_MODEL, lattice_features=bad)}})
+        with pytest.raises(ValueError, match="lattice_features"):
+            ServiceV6(**kwargs)
+
+
+# --------------------------------------------------------------------------- flags off = the pre-change service module
+def test_flags_off_service_model_is_bit_identical_to_the_base(monkeypatch, tmp_path):
+    try:
+        out = subprocess.run(["git", "-C", GIT_REPO, "show", f"{BASE_COMMIT}:1_deployed_service/zero_shot_v6.py"],
+                             capture_output=True, timeout=60)
+    except (OSError, subprocess.TimeoutExpired) as exc:  # pragma: no cover
+        pytest.skip(f"git not available: {exc}")
+    if out.returncode != 0:
+        pytest.skip("pre-change service module not readable from git")
+    src = tmp_path / "_base_service_zero_shot_v6.py"
+    src.write_bytes(out.stdout)
+    spec = importlib.util.spec_from_file_location("_base_service_zero_shot_v6", src)
+    base = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(base)
+    monkeypatch.setattr(svc_v4, "CLIPVisionModelWithProjection", _TinyCLIP)
+    _, kwargs = mh._verdict_kwargs_from_checkpoint({"config": {"model": dict(V6_MODEL)}})
+    torch.manual_seed(7)
+    old = base.ZeroShotV6Detector(**kwargs).eval()
+    torch.manual_seed(7)
+    new = ServiceV6(**kwargs).eval()
+    so, sn = old.state_dict(), new.state_dict()
+    assert list(so) == list(sn) and all(torch.equal(so[k], sn[k]) for k in so)
+    g = torch.Generator().manual_seed(3)
+    x = (torch.rand(2, 3, 224, 224, generator=g) - 0.45) / 0.27
+    crops = (torch.rand(2, 9, 3, 224, 224, generator=g) - 0.45) / 0.27
+    with torch.no_grad():
+        a, b = old(x, crops), new(x, crops)
+    assert set(a) == set(b) and all(torch.equal(a[k], b[k]) for k in a)
+
+
+@pytest.mark.slow
+def test_flags_off_real_rc1_checkpoint_is_bit_identical_to_the_base(tmp_path):
+    """The deployed RC1 verdict (models/best69.pt, real CLIP-L + DINOv2-S) through the pre-change and the current service
+    ZeroShotV6Detector: every output tensor equal on a fixed input with 9 native crops."""
+    ckpt = os.path.join(ROOT, "models", "best69.pt")
+    if not os.path.isfile(ckpt):
+        pytest.skip("models/best69.pt not present")
+    try:
+        out = subprocess.run(["git", "-C", GIT_REPO, "show", f"{BASE_COMMIT}:1_deployed_service/zero_shot_v6.py"],
+                             capture_output=True, timeout=60)
+    except (OSError, subprocess.TimeoutExpired) as exc:  # pragma: no cover
+        pytest.skip(f"git not available: {exc}")
+    if out.returncode != 0:
+        pytest.skip("pre-change service module not readable from git")
+    src = tmp_path / "_base_service_zero_shot_v6_rc1.py"
+    src.write_bytes(out.stdout)
+    spec = importlib.util.spec_from_file_location("_base_service_zero_shot_v6_rc1", src)
+    base = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(base)
+    ck = torch.load(ckpt, map_location="cpu", weights_only=True)
+    state = ck["model_trainable_state_dict"]
+    arch, kwargs = mh._verdict_kwargs_from_checkpoint(ck)
+    assert arch == "v6" and kwargs.get("lattice_features") is None
+    g = torch.Generator().manual_seed(5)
+    x = (torch.rand(1, 3, 224, 224, generator=g) - 0.45) / 0.27
+    crops = (torch.rand(1, 9, 3, 224, 224, generator=g) - 0.45) / 0.27
+    outs = []
+    for cls in (base.ZeroShotV6Detector, ServiceV6):
+        m = cls(**kwargs)
+        mh._load_state_strict(m, state, "verdict(v6)")
+        m.eval()
+        with torch.no_grad():
+            outs.append({k: v.clone() for k, v in m(x, crops).items()})
+        del m
+    assert set(outs[0]) == set(outs[1]) and all(torch.equal(outs[0][k], outs[1][k]) for k in outs[0])
+
+
+# --------------------------------------------------------------------------- parity with the training model
+def _parity(monkeypatch, mcfg, x, crops):
+    factory, trn_v4 = _training()
+    monkeypatch.setattr(trn_v4, "CLIPVisionModelWithProjection", _TinyCLIP)
+    monkeypatch.setattr(svc_v4, "CLIPVisionModelWithProjection", _TinyCLIP)
+    cfg = {"model": mcfg, "data": {"image_size": 224, "multiview": True, "decode_draft_size": 2048}}
+    torch.manual_seed(7)
+    trained = factory.build_model(cfg).eval()
+    with torch.no_grad():                                        # move the fresh heads away from their init
+        for n, p in trained.named_parameters():
+            if p.requires_grad and not n.startswith("clip."):
+                p.add_(0.02 * torch.randn_like(p))
+    ck = {"model_trainable_state_dict": trained.trainable_state_dict(), "config": cfg}
+    arch, kwargs = mh._verdict_kwargs_from_checkpoint(ck)
+    assert arch == "v6" and kwargs["lattice_features"] == mcfg["lattice_features"]
+    served = ServiceV6(**kwargs)
+    mh._load_state_strict(served, ck["model_trainable_state_dict"], "verdict(v6)")
+    served.eval()
+    with torch.no_grad():
+        a, b = trained(x, crops), served(x, crops)
+        pix, geom = svc_cg.split_geometry(crops)
+        fa = trained.lattice(trained._to_raw_rgb(pix.flatten(0, 1)), geom.flatten(0, 1))
+        fb = served.lattice(served._to_raw_rgb(pix.flatten(0, 1)), geom.flatten(0, 1))
+    assert torch.equal(fa, fb)
+    d = {k: float((a[k] - b[k]).abs().max()) for k in ("logits", "artifact_features", "features")}
+    d["p_ai"] = float((torch.softmax(a["logits"], 1)[:, 1] - torch.softmax(b["logits"], 1)[:, 1]).abs().max())
+    assert max(d.values()) < TOL, d
+    return trained, served, fa
+
+
+def test_service_equals_training_with_lattice_features(monkeypatch):
+    img = _renderer_image(seed=1)
+    crops = torch.stack([_plane_crops(img), _plane_crops(_renderer_image(700, 500, seed=2, amp=0.0))])
+    g = torch.Generator().manual_seed(11)
+    x = (torch.rand(2, 3, 224, 224, generator=g) - 0.45) / 0.27
+    _, served, feats = _parity(monkeypatch, dict(V6_MODEL, lattice_features=SPEC), x, crops)
+    f = feats.view(2, 9, 2)
+    assert float(f[0, :, 0].mean()) > 2.0 > float(f[1, :, 0].mean())     # lattice image vs the same content without it
+    with pytest.raises(ValueError, match="geometry plane"):
+        served(x, svc_cg.split_geometry(crops)[0])                        # native crops without the plane
+
+
+def test_service_equals_training_with_lattice_features_and_dinov2(monkeypatch):
+    from transformers import AutoModel
+
+    from zero_shot_v6 import PATCH_BACKBONES
+
+    repo, rev = PATCH_BACKBONES["dinov2-small"]
+    try:
+        AutoModel.from_pretrained(repo, revision=rev)
+    except Exception as exc:  # pragma: no cover - machine dependent
+        pytest.skip(f"pinned {repo} not available: {type(exc).__name__}")
+    crops = _plane_crops(_renderer_image(seed=3), k=9).unsqueeze(0)
+    g = torch.Generator().manual_seed(12)
+    x = (torch.rand(1, 3, 224, 224, generator=g) - 0.45) / 0.27
+    _parity(monkeypatch, dict(V6_MODEL, patch_backbone="dinov2-small", lattice_features=SPEC), x, crops)
+
+
+# --------------------------------------------------------------------------- the service's own crops
+class _Stub:
+    def __init__(self, lattice: bool, k: int = 9):
+        self.verdict = type("V", (), {"lattice_spec": svc_lf.parse_lattice_features(SPEC) if lattice else None})()
+        self.verdict_crops = k
+        import torchvision.transforms as T
+
+        self.transform_crop = T.Compose([T.ToTensor(), T.Normalize(svc_v4.CLIP_MEAN, svc_v4.CLIP_STD)])
+        self.device = torch.device("cpu")
+
+
+@pytest.mark.parametrize("size", [(1086, 725), (1024, 1024), (300, 200), (180, 500)])
+def test_native_crops_attach_the_evaluators_plane_only_for_a_lattice_verdict(size):
+    img = _renderer_image(*size, seed=4)
+    plain = mh.HybridDetector._native_crops(_Stub(False), img)
+    with_plane = mh.HybridDetector._native_crops(_Stub(True), img)
+    assert plain.shape == (1, 9, 3, 224, 224) and with_plane.shape == (1, 9, 4, 224, 224)
+    pix, geom = svc_cg.split_geometry(with_plane)
+    assert torch.equal(pix, plain)
+    assert torch.equal(with_plane[0], _plane_crops(img))
+    assert (geom[..., 2:4] == torch.tensor(size, dtype=torch.float64)).all()

tests/test_patch_adapter_merge.py

@@ -0,0 +1,269 @@
+"""DINOv2 patch adapter (GPT round 2, R2C, 2026-09-24) in the service. Run:
+    .venv\\Scripts\\python -m pytest 1_deployed_service/tests/test_patch_adapter_merge.py -q
+
+A verdict trained with an Effort adapter on its DINOv2 patch linears (training config model.patch_adapter) is served
+MERGED: the export folds W_p + U_k diag(s_k) V_k into plain weights stored under the frozen backbone's own names, and the
+service builds the ordinary v6 and loads them with its existing strict loader. These tests pin:
+  * checkpoints without a patch adapter are untouched (no new constructor key, no new tensors);
+  * an UNMERGED adapter checkpoint is refused before anything is built (the service has no adapter code path);
+  * a merged checkpoint must carry exactly the merged tensors its config announces (every targeted linear of every layer);
+  * PARITY: the merged service forward equals the adapted training forward, |diff| < 1e-5 on CPU - on the DINOv2 branch
+    with the real pinned dinov2-small, and on the whole v6 model (a tiny random CLIP stands in for CLIP-L so the test
+    needs no 1.7 GB backbone; DINOv2 is the real one).
+The DINOv2 tests skip when the pinned dinov2-small is not in the local Hugging Face cache; the training-side tests skip in
+the service image (no 4_model_training).
+"""
+from __future__ import annotations
+
+import copy
+import os
+import sys
+
+import pytest
+import torch
+import torch.nn as nn
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+REPO = os.path.dirname(ROOT)
+sys.path.insert(0, ROOT)
+
+import main_hybrid as mh  # noqa: E402
+import zero_shot_v4 as svc_v4  # noqa: E402
+from zero_shot_v6 import PATCH_BACKBONES  # noqa: E402
+
+TARGETS = ["query", "key", "value", "dense"]
+TOL = 1e-5
+
+
+def _training_v6():
+    training = os.path.join(REPO, "4_model_training")
+    if not os.path.isdir(training):
+        pytest.skip("4_model_training not present (service image): nothing to compare against")
+    if training not in sys.path:
+        sys.path.insert(0, training)
+    from src.models import zero_shot_v6 as z6
+    return z6
+
+
+def _service_dinov2():
+    """The service's own call (zero_shot_v6: AutoModel.from_pretrained(repo, revision=pinned)), frozen, eval."""
+    from transformers import AutoModel
+
+    repo, rev = PATCH_BACKBONES["dinov2-small"]
+    try:
+        model = AutoModel.from_pretrained(repo, revision=rev)
+    except Exception as exc:  # pragma: no cover - depends on the machine's cache / network
+        pytest.skip(f"pinned {repo}@{rev[:8]} not available: {type(exc).__name__}")
+    for p in model.parameters():
+        p.requires_grad = False
+    return model.eval()
+
+
+def _tokens(backbone: nn.Module, x: torch.Tensor) -> torch.Tensor:
+    """CLS ⊕ mean patch token - exactly what ZeroShotV6Detector._patch_tokens hands to patch_proj."""
+    with torch.no_grad():
+        out = backbone(pixel_values=x).last_hidden_state
+    return torch.cat([out[:, 0], out[:, 1:].mean(dim=1)], dim=1).float()
+
+
+def _perturb(wrapped: dict, seed: int = 0) -> None:
+    """Move the Effort factors well away from their SVD init (a 'trained' adapter)."""
+    g = torch.Generator().manual_seed(seed)
+    with torch.no_grad():
+        for m in wrapped.values():
+            m.U_k.add_(0.05 * torch.randn(m.U_k.shape, generator=g))
+            m.V_k.add_(0.05 * torch.randn(m.V_k.shape, generator=g))
+            m.s_k.mul_(1.0 + 4.0 * torch.rand(m.s_k.shape, generator=g)).add_(0.2)
+
+
+def _crops(n: int, seed: int = 1) -> torch.Tensor:
+    g = torch.Generator().manual_seed(seed)
+    x = torch.rand(n, 3, 224, 224, generator=g)
+    mean = torch.tensor((0.485, 0.456, 0.406)).view(1, 3, 1, 1)
+    std = torch.tensor((0.229, 0.224, 0.225)).view(1, 3, 1, 1)
+    return (x - mean) / std
+
+
+class _Holder(nn.Module):
+    """Just enough v6 for _load_state_strict / _check_patch_adapter: a `patch` DINOv2."""
+
+    def __init__(self, patch: nn.Module) -> None:
+        super().__init__()
+        self.patch = patch
+
+
+def _tiny_dinov2(layers: int = 2) -> nn.Module:
+    from transformers import Dinov2Config, Dinov2Model
+
+    cfg = Dinov2Config(hidden_size=32, num_hidden_layers=layers, num_attention_heads=2, intermediate_size=64, image_size=28,
+                       patch_size=14)
+    return Dinov2Model(cfg).eval()
+
+
+V6_MODEL = {
+    "type": "zero_shot_v6", "clip_backbone": "clip-vit-l-14", "clip_layers": [13], "anchor_layer": 13,
+    "clip_adapter": "effort", "adapter_rank": 4, "adapter_targets": ["q_proj", "k_proj", "v_proj", "out_proj"],
+    "semantic_dim": 512, "forensic_dim": 256, "frequency_dim": 192, "fft_bins": 48, "num_classes": 2,
+    "dropout": 0.26, "source_grl_lambda": 0.0, "patch_backbone": "dinov2-small",
+    "patch_dim": 256, "n_crops_train": 4, "n_crops_eval": 9, "crop_pool": "mean", "grad_checkpointing": True,
+}
+
+
+# --------------------------------------------------------------------------- contract (no model download)
+def test_service_target_table_is_the_training_table():
+    z6 = _training_v6()
+    assert mh._PATCH_ADAPTER_TARGETS == z6.PATCH_ADAPTER_TARGETS
+
+
+def test_checkpoints_without_a_patch_adapter_are_untouched():
+    for mcfg in (dict(V6_MODEL), dict(V6_MODEL, patch_adapter=None), dict(V6_MODEL, patch_adapter={"kind": "none"}),
+                 dict(V6_MODEL, patch_adapter="none")):
+        assert mh._patch_adapter_spec(mcfg) is None
+        arch, kwargs = mh._verdict_kwargs_from_checkpoint({"config": {"model": mcfg}})
+        assert arch == "v6" and "patch_adapter" not in kwargs
+
+
+def test_an_unmerged_adapter_checkpoint_is_refused_before_anything_is_built():
+    mcfg = dict(V6_MODEL, patch_adapter={"kind": "effort", "rank": 4, "targets": TARGETS})
+    with pytest.raises(ValueError, match="UNMERGED"):
+        mh._verdict_kwargs_from_checkpoint({"config": {"model": mcfg}})
+    with pytest.raises(ValueError, match="UNMERGED"):
+        mh._verdict_kwargs_from_checkpoint({"config": {"model": dict(mcfg, patch_adapter=dict(mcfg["patch_adapter"], merged=False))}})
+    with pytest.raises(ValueError, match="targets"):
+        mh._verdict_kwargs_from_checkpoint({"config": {"model": dict(V6_MODEL, patch_adapter={
+            "kind": "effort", "rank": 4, "targets": ["qkv"], "merged": True})}})
+
+
+def test_a_merged_adapter_checkpoint_builds_the_plain_v6():
+    mcfg = dict(V6_MODEL, patch_adapter={"kind": "effort", "rank": 4, "targets": TARGETS, "merged": True})
+    arch, kwargs = mh._verdict_kwargs_from_checkpoint({"config": {"model": mcfg}})
+    assert arch == "v6"
+    assert "patch_adapter" not in kwargs          # the service's ZeroShotV6Detector has no adapter code path
+    assert mh._patch_adapter_spec(mcfg)["targets"] == TARGETS
+
+
+def test_merged_tensors_must_be_exactly_the_ones_the_config_announces():
+    holder = _Holder(_tiny_dinov2(layers=2))
+    merged_cfg = {"patch_adapter": {"kind": "effort", "rank": 4, "targets": TARGETS, "merged": True}}
+    own = holder.state_dict()
+    want = [f"patch.encoder.layer.{i}.{mh._PATCH_ADAPTER_TARGETS[t]}.weight" for i in range(2) for t in TARGETS]
+    state = {k: torch.randn_like(own[k]) for k in want}
+    assert mh._load_state_strict(holder, state, "tiny") == 8
+    assert mh._check_patch_adapter(holder, merged_cfg, state, "tiny") == 8
+    for k in want:                                               # the merged weights really are in the backbone now
+        assert torch.equal(holder.state_dict()[k], state[k])
+
+    with pytest.raises(RuntimeError, match="1 missing"):
+        mh._check_patch_adapter(holder, merged_cfg, {k: v for k, v in state.items() if k != want[3]}, "tiny")
+    extra = dict(state, **{"patch.encoder.layer.0.mlp.fc1.weight": own["patch.encoder.layer.0.mlp.fc1.weight"]})
+    with pytest.raises(RuntimeError, match="1 unexpected"):
+        mh._check_patch_adapter(holder, merged_cfg, extra, "tiny")
+    with pytest.raises(RuntimeError, match="no patch_adapter"):
+        mh._check_patch_adapter(holder, {}, state, "tiny")      # merged weights whose config flag was lost
+    assert mh._check_patch_adapter(holder, {}, {"head.0.weight": torch.zeros(1)}, "tiny") == 0
+    with pytest.raises(RuntimeError, match="no DINOv2"):
+        mh._check_patch_adapter(nn.Linear(2, 2), merged_cfg, state, "tiny")
+
+
+# --------------------------------------------------------------------------- parity (real pinned dinov2-small)
+def test_merged_dinov2_branch_equals_the_adapted_branch():
+    """merge_patch_adapter_state (training package) -> the service's plain pinned DINOv2 through _load_state_strict:
+    the tokens patch_proj consumes must equal the adapted training forward to 1e-5 (CPU, fp32)."""
+    z6 = _training_v6()
+    spec = z6.parse_patch_adapter({"kind": "effort", "rank": 4, "targets": TARGETS})
+    adapted, _ = z6.load_patch_backbone("dinov2-small")
+    pretrained_tokens = None
+    x = _crops(3)
+    pretrained_tokens = _tokens(adapted, x)                        # before wrapping: the frozen historic branch
+    wrapped = z6.wrap_patch_backbone(adapted, spec)
+    assert len(wrapped) == 12 * 4
+    assert float((_tokens(adapted, x) - pretrained_tokens).abs().max()) < 1e-3   # SVD init = the pretrained layer
+    _perturb(wrapped)
+    adapted_tokens = _tokens(adapted, x)
+    assert float((adapted_tokens - pretrained_tokens).abs().max()) > 1e-2      # the test can see an adapter at all
+
+    state = {f"patch.{p}.{n}": getattr(m, n).detach().clone() for p, m in wrapped.items() for n in z6.PATCH_ADAPTER_FACTORS}
+    state["head.8.bias"] = torch.arange(2.0)                                   # a non-patch tensor rides along untouched
+    mcfg = {"patch_backbone": "dinov2-small", "patch_adapter": {"kind": "effort", "rank": 4, "targets": TARGETS}}
+    merged, merged_cfg = z6.merge_patch_adapter_state(state, mcfg)
+    assert merged_cfg["patch_adapter"]["merged"] is True and "merged" not in mcfg["patch_adapter"]
+    assert torch.equal(merged["head.8.bias"], state["head.8.bias"])
+    patch_state = {k: v for k, v in merged.items() if k.startswith("patch.")}
+    assert len(patch_state) == 48 and all(k.endswith(".weight") for k in patch_state)
+
+    service = _Holder(_service_dinov2())
+    assert mh._load_state_strict(service, patch_state, "parity") == 48
+    assert mh._check_patch_adapter(service, merged_cfg, merged, "parity") == 48
+    diff = float((_tokens(service.patch, x) - adapted_tokens).abs().max())
+    assert diff < TOL, f"merged service tokens differ from the adapted training tokens by {diff:.3g}"
+
+
+# --------------------------------------------------------------------------- parity (whole v6, tiny CLIP)
+class _TinyCLIP:
+    """Stands in for CLIPVisionModelWithProjection.from_pretrained in BOTH copies: identical random weights every call."""
+    base = None
+
+    @classmethod
+    def from_pretrained(cls, *_a, **_k):
+        if cls.base is None:
+            from transformers import CLIPVisionConfig, CLIPVisionModelWithProjection
+
+            with torch.random.fork_rng():
+                torch.manual_seed(1234)
+                cls.base = CLIPVisionModelWithProjection(CLIPVisionConfig(
+                    hidden_size=64, intermediate_size=128, num_hidden_layers=13, num_attention_heads=4, image_size=224,
+                    patch_size=32, projection_dim=32))
+        return copy.deepcopy(cls.base)
+
+
+def test_whole_v6_merged_service_equals_the_adapted_training_model(monkeypatch):
+    """Train-side ZeroShotV6Detector with a 'trained' patch adapter -> tools/merge_patch_adapter.merge_checkpoint ->
+    the SERVICE's _verdict_kwargs_from_checkpoint + service ZeroShotV6Detector + _load_state_strict +
+    _check_patch_adapter: logits and p_ai must agree to 1e-5 with 9 native crops; the unmerged file is refused."""
+    z6 = _training_v6()
+    _service_dinov2()  # skip early when the pinned backbone is not available
+    from src.models import factory
+    import src.models.zero_shot_v4 as trn_v4
+
+    monkeypatch.setattr(trn_v4, "CLIPVisionModelWithProjection", _TinyCLIP)
+    monkeypatch.setattr(svc_v4, "CLIPVisionModelWithProjection", _TinyCLIP)
+    mcfg = dict(V6_MODEL, semantic_dim=32, forensic_dim=16, frequency_dim=24, fft_bins=8, patch_dim=16, num_sources=3,
+                patch_adapter={"kind": "effort", "rank": 4, "targets": TARGETS})
+    cfg = {"model": mcfg, "data": {"image_size": 224, "multiview": True, "decode_draft_size": 2048}}
+    torch.manual_seed(7)
+    trained = factory.build_model(cfg).eval()
+    assert len(trained.patch_adapted) == 48
+    _perturb(trained.patch_adapted, seed=3)
+    ck = {"model_trainable_state_dict": trained.trainable_state_dict(), "config": cfg,
+          "metrics": {"calibrated_threshold": 0.5}, "epoch": 0, "source_to_id": {"a": 0, "b": 1, "c": 2}}
+    assert sum(1 for k in ck["model_trainable_state_dict"] if k.startswith("patch.")) == 48 * 3
+
+    with pytest.raises(ValueError, match="UNMERGED"):
+        mh._verdict_kwargs_from_checkpoint(ck)                   # the training file itself is never served
+
+    tools = os.path.join(REPO, "tools")
+    if tools not in sys.path:
+        sys.path.insert(0, tools)
+    import merge_patch_adapter as mpa
+
+    merged = mpa.merge_checkpoint(ck)
+    assert mpa.patch_adapter_state(merged) == "merged" and merged["patch_adapter_merge"]["merged_tensors"] == 48
+    arch, kwargs = mh._verdict_kwargs_from_checkpoint(merged)
+    assert arch == "v6" and kwargs["num_sources"] == 3 and "patch_adapter" not in kwargs
+    from zero_shot_v6 import ZeroShotV6Detector as ServiceV6
+
+    served = ServiceV6(**kwargs)
+    state = merged["model_trainable_state_dict"]
+    mh._load_state_strict(served, state, "verdict(v6)")
+    assert mh._check_patch_adapter(served, merged["config"]["model"], state, "verdict(v6)") == 48
+    served.eval()
+
+    g = torch.Generator().manual_seed(11)
+    x = (torch.rand(2, 3, 224, 224, generator=g) - 0.45) / 0.27
+    crops = (torch.rand(2, 9, 3, 224, 224, generator=g) - 0.45) / 0.27
+    with torch.no_grad():
+        a, b = trained(x, crops), served(x, crops)
+    d_logits = float((a["logits"] - b["logits"]).abs().max())
+    d_p = float((torch.softmax(a["logits"], 1)[:, 1] - torch.softmax(b["logits"], 1)[:, 1]).abs().max())
+    d_art = float((a["artifact_features"] - b["artifact_features"]).abs().max())
+    assert d_logits < TOL and d_p < TOL and d_art < TOL, (d_logits, d_p, d_art)

tests/test_renderer_trace.py

@@ -0,0 +1,213 @@
+"""renderer_trace (GPT round 4 TRACE basis, _collab/prereg_gpt_round4.json 'trace'). Run:
+    .venv\\Scripts\\python -m pytest 1_deployed_service/tests/test_renderer_trace.py -q
+
+Pinned here (CPU, numpy only):
+  * 1_deployed_service/renderer_trace.py is BYTE-identical to tools/renderer_trace.py (the statistic the service computes
+    is the one tools/trace_calib.py calibrated t* on); the service copy imports nothing from tools/ or 4_model_training;
+  * REPRODUCTION: both per-image statistics (mean over the 9 native crops of nyq_min_img and of d4_img) reproduce the
+    wf_r3 measurement (scratch wf_r3/measure supp.jsonl 'crop_nyqmin_img' / d4all.jsonl 'crop_d4_img') within |dz| < 1e-4
+    on 24 files x {pristine, jpeg85}: 8 owner ChatGPT images, 6 public gpt-image-1.5, 10 camera / web reals. The
+    reference values are copied below (the jsonl lives in a session scratch folder); a missing file skips its case;
+  * the gate (decoded long side <= 2048, else not computed and never fires), the v2 lower bound gate_min (1024: the gate
+    becomes [1024, 2048]; gate_min = 0 is v1 bit for bit), strict one-sided firing, the JPEG draft
+    decode, small-image padding, the constants (= lattice_features.PHI0 / T_REF) and the statistic fingerprint.
+"""
+from __future__ import annotations
+
+import hashlib
+import io
+import os
+import sys
+
+import numpy as np
+import pytest
+from PIL import Image
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+REPO = os.path.dirname(ROOT)
+sys.path.insert(0, ROOT)
+
+import renderer_trace as RT  # noqa: E402  (the service copy)
+
+TOL = 1e-4
+FINGERPRINT = "a0a1d8550df34d6a"
+
+# (repo-relative path, wf_r3 group, variant, crop_nyqmin_img, crop_d4_img) - wf_r3 measure, 2026-09-25
+FIXTURE = [
+    ('data_v7/user_gpt25/a-eye_training/ai_everyday_022_traditional_market.png', 'owner_full_train', 'pristine', 10.694231784121602, 7.053609886764008),
+    ('data_v7/user_gpt25/a-eye_training/ai_everyday_022_traditional_market.png', 'owner_full_train', 'jpeg85', 3.8448883508778184, 1.5490452713572158),
+    ('data_v7/user_gpt25/a-eye_training/ai_office_017_reverse_wall.png', 'owner_full_heldout', 'pristine', 7.509497901867495, 11.99300998013274),
+    ('data_v7/user_gpt25/a-eye_training/ai_office_017_reverse_wall.png', 'owner_full_heldout', 'jpeg85', 1.4971738582275438, 0.7040067768732041),
+    ('data_v7/user_gpt25/new_full/new_full_004_snow_gas_station.png', 'owner_full_train', 'pristine', 9.915207132243928, 11.944014308888827),
+    ('data_v7/user_gpt25/new_full/new_full_004_snow_gas_station.png', 'owner_full_train', 'jpeg85', 4.700899091654044, 0.5649400186262407),
+    ('data_v7/user_gpt25/new_full/new_full_046_street_food_cleanup.png', 'owner_full_heldout', 'pristine', 11.741384243125863, 27.425297221152103),
+    ('data_v7/user_gpt25/new_full/new_full_046_street_food_cleanup.png', 'owner_full_heldout', 'jpeg85', 2.7849015304305027, 3.1751882303490047),
+    ('data_v7/user_gpt25/new_partial/new_partial_058_breakwater_seaweed.png', 'owner_edit_train', 'pristine', 12.908809115322608, 10.274090149233054),
+    ('data_v7/user_gpt25/new_partial/new_partial_058_breakwater_seaweed.png', 'owner_edit_train', 'jpeg85', 6.48981954897316, 3.783058830310471),
+    ('data_v7/user_gpt25/partial_a/partial_012_giraffes_flowers.png', 'owner_edit_heldout', 'pristine', 18.188971110754164, 5.5211916611012795),
+    ('data_v7/user_gpt25/partial_a/partial_012_giraffes_flowers.png', 'owner_edit_heldout', 'jpeg85', 6.367683024856147, 1.3704302113977171),
+    ('data_v7/user_gpt25/partial_a/partial_038_penguin_footprint.png', 'owner_edit_train', 'pristine', 7.673462680713445, 9.425334150837061),
+    ('data_v7/user_gpt25/partial_a/partial_038_penguin_footprint.png', 'owner_edit_train', 'jpeg85', 1.5099918077834746, 0.6029541341489189),
+    ('data_v7/user_gpt25/partial_a/partial_096_chapel_mat.png', 'owner_edit_heldout', 'pristine', 9.062102812393352, 5.121994810678637),
+    ('data_v7/user_gpt25/partial_a/partial_096_chapel_mat.png', 'owner_edit_heldout', 'jpeg85', 3.120949925188513, 0.8041635773940743),
+    ('data_v7/raw_gpt/corebench_gpt/corebench_gpt_gpt-image-15_R-RR-010_0_0a384d685b.png', 'pub_gptimage15_corebench', 'pristine', 17.167610965410557, 3.4572679573815597),
+    ('data_v7/raw_gpt/corebench_gpt/corebench_gpt_gpt-image-15_R-RR-010_0_0a384d685b.png', 'pub_gptimage15_corebench', 'jpeg85', 14.126586320136362, 1.8836683582564007),
+    ('data_v7/raw_gpt/corebench_gpt/corebench_gpt_gpt-image-15_R-RR-076_2_cf5971e759.png', 'pub_gptimage15_corebench', 'pristine', 17.77225490959163, 11.894073200270906),
+    ('data_v7/raw_gpt/corebench_gpt/corebench_gpt_gpt-image-15_R-RR-076_2_cf5971e759.png', 'pub_gptimage15_corebench', 'jpeg85', 8.572520708585278, 0.987548239945752),
+    ('data_v7/raw/qwen_image_bench/qwen_image_bench_000181_3f841da5_0cf131f70b.png', 'pub_gptimage15_qwenbench', 'pristine', 19.645701698236145, 2.6086218555412657),
+    ('data_v7/raw/qwen_image_bench/qwen_image_bench_000181_3f841da5_0cf131f70b.png', 'pub_gptimage15_qwenbench', 'jpeg85', 17.33900084069554, 2.3035405333164176),
+    ('data_v7/raw/qwen_image_bench/qwen_image_bench_000344_07c67df4_d6cf4ef42e.png', 'pub_gptimage15_qwenbench', 'pristine', 18.290488867974393, 7.715865686147459),
+    ('data_v7/raw/qwen_image_bench/qwen_image_bench_000344_07c67df4_d6cf4ef42e.png', 'pub_gptimage15_qwenbench', 'jpeg85', 11.603799818013378, 4.570794330842024),
+    ('data_v7/raw/aas_gpt_image_15/aas_gpt_image_15_s0_r8_image_original_e021d63fa1.png', 'pub_gptimage15_aas_original', 'pristine', 17.515796904076957, 21.406413514315226),
+    ('data_v7/raw/aas_gpt_image_15/aas_gpt_image_15_s0_r8_image_original_e021d63fa1.png', 'pub_gptimage15_aas_original', 'jpeg85', 7.8591363403512435, 1.7628790897834679),
+    ('data_v7/raw/aas_gpt_image_15/aas_gpt_image_15_s1_r96_image_original_4429b99683.png', 'pub_gptimage15_aas_original', 'pristine', 16.761184695245028, 18.30242810917687),
+    ('data_v7/raw/aas_gpt_image_15/aas_gpt_image_15_s1_r96_image_original_4429b99683.png', 'pub_gptimage15_aas_original', 'jpeg85', 10.2207251650532, 4.355083679796606),
+    ('data_v7/owner_phone/202410_a_camera/IMG_9603.jpg', 'owner_iphone_train', 'pristine', -0.8201789631900693, 0.42727664067819165),
+    ('data_v7/owner_phone/202410_a_camera/IMG_9603.jpg', 'owner_iphone_train', 'jpeg85', -0.6152301935999862, 0.43513888854761046),
+    ('data_v7/owner_phone/202412_a_camera/IMG_0311.jpg', 'owner_iphone_train', 'pristine', -0.7716893052470097, -1.4053186442213916),
+    ('data_v7/owner_phone/202412_a_camera/IMG_0311.jpg', 'owner_iphone_train', 'jpeg85', -0.7351182241908449, -0.6816478831554456),
+    ('data_v7/owner_phone/202602_a_camera/IMG_9166.JPG', 'owner_iphone_cal', 'pristine', -4.186727597582083, 0.17815959009504395),
+    ('data_v7/owner_phone/202602_a_camera/IMG_9166.JPG', 'owner_iphone_cal', 'jpeg85', -0.4227467981441239, 0.4360545710864139),
+    ('data_v7/owner_phone/202602_a_camera/IQXK0846.jpg', 'owner_iphone_cal', 'pristine', -0.4859276786759066, 0.32001647669682437),
+    ('data_v7/owner_phone/202602_a_camera/IQXK0846.jpg', 'owner_iphone_cal', 'jpeg85', -0.9064865761990328, -0.0043320272202975),
+    ('data_v7/raw/dresden_forchheim/dresden_forchheim_D01_img_orig_0058_0199b63992.jpg', 'real_dresden_forchheim', 'pristine', 7.187986564275387, -1.1119387119998743),
+    ('data_v7/raw/dresden_forchheim/dresden_forchheim_D01_img_orig_0058_0199b63992.jpg', 'real_dresden_forchheim', 'jpeg85', 2.2629310284484245, -3.066560814365873),
+    ('data_v7/raw/dresden_forchheim/dresden_forchheim_D27_img_orig_0047_a9f235dde9.jpg', 'real_dresden_forchheim', 'pristine', -0.26274310767954984, -0.243590503121684),
+    ('data_v7/raw/dresden_forchheim/dresden_forchheim_D27_img_orig_0047_a9f235dde9.jpg', 'real_dresden_forchheim', 'jpeg85', -1.112180078403801, 0.4938441155635647),
+    ('data_v7/raw/pexels_janpf/pexels_janpf_13639f277329ac6d8cd418d9c8c6d9b2_e79068cb6b.jpg', 'real_pexels_janpf', 'pristine', -0.9935981233036278, 0.4815018842525822),
+    ('data_v7/raw/pexels_janpf/pexels_janpf_13639f277329ac6d8cd418d9c8c6d9b2_e79068cb6b.jpg', 'real_pexels_janpf', 'jpeg85', -0.9936821685532186, 0.4796875691748703),
+    ('data_v7/raw/unsplash_lite/unsplash_lite_u5350_33ae12457c.jpg', 'real_unsplash_lite', 'pristine', -0.7474683860488689, 0.009228328801253892),
+    ('data_v7/raw/unsplash_lite/unsplash_lite_u5350_33ae12457c.jpg', 'real_unsplash_lite', 'jpeg85', -0.46249269289745776, -0.14576180125523094),
+    ('data_v7/raw/open_images_web/open_images_web_000000341_426b89cd58.jpg', 'real_open_images_web', 'pristine', -1.3376806754480057, -1.2142137789608374),
+    ('data_v7/raw/open_images_web/open_images_web_000000341_426b89cd58.jpg', 'real_open_images_web', 'jpeg85', -1.143992187479694, -1.0283076112850447),
+    ('data_v7/raw/open_images_web/open_images_web_000004944_f112f2bd22.jpg', 'real_open_images_web', 'pristine', -0.8030112395735514, 0.46365719571240027),
+    ('data_v7/raw/open_images_web/open_images_web_000004944_f112f2bd22.jpg', 'real_open_images_web', 'jpeg85', -0.6547083754197037, 0.2684789778029803),
+]
+
+
+def _variant(img: Image.Image, variant: str) -> Image.Image:
+    """wf_r3 measure.make_variant for the two variants pinned here (jpeg85 = PIL JPEG q85, default 4:2:0)."""
+    if variant == "pristine":
+        return img
+    if variant == "jpeg85":
+        b = io.BytesIO()
+        img.save(b, "JPEG", quality=85)
+        b.seek(0)
+        return Image.open(b).convert("RGB")
+    raise ValueError(variant)
+
+
+def test_copies_byte_identical():
+    tools_copy = os.path.join(REPO, "tools", "renderer_trace.py")
+    if not os.path.exists(tools_copy):
+        pytest.skip("tools/ not present (service image)")
+    h = lambda p: hashlib.sha256(open(p, "rb").read()).hexdigest()  # noqa: E731
+    assert h(tools_copy) == h(os.path.join(ROOT, "renderer_trace.py"))
+
+
+def test_service_copy_is_standalone():
+    import ast
+    tree = ast.parse(open(os.path.join(ROOT, "renderer_trace.py"), encoding="utf-8").read())
+    mods = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            mods.update(a.name.split(".")[0] for a in node.names)
+        elif isinstance(node, ast.ImportFrom):
+            mods.add((node.module or "").split(".")[0])
+    assert mods <= {"__future__", "argparse", "hashlib", "io", "json", "math", "sys", "numpy", "PIL", "scipy"}, mods
+
+
+@pytest.mark.parametrize("rel,group,variant,ref_nyq,ref_d4", FIXTURE, ids=[f"{os.path.basename(f[0])}-{f[2]}" for f in FIXTURE])
+def test_reproduces_wf_r3(rel, group, variant, ref_nyq, ref_d4):
+    path = os.path.join(REPO, *rel.split("/"))
+    if not os.path.exists(path):
+        pytest.skip(f"{rel} not on disk")
+    st = RT.trace_stat(_variant(RT.decode(path), variant), force=True)
+    assert abs(st["nyq_min_img_mean"] - ref_nyq) < TOL
+    assert abs(st["d4_img_mean"] - ref_d4) < TOL
+    assert st["s"] == pytest.approx(min(ref_nyq / RT.SCALE_NYQ, ref_d4 / RT.SCALE_D4), abs=TOL)
+
+
+def test_fixture_covers_the_registered_groups():
+    groups = {g for _, g, _, _, _ in FIXTURE}
+    files = {p for p, _, _, _, _ in FIXTURE}
+    assert len(files) >= 20
+    assert any(g.startswith("owner_") and "iphone" not in g for g in groups)      # owner ChatGPT images
+    assert any(g.startswith("pub_gptimage15") for g in groups)                      # public gpt-image-1.5
+    assert any(g in ("owner_iphone_train", "owner_iphone_cal", "real_dresden_forchheim") for g in groups)  # camera reals
+
+
+def _noise(w: int, h: int, seed: int = 0) -> Image.Image:
+    return Image.fromarray(np.random.default_rng(seed).integers(0, 256, (h, w, 3), dtype=np.uint8))
+
+
+def test_gate():
+    inside = RT.trace_stat(_noise(2048, 300))
+    assert inside["gated"] is False and inside["s"] is not None and inside["long_side"] == 2048
+    above = RT.trace_stat(_noise(300, 2049))
+    assert above == {"s": None, "nyq_min_img_mean": None, "d4_img_mean": None, "long_side": 2049, "gated": True}
+    assert RT.fires(_noise(300, 2049), -1e9) is False
+    forced = RT.trace_stat(_noise(300, 2049), force=True)
+    assert forced["gated"] is True and forced["s"] is not None
+
+
+def test_gate_min_v2():
+    small, low, top = _noise(1023, 700, 7), _noise(700, 1024, 8), _noise(2048, 900, 9)
+    # gate_min = 0 is v1, bit for bit
+    for img in (small, low, top):
+        assert RT.trace_stat(img, gate_min=0) == RT.trace_stat(img)
+        assert RT.fires(img, -1e9, gate_min=0) == RT.fires(img, -1e9)
+    # v2 gate 1024 <= long side <= 2048
+    below = RT.trace_stat(small, gate_min=1024)
+    assert below == {"s": None, "nyq_min_img_mean": None, "d4_img_mean": None, "long_side": 1023, "gated": True}
+    assert RT.fires(small, -1e9, gate_min=1024) is False and RT.fires(small, -1e9) is True
+    assert RT.trace_stat(low, gate_min=1024) == RT.trace_stat(low)          # 1024 is inside
+    assert RT.trace_stat(top, gate_min=1024) == RT.trace_stat(top)          # 2048 is inside
+    assert RT.trace_stat(_noise(300, 2049), gate_min=1024)["gated"] is True
+    forced = RT.trace_stat(small, force=True, gate_min=1024)
+    assert forced["gated"] is True and forced["s"] == RT.trace_stat(small)["s"]
+    assert RT.outside_gate(1023, 1024) and not RT.outside_gate(1024, 1024) and not RT.outside_gate(2048, 1024)
+    assert RT.outside_gate(2049, 0) and not RT.outside_gate(10, 0)
+
+
+def test_fires_is_strict_and_one_sided():
+    img = _noise(640, 480, 3)
+    s = RT.trace_stat(img)["s"]
+    assert RT.fires(img, s) is False
+    assert RT.fires(img, s - 1e-9) is True
+    assert RT.fires(img, s + 1.0) is False
+
+
+def test_small_image_is_padded_like_wf_r3():
+    img = _noise(200, 150, 5)
+    nyq, d4 = RT.crop_z(img)
+    assert len(nyq) == len(d4) == RT.N_CROPS
+    padded = RT.pad_to(np.asarray(img), RT.CROP)
+    assert padded.shape[:2] == (224, 224)
+    # the statistic of the small image is the statistic of its padded frame
+    assert RT.crop_z(Image.fromarray(padded)) == (nyq, d4)
+
+
+def test_decode_uses_the_evaluator_draft():
+    def jpeg(w, h):
+        b = io.BytesIO()
+        Image.new("RGB", (w, h), (120, 130, 140)).save(b, "JPEG", quality=90)
+        return b.getvalue()
+    assert RT.decode(jpeg(4096, 4096)).size == (2048, 2048)      # both sides >= 2 x 2048: DCT scale 1/2
+    assert RT.decode(jpeg(4000, 3000)).size == (4000, 3000)      # otherwise full size (outside the gate)
+    assert RT.decode(jpeg(1600, 1200)).size == (1600, 1200)
+
+
+def test_constants_match_lattice_features():
+    try:
+        import lattice_features as LF  # service flat layout (needs torch)
+    except Exception as exc:  # noqa: BLE001
+        pytest.skip(f"lattice_features not importable here: {exc}")
+    assert tuple(LF.PHI0) == tuple(RT.PHI0)
+    assert tuple(map(tuple, LF.T_REF)) == tuple(map(tuple, RT.T_REF))
+    assert tuple(LF.CTRL_EPS) == tuple(float(e) for e in RT.CTRL_EPS)
+
+
+def test_fingerprint_pinned():
+    assert RT.statistic_fingerprint() == FINGERPRINT
+    assert (RT.SCALE_NYQ, RT.SCALE_D4, RT.GATE_LONG_SIDE, RT.CROP, RT.N_CROPS) == (1.08, 4.42, 2048, 224, 9)

webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/AntDesign.3f78af31cca60105799838a1a7a59fbd.ttf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:08a9d5b513cf947e22ede81e9a843bd8d7763a63444cd21484bfde7662cc6543
-size 130484

webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome.b06871f281fee6b241d60582ae9369b9.ttf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:aa58f33f239a0fb02f5c7a6c45c043d7a9ac9a093335806694ecd6d4edc0d6a8
-size 165548

webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome5_Brands.3b89dd103490708d19a95adcae52210e.ttf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:06f4d00923ea24697df5df0b92984175991d8bd25776a02d531bb401e393ec42
-size 134040

webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome5_Solid.605ed7926cf39a2ad5ec2d1f9d391d3d.ttf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3d06af1f31cd83ace7a265a014b8fb5dee15770ecac8f7a55555190e627e03c2
-size 202744

webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome6_Brands.56c8d80832e37783f12c05db7c8849e2.ttf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bc844b5b02d3f3adabb514de4e0c0208252d3123413bd03f6287fa446acee859
-size 209376

webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/FontAwesome6_Solid.adec7d6f310bc577f05e8fe06a5daccf.ttf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:31f099c13f6e4ba05f1b471bf170cb5493249474222917372de3ca5cf29e6a1a
-size 423676

webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/Fontisto.b49ae8ab2dbccb02c4d11caaacf09eab.ttf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:94dab9f1d5b13ea0769d124a2da0d02433f3b99d6dea5a07c0446a77158100c0
-size 313528

webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/MaterialCommunityIcons.6e435534bd35da5fef04168860a9b8fa.ttf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:61e8aba5a4e981fe22cf7c8e8bcdbea00476e75c62c37f01bf7ee33361d68428
-size 1307660

webapp/assets/node_modules/@expo/vector-icons/build/vendor/react-native-vector-icons/Fonts/MaterialIcons.4e85bc9ebe07e0340c9c4fc2f6c38908.ttf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ef149f08bdd2ff09a4e2c8573476b7b0f3fbb15b623954ade59899e7175bedda
-size 356840

webapp/index.html

@@ -34,6 +34,11 @@
         height: 100%;
         flex: 1;
       }
+      /* Hangul: break between words, not inside them (the native apps get this from the OS line breaker) */
+      #root {
+        word-break: keep-all;
+        overflow-wrap: anywhere;
+      }
 
       /* Desktop: the app is a phone layout; centre it in a frame instead of stretching it across a monitor. */
       @media (min-width: 768px) {
@@ -58,6 +63,6 @@
     </noscript>
     <!-- The root element for your Expo app. -->
     <div id="root"></div>
-  <script src="/_expo/static/js/web/entry-c72d53cd4e22507b95184fe0159c61c3.js" defer></script>
+  <script src="/_expo/static/js/web/entry-73d73bf1e3d88c923bfb3f7b7cae3866.js" defer></script>
 </body>
 </html>

webapp/legal.css

@@ -0,0 +1,151 @@
+/*
+  Shared stylesheet of the public legal pages (privacy.html, privacy-en.html, support.html).
+
+  Audience: a store reviewer, or someone deciding whether to install - both want to confirm in half a minute what
+  happens to their photo. So the page opens with the path one photo takes (device -> server -> result -> gone) and
+  everything after it is a quiet, left-aligned reading column.
+  Colours are the app tokens from constants/colors.ts and nothing else. The verdict colours (real / uncertain / ai)
+  are deliberately absent: nothing on these pages is a verdict. "Kept" vs "not kept" is said in words and in the
+  line style of the path (solid = travels, dashed = discarded), not in colour.
+  No web fonts, no scripts, no third-party requests: a privacy page should not call anyone.
+*/
+:root {
+  --bg: #FAFAFC;
+  --surface2: #F1F2F7;
+  --fg: #0F172A;
+  --muted: #64748B;
+  --border: #E2E8F0;
+  --border-strong: #CBD5E1;
+  --primary: #5B6BFF;
+  --secondary: #06B6D4;
+  color-scheme: light dark;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #0A0E1A;
+    --surface2: #1F2937;
+    --fg: #F9FAFB;
+    --muted: #9CA3AF;
+    --border: #1E293B;
+    --border-strong: #334155;
+  }
+}
+
+* { box-sizing: border-box; }
+html { -webkit-text-size-adjust: 100%; scroll-behavior: smooth; scroll-padding-top: 24px; }
+@media (prefers-reduced-motion: reduce) { html { scroll-behavior: auto; } }
+body {
+  margin: 0;
+  background: var(--bg);
+  color: var(--fg);
+  font-family: "Pretendard Variable", Pretendard, -apple-system, BlinkMacSystemFont, "Apple SD Gothic Neo",
+    "Noto Sans KR", "Malgun Gothic", "Segoe UI", Roboto, sans-serif;
+  font-size: 17px;
+  line-height: 1.75;
+  word-break: keep-all;       /* Korean breaks between words, not inside them */
+  overflow-wrap: anywhere;
+}
+
+.page { max-width: 1040px; margin: 0 auto; padding: 40px 24px 96px; }
+
+/* ---- top bar */
+.bar { display: flex; align-items: baseline; justify-content: space-between; gap: 16px; }
+.brand { font-weight: 800; letter-spacing: 0.08em; font-size: 0.95rem; text-decoration: none; color: var(--fg); }
+.langs { display: flex; gap: 16px; font-size: 0.9rem; }
+.langs [aria-current="page"] { color: var(--muted); text-decoration: none; }
+
+/* links: text stays in the foreground colour (primary on the light background is 4:1, under AA), the brand
+   colour carries the underline */
+a { color: var(--fg); text-decoration: underline; text-decoration-color: var(--primary);
+    text-decoration-thickness: 2px; text-underline-offset: 4px; }
+a:hover { text-decoration-color: var(--secondary); }
+:focus-visible { outline: 2px solid var(--primary); outline-offset: 3px; border-radius: 2px; }
+
+/* ---- title block */
+h1 { font-size: clamp(2rem, 5.2vw, 3.1rem); line-height: 1.18; letter-spacing: -0.03em; font-weight: 800;
+     margin: 56px 0 12px; max-width: 16em; }
+.lede { font-size: 1.12rem; line-height: 1.7; max-width: 34em; margin: 0 0 8px; }
+.meta { color: var(--muted); font-size: 0.92rem; margin: 0; }
+
+/* ---- the path one photo takes */
+.path { list-style: none; margin: 48px 0 64px; padding: 0; display: grid; grid-template-columns: repeat(4, 1fr);
+        gap: 0; counter-reset: step; }
+.path li { position: relative; padding: 30px 24px 0 0; }
+.path li::before {            /* the line */
+  content: ""; position: absolute; top: 7px; left: 0; right: 0; height: 0;
+  border-top: 2px solid var(--secondary);
+}
+.path li:nth-child(2)::before { border-image: linear-gradient(90deg, var(--secondary), var(--primary)) 1; }
+.path li:nth-child(3)::before { border-top-color: var(--primary); }
+.path li:last-child::before { border-top: 2px dashed var(--border-strong); }   /* discarded: nothing travels on */
+.path li::after {             /* the node */
+  content: ""; position: absolute; top: 0; left: 0; width: 16px; height: 16px; border-radius: 50%;
+  background: var(--bg); border: 2px solid var(--secondary);
+}
+.path li:nth-child(n+3)::after { border-color: var(--primary); }
+.path li:last-child::after { border-color: var(--border-strong); border-style: dashed; }
+.path h2 { font-size: 1.02rem; font-weight: 700; margin: 0 0 4px; letter-spacing: -0.01em; }
+.path p { margin: 0; font-size: 0.92rem; line-height: 1.6; color: var(--muted); }
+.path strong { color: var(--fg); font-weight: 600; }
+
+/* ---- reading layout */
+.layout { display: grid; grid-template-columns: 220px minmax(0, 1fr); gap: 56px; align-items: start; }
+.toc { position: sticky; top: 24px; font-size: 0.9rem; line-height: 1.5; }
+.toc ol { list-style: none; margin: 0; padding: 0; border-left: 1px solid var(--border-strong); }
+.toc li { margin: 0; }
+.toc a { display: block; padding: 6px 0 6px 16px; text-decoration: none; color: var(--muted); margin-left: -1px;
+         border-left: 1px solid transparent; }
+.toc a:hover { color: var(--fg); border-left-color: var(--primary); }
+
+.doc { max-width: 38em; }
+.doc section + section { margin-top: 56px; }
+.doc h2 { font-size: 1.4rem; line-height: 1.35; letter-spacing: -0.02em; font-weight: 700; margin: 0 0 16px; }
+.doc h3 { font-size: 1.02rem; font-weight: 700; margin: 28px 0 8px; }
+.doc p { margin: 0 0 14px; }
+.doc ul { margin: 0 0 14px; padding-left: 1.15em; }
+.doc li { margin-bottom: 6px; }
+.doc li::marker { color: var(--muted); }
+.note { color: var(--muted); font-size: 0.93rem; }
+
+/* ---- tables: rules, not boxes */
+.table-wrap { margin: 20px 0 22px; }
+table { width: 100%; border-collapse: collapse; font-size: 0.93rem; line-height: 1.6; }
+th, td { text-align: left; vertical-align: top; padding: 12px 16px 12px 0; border-bottom: 1px solid var(--border); }
+thead th { font-weight: 600; color: var(--muted); border-bottom: 1px solid var(--border-strong); font-size: 0.86rem; }
+tbody th { font-weight: 600; width: 34%; }
+td:last-child, th:last-child { padding-right: 0; }
+
+.foot { margin-top: 80px; padding-top: 20px; border-top: 1px solid var(--border); color: var(--muted);
+        font-size: 0.88rem; display: flex; flex-wrap: wrap; gap: 8px 24px; }
+
+/* ---- small screens: the path turns into a vertical line, the contents list goes inline, tables stack */
+@media (max-width: 860px) {
+  body { font-size: 16px; }
+  .page { padding: 28px 20px 72px; }
+  h1 { margin-top: 40px; }
+  .layout { grid-template-columns: minmax(0, 1fr); gap: 32px; }
+  .toc { position: static; }
+  .path { grid-template-columns: 1fr; margin: 36px 0 48px; }
+  .path li { padding: 0 0 28px 34px; }
+  .path li:last-child { padding-bottom: 0; }
+  .path li::before { top: 8px; bottom: -8px; left: 7px; right: auto; height: auto; width: 0;
+                     border-top: 0; border-left: 2px solid var(--secondary); border-image: none; }
+  .path li:nth-child(2)::before { border-image: linear-gradient(180deg, var(--secondary), var(--primary)) 1; }
+  .path li:nth-child(3)::before { border-left: 2px dashed var(--border-strong); }
+  .path li:last-child::before { display: none; }
+  .path li::after { top: 4px; }
+
+  table, thead, tbody, tr, th, td { display: block; }
+  thead { position: absolute; width: 1px; height: 1px; overflow: hidden; clip-path: inset(50%); }
+  tr { padding: 14px 0; border-bottom: 1px solid var(--border); }
+  th, td { border: 0; padding: 0; }
+  tbody th { width: auto; margin-bottom: 6px; }
+  td { color: var(--fg); margin-top: 4px; }
+  td::before { content: attr(data-label); display: block; color: var(--muted); font-size: 0.82rem; margin-top: 8px; }
+}
+
+@media print {
+  .toc, .langs { display: none; }
+  .layout { grid-template-columns: 1fr; }
+  body { font-size: 11pt; }
+}

webapp/privacy-en.html

@@ -0,0 +1,216 @@
+<!DOCTYPE html>
+<!-- English version of privacy.html. Same content, same effective date - change both (and constants/legal.ts) together. -->
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>A-EYE Privacy Policy</title>
+  <meta name="description" content="A-EYE sends only the one photo you choose to its analysis server and does not keep it after the analysis. No account, no ad tracking." />
+  <meta name="theme-color" content="#FAFAFC" media="(prefers-color-scheme: light)" />
+  <meta name="theme-color" content="#0A0E1A" media="(prefers-color-scheme: dark)" />
+  <link rel="alternate" hreflang="ko" href="privacy.html" />
+  <link rel="stylesheet" href="legal.css" />
+  <style>body { word-break: normal; }</style>
+</head>
+<body>
+<div class="page">
+  <header class="bar">
+    <a class="brand" href="/">A-EYE</a>
+    <nav class="langs" aria-label="Language">
+      <a href="privacy.html" lang="ko">한국어</a>
+      <a href="privacy-en.html" aria-current="page" lang="en">English</a>
+    </nav>
+  </header>
+
+  <h1>Your photo is on our server only while it is analysed</h1>
+  <p class="lede">This is the privacy policy of A-EYE, a mobile app and web service that estimates whether a photo was generated by AI. It works without an account.</p>
+  <p class="meta">Effective 24 September 2026</p>
+
+  <ol class="path" aria-label="The path one photo takes">
+    <li>
+      <h2>Your device</h2>
+      <p>You pick or take a photo. <strong>Your analysis history is stored on this device only.</strong></p>
+    </li>
+    <li>
+      <h2>Upload</h2>
+      <p>Only the photo you chose travels to the analysis server, over an encrypted connection (HTTPS).</p>
+    </li>
+    <li>
+      <h2>Analysis</h2>
+      <p>The server analyses it in memory and returns the result with a heatmap of suspicious areas.</p>
+    </li>
+    <li>
+      <h2>Discarded</h2>
+      <p>The photo is gone from the server once the result is returned. <strong>What remains is an operational record that cannot reconstruct the photo.</strong></p>
+    </li>
+  </ol>
+
+  <div class="layout">
+    <nav class="toc" aria-label="Contents">
+      <ol>
+        <li><a href="#items">1. What we process, and why</a></li>
+        <li><a href="#retention">2. Retention and deletion</a></li>
+        <li><a href="#training">3. Not used for model training</a></li>
+        <li><a href="#sharing">4. Sharing with third parties</a></li>
+        <li><a href="#transfer">5. Hosting and international transfer</a></li>
+        <li><a href="#rights">6. Your rights</a></li>
+        <li><a href="#permissions">7. App permissions</a></li>
+        <li><a href="#security">8. Security</a></li>
+        <li><a href="#cookies">9. Cookies and automatic collection</a></li>
+        <li><a href="#children">10. Children</a></li>
+        <li><a href="#contact">11. Contact</a></li>
+        <li><a href="#remedy">12. Complaints</a></li>
+        <li><a href="#changes">13. Changes to this policy</a></li>
+      </ol>
+    </nav>
+
+    <main class="doc">
+      <section id="items">
+        <h2>1. What we process, and why</h2>
+        <p>A-EYE processes only the following: what an analysis request needs, and the minimum record required to keep the service running.</p>
+        <div class="table-wrap">
+          <table>
+            <thead>
+              <tr><th scope="col">Data</th><th scope="col">Purpose</th><th scope="col">Retention</th></tr>
+            </thead>
+            <tbody>
+              <tr>
+                <th scope="row">The photo you submit, and its file name</th>
+                <td data-label="Purpose">Estimating whether it is AI-generated; reading provenance information (such as C2PA)</td>
+                <td data-label="Retention">Not retained. Discarded as soon as the result is returned.</td>
+              </tr>
+              <tr>
+                <th scope="row">Operational record — request number, the first 12 characters of the photo file’s hash, image format, dimensions and size, the verdict and scores, processing time</th>
+                <td data-label="Purpose">Troubleshooting and abuse prevention</td>
+                <td data-label="Retention">Exists only in the server’s run-time log and disappears when the server restarts. We do not copy it anywhere else.</td>
+              </tr>
+              <tr>
+                <th scope="row">IP address</th>
+                <td data-label="Purpose">Rate limiting (20 requests a minute, 300 a day)</td>
+                <td data-label="Retention">In server memory only, for at most 24 hours. Never written to disk; cleared when the server restarts.</td>
+              </tr>
+              <tr>
+                <th scope="row">Analysis history, settings, date you accepted the terms</th>
+                <td data-label="Purpose">Showing your history, keeping your settings</td>
+                <td data-label="Retention">Stored on your device only. Never sent to the server.</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+        <p>A photo file can contain metadata (EXIF) such as the camera model, the capture time and sometimes the location, and it travels with the file. The server reads it only to check provenance and does not store it. If you do not want location included, use the option your operating system offers for removing location when you pick a photo, or use a photo without location data.</p>
+        <p>The hash in the operational record is a short fingerprint computed from the photo; it cannot be used to reconstruct the photo or learn what it shows. The record contains no name, account, IP address or file name.</p>
+        <p>A photo may show other people. A-EYE does not identify people in photos or extract facial features; it only computes signals of whether the image was generated.</p>
+        <h3>What we do not collect</h3>
+        <p>Name, email address, phone number, account, advertising identifier, contacts, location permission, microphone. The app contains no advertising or behavioural-analytics SDK.</p>
+      </section>
+
+      <section id="retention">
+        <h2>2. Retention and deletion</h2>
+        <ul>
+          <li>A submitted photo is processed in the analysis server’s memory and discarded as soon as the result is returned. Temporary files that may be created while the request is handled are deleted when the request ends.</li>
+          <li>The operational record and IP addresses are kept as described in the table above.</li>
+          <li>The history on your device stays until you delete it or uninstall the app. Only the latest 100 entries are kept; older ones are removed automatically.</li>
+        </ul>
+      </section>
+
+      <section id="training">
+        <h2>3. Not used for model training</h2>
+        <p>We do not use submitted photos to train or improve AI models. If a future feature (such as reporting a wrong verdict) asks you to share a photo, we will ask for separate consent and revise this policy first.</p>
+      </section>
+
+      <section id="sharing">
+        <h2>4. Sharing with third parties</h2>
+        <p>We do not sell or share your information with third parties. The exception is a lawful request from an authority; even then, all we hold is the operational record described in section 1.</p>
+      </section>
+
+      <section id="transfer">
+        <h2>5. Hosting and international transfer</h2>
+        <p>The analysis server runs on Hugging Face’s cloud service, so a photo you submit is transferred to a server outside Korea.</p>
+        <div class="table-wrap">
+          <table>
+            <tbody>
+              <tr><th scope="row">Recipient</th><td>Hugging Face, SAS (9 rue des Colonnes, 75002 Paris, France) · privacy@huggingface.co</td></tr>
+              <tr><th scope="row">Country</th><td>United States (location of Hugging Face’s servers)</td></tr>
+              <tr><th scope="row">When and how</th><td>When you request an analysis, over an encrypted connection (HTTPS). When you tap the camera or gallery button to start one, and while you wait for the result, the app checks whether the server is up; while the server is still getting ready this repeats every few seconds for up to about four minutes. These checks send no photo, only the connection itself (your IP address).</td></tr>
+              <tr><th scope="row">Data transferred</th><td>The photo file and file name from section 1, and your IP address</td></tr>
+              <tr><th scope="row">Purpose</th><td>Hosting the analysis server (processing on our behalf)</td></tr>
+              <tr><th scope="row">Retention</th><td>As in section 2: the photo is discarded right after the analysis. Access records that Hugging Face keeps in its own infrastructure follow the <a href="https://huggingface.co/privacy">Hugging Face privacy policy</a>.</td></tr>
+              <tr><th scope="row">How to refuse</th><td>Nothing is transferred unless you use the analysis feature (the camera or gallery button). Without it, photos cannot be analysed.</td></tr>
+            </tbody>
+          </table>
+        </div>
+        <p>In the Android app only: when the phone’s DNS (the lookup of internet addresses) cannot find the analysis server’s address or has not answered within 2.5 seconds, the app looks up that one name (wonjun12-aeye-backend.hf.space) with two public DNS services, Cloudflare (1.1.1.1) and Google (8.8.8.8), over an encrypted connection. No photo or history is sent; the two services handle the name looked up and your IP address under their own privacy policies (<a href="https://www.cloudflare.com/privacypolicy/">Cloudflare</a>, <a href="https://developers.google.com/speed/public-dns/privacy">Google</a>).</p>
+      </section>
+
+      <section id="rights">
+        <h2>6. Your rights</h2>
+        <ul>
+          <li>You can delete the history stored on your device at any time: Settings &gt; Delete all history, or uninstall the app (on the web, clear the site data in your browser).</li>
+          <li>The server keeps nothing that identifies you, so in principle there is no personal data to access, correct, delete or restrict. If you still want confirmation, write to the contact in section 11; we answer within 10 days.</li>
+          <li>You may exercise these rights through a legal representative or an authorised agent.</li>
+        </ul>
+      </section>
+
+      <section id="permissions">
+        <h2>7. App permissions</h2>
+        <ul>
+          <li>Camera (optional): used only when you take a photo to analyse. No video or sound is recorded. Without it you can still analyse photos you pick.</li>
+          <li>Picking a photo: the app uses the operating system’s photo picker, which needs no permission. The app never gets access to your whole library, only to the one photo you choose.</li>
+          <li>Saving a result card (iPhone, optional): only when you save the card to Photos with Save Image in the share sheet, iOS asks for permission to add photos. It is an add-only permission; the app never reads your photo library.</li>
+        </ul>
+        <p>A permission is requested only when you use the feature, and you can withdraw it at any time in your device settings.</p>
+      </section>
+
+      <section id="security">
+        <h2>8. Security</h2>
+        <ul>
+          <li>All traffic is encrypted in transit (HTTPS).</li>
+          <li>Uploaded files are validated for type and size, and requests are rate-limited.</li>
+          <li>File names and IP addresses are kept out of the operational record.</li>
+          <li>We ask for as little as possible in the first place: there are no accounts and there is no database.</li>
+        </ul>
+      </section>
+
+      <section id="cookies">
+        <h2>9. Cookies and automatic collection</h2>
+        <p>We use no cookies and no advertising identifiers. The web version keeps your analysis history in browser storage (IndexedDB); it is never sent to the server.</p>
+      </section>
+
+      <section id="children">
+        <h2>10. Children</h2>
+        <p>A-EYE does not knowingly collect personal information from children under 14. Because it takes no account or identifying information, it cannot know a user’s age.</p>
+      </section>
+
+      <section id="contact">
+        <h2>11. Contact</h2>
+        <p>Privacy officer: Wonjun Choi (developer and operator of A-EYE)<br />
+        Email: <a href="mailto:oscar43@naver.com">oscar43@naver.com</a></p>
+        <p class="note">For questions about using the app, see the <a href="support.html">support page</a>.</p>
+      </section>
+
+      <section id="remedy">
+        <h2>12. Complaints</h2>
+        <p>In Korea you can contact the following bodies about a privacy infringement.</p>
+        <ul>
+          <li>KISA Privacy Infringement Report Center — privacy.kisa.or.kr, dial 118</li>
+          <li>Personal Information Dispute Mediation Committee — www.kopico.go.kr, 1833-6972</li>
+          <li>Supreme Prosecutors’ Office, Cyber Investigation — www.spo.go.kr, dial 1301</li>
+          <li>Korean National Police Agency, Cyber Bureau — ecrm.police.go.kr, dial 182</li>
+        </ul>
+      </section>
+
+      <section id="changes">
+        <h2>13. Changes to this policy</h2>
+        <p>This policy applies from 24 September 2026. We announce changes in the app and on this page at least 7 days before they take effect (30 days for changes that materially affect your rights).</p>
+      </section>
+    </main>
+  </div>
+
+  <footer class="foot">
+    <span>A-EYE</span>
+    <a href="support.html">Support</a>
+    <a href="privacy.html" lang="ko">개인정보처리방침 (한국어)</a>
+  </footer>
+</div>
+</body>
+</html>

webapp/privacy.html

@@ -0,0 +1,221 @@
+<!DOCTYPE html>
+<!--
+  Public privacy policy (Korean). This is the URL registered in App Store Connect and Google Play.
+  Same content and date as constants/legal.ts (the in-app version) and privacy-en.html - change all three together.
+  Every statement about the server was checked against 1_deployed_service (main_hybrid._analyze_upload, guards.py):
+  the upload is processed in memory, the log line carries rid / sha256[:12] / format / size / verdict / latency and
+  no file name or IP, and the rate limiter keeps IPs in memory for at most 24 h.
+-->
+<html lang="ko">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>A-EYE 개인정보처리방침</title>
+  <meta name="description" content="A-EYE는 분석할 사진 한 장만 서버로 보내고, 분석이 끝나면 서버에 남기지 않습니다. 회원가입과 광고 추적이 없습니다." />
+  <meta name="theme-color" content="#FAFAFC" media="(prefers-color-scheme: light)" />
+  <meta name="theme-color" content="#0A0E1A" media="(prefers-color-scheme: dark)" />
+  <link rel="alternate" hreflang="en" href="privacy-en.html" />
+  <link rel="stylesheet" href="legal.css" />
+</head>
+<body>
+<div class="page">
+  <header class="bar">
+    <a class="brand" href="/">A-EYE</a>
+    <nav class="langs" aria-label="언어">
+      <a href="privacy.html" aria-current="page" lang="ko">한국어</a>
+      <a href="privacy-en.html" lang="en">English</a>
+    </nav>
+  </header>
+
+  <h1>사진은 분석하는 동안만 서버에 있습니다</h1>
+  <p class="lede">A-EYE 개인정보처리방침입니다. A-EYE는 사진이 AI로 만들어졌을 가능성을 분석하는 모바일 앱과 웹 서비스이며, 회원가입 없이 사용합니다.</p>
+  <p class="meta">시행일 2026년 9월 24일</p>
+
+  <ol class="path" aria-label="사진 한 장이 거치는 길">
+    <li>
+      <h2>내 기기</h2>
+      <p>사진을 고르거나 촬영합니다. <strong>분석 기록은 이 기기에만 저장됩니다.</strong></p>
+    </li>
+    <li>
+      <h2>전송</h2>
+      <p>고른 사진 한 장만 암호화된 통신(HTTPS)으로 분석 서버에 보냅니다.</p>
+    </li>
+    <li>
+      <h2>분석</h2>
+      <p>서버 메모리에서 분석하고 결과와 의심 영역 이미지를 돌려줍니다.</p>
+    </li>
+    <li>
+      <h2>폐기</h2>
+      <p>결과를 돌려준 직후 사진은 서버에서 사라집니다. <strong>남는 것은 사진을 복원할 수 없는 운영 기록뿐입니다.</strong></p>
+    </li>
+  </ol>
+
+  <div class="layout">
+    <nav class="toc" aria-label="목차">
+      <ol>
+        <li><a href="#items">1. 처리하는 정보와 목적</a></li>
+        <li><a href="#retention">2. 보관 기간과 파기</a></li>
+        <li><a href="#training">3. 모델 학습에 쓰지 않습니다</a></li>
+        <li><a href="#sharing">4. 제3자 제공</a></li>
+        <li><a href="#transfer">5. 처리 위탁과 국외 이전</a></li>
+        <li><a href="#rights">6. 이용자의 권리</a></li>
+        <li><a href="#permissions">7. 앱 접근 권한</a></li>
+        <li><a href="#security">8. 안전성 확보 조치</a></li>
+        <li><a href="#cookies">9. 쿠키와 자동 수집</a></li>
+        <li><a href="#children">10. 만 14세 미만 아동</a></li>
+        <li><a href="#contact">11. 보호책임자와 문의</a></li>
+        <li><a href="#remedy">12. 권익 침해 구제</a></li>
+        <li><a href="#changes">13. 방침의 변경</a></li>
+      </ol>
+    </nav>
+
+    <main class="doc">
+      <section id="items">
+        <h2>1. 처리하는 정보와 목적</h2>
+        <p>A-EYE는 아래 정보만 처리합니다. 분석 요청에 꼭 필요한 것과, 서비스를 안정적으로 운영하기 위한 최소한의 기록입니다.</p>
+        <div class="table-wrap">
+          <table>
+            <thead>
+              <tr><th scope="col">항목</th><th scope="col">목적</th><th scope="col">보관</th></tr>
+            </thead>
+            <tbody>
+              <tr>
+                <th scope="row">분석할 사진 파일과 파일명</th>
+                <td data-label="목적">AI 생성 여부 분석, 출처 정보(C2PA 등) 확인</td>
+                <td data-label="보관">보관하지 않습니다. 결과를 돌려준 직후 폐기합니다.</td>
+              </tr>
+              <tr>
+                <th scope="row">운영 기록 — 요청 번호, 사진 파일 해시값의 앞 12자리, 이미지 형식·크기·용량, 판정 결과와 점수, 처리 시간</th>
+                <td data-label="목적">장애 대응, 남용 방지</td>
+                <td data-label="보관">분석 서버의 실행 로그에만 남고 서버가 재시작되면 함께 사라집니다. 다른 곳에 복사해 보관하지 않습니다.</td>
+              </tr>
+              <tr>
+                <th scope="row">접속 IP 주소</th>
+                <td data-label="목적">과도한 요청 차단(분당 20회, 하루 300회)</td>
+                <td data-label="보관">서버 메모리에서만 최대 24시간. 디스크에 기록하지 않으며 서버가 재시작되면 즉시 사라집니다.</td>
+              </tr>
+              <tr>
+                <th scope="row">분석 기록, 설정, 약관 동의 일자</th>
+                <td data-label="목적">기록 보기, 설정 유지</td>
+                <td data-label="보관">이용자의 기기에만 저장합니다. 서버로 전송하지 않습니다.</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+        <p>사진 파일에는 촬영 기기와 일시, 경우에 따라 위치 같은 메타데이터(EXIF)가 들어 있을 수 있고, 파일과 함께 전송됩니다. 서버는 이 정보를 출처 확인에만 읽고 저장하지 않습니다. 위치가 담기는 것을 원하지 않으면 사진을 고를 때 운영체제가 제공하는 위치 정보 제외 옵션을 쓰거나, 위치 정보가 없는 사진을 사용해 주세요.</p>
+        <p>운영 기록의 해시값은 사진에서 계산한 짧은 지문으로, 이것으로 사진을 복원하거나 내용을 알아낼 수 없습니다. 운영 기록에는 이름·계정·IP 주소·파일명이 들어가지 않습니다.</p>
+        <p>사진에 다른 사람의 얼굴 등이 담겨 있을 수 있습니다. A-EYE는 사진 속 인물을 식별하거나 얼굴 특징을 추출하지 않습니다. 이미지가 생성된 것인지에 대한 신호만 계산합니다.</p>
+        <h3>수집하지 않는 것</h3>
+        <p>이름, 이메일, 전화번호, 계정, 광고 식별자, 연락처, 위치 권한, 마이크. 광고나 행동 분석을 위한 외부 SDK를 사용하지 않습니다.</p>
+      </section>
+
+      <section id="retention">
+        <h2>2. 보관 기간과 파기</h2>
+        <ul>
+          <li>전송된 사진은 분석 서버의 메모리에서 처리되고, 결과를 돌려준 직후 폐기됩니다. 요청을 처리하는 동안 만들어질 수 있는 임시 파일도 요청이 끝나면 삭제됩니다.</li>
+          <li>운영 기록과 IP 주소의 보관은 1항의 표와 같습니다.</li>
+          <li>기기에 저장된 분석 기록은 이용자가 지우거나 앱을 삭제할 때까지 남습니다. 최근 100건까지만 보관하고 그보다 오래된 기록은 자동으로 지워집니다.</li>
+        </ul>
+      </section>
+
+      <section id="training">
+        <h2>3. 모델 학습에 쓰지 않습니다</h2>
+        <p>전송된 사진을 AI 모델의 학습이나 개선에 사용하지 않습니다. 앞으로 오판 신고 같은 기능으로 사진을 제공받게 된다면, 그 전에 별도의 동의를 받고 이 방침을 먼저 개정합니다.</p>
+      </section>
+
+      <section id="sharing">
+        <h2>4. 제3자 제공</h2>
+        <p>이용자의 정보를 제3자에게 제공하거나 판매하지 않습니다. 법령에 따라 수사기관 등이 적법한 절차로 요구하는 경우는 예외이며, 그때에도 A-EYE가 가진 것은 1항의 운영 기록뿐입니다.</p>
+      </section>
+
+      <section id="transfer">
+        <h2>5. 처리 위탁과 국외 이전</h2>
+        <p>분석 서버는 Hugging Face의 클라우드 서비스에서 운영됩니다. 그래서 분석을 요청하면 사진이 국외에 있는 서버로 전송됩니다.</p>
+        <div class="table-wrap">
+          <table>
+            <tbody>
+              <tr><th scope="row">이전받는 자</th><td>Hugging Face, SAS (9 rue des Colonnes, 75002 Paris, France) · privacy@huggingface.co</td></tr>
+              <tr><th scope="row">이전되는 국가</th><td>미국 (Hugging Face의 서버 소재지)</td></tr>
+              <tr><th scope="row">일시와 방법</th><td>이용자가 분석을 요청하는 시점에, 암호화된 통신(HTTPS)으로 전송. 분석을 시작하려고 촬영이나 갤러리를 누를 때와 결과를 기다리는 동안에는 서버가 켜져 있는지 확인하기 위해 사진 없이 서버 상태를 조회합니다. 서버가 아직 준비되지 않았으면 준비될 때까지(최대 약 4분) 몇 초 간격으로 반복하며, 이때는 접속 정보만 전달됩니다.</td></tr>
+              <tr><th scope="row">이전 항목</th><td>1항의 사진 파일과 파일명, 접속 IP 주소</td></tr>
+              <tr><th scope="row">목적</th><td>분석 서버 호스팅(서버 운영 위탁)</td></tr>
+              <tr><th scope="row">보유 기간</th><td>2항과 같습니다. 사진은 분석 직후 폐기됩니다. Hugging Face가 자사 인프라에서 남기는 접속 기록은 <a href="https://huggingface.co/privacy">Hugging Face 개인정보처리방침</a>을 따릅니다.</td></tr>
+              <tr><th scope="row">거부 방법</th><td>분석 기능(촬영·갤러리 버튼)을 사용하지 않으면 이전되지 않습니다. 이 경우 사진 분석을 이용할 수 없습니다.</td></tr>
+            </tbody>
+          </table>
+        </div>
+        <p>Android 앱에��는 휴대폰의 DNS(인터넷 주소 조회)가 분석 서버의 주소를 찾지 못하거나 2.5초 안에 답하지 않을 때에만, 분석 서버의 이름(wonjun12-aeye-backend.hf.space) 하나를 공개 DNS 서비스인 Cloudflare(1.1.1.1)와 Google(8.8.8.8)에 암호화된 통신으로 조회합니다. 사진이나 기록은 보내지 않으며, 두 서비스는 조회된 이름과 접속 IP 주소를 각자의 개인정보처리방침(<a href="https://www.cloudflare.com/privacypolicy/">Cloudflare</a>, <a href="https://developers.google.com/speed/public-dns/privacy">Google</a>)에 따라 처리합니다.</p>
+      </section>
+
+      <section id="rights">
+        <h2>6. 이용자의 권리</h2>
+        <ul>
+          <li>기기에 저장된 분석 기록은 설정 &gt; 기록 전체 삭제, 또는 앱 삭제(웹은 브라우저의 사이트 데이터 삭제)로 언제든 지울 수 있습니다.</li>
+          <li>서버에는 이용자를 식별할 수 있는 정보를 보관하지 않으므로 열람·정정·삭제·처리정지를 요청할 개인정보가 원칙적으로 없습니다. 그래도 확인이 필요하면 11항의 문의처로 요청해 주세요. 10일 안에 답변합니다.</li>
+          <li>권리 행사는 법정대리인이나 위임받은 대리인을 통해서도 할 수 있습니다.</li>
+        </ul>
+      </section>
+
+      <section id="permissions">
+        <h2>7. 앱 접근 권한</h2>
+        <ul>
+          <li>카메라(선택): 분석할 사진을 직접 촬영할 때만 사용합니다. 동영상과 소리는 기록하지 않습니다. 허용하지 않아도 사진 선택으로 분석할 수 있습니다.</li>
+          <li>사진 선택: 운영체제의 사진 선택 화면을 사용하므로 별도 권한이 없습니다. 앱은 사진 보관함 전체에 접근하지 않고 이용자가 고른 사진 한 장만 전달받습니다.</li>
+          <li>사진 저장(iPhone, 선택): 결과 카드를 공유 화면의 ‘이미지 저장’으로 사진 앱에 저장할 때만 운영체제가 사진 추가 권한을 묻습니다. 사진을 추가하는 권한이며, 앱은 사진 보관함의 사진을 읽지 않습니다.</li>
+        </ul>
+        <p>권한은 해당 기능을 쓸 때만 요청되며 기기 설정에서 언제든 철회할 수 있습니다.</p>
+      </section>
+
+      <section id="security">
+        <h2>8. 안전성 확보 조치</h2>
+        <ul>
+          <li>모든 전송 구간을 암호화합니다(HTTPS).</li>
+          <li>업로드 파일의 형식과 크기를 검증하고, 요청량을 제한합니다.</li>
+          <li>운영 기록에 파일명과 IP 주소를 남기지 않습니다.</li>
+          <li>처음부터 필요한 최소한의 정보만 받습니다. 계정과 데이터베이스가 없습니다.</li>
+        </ul>
+      </section>
+
+      <section id="cookies">
+        <h2>9. 쿠키와 자동 수집</h2>
+        <p>쿠키와 광고 식별자를 사용하지 않습니다. 웹 버전은 분석 기록을 브라우저 저장소(IndexedDB)에 보관하며, 이 데이터는 서버로 전송되지 않습니다.</p>
+      </section>
+
+      <section id="children">
+        <h2>10. 만 14세 미만 아동</h2>
+        <p>A-EYE는 만 14세 미만 아동의 개인정보를 알면서 수집하지 않습니다. 계정이나 식별 정보를 받지 않으므로 이용자의 나이를 알 수 없습니다.</p>
+      </section>
+
+      <section id="contact">
+        <h2>11. 보호책임자와 문의</h2>
+        <p>개인정보 보호책임자: 최원준 (A-EYE 개발·운영)<br />
+        이메일: <a href="mailto:oscar43@naver.com">oscar43@naver.com</a></p>
+        <p class="note">앱 사용에 관한 문의는 <a href="support.html">지원 페이지</a>를 확인해 주세요.</p>
+      </section>
+
+      <section id="remedy">
+        <h2>12. 권익 침해 구제</h2>
+        <p>개인정보 침해에 대한 상담이나 신고가 필요하면 아래 기관에 문의할 수 있습니다.</p>
+        <ul>
+          <li>개인정보침해신고센터 — privacy.kisa.or.kr, 국번 없이 118</li>
+          <li>개인정보분쟁조정위원회 — www.kopico.go.kr, 1833-6972</li>
+          <li>대검찰청 사이버수사과 — www.spo.go.kr, 국번 없이 1301</li>
+          <li>경찰청 사이버수사국 — ecrm.police.go.kr, 국번 없이 182</li>
+        </ul>
+      </section>
+
+      <section id="changes">
+        <h2>13. 방침의 변경</h2>
+        <p>이 방침은 2026년 9월 24일부터 적용됩니다. 내용이 바뀌면 시행 7일 전부터(이용자 권리에 중요한 변경은 30일 전부터) 앱과 이 페이지에서 알립니다.</p>
+      </section>
+    </main>
+  </div>
+
+  <footer class="foot">
+    <span>A-EYE</span>
+    <a href="support.html">지원</a>
+    <a href="privacy-en.html" lang="en">Privacy Policy (English)</a>
+  </footer>
+</div>
+</body>
+</html>

webapp/support.html

@@ -0,0 +1,98 @@
+<!DOCTYPE html>
+<!-- Support page: the "Support URL" of App Store Connect and the website field of Google Play.
+     Numbers come from 1_deployed_service/guards.py (28 MiB body, JPEG 64 MP / PNG-WebP 32 MP, 20/min 300/day). -->
+<html lang="ko">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>A-EYE 지원</title>
+  <meta name="description" content="A-EYE 사용 중 자주 묻는 질문과 문의 방법." />
+  <meta name="theme-color" content="#FAFAFC" media="(prefers-color-scheme: light)" />
+  <meta name="theme-color" content="#0A0E1A" media="(prefers-color-scheme: dark)" />
+  <link rel="stylesheet" href="legal.css" />
+</head>
+<body>
+<div class="page">
+  <header class="bar">
+    <a class="brand" href="/">A-EYE</a>
+    <nav class="langs" aria-label="바로가기">
+      <a href="#english" lang="en">English</a>
+      <a href="privacy.html">개인정보처리방침</a>
+    </nav>
+  </header>
+
+  <h1>막히는 곳이 있으면 여기서 확인하세요</h1>
+  <p class="lede">A-EYE는 사진 한 장이 AI로 만들어졌을 가능성을 추정하고, 의심되는 영역을 보여 주는 앱입니다. 아래에서 답을 찾지 못하면 메일을 보내 주세요.</p>
+  <p class="meta">문의 <a href="mailto:oscar43@naver.com">oscar43@naver.com</a> · 보통 3일 안에 답변합니다</p>
+
+  <div class="layout" style="margin-top:56px">
+    <nav class="toc" aria-label="목차">
+      <ol>
+        <li><a href="#slow">분석이 오래 걸려요</a></li>
+        <li><a href="#files">어떤 사진을 올릴 수 있나요</a></li>
+        <li><a href="#wrong">결과가 틀린 것 같아요</a></li>
+        <li><a href="#limit">요청이 거절돼요</a></li>
+        <li><a href="#photo">내 사진은 어떻게 되나요</a></li>
+        <li><a href="#history">기록을 지우고 싶어요</a></li>
+        <li><a href="#english">English</a></li>
+      </ol>
+    </nav>
+
+    <main class="doc">
+      <section id="slow">
+        <h2>분석이 오래 걸려요</h2>
+        <p>분석은 보통 10초 안팎에 끝납니다. 오랜만에 분석할 때는 분석 서버를 준비하는 데 1~3분쯤 걸릴 수 있습니다. 기다리는 동안 앱이 ‘분석 서버 준비 중’과 기다린 시간을 보여 주고, 언제든 취소할 수 있습니다. 4분이 지나도 준비되지 않으면 앱이 알려 드리니, 잠시 뒤 다시 시도해 주세요.</p>
+      </section>
+
+      <section id="files">
+        <h2>어떤 사진을 올릴 수 있나요</h2>
+        <ul>
+          <li>JPEG, PNG, WebP를 분석합니다. 아이폰의 HEIC 사진은 앱이 자동으로 JPEG로 바꿔 보냅니다(웹 버전은 JPEG·PNG·WebP만).</li>
+          <li>파일은 약 25MB까지, 해상도는 JPEG 6,400만 화소·PNG/WebP 3,200만 화소까지입니다. 움직이는 이미지는 분석하지 않습니다.</li>
+          <li>가능하면 원본 파일을 그대로 올려 주세요. 메신저로 여러 번 전달됐거나 화면을 캡처한 이미지는 압축과 크기 변경으로 단서가 줄어 결과가 불확실해질 수 있습니다.</li>
+        </ul>
+      </section>
+
+      <section id="wrong">
+        <h2>결과가 틀린 것 같아요</h2>
+        <p>A-EYE의 결과는 통계적 추정입니다. 실제 사진을 AI로, AI 이미지를 실제로 판단할 수 있고, 새로 나온 생성 도구의 이미지일수록 놓치기 쉽습니다. ‘판단 유보’는 어느 쪽이라고 말하기 어렵다는 뜻이며 오류가 아닙니다.</p>
+        <p>법적 증거, 보도, 인사 결정처럼 중요한 판단의 유일한 근거로 쓰지 말고 출처, 촬영 맥락, 메타데이터를 함께 확인해 주세요. 잘못된 결과를 알려 주시면 개선에 참고하겠습니다. 이때 사진을 메일로 보내실지는 직접 결정하실 수 있습니다.</p>
+      </section>
+
+      <section id="limit">
+        <h2>요청이 거절돼요</h2>
+        <p>서비스를 누구나 쓸 수 있게 하려고 요청 수를 제한합니다(분당 20회, 하루 300회). ‘잠시 후 다시 시도’ 안내가 나오면 1분 뒤에 다시 해 보세요. 동시에 요청이 몰리면 대기 후 ‘서버가 바쁩니다’가 나올 수 있습니다.</p>
+      </section>
+
+      <section id="photo">
+        <h2>내 사진은 어떻게 되나요</h2>
+        <p>고른 사진 한 장만 암호화된 통신으로 분석 서버에 전송되고, 결과를 돌려준 직후 서버에서 폐기됩니다. 모델 학습에 쓰지 않습니다. 자세한 내용은 <a href="privacy.html">개인정보처리방침</a>에 있습니다.</p>
+      </section>
+
+      <section id="history">
+        <h2>기록을 지우고 싶어요</h2>
+        <p>설정 &gt; 기록 &gt; 기록 전체 삭제를 누르면 기기에 저장된 분석 기록이 모두 지워집니다. 기록 탭에서 한 건을 길게 누르면 그 기록만 지울 수도 있습니다. 앱을 삭제해도 함께 지워집니다. 기록은 서��에 저장되지 않으므로 따로 삭제를 요청할 필요가 없습니다.</p>
+      </section>
+
+      <section id="english" lang="en" style="word-break:normal">
+        <h2>English</h2>
+        <p>A-EYE estimates whether a photo was generated by AI and highlights suspicious areas. Results are statistical estimates, not proof: do not use them as the only basis for an important decision.</p>
+        <ul>
+          <li>A result usually takes about 10 seconds. The first analysis after a while can take 1–3 minutes while the analysis server gets ready; the app shows how long you have waited and you can cancel at any time.</li>
+          <li>Supported files: JPEG, PNG, WebP (HEIC is converted automatically in the app), up to about 25 MB.</li>
+          <li>Only the photo you choose is uploaded, over HTTPS, and it is discarded as soon as the result is returned. See the <a href="privacy-en.html">privacy policy</a>.</li>
+          <li>Delete your history in 설정 (Settings) &gt; 기록 (History) &gt; 기록 전체 삭제 (Delete all), or one record by long-pressing it in the history tab. It is stored on your device only.</li>
+        </ul>
+        <p>Contact: <a href="mailto:oscar43@naver.com">oscar43@naver.com</a></p>
+      </section>
+    </main>
+  </div>
+
+  <footer class="foot">
+    <span>A-EYE</span>
+    <a href="privacy.html">개인정보처리방침</a>
+    <a href="privacy-en.html" lang="en">Privacy Policy</a>
+  </footer>
+</div>
+</body>
+</html>

zero_shot_v4.py

@@ -3,6 +3,8 @@
 Ported verbatim from the model repo's ``src/models/zero_shot_v4.py``. The only
 change is that ``CLIP_MEAN`` / ``CLIP_STD`` are inlined here instead of importing
 ``src.data.transforms`` (which is not part of the web backend).
+C3 (2026-09-24): ``RadialFFTBranch`` (incl. ``fft_nyquist``) is kept textually identical to the training copy -
+tests/test_fft_nyquist_parity.py checks it.
 
   - frozen CLIP ViT-L/14 intermediate patch tokens (semantic/texture cues)
   - trainable forensic residual CNN (sensor/compression/noise evidence)
@@ -159,17 +161,32 @@ class ForensicResidualBranch(nn.Module):
 
 
 class RadialFFTBranch(nn.Module):
+    """Radial log-magnitude spectrum (bins rings) + a high/low ratio -> MLP.
+
+    fft_nyquist (C3, 2026-09-24; default False = the historic masks, bit for bit): the historic masks clamp the radius
+    to 1.0 and the last ring needs r < 1, so everything at r >= 1 is dropped. The radius grid is linspace(-1, 1, 224),
+    which is not centred on DC (index 112 sits at +0.0045), so r >= 1 is rows/columns 0 AND 223 (index 0 = the
+    Nyquist frequency after fftshift, index 223 = +111/224 cycles, which maps to exactly 1.0) plus the four corners
+    (r up to sqrt 2): 22.2% of the 224x224 spectrum, the highest frequencies, where upsampler / decoder lattices live.
+    With nyquist=True the last ring spans [edges[-2], sqrt 2]
+    (no clamp); rings 0..bins-2 are unchanged, so a warm start from a clamped checkpoint only sees its last input move.
+    The masks are a persistent buffer (checkpoints carry them): a nyquist branch keeps its own masks when a checkpoint
+    made without the flag is loaded into it (warm start from RC1 / best49) - see _load_from_state_dict."""
+
     def __init__(
         self,
         image_size: int = 224,
         bins: int = 48,
         out_dim: int = 192,
         dropout: float = 0.12,
+        nyquist: bool = False,
     ):
         super().__init__()
         self.image_size = int(image_size)
         self.bins = int(bins)
-        masks = self._make_radial_masks(self.image_size, self.bins)
+        self.nyquist = bool(nyquist)
+        self.ignored_checkpoint_masks = False
+        masks = self._make_radial_masks(self.image_size, self.bins, nyquist=self.nyquist)
         self.register_buffer("masks", masks)
         in_dim = 3 * self.bins + 3
         self.mlp = nn.Sequential(
@@ -186,18 +203,47 @@ class RadialFFTBranch(nn.Module):
                 nn.init.zeros_(module.bias)
 
     @staticmethod
-    def _make_radial_masks(size: int, bins: int) -> torch.Tensor:
+    def _make_radial_masks(size: int, bins: int, nyquist: bool = False) -> torch.Tensor:
         axis = torch.linspace(-1.0, 1.0, size)
         yy, xx = torch.meshgrid(axis, axis, indexing="ij")
-        rr = torch.sqrt(xx.square() + yy.square()).clamp(max=1.0)
+        rr = torch.sqrt(xx.square() + yy.square())
+        if not nyquist:
+            rr = rr.clamp(max=1.0)  # historic: r >= 1 (rows/cols 0 and 223 + corners) falls in no ring
         edges = torch.linspace(0.0, 1.0, bins + 1)
         masks = []
         for idx in range(bins):
-            mask = ((rr >= edges[idx]) & (rr < edges[idx + 1])).float()
+            if nyquist and idx == bins - 1:
+                mask = (rr >= edges[idx]).float()  # last ring = [edges[-2], sqrt(2)]
+            else:
+                mask = ((rr >= edges[idx]) & (rr < edges[idx + 1])).float()
             denom = mask.sum().clamp_min(1.0)
             masks.append(mask / denom)
         return torch.stack(masks, dim=0)
 
+    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs):
+        # The ring geometry is a function of the config, not a learned value. A nyquist branch must not be switched back
+        # to the clamped rings by a checkpoint made without the flag (train_v5 warm-starts every run from a source
+        # checkpoint, and load_trainable_state_dict copies every non-CLIP tensor, buffers included). Without the flag
+        # the historic behaviour (masks come from the checkpoint) is untouched - it only SAYS so when the checkpoint's
+        # rings are not the historic ones (a fft_nyquist checkpoint fine-tuned or evaluated without the flag: the run
+        # still computes the nyquist rings, but its saved config would no longer describe them).
+        key = prefix + "masks"
+        if key in state_dict:
+            incoming = state_dict[key]
+            differs = tuple(incoming.shape) == tuple(self.masks.shape) and not torch.equal(
+                incoming.detach().to(device=self.masks.device, dtype=self.masks.dtype), self.masks)
+            if differs and self.nyquist:
+                state_dict[key] = self.masks.detach().clone()
+                if not self.ignored_checkpoint_masks:
+                    print(f"[fft] {key}: checkpoint masks differ from the fft_nyquist rings -> kept the nyquist masks "
+                          f"(warm start from a clamped-ring checkpoint)", flush=True)
+                self.ignored_checkpoint_masks = True
+            elif differs:
+                print(f"[fft] WARNING {key}: the checkpoint carries non-historic rings (a fft_nyquist checkpoint?) and this "
+                      f"model was built without fft_nyquist - they are loaded as they are; set model.fft_nyquist: true",
+                      flush=True)
+        super()._load_from_state_dict(state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs)
+
     def forward(self, raw: torch.Tensor) -> torch.Tensor:
         freq = torch.fft.fftshift(torch.fft.fft2(raw, norm="ortho"), dim=(-2, -1))
         mag = torch.log1p(torch.abs(freq))
@@ -239,9 +285,11 @@ class ZeroShotV4Detector(nn.Module):
         dropout: float = 0.25,
         source_grl_lambda: float = 1.0,
         freeze_clip: bool = True,
+        fft_nyquist: bool = False,
     ):
         super().__init__()
         self.clip_backbone = clip_backbone
+        self.fft_nyquist = bool(fft_nyquist)
         self.is_siglip = clip_backbone in SIGLIP_BACKBONES
         if self.is_siglip:
             if SiglipVisionModel is None:
@@ -285,6 +333,7 @@ class ZeroShotV4Detector(nn.Module):
             bins=fft_bins,
             out_dim=frequency_dim,
             dropout=dropout * 0.5,
+            nyquist=self.fft_nyquist,
         )
 
         self.register_buffer("clip_mean", torch.tensor(CLIP_MEAN).view(1, 3, 1, 1))

zero_shot_v6.py

@@ -23,6 +23,11 @@ Design:
   (`crop_logits` [B,K]) trained with mask-derived crop labels (multiview_dataset crop_labels), and `mil_logit` [B] =
   log-mean-exp over the crops (a smooth max: one tampered crop is enough). `crop_pool="mil"` pools the crops with the
   softmax of those logits, so the fused vector follows the most suspicious crop instead of the average.
++ lattice features (2026-09-26, GPT round 3; checkpoint config model.lattice_features): per crop, the one-sided ChatGPT-
+  renderer lattice statistics of lattice_features.py (a byte-identical copy of the training module) are appended to the
+  per-crop artifact vector before artifact_norm. They are computed in IMAGE coordinates, which travel with the crops as a
+  fourth "geometry plane" channel (crop_geometry.py; main_hybrid._native_crops attaches it for such a checkpoint). Absent =
+  the historic model, bit for bit.
 """
 from __future__ import annotations
 
@@ -33,6 +38,7 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
+from lattice_features import LatticeFeatures, own_frame_geometry, parse_lattice_features, split_geometry  # service copy
 from zero_shot_v4 import AttentionPool, _deep_head, gradient_reverse  # service-local copy (no src package)
 from zero_shot_v5 import ZeroShotV5Detector
 
@@ -58,6 +64,7 @@ class ZeroShotV6Detector(ZeroShotV5Detector):
         semantic_dropout_p: float = 0.0,
         artifact_dropout_p: float = 0.0,
         attribution_classes: int | None = None,
+        lattice_features: dict | None = None,   # GPT round 3: per-crop renderer-lattice statistics (None = historic)
         **v5_kwargs,
     ) -> None:
         # v4 does not keep these as attributes; remember them for the new heads (defaults = v4 defaults)
@@ -65,6 +72,7 @@ class ZeroShotV6Detector(ZeroShotV5Detector):
         self.forensic_dim = int(v5_kwargs.get("forensic_dim", 256))
         self.frequency_dim = int(v5_kwargs.get("frequency_dim", 192))
         self.dropout_p = float(v5_kwargs.get("dropout", 0.25))
+        lattice_spec = parse_lattice_features(lattice_features)  # fail closed on an unknown stat before CLIP loads
         super().__init__(**v5_kwargs)
         self.patch_backbone_name = str(patch_backbone).lower()
         self.n_crops_train = int(n_crops_train)
@@ -91,7 +99,11 @@ class ZeroShotV6Detector(ZeroShotV5Detector):
             self.patch_dim = int(patch_dim)
             self.patch_proj = nn.Sequential(nn.LayerNorm(hidden * 2), nn.Linear(hidden * 2, self.patch_dim), nn.GELU(),
                                             nn.Dropout(self.dropout_p * 0.5))
-        self.artifact_dim = self.patch_dim + self.forensic_dim + self.frequency_dim
+        # lattice features: no parameters (nothing in a state dict); only the widths below change when they are on
+        self.lattice_spec = lattice_spec
+        self.lattice = LatticeFeatures(lattice_spec) if lattice_spec is not None else None
+        self.lattice_dim = self.lattice.out_dim if self.lattice is not None else 0
+        self.artifact_dim = self.patch_dim + self.forensic_dim + self.frequency_dim + self.lattice_dim
         self.artifact_norm = nn.LayerNorm(self.artifact_dim)
         self.crop_pool = AttentionPool(self.artifact_dim) if self.crop_pool_mode == "attention" else None
         self.crop_logit = None
@@ -124,18 +136,25 @@ class ZeroShotV6Detector(ZeroShotV5Detector):
         return torch.cat([out[:, 0], out[:, 1:].mean(dim=1)], dim=1).float()
 
     def artifact_features(self, crops: torch.Tensor) -> torch.Tensor:
-        """crops [B,K,3,H,W] (CLIP-normalised like x) -> pooled artifact vector [B, artifact_dim]."""
+        """crops [B,K,3,H,W] (CLIP-normalised like x; [B,K,4,H,W] with the geometry plane when lattice_features is on)
+        -> pooled artifact vector [B, artifact_dim]."""
         return self._artifact(crops)[0]
 
-    def _artifact(self, crops: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None]:
-        """-> (pooled [B,D], per-crop [B,K,D], per-crop tamper logits [B,K] or None)."""
+    def _artifact(self, crops: torch.Tensor, crop_geom: torch.Tensor | None = None
+                  ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None]:
+        """-> (pooled [B,D], per-crop [B,K,D], per-crop tamper logits [B,K] or None). `crop_geom` [B,K,6] is only used
+        with lattice_features (None = read the geometry plane of `crops`)."""
         b, k = crops.shape[:2]
+        if self.lattice is not None and crop_geom is None:
+            crops, crop_geom = split_geometry(crops)  # raises when the plane is missing: never a crop-coordinate statistic
         flat = crops.flatten(0, 1)
         raw = self._to_raw_rgb(flat)
         parts = []
         if self.patch is not None:
             parts.append(self.patch_proj(self._patch_tokens(raw)))
         parts += [self.forensic_branch(raw), self.frequency_branch(raw)]
+        if self.lattice is not None:
+            parts.append(self.lattice(raw, crop_geom.reshape(b * k, -1)))
         per_crop = self.artifact_norm(torch.cat(parts, dim=1)).view(b, k, -1)
         crop_logits = self.crop_logit(per_crop).squeeze(-1) if self.crop_logit is not None else None
         if self.crop_pool_mode == "mil":
@@ -149,9 +168,12 @@ class ZeroShotV6Detector(ZeroShotV5Detector):
 
     def forward(self, x: torch.Tensor, crops: torch.Tensor | None = None) -> dict[str, torch.Tensor]:
         semantic_raw = self.semantic_features(x)
+        crop_geom = None
         if crops is None:
             crops = x.unsqueeze(1)  # the global view as a single crop (aux batches / callers without crops)
-        artifact_raw, _per_crop, crop_logits = self._artifact(crops)
+            if self.lattice is not None:
+                crop_geom = own_frame_geometry(crops)  # a resized view: its own image (no renderer lattice survives it)
+        artifact_raw, _per_crop, crop_logits = self._artifact(crops, crop_geom)
         semantic, artifact = semantic_raw, artifact_raw
         if self.training and (self.semantic_dropout_p > 0 or self.artifact_dropout_p > 0):
             u = torch.rand(x.shape[0], device=x.device)
@@ -183,6 +205,9 @@ class ZeroShotV6Detector(ZeroShotV5Detector):
     def param_summary(self) -> str:
         total = sum(p.numel() for p in self.parameters())
         trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
+        la = ""  # without lattice features the summary line is the historic one
+        if self.lattice is not None:
+            la = f" lattice={'+'.join(self.lattice.stats)}(clip={self.lattice.clip:g}, {self.lattice.sides}, per crop, image coords)"
         return (f"[ZeroShotV6: {self.clip_backbone} layers={self.clip_layers} + patches={self.patch_backbone_name} "
-                f"pool={self.crop_pool_mode} crops train/eval={self.n_crops_train}/{self.n_crops_eval} adapter={self.clip_adapter}] "
+                f"pool={self.crop_pool_mode} crops train/eval={self.n_crops_train}/{self.n_crops_eval} adapter={self.clip_adapter}{la}] "
                 f"total={total:,} trainable={trainable:,} ({100 * trainable / max(1, total):.2f}%) fused_dim={self.fused_dim}")