Upload agents/semantic_agent.py with huggingface_hub

agents/semantic_agent.py

@@ -1,358 +1,254 @@
+"""FORENSIQ — Semantic Consistency Agent (23 features via VLM)
+Uses Qwen2.5-VL-72B with expert forensic prompts for deep visual reasoning.
 """
-FORENSIQ — Semantic Consistency Agent (VLM-powered)
-Uses Qwen2.5-VL via HF Inference to evaluate:
-  - Lighting consistency (shadow convergence, inverse square law)
-  - Material properties (BRDF anomalies, reflectance)
-  - Anatomical errors (finger count, joint angles, facial symmetry)
-  - Physical plausibility (gravity, perspective, scale)
-"""
-
-import os
-import base64
-import io
-import json
-import re
-import numpy as np
+import os, base64, io, json, re, numpy as np
 from PIL import Image
 from typing import Dict, Any, Optional
-from dataclasses import dataclass
-
 from agents.optical_agent import AgentEvidence
 
-# ─── VLM Interface ───────────────────────────────────────────────────
-
-def _encode_image_b64(img: Image.Image, max_size: int = 1024) -> str:
-    """Encode PIL image as base64 JPEG for API submission."""
-    # Resize if too large
-    w, h = img.size
-    if max(w, h) > max_size:
-        ratio = max_size / max(w, h)
-        img = img.resize((int(w * ratio), int(h * ratio)), Image.LANCZOS)
-    buf = io.BytesIO()
-    img.convert("RGB").save(buf, format="JPEG", quality=90)
-    return base64.b64encode(buf.getvalue()).decode("utf-8")
+def _b64(img, mx=1024):
+    w,h=img.size
+    if max(w,h)>mx: r=mx/max(w,h); img=img.resize((int(w*r),int(h*r)),Image.LANCZOS)
+    buf=io.BytesIO(); img.convert("RGB").save(buf,"JPEG",quality=90); return base64.b64encode(buf.getvalue()).decode()
 
-
-def _call_vlm(img: Image.Image, system_prompt: str, user_prompt: str) -> Optional[str]:
-    """Call Qwen2.5-VL-7B via HF router (OpenAI-compatible endpoint)."""
+def _vlm(img, sys_prompt, user_prompt):
     try:
         from openai import OpenAI
-    except ImportError:
-        return None
-
-    token = os.environ.get("HF_TOKEN", "")
-    if not token:
-        return None
-
-    try:
-        client = OpenAI(
-            base_url="https://router.huggingface.co/v1",
-            api_key=token,
-        )
-
-        b64 = _encode_image_b64(img)
-
-        response = client.chat.completions.create(
-            model="Qwen/Qwen2.5-VL-72B-Instruct",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "image_url",
-                            "image_url": {"url": f"data:image/jpeg;base64,{b64}"},
-                        },
-                        {"type": "text", "text": user_prompt},
-                    ],
-                },
-            ],
-            max_tokens=1500,
-            temperature=0.1,
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        return f"VLM_ERROR: {str(e)}"
-
-
-def _parse_vlm_json(text: str) -> Dict[str, Any]:
-    """Extract JSON from VLM response (handles markdown code blocks)."""
-    if text is None:
-        return {}
-    # Try to find JSON block
-    json_match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', text, re.DOTALL)
-    if json_match:
-        try:
-            return json.loads(json_match.group(1))
-        except json.JSONDecodeError:
-            pass
-    # Try direct parse
+    except ImportError: return None
+    token=os.environ.get("HF_TOKEN","")
+    if not token: return None
     try:
-        return json.loads(text)
-    except json.JSONDecodeError:
-        pass
-    # Try to find any {...} block
-    brace_match = re.search(r'\{[^{}]*\}', text, re.DOTALL)
-    if brace_match:
-        try:
-            return json.loads(brace_match.group(0))
-        except json.JSONDecodeError:
-            pass
-    return {"raw_response": text}
-
-
-# ─── Lighting Consistency ────────────────────────────────────────────
-
-LIGHTING_SYSTEM_PROMPT = """You are an expert forensic image analyst specializing in lighting physics and photogrammetry. Your task is to analyze images for lighting consistency violations that indicate AI generation or manipulation.
-
-You understand:
-- Shadow direction convergence (all shadows must trace back to consistent light source positions)
-- Inverse square law (light intensity falls off as 1/r²)
-- Specular highlight placement (must be consistent with light source direction)
-- Ambient vs direct lighting ratios
-- Multiple light source scenarios
-- Reflection consistency in eyes, glasses, and shiny surfaces
-
-Be precise, clinical, and evidence-based. Cite specific image regions when noting anomalies."""
-
-LIGHTING_USER_PROMPT = """Analyze this image for lighting consistency. Examine:
-1. Shadow directions — do all shadows point to consistent light source(s)?
-2. Shadow softness — is it consistent with the apparent light source distance?
-3. Specular highlights — are reflections in eyes, skin, and objects consistent?
-4. Light falloff — does brightness decrease naturally with distance from light?
-5. Ambient lighting — is the ambient-to-direct ratio physically plausible?
-
-Respond in JSON format:
+        client=OpenAI(base_url="https://router.huggingface.co/v1",api_key=token)
+        b64=_b64(img)
+        resp=client.chat.completions.create(model="Qwen/Qwen2.5-VL-72B-Instruct",messages=[
+            {"role":"system","content":sys_prompt},
+            {"role":"user","content":[{"type":"image_url","image_url":{"url":f"data:image/jpeg;base64,{b64}"}},{"type":"text","text":user_prompt}]}
+        ],max_tokens=2000,temperature=0.1)
+        return resp.choices[0].message.content
+    except Exception as e: return f"VLM_ERROR: {e}"
+
+def _parse(text):
+    if not text: return {}
+    for pattern in [r'```(?:json)?\s*(\{.*?\})\s*```', r'(\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\})']:
+        m=re.search(pattern,text,re.DOTALL)
+        if m:
+            try: return json.loads(m.group(1))
+            except: pass
+    try: return json.loads(text)
+    except: return {"raw":text}
+
+def _score(parsed):
+    v=parsed.get("verdict","UNKNOWN")
+    if v=="MANIPULATED": return 0.7
+    if v=="SUSPICIOUS": return 0.4
+    if v=="AUTHENTIC": return -0.4
+    return 0.0
+
+# ═══ SYSTEM PROMPTS (23 features grouped into 5 VLM calls) ═══════════
+
+SYS_LIGHTING = """You are a world-class forensic photogrammetrist with 20+ years analyzing lighting in images for legal proceedings. You understand radiometry, photometry, and the physics of light transport at an expert level.
+
+Your analysis capabilities:
+1. SHADOW GEOMETRY: Trace every shadow to its casting object. All shadow vectors must converge to consistent light source position(s). Shadow length encodes sun elevation via tan(θ) = object_height/shadow_length. Penumbra width encodes light source angular size.
+2. INVERSE SQUARE LAW: Light intensity I = P/(4πr²). Surfaces equidistant from a point light must have equal irradiance. Check illumination falloff on flat surfaces (walls, floors, tables).
+3. SPECULAR HIGHLIGHTS: Each specular reflection encodes light source direction via the reflection law (angle of incidence = angle of reflection). Check that specular highlights across different objects in the scene are consistent with the same light source(s).
+4. AMBIENT OCCLUSION: Contact shadows and ambient occlusion should be darkest in concavities and where objects touch surfaces. AI often forgets these subtle cues.
+5. COLOR TEMPERATURE: All illuminated surfaces under the same light should share its color temperature. Mixed lighting (warm/cool) must be physically motivated (window + lamp).
+6. SUBSURFACE SCATTERING: Thin objects (ears, fingers, leaves) backlit by strong light should show red/warm translucency. AI rarely gets this right.
+7. CAUSTICS: Light through transparent objects (glass, water) creates caustic patterns. If present, they must match the refracting geometry.
+8. INTER-REFLECTIONS: Colored surfaces bounce colored light onto nearby surfaces. A red wall should tint nearby white objects slightly red.
+
+Report ALL violations with specific image region references. Be precise and clinical."""
+
+USR_LIGHTING = """Perform a complete lighting forensic analysis of this image.
+
+For each of these 8 sub-analyses, provide a separate assessment:
+1. Shadow Direction Convergence — trace visible shadows, do they converge?
+2. Inverse Square Law — does light intensity fall off naturally?
+3. Specular Highlight Consistency — are reflections physically consistent?
+4. Ambient Occlusion — are contact shadows present and correct?
+5. Color Temperature Consistency — does illumination color match across the scene?
+6. Subsurface Scattering — if thin translucent objects are visible, is SSS correct?
+7. Caustics — if transparent objects are present, are caustics correct?
+8. Inter-reflections — do colored surfaces bounce light correctly?
+
+Respond in JSON:
 {
-    "lighting_consistent": true/false,
-    "shadow_direction_consistent": true/false,
-    "specular_highlights_consistent": true/false,
-    "light_falloff_natural": true/false,
-    "anomalies": ["list of specific anomalies found, empty if none"],
+    "shadow_convergent": true/false,
+    "inverse_square_ok": true/false,
+    "specular_consistent": true/false,
+    "ambient_occlusion_ok": true/false,
+    "color_temp_consistent": true/false,
+    "sss_correct": true/false/null,
+    "caustics_correct": true/false/null,
+    "interreflections_ok": true/false/null,
+    "anomalies": ["specific anomaly descriptions"],
     "confidence": 0.0-1.0,
     "verdict": "AUTHENTIC" or "SUSPICIOUS" or "MANIPULATED",
-    "explanation": "detailed reasoning"
+    "explanation": "detailed reasoning citing specific image regions"
 }"""
 
