diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3295f50d..fb49246c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -99,7 +99,7 @@ jobs:
         run: python -m pytest tests/unit/test_user_mri_dataset.py tests/unit/test_user_collection_hook.py -v
 
       - name: Automatic report evidence and source preservation
-        run: python -m pytest tests/unit/test_report_evidence.py tests/unit/test_report_measurements.py tests/unit/test_report_measurement_cache.py tests/unit/test_quiz_report_questions.py -v
+        run: python -m pytest tests/unit/test_report_evidence.py tests/unit/test_report_consistency.py tests/unit/test_report_measurements.py tests/unit/test_report_measurement_cache.py tests/unit/test_quiz_report_questions.py -v
 
       - name: Path-safety unit tests
         run: python -m pytest tests/unit/test_path_safety.py -v
diff --git a/PanTS-Demo/src/components/ReportScreen/SourceConsistencyChecks.tsx b/PanTS-Demo/src/components/ReportScreen/SourceConsistencyChecks.tsx
new file mode 100644
index 00000000..09a8951a
--- /dev/null
+++ b/PanTS-Demo/src/components/ReportScreen/SourceConsistencyChecks.tsx
@@ -0,0 +1,31 @@
+import { CONSISTENCY_EXPLANATION, getConsistencyItems } from '../../helpers/reportConsistency';
+import type { ReportData } from '../../helpers/reportFindings';
+
+// Where the report's own sources disagree. A discrepancy asks a person to compare
+// sources; it is never a finding (docs/report-evidence.md, "Source consistency checks").
+export default function SourceConsistencyChecks({ data, dark = false }: { data: ReportData; dark?: boolean }) {
+  const items = getConsistencyItems(data.consistency);
+  if (items.length === 0) return null;
+  const discrepancies = items.filter(item => item.status === 'discrepancy');
+  const consistent = items.length - discrepancies.length;
+  const border = dark ? 'rgba(255,255,255,0.16)' : '#d9e0eb';
+  const summary = discrepancies.length
+    ? `Source consistency: ${discrepancies.length} ${discrepancies.length === 1 ? 'discrepancy' : 'discrepancies'} to review`
+    : `Source consistency: no discrepancies in ${items.length} ${items.length === 1 ? 'check' : 'checks'}`;
+  return (
+    <details data-testid="source-consistency" style={{ borderTop: `1px solid ${border}`, paddingTop: 14, marginBottom: 14 }}>
+      <summary style={{ cursor: 'pointer', fontSize: 15, fontWeight: 700 }}>{summary}</summary>
+      <p style={{ margin: '10px 0 8px', fontSize: 13.5 }}>{CONSISTENCY_EXPLANATION}</p>
+      {discrepancies.length > 0 && (
+        <ul aria-label="Source discrepancies" style={{ paddingLeft: 20, margin: '0 0 8px' }}>
+          {discrepancies.map(item => <li key={item.text} style={{ marginBottom: 4 }}>{item.text}</li>)}
+        </ul>
+      )}
+      {consistent > 0 && (
+        <p style={{ margin: 0, fontSize: 13, opacity: 0.8 }}>
+          {consistent} other {consistent === 1 ? 'check agrees' : 'checks agree'} across sources.
+        </p>
+      )}
+    </details>
+  );
+}
diff --git a/PanTS-Demo/src/components/ReportScreen/SourceReportDetails.tsx b/PanTS-Demo/src/components/ReportScreen/SourceReportDetails.tsx
index f148b2b9..58322c0e 100644
--- a/PanTS-Demo/src/components/ReportScreen/SourceReportDetails.tsx
+++ b/PanTS-Demo/src/components/ReportScreen/SourceReportDetails.tsx
@@ -1,6 +1,7 @@
 import { useState } from 'react';
 import { getCoverageLimitations, getSourceReportText, REPORT_ASSESSMENT_SCOPE } from '../../helpers/reportFindings';
 import type { ReportData } from '../../helpers/reportFindings';
