Refreshed backend assets and scripts via Git LFS

.gitattributes

@@ -33,18 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-backend/test_noise.png filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/Pepsi[[:space:]]can[[:space:]]real.webp filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/Scenery-1.jpg filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/Scenery-2.jpg filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/WIN_20240923_10_49_05_Pro.jpg filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/ai-generated-face.png filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/digital[[:space:]]AI[[:space:]]painting.jpg filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/skynews-zelenskyy-deepfake_5708613.jpg filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/stable_diffusion[[:space:]]image.jpg filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/wonderland-girl-generated-by-Fotor-ai-art-generator.webp filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Images/yard.jpg filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Videos/229254_tiny.mp4 filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Videos/WIN_20260225_20_51_10_Pro.mp4 filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Videos/WIN_20260315_16_53_03_Pro.mp4 filter=lfs diff=lfs merge=lfs -text
-video_bundle/Sample[[:space:]]Images[[:space:]]and[[:space:]]Videos/Videos/video_307231ea-7a0a-49cf-a74b-616bc9c80f7b.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text

backend/model_service.py

@@ -32,13 +32,20 @@ REPO_DIR = ROOT / 'repo_inspect'
 INTEGRATION_ASSETS_DIR = ROOT / 'integration_assets'
 VIDEO_BUNDLE_DIR = ROOT / 'video_bundle'
 VIDEO_CODE_DIR = VIDEO_BUNDLE_DIR / 'Video'
-for path in [REPO_DIR, INTEGRATION_ASSETS_DIR, VIDEO_BUNDLE_DIR, VIDEO_CODE_DIR]:
-    if str(path) not in sys.path:
-        sys.path.insert(0, str(path))
+for path in [ROOT, VIDEO_CODE_DIR, VIDEO_BUNDLE_DIR, REPO_DIR, INTEGRATION_ASSETS_DIR]:
+    path_str = str(path)
+    if path_str in sys.path:
+        sys.path.remove(path_str)
+    sys.path.insert(0, path_str)
 
 from ethical_assessment import EthicalAssessment, format_ethical_report, get_simple_status  # noqa: E402
 from video_model import ResNetLSTM, GradCAM as VideoGradCAM, overlay_cam  # noqa: E402
 
+try:
+    from neurosymbolic import run_neurosymbolic_assessment  # type: ignore  # noqa: E402
+except Exception:
+    run_neurosymbolic_assessment = None
+
 PRIMARY_WEIGHTS_PATH = ROOT / 'models_adv' / 'best_model_weights.pt'
 FALLBACK_WEIGHTS_PATH = ROOT / 'integration_assets' / 'best_model_weights.pt'
 WEIGHTS_PATH = PRIMARY_WEIGHTS_PATH if PRIMARY_WEIGHTS_PATH.exists() else FALLBACK_WEIGHTS_PATH
@@ -152,6 +159,7 @@ class InferenceArtifacts:
     artifacts: list[dict[str, Any]]
     source_analysis: dict[str, Any] | None
     ethical: dict[str, Any] | None
+    neurosymbolic: dict[str, Any] | None
 
 
 @dataclass
@@ -203,8 +211,11 @@ def detect_backbone(state_dict: dict[str, torch.Tensor]) -> str:
 
 
 state_dict = torch.load(WEIGHTS_PATH, map_location=DEVICE)
-model = EfficientNetFFTFusion(backbone=detect_backbone(state_dict)).to(DEVICE)
-model.load_state_dict(state_dict, strict=False)
+model = EfficientNetFFTFusion(backbone=detect_backbone(state_dict))
+model.load_state_dict(state_dict, strict=True)
+for parameter in model.parameters():
+    parameter.requires_grad_(True)
+model = model.to(DEVICE)
 model.eval()
 MODEL_INFO = {'model_type': 'efficientnet_fft', 'backbone': detect_backbone(state_dict), 'optimal_threshold': THRESHOLD_AI}
 
@@ -217,7 +228,7 @@ if GAN_DIFF_WEIGHTS_PATH.exists() and GAN_DIFF_CONFIG_PATH.exists():
     gan_diff_state = torch.load(GAN_DIFF_WEIGHTS_PATH, map_location=DEVICE)
     if isinstance(gan_diff_state, dict) and 'model_state' in gan_diff_state:
         gan_diff_state = gan_diff_state['model_state']