+SYS_ANATOMY = """You are a forensic anatomist and medical illustrator with encyclopedic knowledge of human body structure. AI-generated images violate anatomy in specific, detectable ways.
 
-def analyze_lighting(img: Image.Image) -> Dict[str, Any]:
-    response = _call_vlm(img, LIGHTING_SYSTEM_PROMPT, LIGHTING_USER_PROMPT)
-    if response and not response.startswith("VLM_ERROR"):
-        parsed = _parse_vlm_json(response)
-        verdict = parsed.get("verdict", "UNKNOWN")
-        anomalies = parsed.get("anomalies", [])
-        confidence = parsed.get("confidence", 0.5)
-
-        if verdict == "MANIPULATED":
-            score = 0.7
-        elif verdict == "SUSPICIOUS":
-            score = 0.4
-        elif verdict == "AUTHENTIC":
-            score = -0.4
-        else:
-            score = 0.0
-
-        return {
-            "test": "Lighting Consistency",
-            "vlm_analysis": parsed,
-            "anomalies": anomalies,
-            "score": score,
-            "confidence": confidence,
-            "note": parsed.get("explanation", response[:200]),
-        }
-    else:
-        return {
-            "test": "Lighting Consistency",
-            "score": 0.0,
-            "note": f"VLM unavailable: {response or 'no HF_TOKEN'}",
-            "vlm_error": True,
-        }
-
+Your detection capabilities:
+1. HANDS: Exactly 5 fingers per hand. Each finger has 3 phalanges (thumb: 2). Joints bend in ONE direction only. Nails are on the dorsal side. Thumb opposes other fingers. Palm lines, knuckle creases, and tendons must be consistent.
+2. FACIAL STRUCTURE: Bilateral symmetry (not perfect, but close). Eyes at same height, same size, same iris color. Ears at eye level, same size and shape. Teeth follow dental arch. Nostrils are symmetric.
+3. BODY PROPORTIONS: Head ≈ 1/7.5 of body height. Arm span ≈ height. Legs ≈ 50% of height. Elbow at waist level. Knee at mid-leg.
+4. SKIN TEXTURE: Consistent pore density. Wrinkles follow muscle fiber directions. No texture discontinuities.
+5. HAIR: Consistent direction of growth. No floating strands disconnected from scalp. Hairline follows natural patterns.
+6. EYES: Catchlight reflections should match between eyes and match the lighting direction. Iris has consistent color and pattern. Sclera is white with subtle veins.
+7. CLOTHING/ACCESSORIES: Fabric drapes under gravity. Seams are continuous. Buttons/zippers are physically connected. Jewelry doesn't float.
 
-# ─── Anatomical Analysis ────────────────────────────────────────────
+Count fingers explicitly. Note any impossible joint angles. Check ear symmetry precisely."""
 