+import SourceConsistencyChecks from './SourceConsistencyChecks';
 
 export default function SourceReportDetails({ data, dark = false }: { data: ReportData; dark?: boolean }) {
   const sourceText = getSourceReportText(data);
@@ -27,6 +28,7 @@ export default function SourceReportDetails({ data, dark = false }: { data: Repo
           {getCoverageLimitations(data).map(limitation => <li key={limitation}>{limitation}</li>)}
         </ul>
       </details>
+      <SourceConsistencyChecks data={data} dark={dark} />
       {sourceText ? (
         <details open={referenceOpen} style={{ borderTop: `1px solid ${dark ? 'rgba(255,255,255,0.16)' : '#d9e0eb'}`, paddingTop: 14, marginBottom: 18 }}>
           <summary onClick={event => { event.preventDefault(); setExpandedReference(referenceOpen ? null : data); }} style={{ cursor: 'pointer', fontSize: 16, fontWeight: 700 }}>
diff --git a/PanTS-Demo/src/helpers/reportConsistency.ts b/PanTS-Demo/src/helpers/reportConsistency.ts
new file mode 100644
index 00000000..34372917
--- /dev/null
+++ b/PanTS-Demo/src/helpers/reportConsistency.ts
@@ -0,0 +1,119 @@
+// Source consistency checks (flask-server/services/report_consistency.py).
+// Display text is built here from typed fields only; incoming prose is never
+// shown, matching how coverage limitations are handled (docs/report-evidence.md).
+
+export type ConsistencyKind = 'source_volume' | 'parts_whole' | 'recorded_sex';
+export type ConsistencyStatus = 'discrepancy' | 'consistent';
+
+export interface ConsistencyCheck {
+  kind: ConsistencyKind;
+  status: ConsistencyStatus;
+  structures: string[];
+  measured_volume?: number | null;
+  source_volume?: number | null;
+  parts_volume?: number | null;
+  whole_volume?: number | null;
+  difference_percent?: number | null;
+  recorded_sex?: string | null;
+}
+
+export interface ReportConsistency {
+  schema_version?: string;
+  checks: ConsistencyCheck[];
+  discrepancy_count?: number;
+}
+
+export interface ConsistencyItem {
+  kind: ConsistencyKind;
+  status: ConsistencyStatus;
+  text: string;
+}
+
+export const CONSISTENCY_EXPLANATION =
+  'These checks compare the sources this report already holds: segmentation measurements, the stored source '
+  + 'reference, and case metadata. A discrepancy means a person should compare the sources. It does not indicate '
+  + 'disease, and it does not say which source is correct.';
+
+const KINDS: ConsistencyKind[] = ['source_volume', 'parts_whole', 'recorded_sex'];
+const STRUCTURE = /^[a-z][a-z0-9_]*$/;
+
+export function structureLabel(name: string): string {
+  const side = /^(.*)_(left|right)$/.exec(name);
+  return (side ? `${side[2]} ${side[1]}` : name).replace(/_/g, ' ');
+}
+
+function cc(value: unknown): string | null {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? `${value.toFixed(1)} cc` : null;
+}
+
+function describe(check: ConsistencyCheck): string | null {
+  const [first, ...rest] = check.structures;
+  const name = structureLabel(first);
+  if (check.kind === 'source_volume') {
+    const measured = cc(check.measured_volume);
+    const source = cc(check.source_volume);
+    if (!measured || !source) return null;
+    return check.status === 'discrepancy'
+      ? `Measured ${name} volume (${measured}) and the volume stated in the source reference (${source}) do not match.`
+      : `Measured ${name} volume matches the source reference (${measured} vs. ${source}).`;
+  }
+  if (check.kind === 'parts_whole') {
+    const parts = cc(check.parts_volume);
+    if (!parts || rest.length === 0) return null;
+    const partNames = rest.map(structureLabel).join(', ');
+    const whole = cc(check.whole_volume);
+    if (check.status === 'discrepancy') {
+      return whole
+        ? `The ${name} measures ${whole}, but its parts (${partNames}) measure ${parts} in total.`
+        : `No ${name} measurement is available, but its parts (${partNames}) measure ${parts} in total.`;
+    }
+    return whole ? `The ${name} (${whole}) matches the sum of its parts (${parts}).` : null;
+  }
+  const measured = cc(check.measured_volume);
+  const sex = check.recorded_sex === 'F' ? 'female' : check.recorded_sex === 'M' ? 'male' : null;
+  if (!measured || !sex) return null;
+  return check.status === 'discrepancy'
+    ? `A ${name} mask (${measured}) is present, but the case metadata records sex as ${sex}. The metadata, the structure name, or the mask may be wrong.`
+    : `The ${name} mask matches the recorded sex.`;
+}
+
+const NUMBER_FIELDS = ['measured_volume', 'source_volume', 'parts_volume', 'whole_volume', 'difference_percent'] as const;
+
+/** Keep only typed fields from a server payload; prose such as `message` is discarded. */
+export function normalizeConsistency(value: unknown): ReportConsistency | undefined {
+  const checks = (value as { checks?: unknown } | null | undefined)?.checks;
+  if (!value || typeof value !== 'object' || !Array.isArray(checks)) return undefined;
+  const kept: ConsistencyCheck[] = [];
+  for (const raw of checks) {
+    if (!raw || typeof raw !== 'object') continue;
+    const check = raw as Record<string, unknown>;
+    const copy: ConsistencyCheck = {
+      kind: check.kind as ConsistencyKind,
+      status: check.status as ConsistencyStatus,
+      structures: Array.isArray(check.structures) ? check.structures.filter(name => typeof name === 'string') : [],
+      recorded_sex: typeof check.recorded_sex === 'string' ? check.recorded_sex : null,
+    };
+    for (const field of NUMBER_FIELDS) {
+      const number = check[field];
+      copy[field] = typeof number === 'number' && Number.isFinite(number) ? number : null;
+    }
+    kept.push(copy);
+  }
+  return { checks: kept };
+}
+
+/** Validated display items, discrepancies first. Malformed checks are dropped. */
+export function getConsistencyItems(consistency: unknown): ConsistencyItem[] {
+  const checks = (consistency as ReportConsistency | null | undefined)?.checks;
+  if (!Array.isArray(checks)) return [];
+  const items: ConsistencyItem[] = [];
+  for (const check of checks as ConsistencyCheck[]) {
+    if (!check || !KINDS.includes(check.kind)) continue;
+    if (check.status !== 'discrepancy' && check.status !== 'consistent') continue;
+    if (!Array.isArray(check.structures) || check.structures.length === 0
+      || !check.structures.every(name => typeof name === 'string' && STRUCTURE.test(name))) continue;
+    const text = describe(check);
+    if (text) items.push({ kind: check.kind, status: check.status, text });
+  }
+  return items.sort((a, b) => Number(b.status === 'discrepancy') - Number(a.status === 'discrepancy'));
+}
diff --git a/PanTS-Demo/src/helpers/reportFindings.ts b/PanTS-Demo/src/helpers/reportFindings.ts
index 86999c08..17f994a6 100644
--- a/PanTS-Demo/src/helpers/reportFindings.ts
+++ b/PanTS-Demo/src/helpers/reportFindings.ts
@@ -1,5 +1,8 @@
 // Report text and segmentation measurements are separate evidence sources.
 // Neither absent flags nor an in-range measurement establishes clinical normality.
+import { normalizeConsistency } from './reportConsistency';
+import type { ReportConsistency } from './reportConsistency';
+
 export interface OrganData {
   volume: number | null;
   mean_hu: number | null;
@@ -49,6 +52,7 @@ export interface ReportData {
     image_review_performed: boolean;
   };
   coverage?: { status: string; measured_structures: number; limitations: string[] };
+  consistency?: ReportConsistency;
 }
 
 const DEFAULT_LIMITATIONS = [
@@ -125,6 +129,7 @@ export function normalizeReportData(value: unknown): ReportData | null {
       status: 'limited', measured_structures: Object.keys(organ_volumes).length,
       limitations: trustedCoverageLimitations(Object.keys(organ_volumes).length, source.load_failed === true),
     },
+    consistency: normalizeConsistency(value.consistency),
   };
 }
 
diff --git a/PanTS-Demo/src/test/sourceConsistency.test.tsx b/PanTS-Demo/src/test/sourceConsistency.test.tsx
new file mode 100644
index 00000000..7f043a0f
--- /dev/null
+++ b/PanTS-Demo/src/test/sourceConsistency.test.tsx
@@ -0,0 +1,97 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import ReportScreen from '../components/ReportScreen/ReportScreen';
+import SourceReportDetails from '../components/ReportScreen/SourceReportDetails';
+import { getConsistencyItems, structureLabel } from '../helpers/reportConsistency';
+import { normalizeReportData } from '../helpers/reportFindings';
+import type { ReportData } from '../helpers/reportFindings';
+
+// Synthetic values only; no patient data.
+const checks = [
+  { kind: 'source_volume', status: 'consistent', structures: ['liver'], measured_volume: 1020, source_volume: 1000, difference_percent: 2 },
+  { kind: 'source_volume', status: 'discrepancy', structures: ['spleen'], measured_volume: 440, source_volume: 100, difference_percent: 340 },
+  { kind: 'parts_whole', status: 'discrepancy', structures: ['pancreas', 'pancreas_head', 'pancreas_body', 'pancreas_tail'], parts_volume: 113, whole_volume: null },
+  { kind: 'recorded_sex', status: 'discrepancy', structures: ['prostate'], measured_volume: 144.5, recorded_sex: 'F' },
+];
+
+function report(consistency: unknown): ReportData {
+  return {
+    case_id: 'synthetic-7', patient: { age: 'Unknown', sex: 'Unknown' }, organ_volumes: {},
+    comments: '', impression: [], consistency: consistency as ReportData['consistency'],
+    source_report: { available: true, source: 'Synthetic report fixture', text: 'Synthetic source.', findings: '', impression: [], reviewed_by_clinician: false },
+  };
+}
+
+describe('source consistency helper', () => {
+  it('labels sided structures readably', () => {
+    expect(structureLabel('kidney_left')).toBe('left kidney');
+    expect(structureLabel('adrenal_gland_right')).toBe('right adrenal gland');
+    expect(structureLabel('pancreas_head')).toBe('pancreas head');
+  });
+
+  it('builds text from typed fields, discrepancies first, and ignores incoming prose', () => {
+    const items = getConsistencyItems({ checks: checks.map(check => ({ ...check, message: 'All organs healthy.' })) });
+    expect(items.map(item => item.status)).toEqual(['discrepancy', 'discrepancy', 'discrepancy', 'consistent']);
+    expect(items[0].text).toBe('Measured spleen volume (440.0 cc) and the volume stated in the source reference (100.0 cc) do not match.');
+    expect(items[1].text).toBe('No pancreas measurement is available, but its parts (pancreas head, pancreas body, pancreas tail) measure 113.0 cc in total.');
+    expect(items.map(item => item.text).join(' ')).not.toMatch(/healthy/);
+  });
+
+  it('drops malformed or unknown checks', () => {
+    expect(getConsistencyItems(undefined)).toEqual([]);
+    expect(getConsistencyItems({ checks: 'nope' })).toEqual([]);
+    expect(getConsistencyItems({ checks: [
+      { kind: 'diagnosis', status: 'discrepancy', structures: ['spleen'], measured_volume: 1, source_volume: 2 },
+      { kind: 'source_volume', status: 'abnormal', structures: ['spleen'], measured_volume: 1, source_volume: 2 },
+      { kind: 'source_volume', status: 'discrepancy', structures: ['<script>'], measured_volume: 1, source_volume: 2 },
+      { kind: 'source_volume', status: 'discrepancy', structures: ['spleen'], measured_volume: Number.NaN, source_volume: 2 },
+      { kind: 'recorded_sex', status: 'discrepancy', structures: ['prostate'], measured_volume: 5, recorded_sex: 'unknown' },
+    ] })).toEqual([]);
+  });
+
+  it('uses no clinical wording or em-dashes', () => {
+    const text = getConsistencyItems({ checks }).map(item => item.text).join(' ');
+    expect(text).not.toMatch(/\b(normal|abnormal|enlarged|healthy|tumou?r|cancer|diagnos)/i);
+    expect(text).not.toContain('—');
+  });
+});
+
+describe('source consistency from a fetched report', () => {
+  afterEach(() => { vi.unstubAllGlobals(); vi.restoreAllMocks(); });
+
+  it('survives normalization without keeping incoming prose', () => {
+    const normalized = normalizeReportData({ ...report({ checks: checks.map(check => ({ ...check, message: 'All organs healthy.' })) }) });
+    expect(normalized?.consistency?.checks).toHaveLength(4);
+    expect(JSON.stringify(normalized?.consistency)).not.toContain('healthy');
+    expect(normalizeReportData({ ...report(undefined) })?.consistency).toBeUndefined();
+  });
+
+  it('appears in the report walkthrough loaded from the server', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, json: async () => report({ checks }) } as Response));
+    render(<ReportScreen id="synthetic-consistency" onClose={vi.fn()} onViewChange={vi.fn()} />);
+    expect(await screen.findByText('Source consistency: 3 discrepancies to review', { selector: 'summary' })).toBeInTheDocument();
+  });
+});
+
+describe('source consistency panel', () => {
+  it('shows a closed summary that expands to the discrepancies', () => {
+    render(<SourceReportDetails data={report({ checks })} />);
+    const summary = screen.getByText('Source consistency: 3 discrepancies to review', { selector: 'summary' });
+    expect(summary.closest('details')).not.toHaveAttribute('open');
+    fireEvent.click(summary);
+    expect(screen.getByRole('list', { name: 'Source discrepancies' }).children).toHaveLength(3);
+    expect(screen.getByText('1 other check agrees across sources.')).toBeInTheDocument();
+    expect(screen.getByText(/does not say which source is correct/)).toBeInTheDocument();
+  });
+
+  it('reports agreement when nothing disagrees', () => {
+    render(<SourceReportDetails data={report({ checks: [checks[0]] })} />);
+    expect(screen.getByText('Source consistency: no discrepancies in 1 check', { selector: 'summary' })).toBeInTheDocument();
+  });
+
+  it('renders nothing for older payloads without checks', () => {
+    render(<SourceReportDetails data={report(undefined)} />);
+    expect(screen.queryByTestId('source-consistency')).not.toBeInTheDocument();
+    expect(screen.getByText('Unverified source reference', { selector: 'summary' })).toBeInTheDocument();
+  });
+});
diff --git a/docs/report-evidence.md b/docs/report-evidence.md
index dfd7f23d..1d158487 100644
--- a/docs/report-evidence.md
+++ b/docs/report-evidence.md
@@ -39,6 +39,18 @@ conventions; without verified structure identities they are not used to produce
 organ measurements. Combined-only cases therefore retain their source report
 but show unavailable measurements.
 
