diff --git a/admin-compliance/app/sdk/iace/[projectId]/benchmark/_components/CategoryBreakdown.tsx b/admin-compliance/app/sdk/iace/[projectId]/benchmark/_components/CategoryBreakdown.tsx
new file mode 100644
index 0000000..c72c3ae
--- /dev/null
+++ b/admin-compliance/app/sdk/iace/[projectId]/benchmark/_components/CategoryBreakdown.tsx
@@ -0,0 +1,46 @@
+'use client'
+
+import React from 'react'
+import type { CategoryScore } from '../_hooks/useBenchmark'
+
+interface Props { breakdown: CategoryScore[] }
+
+const CATEGORY_LABELS: Record<string, string> = {
+  'mechanische gefaehrdungen': 'Mechanisch',
+  'elektrische gefaehrdungen': 'Elektrisch',
+  'thermische gefaehrdungen': 'Thermisch',
+  'laerm': 'Laerm',
+  'vibration': 'Vibration',
+  'strahlung': 'Strahlung',
+  'materialien und substanzen': 'Materialien/Substanzen',
+  'ergonomische gefaehrdungen': 'Ergonomie',
+  'einsatzumgebung': 'Einsatzumgebung',
+}
+
+export function CategoryBreakdown({ breakdown }: Props) {
+  if (!breakdown || breakdown.length === 0) return null
+
+  return (
+    <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+      <h3 className="text-sm font-semibold text-gray-700 dark:text-gray-300 mb-3">Coverage nach Gefaehrdungsgruppe</h3>
+      <div className="space-y-2">
+        {breakdown.map((cat) => {
+          const label = CATEGORY_LABELS[cat.category] || cat.category
+          const pct = Math.round(cat.coverage * 100)
+          const barColor = pct >= 80 ? 'bg-green-500' : pct >= 50 ? 'bg-yellow-500' : 'bg-red-500'
+          return (
+            <div key={cat.category}>
+              <div className="flex justify-between text-xs text-gray-600 dark:text-gray-400 mb-0.5">
+                <span>{label}</span>
+                <span>{cat.match_count}/{cat.gt_count} ({pct}%)</span>
+              </div>
+              <div className="h-2 bg-gray-100 dark:bg-gray-700 rounded-full overflow-hidden">
+                <div className={`h-full ${barColor} rounded-full transition-all`} style={{ width: `${pct}%` }} />
+              </div>
+            </div>
+          )
+        })}
+      </div>
+    </div>
+  )
+}
diff --git a/admin-compliance/app/sdk/iace/[projectId]/benchmark/_components/GTImportForm.tsx b/admin-compliance/app/sdk/iace/[projectId]/benchmark/_components/GTImportForm.tsx
new file mode 100644
index 0000000..ac69519
--- /dev/null
+++ b/admin-compliance/app/sdk/iace/[projectId]/benchmark/_components/GTImportForm.tsx
@@ -0,0 +1,121 @@
+'use client'
+
+import React, { useState, useRef } from 'react'
+import type { GroundTruthEntry } from '../_hooks/useBenchmark'
+
+interface Props {
+  onImport: (gt: { entries: GroundTruthEntry[]; source_file?: string; description?: string }) => Promise<void>
+  loading: boolean
+}
+
+export function GTImportForm({ onImport, loading }: Props) {
+  const [jsonText, setJsonText] = useState('')
+  const [parseError, setParseError] = useState<string | null>(null)
+  const [preview, setPreview] = useState<{ count: number; groups: Record<string, number> } | null>(null)
+  const fileRef = useRef<HTMLInputElement>(null)
+
+  function tryParse(text: string) {
+    setJsonText(text)
+    setParseError(null)
+    setPreview(null)
+    if (!text.trim()) return
+
+    try {
+      const parsed = JSON.parse(text)
+      const entries: GroundTruthEntry[] = parsed.entries || parsed
+      if (!Array.isArray(entries) || entries.length === 0) {
+        setParseError('JSON muss ein Array "entries" enthalten')
+        return
+      }
+      // Validate first entry has required fields
+      const first = entries[0]
+      if (!first.hazard_type && !first.hazard_group) {
+        setParseError('Eintraege muessen hazard_type oder hazard_group enthalten')
+        return
+      }
+      // Build preview
+      const groups: Record<string, number> = {}
+      for (const e of entries) {
+        const g = e.hazard_group || 'Unbekannt'
+        groups[g] = (groups[g] || 0) + 1
+      }
+      setPreview({ count: entries.length, groups })
+    } catch (err) {
+      setParseError('Ungueltiges JSON: ' + (err instanceof Error ? err.message : String(err)))
+    }
+  }
+
+  async function handleImport() {
+    if (!jsonText.trim()) return
+    try {
+      const parsed = JSON.parse(jsonText)
+      const gt = parsed.entries ? parsed : { entries: parsed }
+      await onImport(gt)
+      setJsonText('')
+      setPreview(null)
+    } catch (err) {
+      setParseError(err instanceof Error ? err.message : 'Import fehlgeschlagen')
+    }
+  }
+
+  function handleFileUpload(e: React.ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0]
+    if (!file) return
+    const reader = new FileReader()
+    reader.onload = (ev) => {
+      const text = ev.target?.result as string
+      tryParse(text)
+    }
+    reader.readAsText(file)
+  }
+
+  return (
+    <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+      <h3 className="text-sm font-semibold text-gray-700 dark:text-gray-300 mb-2">Ground Truth importieren</h3>
+      <p className="text-xs text-gray-500 mb-3">
+        JSON-Datei mit der professionellen Risikobeurteilung einfuegen oder hochladen.
+      </p>
+
+      <div className="flex gap-2 mb-3">
+        <button
+          onClick={() => fileRef.current?.click()}
+          className="px-3 py-1.5 text-xs bg-gray-100 hover:bg-gray-200 dark:bg-gray-700 dark:hover:bg-gray-600 rounded-md transition-colors"
+        >
+          JSON-Datei waehlen
+        </button>
+        <input ref={fileRef} type="file" accept=".json" onChange={handleFileUpload} className="hidden" />
+      </div>
+
+      <textarea
+        value={jsonText}
+        onChange={(e) => tryParse(e.target.value)}
+        placeholder='{"entries": [...], "source_file": "...", "description": "..."}'
+        rows={6}
+        className="w-full text-xs font-mono border border-gray-300 dark:border-gray-600 rounded-md p-2 bg-gray-50 dark:bg-gray-900 text-gray-800 dark:text-gray-200 resize-y"
+      />
+
+      {parseError && (
+        <div className="mt-2 px-3 py-2 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded text-xs text-red-600">
+          {parseError}
+        </div>
+      )}
+
+      {preview && (
+        <div className="mt-2 px-3 py-2 bg-green-50 dark:bg-green-900/20 border border-green-200 dark:border-green-800 rounded text-xs text-green-700 dark:text-green-400">
+          <strong>{preview.count} Eintraege</strong> erkannt:
+          {Object.entries(preview.groups).map(([g, c]) => (
+            <span key={g} className="ml-2">{g}: {c}</span>
+          ))}
+        </div>
+      )}
+
+      <button
+        onClick={handleImport}
+        disabled={loading || !preview}
+        className="mt-3 w-full px-4 py-2 text-sm font-medium bg-purple-600 hover:bg-purple-700 disabled:bg-gray-300 text-white rounded-md transition-colors"
+      >
+        {loading ? 'Importiere...' : 'Ground Truth importieren'}
+      </button>
+    </div>
+  )
+}
diff --git a/admin-compliance/app/sdk/iace/[projectId]/benchmark/_components/HazardComparisonTable.tsx b/admin-compliance/app/sdk/iace/[projectId]/benchmark/_components/HazardComparisonTable.tsx
new file mode 100644
index 0000000..4e0400f
--- /dev/null
+++ b/admin-compliance/app/sdk/iace/[projectId]/benchmark/_components/HazardComparisonTable.tsx
@@ -0,0 +1,158 @@
+'use client'
+
+import React, { useState } from 'react'
+import type { HazardMatchPair, GroundTruthEntry, HazardSummary } from '../_hooks/useBenchmark'
+
+interface Props {
+  matched: HazardMatchPair[]
+  missing: GroundTruthEntry[]
+  extra: HazardSummary[]
+}
+
+type TabType = 'matched' | 'missing' | 'extra'
+
+export function HazardComparisonTable({ matched, missing, extra }: Props) {
+  const [tab, setTab] = useState<TabType>('matched')
+
+  const tabs: { id: TabType; label: string; count: number; color: string }[] = [
+    { id: 'matched', label: 'Zugeordnet', count: matched.length, color: 'text-green-600' },
+    { id: 'missing', label: 'Fehlend', count: missing.length, color: 'text-red-600' },
+    { id: 'extra', label: 'Zusaetzlich', count: extra.length, color: 'text-gray-500' },
+  ]
+
+  return (
+    <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700">
+      {/* Tab bar */}
+      <div className="flex border-b border-gray-200 dark:border-gray-700">
+        {tabs.map((t) => (
+          <button
+            key={t.id}
+            onClick={() => setTab(t.id)}
+            className={`flex-1 px-4 py-2.5 text-xs font-medium transition-colors ${
+              tab === t.id
+                ? 'border-b-2 border-purple-600 text-purple-700 dark:text-purple-400'
+                : 'text-gray-500 hover:text-gray-700'
+            }`}
+          >
+            {t.label} <span className={t.color}>({t.count})</span>
+          </button>
+        ))}
+      </div>
+
+      <div className="overflow-x-auto">
+        {tab === 'matched' && <MatchedTable pairs={matched} />}
+        {tab === 'missing' && <MissingTable entries={missing} />}
+        {tab === 'extra' && <ExtraTable entries={extra} />}
+      </div>
+    </div>
+  )
+}
+
+function MatchedTable({ pairs }: { pairs: HazardMatchPair[] }) {
+  if (pairs.length === 0) return <EmptyState text="Keine Zuordnungen gefunden" />
+  return (
+    <table className="w-full text-xs">
+      <thead>
+        <tr className="bg-gray-50 dark:bg-gray-700/50">
+          <th className="px-3 py-2 text-left font-medium text-gray-500">Nr.</th>
+          <th className="px-3 py-2 text-left font-medium text-gray-500">Ground Truth</th>
+          <th className="px-3 py-2 text-left font-medium text-gray-500">R(GT)</th>
+          <th className="px-3 py-2 text-left font-medium text-gray-500">Engine</th>
+          <th className="px-3 py-2 text-center font-medium text-gray-500">Score</th>
+          <th className="px-3 py-2 text-left font-medium text-gray-500">Match</th>
+        </tr>
+      </thead>
+      <tbody className="divide-y divide-gray-100 dark:divide-gray-700">
+        {pairs.map((p, i) => (
+          <tr key={i} className="hover:bg-gray-50 dark:hover:bg-gray-700/30">
+            <td className="px-3 py-2 text-gray-400">{p.gt_entry.nr}</td>
+            <td className="px-3 py-2">
+              <div className="font-medium text-gray-800 dark:text-gray-200">{p.gt_entry.hazard_type}</div>
+              <div className="text-gray-400 truncate max-w-[250px]">{p.gt_entry.component_zone}</div>
+            </td>
+            <td className="px-3 py-2 text-center">
+              <RiskBadge risk={p.gt_entry.risk_in.r} />
+            </td>
+            <td className="px-3 py-2">
+              <div className="font-medium text-gray-800 dark:text-gray-200">{p.engine_hazard.name}</div>
+              <div className="text-gray-400">{p.engine_hazard.category}</div>
+            </td>
+            <td className="px-3 py-2 text-center">
+              <ScoreBadge score={p.match_score} />
+            </td>
+            <td className="px-3 py-2 text-gray-400">{p.match_reason}</td>
+          </tr>
+        ))}
+      </tbody>
+    </table>
+  )
+}
+
+function MissingTable({ entries }: { entries: GroundTruthEntry[] }) {
+  if (entries.length === 0) return <EmptyState text="Keine fehlenden Gefaehrdungen" />
+  return (
+    <table className="w-full text-xs">
+      <thead>
+        <tr className="bg-red-50 dark:bg-red-900/20">
+          <th className="px-3 py-2 text-left font-medium text-red-600">Nr.</th>
+          <th className="px-3 py-2 text-left font-medium text-red-600">Gefaehrdung</th>
+          <th className="px-3 py-2 text-left font-medium text-red-600">Ursache</th>
+          <th className="px-3 py-2 text-left font-medium text-red-600">Zone</th>
+          <th className="px-3 py-2 text-center font-medium text-red-600">R</th>
+          <th className="px-3 py-2 text-left font-medium text-red-600">Typ</th>
+        </tr>
+      </thead>
+      <tbody className="divide-y divide-gray-100 dark:divide-gray-700">
+        {entries.map((e, i) => (
+          <tr key={i} className="hover:bg-red-50/50">
+            <td className="px-3 py-2 text-gray-400">{e.nr}</td>
+            <td className="px-3 py-2 font-medium text-gray-800 dark:text-gray-200">{e.hazard_type}</td>
+            <td className="px-3 py-2 text-gray-600 truncate max-w-[200px]">{e.hazard_cause}</td>
+            <td className="px-3 py-2 text-gray-500">{e.component_zone}</td>
+            <td className="px-3 py-2 text-center"><RiskBadge risk={e.risk_in.r} /></td>
+            <td className="px-3 py-2 text-gray-500">{e.measure_type}</td>
+          </tr>
+        ))}
+      </tbody>
+    </table>
+  )
+}
+
+function ExtraTable({ entries }: { entries: HazardSummary[] }) {
+  if (entries.length === 0) return <EmptyState text="Keine zusaetzlichen Engine-Gefaehrdungen" />
+  return (
+    <table className="w-full text-xs">
+      <thead>
+        <tr className="bg-gray-50 dark:bg-gray-700/50">
+          <th className="px-3 py-2 text-left font-medium text-gray-500">Name</th>
+          <th className="px-3 py-2 text-left font-medium text-gray-500">Kategorie</th>
+          <th className="px-3 py-2 text-left font-medium text-gray-500">Zone</th>
+        </tr>
+      </thead>
+      <tbody className="divide-y divide-gray-100 dark:divide-gray-700">
+        {entries.map((e, i) => (
+          <tr key={i} className="hover:bg-gray-50 dark:hover:bg-gray-700/30">
+            <td className="px-3 py-2 text-gray-800 dark:text-gray-200">{e.name}</td>
+            <td className="px-3 py-2 text-gray-500">{e.category}</td>
+            <td className="px-3 py-2 text-gray-400">{e.zone || '-'}</td>
+          </tr>
+        ))}
+      </tbody>
+    </table>
+  )
+}
+
+function RiskBadge({ risk }: { risk: number }) {
+  const color = risk >= 30 ? 'bg-red-100 text-red-700' : risk >= 15 ? 'bg-yellow-100 text-yellow-700' : 'bg-green-100 text-green-700'
+  return <span className={`inline-block px-1.5 py-0.5 rounded text-[10px] font-bold ${color}`}>{risk}</span>
+}
+
+function ScoreBadge({ score }: { score: number }) {
+  const pct = Math.round(score * 100)
+  const color = pct >= 70 ? 'text-green-600' : pct >= 50 ? 'text-yellow-600' : 'text-red-600'
+  return <span className={`font-bold ${color}`}>{pct}%</span>
+}
+
+function EmptyState({ text }: { text: string }) {
+  return <div className="px-4 py-8 text-center text-sm text-gray-400">{text}</div>
+}
diff --git a/admin-compliance/app/sdk/iace/[projectId]/benchmark/_hooks/useBenchmark.ts b/admin-compliance/app/sdk/iace/[projectId]/benchmark/_hooks/useBenchmark.ts
new file mode 100644
index 0000000..f309cb8
--- /dev/null
+++ b/admin-compliance/app/sdk/iace/[projectId]/benchmark/_hooks/useBenchmark.ts
@@ -0,0 +1,115 @@
+'use client'
+
+import { useState, useCallback } from 'react'
+
+export interface GTRisk { f: number; w: number; p: number; s: number; r: number }
+export interface GTPLr { s: string; f: string; p: string; ew?: string; plr: string }
+
+export interface GroundTruthEntry {
+  nr: string
+  hazard_group: string
+  hazard_group_applicable: boolean
+  hazard_subgroup: string
+  hazard_type: string
+  hazard_cause: string
+  lifecycle_phases: string[]
+  component_zone: string
+  risk_in: GTRisk
+  plr?: GTPLr | null
+  measures: string[]
+  measure_type: string
+  risk_out: GTRisk
+  norm_references: string[]
+  sufficient: boolean
+  comment?: string
+  reduction_steps?: {
+    risk_in: GTRisk; measures: string[]; measure_type: string
+    risk_out: GTRisk; norm_references: string[]; sufficient: boolean
+  }[]
+}
+
+export interface HazardSummary {
+  id: string; name: string; category: string
+  component?: string; zone?: string; risk_level?: string
+}
+
+export interface HazardMatchPair {
+  gt_entry: GroundTruthEntry
+  engine_hazard: HazardSummary
+  match_score: number
+  match_reason: string
+}
+
+export interface CategoryScore {
+  category: string; gt_count: number; match_count: number; coverage: number
+}
+
+export interface BenchmarkResult {
+  coverage_score: number
+  measure_coverage: number
+  total_gt: number
+  total_engine: number
+  matched_pairs: HazardMatchPair[]
+  missing_from_engine: GroundTruthEntry[]
+  extra_in_engine: HazardSummary[]
+  category_breakdown: CategoryScore[]
+  risk_rank_pairs: { gt_rank: number; engine_rank: number; hazard_name: string; gt_risk_score: number }[]
+}
+
+interface UseBenchmarkReturn {
+  result: BenchmarkResult | null
+  gtLoaded: boolean
+  gtEntryCount: number
+  loading: boolean
+  error: string | null
+  importGT: (gt: { entries: GroundTruthEntry[]; source_file?: string; description?: string }) => Promise<void>
+  runBenchmark: (gtProjectId?: string) => Promise<void>
+}
+
+export function useBenchmark(projectId: string): UseBenchmarkReturn {
+  const [result, setResult] = useState<BenchmarkResult | null>(null)
+  const [gtLoaded, setGtLoaded] = useState(false)
+  const [gtEntryCount, setGtEntryCount] = useState(0)
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const importGT = useCallback(async (gt: { entries: GroundTruthEntry[]; source_file?: string; description?: string }) => {
+    setLoading(true)
+    setError(null)
+    try {
+      const res = await fetch(`/api/sdk/v1/iace/projects/${projectId}/benchmark/import-gt`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(gt),
+      })
+      if (!res.ok) throw new Error(await res.text())
+      const data = await res.json()
+      setGtLoaded(true)
+      setGtEntryCount(data.entry_count || gt.entries.length)
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Import failed')
+    } finally {
+      setLoading(false)
+    }
+  }, [projectId])
+
+  const runBenchmark = useCallback(async (gtProjectId?: string) => {
+    setLoading(true)
+    setError(null)
+    try {
+      const params = gtProjectId ? `?gt_project_id=${gtProjectId}` : ''
+      const res = await fetch(`/api/sdk/v1/iace/projects/${projectId}/benchmark${params}`)
+      if (!res.ok) throw new Error(await res.text())
+      const data: BenchmarkResult = await res.json()
+      setResult(data)
+      setGtLoaded(true)
+      setGtEntryCount(data.total_gt)
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Benchmark failed')
+    } finally {
+      setLoading(false)
+    }
+  }, [projectId])
+
+  return { result, gtLoaded, gtEntryCount, loading, error, importGT, runBenchmark }
+}
diff --git a/admin-compliance/app/sdk/iace/[projectId]/benchmark/page.tsx b/admin-compliance/app/sdk/iace/[projectId]/benchmark/page.tsx
new file mode 100644
index 0000000..bbcd99a
--- /dev/null
+++ b/admin-compliance/app/sdk/iace/[projectId]/benchmark/page.tsx
@@ -0,0 +1,160 @@
+'use client'
+
+import React, { useState } from 'react'
+import { useParams } from 'next/navigation'
+import { useBenchmark } from './_hooks/useBenchmark'
+import { GTImportForm } from './_components/GTImportForm'
+import { HazardComparisonTable } from './_components/HazardComparisonTable'
+import { CategoryBreakdown } from './_components/CategoryBreakdown'
+
+export default function BenchmarkPage() {
+  const { projectId } = useParams<{ projectId: string }>()
+  const { result, gtLoaded, gtEntryCount, loading, error, importGT, runBenchmark } = useBenchmark(projectId)
+  const [gtProjectId, setGtProjectId] = useState('')
+
+  const coveragePct = result ? Math.round(result.coverage_score * 100) : 0
+  const measurePct = result ? Math.round(result.measure_coverage * 100) : 0
+
+  return (
+    <div className="space-y-6 max-w-[1200px]">
+      {/* Header */}
+      <div>
+        <h1 className="text-lg font-bold text-gray-900 dark:text-white">Ground Truth Benchmark</h1>
+        <p className="text-sm text-gray-500 mt-1">
+          Vergleich der Engine-Ergebnisse mit einer professionellen Risikobeurteilung
+        </p>
+      </div>
+
+      {error && (
+        <div className="px-4 py-3 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-lg text-sm text-red-600">
+          {error}
+        </div>
+      )}
+
+      {/* GT Import or Cross-Project Reference */}
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-4">
+        <GTImportForm onImport={importGT} loading={loading} />
+
+        <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+          <h3 className="text-sm font-semibold text-gray-700 dark:text-gray-300 mb-2">Benchmark ausfuehren</h3>
+          <p className="text-xs text-gray-500 mb-3">
+            GT aus diesem Projekt verwenden, oder eine Projekt-ID mit importierter GT angeben.
+          </p>
+
+          <div className="space-y-2">
+            <input
+              type="text"
+              value={gtProjectId}
+              onChange={(e) => setGtProjectId(e.target.value)}
+              placeholder="GT-Projekt-ID (optional — leer = dieses Projekt)"
+              className="w-full text-xs border border-gray-300 dark:border-gray-600 rounded-md px-3 py-2 bg-gray-50 dark:bg-gray-900"
+            />
+            <button
+              onClick={() => runBenchmark(gtProjectId || undefined)}
+              disabled={loading}
+              className="w-full px-4 py-2 text-sm font-medium bg-purple-600 hover:bg-purple-700 disabled:bg-gray-300 text-white rounded-md transition-colors"
+            >
+              {loading ? 'Vergleiche...' : 'Benchmark starten'}
+            </button>
+          </div>
+
+          {gtLoaded && !result && (
+            <div className="mt-3 px-3 py-2 bg-blue-50 dark:bg-blue-900/20 rounded text-xs text-blue-600">
+              {gtEntryCount} GT-Eintraege geladen. Klicke &quot;Benchmark starten&quot;.
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Results */}
+      {result && (
+        <>
+          {/* Score Cards */}
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+            <ScoreCard
+              label="Hazard Coverage"
+              value={`${coveragePct}%`}
+              sub={`${result.matched_pairs?.length || 0} / ${result.total_gt} erkannt`}
+              color={coveragePct >= 80 ? 'green' : coveragePct >= 50 ? 'yellow' : 'red'}
+            />
+            <ScoreCard
+              label="Massnahmen-Coverage"
+              value={`${measurePct}%`}
+              sub="der zugeordneten Gefaehrdungen"
+              color={measurePct >= 80 ? 'green' : measurePct >= 50 ? 'yellow' : 'red'}
+            />
+            <ScoreCard
+              label="GT Eintraege"
+              value={String(result.total_gt)}
+              sub="professionelle Beurteilung"
+              color="gray"
+            />
+            <ScoreCard
+              label="Engine Eintraege"
+              value={String(result.total_engine)}
+              sub={`${result.extra_in_engine?.length || 0} zusaetzlich`}
+              color="gray"
+            />
+          </div>
+
+          {/* Category Breakdown */}
+          <CategoryBreakdown breakdown={result.category_breakdown || []} />
+
+          {/* Hazard Comparison Table */}
+          <HazardComparisonTable
+            matched={result.matched_pairs || []}
+            missing={result.missing_from_engine || []}
+            extra={result.extra_in_engine || []}
+          />
+
+          {/* Business Impact */}
+          <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+            <h3 className="text-sm font-semibold text-gray-700 dark:text-gray-300 mb-2">Business Impact</h3>
+            <div className="grid grid-cols-3 gap-4 text-center">
+              <div>
+                <div className="text-2xl font-bold text-gray-900 dark:text-white">2,5 Tage</div>
+                <div className="text-xs text-gray-500">Manueller Aufwand</div>
+              </div>
+              <div>
+                <div className="text-2xl font-bold text-purple-600">
+                  {(coveragePct / 100 * 2.5).toFixed(1)} Tage
+                </div>
+                <div className="text-xs text-gray-500">Eingespart bei {coveragePct}% Coverage</div>
+              </div>
+              <div>
+                <div className="text-2xl font-bold text-green-600">
+                  {Math.round(coveragePct / 100 * 2.5 * 8 * 100)} EUR
+                </div>
+                <div className="text-xs text-gray-500">Einsparung (100 EUR/h)</div>
+              </div>
+            </div>
+          </div>
+        </>
+      )}
+    </div>
+  )
+}
+
+function ScoreCard({ label, value, sub, color }: {
+  label: string; value: string; sub: string
+  color: 'green' | 'yellow' | 'red' | 'gray'
+}) {
+  const colors = {
+    green: 'border-green-200 dark:border-green-800',
+    yellow: 'border-yellow-200 dark:border-yellow-800',
+    red: 'border-red-200 dark:border-red-800',
+    gray: 'border-gray-200 dark:border-gray-700',
+  }
+  const textColors = {
+    green: 'text-green-600', yellow: 'text-yellow-600',
+    red: 'text-red-600', gray: 'text-gray-900 dark:text-white',
+  }
+
+  return (
+    <div className={`bg-white dark:bg-gray-800 rounded-lg border-2 ${colors[color]} p-4 text-center`}>
+      <div className={`text-2xl font-bold ${textColors[color]}`}>{value}</div>
+      <div className="text-xs font-medium text-gray-700 dark:text-gray-300 mt-1">{label}</div>
+      <div className="text-[10px] text-gray-400 mt-0.5">{sub}</div>
+    </div>
+  )
+}
diff --git a/admin-compliance/app/sdk/iace/[projectId]/tech-file/_components/ReportPrintView.tsx b/admin-compliance/app/sdk/iace/[projectId]/tech-file/_components/ReportPrintView.tsx
index 8f740da..5e04883 100644
--- a/admin-compliance/app/sdk/iace/[projectId]/tech-file/_components/ReportPrintView.tsx
+++ b/admin-compliance/app/sdk/iace/[projectId]/tech-file/_components/ReportPrintView.tsx
@@ -119,10 +119,61 @@ export function ReportPrintView({ data }: ReportPrintViewProps) {
         Herstellers nach EU Maschinenverordnung 2023/1230 Art. 10.
       </div>
 
-      {/* 2. Inhaltsverzeichnis */}
+      {/* 2. Methodik der Risikobeurteilung (Erklaerteil) */}
+      <div className="section-break">
+        <h2>Methodik der Risikobeurteilung</h2>
+        <p>
+          Diese Risikobeurteilung orientiert sich an den Grundprinzipien der EN ISO 12100,
+          EN 62061 und EN ISO 13849-1. Bewertet werden Grenzen des Produkts, identifizierte
+          Gefaehrdungen, die jeweilige Risikohoehe sowie das Restrisiko nach Anwendung von
+          Schutzmassnahmen.
+        </p>
+        <p>
+          Der Prozess ist iterativ: Reicht eine Massnahme nicht aus, werden weitere ergriffen
+          und das Restrisiko erneut bewertet, bis ein akzeptables Niveau erreicht ist.
+        </p>
+        <h3>Risikoberechnung</h3>
+        <p>Das Ausgangsrisiko ergibt sich aus: <strong>R = S &times; F &times; P &times; A</strong></p>
+        <table>
+          <thead>
+            <tr><th>Faktor</th><th>Beschreibung</th><th>Skala</th></tr>
+          </thead>
+          <tbody>
+            <tr><td><strong>S</strong></td><td>Schadensschwere</td><td>1 (Erste Hilfe) – 5 (toedlich)</td></tr>
+            <tr><td><strong>F</strong></td><td>Expositionshaeufigkeit</td><td>1 (selten/kurz) – 5 (dauerhaft)</td></tr>
+            <tr><td><strong>P</strong></td><td>Eintrittswahrscheinlichkeit</td><td>1 (vernachlaessigbar) – 5 (fast sicher)</td></tr>
+            <tr><td><strong>A</strong></td><td>Vermeidbarkeit</td><td>1 (leicht vermeidbar) – 5 (unvermeidbar)</td></tr>
+          </tbody>
+        </table>
+        <p>
+          Bei Sicherheitskreisen wird der Performance Level (PLr) ueber einen Risikographen
+          abgeleitet und dem Safety Integrity Level (SIL) zugeordnet.
+        </p>
+        <h3>Dreistufenmethode</h3>
+        <p>Schutzmassnahmen werden priorisiert angewandt:</p>
+        <ol>
+          <li><strong>Konstruktive Massnahmen (KM)</strong> — Inhaerent sichere Gestaltung</li>
+          <li><strong>Technische Schutzmassnahmen (TM)</strong> — Schutzeinrichtungen, Sicherheitssteuerungen</li>
+          <li><strong>Benutzerinformationen (BI)</strong> — Warnhinweise, Betriebsanleitung</li>
+        </ol>
+        <h3>Akzeptanz des Restrisikos</h3>
+        <p>
+          Ein Restrisiko gilt als hinreichend gemindert, wenn alle praktisch umsetzbaren Massnahmen
+          ausgeschoepft wurden und Anwender ueber verbleibende Restrisiken informiert sind.
+          Die Akzeptanz wird pro Gefaehrdung mit <strong>JA</strong> / <strong>NEIN</strong> dokumentiert.
+        </p>
+        <p style={{ fontStyle: 'italic', fontSize: '9pt', color: '#374151' }}>
+          &bdquo;Die Moeglichkeit, einen hoeheren Sicherheitsgrad zu erreichen, oder die Verfuegbarkeit
+          anderer Produkte, die ein geringeres Risiko darstellen, ist kein ausreichender Grund,
+          ein Produkt als gefaehrlich anzusehen.&ldquo; — § 3 Abs. 2 ProdSG
+        </p>
+      </div>
+
+      {/* 3. Inhaltsverzeichnis */}
       <div className="section-break">
         <h2>Inhaltsverzeichnis</h2>
         <ol className="toc">
+          <li>Methodik der Risikobeurteilung</li>
           <li>Maschinenbeschreibung</li>
           <li>Angewandte Normen</li>
           <li>Gefaehrdungsliste</li>
diff --git a/admin-compliance/app/sdk/iace/layout.tsx b/admin-compliance/app/sdk/iace/layout.tsx
index 5dd3c80..b8c12ea 100644
--- a/admin-compliance/app/sdk/iace/layout.tsx
+++ b/admin-compliance/app/sdk/iace/layout.tsx
@@ -24,6 +24,7 @@ const IACE_EXTRA_ITEMS = [
   { id: 'knowledge-graph', label: 'Knowledge Graph', href: '/knowledge-graph', icon: 'activity' },
   { id: 'classification', label: 'Klassifikation', href: '/classification', icon: 'tag' },
   { id: 'monitoring', label: 'Monitoring', href: '/monitoring', icon: 'activity' },
+  { id: 'benchmark', label: 'Benchmark', href: '/benchmark', icon: 'check' },
 ]
 
 function NavIcon({ icon, className }: { icon: string; className?: string }) {
diff --git a/ai-compliance-sdk/internal/api/handlers/iace_handler_benchmark.go b/ai-compliance-sdk/internal/api/handlers/iace_handler_benchmark.go
new file mode 100644
index 0000000..ad3990d
--- /dev/null
+++ b/ai-compliance-sdk/internal/api/handlers/iace_handler_benchmark.go
@@ -0,0 +1,162 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/breakpilot/ai-compliance-sdk/internal/iace"
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+// ImportGroundTruth handles POST /projects/:id/benchmark/import-gt
+// Stores Ground Truth data in project metadata.ground_truth.
+func (h *IACEHandler) ImportGroundTruth(c *gin.Context) {
+	projectID, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid project ID"})
+		return
+	}
+
+	ctx := c.Request.Context()
+	project, err := h.store.GetProject(ctx, projectID)
+	if err != nil || project == nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "project not found"})
+		return
+	}
+
+	var gt iace.GroundTruth
+	if err := c.ShouldBindJSON(&gt); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid ground truth JSON: " + err.Error()})
+		return
+	}
+
+	if gt.ImportedAt == "" {
+		gt.ImportedAt = time.Now().Format("2006-01-02")
+	}
+
+	// Merge into existing metadata
+	meta := make(map[string]json.RawMessage)
+	if project.Metadata != nil {
+		_ = json.Unmarshal(project.Metadata, &meta)
+	}
+	gtJSON, _ := json.Marshal(gt)
+	meta["ground_truth"] = gtJSON
+
+	mergedMeta, _ := json.Marshal(meta)
+	err = h.store.UpdateProjectMetadata(ctx, projectID, mergedMeta)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to store ground truth"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"message":     "ground truth imported",
+		"entry_count": len(gt.Entries),
+		"source_file": gt.SourceFile,
+	})
+}
+
+// RunBenchmark handles GET /projects/:id/benchmark?gt_project_id=:gtId
+// Compares engine hazards from project :id against GT from project :gtId.
+// If gt_project_id is omitted, looks for GT in the same project's metadata.
+func (h *IACEHandler) RunBenchmark(c *gin.Context) {
+	projectID, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid project ID"})
+		return
+	}
+
+	ctx := c.Request.Context()
+
+	// Determine GT source
+	gtProjectID := projectID
+	if gtParam := c.Query("gt_project_id"); gtParam != "" {
+		parsed, err := uuid.Parse(gtParam)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid gt_project_id"})
+			return
+		}
+		gtProjectID = parsed
+	}
+
+	// Load GT
+	gtProject, err := h.store.GetProject(ctx, gtProjectID)
+	if err != nil || gtProject == nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "GT project not found"})
+		return
+	}
+	gt, err := iace.ParseGroundTruth(gtProject.Metadata)
+	if err != nil || gt == nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "no ground truth data in project metadata"})
+		return
+	}
+
+	// Load engine hazards + mitigations
+	hazards, err := h.store.ListHazards(ctx, projectID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to load hazards"})
+		return
+	}
+	mitigations, err := h.store.ListMitigationsByProject(ctx, projectID)
+	if err != nil {
+		mitigations = nil
+	}
+
+	result := iace.CompareBenchmark(gt, hazards, mitigations)
+	c.JSON(http.StatusOK, result)
+}
+
+// GetBenchmarkSummary handles GET /projects/:id/benchmark/summary
+// Returns lightweight coverage metrics without full match details.
+func (h *IACEHandler) GetBenchmarkSummary(c *gin.Context) {
+	projectID, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid project ID"})
+		return
+	}
+
+	ctx := c.Request.Context()
+
+	gtProjectID := projectID
+	if gtParam := c.Query("gt_project_id"); gtParam != "" {
+		parsed, err := uuid.Parse(gtParam)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid gt_project_id"})
+			return
+		}
+		gtProjectID = parsed
+	}
+
+	gtProject, err := h.store.GetProject(ctx, gtProjectID)
+	if err != nil || gtProject == nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "GT project not found"})
+		return
+	}
+	gt, err := iace.ParseGroundTruth(gtProject.Metadata)
+	if err != nil || gt == nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "no ground truth data"})
+		return
+	}
+
+	hazards, err := h.store.ListHazards(ctx, projectID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to load hazards"})
+		return
+	}
+	mitigations, _ := h.store.ListMitigationsByProject(ctx, projectID)
+
+	result := iace.CompareBenchmark(gt, hazards, mitigations)
+
+	c.JSON(http.StatusOK, gin.H{
+		"coverage_score":     result.CoverageScore,
+		"measure_coverage":   result.MeasureCoverage,
+		"total_gt":           result.TotalGT,
+		"total_engine":       result.TotalEngine,
+		"matched_count":      len(result.MatchedPairs),
+		"missing_count":      len(result.MissingFromEngine),
+		"extra_count":        len(result.ExtraInEngine),
+		"category_breakdown": result.CategoryBreakdown,
+	})
+}
diff --git a/ai-compliance-sdk/internal/api/handlers/iace_handler_init.go b/ai-compliance-sdk/internal/api/handlers/iace_handler_init.go
index 67f3e45..4f22b49 100644
--- a/ai-compliance-sdk/internal/api/handlers/iace_handler_init.go
+++ b/ai-compliance-sdk/internal/api/handlers/iace_handler_init.go
@@ -143,26 +143,53 @@ func (h *IACEHandler) InitializeProject(c *gin.Context) {
 	if len(existingHazards) == 0 && len(matchOutput.MatchedPatterns) > 0 {
 		comps, _ := h.store.ListComponents(ctx, projectID)
 		var defaultCompID uuid.UUID
+		compByName := make(map[string]uuid.UUID)
 		if len(comps) > 0 {
 			defaultCompID = comps[0].ID
+			for _, c := range comps {
+				compByName[iace.NormalizeDEPublic(c.Name)] = c.ID
+			}
 		}
 
 		created := 0
-		seenCat := make(map[string]bool)
+		seenCatZone := make(map[string]bool)
 		for _, mp := range matchOutput.MatchedPatterns {
 			for _, cat := range mp.HazardCats {
-				if seenCat[cat] {
+				// Dedup by category + zone (allows multiple hazards per category at different zones)
+				zoneKey := mp.ZoneDE
+				if zoneKey == "" {
+					zoneKey = mp.PatternID
+				}
+				dedupKey := cat + ":" + zoneKey
+				if seenCatZone[dedupKey] {
 					continue
 				}
-				seenCat[cat] = true
+				seenCatZone[dedupKey] = true
 
 				name := mp.PatternName
 				if name == "" {
 					name = cat
 				}
+				// Append zone to name for specificity
+				if mp.ZoneDE != "" && !containsSubstring(name, mp.ZoneDE) {
+					name = name + " (" + mp.ZoneDE + ")"
+				}
+
+				// Find matching component by zone name
+				compID := defaultCompID
+				if mp.ZoneDE != "" {
+					zoneNorm := iace.NormalizeDEPublic(mp.ZoneDE)
+					for cName, cID := range compByName {
+						if containsSubstring(zoneNorm, cName) || containsSubstring(cName, zoneNorm) {
+							compID = cID
+							break
+						}
+					}
+				}
+
 				hz, cerr := h.store.CreateHazard(ctx, iace.CreateHazardRequest{
 					ProjectID:      projectID,
-					ComponentID:    defaultCompID,
+					ComponentID:    compID,
 					Name:           name,
 					Description:    mp.ScenarioDE,
 					Category:       cat,
diff --git a/ai-compliance-sdk/internal/api/handlers/iace_handler_init_helpers.go b/ai-compliance-sdk/internal/api/handlers/iace_handler_init_helpers.go
index 6f5fb2e..c8bdcd1 100644
--- a/ai-compliance-sdk/internal/api/handlers/iace_handler_init_helpers.go
+++ b/ai-compliance-sdk/internal/api/handlers/iace_handler_init_helpers.go
@@ -2,6 +2,7 @@ package handlers
 
 import (
 	"encoding/json"
+	"strings"
 
 	"github.com/breakpilot/ai-compliance-sdk/internal/iace"
 	"github.com/google/uuid"
@@ -190,6 +191,14 @@ func extractIndustrySectorsFromMetadata(metadata json.RawMessage) []string {
 	return result
 }
 
+// containsSubstring checks if haystack contains needle (case-insensitive, normalized).
+func containsSubstring(haystack, needle string) bool {
+	return strings.Contains(
+		strings.ToLower(haystack),
+		strings.ToLower(needle),
+	)
+}
+
 // findHazardForMeasureByCategory finds a matching hazard for a measure.
 func findHazardForMeasureByCategory(measureCat string, hazardsByCategory map[string]uuid.UUID) uuid.UUID {
 	if id, ok := hazardsByCategory[measureCat]; ok {
diff --git a/ai-compliance-sdk/internal/app/routes.go b/ai-compliance-sdk/internal/app/routes.go
index 6c0b385..782b5ed 100644
--- a/ai-compliance-sdk/internal/app/routes.go
+++ b/ai-compliance-sdk/internal/app/routes.go
@@ -432,6 +432,9 @@ func registerIACERoutes(v1 *gin.RouterGroup, h *handlers.IACEHandler) {
 		iaceRoutes.POST("/library-search", h.SearchLibrary)
 		iaceRoutes.GET("/ce-corpus-documents", h.ListCECorpusDocuments)
 		iaceRoutes.POST("/projects/:id/initialize", h.InitializeProject)
+		iaceRoutes.POST("/projects/:id/benchmark/import-gt", h.ImportGroundTruth)
+		iaceRoutes.GET("/projects/:id/benchmark", h.RunBenchmark)
+		iaceRoutes.GET("/projects/:id/benchmark/summary", h.GetBenchmarkSummary)
 		iaceRoutes.GET("/projects/:id/hazards/:hid/regulatory-hints", h.EnrichHazardWithRegulations)
 		iaceRoutes.GET("/projects/:id/mitigations/:mid/regulatory-hints", h.EnrichMitigationWithRegulations)
 		iaceRoutes.GET("/projects/:id/regulatory-hints", h.EnrichProjectHazardsBatch)
diff --git a/ai-compliance-sdk/internal/iace/benchmark_matcher.go b/ai-compliance-sdk/internal/iace/benchmark_matcher.go
new file mode 100644
index 0000000..e62fb41
--- /dev/null
+++ b/ai-compliance-sdk/internal/iace/benchmark_matcher.go
@@ -0,0 +1,365 @@
+package iace
+
+import (
+	"sort"
+	"strings"
+)
+
+// ============================================================================
+// Fuzzy matching: Ground Truth entries ↔ Engine hazards
+// ============================================================================
+
+const matchThreshold = 0.35
+
+// categoryMap maps GT hazard_group (German) to engine category prefixes.
+var categoryMap = map[string][]string{
+	"mechanische gefaehrdungen":                           {"mechanical"},
+	"elektrische gefaehrdungen":                           {"electrical"},
+	"thermische gefaehrdungen":                            {"thermal"},
+	"gefaehrdungen durch laerm":                           {"noise", "ergonomic"},
+	"gefaehrdungen durch vibration":                       {"noise", "vibration"},
+	"gefaehrdungen durch strahlung":                       {"radiation", "emc"},
+	"gefaehrdungen durch materialien und substanzen":      {"material", "environmental"},
+	"ergonomische gefaehrdungen":                          {"ergonomic"},
+	"gefaehrdungen im zusammenhang mit der einsatzumgebung": {"environmental"},
+}
+
+// synonymSets groups equivalent hazard terms for keyword matching.
+var synonymSets = [][]string{
+	{"quetsch", "crush", "einklemm", "klemm"},
+	{"scher", "shear", "absch"},
+	{"schneid", "cut", "schnitt"},
+	{"stoss", "schlag", "impact", "treff", "aufprall"},
+	{"einzug", "fang", "erfass", "entangle", "wickel"},
+	{"elektrisch", "stromschlag", "electric", "beruehr", "spannungsfuehr"},
+	{"brand", "feuer", "fire", "kabelbrand", "kurzschluss"},
+	{"verbrenn", "burn", "heiss", "thermisch"},
+	{"laerm", "noise", "gehoer", "schall"},
+	{"vibration", "schwing"},
+	{"ergonom", "haltung", "handhabung", "bedien"},
+	{"kuehlschmierstoff", "kss", "aerosol", "coolant"},
+	{"pneumat", "druckluft", "compressed"},
+	{"hydraul", "druck", "pressure"},
+	{"roboter", "robot", "roboterarm"},
+	{"greifer", "gripper", "schunk"},
+	{"foerderband", "transport", "conveyor"},
+	{"schutzzaun", "schutzgitter", "fence", "guard"},
+	{"werkzeugmaschine", "robodrill", "bearbeitungszentrum", "wzm"},
+	{"stolper", "rutsch", "slip", "trip"},
+	{"leckage", "austreten", "leak"},
+	{"einstich", "puncture", "spritz"},
+}
+
+// CompareBenchmark runs the full comparison between Ground Truth and engine output.
+func CompareBenchmark(gt *GroundTruth, hazards []Hazard, mitigations []Mitigation) *BenchmarkResult {
+	if gt == nil || len(gt.Entries) == 0 {
+		return &BenchmarkResult{}
+	}
+
+	engineSummaries := make([]HazardSummary, len(hazards))
+	for i, h := range hazards {
+		engineSummaries[i] = HazardSummary{
+			ID:       h.ID.String(),
+			Name:     h.Name,
+			Category: h.Category,
+			Zone:     h.HazardousZone,
+		}
+	}
+
+	// Build score matrix: gt[i] × engine[j]
+	type scoredPair struct {
+		gtIdx, engIdx int
+		score         float64
+		reason        string
+	}
+	var pairs []scoredPair
+	for i := range gt.Entries {
+		for j := range hazards {
+			score, reason := fuzzyMatchScore(&gt.Entries[i], &hazards[j])
+			if score >= matchThreshold {
+				pairs = append(pairs, scoredPair{i, j, score, reason})
+			}
+		}
+	}
+
+	// Greedy best-first 1:1 assignment
+	sort.Slice(pairs, func(a, b int) bool { return pairs[a].score > pairs[b].score })
+	usedGT := make(map[int]bool)
+	usedEng := make(map[int]bool)
+	var matched []HazardMatchPair
+
+	for _, p := range pairs {
+		if usedGT[p.gtIdx] || usedEng[p.engIdx] {
+			continue
+		}
+		usedGT[p.gtIdx] = true
+		usedEng[p.engIdx] = true
+		matched = append(matched, HazardMatchPair{
+			GTEntry:      gt.Entries[p.gtIdx],
+			EngineHazard: engineSummaries[p.engIdx],
+			MatchScore:   p.score,
+			MatchReason:  p.reason,
+		})
+	}
+
+	// Collect unmatched
+	var missing []GroundTruthEntry
+	for i, e := range gt.Entries {
+		if !usedGT[i] {
+			missing = append(missing, e)
+		}
+	}
+	var extra []HazardSummary
+	for i, s := range engineSummaries {
+		if !usedEng[i] {
+			extra = append(extra, s)
+		}
+	}
+
+	// Category breakdown
+	catGT := map[string]int{}
+	catMatch := map[string]int{}
+	for _, e := range gt.Entries {
+		cat := normalizeCategoryDE(e.HazardGroup)
+		catGT[cat]++
+	}
+	for _, m := range matched {
+		cat := normalizeCategoryDE(m.GTEntry.HazardGroup)
+		catMatch[cat]++
+	}
+	var breakdown []CategoryScore
+	for cat, total := range catGT {
+		cov := 0.0
+		if total > 0 {
+			cov = float64(catMatch[cat]) / float64(total)
+		}
+		breakdown = append(breakdown, CategoryScore{
+			Category: cat, GTCount: total, MatchCount: catMatch[cat], Coverage: cov,
+		})
+	}
+	sort.Slice(breakdown, func(i, j int) bool { return breakdown[i].GTCount > breakdown[j].GTCount })
+
+	// Measure coverage (simplified: count GT entries where at least 1 measure keyword matches)
+	measMatched := 0
+	for _, m := range matched {
+		if measureOverlap(m.GTEntry.Measures, mitigations) {
+			measMatched++
+		}
+	}
+	measCov := 0.0
+	if len(matched) > 0 {
+		measCov = float64(measMatched) / float64(len(matched))
+	}
+
+	// Risk rank comparison
+	rankPairs := buildRiskRankPairs(matched)
+
+	coverage := 0.0
+	if len(gt.Entries) > 0 {
+		coverage = float64(len(matched)) / float64(len(gt.Entries))
+	}
+
+	return &BenchmarkResult{
+		CoverageScore:     coverage,
+		MeasureCoverage:   measCov,
+		TotalGT:           len(gt.Entries),
+		TotalEngine:       len(hazards),
+		MatchedPairs:      matched,
+		MissingFromEngine: missing,
+		ExtraInEngine:     extra,
+		CategoryBreakdown: breakdown,
+		RiskRankPairs:     rankPairs,
+	}
+}
+
+// fuzzyMatchScore computes a 0-1 similarity between a GT entry and an engine hazard.
+func fuzzyMatchScore(gt *GroundTruthEntry, h *Hazard) (float64, string) {
+	var score float64
+	var reasons []string
+
+	// 1. Category match (weight 0.4)
+	catScore := categoryMatchScore(gt.HazardGroup, h.Category)
+	score += 0.4 * catScore
+	if catScore > 0 {
+		reasons = append(reasons, "Kategorie")
+	}
+
+	// 2. Keyword/synonym match (weight 0.3)
+	kwScore := keywordMatchScore(gt.HazardType, gt.HazardCause, h.Name, h.Description, h.Scenario)
+	score += 0.3 * kwScore
+	if kwScore > 0 {
+		reasons = append(reasons, "Keywords")
+	}
+
+	// 3. Component/zone match (weight 0.3)
+	zoneScore := zoneMatchScore(gt.ComponentZone, gt.HazardSubgroup, h.HazardousZone, h.MachineModule)
+	score += 0.3 * zoneScore
+	if zoneScore > 0 {
+		reasons = append(reasons, "Zone")
+	}
+
+	return score, strings.Join(reasons, "+")
+}
+
+func categoryMatchScore(gtGroup, engCategory string) float64 {
+	normalized := normalizeDE(gtGroup)
+	prefixes, ok := categoryMap[normalized]
+	if !ok {
+		return 0
+	}
+	engLower := strings.ToLower(engCategory)
+	for _, p := range prefixes {
+		if strings.Contains(engLower, p) {
+			return 1.0
+		}
+	}
+	return 0
+}
+
+func keywordMatchScore(gtType, gtCause, engName, engDesc, engScenario string) float64 {
+	gtText := normalizeDE(gtType + " " + gtCause)
+	engText := normalizeDE(engName + " " + engDesc + " " + engScenario)
+
+	matchedSets := 0
+	totalRelevant := 0
+
+	for _, synSet := range synonymSets {
+		gtHas := false
+		engHas := false
+		for _, syn := range synSet {
+			if strings.Contains(gtText, syn) {
+				gtHas = true
+			}
+			if strings.Contains(engText, syn) {
+				engHas = true
+			}
+		}
+		if gtHas {
+			totalRelevant++
+			if engHas {
+				matchedSets++
+			}
+		}
+	}
+
+	if totalRelevant == 0 {
+		return 0
+	}
+	return float64(matchedSets) / float64(totalRelevant)
+}
+
+func zoneMatchScore(gtZone, gtSubgroup, engZone, engModule string) float64 {
+	gtText := normalizeDE(gtZone + " " + gtSubgroup)
+	engText := normalizeDE(engZone + " " + engModule)
+
+	if gtText == "" || engText == "" {
+		return 0
+	}
+
+	// Check for significant word overlap
+	gtWords := extractSignificantWords(gtText)
+	engWords := extractSignificantWords(engText)
+
+	if len(gtWords) == 0 {
+		return 0
+	}
+
+	matched := 0
+	for _, gw := range gtWords {
+		for _, ew := range engWords {
+			if strings.Contains(ew, gw) || strings.Contains(gw, ew) {
+				matched++
+				break
+			}
+		}
+	}
+	return float64(matched) / float64(len(gtWords))
+}
+
+func extractSignificantWords(text string) []string {
+	stopWords := map[string]bool{
+		"der": true, "die": true, "das": true, "und": true, "oder": true,
+		"von": true, "in": true, "an": true, "am": true, "im": true,
+		"zu": true, "bei": true, "mit": true, "des": true, "den": true,
+		"dem": true, "ein": true, "eine": true, "einer": true, "einem": true,
+		"fuer": true, "auf": true, "aus": true, "um": true, "nach": true,
+		"ueber": true, "unter": true, "vor": true, "durch": true,
+	}
+	words := strings.Fields(text)
+	var sig []string
+	for _, w := range words {
+		if len(w) < 3 || stopWords[w] {
+			continue
+		}
+		sig = append(sig, w)
+	}
+	return sig
+}
+
+// NormalizeDEPublic is the exported version of normalizeDE for use outside this package.
+func NormalizeDEPublic(s string) string { return normalizeDE(s) }
+
+// normalizeDE lowercases and replaces umlauts (same as narrative_parser).
+func normalizeDE(s string) string {
+	s = strings.ToLower(strings.TrimSpace(s))
+	s = strings.ReplaceAll(s, "ä", "ae")
+	s = strings.ReplaceAll(s, "ö", "oe")
+	s = strings.ReplaceAll(s, "ü", "ue")
+	s = strings.ReplaceAll(s, "ß", "ss")
+	return s
+}
+
+func normalizeCategoryDE(group string) string {
+	n := normalizeDE(group)
+	// Shorten for display
+	n = strings.TrimPrefix(n, "gefaehrdungen durch ")
+	n = strings.TrimPrefix(n, "gefaehrdungen im zusammenhang mit ")
+	return n
+}
+
+func measureOverlap(gtMeasures []string, mitigations []Mitigation) bool {
+	for _, gm := range gtMeasures {
+		gmNorm := normalizeDE(gm)
+		for _, m := range mitigations {
+			mNorm := normalizeDE(m.Name + " " + m.Description)
+			// Check if any significant word from GT measure appears in engine mitigation
+			words := extractSignificantWords(gmNorm)
+			for _, w := range words {
+				if strings.Contains(mNorm, w) {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+func buildRiskRankPairs(matched []HazardMatchPair) []RiskRankPair {
+	if len(matched) == 0 {
+		return nil
+	}
+
+	// Sort by GT risk descending to get GT rank
+	type ranked struct {
+		idx     int
+		gtRisk  int
+		name    string
+	}
+	items := make([]ranked, len(matched))
+	for i, m := range matched {
+		items[i] = ranked{i, m.GTEntry.RiskIn.R, m.GTEntry.HazardType}
+	}
+	sort.Slice(items, func(a, b int) bool { return items[a].gtRisk > items[b].gtRisk })
+
+	pairs := make([]RiskRankPair, len(items))
+	for rank, item := range items {
+		pairs[rank] = RiskRankPair{
+			GTRank:      rank + 1,
+			EngineRank:  0, // Engine has no assessment yet for auto-generated hazards
+			HazardName:  item.name,
+			GTRiskScore: item.gtRisk,
+			EngineRisk:  0,
+		}
+	}
+	return pairs
+}
diff --git a/ai-compliance-sdk/internal/iace/benchmark_types.go b/ai-compliance-sdk/internal/iace/benchmark_types.go
new file mode 100644
index 0000000..f98b976
--- /dev/null
+++ b/ai-compliance-sdk/internal/iace/benchmark_types.go
@@ -0,0 +1,135 @@
+package iace
+
+import "encoding/json"
+
+// ============================================================================
+// Ground Truth types — stores a professional risk assessment for benchmarking
+// ============================================================================
+
+// GroundTruth is the top-level container stored in project metadata.ground_truth.
+type GroundTruth struct {
+	Entries     []GroundTruthEntry `json:"entries"`
+	SourceFile  string             `json:"source_file,omitempty"`
+	ImportedAt  string             `json:"imported_at"`
+	Description string             `json:"description,omitempty"`
+}
+
+// GroundTruthEntry represents a single hazard from a professional risk assessment.
+type GroundTruthEntry struct {
+	Nr                  string           `json:"nr"`
+	HazardGroup         string           `json:"hazard_group"`
+	HazardGroupApplicable bool           `json:"hazard_group_applicable"`
+	HazardSubgroup      string           `json:"hazard_subgroup"`
+	HazardType          string           `json:"hazard_type"`
+	HazardCause         string           `json:"hazard_cause"`
+	LifecyclePhases     []string         `json:"lifecycle_phases"`
+	ComponentZone       string           `json:"component_zone"`
+	RiskIn              GTRisk           `json:"risk_in"`
+	PLr                 *GTPLr           `json:"plr,omitempty"`
+	Measures            []string         `json:"measures"`
+	MeasureType         string           `json:"measure_type"`
+	RiskOut             GTRisk           `json:"risk_out"`
+	NormReferences      []string         `json:"norm_references"`
+	Sufficient          bool             `json:"sufficient"`
+	Comment             string           `json:"comment,omitempty"`
+	ReductionSteps      []GTReductionStep `json:"reduction_steps,omitempty"`
+}
+
+// GTRisk represents the EN 62061 additive risk: R = (F + W + P) * S.
+type GTRisk struct {
+	F int `json:"f"`
+	W int `json:"w"`
+	P int `json:"p"`
+	S int `json:"s"`
+	R int `json:"r"`
+}
+
+// GTPLr represents Performance Level required (EN ISO 13849-1).
+type GTPLr struct {
+	S   string `json:"s"`
+	F   string `json:"f"`
+	P   string `json:"p"`
+	EW  string `json:"ew,omitempty"`
+	PLr string `json:"plr"`
+}
+
+// GTReductionStep represents an iterative risk reduction row.
+type GTReductionStep struct {
+	RiskIn         GTRisk   `json:"risk_in"`
+	PLr            *GTPLr   `json:"plr,omitempty"`
+	Measures       []string `json:"measures"`
+	MeasureType    string   `json:"measure_type"`
+	RiskOut        GTRisk   `json:"risk_out"`
+	NormReferences []string `json:"norm_references"`
+	Sufficient     bool     `json:"sufficient"`
+	Comment        string   `json:"comment,omitempty"`
+}
+
+// ============================================================================
+// Benchmark result types — comparison output
+// ============================================================================
+
+// BenchmarkResult is the API response for the comparison endpoint.
+type BenchmarkResult struct {
+	CoverageScore     float64            `json:"coverage_score"`
+	MeasureCoverage   float64            `json:"measure_coverage"`
+	TotalGT           int                `json:"total_gt"`
+	TotalEngine       int                `json:"total_engine"`
+	MatchedPairs      []HazardMatchPair  `json:"matched_pairs"`
+	MissingFromEngine []GroundTruthEntry `json:"missing_from_engine"`
+	ExtraInEngine     []HazardSummary    `json:"extra_in_engine"`
+	CategoryBreakdown []CategoryScore    `json:"category_breakdown"`
+	RiskRankPairs     []RiskRankPair     `json:"risk_rank_pairs"`
+}
+
+// HazardMatchPair links a GT entry to an engine hazard.
+type HazardMatchPair struct {
+	GTEntry      GroundTruthEntry `json:"gt_entry"`
+	EngineHazard HazardSummary    `json:"engine_hazard"`
+	MatchScore   float64          `json:"match_score"`
+	MatchReason  string           `json:"match_reason"`
+}
+
+// HazardSummary is a lightweight hazard representation for benchmark results.
+type HazardSummary struct {
+	ID        string `json:"id"`
+	Name      string `json:"name"`
+	Category  string `json:"category"`
+	Component string `json:"component,omitempty"`
+	Zone      string `json:"zone,omitempty"`
+	RiskLevel string `json:"risk_level,omitempty"`
+}
+
+// CategoryScore shows coverage per ISO 12100 hazard group.
+type CategoryScore struct {
+	Category   string  `json:"category"`
+	GTCount    int     `json:"gt_count"`
+	MatchCount int     `json:"match_count"`
+	Coverage   float64 `json:"coverage"`
+}
+
+// RiskRankPair compares risk ordering between GT and engine.
+type RiskRankPair struct {
+	GTRank      int     `json:"gt_rank"`
+	EngineRank  int     `json:"engine_rank"`
+	HazardName  string  `json:"hazard_name"`
+	GTRiskScore int     `json:"gt_risk_score"`
+	EngineRisk  float64 `json:"engine_risk"`
+}
+
+// ParseGroundTruth extracts GroundTruth from project metadata JSON.
+func ParseGroundTruth(metadata json.RawMessage) (*GroundTruth, error) {
+	var m map[string]json.RawMessage
+	if err := json.Unmarshal(metadata, &m); err != nil {
+		return nil, err
+	}
+	raw, ok := m["ground_truth"]
+	if !ok {
+		return nil, nil
+	}
+	var gt GroundTruth
+	if err := json.Unmarshal(raw, &gt); err != nil {
+		return nil, err
+	}
+	return &gt, nil
+}
diff --git a/ai-compliance-sdk/internal/iace/document_export.go b/ai-compliance-sdk/internal/iace/document_export.go
index c9346b5..96268b6 100644
--- a/ai-compliance-sdk/internal/iace/document_export.go
+++ b/ai-compliance-sdk/internal/iace/document_export.go
@@ -50,6 +50,10 @@ func (e *DocumentExporter) ExportPDF(
 	pdf.AddPage()
 	e.pdfCoverPage(pdf, project)
 
+	// --- Methodology ("Erklaerteil") ---
+	pdf.AddPage()
+	e.pdfMethodologySection(pdf)
+
 	// --- Table of Contents ---
 	pdf.AddPage()
 	e.pdfTableOfContents(pdf, sections)
@@ -127,6 +131,11 @@ func (e *DocumentExporter) ExportMarkdown(
 		buf.WriteString(fmt.Sprintf("> %s\n\n", project.Description))
 	}
 
+	buf.WriteString("---\n\n")
+	buf.WriteString(fmt.Sprintf("## %s\n\n", RiskAssessmentMethodologySectionTitle))
+	buf.WriteString(RiskAssessmentMethodologyDE)
+	buf.WriteString("\n\n---\n\n")
+
 	for _, section := range sections {
 		buf.WriteString(fmt.Sprintf("## %s\n\n", section.Title))
 		buf.WriteString(fmt.Sprintf("*Typ: %s | Status: %s | Version: %d*\n\n",
diff --git a/ai-compliance-sdk/internal/iace/document_export_pdf.go b/ai-compliance-sdk/internal/iace/document_export_pdf.go
index b074ad1..59d578a 100644
--- a/ai-compliance-sdk/internal/iace/document_export_pdf.go
+++ b/ai-compliance-sdk/internal/iace/document_export_pdf.go
@@ -2,6 +2,7 @@ package iace
 
 import (
 	"fmt"
+	"strings"
 	"time"
 
 	"github.com/jung-kurt/gofpdf"
@@ -49,6 +50,31 @@ func (e *DocumentExporter) pdfCoverPage(pdf *gofpdf.Fpdf, project *Project) {
 	}
 }
 
+func (e *DocumentExporter) pdfMethodologySection(pdf *gofpdf.Fpdf) {
+	paragraphs := strings.Split(RiskAssessmentMethodologyDE, "\n\n")
+	for _, para := range paragraphs {
+		para = strings.TrimSpace(para)
+		if para == "" {
+			continue
+		}
+		// Headings: lines that are short and don't end with punctuation
+		if len(para) < 60 && !strings.HasSuffix(para, ".") && !strings.HasSuffix(para, ")") {
+			pdf.Ln(4)
+			pdf.SetFont("Helvetica", "B", 12)
+			pdf.SetTextColor(50, 50, 50)
+			pdf.CellFormat(0, 8, para, "", 1, "L", false, 0, "")
+			pdf.SetTextColor(0, 0, 0)
+			pdf.SetDrawColor(200, 200, 200)
+			pdf.Line(10, pdf.GetY(), 200, pdf.GetY())
+			pdf.Ln(3)
+			continue
+		}
+		pdf.SetFont("Helvetica", "", 10)
+		pdf.MultiCell(0, 5, para, "", "L", false)
+		pdf.Ln(2)
+	}
+}
+
 func (e *DocumentExporter) pdfTableOfContents(pdf *gofpdf.Fpdf, sections []TechFileSection) {
 	pdf.SetFont("Helvetica", "B", 16)
 	pdf.SetTextColor(50, 50, 50)
@@ -61,6 +87,7 @@ func (e *DocumentExporter) pdfTableOfContents(pdf *gofpdf.Fpdf, sections []TechF
 	pdf.SetFont("Helvetica", "", 11)
 
 	fixedEntries := []string{
+		RiskAssessmentMethodologySectionTitle,
 		"Gefaehrdungsprotokoll",
 		"Risikomatrix-Zusammenfassung",
 		"Massnahmen-Uebersicht",
diff --git a/ai-compliance-sdk/internal/iace/risk_assessment_template.go b/ai-compliance-sdk/internal/iace/risk_assessment_template.go
new file mode 100644
index 0000000..cac32f5
--- /dev/null
+++ b/ai-compliance-sdk/internal/iace/risk_assessment_template.go
@@ -0,0 +1,53 @@
+package iace
+
+// RiskAssessmentMethodologyDE contains the German-language methodology introduction
+// ("Erklaerteil") that is prepended to every risk assessment export.
+//
+// This text is the single source of truth — it is used by:
+//   - PDF export (document_export_pdf.go)
+//   - Markdown export (document_export.go)
+//   - Frontend print view (ReportPrintView.tsx mirrors this content)
+//
+// The methodology is BreakPilot's own formulation, inspired by the general
+// principles of EN ISO 12100, EN 62061, and EN ISO 13849-1.
+// No normative text is reproduced.
+const RiskAssessmentMethodologyDE = `Methodik der Risikobeurteilung
+
+Diese Risikobeurteilung orientiert sich an den Grundprinzipien der EN ISO 12100, EN 62061 und EN ISO 13849-1. Bewertet werden Grenzen des Produkts, identifizierte Gefaehrdungen, die jeweilige Risikohoehe sowie das Restrisiko nach Anwendung von Schutzmassnahmen.
+
+Der Prozess ist iterativ: Reicht eine Massnahme nicht aus, werden weitere ergriffen und das Restrisiko erneut bewertet, bis ein akzeptables Niveau erreicht ist. Werden mehrere Massnahmen gemeinsam umgesetzt, erfolgt eine Gesamtbewertung. Wurde die Wirksamkeit einzelner Massnahmen gesondert betrachtet, wird das Restrisiko stufenweise ausgewiesen.
+
+Risikoberechnung
+
+Das Ausgangsrisiko ergibt sich aus:
+
+R = S x F x P x A
+
+S = Schadensschwere (1-5): erwartbare Verletzungsschwere (Erste Hilfe bis toedlich)
+F = Expositionshaeufigkeit (1-5): Haeufigkeit und Dauer der Exposition (selten/kurz bis dauerhaft)
+P = Eintrittswahrscheinlichkeit (1-5): technische Ausfallwahrscheinlichkeit und menschliches Verhalten (vernachlaessigbar bis fast sicher)
+A = Vermeidbarkeit (1-5): Erkennbarkeit, Reaktionszeit, raeumliche Ausweichmoeglichkeit (leicht vermeidbar bis unvermeidbar)
+
+Das Restrisiko beruecksichtigt die Wirksamkeit umgesetzter Massnahmen (Reifegrad, Abdeckungsgrad, Verifikationsstand).
+
+Bei sicherheitstechnischen Steuerungskreisen wird zusaetzlich der erforderliche Performance Level (PLr) ueber einen Risikographen abgeleitet und dem entsprechenden Safety Integrity Level (SIL) zugeordnet. Die Verifikation erfolgt durch den zustaendigen Functional-Safety-Ingenieur.
+
+Massnahmen nach Dreistufenmethode
+
+Schutzmassnahmen werden priorisiert angewandt:
+1. Konstruktive Massnahmen (KM) — Inhaerent sichere Gestaltung
+2. Technische Schutzmassnahmen (TM) — Schutzeinrichtungen, Sicherheitssteuerungen
+3. Benutzerinformationen (BI) — Warnhinweise, Betriebsanleitung
+
+Benutzerinformationen allein sind keine ausreichende Primaermassnahme.
+
+Akzeptanz des Restrisikos
+
+Ein Restrisiko gilt als hinreichend gemindert, wenn alle praktisch umsetzbaren Massnahmen ausgeschoepft wurden, keine neuen Gefaehrdungen durch Schutzmassnahmen entstehen und Anwender ueber verbleibende Restrisiken informiert sind. Massgeblich ist die Verhaeltnismaessigkeit: Je hoeher das Restrisiko, desto hoeher der zumutbare Aufwand.
+
+Die Akzeptanz wird pro Gefaehrdung mit JA / NEIN dokumentiert. Die Farbcodierung spiegelt den erforderlichen SIL wider — ein rotes Restrisiko bedeutet nicht automatisch, dass weitere Massnahmen noetig sind.
+
+"Die Moeglichkeit, einen hoeheren Sicherheitsgrad zu erreichen, oder die Verfuegbarkeit anderer Produkte, die ein geringeres Risiko darstellen, ist kein ausreichender Grund, ein Produkt als gefaehrlich anzusehen." (§ 3 Abs. 2 ProdSG)`
+
+// RiskAssessmentMethodologySection is the section title for the TOC.
+const RiskAssessmentMethodologySectionTitle = "Methodik der Risikobeurteilung"
diff --git a/ai-compliance-sdk/internal/iace/store_projects.go b/ai-compliance-sdk/internal/iace/store_projects.go
index c8de01f..047c5fd 100644
--- a/ai-compliance-sdk/internal/iace/store_projects.go
+++ b/ai-compliance-sdk/internal/iace/store_projects.go
@@ -233,6 +233,18 @@ func (s *Store) UpdateProjectCompleteness(ctx context.Context, id uuid.UUID, sco
 	return nil
 }
 
+// UpdateProjectMetadata replaces the metadata JSON for a project.
+func (s *Store) UpdateProjectMetadata(ctx context.Context, id uuid.UUID, metadata json.RawMessage) error {
+	_, err := s.pool.Exec(ctx, `
+		UPDATE iace_projects SET metadata = $2, updated_at = NOW()
+		WHERE id = $1
+	`, id, metadata)
+	if err != nil {
+		return fmt.Errorf("update project metadata: %w", err)
+	}
+	return nil
+}
+
 // ListVariants returns all variant sub-projects for a given parent project
 func (s *Store) ListVariants(ctx context.Context, parentID uuid.UUID) ([]Project, error) {
 	rows, err := s.pool.Query(ctx, `
diff --git a/ai-compliance-sdk/internal/iace/testdata/ground_truth_bremse.json b/ai-compliance-sdk/internal/iace/testdata/ground_truth_bremse.json
new file mode 100644
index 0000000..033eea4
--- /dev/null
+++ b/ai-compliance-sdk/internal/iace/testdata/ground_truth_bremse.json
@@ -0,0 +1,2570 @@
+{
+  "entries": [
+    {
+      "nr": "1.1",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Gesamte Anlage",
+      "hazard_type": "Schneiden",
+      "hazard_cause": "Schneiden an scharfen Kanten des Gehäuses",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Zugängliche Kanten der Maschine",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 16
+      },
+      "measures": [
+        "Brechen oder Runden aller zugänglichen Kanten"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "1.2",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Gesamte Anlage",
+      "hazard_type": "Quetschen, Stoß",
+      "hazard_cause": "Tragfähigkeit des Betonbodens wird überschritten, Anlage bricht ein",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bereich um die Maschine",
+      "risk_in": {
+        "f": 2,
+        "w": 3,
+        "p": 5,
+        "s": 4,
+        "r": 40
+      },
+      "measures": [
+        "Tragfähigkeit des Untergrunds / Bodens ist auf die maximal technisch möglichen statischen und dynamischen Lasten der Maschine ausgelegt"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 4,
+        "r": 12
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "comment": "Kommentar:\nMontage durch Anlagenhersteller"
+    },
+    {
+      "nr": "1.3",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Gesamte Anlage",
+      "hazard_type": "Schlag, Stoß",
+      "hazard_cause": "Pneumatikschlauch der Automation springt ab, trifft Werker",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Pneumatikschläuche der Automation",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 1,
+        "r": 7
+      },
+      "measures": [
+        "Verwendung von geeigneten",
+        "Pneumatikleitungen und Befestigungen entsprechend den Herstellerempfehlungen",
+        "Sicherung der Pneumatikschläuche gegen Abspringen",
+        "Fachgerechte Montage der Komponenten des pneumatischen Systems gemäß den Herstellerangaben"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN ISO 4414"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "1.4",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Gesamte Anlage",
+      "hazard_type": "Schlag, Stoß",
+      "hazard_cause": "Druckluftbeaufschlagte Teile des Pneumatiksystems bersten und verletzen Person",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Pneumatikschläuche der Automation",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 1,
+        "r": 7
+      },
+      "measures": [
+        "Leitungen, Dichtungen, Verbindungsstücke, Befestigungen sowie sonstige Komponenten der Pneumatik sind auf den Nenndruck der Anlage ausgelegt"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN ISO 4414"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "1.5",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Gesamte Anlage",
+      "hazard_type": "Schlag, Stoß",
+      "hazard_cause": "Komponenten des pneumatischen Systems stehen nach Abschaltung noch unter Druck (z.B. aufgrund geschlossener Ventile). Person verletzt sich bei Arbeiten am System an unter Druck stehenden Teilen (z.B. beim Öffnen von Schlauchverbindung)",
+      "lifecycle_phases": [
+        "Umrüsten",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Pneumatikschläuche /-Komponenten",
+      "risk_in": {
+        "f": 2,
+        "w": 3,
+        "p": 3,
+        "s": 2,
+        "r": 16
+      },
+      "measures": [
+        "Pneumatik-Kreise verfügen über die Möglichkeit zur Druckentlastung",
+        "Hinweis in BA: Vorsicht",
+        "Verletzungsgefahr durch gespeicherte Restenergie in Pneumatik-Kreisen.",
+        "Anleitung in BA:",
+        "Anleitung zur Druckentlastung der Pneumatik-Kreise im Notfall"
+      ],
+      "measure_type": "KMBI",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN ISO 4414"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "1.6",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Gesamte Anlage",
+      "hazard_type": "Quetschen",
+      "hazard_cause": "Person ist zwischen beweglichen und feststehenden Teilen eingeklemmt",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "bewegliche und feststehende Teile der Anlage",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 21
+      },
+      "measures": [
+        "Lösen von quetschenden Einrichtungen (z. B. nach Not-Halt)  ist möglich",
+        "Hinweis in BA:",
+        "Anleitung zum Lösen von quetschenden Einrichtungen in Betriebsanleitung"
+      ],
+      "measure_type": "KMBI",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 3,
+        "r": 9
+      },
+      "norm_references": [
+        "EN ISO 4414"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "1.6",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Roboter",
+      "hazard_type": "Quetschen, Stoß",
+      "hazard_cause": "Werker steht in Bewegungsbereich des Roboterarms, wird von sich bewegendem Roboterarm getroffen oder zwischen Roboterarm und feststehenden Gegenständen gequetscht",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung"
+      ],
+      "component_zone": "Roboterarm",
+      "risk_in": {
+        "f": 4,
+        "w": 3,
+        "p": 3,
+        "s": 3,
+        "r": 30
+      },
+      "measures": [
+        "Roboter ist mit Schutzzaun eingehaust (Einhausung  nur mit Werkzeug zu öffnen),  Zugang nur über abgefragte  Türen im  Zaun möglich"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 3,
+        "w": 2,
+        "p": 1,
+        "s": 3,
+        "r": 18
+      },
+      "norm_references": [
+        "EN ISO 13857 EN ISO 14120"
+      ],
+      "sufficient": false,
+      "reduction_steps": [
+        {
+          "risk_in": {
+            "f": 3,
+            "w": 2,
+            "p": 1,
+            "s": 3,
+            "r": 18
+          },
+          "measures": [
+            "Position der Zugangstüre im Schutzzaun über Sensor abgefragt.  Türe lässt sich erst öffnen, wenn Roboter steht \n-> Im  Folgenden : \"SICHERES STILLSETZEN ROBOTER\""
+          ],
+          "measure_type": "TM",
+          "risk_out": {
+            "f": 2,
+            "w": 1,
+            "p": 1,
+            "s": 1,
+            "r": 4
+          },
+          "norm_references": [
+            "EN ISO 10218-2",
+            "Ziff. 5.3.8"
+          ],
+          "sufficient": true,
+          "plr": {
+            "s": "S2",
+            "f": "F2",
+            "p": "P1",
+            "ew": "Ni",
+            "plr": "c"
+          },
+          "comment": "Kommentar:\nSicherheitszuhaltung nur erforderlich wenn Roboter relevanten Nachlauf hat"
+        }
+      ]
+    },
+    {
+      "nr": "1.7",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Roboter",
+      "hazard_type": "Quetschen, Stoß",
+      "hazard_cause": "Werker steht in Bewegungsbereich des Roboterarms ( z.B. zum Teachen),  wird von sich bewegendem Roboterarm getroffen oder zwischen Roboterarm und feststehenden Gegenständen gequetscht",
+      "lifecycle_phases": [
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "nehmen",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Roboterarm,\nInneres der Roboterzelle",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 24
+      },
+      "measures": [
+        "Betriebsart \"TEACHING BETRIEB\" des Roboters nur über schlüsselbetätigten oder passwortgeschützten Betriebsartenwahlschalter aktivierbar",
+        "Bei geöffneter Türe im Schutzzaun nur Teaching-Modus des Roboters möglich.",
+        "Im Teaching-Modus Bewegung des Roboterarms << sicher reduzierte Geschwindigkeit (max. 250 mm/s), Betrieb nur möglich im Tippbetrieb in Verbindung mit einer Zustimmungseinrichtung",
+        "> Im  Folgenden : \"TEACHING MODUS\""
+      ],
+      "measure_type": "KMTM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN ISO 10218-1 Ziff. 5.6.2 Ziff. 5.7.3 Ziff. 5.8.3"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "c"
+      }
+    },
+    {
+      "nr": "1.8",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Roboter",
+      "hazard_type": "Quetschen, Stoß",
+      "hazard_cause": "Roboterarm durchschlägt  Schutzzaun der Roboterzelle, verletzt Werker",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung",
+        "Umrüsten",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bereich um Roboterarm außerhalb Roboterzelle",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 16
+      },
+      "measures": [
+        "Bewegungsbereich des Roboterarms sicher begrenzt. Abstand des begrenzten Bewegungsbereichs zu Schutzzaun und Einhausung des Bearbeitungszentrums berücksichtigt die maximalen Abmessungen / Gewicht des Werkstücks  (Dual Check Safety)",
+        "> Im Folgenden: \"SICHER BEGRENZTER BEWEGUNGSBEREICH\""
+      ],
+      "measure_type": "TM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 2,
+        "r": 6
+      },
+      "norm_references": [
+        "EN ISO 10218-2 Ziff.",
+        "5.4.3"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S1",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "a"
+      }
+    },
+    {
+      "nr": "1.9",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Roboter",
+      "hazard_type": "Quetschen, Stoß",
+      "hazard_cause": "Werker greift mit  der Hand / Arm in den Bewegungsbereich des Roboters und wird zwischen Roboterarm und feststehenden Teilen der Anlage gequetscht",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Roboterarm",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 24
+      },
+      "measures": [
+        "Roboter ist mit Schutzzaun eingehaust (Einhausung  nur mit Werkzeug zu öffnen),  Zugang nur über abgefragte  Türen im  Zaun möglich)",
+        "Gefahrbringende Bewegungen des Roboters werden bei Öffnen der Zuganstür stillgesetzt*"
+      ],
+      "measure_type": "KMTM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN ISO 13857"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "c"
+      },
+      "comment": "Kommentar:\n* Sicherheitszuhaltung erforderlich wenn Roboter relevanten Nachlauf hat"
+    },
+    {
+      "nr": "1.10",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Roboter",
+      "hazard_type": "Quetschen, Stoß",
+      "hazard_cause": "Werker greift über Schutzzaun, Hand oder Arm wird zwischen Roboterarm und feststehenden Teilen der Anlage gequetscht",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Roboterarm",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 21
+      },
+      "measures": [
+        "Waagrechter Abstand von Oberkante des Schutzzauns zu Greifer / Werkstück / Roboterarm > 250mm bei Höhe des Schutzzauns 2250 mm"
+      ],
+      "measure_type": "KMTM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN ISO 13857"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F1",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "b"
+      },
+      "comment": "Kommentar: \nNiedriges Risiko, daher Tabelle 1 nach EN 13857 anwendbar.\nÜber DCS abgesichert oder Roboter kann Bereich nicht erreichen"
+    },
+    {
+      "nr": "1.11",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Roboter",
+      "hazard_type": "Quetschen, Scheren",
+      "hazard_cause": "Werker greift durch Öffnung der Förderbänder für die Werkstück Ein- oder -ausfuhr im Schutzzaun in den Bewegungsbereich des Roboterarms ( z.B. um Werkstück von Band zu nehmen) , wird von sich bewegendem Roboterarm getroffen oder zwischen Roboterarm und feststehenden Gegenständen gequetscht",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Roboterarm,\nBereich um Öffnung Förderbänder",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 24
+      },
+      "measures": [
+        "Abstand von Öffnung der Transportbänder im Schutzzaun bis zum Bewegungsbereich des Roboters beträgt min. 850 mm",
+        "Vertikale Öffnungsgröße im Schutzzaun ist so klein wie es die Werkstücke zulassen",
+        "Zugangstüre im Schutztaun ermöglicht schnellen und sicheren Zugang zum Anlageninneren, kein Anreiz zum Durchsteigen der Öffnung"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN ISO 13857"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "1.12",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Roboter",
+      "hazard_type": "Quetschen, Scheren, Stoß",
+      "hazard_cause": "Person befindet sich in Roboterzelle z.B. zur Reinigung oder Umrüsten der Anlage, Schutztüre zur Roboterzelle ist / wird geschlossen, Person wird von sich bewegendem Roboterarm, Werkzeug oder Werkstück verletzt",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Roboterarm,\nInneres der Roboterzelle",
+      "risk_in": {
+        "f": 4,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 27
+      },
+      "measures": [
+        "Gefahrenbereich der Maschine ist vom HMI der Robodrill von außen einsehbar",
+        "Gefahrbringende Bewegungen des Roboters werden bei Öffnen der Zuganstür stillgesetzt",
+        "Anlage kann nur durch bewusstes Wiederingangsetzen von außerhalb (HMI Robodrill)  wieder anlaufen.",
+        "Öffnen der Schutztüre  zur Roboterzelle von innen händisch ohne Hilfsmittel einfach möglich. Öffnen der Schutztüre setzt Roboter still"
+      ],
+      "measure_type": "KMTM",
+      "risk_out": {
+        "f": 2,
+        "w": 2,
+        "p": 1,
+        "s": 1,
+        "r": 5
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "c"
+      }
+    },
+    {
+      "nr": "1.13",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkzeug (Greifer Roboter)",
+      "hazard_type": "Quetschen, Scheren, Stoß",
+      "hazard_cause": "Werker steht in Bewegungsbereich des Roboterarms, wird von bewegtem Werkzeug / Greifer getroffen oder zwischen Werkzeug / Greifer und feststehenden angrenzenden Gegenständen gequetscht",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Umrüsten",
+        "Reinigung"
+      ],
+      "component_zone": "Inneres der Roboterzelle",
+      "risk_in": {
+        "f": 3,
+        "w": 3,
+        "p": 3,
+        "s": 3,
+        "r": 27
+      },
+      "measures": [
+        "Roboter ist mit Schutzzaun eingehaust (Einhausung  nur mit Werkzeug zu öffnen),  Zugang nur über abgefragte  Türen im  Zaun möglich"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 2,
+        "p": 1,
+        "s": 3,
+        "r": 15
+      },
+      "norm_references": [
+        "EN ISO 14120"
+      ],
+      "sufficient": false,
+      "reduction_steps": [
+        {
+          "risk_in": {
+            "f": 2,
+            "w": 2,
+            "p": 1,
+            "s": 3,
+            "r": 15
+          },
+          "measures": [
+            "-SICHERES STILLSETZEN ROBOTER"
+          ],
+          "measure_type": "TM",
+          "risk_out": {
+            "f": 2,
+            "w": 1,
+            "p": 1,
+            "s": 1,
+            "r": 4
+          },
+          "norm_references": [
+            "EN ISO 10218-2",
+            "Ziff. 5.3.8"
+          ],
+          "sufficient": true,
+          "plr": {
+            "s": "S2",
+            "f": "F1",
+            "p": "P1",
+            "ew": "Ni",
+            "plr": "b"
+          }
+        }
+      ]
+    },
+    {
+      "nr": "1.14",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkzeug (Greifer Roboter)",
+      "hazard_type": "Quetschen, Scheren, Stoß",
+      "hazard_cause": "Werker steht in Bewegungsbereich des Roboterarms (z.B. zum Teachen), wird von bewegtem Werkzeug / Greifer getroffen oder zwischen Werkzeug / Greifer und feststehenden angrenzenden Gegenständen gequetscht",
+      "lifecycle_phases": [
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Inneres der Roboterzelle",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 24
+      },
+      "measures": [
+        "TEACHING MODUS"
+      ],
+      "measure_type": "TM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN ISO 10218-1 Ziff. 5.6.2 Ziff. 5.7.3 Ziff. 5.8.3"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "c"
+      }
+    },
+    {
+      "nr": "1.15",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkzeug (Greifer Roboter)",
+      "hazard_type": "Schlag, Stoß",
+      "hazard_cause": "Greifer an Robotergreifer durchschlägt Schutzzaun, Person wird getroffen",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung",
+        "Umrüsten",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bereich um Roboterarm außerhalb Maschine",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 14
+      },
+      "measures": [
+        "SICHER BEGRENZTER BEWEGUNSBEREICH"
+      ],
+      "measure_type": "TM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN ISO 10218-2 Ziff.",
+        "5.4.3"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S1",
+        "f": "F1",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "a"
+      }
+    },
+    {
+      "nr": "1.16",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkzeug (Greifer Roboter)",
+      "hazard_type": "Quetschen, Scheren, Stoß",
+      "hazard_cause": "Werker greift in den Bereich des Greifers während der Roboter ein Werkstück greift, Hand wird zwischen Greifer und Werkstück gequetscht",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung"
+      ],
+      "component_zone": "Inneres der Roboterzelle",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 21
+      },
+      "measures": [
+        "Türposition der Zugangstüre im Schutzzaun über Sensor abgefragt. Öffnen der Türe setzt Greifer still."
+      ],
+      "measure_type": "TM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN ISO 10218-2 Ziff.",
+        "5.4.3"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F1",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "b"
+      }
+    },
+    {
+      "nr": "1.17",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkzeug (Greifer Roboter)",
+      "hazard_type": "Quetschen, Scheren, Stoß",
+      "hazard_cause": "Werker greift in den Bereich des Greifers während der Roboter ein Werkstück greift, Hand wird zwischen Greifer und Werkstück gequetscht",
+      "lifecycle_phases": [
+        "Umrüsten",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Inneres der Roboterzelle",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 24
+      },
+      "measures": [
+        "TEACHING MODUS"
+      ],
+      "measure_type": "TM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN ISO 10218-1 Ziff. 5.6.2 Ziff. 5.7.3 Ziff. 5.8.3"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "c"
+      }
+    },
+    {
+      "nr": "1.18",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkzeug (Greifer Roboter)",
+      "hazard_type": "Quetschen, Scheren, Stoß",
+      "hazard_cause": "Werker greift über Schutzzaun, Hand oder Arm wird zwischen Roboterarm und feststehenden Teilen der Anlage gequetscht",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Roboterarm",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 1,
+        "s": 2,
+        "r": 10
+      },
+      "measures": [
+        "Waagrechter Abstand von Oberkante des Schutzzauns zu Greifer / Werkstück / Roboterarm > 250mm bei Höhe des Schutzzauns 2250 mm"
+      ],
+      "measure_type": "KMTM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN ISO 13857"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S1",
+        "f": "F1",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "a"
+      },
+      "comment": "Kommentar: \nNiedriges Risiko, daher Tabelle 1 nach EN 13857 anwendbar.\nÜber DCS abgesichert oder Roboter kann Bereich nicht erreichen"
+    },
+    {
+      "nr": "1.19",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkstück an Robotergreifer",
+      "hazard_type": "Quetschen, Scheren, Stoß",
+      "hazard_cause": "Werker steht in Bewegungsbereich des Roboterarms , wird von sich bewegendem Werkstück / Werkzeug  getroffen oder zwischen Werkstück / Werkzeug  und feststehenden Gegenständen gequetscht",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Umrüsten",
+        "Reinigung"
+      ],
+      "component_zone": "Inneres der Roboterzelle / Greifer des Roboterarms",
+      "risk_in": {
+        "f": 4,
+        "w": 3,
+        "p": 3,
+        "s": 3,
+        "r": 30
+      },
+      "measures": [
+        "Roboter ist mit Schutzzaun eingehaust (Einhausung  nur mit Werkzeug zu öffnen),  Zugang nur über abgefragte  Türen im  Zaun möglich"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 2,
+        "p": 1,
+        "s": 3,
+        "r": 15
+      },
+      "norm_references": [
+        "EN ISO 14120"
+      ],
+      "sufficient": false,
+      "reduction_steps": [
+        {
+          "risk_in": {
+            "f": 2,
+            "w": 2,
+            "p": 1,
+            "s": 3,
+            "r": 15
+          },
+          "measures": [
+            "-SICHERES STILLSETZEN ROBOTER"
+          ],
+          "measure_type": "TM",
+          "risk_out": {
+            "f": 2,
+            "w": 1,
+            "p": 1,
+            "s": 1,
+            "r": 4
+          },
+          "norm_references": [
+            "EN ISO 10218-2",
+            "Ziff. 5.3.8"
+          ],
+          "sufficient": true,
+          "plr": {
+            "s": "S2",
+            "f": "F1",
+            "p": "P1",
+            "ew": "Ni",
+            "plr": "b"
+          }
+        }
+      ]
+    },
+    {
+      "nr": "1.20",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkstück an Robotergreifer",
+      "hazard_type": "Quetschen, Scheren, Stoß",
+      "hazard_cause": "Werker steht in Bewegungsbereich des Roboterarms , wird von sich bewegendem Werkstück / Werkzeug  getroffen oder zwischen Werkstück / Werkzeug  und feststehenden Gegenständen gequetscht",
+      "lifecycle_phases": [
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "'Inneres der Roboterzelle / Greifer des Roboterarms",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 24
+      },
+      "measures": [
+        "TEACHING MODUS"
+      ],
+      "measure_type": "TM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN ISO 10218-1 Ziff. 5.6.2 Ziff. 5.7.3 Ziff. 5.8.3"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "c"
+      }
+    },
+    {
+      "nr": "1.21",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkstück an Robotergreifer",
+      "hazard_type": "Schlag, Stoß",
+      "hazard_cause": "Werkstück oder Werkzeug an Robotergreifer durchschlägt Schutzzaun, Person wird getroffen",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung",
+        "Umrüsten",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bereich um Roboterarm außerhalb Maschine",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 14
+      },
+      "measures": [
+        "SICHER BEGRENZTER BEWEGUNSBEREICH"
+      ],
+      "measure_type": "TM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN ISO 10218-2 Ziff.",
+        "5.4.3"
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S1",
+        "f": "F1",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "a"
+      }
+    },
+    {
+      "nr": "1.22",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkstück an Robotergreifer",
+      "hazard_type": "Schlag, Stoß",
+      "hazard_cause": "Greifer des Roboters versagt oder greift nicht richtig und durch Roboter-Arm beschleunigtes Werkstück / Rohling wird weggeschleudert",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung",
+        "Umrüsten",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bereich um Roboterarm außerhalb Roboterzelle",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 24
+      },
+      "measures": [
+        "Einhausung hält durch Roboter weggeschleuderten Rohteilen stand",
+        "Angabe des Maximalgewichts für  Rohteile in BA",
+        "Beschriftung des maximalen Werkstück- / Rohteilgewichts an Transportbändern zur manuellen Beladung"
+      ],
+      "measure_type": "KMBI",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "1.23",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkstück an Robotergreifer",
+      "hazard_type": "Schlag, Stoß",
+      "hazard_cause": "Greifer des Roboters lässt Werkstück fallen, (z.B. durch Ausfall Stromversorgung, Druckluft /Druckverlust), Werkstück trifft Person die sich innerhalb des Schutzzauns aufhält an Hand oder Fuß",
+      "lifecycle_phases": [
+        "Reinigung",
+        "Umrüsten",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bereich unterhalb Greifer / Werkstück",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 16
+      },
+      "measures": [
+        "Greifer inkl. Pneumatik-System sind auf das maximale Werkstück-Gewicht ausgelegt.",
+        "Werkstück wird auch bei Energieausfall (Spannungsversorgung / Druckluft) durch Greifer sicher gehalten *",
+        "Leitungen, Dichtungen, Verbindungsstücke, Befestigungen sowie sonstige Komponenten der Pneumatik sind auf den Nenndruck der Anlage ausgelegt",
+        "Fachgerechte Montage der Komponenten des pneumatischen Systems gemäß den Herstellerangaben",
+        "Hinweis in BA:",
+        "Angabe des maximalen Werkstückgewichts  in BA"
+      ],
+      "measure_type": "KMBI",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN ISO 14120",
+        "EN ISO",
+        "4414"
+      ],
+      "sufficient": true,
+      "comment": "Kommentar:\nAnsteuerung und Druckhaltung des Greifers erfolgt über 5-3 Wegeventil (Stromlos in Sperr-Mittelstellung)\nauch bei Betätigung des Not-Haltes \n(-> Hinweis in BA zu lösen der Quetschenden Verbindungen)"
+    },
+    {
+      "nr": "1.24",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Werkstück an Robotergreifer",
+      "hazard_type": "Quetschen, Scheren, Stoß",
+      "hazard_cause": "Werker ist in Roboterzelle eingeschlossen (Schutztüre Roboterzelle wird geschlossen während sich Person innerhalb befindet) , wird von Roboterarm, Werkzeug oder  Werkstück verletzt",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Roboterarm,\nInneres der Roboterzelle",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 21
+      },
+      "measures": [
+        "Gefahrenbereich der Maschine ist vom HMI der Robodrill von außen einsehbar",
+        "Gefahrbringende Bewegungen des Roboters werden bei Öffnen der Zuganstür stillgesetzt",
+        "Anlage kann nur durch bewusstes Wiederingangsetzen von außerhalb (HMI Robodrill)  wieder anlaufen.",
+        "Öffnen der Schutztüre  zur Roboterzelle von innen händische ohne Hilfsmittel einfach möglich. Öffnen der Schutztüre setzt Roboter still"
+      ],
+      "measure_type": "KMTM",
+      "risk_out": {
+        "f": 2,
+        "w": 2,
+        "p": 1,
+        "s": 1,
+        "r": 5
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F1",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "b"
+      }
+    },
+    {
+      "nr": "1.25",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Förderbänder ( Werkstückzu- / -auslauf)",
+      "hazard_type": "Quetschen, Scheren, Fangen",
+      "hazard_cause": "Werker greift an Förderband für Werkstückzulauf oder -auslauf und wird zwischen beweglichen und feststehenden Teilen des Förderbandes gequetscht",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Förderbänder",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 16
+      },
+      "measures": [
+        "Herstellererklärung  Transportbänder liegt vor",
+        "Keine Quetsch- und Einzugstellen am Förderband vorhanden",
+        "Abstand zwischen auf Band transportierten Werkstück und benachbarten feststehenden Teilen > 25 mm (Lichtschranke etc.)"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "1.26",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Förderbänder ( Werkstückzu- / -auslauf)",
+      "hazard_type": "Quetschen,Stoß",
+      "hazard_cause": "Werker greift an Tunnel, wird von auf Förderband bewegtem Werkstück getroffen (Einquetschen Finger zwischen Werkstück und Portal in Schutzzaun)",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Werkstück auf Förderband",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 14
+      },
+      "measures": [
+        "Abstand zwischen Werkstück (bei üblicher Beladeposition) und Tunnel / Rahmen > 25 mm",
+        "Kanten des Tunnels / Öffnung in Schutzeinhausung nicht schneidend (mit Kantenschutz versehen)",
+        "Transportgeschwindigkeit des Bands < 100 mm/s"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "comment": "Intern:\nGeschwindigkeit der Bänder: (Grenzwert aus letztem Projekt SHW übernommen, Bänder liefen nicht schneller)"
+    },
+    {
+      "nr": "1.27",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Förderbänder ( Werkstückzu- / -auslauf)",
+      "hazard_type": "Quetschen, Schlag, Stoß",
+      "hazard_cause": "Person steht innerhalb oder außerhalb der Zelle an am Ende eines Transportbandes. Ein herein- oder heraustransportiertes Werkstück fällt vom Transportband, trifft Person an Fuß / Bein",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Förderbänder",
+      "risk_in": {
+        "f": 3,
+        "w": 3,
+        "p": 3,
+        "s": 2,
+        "r": 18
+      },
+      "measures": [
+        "Werkstücke sind durch einen mechanischen Anschlag an den Enden der Transportbänder gegen Herunterfallen vom Band gesichert"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "comment": "Kommentar:\nAlle Bänder im Innen- und Außenbereich gesichert"
+    },
+    {
+      "nr": "1.28",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Zentriergreifer (an Transportbändern Werkstückzuführung)",
+      "hazard_type": "Quetschen, Schlag, Stoß",
+      "hazard_cause": "Werker befindet sich außerhalb der  der Roboterzelle und greift an die Zentriereinheit (fest montierten Greifer) und quetscht sich zwischen die Finger / Hand zwischen beweglichen und feststehenden Teilen des Greifers und dem Werkstück oder Transportband",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Zentriereinheit an Förderbänder",
+      "risk_in": {
+        "f": 4,
+        "w": 3,
+        "p": 3,
+        "s": 2,
+        "r": 20
+      },
+      "measures": [
+        "Zentriereinheit / -Greifer befindet sich  innerhalb des Schutzzauns",
+        "ENTWEDER:",
+        "Abstand > 850mm zwischen Greifer und Öffnung der Transportbänder in Schutzzaun / Tunnel",
+        "ODER",
+        "Warnhinweis an Öffnung Schutzzaun:",
+        "Vorsicht Quetschgefahr. Greifen Sie nicht in die Anlage ein",
+        "Piktogramm an Öffnungen Schutzzaun Transportbänder:"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "1.29",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Zentriergreifer (an Transportbändern Werkstückzuführung)",
+      "hazard_type": "Quetschen, Schlag, Stoß",
+      "hazard_cause": "Werker befindet sich innerhalb der Roboterzelle und greift an die Zentriereinheit (fest montierten Greifer) und quetscht sich die Finger / Hand zwischen beweglichen und feststehenden Teilen des Greifers und dem Werkstück oder Transportband",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Zentriereinheit an Förderbänder",
+      "risk_in": {
+        "f": 4,
+        "w": 3,
+        "p": 3,
+        "s": 2,
+        "r": 20
+      },
+      "measures": [
+        "Öffnen der Zugangstüre im Schutzzaun setzt den Greifer still (Magnetventil für Druckluftversorgung von Greifer wird abgesteuert)"
+      ],
+      "measure_type": "KMTM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "plr": {
+        "s": "S1",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ho",
+        "plr": "b"
+      }
+    },
+    {
+      "nr": "1.30",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Druckluftreinigung Werkstücke (Einbau im Bearbeitungsraum der Robodrill)",
+      "hazard_type": "Einstich, \nAugenverletzung",
+      "hazard_cause": "Person wird von ausströmender Druckluft oder Bearbeitungsrückständen in Bearbeitungszelle der Robodrill an Auge verletzt",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bearbeitungszelle WZM / insbesondere vor Schutztüre",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 16
+      },
+      "measures": [
+        "Druckluftreinigungsdüse zur Werkstückreinigung ist innerhalb der  Bearbeitungszelle der WZM eingebaut",
+        "Einhausung des Bearbeitungszentrums ist mechanisch so bemessen, dass weggeschleuderte Teile wie Material,  Bruchstücke und Kühlschmierstoff sicher zurückgehalten werden.",
+        "Druckluftversorgung der Reinigungsdüse zur Werkstückreinigung in Bearbeitungszelle ist bei geöffneter Türe der WZM abgeschaltet"
+      ],
+      "measure_type": "KMTM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN 12417 Kap. 5.2 / Pos. 1.1.4."
+      ],
+      "sufficient": true,
+      "plr": {
+        "s": "S1",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "a"
+      }
+    },
+    {
+      "nr": "1.31",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Robodrill",
+      "hazard_type": "Quetschen, Scheren, Schlag",
+      "hazard_cause": "Werker befindet sich in Roboterzelle und greift durch Beladetüre der Werkzeugmaschine , Beladetüre schließt sich und Werker quetscht sich Hand / Arm an Beladetüre",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Beladetüre Werkzeugmaschine",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 16
+      },
+      "measures": [
+        "Robodrill Werkzeugmaschinen haben CE *"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "comment": "Kommentar:\n* Sicherer Automatikbetrieb und Einrichtbetrieb über CE der Robodrill abgedeckt"
+    },
+    {
+      "nr": "1.32",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Robodrill",
+      "hazard_type": "Quetschen, Scheren, Schlag",
+      "hazard_cause": "Werker befindet sich in Roboterzelle und greift durch Beladetüre ins Innere der Werkzeugmaschine , wird von beweglichen Teilen der Werkzeugmaschine verletzt",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bewegliche Teile in Bearbeitungszelle Werkzeugmaschine",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 24
+      },
+      "measures": [
+        "Türpositionsschalter der Zugangstüre im Schutzzaun ist in Steuerung der Werkzeugmaschine eingebunden.",
+        "Alle gefährlichen Bewegungen der Werkzeugmaschine (Achsen, Spindel, Spannmittel etc.) werden stillgesetzt, wenn die Zugangstüre geöffnet wird.",
+        "Beladetüre der WZM ist bei Bearbeitung /  laufendem Betrieb der WZM geschlossen*",
+        "Robodrill Werkzeugmaschinen haben CE"
+      ],
+      "measure_type": "KMTM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "plr": {
+        "s": "S2",
+        "f": "F2",
+        "p": "P1",
+        "ew": "Ni",
+        "plr": "c"
+      },
+      "comment": "Kommentar:\n* Sicherer Automatikbetrieb und Einrichtbetrieb über CE der Robodrill abgedeckt"
+    },
+    {
+      "nr": "1.33",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Robodrill",
+      "hazard_type": "Quetschen, Scheren, Schlag",
+      "hazard_cause": "Werker befindet sich in Roboterzelle und greift beim Einrichten der Maschine durch Beladetüre ins Innere der Werkzeugmaschine , wird von beweglichen Teilen der Werkzeugmaschine verletzt",
+      "lifecycle_phases": [
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bewegliche Teile in Bearbeitungszelle Werkzeugmaschine",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 24
+      },
+      "measures": [
+        "Robodrill Werkzeugmaschinen haben CE*"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "comment": "Kommentar:\n* Sicherer Automatikbetrieb und Einrichtbetrieb über CE der Robodrill abgedeckt"
+    },
+    {
+      "nr": "1.34",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Kühlschmierstoffanlagen",
+      "hazard_type": "Schlag, Stoß, Einstich",
+      "hazard_cause": "Unter Druck stehender Schlauch mit Kühlschmierstoff, zum Anschluss der Kühlschmierstoff-Aufbereitung-Anlage an das Bearbeitungszentrum, springt ab und trifft Werker\n\n[Voraussetzung: \nMaximaler Druck im Kühlschmierstoffsystem ist 1bar (nur Pumpe für Bettspülung vorhanden)]",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Druckschläuche / \ndruckbeaufschlagte Komponenten des Kühlschmierstoff-systems",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 14
+      },
+      "measures": [
+        "Schläuche, Dichtungen, Verbindungsstücke, Befestigungen sowie sonstige Komponenten sind auf den Nenndruck der jeweiligen Pumpen ausgelegt",
+        "Verwendung von geeigneten Schläuchen und Befestigungen für das Kühlschmierstoffsystem entsprechend den Herstellerempfehlungen und fachgerechte Montage gemäß Herstellerangaben",
+        "Sicherung der Druckschläuche gegen Abspringen"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 2,
+        "r": 6
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "1.35",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Kühlschmierstoffanlagen",
+      "hazard_type": "Schlag, Einstich",
+      "hazard_cause": "Schlauch der Kühlschmierstoffversorgung zum Anschluss der Kühlschmierstoff-Aufbereitung-Anlage an das Bearbeitungszentrum, springt ab oder birst  wenn mit Druck beaufschlagt, Werker wird von Schlauchteilen oder Kühlschmierstoff getroffen",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Druckschläuche / \ndruckbeaufschlagte Komponenten des Kühlschmierstoff-systems",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 21
+      },
+      "measures": [
+        "Schläuche, Dichtungen, Verbindungsstücke, Befestigungen sowie sonstige Komponenten sind auf den Nenndruck der jeweiligen Pumpen ausgelegt"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 2,
+        "r": 6
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "1.36",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Kühlschmierstoffanlagen",
+      "hazard_type": "Stolpern, Stoß",
+      "hazard_cause": "Kühlschmierstoff  tritt aus Leckage aus, Person rutscht aus / stößt sich",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Umgebung des Bearbeitungszentrums und der betreffenden Sub-Systeme",
+      "risk_in": {
+        "f": 3,
+        "w": 3,
+        "p": 3,
+        "s": 2,
+        "r": 18
+      },
+      "measures": [
+        "Schläuche, Dichtungen, Verbindungsstücke, Befestigungen sowie sonstige Komponenten sind auf den Nenndruck der jeweiligen Pumpen ausgelegt",
+        "Sicherung der Druckschläuche gegen Abspringen gemäß Herstellerangaben",
+        "Hinweis in BA:",
+        "\"Rutschgefahr! Beseitigen Sie regelmäßig Verschmutzungen durch Kühlschmierstoff und andere austretende Flüssigkeiten oder Stoffe!\""
+      ],
+      "measure_type": "KMBI",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "1.37",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Kühlschmierstoffanlagen",
+      "hazard_type": "Schlag, Einstich",
+      "hazard_cause": "Niederdruck-Pumpe der Kühlschmierstoffanlage ( ≤ 1 MPa) läuft, Werker bekommt Kühlschmierstoff-Spritzer ins Auge",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Austrittsdüse der Außenkühlung",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 3,
+        "s": 1,
+        "r": 8
+      },
+      "measures": [
+        "SICHERE EINHAUSUNG ROBODRILL"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN 12417 Kap. 5.2 / Pos. 1.1.4."
+      ],
+      "sufficient": true,
+      "comment": "Kommentar:\nnur Bettspülung zur Späneabfuhr vorhanden mit 0,8 bar \nBearbeitung der Werkstücke erfolgt troken."
+    },
+    {
+      "nr": "1.38",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Kühlschmierstoffanlagen",
+      "hazard_type": "Schlag, Einstich",
+      "hazard_cause": "Niederdruck-Pumpe  für Bettspülung ( ≤ 1 MPa)läuft an, Werker bekommt Kühlschmierstoff-Spritzer ins Auge",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Umgebung des Bearbeitungszentrums insbesondere vor Schutztüre",
+      "risk_in": {
+        "f": 2,
+        "w": 3,
+        "p": 1,
+        "s": 1,
+        "r": 6
+      },
+      "measures": [
+        "Die Austrittsöffnungen  für den Kühlschmierstoff zur Bettspülung befinden sich im unteren Bereich der Bearbeitungszelle und der Druck ist so niedrig (hohes Volumen bei niedrigem Druck), dass eine Gefährdung durch hochspritzenden Kühlschmierstoff (ins Auge) nicht gegeben ist"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "1.39",
+      "hazard_group": "Mechanische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Kühlschmierstoffanlagen",
+      "hazard_type": "Schlag, Einstich",
+      "hazard_cause": "Tür des Bearbeitungszentrums ist geöffnet (z.B. Zur Beladung, Behebung von Leckage, Verstopfungen, Einrichten…) , Niederdruck-Pumpe für Bettspülung ( ≤ 1 MPa) der Kühlmittelanlage läuft , Werker bekommt Kühlschmierstoff-Spritzer ins Auge",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Inneres des Bearbeitungszentrums",
+      "risk_in": {
+        "f": 3,
+        "w": 3,
+        "p": 1,
+        "s": 1,
+        "r": 7
+      },
+      "measures": [
+        "Die Austrittsöffnung  für den Kühlschmierstoff zur Bettspülung befindet sich im unteren Bereich der Bearbeitungszelle und der Druck ist so niedrig (hohes Volumen bei niedrigem Druck), dass eine Gefährdung durch hochspritzenden Kühlschmierstoff (ins Auge) nicht gegeben ist"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "2.1",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Elektrischer Schlag",
+      "hazard_cause": "Direktes Berühren von spannungsführenden Teilen (> 50 V AC / 75 V DC)",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Zugängliche Kabel und Leitungen",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 4,
+        "r": 28
+      },
+      "measures": [
+        "Alle zugänglichen Kabel / Leitungen im Niederspannungsbereich (≥ 50 VAC/ 75 VDC):",
+        "a) verstärkt isoliert oder",
+        "b) doppelt isoliert",
+        "Kabel / Leitungen ausreichend gegen die vorhersehbaren Umwelteinflüsse (mechanisch / chemisch / Wasser / UV / Temperatur etc.) geschützt"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 4,
+        "r": 16
+      },
+      "norm_references": [
+        "EN 60204-1 Ziff. 6.2"
+      ],
+      "sufficient": true,
+      "comment": "Prüfprotokoll nach EN 60204-1"
+    },
+    {
+      "nr": "2.2",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Elektrischer Schlag",
+      "hazard_cause": "Direktes Berühren von spannungsführenden Teilen",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Spannungsführende Teile in der Anlage",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 4,
+        "r": 28
+      },
+      "measures": [
+        "Elektrische Ausrüstung im Niederspannungsbereich:",
+        "a) verstärkt isoliert (≥ 2,0 MΩ) oder",
+        "b) doppelt isoliert (≥ 2 x 1,0 MΩ) oder",
+        "c) einfach isoliert (≥ 1,0 MΩ) und durch PE-geschütztes Gehäuse gegen Zugriff geschützt",
+        "Gehäuse um niederspannungsführende Teile fingersicher werkzeuggesichert eingehaust (mindestens IP2X bzw. IPXXB)"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 4,
+        "r": 12
+      },
+      "norm_references": [
+        "EN 60204-1 Ziff. 6.2. Ziff. 8.2.3"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "2.3",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Elektrischer Schlag",
+      "hazard_cause": "Direktes Berühren von spannungsführenden Teilen",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Montage und Installation",
+        "Inbetriebnahme",
+        "Reinigung/ Instandhaltung",
+        "Fehlersuche und -beseitigung",
+        "Demontage"
+      ],
+      "component_zone": "Bereich innerhalb von Einhausungen (z.B. Schaltschrank)",
+      "risk_in": {
+        "f": 2,
+        "w": 3,
+        "p": 3,
+        "s": 4,
+        "r": 32
+      },
+      "measures": [
+        "Bei geöffneter Einhausung (z.B. Schaltschranktür) sind alle Leiter um Bedienelemente fingersicher geschützt (mindestens IP2X bzw. IPXXB)"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 2,
+        "p": 1,
+        "s": 4,
+        "r": 16
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "2.4",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Elektrischer Schlag",
+      "hazard_cause": "Gefährliche Berührungsspannung an berührbaren Teilen (bei Unterbrechung des Schutzleiters) durch erhöhte Ableitströme. (insbesondere bei Einsatz von Komponenten mit Frequenzumformer oder EMV-Filtern)",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Berührbare leitende Oberflächen",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 4,
+        "r": 28
+      },
+      "measures": [
+        "Bei Ableitströmen >10 mA:",
+        "Wahlweise:",
+        "a) mechanischer Schutz des Schutzleiters (z.B. durch zusätzliches Schutzrohr, erd-und kurschlusssichere Verlegung)",
+        "b) Schutzleiter-Querschnitt ≥ 10mm2 Cu",
+        "c) zweiter paralleler Schutzleiter mit gleichem Querschnitt wie Netzanschluss",
+        "d) Schutzleiterüberwachung",
+        "e) bei Steckverbindungen mit Gummi-schlauchleitung Schutzleiterquerschnitt min. 2,5 mm2 (wenn mechanischer Schutz gegeben.) sonst mind. 4mm2",
+        "Hinweis an PE-Anschlussklemme und in BA:*"
+      ],
+      "measure_type": "KMBI",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 4,
+        "r": 12
+      },
+      "norm_references": [
+        "EN 60204-1 Ziff. 8.2.6"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "2.5",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Elektrischer Schlag",
+      "hazard_cause": "Indirektes Berühren von spannungsführenden Teilen",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Berührbare leitende Oberflächen",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 5,
+        "s": 4,
+        "r": 36
+      },
+      "measures": [
+        "Wahlweise / ergänzend:",
+        "1. durchgehende Verbindung des Schutzleitersystems (validiert durch Schutzleiterwiderstandsprüfungen an Oberfläche) und Überstrom-schutzeinrichtung für die automatische Abschaltung der Versorgung im Fehlerfall  (in TN-System),  oder",
+        "2. Verwendung von Geräten der Schutzklasse II oder durch gleichwertige Isolierung oder",
+        "3. Schutz durch Kleinspannung"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 4,
+        "r": 12
+      },
+      "norm_references": [
+        "EN 60204-1 Ziff. 6.3., Ziff. 8.2.3"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "2.6",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Elektrischer Schlag, \nBrand",
+      "hazard_cause": "Kurzschluss oder gefährliche Berührungsspannung an berührbaren Teilen aufgrund von Luft- und Kriechstrecken",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 4,
+        "r": 28
+      },
+      "measures": [
+        "Luft- und Kriechstrecken sind so dimensioniert, dass Sie den zu erwartenden elektrischen Beanspruchungen und Anforderungen an Feuchtigkeit und Verschmutzungsgrad standhalten"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 4,
+        "r": 12
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "comment": "Kommentar:\nVerwendung von elektrischen Standardkomponenten (Keine selbstgefertigten Platinen)"
+    },
+    {
+      "nr": "2.7",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Elektrischer Schlag",
+      "hazard_cause": "Indirektes Berühren von spannungsführenden Teilen durch Anschluss von defekten Geräten an Steckdosenstromkreisen der Maschine",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Berührbare leitende Oberflächen / Betriebsmittel an Steckdosenstromkreisen",
+      "risk_in": {
+        "f": 3,
+        "w": 2,
+        "p": 5,
+        "s": 4,
+        "r": 40
+      },
+      "measures": [
+        "Durchgehende Verbindung des Schutzleitersystems und Absicherung über Überstromschutzeinrichtung*",
+        "Alle Steckdosenkreise sind über eine Fehlerstrom-Schutzeinrichtung (RCD) geschützt"
+      ],
+      "measure_type": "KMBI",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 4,
+        "r": 12
+      },
+      "norm_references": [
+        "EN 61010-1 Ziff. 6.5"
+      ],
+      "sufficient": true,
+      "comment": "*Kommentar:\nValidierung durch Messsung"
+    },
+    {
+      "nr": "2.8",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Brand / Kabelbrand",
+      "hazard_cause": "Brand aufgrund von Überlast / Überhitzung",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Kabel / Leitungen",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 21
+      },
+      "measures": [
+        "Querschnitt der verwendeten Kabel ist auf die maximale elektrische Leistung und auf das vorgeschaltete Überstromschutzorgan ausgelegt",
+        "Überstromschutzeinrichtung für die automatische Abschaltung der Versorgung im Fehlerfall in jedem aktiven Leiter vorhanden und richtig dimensioniert / eingestellt"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN 60204-1 Ziff. 7.2"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "2.9",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Brand",
+      "hazard_cause": "Kurzschluss durch eindringendes Wasser",
+      "lifecycle_phases": [
+        "Reinigung"
+      ],
+      "component_zone": "Spannungsführende Teile in der Anlage",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 21
+      },
+      "measures": [
+        "Schutz vor eindringendem Wasser für Schaltgerätekombinationen mind. IP22",
+        "Netztrenneinrichtung (Hauptschalter oder frei zugängliche Steckverbindung)",
+        "Warnhinweis in BA:",
+        "Reinigungsarbeiten nur in spannungsfreiem Zustand durchführen",
+        "Warnhinweis in BA:",
+        "Verwenden Sie keine tropfnassen Tücher oder Hochdruckreiniger"
+      ],
+      "measure_type": "KMBI",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 2,
+        "r": 6
+      },
+      "norm_references": [
+        "EN 60204-1 Ziff. 5.3, Ziff. 11.3"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "2.10",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Brand",
+      "hazard_cause": "Kurzschluss durch aus Rohrleitung oder Behälter austretende Flüssigkeiten  (z.B. Kühlschmierstoff)",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Spannungsführende Teile  der Anlage unterhalb / angrenzend von Rohrleitungen oder Behältern",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 21
+      },
+      "measures": [
+        "Kühlschmierstoffanlage:",
+        "Schläuche, Dichtungen, Verbindungsstücke, Befestigungen sowie sonstige Komponenten sind auf den Nenndruck der jeweiligen Pumpen ausgelegt",
+        "Verwendung von geeigneten Schläuchen und Befestigungen für das Kühlschmierstoffsystem entsprechend den Herstellerempfehlungen und fachgerechte Montage gemäß Herstellerangaben",
+        "Sicherung der Druckschläuche gegen Abspringen"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN 60204-1 Ziff. 11.3"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "2.11",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Elektrischer Schlag, Brand",
+      "hazard_cause": "Beschädigen/Ausreißen der im zugänglichen Bereich verlegten Kabel",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Verlegte Kabel",
+      "risk_in": {
+        "f": 1,
+        "w": 2,
+        "p": 3,
+        "s": 4,
+        "r": 24
+      },
+      "measures": [
+        "Außerhalb von Gehäusen verlegte Kabel in einem Kabelkanal verlegt oder Verwendung ausreichend gegen mechanische Beschädigung geschützter Kabel",
+        "Zugentlastung der Kabel an Gehäuseeinführungen und wo technisch sinnvoll"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 4,
+        "r": 12
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "2.12",
+      "hazard_group": "Elektrische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Elektrischer Schlag",
+      "hazard_cause": "Gefährliche Berührungsspannung an leitfähigen Teilen durch unterschiedliche Potentiale der verschiedenen Anlagenteile (Roboterzelle, Robodrill, Kühlschmierstoffaufbereitung, …)",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "elektrisch leitfähige Oberflächen",
+      "risk_in": {
+        "f": 2,
+        "w": 2,
+        "p": 3,
+        "s": 4,
+        "r": 28
+      },
+      "measures": [
+        "Potentialausgleich zwischen Robodrill / Kühlschmierstoff-Anlage / Roboterzelle und sonstigen Anlagenteilen die unterschiedliche Potentiale annehmen können (Stromversorgung über verschiedene Einspeisungen z.B. Hausnetz / Robodrill."
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "3.1",
+      "hazard_group": "Thermische Gefährdungen",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Keine relevanten elektrischen Gefährdungen durch Geräte (Einheiten hat Einbauerklärung / CE-Zeichen)",
+      "hazard_type": "Verbrennung",
+      "hazard_cause": "Person verletzt sich an heißen Werkstücken\n\n[Voraussetzung: Werkstücke werden nicht gefährlich heiß]",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Werkstück",
+      "risk_in": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "measures": [
+        "==> keine risikomindernden Maßnahmen erforlderlich"
+      ],
+      "measure_type": "",
+      "risk_out": {
+        "f": 0,
+        "w": 0,
+        "p": 0,
+        "s": 0,
+        "r": 0
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "4.1",
+      "hazard_group": "Gefährdungen durch Lärm",
+      "hazard_group_applicable": true,
+      "hazard_subgroup": "Keine relevanten elektrischen Gefährdungen durch Geräte (Einheiten hat Einbauerklärung / CE-Zeichen)",
+      "hazard_type": "Lärm",
+      "hazard_cause": "Person erleidet Schädigung des Gehörs durch hohen Geräuschpegel\n[Voraussetzung: Emission von Robodrill und Roboterarm < 70 dB]",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Direkte Umgebung Maschine",
+      "risk_in": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "measures": [
+        "==> keine risikomindernden Maßnahmen erforlderlich"
+      ],
+      "measure_type": "",
+      "risk_out": {
+        "f": 0,
+        "w": 0,
+        "p": 0,
+        "s": 0,
+        "r": 0
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "6.1",
+      "hazard_group": "Gefährdungen durch Strahlung",
+      "hazard_group_applicable": false,
+      "hazard_subgroup": "Allgemein",
+      "hazard_type": "Quetschen; Scheren, Schlag",
+      "hazard_cause": "Bewegliche Teile des Bearbeitungszentrums oder von Sub-Systemen (Achsen, Werkzeug, Spannvorrichtung etc.) , werden durch elektromagnetische Einkopplung / Störungen unerwartet in Bewegung gesetzt, Werker verletzt sich",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bearbeitungsbereich innerhalb des Bearbeitungszentrum",
+      "risk_in": {
+        "f": 1,
+        "w": 2,
+        "p": 3,
+        "s": 3,
+        "r": 18
+      },
+      "measures": [
+        "Eingesetzte Komponenten / Systeme sind technisch gegen gefährliche EMV Störeinflüsse ausgelegt / geschirmt.",
+        "Fachgerechte EMV-konforme Installation und Verkabelung der Zusatz-Komponenten und Sub-Systeme unter Beachtung der Herstellerangaben"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [
+        "EN 16090-1 Ziff. 5.8.7"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "7.1",
+      "hazard_group": "Gefährdungen durch Materialien und Substanzen",
+      "hazard_group_applicable": false,
+      "hazard_subgroup": "Kühlmittelanlage (Coolant System)",
+      "hazard_type": "Hautirritationen, Atembeschwerden, Infektion",
+      "hazard_cause": "Hautkontakt mit Kühlschmierstoff bei Arbeiten an Bearbeitungszentrum oder angrenzender Roboterzelle",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bearbeitungszentrum,\nRoboterzelle Bereich Beladetüre Robodrill",
+      "risk_in": {
+        "f": 3,
+        "w": 4,
+        "p": 3,
+        "s": 1,
+        "r": 10
+      },
+      "measures": [
+        "Hinweis in BA:",
+        "Gefährdung durch Stoffe:",
+        "Beachten Sie die Sicherheitshinweise gemäß Sicherheitsdatenblatt des eingesetzten Kühlschmierstoffes und tragen Sie die erforderliche persönliche Schutzausrüstung"
+      ],
+      "measure_type": "BI",
+      "risk_out": {
+        "f": 1,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 3
+      },
+      "norm_references": [],
+      "sufficient": true
+    },
+    {
+      "nr": "7.2",
+      "hazard_group": "Gefährdungen durch Materialien und Substanzen",
+      "hazard_group_applicable": false,
+      "hazard_subgroup": "Kühlmittelanlage (Coolant System)",
+      "hazard_type": "Atembeschwerden",
+      "hazard_cause": "Person atmet  Kühlschmierstoff-Aerosole ein, die während Werkstückbearbeitung in Bearbeitungszelle entstehen\n\n[Voraussetzung: Anlage nur mit Pumpe für Bettspülung ausgerüstet  mit 0,8 bar]",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bearbeitungszentrum,  vor Bearbeitungszelle",
+      "risk_in": {
+        "f": 2,
+        "w": 1,
+        "p": 3,
+        "s": 1,
+        "r": 6
+      },
+      "measures": [
+        "SICHERE EINHAUSUNG ROBODRILL",
+        "hält Dämpfe / Aerosole zurück.",
+        "Schutztüren (Front- und Seitentüre) der Robodrill sind während des Bearbeitungsprozesses  geschlossen"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN 12417 Kap. 5.2 / Pos. 7.1",
+        "(Neue Norm: EN 16090-1 Kap. 5.)"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "7.4",
+      "hazard_group": "Gefährdungen durch Materialien und Substanzen",
+      "hazard_group_applicable": false,
+      "hazard_subgroup": "Kühlmittelanlage (Coolant System)",
+      "hazard_type": "Atembeschwerden",
+      "hazard_cause": "Person atmet Kühlschmierstoff-Aerosole ein, die sich nach beendeter Werkstückbearbeitung  (Türe des Bearbeitungszentrums geöffnet) noch in der Bearbeitungszelle befinden",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Einrichten",
+        "Einlernen (Teachen)/Programmieren und/oder Umrüsten",
+        "Reinigung",
+        "Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bearbeitungszentrum,  Bearbeitungszelle",
+      "risk_in": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "measures": [
+        "Keine risikomindernde Maßnahme erforderlich *"
+      ],
+      "measure_type": "",
+      "risk_out": {
+        "f": 0,
+        "w": 0,
+        "p": 0,
+        "s": 0,
+        "r": 0
+      },
+      "norm_references": [],
+      "sufficient": true,
+      "comment": "Kommentar:\nMenge der entstehenden Kühlschmierstoff-Aerosole ist nur so hoch, dass nach abgeschlossenem Bearbeitungsvorgang  / Öffnen der Schutztüre keine kritische Aerosol-Konzentration mehr in der Bearbeitungszelle herrscht."
+    },
+    {
+      "nr": "8.1",
+      "hazard_group": "Ergonomische Gefährdungen",
+      "hazard_group_applicable": false,
+      "hazard_subgroup": "Kühlmittelanlage (Coolant System)",
+      "hazard_type": "Störung des Bewegungsapparates",
+      "hazard_cause": "Ergonomische ungünstige Einlegepositionen",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Inbetriebnahme",
+        "Reinigung/ Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Beladebereich der Anlage",
+      "risk_in": {
+        "f": 5,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 20
+      },
+      "measures": [
+        "Die Höhe des Transportbandes ist ausgelegt auf eine möglichst ergonomische Handhabung der Werkstücke bei der Be- und Entladung der Maschine.",
+        "Beladung der Transportbänder zur manuellen Beladung mit Hebehilfe möglich",
+        "Hinweis in BA:",
+        "Bei Werkstücken mit einem Gewicht >25kg ist für die Be- und Entladung eine Hebehilfe zu verwenden"
+      ],
+      "measure_type": "KMBI",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN 614-1 DIN EN 1005-2 Tab.1"
+      ],
+      "sufficient": true
+    },
+    {
+      "nr": "8.2",
+      "hazard_group": "Ergonomische Gefährdungen",
+      "hazard_group_applicable": false,
+      "hazard_subgroup": "Kühlmittelanlage (Coolant System)",
+      "hazard_type": "Störung des Bewegungsapparates",
+      "hazard_cause": "Bedienelemente werden aus einer unergonomischen Position heraus bedient",
+      "lifecycle_phases": [
+        "Betrieb",
+        "Inbetriebnahme",
+        "Reinigung/ Instandhaltung",
+        "Fehlersuche und -beseitigung"
+      ],
+      "component_zone": "Bereich um die Bedienelemente",
+      "risk_in": {
+        "f": 5,
+        "w": 2,
+        "p": 3,
+        "s": 2,
+        "r": 20
+      },
+      "measures": [
+        "Bedienelemente in ergonomisch günstiger Höhe positioniert (Arbeitshöhe in stehender Position zwischen 95 und 120 cm, Bedienelemente zwischen 95 und 150 cm Höhe, keine Handhabung von schweren oder sperrigen Gegenständen)",
+        "Kein ständiger Arbeitsplatz. Anlage läuft i.d.R. automatisch"
+      ],
+      "measure_type": "KM",
+      "risk_out": {
+        "f": 2,
+        "w": 1,
+        "p": 1,
+        "s": 1,
+        "r": 4
+      },
+      "norm_references": [
+        "EN 614-1"
+      ],
+      "sufficient": true
+    }
+  ],
+  "source_file": "GroundTruth Bremse- risikobeurteilung.xlsx",
+  "imported_at": "2026-05-13",
+  "description": "Roboterzelle Bremsscheibe — professionelle Risikobeurteilung als Benchmark"
+}
\ No newline at end of file