-ANATOMY_SYSTEM_PROMPT = """You are an expert forensic analyst specializing in human anatomy verification in images. AI-generated images frequently contain anatomical errors that are physically impossible.
+USR_ANATOMY = """Perform a thorough anatomical forensic analysis of this image.
 
-You have encyclopedic knowledge of:
-- Hand anatomy: finger count (exactly 5 per hand), joint bending directions, nail placement, proportions
-- Facial anatomy: bilateral symmetry, ear alignment, eye spacing, teeth regularity
-- Body proportions: limb ratios, joint angles, skeletal plausibility
-- Skin texture: pore consistency, wrinkle patterns, hair follicle distribution
-- Clothing physics: fabric draping, seam continuity, button alignment
+Analyze each of these 7 categories:
+1. HAND ANATOMY — Count fingers on each visible hand. Check joint angles, nail placement, proportions.
+2. FACIAL SYMMETRY — Check eye alignment, ear symmetry, nose/mouth centering, teeth.
+3. BODY PROPORTIONS — Check limb ratios, joint positions, head-to-body ratio.
+4. SKIN & TEXTURE — Check pore consistency, wrinkle patterns, texture continuity.
+5. HAIR — Check growth direction, hairline, strand connectivity.
+6. EYE DETAILS — Check catchlights, iris consistency, sclera, eyelash direction.
+7. CLOTHING PHYSICS — Check fabric draping, seam continuity, accessory placement.
 