+## Source consistency checks
+
+`consistency` compares sources the payload already holds and reports where they
+disagree: a volume stated in the stored source report against the measured
+volume of the same named structure, a whole structure against the sum of its
+parts (pancreas against head, body and tail), and a sex-specific structure
+against the recorded sex. A discrepancy asks a person to compare the sources. It
+is not a finding, it does not say which source is correct, and it never uses
+size or wording to suggest disease. The only value read from source text is a
+volume stated inside that structure's own section. Thresholds (5% and a 1 cc
+presence minimum) are placeholders for review. Logic: `services/report_consistency.py`.
+
 ## What this fixes
 
 - Unsupported counts of normal or healthy organs based on segmentation status.
@@ -69,7 +81,7 @@ reference preserves the original wording. Do not add patient reports, scans,
 credentials or production databases to fixtures or pull requests.
 
 Run `npm test` and `npm run build` in `PanTS-Demo`. In `flask-server`, run
-`python -m pytest tests/unit/test_report_evidence.py tests/unit/test_report_measurements.py tests/unit/test_report_measurement_cache.py tests/unit/test_quiz_report_questions.py`.
+`python -m pytest tests/unit/test_report_evidence.py tests/unit/test_report_consistency.py tests/unit/test_report_measurements.py tests/unit/test_report_measurement_cache.py tests/unit/test_quiz_report_questions.py`.
 The backend tests use generated files and isolate report functions from model
 services, production data, and database initialization.
 
