Upload agents/optical_agent.py with huggingface_hub

agents/optical_agent.py

@@ -1,583 +1,414 @@
 """
-FORENSIQ — Optical Physics Agent
-Tests violations of lens and optical physics:
-  - Chromatic Aberration analysis (RGB channel misregistration)
-  - Vignetting analysis (cos⁴θ intensity falloff)
-  - Depth-of-Field consistency (expected vs measured blur)
-  - Bokeh microstructure (aperture blade FFT signatures)
+FORENSIQ — Optical Physics Agent  (20 features)
+Tests violations of lens and optical physics.
 """
 
 import numpy as np
 from PIL import Image
-from scipy.ndimage import sobel, gaussian_filter, uniform_filter
-from scipy.signal import find_peaks
+from scipy.ndimage import sobel, gaussian_filter, uniform_filter, label, median_filter, maximum_filter
+from scipy.signal import find_peaks, convolve2d
 from dataclasses import dataclass, field
 from typing import List, Dict, Any, Optional
 
 
 @dataclass
 class AgentEvidence:
-    """Structured evidence output from any forensic agent."""
     agent_name: str
-    violation_score: float  # -1 (authentic) to +1 (fake)
-    confidence: float       # 0 to 1
-    failure_prob: float     # probability this agent's analysis failed
+    violation_score: float
+    confidence: float
+    failure_prob: float
     rationale: str
     sub_findings: List[Dict[str, Any]] = field(default_factory=list)
-    visual_evidence: Optional[Any] = None  # numpy array or PIL image
+    visual_evidence: Optional[Any] = None
 
 
-def _to_gray(img: Image.Image) -> np.ndarray:
-    return np.array(img.convert("L")).astype(np.float64)
+def _g(img): return np.array(img.convert("L")).astype(np.float64)
+def _rgb(img): return np.array(img.convert("RGB")).astype(np.float64)
 