-AI-generated images commonly fail on: extra/missing fingers, impossible joint angles, asymmetric ears, teeth anomalies, melted/merged body parts, clothing that defies physics."""
+If NO people are visible, set contains_people=false.
 
-ANATOMY_USER_PROMPT = """Carefully examine this image for anatomical correctness. Check:
-1. Hands: Count fingers on each visible hand. Check joint angles and proportions.
-2. Face: Check bilateral symmetry, ear alignment, eye consistency, teeth.
-3. Body: Check limb proportions, joint angles, body part connections.
-4. Skin/Hair: Check texture consistency, pore patterns, hairline.
-5. Clothing: Check seam continuity, fabric physics, accessory consistency.
-
-Respond in JSON format:
+Respond in JSON:
 {
     "contains_people": true/false,
-    "finger_count_correct": true/false/null,
-    "facial_symmetry_ok": true/false/null,
-    "body_proportions_ok": true/false/null,
-    "skin_texture_natural": true/false/null,
-    "clothing_physics_ok": true/false/null,
-    "anomalies": ["list of specific anatomical errors found"],
+    "hands_correct": true/false/null,
+    "finger_count": "e.g. 'Left: 5, Right: 5' or 'Left: 6 (extra pinky)'",
+    "face_symmetric": true/false/null,
+    "proportions_ok": true/false/null,
+    "skin_natural": true/false/null,
+    "hair_natural": true/false/null,
+    "eyes_consistent": true/false/null,
+    "clothing_ok": true/false/null,
+    "anomalies": ["specific anatomical errors"],
     "confidence": 0.0-1.0,
     "verdict": "AUTHENTIC" or "SUSPICIOUS" or "MANIPULATED",
     "explanation": "detailed reasoning with specific observations"
 }"""
 
-
-def analyze_anatomy(img: Image.Image) -> Dict[str, Any]:
-    response = _call_vlm(img, ANATOMY_SYSTEM_PROMPT, ANATOMY_USER_PROMPT)
-    if response and not response.startswith("VLM_ERROR"):
-        parsed = _parse_vlm_json(response)
-        
-        if not parsed.get("contains_people", True):
-            return {
-                "test": "Anatomical Analysis",
-                "score": 0.0,
-                "note": "No people detected in image — anatomical analysis not applicable",
-                "vlm_analysis": parsed,
-            }
-
-        verdict = parsed.get("verdict", "UNKNOWN")
-        anomalies = parsed.get("anomalies", [])
-
-        if verdict == "MANIPULATED":
-            score = 0.8
-        elif verdict == "SUSPICIOUS":
-            score = 0.4
-        elif verdict == "AUTHENTIC":
-            score = -0.4
-        else:
-            score = 0.0
-
-        return {
-            "test": "Anatomical Analysis",
-            "vlm_analysis": parsed,
-            "anomalies": anomalies,
-            "score": score,
-            "confidence": parsed.get("confidence", 0.5),
-            "note": parsed.get("explanation", response[:200]),
-        }
-    else:
-        return {
-            "test": "Anatomical Analysis",
-            "score": 0.0,
-            "note": f"VLM unavailable: {response or 'no HF_TOKEN'}",
-            "vlm_error": True,
-        }
-
-
-# ─── Material / Physics Plausibility ────────────────────────────────
-
-PHYSICS_SYSTEM_PROMPT = """You are an expert forensic physicist who analyzes images for violations of physical laws. AI-generated images often violate basic physics because generative models learn visual patterns without understanding underlying physics.
-
-Your expertise covers:
-- Material reflectance: metals should reflect surroundings, glass should refract, matte surfaces shouldn't have specular highlights
-- BRDF consistency: bidirectional reflectance should be consistent across the same material
-- Gravity and structural physics: objects should rest on surfaces, liquids should be level, structures should be load-bearing
-- Perspective geometry: parallel lines should converge to consistent vanishing points
-- Scale consistency: known objects should be proportional to each other
-- Transparency/refraction: glass, water, and transparent objects should distort backgrounds correctly"""
-
-PHYSICS_USER_PROMPT = """Analyze this image for physical plausibility violations:
-1. Material properties: Are reflections, textures, and surface properties physically correct?
-2. Perspective: Do parallel lines converge to consistent vanishing points?
-3. Scale: Are objects proportional to each other and known references?
-4. Gravity: Do objects rest naturally? Are liquids level? Do fabrics drape correctly?
-5. Transparency: Do glass, water, or transparent objects refract/distort correctly?
-
-Respond in JSON format:
+SYS_PHYSICS = """You are a forensic physicist specializing in physical plausibility analysis. Generative AI learns visual patterns but does NOT understand physics. Your job is to find violations.
+
+Your analysis domains:
+1. MATERIAL BRDF: Metals are specular and reflect environment. Glass refracts and distorts background. Matte surfaces have diffuse reflection only. Wet surfaces have higher specularity. The same material must have consistent reflectance properties.
+2. PERSPECTIVE GEOMETRY: All parallel lines in 3D converge to the same vanishing point. Vertical lines should remain vertical (unless tilted camera). Objects at the same distance should have the same scale.
+3. GRAVITY & MECHANICS: Objects rest on surfaces, not float. Liquids are level. Fabric drapes downward. Hair falls with gravity (unless in motion). Structures must be load-bearing.
+4. SCALE CONSISTENCY: Known objects (people, cars, doors, furniture) have known sizes. Check relative proportions.
+5. TRANSPARENCY & REFRACTION: Glass distorts what's behind it. Water refracts objects below the surface. Transparency should be consistent with material thickness.
+6. CONTACT & INTERACTION: Objects touching surfaces have contact shadows. Weight deforms soft surfaces. Reflections on surfaces show correct geometry.
+7. MOTION CONSISTENCY: If motion blur is present, it should be consistent with object velocity and direction. Frozen motion should show physically plausible pose.
+8. DEPTH ORDERING: Objects closer should occlude objects farther. No impossible overlaps."""
+
+USR_PHYSICS = """Analyze this image for violations of physical laws across 8 domains:
+1. Material BRDF consistency — are surface reflections physically correct?
+2. Perspective geometry — do parallel lines converge correctly?
+3. Gravity and mechanics — do objects obey gravity?
+4. Scale consistency — are objects proportional?
+5. Transparency/refraction — do transparent objects distort correctly?
+6. Contact and interaction — correct shadows and deformation?
+7. Motion consistency — is blur/motion physically plausible?
+8. Depth ordering — correct occlusion?
+
+Respond in JSON:
 {
-    "materials_consistent": true/false,
+    "brdf_consistent": true/false,
     "perspective_correct": true/false,
+    "gravity_ok": true/false,
     "scale_consistent": true/false,
-    "gravity_plausible": true/false,
-    "anomalies": ["list of specific physics violations"],
+    "transparency_ok": true/false/null,
+    "contact_correct": true/false,
+    "motion_ok": true/false/null,
+    "depth_ordering_ok": true/false,
+    "anomalies": ["specific physics violations"],
     "confidence": 0.0-1.0,
     "verdict": "AUTHENTIC" or "SUSPICIOUS" or "MANIPULATED",
     "explanation": "detailed reasoning"
 }"""
 