diff --git a/flask-server/services/report_consistency.py b/flask-server/services/report_consistency.py
new file mode 100644
index 00000000..f14e07dd
--- /dev/null
+++ b/flask-server/services/report_consistency.py
@@ -0,0 +1,196 @@
+"""Consistency checks between the sources a report already holds.
+
+A report combines three sources: measurements from named segmentation masks,
+the stored (unverified) source report, and case metadata. When two of them give
+different values for the same thing, a reader cannot tell which to trust. These
+checks only point that out. They never assess disease, never decide which source
+is correct, and never classify report wording. The only thing read from source
+text is a volume the source states for a named structure, so it can be put next
+to the measured volume.
+
+Every threshold is a placeholder for review with the team, not a clinical cutoff.
+"""
+from __future__ import annotations
+
+import math
+import re
+
+CONSISTENCY_SCHEMA_VERSION = "1"
+CONSISTENCY_EXPLANATION = (
+    "These checks compare the sources this report already holds: segmentation "
+    "measurements, the stored source report, and case metadata. A discrepancy means "
+    "a person should compare the sources. It does not indicate disease, and it does "
+    "not say which source is correct."
+)
+
+# Stored source reports state volumes computed from masks of the same case
+# (services/label_scheme.py notes that the dataset spleen label matches the stored
+# spleen volume in every local case), so matching sources agree closely.
+SOURCE_VOLUME_TOLERANCE = 0.05
+# The whole structure is the union of its parts, so the sum should match closely.
+PARTS_TOLERANCE = 0.05
+# Ignore specks: a structure must measure at least this much to count as present.
+MIN_PRESENT_CC = 1.0
+
+# Source report section heading -> {mask name: pattern for the stated volume}.
+_NUMBER = r"([0-9]+(?:\.[0-9]+)?)\s*(?:cc|cm3|cm\^3|ml)\b"
+SOURCE_VOLUME_PATTERNS = {
+    "spleen": {"spleen": rf"(?<![a-z ])volume:\s*{_NUMBER}"},
+    "liver": {"liver": rf"(?<![a-z ])volume:\s*{_NUMBER}"},
+    "pancreas": {"pancreas": rf"(?<![a-z ])volume:\s*{_NUMBER}"},
+    "kidney": {
+        "kidney_right": rf"right kidney volume:\s*{_NUMBER}",
+        "kidney_left": rf"left kidney volume:\s*{_NUMBER}",
+    },
+}
+_SECTION_HEADING = re.compile(r"(?im)^\s*([a-z][a-z ]*?)\s*:\s*$")
+
+# Whole structure -> the parts it is made of (the pancreatic duct lies inside
+# the other parts, so it is not added).
+STRUCTURE_PARTS = {"pancreas": ("pancreas_head", "pancreas_body", "pancreas_tail")}
+
+# Structure -> the only recorded sex it is expected with.
+SEX_SPECIFIC_STRUCTURES = {"prostate": "M"}
+_SEX_VALUES = {"m": "M", "male": "M", "f": "F", "female": "F"}
+
+
+def _volume(organ_volumes, name):
+    try:
+        value = float((organ_volumes.get(name) or {}).get("volume"))
+    except (TypeError, ValueError):
+        return None
+    return value if math.isfinite(value) else None
+
+
+def _label(name):
+    for side in ("left", "right"):
+        if name.endswith(f"_{side}"):
+            return f"{side} {name[: -len(side) - 1].replace('_', ' ')}"
+    return name.replace("_", " ")
+
+
+def source_stated_volumes(findings_text):
+    """Return {mask name: volume in cc} for volumes the source states plainly.
+
+    Only a value inside the section for that structure is used, so a volume
+    mentioned under another heading is never attributed to the wrong organ.
+    """
+    text = str(findings_text or "")
+    headings = list(_SECTION_HEADING.finditer(text))
+    stated = {}
+    for index, heading in enumerate(headings):
+        section = heading.group(1).strip().lower()
+        patterns = SOURCE_VOLUME_PATTERNS.get(section) or SOURCE_VOLUME_PATTERNS.get(section.removesuffix("s"))
+        if not patterns:
+            continue
+        end = headings[index + 1].start() if index + 1 < len(headings) else len(text)
+        body = text[heading.end():end]
+        for name, pattern in patterns.items():
+            match = re.search(pattern, body, re.IGNORECASE)
+            if match and name not in stated:
+                stated[name] = float(match.group(1))
+    return stated
+
+
+def _relative_difference(a, b):
+    return abs(a - b) / b if b else math.inf
+
+
+def _source_volume_checks(organ_volumes, stated):
+    checks = []
+    for name, source_value in sorted(stated.items()):
+        measured = _volume(organ_volumes, name)
+        if measured is None:
+            continue
+        difference = _relative_difference(measured, source_value)
+        discrepancy = difference > SOURCE_VOLUME_TOLERANCE
+        checks.append({
+            "kind": "source_volume",
+            "structures": [name],
+            "status": "discrepancy" if discrepancy else "consistent",
+            "measured_volume": round(measured, 2),
+            "source_volume": round(source_value, 2),
+            "difference_percent": round(difference * 100, 1) if math.isfinite(difference) else None,
+            "message": (
+                f"The measured {_label(name)} volume ({measured:.1f} cc) and the volume stated in "
+                f"the stored source report ({source_value:.1f} cc) differ by more than "
+                f"{SOURCE_VOLUME_TOLERANCE:.0%}."
+                if discrepancy else
+                f"The measured {_label(name)} volume agrees with the stored source report "
+                f"within {SOURCE_VOLUME_TOLERANCE:.0%}."
+            ),
+        })
+    return checks
+
+
+def _parts_checks(organ_volumes):
+    checks = []
+    for whole, parts in STRUCTURE_PARTS.items():
+        part_volumes = [_volume(organ_volumes, part) for part in parts]
+        if any(value is None for value in part_volumes):
+            continue
+        total = sum(part_volumes)
+        if total < MIN_PRESENT_CC:
+            continue
+        whole_volume = _volume(organ_volumes, whole)
+        base = {"kind": "parts_whole", "structures": [whole, *parts],
+                "parts_volume": round(total, 2),
+                "whole_volume": None if whole_volume is None else round(whole_volume, 2)}
+        if whole_volume is None:
+            checks.append({**base, "status": "discrepancy", "difference_percent": None, "message": (
+                f"No {_label(whole)} measurement is available, but its parts "
+                f"({', '.join(_label(part) for part in parts)}) measure {total:.1f} cc in total."
+            )})
+            continue
+        difference = _relative_difference(whole_volume, total)
+        discrepancy = difference > PARTS_TOLERANCE
+        checks.append({**base, "status": "discrepancy" if discrepancy else "consistent",
+                       "difference_percent": round(difference * 100, 1), "message": (
+            f"The {_label(whole)} measures {whole_volume:.1f} cc, but its parts measure "
+            f"{total:.1f} cc in total."
+            if discrepancy else
+            f"The {_label(whole)} volume equals the sum of its parts within {PARTS_TOLERANCE:.0%}."
+        )})
+    return checks
+
+
+def _recorded_sex_checks(organ_volumes, patient):
+    recorded = _SEX_VALUES.get(str((patient or {}).get("sex") or "").strip().lower())
+    if recorded is None:
+        return []
+    checks = []
+    for name, expected in sorted(SEX_SPECIFIC_STRUCTURES.items()):
+        measured = _volume(organ_volumes, name)
+        if measured is None or measured < MIN_PRESENT_CC:
+            continue
+        discrepancy = recorded != expected
+        checks.append({
+            "kind": "recorded_sex",
+            "structures": [name],
+            "status": "discrepancy" if discrepancy else "consistent",
+            "measured_volume": round(measured, 2),
+            "recorded_sex": recorded,
+            "message": (
+                f"A {_label(name)} mask ({measured:.1f} cc) is present, but the case metadata "
+                f"records sex as {'female' if recorded == 'F' else 'male'}. The metadata, the "
+                f"structure name, or the mask may be wrong."
+                if discrepancy else
+                f"The {_label(name)} mask matches the recorded sex."
+            ),
+        })
+    return checks
+
+
+def report_consistency(organ_volumes=None, source_findings="", patient=None):
+    organ_volumes = organ_volumes or {}
+    checks = (
+        _source_volume_checks(organ_volumes, source_stated_volumes(source_findings))
+        + _parts_checks(organ_volumes)
+        + _recorded_sex_checks(organ_volumes, patient)
+    )
+    return {
+        "schema_version": CONSISTENCY_SCHEMA_VERSION,
+        "explanation": CONSISTENCY_EXPLANATION,
+        "checks": checks,
+        "discrepancy_count": sum(check["status"] == "discrepancy" for check in checks),
+    }
diff --git a/flask-server/services/report_evidence.py b/flask-server/services/report_evidence.py
index 3b36bdbd..e6a5fce0 100644
--- a/flask-server/services/report_evidence.py
+++ b/flask-server/services/report_evidence.py
@@ -9,6 +9,18 @@
 import math
 import re
 