-    gan_diff_model.load_state_dict(gan_diff_state, strict=False)
+    gan_diff_model.load_state_dict(gan_diff_state, strict=True)
     GAN_DIFF_MODEL = gan_diff_model.to(DEVICE)
     GAN_DIFF_MODEL.eval()
 
@@ -233,8 +244,11 @@ if VIDEO_WEIGHTS_PATH.exists():
         temporal_pool=VIDEO_CONFIG.get('temporal_pool', 'mean'),
         pretrained=False,
         backbone_name=VIDEO_CONFIG.get('backbone', 'xception'),
-    ).to(DEVICE)
-    VIDEO_MODEL.load_state_dict(video_ckpt['model_state'], strict=False)
+    )
+    VIDEO_MODEL.load_state_dict(video_ckpt['model_state'], strict=True)
+    for parameter in VIDEO_MODEL.parameters():
+        parameter.requires_grad_(True)
+    VIDEO_MODEL = VIDEO_MODEL.to(DEVICE)
     VIDEO_MODEL.eval()
 
 
@@ -338,10 +352,15 @@ def analyze_fft(image: Image.Image) -> dict[str, Any]:
 
 
 def overlay_gradcam_from_pil(pil_image: Image.Image) -> tuple[Image.Image, np.ndarray]:
+    model.eval()
+    for parameter in model.parameters():
+        parameter.requires_grad_(True)
     input_tensor = transform(pil_image).unsqueeze(0).to(DEVICE)
+    input_tensor.requires_grad_(True)
     target_layer = model.backbone.conv_head
     grad_cam = SimpleGradCAM(model, target_layer)
     try:
+        model.zero_grad(set_to_none=True)
         cam = grad_cam.generate_cam(input_tensor, target_class=1)
     finally:
         grad_cam.close()
@@ -417,8 +436,12 @@ def predict_source_from_pil(image: Image.Image) -> dict[str, Any] | None:
         probs = torch.softmax(logits, dim=1)[0].cpu().numpy()
         pred_idx = int(np.argmax(probs))
     labels = {int(k): str(v) for k, v in id_to_label.items()} if isinstance(id_to_label, dict) else {0: 'gan', 1: 'diffusion'}
+    predicted_source = labels.get(pred_idx, 'unknown')
+    top_prob = float(probs[pred_idx])
     return {
-        'predictedSource': labels.get(pred_idx, 'unknown'),
+        'predictedSource': predicted_source,
+        'label': predicted_source,
+        'top_prob': round(top_prob, 6),
         'ganProbability': round(float(probs[0]), 6),
         'diffusionProbability': round(float(probs[1]), 6),
     }