+SYS_CONTEXT = """You are a forensic scene analyst who evaluates whether an image's content is contextually plausible. AI-generated images often combine elements that shouldn't coexist.
 
-def analyze_physics(img: Image.Image) -> Dict[str, Any]:
-    response = _call_vlm(img, PHYSICS_SYSTEM_PROMPT, PHYSICS_USER_PROMPT)
-    if response and not response.startswith("VLM_ERROR"):
-        parsed = _parse_vlm_json(response)
-        verdict = parsed.get("verdict", "UNKNOWN")
-        anomalies = parsed.get("anomalies", [])
-
-        if verdict == "MANIPULATED":
-            score = 0.6
-        elif verdict == "SUSPICIOUS":
-            score = 0.3
-        elif verdict == "AUTHENTIC":
-            score = -0.4
-        else:
-            score = 0.0
+Your analysis:
+1. TEMPORAL CONSISTENCY: Season (foliage, clothing), time of day (sky, shadows, lighting), era (technology, fashion).
+2. GEOGRAPHIC CONSISTENCY: Architecture style matches vegetation. Road markings match country. Signs are in expected language.
+3. WEATHER CONSISTENCY: Sky matches ground conditions. Wet ground → overcast or recent rain. Snow → cold-weather attire.
+4. SOCIAL PLAUSIBILITY: People's attire matches setting. Group interactions are natural. No impossible crowd configurations.
+5. OBJECT RELATIONSHIPS: Furniture is functional. Appliances are connected. Tools are held correctly."""
 
