Upload agents/model_agent.py with huggingface_hub

agents/model_agent.py

@@ -1,360 +1,252 @@
-"""
-FORENSIQ — Generative Model Agent
-Detects architecture-specific signatures:
-  - Frequency grid artifacts (8×8, 16×16 periodic patterns from GANs)
-  - Diffusion residuals (spectral notches at step noise harmonics)
-  - Model fingerprinting (frequency-domain generator attribution)
-"""
-
+"""FORENSIQ — Generative Model Agent (15 features)"""
 import numpy as np
 from PIL import Image
 from scipy.signal import find_peaks
-from scipy.ndimage import gaussian_filter
+from scipy.ndimage import gaussian_filter, label
 from typing import Dict, Any
-
 from agents.optical_agent import AgentEvidence
 
-
-# ─── Frequency Grid Artifacts ────────────────────────────────────────
-def analyze_frequency_grid(img: Image.Image) -> Dict[str, Any]:
-    """
-    GAN upsampling (deconv layers) creates periodic grid patterns 
-    visible in 2D FFT as spectral peaks at multiples of 8×8 or 16×16.
-    """
-    gray = np.array(img.convert("L")).astype(np.float64)
-    h, w = gray.shape
-
-    # 2D FFT
-    fft = np.fft.fft2(gray)
-    fft_shift = np.fft.fftshift(fft)
-    magnitude = np.log(np.abs(fft_shift) + 1)
-
-    # Center row/column profiles
-    cy, cx = h // 2, w // 2
-    row_profile = magnitude[cy, :]
-    col_profile = magnitude[:, cx]
-
-    # Find periodic peaks (GAN artifacts show at multiples of N/8, N/16)
-    row_peaks, row_props = find_peaks(row_profile, distance=5, prominence=0.3)
-    col_peaks, col_props = find_peaks(col_profile, distance=5, prominence=0.3)
-
-    # Check for regular spacing (grid artifact signature)
-    def check_periodic(peaks, size):
-        if len(peaks) < 3:
-            return 0.0, []
-        spacings = np.diff(sorted(peaks))
-        # Expected spacing for 8×8 grid: size/8
-        expected_8 = size / 8
-        expected_16 = size / 16
-        matches_8 = np.sum(np.abs(spacings - expected_8) < expected_8 * 0.15)
-        matches_16 = np.sum(np.abs(spacings - expected_16) < expected_16 * 0.15)
-        best = max(matches_8, matches_16)
-        return float(best / max(len(spacings), 1)), spacings.tolist()
-
-    row_periodic, row_spacings = check_periodic(row_peaks, w)
-    col_periodic, col_spacings = check_periodic(col_peaks, h)
-    grid_score = (row_periodic + col_periodic) / 2
-
-    # High-frequency vs mid-frequency energy ratio
-    hf_ring = magnitude.copy()
-    hf_ring[cy - h // 8:cy + h // 8, cx - w // 8:cx + w // 8] = 0
-    hf_energy = float(np.mean(hf_ring))
-    mf_mask = np.zeros_like(magnitude)
-    mf_mask[cy - h // 4:cy + h // 4, cx - w // 4:cx + w // 4] = 1
-    mf_mask[cy - h // 8:cy + h // 8, cx - w // 8:cx + w // 8] = 0
-    mf_energy = float(np.mean(magnitude * mf_mask))
-
-    if grid_score > 0.4:
-        score = 0.7
-        note = f"Periodic grid artifacts detected (GAN signature, periodicity={grid_score:.2f})"
-    elif grid_score > 0.2:
-        score = 0.3
-        note = f"Weak periodic patterns (possible GAN artifacts, periodicity={grid_score:.2f})"
-    else:
-        score = -0.2
-        note = "No periodic grid artifacts (natural frequency spectrum)"
-
-    return {
-        "test": "Frequency Grid Artifacts",
-        "grid_periodicity_score": round(grid_score, 4),
-        "row_peaks": len(row_peaks),
-        "col_peaks": len(col_peaks),
-        "hf_energy": round(hf_energy, 4),
-        "mf_energy": round(mf_energy, 4),
-        "score": score,
-        "note": note,
-        "magnitude_spectrum": magnitude,
-    }
-
-
-# ─── Diffusion Residuals ────────────────────────────────────────────
-def analyze_diffusion_residuals(img: Image.Image) -> Dict[str, Any]:
-    """
-    Diffusion models leave characteristic spectral notches and
-    autocorrelation patterns from the denoising step schedule.
-    """
-    gray = np.array(img.convert("L")).astype(np.float64)
-
-    # Compute radial power spectrum
-    fft = np.fft.fft2(gray)
-    fft_shift = np.fft.fftshift(fft)
-    power = np.abs(fft_shift) ** 2
-
-    h, w = power.shape
-    cy, cx = h // 2, w // 2
-    Y, X = np.mgrid[0:h, 0:w]
-    R = np.sqrt((X - cx) ** 2 + (Y - cy) ** 2).astype(int)
-
-    # Radially averaged power spectrum
-    max_r = min(cy, cx)
-    radial_power = np.zeros(max_r)
-    counts = np.zeros(max_r)
-    for r in range(max_r):
-        mask = R == r
-        if mask.any():
-            radial_power[r] = np.mean(power[mask])
-            counts[r] = np.sum(mask)
-
-    radial_power = np.log(radial_power + 1)
-
-    # Natural images: power ∝ 1/f² → linear decrease in log-log
-    freqs = np.arange(1, max_r)
-    log_freqs = np.log(freqs + 1)
-    log_power = radial_power[1:max_r]
-
-    # Fit linear model (1/f² slope)
-    if len(log_freqs) > 10:
-        coeffs = np.polyfit(log_freqs, log_power, 1)
-        fitted = np.polyval(coeffs, log_freqs)
-        residuals = log_power - fitted
-
-        # Diffusion models: spectral notches (negative dips in residuals)
-        notches, _ = find_peaks(-residuals, prominence=0.5)
-        
-        # Smoothness of spectral rolloff
-        smoothness = float(np.std(residuals))
-        slope = float(coeffs[0])
-    else:
-        notches = []
-        smoothness = 1.0
-        slope = 0.0
-
-    # Natural 1/f² slope is ~ -2 in log-log
-    slope_deviation = abs(slope - (-2.0))
-
-    if len(notches) > 3:
-        score = 0.5
-        note = f"Spectral notches detected ({len(notches)} notches, diffusion signature)"
-    elif smoothness > 1.0 or slope_deviation > 1.5:
-        score = 0.3
-        note = f"Unnatural spectral rolloff (slope={slope:.2f}, deviation={slope_deviation:.2f})"
-    elif smoothness < 0.5 and slope_deviation < 0.5:
-        score = -0.3
-        note = f"Natural 1/f² spectral profile (slope={slope:.2f})"
-    else:
-        score = 0.1
-        note = f"Mild spectral deviation (slope={slope:.2f})"
-
-    return {
-        "test": "Diffusion Residuals",
-        "spectral_notches": len(notches),
-        "spectral_smoothness": round(smoothness, 4),
-        "slope": round(slope, 4),
-        "slope_deviation": round(slope_deviation, 4),
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── Model Fingerprinting ───────────────────────────────────────────
-def analyze_model_fingerprint(img: Image.Image) -> Dict[str, Any]:
-    """
-    Different generators leave unique frequency-domain signatures.
-    Analyzes autocorrelation and spectral texture for attribution.
-    """
-    gray = np.array(img.convert("L")).astype(np.float64)
-
-    # Autocorrelation map
-    fft = np.fft.fft2(gray)
-    power = np.abs(fft) ** 2
-    autocorr = np.real(np.fft.ifft2(power))
-    autocorr = np.fft.fftshift(autocorr)
-    autocorr = autocorr / (autocorr.max() + 1e-9)
-
-    h, w = autocorr.shape
-    cy, cx = h // 2, w // 2
-
-    # Check for periodic peaks in autocorrelation (GAN checkerboard)
-    # Exclude center peak
-    autocorr_masked = autocorr.copy()
-    r_exclude = max(h, w) // 20
-    Y, X = np.mgrid[0:h, 0:w]
-    center_mask = ((X - cx) ** 2 + (Y - cy) ** 2) < r_exclude ** 2
-    autocorr_masked[center_mask] = 0
-
-    max_secondary = float(np.max(autocorr_masked))
-    
-    # High secondary peak = repetitive structure (GAN artifact)
-    if max_secondary > 0.3:
-        score = 0.6
-        note = f"Strong autocorrelation secondary peak ({max_secondary:.3f}) — GAN checkerboard pattern"
-    elif max_secondary > 0.15:
-        score = 0.3
-        note = f"Moderate autocorrelation peak ({max_secondary:.3f}) — possible generator artifacts"
-    else:
-        score = -0.2
-        note = f"Natural autocorrelation structure (peak={max_secondary:.3f})"
-
-    return {
-        "test": "Model Fingerprinting",
-        "max_secondary_peak": round(max_secondary, 4),
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── GAN Upsampling Checkerboard ─────────────────────────────────────
-def analyze_upsampling_checkerboard(img: Image.Image) -> Dict[str, Any]:
-    """
-    Transposed convolutions in GANs create checkerboard patterns.
-    Detected via pixel-level autocorrelation at lag=2.
-    """
-    gray = np.array(img.convert("L")).astype(np.float64)
-    h, w = gray.shape
-
-    # Compute autocorrelation at lag 2 (checkerboard period)
-    if h < 10 or w < 10:
-        return {"test": "Upsampling Checkerboard", "score": 0.0, "note": "Image too small"}
-
-    # Horizontal lag-2 autocorrelation
-    h_auto = float(np.corrcoef(gray[:, :-2].ravel(), gray[:, 2:].ravel())[0, 1])
-    # Vertical lag-2
-    v_auto = float(np.corrcoef(gray[:-2, :].ravel(), gray[2:, :].ravel())[0, 1])
-
-    # Compare lag-1 vs lag-2 (checkerboard: lag-2 > lag-1)
-    h_auto1 = float(np.corrcoef(gray[:, :-1].ravel(), gray[:, 1:].ravel())[0, 1])
-    v_auto1 = float(np.corrcoef(gray[:-1, :].ravel(), gray[1:, :].ravel())[0, 1])
-
-    # Checkerboard signature: lag-2 corr noticeably higher than lag-1
-    h_checker = h_auto - h_auto1
-    v_checker = v_auto - v_auto1
-    checker_score = (h_checker + v_checker) / 2
-
-    if checker_score > 0.02:
-        score = 0.5
-        note = f"Checkerboard pattern detected (Δcorr={checker_score:.4f}, GAN upsampling artifact)"
-    elif checker_score > 0.005:
-        score = 0.2
-        note = f"Mild checkerboard tendency (Δcorr={checker_score:.4f})"
-    else:
-        score = -0.1
-        note = f"No checkerboard pattern (Δcorr={checker_score:.4f})"
-
-    return {
-        "test": "Upsampling Checkerboard",
-        "checker_delta": round(checker_score, 6),
-        "h_lag2": round(h_auto, 4),
-        "v_lag2": round(v_auto, 4),
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── VAE Boundary Artifacts ─────────────────────────────────────────
-def analyze_vae_boundaries(img: Image.Image) -> Dict[str, Any]:
-    """
-    VAE-based generators (Stable Diffusion) process in latent patches.
-    This can create subtle boundary artifacts at 64x64 or 32x32 grid.
-    """
-    gray = np.array(img.convert("L")).astype(np.float64)
-    h, w = gray.shape
-
-    # Check for grid artifacts at common VAE patch sizes
-    best_score = 0.0
-    best_size = 0
-    best_ratio = 1.0
-
-    for patch_size in [32, 64, 128]:
-        if h < patch_size * 2 or w < patch_size * 2:
-            continue
-
-        h_crop = (h // patch_size) * patch_size
-        w_crop = (w // patch_size) * patch_size
-        g = gray[:h_crop, :w_crop]
-
-        # Measure intensity discontinuity at patch boundaries
-        boundary_diffs = []
-        interior_diffs = []
-
-        for i in range(1, h_crop):
-            row_diff = np.abs(g[i, :] - g[i - 1, :])
-            if i % patch_size == 0:
-                boundary_diffs.append(float(np.mean(row_diff)))
-            elif i % patch_size != 1:
-                interior_diffs.append(float(np.mean(row_diff)))
-
-        if boundary_diffs and interior_diffs:
-            ratio = float(np.mean(boundary_diffs)) / (float(np.mean(interior_diffs)) + 1e-9)
-            if ratio > best_ratio:
-                best_ratio = ratio
-                best_size = patch_size
-
-    if best_ratio > 1.3:
-        score = 0.4
-        note = f"VAE boundary artifacts at {best_size}px grid (ratio={best_ratio:.3f})"
-    elif best_ratio > 1.1:
-        score = 0.2
-        note = f"Weak boundary artifacts at {best_size}px (ratio={best_ratio:.3f})"
-    else:
-        score = -0.1
-        note = f"No VAE boundary artifacts (max ratio={best_ratio:.3f})"
-
-    return {
-        "test": "VAE Boundary Artifacts",
-        "best_boundary_ratio": round(best_ratio, 4),
-        "best_patch_size": best_size,
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── Main Agent Entry Point ─────────────────────────────────────────
-def run_model_agent(img: Image.Image) -> AgentEvidence:
-    """Run all generative model detection tests."""
-    findings = []
-    scores = []
-
-    for fn in [analyze_frequency_grid, analyze_diffusion_residuals, analyze_model_fingerprint,
-               analyze_upsampling_checkerboard, analyze_vae_boundaries]:
-        try:
-            result = fn(img)
-            findings.append(result)
-            scores.append(result["score"])
-        except Exception as e:
-            findings.append({"test": fn.__name__, "error": str(e), "score": 0})
-
-    avg_score = float(np.mean(scores)) if scores else 0.0
-    confidence = min(1.0, 0.5 + 0.5 * abs(avg_score))
-
-    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"Generative model signatures detected: {', '.join(violations)}."
-    elif compliant:
-        rationale = f"No generator artifacts found: {', '.join(compliant)}."
-    else:
-        rationale = "Generator analysis inconclusive."
-
+def _g(img): return np.array(img.convert("L")).astype(np.float64)
+
+def m01_fft_grid_8x8(img):
+    gray=_g(img); h,w=gray.shape; fft=np.fft.fftshift(np.fft.fft2(gray)); mag=np.log(np.abs(fft)+1)
+    cy,cx=h//2,w//2; rp=mag[cy,:]; cp=mag[:,cx]
+    rpeaks,_=find_peaks(rp,distance=5,prominence=0.3); cpeaks,_=find_peaks(cp,distance=5,prominence=0.3)
+    def check(peaks,sz):
+        if len(peaks)<3: return 0.0
+        sp=np.diff(sorted(peaks)); e8=sz/8; e16=sz/16
+        m8=np.sum(np.abs(sp-e8)<e8*0.15); m16=np.sum(np.abs(sp-e16)<e16*0.15)
+        return float(max(m8,m16)/max(len(sp),1))
+    gs=(check(rpeaks,w)+check(cpeaks,h))/2
+    if gs>0.4: s,n=0.7,f"8×8 grid artifacts (periodicity={gs:.2f})"
+    elif gs>0.2: s,n=0.3,f"Weak grid patterns ({gs:.2f})"
+    else: s,n=-0.2,"No grid artifacts"
+    return {"test":"FFT Grid 8×8","periodicity":round(gs,4),"score":s,"note":n,"magnitude_spectrum":mag}
+
+def m02_fft_grid_16x16(img):
+    gray=_g(img); h,w=gray.shape; fft=np.fft.fftshift(np.fft.fft2(gray)); mag=np.log(np.abs(fft)+1)
+    cy,cx=h//2,w//2
+    # Check specifically for 16×16 period
+    e16_h,e16_w=h//16,w//16
+    peaks_h=[mag[cy,cx+k*e16_w] if cx+k*e16_w<w else 0 for k in range(1,8)]
+    peaks_v=[mag[cy+k*e16_h,cx] if cy+k*e16_h<h else 0 for k in range(1,8)]
+    avg_peak=(float(np.mean(peaks_h))+float(np.mean(peaks_v)))/2
+    bg=float(np.median(mag))
+    ratio=avg_peak/(bg+1e-9)
+    if ratio>1.5: s,n=0.5,f"16×16 spectral peaks (ratio={ratio:.2f})"
+    elif ratio>1.2: s,n=0.2,f"Mild 16×16 peaks ({ratio:.2f})"
+    else: s,n=-0.1,f"No 16×16 artifacts ({ratio:.2f})"
+    return {"test":"FFT Grid 16×16","peak_ratio":round(ratio,3),"score":s,"note":n}
+
+def m03_spectral_slope(img):
+    gray=_g(img); h,w=gray.shape; fft=np.fft.fftshift(np.fft.fft2(gray)); power=np.abs(fft)**2
+    cy,cx=h//2,w//2; 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(power[m]))
+    rp=np.log(rp+1); freqs=np.arange(1,maxr); lf=np.log(freqs+1); lp=rp[1:maxr]
+    if len(lf)>10:
+        c=np.polyfit(lf,lp,1); slope=float(c[0]); dev=abs(slope-(-2.0))
+    else: slope=0; dev=2
+    if dev<0.5: s,n=-0.3,f"Natural 1/f² slope ({slope:.2f})"
+    elif dev>1.5: s,n=0.3,f"Unnatural spectral slope ({slope:.2f})"
+    else: s,n=0.1,f"Slope deviation={dev:.2f}"
+    return {"test":"Spectral Slope 1/f²","slope":round(slope,3),"score":s,"note":n}
+
+def m04_diffusion_notches(img):
+    gray=_g(img); fft=np.fft.fftshift(np.fft.fft2(gray)); power=np.abs(fft)**2
+    h,w=power.shape; cy,cx=h//2,w//2; 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(power[m]))
+    rp=np.log(rp+1)
+    if len(rp)>20:
+        c=np.polyfit(np.log(np.arange(1,maxr)+1),rp[1:maxr],1); fitted=np.polyval(c,np.log(np.arange(1,maxr)+1))
+        res=rp[1:maxr]-fitted; notches,_=find_peaks(-res,prominence=0.5); nn=len(notches)
+    else: nn=0
+    if nn>3: s,n=0.5,f"{nn} spectral notches — diffusion signature"
+    elif nn>1: s,n=0.2,f"{nn} notches"
+    else: s,n=-0.1,"No diffusion notches"
+    return {"test":"Diffusion Notches","count":nn,"score":s,"note":n}
+
+def m05_autocorrelation(img):
+    gray=_g(img); fft=np.fft.fft2(gray); power=np.abs(fft)**2
+    ac=np.real(np.fft.ifft2(power)); ac=np.fft.fftshift(ac); ac=ac/(ac.max()+1e-9)
+    h,w=ac.shape; cy,cx=h//2,w//2; acm=ac.copy()
+    re=max(h,w)//20; Y,X=np.mgrid[0:h,0:w]; cm=((X-cx)**2+(Y-cy)**2)<re**2; acm[cm]=0
+    ms=float(np.max(acm))
+    if ms>0.3: s,n=0.6,f"Strong secondary peak ({ms:.3f}) — GAN checkerboard"
+    elif ms>0.15: s,n=0.3,f"Moderate peak ({ms:.3f})"
+    else: s,n=-0.2,f"Natural autocorrelation ({ms:.3f})"
+    return {"test":"Autocorrelation Peak","max_secondary":round(ms,4),"score":s,"note":n}
+
+def m06_checkerboard(img):
+    gray=_g(img); h,w=gray.shape
+    if h<10 or w<10: return {"test":"Checkerboard Pattern","score":0.0,"note":"Too small"}
+    ha=float(np.corrcoef(gray[:,:-2].ravel()[::100],gray[:,2:].ravel()[::100])[0,1])
+    va=float(np.corrcoef(gray[:-2,:].ravel()[::100],gray[2:,:].ravel()[::100])[0,1])
+    h1=float(np.corrcoef(gray[:,:-1].ravel()[::100],gray[:,1:].ravel()[::100])[0,1])
+    v1=float(np.corrcoef(gray[:-1,:].ravel()[::100],gray[1:,:].ravel()[::100])[0,1])
+    delta=((ha-h1)+(va-v1))/2
+    if delta>0.02: s,n=0.5,f"Checkerboard detected (Δ={delta:.4f})"
+    elif delta>0.005: s,n=0.2,f"Mild checkerboard ({delta:.4f})"
+    else: s,n=-0.1,f"No checkerboard ({delta:.4f})"
+    return {"test":"Checkerboard Pattern","delta":round(delta,6),"score":s,"note":n}
+
+def m07_vae_boundaries(img):
+    gray=_g(img); h,w=gray.shape; best_r,best_s=1.0,0
+    for ps in [32,64,128]:
+        if h<ps*2 or w<ps*2: continue
+        hc,wc=(h//ps)*ps,(w//ps)*ps; g=gray[:hc,:wc]
+        bd,it=[],[]
+        for i in range(1,hc):
+            rd=np.abs(g[i,:]-g[i-1,:])
+            if i%ps==0: bd.append(float(np.mean(rd)))
+            elif i%ps!=1: it.append(float(np.mean(rd)))
+        if bd and it:
+            r=float(np.mean(bd))/(float(np.mean(it))+1e-9)
+            if r>best_r: best_r=r; best_s=ps
+    if best_r>1.3: s,n=0.4,f"VAE boundaries at {best_s}px ({best_r:.3f})"
+    elif best_r>1.1: s,n=0.2,f"Weak boundaries ({best_r:.3f})"
+    else: s,n=-0.1,f"No VAE boundaries ({best_r:.3f})"
+    return {"test":"VAE Patch Boundaries","ratio":round(best_r,4),"score":s,"note":n}
+
+def m08_spectral_symmetry(img):
+    gray=_g(img); fft=np.fft.fftshift(np.fft.fft2(gray)); mag=np.log(np.abs(fft)+1)
+    h,w=mag.shape; cy,cx=h//2,w//2
+    top=mag[:cy,:]; bot=np.flipud(mag[cy+1:,:])
+    left=mag[:,:cx]; right=np.fliplr(mag[:,cx+1:])
+    mh,mw=min(top.shape[0],bot.shape[0]),min(top.shape[1],bot.shape[1])
+    asym_tb=float(np.mean(np.abs(top[:mh,:mw]-bot[:mh,:mw])))
+    mh2,mw2=min(left.shape[0],right.shape[0]),min(left.shape[1],right.shape[1])
+    asym_lr=float(np.mean(np.abs(left[:mh2,:mw2]-right[:mh2,:mw2])))
+    asym=(asym_tb+asym_lr)/2
+    if asym<0.1: s,n=-0.1,f"Symmetric spectrum ({asym:.3f})"
+    elif asym>0.5: s,n=0.3,f"Asymmetric spectrum ({asym:.3f})"
+    else: s,n=0.0,f"Spectral asymmetry={asym:.3f}"
+    return {"test":"Spectral Symmetry","asymmetry":round(asym,4),"score":s,"note":n}
+
+def m09_upsampling_stride(img):
+    gray=_g(img); h,w=gray.shape
+    # Check for stride-2 upsampling artifacts
+    even=gray[::2,::2]; odd=gray[1::2,1::2]
+    mh,mw=min(even.shape[0],odd.shape[0]),min(even.shape[1],odd.shape[1])
+    diff=float(np.mean(np.abs(even[:mh,:mw]-odd[:mh,:mw])))
+    mean_val=float(np.mean(gray))
+    norm_diff=diff/(mean_val+1e-9)
+    if norm_diff>0.1: s,n=-0.1,f"Natural stride variation ({norm_diff:.4f})"
+    elif norm_diff<0.01: s,n=0.3,f"Stride-2 artifacts ({norm_diff:.4f})"
+    else: s,n=0.0,f"Stride diff={norm_diff:.4f}"
+    return {"test":"Upsampling Stride-2","norm_diff":round(norm_diff,4),"score":s,"note":n}
+
+def m10_patch_diversity(img):
+    gray=_g(img); h,w=gray.shape; ps=32
+    hc,wc=(h//ps)*ps,(w//ps)*ps; gray=gray[:hc,:wc]
+    patches=[]
+    for i in range(0,hc,ps):
+        for j in range(0,wc,ps):
+            patches.append(gray[i:i+ps,j:j+ps].ravel())
+    if len(patches)<4: return {"test":"Patch Diversity","score":0.0,"note":"Too few patches"}
+    patches=np.array(patches); means=np.mean(patches,axis=1); stds=np.std(patches,axis=1)
+    diversity=float(np.std(stds)/(np.mean(stds)+1e-9))
+    if diversity>0.5: s,n=-0.2,f"High patch diversity ({diversity:.3f}) — natural"
+    elif diversity<0.15: s,n=0.3,f"Low patch diversity ({diversity:.3f}) — GAN mode collapse"
+    else: s,n=0.0,f"Patch diversity={diversity:.3f}"
+    return {"test":"Patch Diversity","diversity":round(diversity,4),"score":s,"note":n}
+
+def m11_color_consistency(img):
+    rgb=np.array(img.convert("RGB")).astype(np.float64); h,w,_=rgb.shape; ps=64
+    hc,wc=(h//ps)*ps,(w//ps)*ps; rgb=rgb[:hc,:wc]
+    ratios=[]
+    for i in range(0,hc,ps):
+        for j in range(0,wc,ps):
+            p=rgb[i:i+ps,j:j+ps]; m=np.mean(p,axis=(0,1))
+            if m[1]>10: ratios.append(m[0]/(m[1]+1e-9))
+    if len(ratios)<4: return {"test":"Color Ratio Consistency","score":0.0,"note":"Few patches"}
+    cv=float(np.std(ratios))/(float(np.mean(ratios))+1e-9)
+    if cv>0.1: s,n=-0.2,f"Varied color ratios (CV={cv:.3f})"
+    elif cv<0.02: s,n=0.2,f"Suspiciously uniform color ({cv:.3f})"
+    else: s,n=0.0,f"Color CV={cv:.3f}"
+    return {"test":"Color Ratio Consistency","cv":round(cv,4),"score":s,"note":n}
+
+def m12_spectral_rolloff_shape(img):
+    gray=_g(img); fft=np.abs(np.fft.fftshift(np.fft.fft2(gray)))
+    h,w=fft.shape; cy,cx=h//2,w//2
+    diag1=np.array([fft[cy+i,cx+i] for i in range(min(cy,cx)//2)])
+    diag2=np.array([fft[cy+i,cx-i] for i in range(min(cy,cx)//2)])
+    if len(diag1)>5:
+        d1=np.log(diag1+1); d2=np.log(diag2+1)
+        aniso=float(np.mean(np.abs(d1-d2)))/(float(np.mean(d1))+1e-9)
+    else: aniso=0
+    if aniso>0.1: s,n=-0.1,f"Anisotropic rolloff ({aniso:.3f})"
+    elif aniso<0.02: s,n=0.2,f"Isotropic rolloff ({aniso:.3f}) — AI-like"
+    else: s,n=0.0,f"Rolloff anisotropy={aniso:.3f}"
+    return {"test":"Spectral Rolloff Shape","anisotropy":round(aniso,4),"score":s,"note":n}
+
+def m13_texture_repetition(img):
+    gray=_g(img); h,w=gray.shape; ps=64
+    if h<ps*3 or w<ps*3: return {"test":"Texture Repetition","score":0.0,"note":"Too small"}
+    hc,wc=(h//ps)*ps,(w//ps)*ps; gray=gray[:hc,:wc]
+    patches=[]
+    for i in range(0,hc,ps):
+        for j in range(0,wc,ps):
+            p=gray[i:i+ps,j:j+ps]; p=(p-np.mean(p))/(np.std(p)+1e-9)
+            patches.append(p.ravel())
+    if len(patches)<4: return {"test":"Texture Repetition","score":0.0,"note":"Few patches"}
+    patches=np.array(patches)
+    # Find max correlation between non-adjacent patches
+    max_corr=0
+    for i in range(min(len(patches),20)):
+        for j in range(i+2,min(len(patches),20)):
+            c=float(np.corrcoef(patches[i],patches[j])[0,1])
+            if c>max_corr: max_corr=c
+    if max_corr>0.8: s,n=0.4,f"Repeated textures ({max_corr:.3f}) — GAN copy"
+    elif max_corr>0.5: s,n=0.2,f"Similar textures ({max_corr:.3f})"
+    else: s,n=-0.1,f"Varied textures ({max_corr:.3f})"
+    return {"test":"Texture Repetition","max_corr":round(max_corr,4),"score":s,"note":n}
+
+def m14_highfreq_noise_structure(img):
+    gray=_g(img); noise=gray-gaussian_filter(gray,1.0)
+    fft=np.abs(np.fft.fftshift(np.fft.fft2(noise))); h,w=fft.shape; cy,cx=h//2,w//2
+    # Radial power in HF noise
+    Y,X=np.mgrid[0:h,0:w]; R=np.sqrt((X-cx)**2+(Y-cy)**2)
+    Rm=min(cy,cx); hf=fft[R>Rm*0.5]; lf=fft[R<Rm*0.3]
+    ratio=float(np.mean(hf))/(float(np.mean(lf))+1e-9)
+    if ratio>2: s,n=-0.2,f"HF-dominant noise ({ratio:.2f}) — sensor"
+    elif ratio<0.5: s,n=0.3,f"LF-dominant noise ({ratio:.2f}) — AI smoothing"
+    else: s,n=0.0,f"Noise HF/LF={ratio:.2f}"
+    return {"test":"HF Noise Structure","ratio":round(ratio,3),"score":s,"note":n}
+
+def m15_phase_coherence(img):
+    gray=_g(img); fft=np.fft.fft2(gray); phase=np.angle(fft)
+    h,w=phase.shape
+    # Natural images: smooth phase transitions
+    ph_dx=np.abs(np.diff(phase,axis=1)); ph_dy=np.abs(np.diff(phase,axis=0))
+    # Wrap-around correction
+    ph_dx[ph_dx>np.pi]=2*np.pi-ph_dx[ph_dx>np.pi]
+    ph_dy[ph_dy>np.pi]=2*np.pi-ph_dy[ph_dy>np.pi]
+    smoothness=float(np.mean(ph_dx)+np.mean(ph_dy))
+    if smoothness<2: s,n=-0.2,f"Coherent phase ({smoothness:.3f})"
+    elif smoothness>2.5: s,n=0.2,f"Incoherent phase ({smoothness:.3f})"
+    else: s,n=0.0,f"Phase coherence={smoothness:.3f}"
+    return {"test":"Phase Coherence","smoothness":round(smoothness,4),"score":s,"note":n}
+
+ALL_TESTS=[m01_fft_grid_8x8,m02_fft_grid_16x16,m03_spectral_slope,m04_diffusion_notches,
+           m05_autocorrelation,m06_checkerboard,m07_vae_boundaries,m08_spectral_symmetry,
+           m09_upsampling_stride,m10_patch_diversity,m11_color_consistency,m12_spectral_rolloff_shape,
+           m13_texture_repetition,m14_highfreq_noise_structure,m15_phase_coherence]
+
+def run_model_agent(img):
+    findings,scores=[],[]
+    for fn in ALL_TESTS:
+        try: r=fn(img); findings.append(r); scores.append(r["score"])
+        except Exception as e: 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]
+    rat=f"Model signatures: {', '.join(viol)}." if viol else f"No artifacts: {', '.join(comp)}." if comp else "Model analysis inconclusive."
     for f in findings:
-        if f.get("note"):
-            rationale += f" [{f['test']}]: {f['note']}."
-
-    return AgentEvidence(
-        agent_name="Generative Model Agent",
-        violation_score=np.clip(avg_score, -1, 1),
-        confidence=confidence,
-        failure_prob=max(0.0, 1.0 - len(scores) / 5),
-        rationale=rationale,
-        sub_findings=findings,
-    )
+        if f.get("note"): rat+=f" [{f['test']}]: {f['note']}."
+    return AgentEvidence("Generative Model Agent",np.clip(avg,-1,1),conf,max(0,1-len(scores)/len(ALL_TESTS)),rat,findings)