@@ -503,6 +526,7 @@ def analyze_video_file(video_path: str, filename: str, content_type: str, size_b
     pil_frames = [Image.fromarray(frame) for frame in frames]
     frame_tensors = [video_transform(frame).unsqueeze(0) for frame in pil_frames]
     clip = torch.stack([tensor.squeeze(0) for tensor in frame_tensors], dim=0).unsqueeze(0).to(DEVICE)
+    clip.requires_grad_(True)
 
     with torch.no_grad():
         frame_logits, video_logits = VIDEO_MODEL(clip)
@@ -548,6 +572,20 @@ def analyze_video_file(video_path: str, filename: str, content_type: str, size_b
     lead_image = pil_frames[lead_idx]
     ethical = run_ethical_assessment(np.array(lead_image.convert('RGB'))) if verdict != 'authentic' else None
     source_analysis = predict_source_from_pil(lead_image) if verdict != 'authentic' else None
+    neurosymbolic = None
+    if verdict != 'authentic' and run_neurosymbolic_assessment is not None:
+        try:
+            neurosymbolic = run_neurosymbolic_assessment(
+                np.array(lead_image.convert('RGB')),
+                fused_video_score,
+                source_analysis,
+                {
+                    'risk_score': ethical['riskScore'],
+                    'status': ethical['status'],
+                } if ethical else None,
+            )
+        except Exception:
+            neurosymbolic = None
     metadata = {
         'mimeType': content_type,
         'dimensions': f'{lead_image.width} × {lead_image.height} px',
@@ -599,6 +637,7 @@ def analyze_video_file(video_path: str, filename: str, content_type: str, size_b
         'metadata': metadata,
         'sourceAnalysis': source_analysis,
         'ethical': ethical,
+        'neurosymbolic': neurosymbolic,
         'raw': {
             'probabilityAi': round(fused_video_score, 6),
             'rawSequenceProbabilityAi': round(prob_fake, 6),
@@ -627,6 +666,20 @@ def format_result(image: Image.Image, filename: str, content_type: str, size_byt
     ethical = run_ethical_assessment(np.array(image.convert('RGB'))) if verdict != 'authentic' else None
     artifacts = build_artifacts(probability_ai, fft_summary, metadata, heatmap_regions, ethical)
     source_analysis = predict_source_from_pil(image) if verdict != 'authentic' else None
+    neurosymbolic = None
+    if verdict != 'authentic' and run_neurosymbolic_assessment is not None:
+        try:
+            neurosymbolic = run_neurosymbolic_assessment(
+                np.array(image.convert('RGB')),
+                probability_ai,
+                source_analysis,
+                {
+                    'risk_score': ethical['riskScore'],
+                    'status': ethical['status'],
+                } if ethical else None,
+            )
+        except Exception:
+            neurosymbolic = None
     fft_branch_score = round(min(99.9, fft_summary['bands']['high'] / max(fft_summary['bands']['low'], 1e-6) * 40), 2)
     model_breakdown = [
         {'model': 'EfficientNet-B2 Spatial', 'score': round(probability_ai * 100, 2), 'weight': 0.55},
@@ -635,7 +688,7 @@ def format_result(image: Image.Image, filename: str, content_type: str, size_byt
     if source_analysis:
         model_breakdown.append({'model': f"AI Source: {source_analysis['predictedSource'].upper()}", 'score': round(max(source_analysis['ganProbability'], source_analysis['diffusionProbability']) * 100, 2), 'weight': 0.20})
     metadata['heatmapPreview'] = image_to_base64(overlay_image)
-    return InferenceArtifacts(probability_ai, probability_authentic, verdict, round(confidence_score, 2), heatmap_regions, fft_summary, metadata, model_breakdown, artifacts, source_analysis, ethical)
+    return InferenceArtifacts(probability_ai, probability_authentic, verdict, round(confidence_score, 2), heatmap_regions, fft_summary, metadata, model_breakdown, artifacts, source_analysis, ethical, neurosymbolic)
 
 
 @app.get('/api/health')
@@ -721,6 +774,7 @@ async def analyze_media(file: UploadFile = File(...)) -> JSONResponse:
         'metadata': artifacts.metadata,
         'sourceAnalysis': artifacts.source_analysis,
         'ethical': artifacts.ethical,
+        'neurosymbolic': artifacts.neurosymbolic,
         'raw': {
             'probabilityAi': round(artifacts.probability_ai, 6),
             'probabilityAuthentic': round(artifacts.probability_authentic, 6),

neurosymbolic.py

@@ -0,0 +1,123 @@
+"""
+Neurosymbolic reasoning layer for AI-generated image decisions.
+
+This module complements neural predictions with transparent symbolic rules.
+It does not replace the neural model; it explains and supports the decision.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+from detector import rgb_to_gray, extract_residual, fft_stats, lbp_entropy
+
+
+def _clip01(value: float) -> float:
+    return max(0.0, min(1.0, float(value)))
+
+
+def run_neurosymbolic_assessment(
+    img_arr: np.ndarray,
+    ai_confidence: float,
+    source_pred: Optional[Dict[str, Any]] = None,
+    ethical_assessment: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Run symbolic rules over image statistics and model outputs."""
+    if img_arr.dtype != np.float32 and img_arr.dtype != np.float64:
+        img_arr = img_arr.astype(np.float32)
+
+    if img_arr.max() > 1.0:
+        img_arr = img_arr / 255.0
+
+    g = rgb_to_gray(img_arr)
+    residual = extract_residual(g)
+    residual_std = float(np.std(residual))
+    _, hf_ratio = fft_stats(g)
+    entropy = float(lbp_entropy((g * 255).astype(np.uint8)))
+
+    confidence = _clip01(ai_confidence)
+    score = 0.0
+    fired_rules: List[Dict[str, Any]] = []
+
+    def add_rule(rule_id: str, reason: str, weight: float) -> None:
+        nonlocal score
+        score += weight
+        fired_rules.append({"rule": rule_id, "reason": reason, "weight": float(weight)})
+
+    if confidence >= 0.90:
+        add_rule("R1_STRONG_MODEL_CONFIDENCE", "Neural classifier confidence >= 90%.", 0.30)
+    elif confidence >= 0.75:
+        add_rule("R1B_MEDIUM_MODEL_CONFIDENCE", "Neural classifier confidence >= 75%.", 0.20)
+
+    if hf_ratio >= 0.22:
+        add_rule("R2_HIGH_FREQUENCY_SPIKE", "FFT high-frequency ratio suggests synthetic artifacts.", 0.18)
+
+    if residual_std >= 0.09:
+        add_rule("R3_RESIDUAL_NOISE_PATTERN", "Residual noise variance is higher than expected for camera images.", 0.16)
+
+    if entropy <= 4.10 or entropy >= 6.40:
+        add_rule("R4_TEXTURE_REGULARITY_ANOMALY", "LBP entropy indicates atypical texture regularity.", 0.12)
+
+    if isinstance(source_pred, dict):
+        source_label = str(source_pred.get("label", "unknown")).lower()
+        top_prob = float(source_pred.get("top_prob", 0.0))
+        if source_label in {"gan", "diffusion"} and top_prob >= 0.70:
+            add_rule(
+                "R5_SOURCE_MODEL_AGREEMENT",
+                f"Source model supports {source_label.upper()} with {top_prob:.1%} confidence.",
+                0.14,
+            )
+
+    if isinstance(ethical_assessment, dict):
+        risk_score = float(ethical_assessment.get("risk_score", 0.0))
+        if risk_score >= 0.70:
+            add_rule("R6_ETHICAL_RISK_ALIGNMENT", "Ethical risk score is elevated and consistent with AI suspicion.", 0.10)
+
+    symbolic_score = _clip01(score)
+    decision = "SYMBOLIC_SUPPORTS_AI" if symbolic_score >= 0.55 else "SYMBOLIC_UNCERTAIN"
+
+    return {
+        "decision": decision,
+        "symbolic_score": symbolic_score,
+        "features": {
+            "residual_std": residual_std,
+            "hf_ratio": float(hf_ratio),
+            "lbp_entropy": entropy,
+            "ai_confidence": confidence,
+        },
+        "fired_rules": fired_rules,
+    }
+
+
+def format_neurosymbolic_report(result: Optional[Dict[str, Any]]) -> str:
+    """Format neurosymbolic output for UI textboxes."""
+    if not result:
+        return "Neurosymbolic analysis unavailable."
+
+    lines: List[str] = []
+    lines.append("Neurosymbolic Analysis")
+    lines.append(f"Decision: {result.get('decision', 'UNKNOWN')}")
+    lines.append(f"Symbolic score: {float(result.get('symbolic_score', 0.0)):.2%}")
+
+    features = result.get("features", {})
+    lines.append(
+        "Evidence features: "
+        f"residual_std={float(features.get('residual_std', 0.0)):.4f}, "
+        f"hf_ratio={float(features.get('hf_ratio', 0.0)):.4f}, "
+        f"lbp_entropy={float(features.get('lbp_entropy', 0.0)):.4f}"
+    )
+
+    fired_rules = result.get("fired_rules", [])
+    if fired_rules:
+        lines.append("Triggered rules:")
+        for item in fired_rules:
+            rule = str(item.get("rule", "RULE"))
+            reason = str(item.get("reason", ""))
+            weight = float(item.get("weight", 0.0))
+            lines.append(f"- {rule} (+{weight:.2f}): {reason}")
+    else:
+        lines.append("Triggered rules: none")
+
+    return "\n".join(lines)

src/components/AssessmentPanels.jsx

@@ -0,0 +1,93 @@
+import { BrainCircuit, ShieldAlert, ShieldCheck, Scale, Sparkles } from 'lucide-react';
+import styles from './AssessmentPanels.module.css';
+
+function SectionCard({ title, icon: Icon, tone = 'neutral', subtitle, children }) {
+  return (
+    <section className={`${styles.card} ${styles[`tone_${tone}`]}`}>
+      <div className={styles.header}>
+        <div className={styles.titleWrap}>
+          <div className={styles.iconWrap}><Icon size={16} /></div>
+          <div>
+            <h3 className={styles.title}>{title}</h3>
+            {subtitle ? <p className={styles.subtitle}>{subtitle}</p> : null}
+          </div>
+        </div>
+      </div>
+      <div className={styles.body}>{children}</div>
+    </section>
+  );
+}
+
+function Row({ label, value, mono = false, strong = false }) {
+  return (
+    <div className={styles.row}>
+      <span className={styles.label}>{label}</span>
+      <span className={`${styles.value} ${mono ? styles.mono : ''} ${strong ? styles.strong : ''}`}>{value}</span>
+    </div>
+  );
+}
+
+export default function AssessmentPanels({ result }) {
+  const ethical = result.ethical;
+  const neurosymbolic = result.neurosymbolic;
+  if (!ethical && !neurosymbolic) return null;
+
+  const ethicalTone = ethical ? (ethical.is_ethical ? 'positive' : 'critical') : 'neutral';
+  const nsTone = neurosymbolic?.decision === 'SYMBOLIC_SUPPORTS_AI' ? 'critical' : 'neutral';
+
+  return (
+    <div className={styles.grid}>
+      {neurosymbolic && (
+        <SectionCard
+          title="Neurosymbolic Analysis"
+          icon={BrainCircuit}
+          tone={nsTone}
+          subtitle="Symbolic rules layered over the model output for transparent forensic reasoning"
+        >
+          <Row label="Decision" value={neurosymbolic.decision?.replaceAll('_', ' ')} strong />
+          <Row label="Symbolic Score" value={`${((neurosymbolic.symbolic_score || 0) * 100).toFixed(1)}%`} />
+          {neurosymbolic.features && (
+            <>
+              <Row label="Residual Std" value={(neurosymbolic.features.residual_std || 0).toFixed(4)} mono />
+              <Row label="HF Ratio" value={(neurosymbolic.features.hf_ratio || 0).toFixed(4)} mono />
+              <Row label="LBP Entropy" value={(neurosymbolic.features.lbp_entropy || 0).toFixed(4)} mono />
+            </>
+          )}
+          <div className={styles.ruleBlock}>
+            <div className={styles.ruleTitle}><Sparkles size={14} />Triggered Rules</div>
+            {neurosymbolic.fired_rules?.length ? neurosymbolic.fired_rules.map((rule) => (
+              <div key={rule.rule} className={styles.ruleItem}>
+                <div className={styles.ruleHead}>
+                  <span className={styles.ruleCode}>{rule.rule}</span>
+                  <span className={styles.ruleWeight}>+{Number(rule.weight || 0).toFixed(2)}</span>
+                </div>
+                <p className={styles.ruleReason}>{rule.reason}</p>
+              </div>
+            )) : <p className={styles.empty}>No symbolic rules fired.</p>}
+          </div>
+        </SectionCard>
+      )}
+
+      {ethical && (
+        <SectionCard
+          title="Ethical Assessment"
+          icon={ethical.is_ethical ? ShieldCheck : ShieldAlert}
+          tone={ethicalTone}
+          subtitle="Risk-oriented interpretation layer for sensitive or harmful synthetic content"
+        >
+          <Row label="Status" value={ethical.status || 'UNKNOWN'} strong />
+          <Row label="Risk Score" value={`${((ethical.riskScore || 0) * 100).toFixed(1)}%`} />
+          <Row label="Simple Verdict" value={ethical.simpleStatus || 'Unavailable'} />
+          <div className={styles.flagBlock}>
+            <div className={styles.ruleTitle}><Scale size={14} />Flags</div>
+            <div className={styles.flagList}>
+              {ethical.flags?.length ? ethical.flags.map((flag) => (
+                <span key={flag} className={styles.flag}>{flag.replaceAll('_', ' ')}</span>
+              )) : <p className={styles.empty}>No ethical flags raised.</p>}
+            </div>
+          </div>
+        </SectionCard>
+      )}
+    </div>
+  );
+}

src/components/AssessmentPanels.module.css

@@ -0,0 +1,170 @@
+.grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 16px;
+}
+
+.card {
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-xl);
+  box-shadow: var(--shadow-sm);
+  padding: 18px;
+}
+
+.tone_positive {
+  border-color: rgba(0, 198, 122, 0.24);
+  box-shadow: 0 0 0 1px rgba(0, 198, 122, 0.08), var(--shadow-sm);
+}
+
+.tone_critical {
+  border-color: rgba(255, 71, 87, 0.24);
+  box-shadow: 0 0 0 1px rgba(255, 71, 87, 0.08), var(--shadow-sm);
+}
+
+.header {
+  margin-bottom: 14px;
+}
+
+.titleWrap {
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+}
+
+.iconWrap {
+  width: 34px;
+  height: 34px;
+  border-radius: 12px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--bg-surface-2);
+  color: var(--accent);
+}
+
+.title {
+  margin: 0;
+  color: var(--text-primary);
+  font-size: 16px;
+  font-weight: 700;
+}
+
+.subtitle {
+  margin: 4px 0 0;
+  color: var(--text-muted);
+  font-size: 12.5px;
+  line-height: 1.45;
+}
+
+.body {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.row {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 10px 0;
+  border-bottom: 1px solid var(--border);
+}
+
+.label {
+  color: var(--text-secondary);
+  font-size: 12.5px;
+  font-weight: 600;
+}
+
+.value {
+  color: var(--text-primary);
+  font-size: 12.5px;
+  text-align: right;
+}
+
+.strong { font-weight: 700; }
+.mono { font-family: var(--font-mono); }
+
+.ruleBlock,
+.flagBlock {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding-top: 6px;
+}
+
+.ruleTitle {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--text-secondary);
+  font-size: 12px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+}
+
+.ruleItem {
+  padding: 12px;
+  border-radius: var(--radius-md);
+  background: var(--bg-surface-2);
+  border: 1px solid var(--border);
+}
+
+.ruleHead {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 6px;
+}
+
+.ruleCode {
+  color: var(--text-primary);
+  font-size: 11.5px;
+  font-weight: 700;
+  font-family: var(--font-mono);
+}
+
+.ruleWeight {
+  color: var(--accent);
+  font-size: 11.5px;
+  font-weight: 700;
+}
+
+.ruleReason {
+  margin: 0;
+  color: var(--text-secondary);
+  font-size: 12.5px;
+  line-height: 1.45;
+}
+
+.flagList {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.flag {
+  background: var(--bg-surface-2);
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  padding: 6px 10px;
+  color: var(--text-primary);
+  font-size: 11.5px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+}
+
+.empty {
+  margin: 0;
+  color: var(--text-muted);
+  font-size: 12.5px;
+}
+
+@media (max-width: 960px) {
+  .grid {
+    grid-template-columns: 1fr;
+  }
+}

src/components/ForensicDashboard.jsx

@@ -5,6 +5,7 @@ import MediaPanel from './MediaPanel';
 import VerdictCard from './VerdictCard';
 import TemporalTimeline from './TemporalTimeline';
 import TechnicalMetadata from './TechnicalMetadata';
+import AssessmentPanels from './AssessmentPanels';
 import { downloadReport } from '../utils/generateReport';
 import styles from './ForensicDashboard.module.css';
 
@@ -98,6 +99,16 @@ export default function ForensicDashboard({ result, previewUrl, onReset }) {
             </motion.div>
           )}
 
+          {(result.neurosymbolic || result.ethical) && (
+            <motion.div
+              initial={{ opacity: 0, y: 16 }}
+              animate={{ opacity: 1, y: 0 }}
+              transition={{ delay: 0.35 }}
+            >
+              <AssessmentPanels result={result} />
+            </motion.div>
+          )}
+
           <motion.div
             initial={{ opacity: 0, y: 16 }}
             animate={{ opacity: 1, y: 0 }}