+try:
+    from services.report_consistency import report_consistency
+except ImportError:  # Loaded as a standalone file (isolated unit tests).
+    import importlib.util as _importlib_util
+    from pathlib import Path as _Path
+
+    _spec = _importlib_util.spec_from_file_location(
+        "report_consistency", _Path(__file__).with_name("report_consistency.py"))
+    _consistency_module = _importlib_util.module_from_spec(_spec)
+    _spec.loader.exec_module(_consistency_module)
+    report_consistency = _consistency_module.report_consistency
+
 REPORT_SCHEMA_VERSION = "3"
 REPORT_SOURCE = "RadGPT metadata workbook"
 ASSESSMENT_SCOPE_EXPLANATION = (
@@ -88,6 +100,8 @@ def report_payload(case_id, raw, *, organ_volumes=None, lesions=None, patient=No
         "impression": [],
         "assessment_scope": report_assessment_scope(),
         "source_report": source,
+        # Compares sources already in this payload; never a finding or assessment.
+        "consistency": report_consistency(organs, source["findings"] if source["available"] else "", patient),
         "provenance": {
             "report_source": REPORT_SOURCE,
             "source_column": source_column,
diff --git a/flask-server/tests/unit/test_report_consistency.py b/flask-server/tests/unit/test_report_consistency.py
new file mode 100644
index 00000000..c6d55531
--- /dev/null
+++ b/flask-server/tests/unit/test_report_consistency.py
@@ -0,0 +1,135 @@
+"""Synthetic consistency regressions; no patient data, masks or API imports."""
+from __future__ import annotations
+
+import importlib.util
+import re
+from pathlib import Path
+
+import pytest
+
+SERVER = Path(__file__).resolve().parents[2]
+
+
+def load(name):
+    spec = importlib.util.spec_from_file_location(name, SERVER / f"services/{name}.py")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+consistency = load("report_consistency")
+evidence = load("report_evidence")
+
+SYNTHETIC_FINDINGS = """Synthetic source - not patient data.
+Spleen:
+Synthetic size wording (volume: 100.0 cc).
+Mean HU value: 40.0 +/- 10.0.
+
+Liver:
+Synthetic size wording (volume: 1000.0 cc).
+
+Pancreas:
+Synthetic size wording (volume: 50.0 cc).
+
+Kidney:
+Synthetic (right kidney volume: 150.0 cc; left kidney volume: 160.0 cc; total kidney volume: 310.0 cc).
+
+Stomach:
+Synthetic wording mentioning a volume: 999.0 cc that belongs to no checked structure.
+"""
+
+
+def organs(**volumes):
+    return {name: {"volume": value, "mean_hu": 40.0} for name, value in volumes.items()}
+
+
+def checks_of(result, kind):
+    return [check for check in result["checks"] if check["kind"] == kind]
+
+
+def test_reads_only_volumes_stated_in_each_structure_section():
+    stated = consistency.source_stated_volumes(SYNTHETIC_FINDINGS)
+    assert stated == {"spleen": 100.0, "liver": 1000.0, "pancreas": 50.0,
+                      "kidney_right": 150.0, "kidney_left": 160.0}
+
+
+def test_plural_section_heading_and_missing_text_are_handled():
+    assert consistency.source_stated_volumes("Kidneys:\nright kidney volume: 12.5 cc") == {"kidney_right": 12.5}
+    assert consistency.source_stated_volumes("") == {}
+    assert consistency.source_stated_volumes(None) == {}
+    # A volume outside any structure heading is never attributed.
+    assert consistency.source_stated_volumes("Spleen volume: 100 cc") == {}
+
+
+def test_source_volume_discrepancy_is_flagged_without_choosing_a_source():
+    result = consistency.report_consistency(organs(spleen=440.0, liver=1020.0), SYNTHETIC_FINDINGS)
+    by_structure = {check["structures"][0]: check for check in checks_of(result, "source_volume")}
+    assert by_structure["spleen"]["status"] == "discrepancy"
+    assert by_structure["spleen"]["difference_percent"] == 340.0
+    assert by_structure["liver"]["status"] == "consistent"
+    # Structures without a measurement are not compared.
+    assert "pancreas" not in by_structure
+    assert result["discrepancy_count"] == 1
+
+
+def test_whole_structure_missing_while_parts_are_measured():
+    result = consistency.report_consistency(organs(pancreas_head=56.0, pancreas_body=28.0, pancreas_tail=29.0))
+    [check] = checks_of(result, "parts_whole")
+    assert check["status"] == "discrepancy"
+    assert check["whole_volume"] is None and check["parts_volume"] == 113.0
+    assert "No pancreas measurement is available" in check["message"]
+
+
+@pytest.mark.parametrize("whole, status", [(75.5, "consistent"), (60.0, "discrepancy")])
+def test_whole_structure_compared_with_sum_of_parts(whole, status):
+    result = consistency.report_consistency(
+        organs(pancreas=whole, pancreas_head=46.7, pancreas_body=14.5, pancreas_tail=14.3))
+    [check] = checks_of(result, "parts_whole")
+    assert check["status"] == status
+
+
+def test_parts_check_needs_every_part():
+    result = consistency.report_consistency(organs(pancreas_head=56.0, pancreas_body=28.0))
+    assert checks_of(result, "parts_whole") == []
+
+
+@pytest.mark.parametrize("sex, expected", [
+    ("F", "discrepancy"), ("female", "discrepancy"), ("M", "consistent"), ("N/A", None), (None, None),
+])
+def test_sex_specific_structure_compared_with_recorded_sex(sex, expected):
+    result = consistency.report_consistency(organs(prostate=144.5), patient={"sex": sex})
+    found = checks_of(result, "recorded_sex")
+    assert [check["status"] for check in found] == ([expected] if expected else [])
+
+
+def test_specks_do_not_count_as_a_present_structure():
+    result = consistency.report_consistency(organs(prostate=0.4), patient={"sex": "F"})
+    assert checks_of(result, "recorded_sex") == []
+
+
+def test_messages_make_no_clinical_claims_and_use_no_em_dashes():
+    result = consistency.report_consistency(
+        organs(spleen=440.0, liver=1000.0, prostate=144.5,
+               pancreas_head=56.0, pancreas_body=28.0, pancreas_tail=29.0),
+        SYNTHETIC_FINDINGS, {"sex": "F"})
+    text = " ".join(check["message"] for check in result["checks"]) + result["explanation"]
+    assert result["discrepancy_count"] == 3
+    for word in ("normal", "abnormal", "enlarged", "healthy", "tumor", "cancer", "diagnos"):
+        assert not re.search(rf"\b{word}", " ".join(c["message"] for c in result["checks"]), re.I)
+    assert "—" not in text
+
+
+def test_report_payload_carries_consistency_and_keeps_scope():
+    raw = "FINDINGS:\n" + SYNTHETIC_FINDINGS + "\nIMPRESSION:\nSynthetic impression."
+    data = evidence.report_payload("7", raw, organ_volumes=organs(spleen=440.0), patient={"sex": "F"})
+    assert data["consistency"]["discrepancy_count"] == 1
+    assert data["consistency"]["checks"][0]["structures"] == ["spleen"]
+    assert data["assessment_scope"]["disease_assessment"] == "not_supported"
+    assert data["comments"] == "" and data["impression"] == []
+    assert data["organ_volumes"]["spleen"]["status"] == "not_assessed"
+
+
+def test_report_payload_without_source_or_masks_has_no_checks():
+    data = evidence.report_payload("7", "")
+    assert data["consistency"]["checks"] == []
+    assert data["consistency"]["discrepancy_count"] == 0