-
-def _to_rgb(img: Image.Image) -> np.ndarray:
-    return np.array(img.convert("RGB")).astype(np.float64)
-
-
-# ─── Chromatic Aberration ────────────────────────────────────────────
-def analyze_chromatic_aberration(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real lenses create slight spatial offsets between R/G/B edges.
-    AI images have perfectly aligned or impossibly misaligned channels.
-    """
-    rgb = _to_rgb(img)
-    r, g, b = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
-
-    # Edge magnitude per channel
+# ── 1. Chromatic Aberration Magnitude ────────────────────────────────
+def f01_ca_magnitude(img: Image.Image) -> Dict[str, Any]:
+    rgb = _rgb(img); r,g,b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
     edges = {}
-    for name, ch in [("R", r), ("G", g), ("B", b)]:
-        ex = sobel(ch, axis=0)
-        ey = sobel(ch, axis=1)
-        edges[name] = np.hypot(ex, ey)
-
-    # Flatten for correlation
-    er, eg, eb = edges["R"].ravel(), edges["G"].ravel(), edges["B"].ravel()
-
-    rg_corr = float(np.corrcoef(er, eg)[0, 1])
-    rb_corr = float(np.corrcoef(er, eb)[0, 1])
-    gb_corr = float(np.corrcoef(eg, eb)[0, 1])
-
-    avg_corr = (rg_corr + rb_corr + gb_corr) / 3.0
-
-    # Natural range: moderate correlation (0.80–0.97)
-    # Too perfect (>0.99) = synthetic; too low (<0.70) = heavy editing
-    if avg_corr > 0.99:
-        score = 0.6
-        note = "Suspiciously perfect channel alignment (no natural CA)"
-    elif avg_corr < 0.70:
-        score = 0.5
-        note = "Abnormally low channel correlation (heavy manipulation)"
-    elif 0.80 <= avg_corr <= 0.97:
-        score = -0.4
-        note = "Natural chromatic aberration pattern detected"
-    else:
-        score = 0.2
-        note = "Borderline chromatic aberration"
-
-    return {
-        "test": "Chromatic Aberration",
-        "rg_correlation": round(rg_corr, 4),
-        "rb_correlation": round(rb_corr, 4),
-        "gb_correlation": round(gb_corr, 4),
-        "avg_correlation": round(avg_corr, 4),
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── Vignetting ─────────────────────────────────────────────────────
-def analyze_vignetting(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real photos show cos⁴(θ) intensity falloff from center.
-    AI images often have flat or unnatural brightness profiles.
-    """
-    gray = _to_gray(img)
-    h, w = gray.shape
-    cy, cx = h / 2, w / 2
-
-    # Radial distance for every pixel
-    Y, X = np.mgrid[0:h, 0:w]
-    R = np.sqrt((X - cx) ** 2 + (Y - cy) ** 2)
-    R_max = np.sqrt(cx ** 2 + cy ** 2)
-    R_norm = R / R_max  # 0 at center, 1 at corner
-
-    # Bin by radial distance and compute mean intensity
-    n_bins = 20
-    bin_edges = np.linspace(0, 1, n_bins + 1)
-    radial_means = []
-    for i in range(n_bins):
-        mask = (R_norm >= bin_edges[i]) & (R_norm < bin_edges[i + 1])
-        if mask.any():
-            radial_means.append(float(np.mean(gray[mask])))
-        else:
-            radial_means.append(0)
-
-    radial_means = np.array(radial_means)
-    if radial_means[0] == 0:
-        radial_means[0] = 1.0
-
-    # Expected cos⁴(θ) model: I ∝ cos⁴(arctan(r/f))
-    # Simplified: intensity should decrease toward edges
-    normalized = radial_means / (radial_means[0] + 1e-9)
-
-    # Fit cos⁴ model
-    r_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
-    theta = np.arctan(r_centers * 1.5)  # ~35° max field angle
-    cos4_model = np.cos(theta) ** 4
-
-    residual = float(np.mean((normalized - cos4_model) ** 2))
-
-    # Monotonic decrease check
-    diffs = np.diff(normalized)
-    non_decreasing_frac = float(np.sum(diffs > 0.02) / len(diffs))
-
-    if residual < 0.01 and non_decreasing_frac < 0.3:
-        score = -0.3
-        note = "Natural vignetting pattern (cos⁴θ consistent)"
-    elif residual > 0.05 or non_decreasing_frac > 0.5:
-        score = 0.4
-        note = "Unnatural brightness profile (vignetting absent or inconsistent)"
-    else:
-        score = 0.1
-        note = "Mild vignetting deviation"
-
-    return {
-        "test": "Vignetting (cos⁴θ)",
-        "cos4_residual": round(residual, 5),
-        "non_decreasing_fraction": round(non_decreasing_frac, 3),
-        "score": score,
-        "note": note,
-        "radial_profile": normalized.tolist(),
-    }
-
-
-# ─── Depth of Field Consistency ─────────────────────────────────────
-def analyze_dof_consistency(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real depth-of-field blur varies smoothly with distance.
-    AI images often have inconsistent blur regions.
-    """
-    gray = _to_gray(img)
-    h, w = gray.shape
-
-    # Local blur estimation via Laplacian variance in blocks
-    block_size = max(h, w) // 16
-    if block_size < 8:
-        block_size = 8
-
-    blur_map = np.zeros((h // block_size, w // block_size))
-    for bi in range(blur_map.shape[0]):
-        for bj in range(blur_map.shape[1]):
-            y0, y1 = bi * block_size, (bi + 1) * block_size
-            x0, x1 = bj * block_size, (bj + 1) * block_size
-            block = gray[y0:y1, x0:x1]
-            # Laplacian variance = sharpness metric
-            lap = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=np.float64)
-            from scipy.signal import convolve2d
-            laplacian = convolve2d(block, lap, mode="valid")
-            blur_map[bi, bj] = float(np.var(laplacian))
-
-    # Smooth blur map
-    if blur_map.size > 1:
-        smooth_blur = gaussian_filter(blur_map, sigma=1.0)
-        # Inconsistency = high-frequency variation in blur map
-        blur_residual = blur_map - smooth_blur
-        inconsistency = float(np.std(blur_residual) / (np.mean(blur_map) + 1e-9))
-    else:
-        inconsistency = 0.0
-
-    if inconsistency < 0.3:
-        score = -0.3
-        note = "Smooth depth-of-field gradient (consistent with real optics)"
-    elif inconsistency > 0.7:
-        score = 0.5
-        note = "Abrupt blur transitions (inconsistent DoF, possible manipulation)"
-    else:
-        score = 0.1
-        note = "Moderate DoF variation"
-
-    return {
-        "test": "Depth-of-Field Consistency",
-        "blur_inconsistency": round(inconsistency, 4),
-        "score": score,
-        "note": note,
-        "blur_map": blur_map,
-    }
-
-
-# ─── Bokeh Microstructure ───────────────────────────────────────────
-def analyze_bokeh(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real bokeh shows aperture blade polygon structure in Fourier domain.
-    AI bokeh is typically smooth circles without blade structure.
-    """
-    gray = _to_gray(img)
-
-    # Find bright point-like regions (potential bokeh)
-    threshold = np.percentile(gray, 97)
-    bright_mask = gray > threshold
-
-    if np.sum(bright_mask) < 100:
-        return {
-            "test": "Bokeh Microstructure",
-            "score": 0.0,
-            "note": "Insufficient bright highlights for bokeh analysis",
-            "bokeh_found": False,
-        }
-
-    # Extract largest bright region
-    from scipy.ndimage import label
-    labeled, n_features = label(bright_mask)
-    if n_features == 0:
-        return {
-            "test": "Bokeh Microstructure",
-            "score": 0.0,
-            "note": "No bokeh regions detected",
-            "bokeh_found": False,
-        }
-
-    # Get largest blob
-    sizes = [np.sum(labeled == i) for i in range(1, n_features + 1)]
-    largest = np.argmax(sizes) + 1
-    blob_mask = labeled == largest
-
-    # Crop around blob
-    ys, xs = np.where(blob_mask)
-    y0, y1, x0, x1 = ys.min(), ys.max(), xs.min(), xs.max()
-    patch = gray[y0:y1 + 1, x0:x1 + 1]
-
-    if patch.shape[0] < 8 or patch.shape[1] < 8:
-        return {
-            "test": "Bokeh Microstructure",
-            "score": 0.0,
-            "note": "Bokeh regions too small for analysis",
-            "bokeh_found": False,
-        }
-
-    # FFT of patch — look for angular structure (blade signatures)
-    fft = np.fft.fft2(patch)
-    fft_shift = np.fft.fftshift(fft)
-    magnitude = np.log(np.abs(fft_shift) + 1)
-
-    # Angular variance in FFT (high = blade structure, low = smooth circle)
-    cy, cx = magnitude.shape[0] // 2, magnitude.shape[1] // 2
-    angles = np.arctan2(
-        np.mgrid[0:magnitude.shape[0], 0:magnitude.shape[1]][0] - cy,
-        np.mgrid[0:magnitude.shape[0], 0:magnitude.shape[1]][1] - cx,
-    )
-    n_angular_bins = 12
-    angular_profile = []
-    for k in range(n_angular_bins):
-        a0 = -np.pi + k * (2 * np.pi / n_angular_bins)
-        a1 = a0 + (2 * np.pi / n_angular_bins)
-        amask = (angles >= a0) & (angles < a1)
-        angular_profile.append(float(np.mean(magnitude[amask])) if amask.any() else 0)
-
-    angular_var = float(np.var(angular_profile))
-
-    if angular_var > 0.1:
-        score = -0.2
-        note = "Aperture blade structure detected in bokeh (consistent with real lens)"
-    else:
-        score = 0.3
-        note = "Smooth circular bokeh without blade structure (possible AI generation)"
-
-    return {
-        "test": "Bokeh Microstructure",
-        "angular_variance": round(angular_var, 4),
-        "score": score,
-        "note": note,
-        "bokeh_found": True,
-    }
-
-
-# ─── Lens Distortion Analysis ────────────────────────────────────────
-def analyze_lens_distortion(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real lenses produce barrel/pincushion distortion following Brown-Conrady model.
-    AI images often have perfectly rectilinear geometry or impossible distortion.
-    """
-    gray = _to_gray(img)
-    h, w = gray.shape
-
-    # Edge detection
-    ex = sobel(gray, axis=1)
-    ey = sobel(gray, axis=0)
-    edge_mag = np.hypot(ex, ey)
-
-    # Threshold strong edges
-    threshold = np.percentile(edge_mag, 90)
-    strong_edges = edge_mag > threshold
+    for n,c in [("R",r),("G",g),("B",b)]:
+        edges[n] = np.hypot(sobel(c,0), sobel(c,1))
+    er,eg,eb = edges["R"].ravel(), edges["G"].ravel(), edges["B"].ravel()
+    step = max(1, len(er)//200000)
+    rg = float(np.corrcoef(er[::step],eg[::step])[0,1])
+    rb = float(np.corrcoef(er[::step],eb[::step])[0,1])
+    gb = float(np.corrcoef(eg[::step],eb[::step])[0,1])
+    avg = (rg+rb+gb)/3
+    if avg > 0.99:   s,n = 0.6, "Perfect channel alignment — no natural CA"
+    elif avg < 0.70:  s,n = 0.5, "Abnormally low channel correlation"
+    elif 0.80<=avg<=0.97: s,n = -0.4, "Natural CA pattern detected"
+    else: s,n = 0.2, "Borderline CA"
+    return {"test":"CA Magnitude","avg_corr":round(avg,4),"score":s,"note":n}
+
+# ── 2. CA Radial Gradient ────────────────────────────────────────────
+def f02_ca_radial(img: Image.Image) -> Dict[str, Any]:
+    rgb = _rgb(img); h,w,_ = rgb.shape; cy,cx = h/2,w/2
+    r,g,b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
+    bs = max(32,min(h,w)//8)
+    Y,X = np.mgrid[0:h,0:w]; R = np.sqrt((X-cx)**2+(Y-cy)**2); Rm = np.sqrt(cx**2+cy**2)
+    cen,edg = [],[]
+    for bi in range(0,h-bs,bs):
+        for bj in range(0,w-bs,bs):
+            ca = (float(np.std(r[bi:bi+bs,bj:bj+bs]-g[bi:bi+bs,bj:bj+bs]))+float(np.std(r[bi:bi+bs,bj:bj+bs]-b[bi:bi+bs,bj:bj+bs])))/2
+            rd = R[bi+bs//2,bj+bs//2]/Rm
+            if rd<0.4: cen.append(ca)
+            elif rd>0.6: edg.append(ca)
+    if cen and edg:
+        ratio = float(np.mean(edg))/(float(np.mean(cen))+1e-9)
+        if ratio>1.15: s,n = -0.3, f"CA increases radially ({ratio:.2f}) — real lens"
+        elif ratio<0.9: s,n = 0.3, f"CA decreases toward edges ({ratio:.2f}) — unnatural"
+        else: s,n = 0.1, f"Flat CA ({ratio:.2f})"
+    else: ratio=1.0; s,n = 0.0, "Insufficient data"
+    return {"test":"CA Radial Gradient","ratio":round(ratio,4),"score":s,"note":n}
+
+# ── 3. Lateral CA (Red-Blue Shift) ───────────────────────────────────
+def f03_lateral_ca(img: Image.Image) -> Dict[str, Any]:
+    rgb = _rgb(img); h,w,_ = rgb.shape
+    r_edge = np.hypot(sobel(rgb[:,:,0],0),sobel(rgb[:,:,0],1))
+    b_edge = np.hypot(sobel(rgb[:,:,2],0),sobel(rgb[:,:,2],1))
+    # Compare edge positions — real lenses shift R and B in opposite radial directions
+    r_centroid_y = float(np.average(np.arange(h), weights=np.sum(r_edge,axis=1)+1e-9))
+    b_centroid_y = float(np.average(np.arange(h), weights=np.sum(b_edge,axis=1)+1e-9))
+    shift = abs(r_centroid_y - b_centroid_y)
+    norm_shift = shift / (h+1e-9)
+    if 0.001 < norm_shift < 0.02: s,n = -0.3, f"Natural lateral CA shift ({norm_shift:.4f})"
+    elif norm_shift < 0.0005: s,n = 0.3, f"Zero lateral CA ({norm_shift:.4f}) — synthetic"
+    elif norm_shift > 0.03: s,n = 0.3, f"Excessive CA shift ({norm_shift:.4f}) — unnatural"
+    else: s,n = 0.0, f"Borderline lateral CA ({norm_shift:.4f})"
+    return {"test":"Lateral CA","shift":round(norm_shift,6),"score":s,"note":n}
+
+# ── 4. Vignetting cos⁴θ ─────────────────────────────────────────────
+def f04_vignetting(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape; cy,cx = h/2,w/2
+    Y,X = np.mgrid[0:h,0:w]; R = np.sqrt((X-cx)**2+(Y-cy)**2); Rm = np.sqrt(cx**2+cy**2)
+    Rn = R/Rm; nbins = 20; be = np.linspace(0,1,nbins+1)
+    rm = np.array([float(np.mean(gray[(Rn>=be[i])&(Rn<be[i+1])])) if np.any((Rn>=be[i])&(Rn<be[i+1])) else 0 for i in range(nbins)])
+    if rm[0]==0: rm[0]=1.0
+    norm = rm/(rm[0]+1e-9)
+    rc = (be[:-1]+be[1:])/2; theta = np.arctan(rc*1.5); cos4 = np.cos(theta)**4
+    res = float(np.mean((norm-cos4)**2))
+    ndf = float(np.sum(np.diff(norm)>0.02)/len(np.diff(norm)))
+    if res<0.01 and ndf<0.3: s,n = -0.3, f"Natural vignetting (cos⁴θ residual={res:.5f})"
+    elif res>0.05 or ndf>0.5: s,n = 0.4, f"Absent/inconsistent vignetting (res={res:.5f})"
+    else: s,n = 0.1, f"Mild vignetting deviation (res={res:.5f})"
+    return {"test":"Vignetting cos⁴θ","residual":round(res,5),"score":s,"note":n}
+
+# ── 5. Vignetting Symmetry ──────────────────────────────────────────
+def f05_vignetting_symmetry(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape
+    q1 = float(np.mean(gray[:h//2,:w//2])); q2 = float(np.mean(gray[:h//2,w//2:]))
+    q3 = float(np.mean(gray[h//2:,:w//2])); q4 = float(np.mean(gray[h//2:,w//2:]))
+    qs = [q1,q2,q3,q4]; std = float(np.std(qs)); mean = float(np.mean(qs))
+    asym = std/(mean+1e-9)
+    if asym < 0.03: s,n = -0.2, f"Symmetric brightness (asym={asym:.4f}) — real optics"
+    elif asym > 0.1: s,n = 0.3, f"Asymmetric brightness (asym={asym:.4f}) — manipulation"
+    else: s,n = 0.0, f"Moderate asymmetry ({asym:.4f})"
+    return {"test":"Vignetting Symmetry","asymmetry":round(asym,4),"score":s,"note":n}
+
+# ── 6. DoF Consistency ───────────────────────────────────────────────
+def f06_dof(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape
+    bs = max(max(h,w)//16, 8)
+    lap = np.array([[0,1,0],[1,-4,1],[0,1,0]], dtype=np.float64)
+    bm = np.zeros((h//bs, w//bs))
+    for bi in range(bm.shape[0]):
+        for bj in range(bm.shape[1]):
+            block = gray[bi*bs:(bi+1)*bs, bj*bs:(bj+1)*bs]
+            bm[bi,bj] = float(np.var(convolve2d(block, lap, mode="valid")))
+    if bm.size>1:
+        sm = gaussian_filter(bm, sigma=1.0); inc = float(np.std(bm-sm)/(np.mean(bm)+1e-9))
+    else: inc = 0.0
+    if inc < 0.3: s,n = -0.3, f"Smooth DoF gradient (inc={inc:.4f})"
+    elif inc > 0.7: s,n = 0.5, f"Abrupt blur transitions (inc={inc:.4f})"
+    else: s,n = 0.1, f"Moderate DoF variation ({inc:.4f})"
+    return {"test":"DoF Consistency","inconsistency":round(inc,4),"score":s,"note":n,"blur_map":bm}
+
+# ── 7. DoF Gradient Direction ────────────────────────────────────────
+def f07_dof_gradient(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape; bs = max(32,max(h,w)//8)
+    lap = np.array([[0,1,0],[1,-4,1],[0,1,0]], dtype=np.float64)
+    sharpness = []
+    for bi in range(0,h-bs,bs):
+        row_sharp = []
+        for bj in range(0,w-bs,bs):
+            block = gray[bi:bi+bs,bj:bj+bs]
+            row_sharp.append(float(np.var(convolve2d(block,lap,mode="valid"))))
+        sharpness.append(row_sharp)
+    if not sharpness: return {"test":"DoF Gradient","score":0.0,"note":"Too small"}
+    sm = np.array(sharpness)
+    # Check if sharpness changes monotonically in some direction (real DoF)
+    row_means = np.mean(sm,axis=1)
+    if len(row_means)>2:
+        diffs = np.diff(row_means)
+        monotonic = float(max(np.sum(diffs>0), np.sum(diffs<0))/len(diffs))
+    else: monotonic = 0.5
+    if monotonic > 0.7: s,n = -0.2, f"Directional DoF gradient (monotonicity={monotonic:.2f})"
+    elif monotonic < 0.4: s,n = 0.2, f"Random sharpness variation ({monotonic:.2f})"
+    else: s,n = 0.0, f"Weak DoF gradient ({monotonic:.2f})"
+    return {"test":"DoF Gradient Direction","monotonicity":round(monotonic,3),"score":s,"note":n}
+
+# ── 8. Bokeh Microstructure ──────────────────────────────────────────
+def f08_bokeh(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); thr = np.percentile(gray,97); bright = gray > thr
+    if np.sum(bright)<100: return {"test":"Bokeh Shape","score":0.0,"note":"No bokeh regions"}
+    labeled, nf = label(bright)
+    if nf==0: return {"test":"Bokeh Shape","score":0.0,"note":"No features"}
+    sizes = [int(np.sum(labeled==i)) for i in range(1,min(nf+1,50))]
+    largest = np.argmax(sizes)+1; ys,xs = np.where(labeled==largest)
+    patch = gray[ys.min():ys.max()+1, xs.min():xs.max()+1]
+    if patch.shape[0]<8 or patch.shape[1]<8: return {"test":"Bokeh Shape","score":0.0,"note":"Too small"}
+    fft = np.fft.fftshift(np.fft.fft2(patch)); mag = np.log(np.abs(fft)+1)
+    cy,cx = mag.shape[0]//2, mag.shape[1]//2
+    angles = np.arctan2(np.mgrid[0:mag.shape[0],0:mag.shape[1]][0]-cy, np.mgrid[0:mag.shape[0],0:mag.shape[1]][1]-cx)
+    ap = [float(np.mean(mag[(angles>=-np.pi+k*2*np.pi/12)&(angles<-np.pi+(k+1)*2*np.pi/12)])) for k in range(12)]
+    av = float(np.var(ap))
+    if av>0.1: s,n = -0.2, f"Aperture blade structure (var={av:.4f})"
+    else: s,n = 0.3, f"Smooth circular bokeh ({av:.4f}) — AI-like"
+    return {"test":"Bokeh Shape","angular_var":round(av,4),"score":s,"note":n}
+
+# ── 9. Bokeh Chromatic ───────────────────────────────────────────────
+def f09_bokeh_chromatic(img: Image.Image) -> Dict[str, Any]:
+    rgb = _rgb(img); gray = np.mean(rgb,axis=-1)
+    thr = np.percentile(gray,97); bright = gray > thr
+    if np.sum(bright)<50: return {"test":"Bokeh Chromatic","score":0.0,"note":"No highlights"}
+    r_bright = float(np.mean(rgb[:,:,0][bright]))
+    g_bright = float(np.mean(rgb[:,:,1][bright]))
+    b_bright = float(np.mean(rgb[:,:,2][bright]))
+    # Real bokeh: slight color fringing at edges of highlights
+    color_spread = float(np.std([r_bright,g_bright,b_bright]))/(float(np.mean([r_bright,g_bright,b_bright]))+1e-9)
+    if 0.01 < color_spread < 0.08: s,n = -0.2, f"Natural bokeh color fringing ({color_spread:.4f})"
+    elif color_spread < 0.005: s,n = 0.2, f"No chromatic bokeh ({color_spread:.4f})"
+    else: s,n = 0.0, f"Bokeh chromatic spread={color_spread:.4f}"
+    return {"test":"Bokeh Chromatic","spread":round(color_spread,4),"score":s,"note":n}
+
+# ── 10. Lens Distortion ─────────────────────────────────────────────
+def f10_distortion(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape
+    em = np.hypot(sobel(gray,1),sobel(gray,0)); thr = np.percentile(em,90); se = em>thr
+    cy,cx = h/2,w/2; Y,X = np.mgrid[0:h,0:w]; R = np.sqrt((X-cx)**2+(Y-cy)**2); Rm = np.sqrt(cx**2+cy**2); Rn=R/Rm
+    ie = float(np.mean(se[Rn<0.3])); oe = float(np.mean(se[Rn>=0.7]))
+    ratio = oe/(ie+1e-9)
+    if 0.5<ratio<0.9: s,n = -0.3, f"Peripheral edge softening ({ratio:.3f}) — lens distortion"
+    elif ratio>0.95: s,n = 0.3, f"Uniform edges ({ratio:.3f}) — no distortion"
+    else: s,n = 0.1, f"Edge ratio={ratio:.3f}"
+    return {"test":"Lens Distortion","ratio":round(ratio,4),"score":s,"note":n}
+
+# ── 11. Field Curvature ─────────────────────────────────────────────
+def f11_field_curvature(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape; bs = max(32,min(h,w)//8)
+    lap = np.array([[0,1,0],[1,-4,1],[0,1,0]],dtype=np.float64)
+    cy,cx = h/2,w/2; Y,X = np.mgrid[0:h,0:w]; R = np.sqrt((X-cx)**2+(Y-cy)**2)
+    Rm = np.sqrt(cx**2+cy**2)
+    center_sharp, mid_sharp, edge_sharp = [],[],[]
+    for bi in range(0,h-bs,bs):
+        for bj in range(0,w-bs,bs):
+            block = gray[bi:bi+bs,bj:bj+bs]
+            sh = float(np.var(convolve2d(block,lap,mode="valid")))
+            rd = R[bi+bs//2,bj+bs//2]/Rm
+            if rd<0.3: center_sharp.append(sh)
+            elif rd<0.6: mid_sharp.append(sh)
+            else: edge_sharp.append(sh)
+    if center_sharp and edge_sharp:
+        c = float(np.mean(center_sharp)); e = float(np.mean(edge_sharp))
+        m = float(np.mean(mid_sharp)) if mid_sharp else (c+e)/2
+        # Field curvature: mid-field sharper or softer than expected linear falloff
+        expected_mid = (c+e)/2; curvature = abs(m-expected_mid)/(c+1e-9)
+        if curvature > 0.1: s,n = -0.2, f"Field curvature detected ({curvature:.3f}) — real lens"
+        elif curvature < 0.02: s,n = 0.2, f"No field curvature ({curvature:.3f})"
+        else: s,n = 0.0, f"Mild curvature ({curvature:.3f})"
+    else: curvature=0; s,n = 0.0, "Insufficient data"
+    return {"test":"Field Curvature","curvature":round(curvature,4),"score":s,"note":n}
+
+# ── 12. MTF (Modulation Transfer Function) ──────────────────────────
+def f12_mtf(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape
+    fft = np.abs(np.fft.fftshift(np.fft.fft2(gray)))
+    cy,cx = h//2,w//2
+    # Radial average of MTF
+    Y,X = np.mgrid[0:h,0:w]; R = np.sqrt((X-cx)**2+(Y-cy)**2).astype(int)
+    maxr = min(cy,cx); rp = np.zeros(maxr)
+    for r in range(maxr):
+        m = R==r
+        if m.any(): rp[r] = float(np.mean(fft[m]))
+    rp = rp/(rp[0]+1e-9)
+    # Real lenses: smooth MTF rolloff. AI: sharper cutoff or unusual bumps
+    if len(rp)>20:
+        smooth = gaussian_filter(rp,sigma=3); roughness = float(np.mean(np.abs(rp-smooth)))
+        half_idx = np.argmax(rp<0.5) if np.any(rp<0.5) else len(rp)
+        mtf50 = float(half_idx/maxr)
+    else: roughness=0; mtf50=0.5
+    if roughness < 0.02 and 0.1<mtf50<0.6: s,n = -0.2, f"Natural MTF rolloff (MTF50={mtf50:.3f})"
+    elif roughness > 0.05: s,n = 0.3, f"Irregular MTF ({roughness:.4f}) — AI artifacts"
+    else: s,n = 0.0, f"MTF50={mtf50:.3f}, roughness={roughness:.4f}"
+    return {"test":"MTF Analysis","mtf50":round(mtf50,4),"roughness":round(roughness,4),"score":s,"note":n}
+
+# ── 13. Specular Reflection Consistency ──────────────────────────────
+def f13_specular(img: Image.Image) -> Dict[str, Any]:
+    rgb = _rgb(img); gray = np.mean(rgb,axis=-1)
+    thr = np.percentile(gray,98); hmask = gray>thr
+    maxc = np.max(rgb,axis=-1); minc = np.min(rgb,axis=-1)
+    sat = (maxc-minc)/(maxc+1e-9)
+    spec = hmask & (sat<0.2); ns = int(np.sum(spec))
+    if ns<50: return {"test":"Specular Consistency","score":0.0,"note":"Few highlights"}
+    labeled,nf = label(spec)
+    if nf>0:
+        sizes = [int(np.sum(labeled==i)) for i in range(1,min(nf+1,100))]
+        cv = float(np.std(sizes))/(float(np.mean(sizes))+1e-9)
+    else: cv=0
+    if cv>1.0: s,n = -0.2, f"Varied highlight sizes (CV={cv:.2f}) — natural"
+    elif cv<0.3 and nf>3: s,n = 0.3, f"Uniform highlights (CV={cv:.2f})"
+    else: s,n = 0.0, f"Specular CV={cv:.2f}"
+    return {"test":"Specular Consistency","cv":round(cv,3),"count":nf,"score":s,"note":n}
+
+# ── 14. Specular Color Temperature ───────────────────────────────────
+def f14_specular_color(img: Image.Image) -> Dict[str, Any]:
+    rgb = _rgb(img); gray = np.mean(rgb,axis=-1)
+    thr = np.percentile(gray,99); hmask = gray>thr
+    if np.sum(hmask)<20: return {"test":"Specular Color Temp","score":0.0,"note":"Few highlights"}
+    r_mean = float(np.mean(rgb[:,:,0][hmask])); b_mean = float(np.mean(rgb[:,:,2][hmask]))
+    rb_ratio = r_mean/(b_mean+1e-9)
+    # Real light: highlights should reflect light source color consistently
+    # Multiple light sources = multiple highlight colors (OK)
+    # Uniform white = typical for AI
+    highlight_pixels = rgb[hmask]; color_std = float(np.std(highlight_pixels))
+    if color_std > 15: s,n = -0.2, f"Varied highlight colors (std={color_std:.1f}) — real"
+    elif color_std < 3: s,n = 0.3, f"Uniform white highlights (std={color_std:.1f})"
+    else: s,n = 0.0, f"Highlight color std={color_std:.1f}"
+    return {"test":"Specular Color Temp","color_std":round(color_std,2),"score":s,"note":n}
+
+# ── 15. Purple Fringing ──────────────────────────────────────────────
+def f15_purple_fringing(img: Image.Image) -> Dict[str, Any]:
+    rgb = _rgb(img); gray = np.mean(rgb,axis=-1)
+    edge = np.hypot(sobel(gray,0),sobel(gray,1)); emask = edge>np.percentile(edge,95)
+    r,g,b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
+    purple = (r+b-2*g)/(r+g+b+1e-9); ep = purple[emask]
+    if len(ep)<100: return {"test":"Purple Fringing","score":0.0,"note":"Few edges"}
+    pf = float(np.mean(ep>0.1))
+    if pf>0.05: s,n = -0.3, f"Purple fringing at {pf:.1%} of edges — real lens"
+    elif pf<0.01: s,n = 0.2, f"No fringing ({pf:.3f})"
+    else: s,n = 0.0, f"Minimal fringing ({pf:.3f})"
+    return {"test":"Purple Fringing","fraction":round(pf,4),"score":s,"note":n}
+
+# ── 16. Lens Flare Physics ──────────────────────────────────────────
+def f16_lens_flare(img: Image.Image) -> Dict[str, Any]:
+    rgb = _rgb(img); gray = np.mean(rgb,axis=-1); h,w = gray.shape
+    # Detect bright saturated blobs (potential flare)
+    sat_mask = gray > 250
+    if np.sum(sat_mask) < 20: return {"test":"Lens Flare","score":0.0,"note":"No saturated regions"}
+    labeled,nf = label(sat_mask)
+    if nf<2: return {"test":"Lens Flare","score":0.0,"note":"Insufficient flare candidates"}
+    # Real lens flare: blobs aligned on a line through center
+    centroids = []
+    for i in range(1,min(nf+1,20)):
+        ys,xs = np.where(labeled==i)
+        centroids.append((float(np.mean(ys)), float(np.mean(xs))))
+    if len(centroids)>=3:
+        # Check collinearity
+        pts = np.array(centroids); pts_c = pts - pts.mean(axis=0)
+        if pts_c.shape[0]>1:
+            _,s,_ = np.linalg.svd(pts_c); linearity = float(s[0]/(s[1]+1e-9))
+        else: linearity=1
+        if linearity>5: sc,nt = -0.2, f"Aligned flare elements (linearity={linearity:.1f}) — real"
+        else: sc,nt = 0.1, f"Scattered bright blobs ({linearity:.1f})"
+    else: sc,nt = 0.0, f"Few candidates ({len(centroids)})"
+    return {"test":"Lens Flare","score":sc,"note":nt}
+
+# ── 17. Radial Sharpness Falloff ────────────────────────────────────
+def f17_sharpness_falloff(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape
+    em = np.hypot(sobel(gray,0),sobel(gray,1))
+    cy,cx = h/2,w/2; Y,X = np.mgrid[0:h,0:w]; R = np.sqrt((X-cx)**2+(Y-cy)**2)
+    Rm = np.sqrt(cx**2+cy**2); Rn = R/Rm
+    bins = 10; be = np.linspace(0,1,bins+1)
+    rs = [float(np.mean(em[(Rn>=be[i])&(Rn<be[i+1])])) if np.any((Rn>=be[i])&(Rn<be[i+1])) else 0 for i in range(bins)]
+    rs = np.array(rs); rs = rs/(rs[0]+1e-9)
+    # Expect monotonic decrease
+    mono = float(np.sum(np.diff(rs)<0)/(len(rs)-1+1e-9))
+    if mono>0.7: s,n = -0.2, f"Natural sharpness falloff (monotonicity={mono:.2f})"
+    elif mono<0.4: s,n = 0.3, f"Random sharpness profile ({mono:.2f})"
+    else: s,n = 0.0, f"Moderate falloff ({mono:.2f})"
+    return {"test":"Sharpness Falloff","monotonicity":round(mono,3),"score":s,"note":n}
+
+# ── 18. Diffraction Limit Check ─────────────────────────────────────
+def f18_diffraction(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape
+    fft = np.abs(np.fft.fftshift(np.fft.fft2(gray)))
+    # Check for sharp high-frequency cutoff (diffraction-limited lens)
+    cy,cx = h//2,w//2; maxr = min(cy,cx)
+    Y,X = np.mgrid[0:h,0:w]; R = np.sqrt((X-cx)**2+(Y-cy)**2).astype(int)
+    rp = np.zeros(maxr)
+    for r in range(maxr):
+        m = R==r
+        if m.any(): rp[r] = float(np.mean(fft[m]))
+    rp_log = np.log(rp+1); rp_log = rp_log/(rp_log[0]+1e-9) if rp_log[0]>0 else rp_log
+    # Check slope at high freq
+    if maxr>20:
+        hf = rp_log[maxr*3//4:]; slope = float(np.mean(np.diff(hf)))
+        if slope < -0.01: s,n = -0.2, f"Sharp HF cutoff (slope={slope:.4f}) — diffraction limited"
+        elif abs(slope) < 0.001: s,n = 0.2, f"Flat HF spectrum ({slope:.4f}) — unusual"
+        else: s,n = 0.0, f"HF slope={slope:.4f}"
+    else: s,n = 0.0, "Image too small"
+    return {"test":"Diffraction Limit","score":s,"note":n}
+
+# ── 19. Geometric Distortion Pattern ────────────────────────────────
+def f19_geometric_distortion(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape
+    # Horizontal and vertical edge orientation distribution
+    gx = sobel(gray,axis=1); gy = sobel(gray,axis=0)
+    mag = np.hypot(gx,gy); strong = mag > np.percentile(mag,80)
+    angles = np.arctan2(gy[strong],gx[strong])
+    # Real images have dominant H/V edges; distortion bends them
+    hist,_ = np.histogram(angles, bins=36, range=(-np.pi,np.pi))
+    hist = hist.astype(float); hist /= (hist.sum()+1e-9)
+    # Check for peaks at 0, ±π/2
+    hv_energy = float(hist[0]+hist[9]+hist[18]+hist[27])/(hist.sum()+1e-9)
+    entropy_val = -float(np.sum(hist*np.log(hist+1e-9)))
+    if hv_energy > 0.3: s,n = -0.2, f"Strong H/V edge dominance ({hv_energy:.2f})"
+    elif entropy_val > 3.5: s,n = 0.2, f"Isotropic edges (entropy={entropy_val:.2f}) — unusual"
+    else: s,n = 0.0, f"Edge orientation entropy={entropy_val:.2f}"
+    return {"test":"Geometric Distortion","hv_energy":round(hv_energy,3),"score":s,"note":n}
+
+# ── 20. Optical Center Estimation ────────────────────────────────────
+def f20_optical_center(img: Image.Image) -> Dict[str, Any]:
+    gray = _g(img); h,w = gray.shape
+    # Estimate optical center from vignetting gradient
+    smoothed = gaussian_filter(gray, sigma=max(h,w)//10)
+    # Find brightest point (should be near geometric center for real cameras)
+    y_max, x_max = np.unravel_index(np.argmax(smoothed), smoothed.shape)
+    cy, cx = h/2, w/2
+    offset_y = abs(y_max - cy)/(h+1e-9); offset_x = abs(x_max - cx)/(w+1e-9)
+    offset = np.sqrt(offset_y**2 + offset_x**2)
+    if offset < 0.1: s,n = -0.2, f"Optical center near image center (offset={offset:.3f})"
+    elif offset < 0.25: s,n = 0.0, f"Slight optical center offset ({offset:.3f})"
+    else: s,n = 0.2, f"Optical center far from center ({offset:.3f})"
+    return {"test":"Optical Center","offset":round(offset,4),"score":s,"note":n}
+
+
+# ═══ MAIN ENTRY ══════════════════════════════════════════════════════
+ALL_TESTS = [f01_ca_magnitude,f02_ca_radial,f03_lateral_ca,f04_vignetting,
+             f05_vignetting_symmetry,f06_dof,f07_dof_gradient,f08_bokeh,
+             f09_bokeh_chromatic,f10_distortion,f11_field_curvature,f12_mtf,
+             f13_specular,f14_specular_color,f15_purple_fringing,f16_lens_flare,
+             f17_sharpness_falloff,f18_diffraction,f19_geometric_distortion,f20_optical_center]
 
-    # Analyze edge straightness in radial bands
-    cy, cx = h / 2, w / 2
-    Y, X = np.mgrid[0:h, 0:w]
-    R = np.sqrt((X - cx) ** 2 + (Y - cy) ** 2)
-    R_max = np.sqrt(cx ** 2 + cy ** 2)
-    R_norm = R / R_max
-
-    # Compare edge density at different radial distances
-    inner_edges = float(np.mean(strong_edges[R_norm < 0.3]))
-    mid_edges = float(np.mean(strong_edges[(R_norm >= 0.3) & (R_norm < 0.7)]))
-    outer_edges = float(np.mean(strong_edges[R_norm >= 0.7]))
-
-    # Real lenses: edges slightly softer at corners due to distortion
-    # AI: uniform edge sharpness across frame
-    edge_ratio = outer_edges / (inner_edges + 1e-9)
-
-    if 0.5 < edge_ratio < 0.9:
-        score = -0.3
-        note = f"Natural edge falloff at periphery (ratio={edge_ratio:.3f}, lens distortion present)"
-    elif edge_ratio > 0.95:
-        score = 0.3
-        note = f"Unnaturally uniform edges across frame (ratio={edge_ratio:.3f}, no lens distortion)"
-    else:
-        score = 0.1
-        note = f"Edge distribution ratio={edge_ratio:.3f}"
-
-    return {
-        "test": "Lens Distortion",
-        "edge_ratio_outer_inner": round(edge_ratio, 4),
-        "inner_edge_density": round(inner_edges, 4),
-        "outer_edge_density": round(outer_edges, 4),
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── CA Radial Pattern Analysis ─────────────────────────────────────
-def analyze_ca_radial_pattern(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real chromatic aberration increases radially from center (more at corners).
-    AI images have spatially uniform or random channel misregistration.
-    """
-    rgb = _to_rgb(img)
-    h, w, _ = rgb.shape
-    cy, cx = h / 2, w / 2
-
-    r, g, b = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
-
-    # Compute local channel difference in blocks
-    block_size = max(32, min(h, w) // 8)
-    center_diffs = []
-    edge_diffs = []
-
-    Y, X = np.mgrid[0:h, 0:w]
-    R = np.sqrt((X - cx) ** 2 + (Y - cy) ** 2)
-    R_max = np.sqrt(cx ** 2 + cy ** 2)
-
-    for bi in range(0, h - block_size, block_size):
-        for bj in range(0, w - block_size, block_size):
-            block_r = r[bi:bi + block_size, bj:bj + block_size]
-            block_g = g[bi:bi + block_size, bj:bj + block_size]
-            block_b = b[bi:bi + block_size, bj:bj + block_size]
-
-            # Local RG difference as proxy for CA
-            rg_diff = float(np.std(block_r - block_g))
-            rb_diff = float(np.std(block_r - block_b))
-            ca_magnitude = (rg_diff + rb_diff) / 2
-
-            block_center_r = R[bi + block_size // 2, bj + block_size // 2] / R_max
-
-            if block_center_r < 0.4:
-                center_diffs.append(ca_magnitude)
-            elif block_center_r > 0.6:
-                edge_diffs.append(ca_magnitude)
-
-    if center_diffs and edge_diffs:
-        center_ca = float(np.mean(center_diffs))
-        edge_ca = float(np.mean(edge_diffs))
-        ca_increase = edge_ca / (center_ca + 1e-9)
-
-        # Real lenses: CA increases toward edges (ratio > 1.1)
-        if ca_increase > 1.15:
-            score = -0.3
-            note = f"CA increases radially (edge/center={ca_increase:.2f}, natural lens behavior)"
-        elif ca_increase < 0.9:
-            score = 0.3
-            note = f"CA decreases toward edges (ratio={ca_increase:.2f}, unnatural)"
-        else:
-            score = 0.1
-            note = f"Flat CA distribution (ratio={ca_increase:.2f})"
-    else:
-        ca_increase = 1.0
-        score = 0.0
-        note = "Insufficient data for radial CA analysis"
-
-    return {
-        "test": "CA Radial Pattern",
-        "ca_edge_center_ratio": round(ca_increase, 4),
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── Specular Reflection Map ────────────────────────────────────────
-def analyze_specular_reflections(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real specular reflections follow Phong/Blinn-Phong model with
-    consistent highlight shapes. AI often has inconsistent specularity.
-    """
-    rgb = _to_rgb(img)
-    gray = np.mean(rgb, axis=-1)
-
-    # Detect specular highlights (very bright, near-white pixels)
-    highlight_threshold = np.percentile(gray, 98)
-    highlight_mask = gray > highlight_threshold
-
-    # Compute saturation (low saturation = specular)
-    max_c = np.max(rgb, axis=-1)
-    min_c = np.min(rgb, axis=-1)
-    saturation = (max_c - min_c) / (max_c + 1e-9)
-
-    specular_mask = highlight_mask & (saturation < 0.2)
-    n_specular = int(np.sum(specular_mask))
-    specular_fraction = float(n_specular / (gray.size + 1e-9))
-
-    if n_specular < 50:
-        return {
-            "test": "Specular Reflections",
-            "score": 0.0,
-            "note": "Insufficient specular highlights for analysis",
-            "specular_count": n_specular,
-        }
-
-    # Check if specular highlights are compact (real) vs diffuse (AI)
-    from scipy.ndimage import label
-    labeled, n_features = label(specular_mask)
-    if n_features > 0:
-        sizes = [int(np.sum(labeled == i)) for i in range(1, min(n_features + 1, 100))]
-        avg_size = float(np.mean(sizes))
-        size_std = float(np.std(sizes))
-        size_cv = size_std / (avg_size + 1e-9)  # coefficient of variation
-    else:
-        size_cv = 0.0
-        avg_size = 0.0
-
-    # Real highlights: varied sizes (large CV), AI: uniform sizes
-    if size_cv > 1.0:
-        score = -0.2
-        note = f"Varied specular highlight sizes (CV={size_cv:.2f}, natural)"
-    elif size_cv < 0.3 and n_features > 3:
-        score = 0.3
-        note = f"Suspiciously uniform highlight sizes (CV={size_cv:.2f})"
-    else:
-        score = 0.0
-        note = f"Specular analysis neutral (CV={size_cv:.2f})"
-
-    return {
-        "test": "Specular Reflections",
-        "specular_count": n_specular,
-        "n_highlights": n_features,
-        "size_cv": round(size_cv, 4),
-        "avg_size": round(avg_size, 2),
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── Purple Fringing Detection ──────────────────────────────────────
-def analyze_purple_fringing(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real cameras exhibit purple/magenta fringing at high-contrast edges
-    due to chromatic aberration. AI images rarely reproduce this artifact.
-    """
-    rgb = _to_rgb(img)
-    gray = np.mean(rgb, axis=-1)
-
-    # Find high-contrast edges
-    edge = np.hypot(sobel(gray, axis=0), sobel(gray, axis=1))
-    edge_mask = edge > np.percentile(edge, 95)
-
-    # Check for purple/magenta hue at edges
-    r, g, b = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
-
-    # Purple = high R, low G, high B
-    purple_score_map = (r + b - 2 * g) / (r + g + b + 1e-9)
-    edge_purple = purple_score_map[edge_mask]
-
-    if len(edge_purple) < 100:
-        return {
-            "test": "Purple Fringing",
-            "score": 0.0,
-            "note": "Insufficient high-contrast edges for fringing analysis",
-        }
-
-    mean_purple = float(np.mean(edge_purple))
-    purple_fraction = float(np.mean(edge_purple > 0.1))
-
-    if purple_fraction > 0.05:
-        score = -0.3
-        note = f"Purple fringing detected at {purple_fraction:.1%} of edges (real lens artifact)"
-    elif purple_fraction < 0.01 and mean_purple < 0.02:
-        score = 0.2
-        note = "No purple fringing (uncommon in real photography, possible AI)"
-    else:
-        score = 0.0
-        note = f"Minimal fringing (fraction={purple_fraction:.3f})"
-
-    return {
-        "test": "Purple Fringing",
-        "purple_fraction": round(purple_fraction, 4),
-        "mean_purple_score": round(mean_purple, 4),
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── Main Agent Entry Point ─────────────────────────────────────────
 def run_optical_agent(img: Image.Image) -> AgentEvidence:
-    """Run all optical physics tests and produce structured evidence."""
-    findings = []
-    scores = []
-
-    tests = [
-        analyze_chromatic_aberration,
-        analyze_vignetting,
-        analyze_dof_consistency,
-        analyze_bokeh,
-        analyze_lens_distortion,
-        analyze_ca_radial_pattern,
-        analyze_specular_reflections,
-        analyze_purple_fringing,
-    ]
-
-    for fn in tests:
+    findings, scores = [], []
+    for fn in ALL_TESTS:
         try:
-            result = fn(img)
-            findings.append(result)
-            scores.append(result["score"])
+            r = fn(img); findings.append(r); scores.append(r["score"])
         except Exception as e:
-            findings.append({"test": fn.__name__, "error": str(e), "score": 0})
-
-    if scores:
-        avg_score = float(np.mean(scores))
-        confidence = min(1.0, 0.5 + 0.5 * abs(avg_score))
-    else:
-        avg_score = 0.0
-        confidence = 0.1
-
-    # Build rationale
-    violations = [f["test"] for f in findings if f.get("score", 0) > 0.2]
-    compliant = [f["test"] for f in findings if f.get("score", 0) < -0.1]
-
-    if violations:
-        rationale = f"Optical violations detected in: {', '.join(violations)}."
-    elif compliant:
-        rationale = f"Optical physics consistent: {', '.join(compliant)}."
-    else:
-        rationale = "Optical analysis inconclusive."
-
+            findings.append({"test":fn.__name__,"error":str(e),"score":0})
+    avg = float(np.mean(scores)) if scores else 0.0
+    conf = min(1.0, 0.5+0.5*abs(avg))
+    viol = [f["test"] for f in findings if f.get("score",0)>0.2]
+    comp = [f["test"] for f in findings if f.get("score",0)<-0.1]
+    if viol: rat = f"Optical violations: {', '.join(viol)}."
+    elif comp: rat = f"Optical physics consistent: {', '.join(comp)}."
+    else: rat = "Optical analysis inconclusive."
     for f in findings:
-        if f.get("note"):
-            rationale += f" [{f['test']}]: {f['note']}."
-
-    return AgentEvidence(
-        agent_name="Optical Physics Agent",
-        violation_score=np.clip(avg_score, -1, 1),
-        confidence=confidence,
-        failure_prob=max(0.0, 1.0 - len(scores) / len(tests)),
-        rationale=rationale,
-        sub_findings=findings,
-    )
+        if f.get("note"): rat += f" [{f['test']}]: {f['note']}."
+    return AgentEvidence("Optical Physics Agent", np.clip(avg,-1,1), conf,
+                         max(0.0,1.0-len(scores)/len(ALL_TESTS)), rat, findings)