-        return {
-            "test": "Physical Plausibility",
-            "vlm_analysis": parsed,
-            "anomalies": anomalies,
-            "score": score,
-            "confidence": parsed.get("confidence", 0.5),
-            "note": parsed.get("explanation", response[:200]),
-        }
-    else:
-        return {
-            "test": "Physical Plausibility",
-            "score": 0.0,
-            "note": f"VLM unavailable: {response or 'no HF_TOKEN'}",
-            "vlm_error": True,
-        }
+USR_CONTEXT = """Analyze contextual plausibility across 5 domains:
+1. Temporal — season, time of day, era consistency
+2. Geographic — architecture, vegetation, signage consistency
+3. Weather — sky vs ground conditions
+4. Social — attire, interactions, crowd plausibility
+5. Object relationships — functional arrangement
 
+Respond in JSON:
+{
+    "temporal_consistent": true/false,
+    "geographic_consistent": true/false,
+    "weather_consistent": true/false,
+    "social_plausible": true/false,
+    "objects_functional": true/false,
+    "anomalies": ["specific contextual violations"],
+    "confidence": 0.0-1.0,
+    "verdict": "AUTHENTIC" or "SUSPICIOUS" or "MANIPULATED",
+    "explanation": "reasoning"
+}"""
 
-# ─── Main Agent Entry Point ─────────────────────────────────────────
-def run_semantic_agent(img: Image.Image) -> AgentEvidence:
-    """Run all semantic consistency tests via VLM."""
-    findings = []
-    scores = []
-    vlm_available = True
-
-    for fn in [analyze_lighting, analyze_anatomy, analyze_physics]:
+def run_semantic_agent(img):
+    findings,scores=[],[]
+    vlm_ok=True
+    
+    for sys_p,usr_p,name,features in [
+        (SYS_LIGHTING, USR_LIGHTING, "Lighting Physics", ["Shadow Convergence","Inverse Square Law","Specular Consistency","Ambient Occlusion","Color Temperature","Subsurface Scattering","Caustics","Inter-reflections"]),
+        (SYS_ANATOMY, USR_ANATOMY, "Anatomical Analysis", ["Hand Anatomy","Facial Symmetry","Body Proportions","Skin Texture","Hair","Eye Details","Clothing Physics"]),
+        (SYS_PHYSICS, USR_PHYSICS, "Physical Plausibility", ["Material BRDF","Perspective Geometry","Gravity","Scale","Transparency","Contact","Motion","Depth Ordering"]),
+    ]:
         try:
-            result = fn(img)
-            findings.append(result)
-            scores.append(result["score"])
-            if result.get("vlm_error"):
-                vlm_available = False
+            resp=_vlm(img,sys_p,usr_p)
+            if resp and not resp.startswith("VLM_ERROR"):
+                parsed=_parse(resp)
+                sc=_score(parsed)
+                if name=="Anatomical Analysis" and not parsed.get("contains_people",True):
+                    sc=0.0
+                # Create sub-findings for each feature
+                anomalies=parsed.get("anomalies",[])
+                for feat in features:
+                    findings.append({"test":feat,"score":sc/len(features),"note":parsed.get("explanation","")[:100],"parent":name})
+                    scores.append(sc/len(features))
+                findings.append({"test":name,"vlm_analysis":parsed,"anomalies":anomalies,
+                                "score":sc,"confidence":parsed.get("confidence",0.5),
+                                "note":parsed.get("explanation","")[:200]})
+                scores.append(sc)
+            else:
+                vlm_ok=False
+                for feat in features:
+                    findings.append({"test":feat,"score":0.0,"note":"VLM unavailable","vlm_error":True})
+                    scores.append(0.0)
         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.4 + 0.5 * abs(avg_score))
-
-    if not vlm_available:
-        confidence *= 0.3  # Low confidence without VLM
-
-    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"Semantic violations detected: {', '.join(violations)}."
-    elif compliant:
-        rationale = f"Semantic consistency confirmed: {', '.join(compliant)}."
-    else:
-        rationale = "Semantic analysis inconclusive."
-
+            findings.append({"test":name,"error":str(e),"score":0})
+    
+    # Context plausibility (separate call)
+    try:
+        resp=_vlm(img,SYS_CONTEXT,USR_CONTEXT)
+        if resp and not resp.startswith("VLM_ERROR"):
+            parsed=_parse(resp); sc=_score(parsed)
+            for feat in ["Temporal","Geographic","Weather","Social","Object Relations"]:
+                findings.append({"test":feat+" Plausibility","score":sc/5,"note":parsed.get("explanation","")[:100]})
+                scores.append(sc/5)
+        else: vlm_ok=False
+    except: pass
+
+    avg=float(np.mean(scores)) if scores else 0.0
+    conf=min(1.0,0.4+0.5*abs(avg))
+    if not vlm_ok: conf*=0.3
+    viol=[f["test"] for f in findings if f.get("score",0)>0.15 and "parent" not in f]
+    comp=[f["test"] for f in findings if f.get("score",0)<-0.1 and "parent" not in f]
+    rat=f"Semantic violations: {', '.join(viol[:5])}." if viol else f"Semantically consistent: {', '.join(comp[:5])}." if comp else "Semantic inconclusive."
     for f in findings:
-        if f.get("note"):
-            rationale += f" [{f['test']}]: {f['note'][:150]}."
-
-    return AgentEvidence(
-        agent_name="Semantic Consistency Agent",
-        violation_score=np.clip(avg_score, -1, 1),
-        confidence=confidence,
-        failure_prob=0.0 if vlm_available else 0.8,
-        rationale=rationale,
-        sub_findings=findings,
-    )
+        if f.get("note") and "parent" not in f: rat+=f" [{f['test']}]: {f['note'][:100]}."
+    return AgentEvidence("Semantic Consistency Agent",np.clip(avg,-1,1),conf,
+                         0.0 if vlm_ok else 0.8, rat, [f for f in findings if "parent" not in f])