From 6d2de9b897365b184d67a2740f859fc290b95a81 Mon Sep 17 00:00:00 2001
From: Benjamin Admin <benjaminadmin@MacBookPro.fritz.box>
Date: Mon, 16 Mar 2026 12:50:53 +0100
Subject: [PATCH] =?UTF-8?q?feat(iace):=20complete=20CE=20risk=20assessment?=
 =?UTF-8?q?=20=E2=80=94=20LLM=20tech-file=20generation,=20multi-format=20e?=
 =?UTF-8?q?xport,=20TipTap=20editor?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 1: Fix completeness gates G23 (require verified/rejected mitigations) and G09 (audit trail check)
Phase 2: LLM-based tech-file section generation with 19 German prompts and RAG enrichment
Phase 3: Multi-format document export (PDF/Excel/DOCX/Markdown/JSON)
Phase 4: Company profile → IACE data flow with auto component/classification creation
Phase 5: TipTap WYSIWYG editor replacing textarea for tech-file sections
Phase 6: User journey tests, developer portal API reference, updated documentation

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../sdk/iace/[projectId]/tech-file/page.tsx   |  130 +-
 .../components/sdk/iace/TechFileEditor.tsx    |  272 ++++
 admin-compliance/package-lock.json            |  875 ++++++++++++-
 admin-compliance/package.json                 |    8 +
 ai-compliance-sdk/cmd/server/main.go          |    3 +-
 .../internal/api/handlers/iace_handler.go     |  351 +++++-
 .../internal/iace/completeness.go             |   35 +-
 .../internal/iace/completeness_test.go        |   61 +-
 .../internal/iace/document_export.go          | 1101 +++++++++++++++++
 .../internal/iace/document_export_test.go     |  305 +++++
 ai-compliance-sdk/internal/iace/store.go      |   15 +
 .../internal/iace/tech_file_generator.go      |  679 ++++++++++
 .../internal/iace/tech_file_generator_test.go |  521 ++++++++
 .../internal/iace/user_journey_test.go        |  487 ++++++++
 developer-portal/app/api/iace/page.tsx        | 1008 +++++++++++++++
 docs-src/services/sdk-modules/iace.md         |  138 ++-
 16 files changed, 5828 insertions(+), 161 deletions(-)
 create mode 100644 admin-compliance/components/sdk/iace/TechFileEditor.tsx
 create mode 100644 ai-compliance-sdk/internal/iace/document_export.go
 create mode 100644 ai-compliance-sdk/internal/iace/document_export_test.go
 create mode 100644 ai-compliance-sdk/internal/iace/tech_file_generator.go
 create mode 100644 ai-compliance-sdk/internal/iace/tech_file_generator_test.go
 create mode 100644 ai-compliance-sdk/internal/iace/user_journey_test.go
 create mode 100644 developer-portal/app/api/iace/page.tsx

diff --git a/admin-compliance/app/sdk/iace/[projectId]/tech-file/page.tsx b/admin-compliance/app/sdk/iace/[projectId]/tech-file/page.tsx
index f32b923..9aa8ad8 100644
--- a/admin-compliance/app/sdk/iace/[projectId]/tech-file/page.tsx
+++ b/admin-compliance/app/sdk/iace/[projectId]/tech-file/page.tsx
@@ -1,7 +1,8 @@
 'use client'
 
-import React, { useState, useEffect } from 'react'
+import React, { useState, useEffect, useRef } from 'react'
 import { useParams } from 'next/navigation'
+import { TechFileEditor } from '@/components/sdk/iace/TechFileEditor'
 
 interface TechFileSection {
   id: string
@@ -67,6 +68,14 @@ const STATUS_CONFIG: Record<string, { label: string; color: string; bgColor: str
   approved: { label: 'Freigegeben', color: 'text-green-700', bgColor: 'bg-green-100' },
 }
 
+const EXPORT_FORMATS: { value: string; label: string; extension: string }[] = [
+  { value: 'pdf', label: 'PDF', extension: '.pdf' },
+  { value: 'xlsx', label: 'Excel', extension: '.xlsx' },
+  { value: 'docx', label: 'Word', extension: '.docx' },
+  { value: 'md', label: 'Markdown', extension: '.md' },
+  { value: 'json', label: 'JSON', extension: '.json' },
+]
+
 function StatusBadge({ status }: { status: string }) {
   const config = STATUS_CONFIG[status] || STATUS_CONFIG.empty
   return (
@@ -87,7 +96,6 @@ function SectionViewer({
   onApprove: (id: string) => void
   onSave: (id: string, content: string) => void
 }) {
-  const [editedContent, setEditedContent] = useState(section.content || '')
   const [editing, setEditing] = useState(false)
 
   return (
@@ -111,13 +119,10 @@ function SectionViewer({
           )}
           {editing && (
             <button
-              onClick={() => {
-                onSave(section.id, editedContent)
-                setEditing(false)
-              }}
-              className="text-sm px-3 py-1.5 bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors"
+              onClick={() => setEditing(false)}
+              className="text-sm px-3 py-1.5 border border-gray-300 text-gray-700 rounded-lg hover:bg-gray-50 transition-colors"
             >
-              Speichern
+              Fertig
             </button>
           )}
           {section.status !== 'approved' && section.content && !editing && (
@@ -136,19 +141,19 @@ function SectionViewer({
         </div>
       </div>
       <div className="p-6">
-        {editing ? (
-          <textarea
-            value={editedContent}
-            onChange={(e) => setEditedContent(e.target.value)}
-            rows={20}
-            className="w-full px-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-purple-500 focus:border-transparent font-mono text-sm dark:bg-gray-700 dark:border-gray-600 dark:text-white"
-          />
-        ) : section.content ? (
-          <div className="prose prose-sm max-w-none dark:prose-invert">
-            <pre className="whitespace-pre-wrap text-sm text-gray-700 dark:text-gray-300 bg-gray-50 dark:bg-gray-750 p-4 rounded-lg">
-              {section.content}
-            </pre>
-          </div>
+        {section.content ? (
+          editing ? (
+            <TechFileEditor
+              content={section.content}
+              onSave={(html) => onSave(section.id, html)}
+            />
+          ) : (
+            <TechFileEditor
+              content={section.content}
+              onSave={() => {}}
+              readOnly
+            />
+          )
         ) : (
           <div className="text-center py-8 text-gray-500">
             Kein Inhalt vorhanden. Klicken Sie &quot;Generieren&quot; um den Abschnitt zu erstellen.
@@ -167,6 +172,21 @@ export default function TechFilePage() {
   const [generatingSection, setGeneratingSection] = useState<string | null>(null)
   const [viewingSection, setViewingSection] = useState<TechFileSection | null>(null)
   const [exporting, setExporting] = useState(false)
+  const [showExportMenu, setShowExportMenu] = useState(false)
+  const exportMenuRef = useRef<HTMLDivElement>(null)
+
+  // Close export menu when clicking outside
+  useEffect(() => {
+    function handleClickOutside(event: MouseEvent) {
+      if (exportMenuRef.current && !exportMenuRef.current.contains(event.target as Node)) {
+        setShowExportMenu(false)
+      }
+    }
+    if (showExportMenu) {
+      document.addEventListener('mousedown', handleClickOutside)
+      return () => document.removeEventListener('mousedown', handleClickOutside)
+    }
+  }, [showExportMenu])
 
   useEffect(() => {
     fetchSections()
@@ -236,18 +256,22 @@ export default function TechFilePage() {
     }
   }
 
-  async function handleExportZip() {
+  async function handleExport(format: string) {
     setExporting(true)
+    setShowExportMenu(false)
     try {
-      const res = await fetch(`/api/sdk/v1/iace/projects/${projectId}/tech-file/export`, {
-        method: 'POST',
-      })
+      const res = await fetch(
+        `/api/sdk/v1/iace/projects/${projectId}/tech-file/export?format=${format}`,
+        { method: 'GET' }
+      )
       if (res.ok) {
         const blob = await res.blob()
         const url = window.URL.createObjectURL(blob)
+        const formatConfig = EXPORT_FORMATS.find((f) => f.value === format)
+        const extension = formatConfig?.extension || `.${format}`
         const a = document.createElement('a')
         a.href = url
-        a.download = `CE-Akte-${projectId}.zip`
+        a.download = `CE-Akte-${projectId}${extension}`
         document.body.appendChild(a)
         a.click()
         document.body.removeChild(a)
@@ -284,25 +308,45 @@ export default function TechFilePage() {
             Sie alle erforderlichen Abschnitte.
           </p>
         </div>
-        <button
-          onClick={handleExportZip}
-          disabled={!allRequiredApproved || exporting}
-          title={!allRequiredApproved ? 'Alle Pflichtabschnitte muessen freigegeben sein' : 'CE-Akte als ZIP exportieren'}
-          className={`flex items-center gap-2 px-4 py-2 rounded-lg font-medium transition-colors ${
-            allRequiredApproved && !exporting
-              ? 'bg-purple-600 text-white hover:bg-purple-700'
-              : 'bg-gray-200 text-gray-400 cursor-not-allowed'
-          }`}
-        >
-          {exporting ? (
-            <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white" />
-          ) : (
-            <svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 10v6m0 0l-3-3m3 3l3-3m2 8H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+        {/* Export Dropdown */}
+        <div className="relative" ref={exportMenuRef}>
+          <button
+            onClick={() => setShowExportMenu((prev) => !prev)}
+            disabled={!allRequiredApproved || exporting}
+            title={!allRequiredApproved ? 'Alle Pflichtabschnitte muessen freigegeben sein' : 'CE-Akte exportieren'}
+            className={`flex items-center gap-2 px-4 py-2 rounded-lg font-medium transition-colors ${
+              allRequiredApproved && !exporting
+                ? 'bg-purple-600 text-white hover:bg-purple-700'
+                : 'bg-gray-200 text-gray-400 cursor-not-allowed'
+            }`}
+          >
+            {exporting ? (
+              <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white" />
+            ) : (
+              <svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 10v6m0 0l-3-3m3 3l3-3m2 8H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+              </svg>
+            )}
+            Exportieren
+            <svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
             </svg>
+          </button>
+          {showExportMenu && allRequiredApproved && !exporting && (
+            <div className="absolute right-0 mt-2 w-48 bg-white dark:bg-gray-800 rounded-lg shadow-lg border border-gray-200 dark:border-gray-700 py-1 z-50">
+              {EXPORT_FORMATS.map((fmt) => (
+                <button
+                  key={fmt.value}
+                  onClick={() => handleExport(fmt.value)}
+                  className="w-full text-left px-4 py-2 text-sm text-gray-700 dark:text-gray-300 hover:bg-gray-100 dark:hover:bg-gray-700 transition-colors flex items-center gap-3"
+                >
+                  <span className="text-xs font-mono uppercase w-10 text-gray-400">{fmt.extension}</span>
+                  <span>{fmt.label}</span>
+                </button>
+              ))}
+            </div>
           )}
-          ZIP exportieren
-        </button>
+        </div>
       </div>
 
       {/* Progress */}
diff --git a/admin-compliance/components/sdk/iace/TechFileEditor.tsx b/admin-compliance/components/sdk/iace/TechFileEditor.tsx
new file mode 100644
index 0000000..78a8cb2
--- /dev/null
+++ b/admin-compliance/components/sdk/iace/TechFileEditor.tsx
@@ -0,0 +1,272 @@
+'use client'
+
+import React, { useCallback, useEffect, useRef } from 'react'
+import { useEditor, EditorContent, type Editor } from '@tiptap/react'
+import StarterKit from '@tiptap/starter-kit'
+import Table from '@tiptap/extension-table'
+import TableRow from '@tiptap/extension-table-row'
+import TableHeader from '@tiptap/extension-table-header'
+import TableCell from '@tiptap/extension-table-cell'
+import Image from '@tiptap/extension-image'
+
+interface TechFileEditorProps {
+  content: string
+  onSave: (content: string) => void
+  readOnly?: boolean
+}
+
+function normalizeContent(content: string): string {
+  if (!content) return '<p></p>'
+  const trimmed = content.trim()
+  // If it looks like JSON array or has no HTML tags, wrap in <p>
+  if (trimmed.startsWith('[') || !/<[a-z][\s\S]*>/i.test(trimmed)) {
+    return `<p>${trimmed.replace(/\n/g, '</p><p>')}</p>`
+  }
+  return trimmed
+}
+
+interface ToolbarButtonProps {
+  onClick: () => void
+  isActive?: boolean
+  disabled?: boolean
+  title: string
+  children: React.ReactNode
+}
+
+function ToolbarButton({ onClick, isActive, disabled, title, children }: ToolbarButtonProps) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      disabled={disabled}
+      title={title}
+      className={`p-1.5 rounded text-sm font-medium transition-colors ${
+        isActive
+          ? 'bg-purple-100 text-purple-700 dark:bg-purple-900/40 dark:text-purple-300'
+          : 'text-gray-600 hover:bg-gray-100 dark:text-gray-400 dark:hover:bg-gray-700'
+      } disabled:opacity-40 disabled:cursor-not-allowed`}
+    >
+      {children}
+    </button>
+  )
+}
+
+export function TechFileEditor({ content, onSave, readOnly = false }: TechFileEditorProps) {
+  const debounceTimer = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const onSaveRef = useRef(onSave)
+  onSaveRef.current = onSave
+
+  const debouncedSave = useCallback((html: string) => {
+    if (debounceTimer.current) {
+      clearTimeout(debounceTimer.current)
+    }
+    debounceTimer.current = setTimeout(() => {
+      onSaveRef.current(html)
+    }, 3000)
+  }, [])
+
+  const editor = useEditor({
+    extensions: [
+      StarterKit.configure({
+        heading: { levels: [2, 3, 4] },
+      }),
+      Table.configure({
+        resizable: true,
+        HTMLAttributes: { class: 'border-collapse border border-gray-300' },
+      }),
+      TableRow,
+      TableHeader,
+      TableCell,
+      Image.configure({
+        HTMLAttributes: { class: 'max-w-full rounded' },
+      }),
+    ],
+    content: normalizeContent(content),
+    editable: !readOnly,
+    onUpdate: ({ editor: ed }: { editor: Editor }) => {
+      if (!readOnly) {
+        debouncedSave(ed.getHTML())
+      }
+    },
+    editorProps: {
+      attributes: {
+        class: 'prose prose-sm max-w-none dark:prose-invert focus:outline-none min-h-[300px] px-4 py-3',
+      },
+    },
+  })
+
+  // Update content when parent prop changes
+  useEffect(() => {
+    if (editor && content) {
+      const normalized = normalizeContent(content)
+      const currentHTML = editor.getHTML()
+      if (normalized !== currentHTML) {
+        editor.commands.setContent(normalized)
+      }
+    }
+  }, [content, editor])
+
+  // Update editable state when readOnly changes
+  useEffect(() => {
+    if (editor) {
+      editor.setEditable(!readOnly)
+    }
+  }, [readOnly, editor])
+
+  // Cleanup debounce timer
+  useEffect(() => {
+    return () => {
+      if (debounceTimer.current) {
+        clearTimeout(debounceTimer.current)
+      }
+    }
+  }, [])
+
+  if (!editor) {
+    return (
+      <div className="border border-gray-200 dark:border-gray-700 rounded-lg p-4 min-h-[300px] flex items-center justify-center">
+        <div className="animate-spin rounded-full h-6 w-6 border-b-2 border-purple-600" />
+      </div>
+    )
+  }
+
+  return (
+    <div className="border border-gray-200 dark:border-gray-700 rounded-lg overflow-hidden">
+      {/* Toolbar */}
+      {!readOnly && (
+        <div className="flex flex-wrap items-center gap-0.5 px-2 py-1.5 border-b border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-800/50">
+          {/* Text formatting */}
+          <ToolbarButton
+            onClick={() => editor.chain().focus().toggleBold().run()}
+            isActive={editor.isActive('bold')}
+            title="Fett (Ctrl+B)"
+          >
+            <svg className="w-4 h-4" viewBox="0 0 24 24" fill="currentColor">
+              <path d="M15.6 10.79c.97-.67 1.65-1.77 1.65-2.79 0-2.26-1.75-4-4-4H7v14h7.04c2.09 0 3.71-1.7 3.71-3.79 0-1.52-.86-2.82-2.15-3.42zM10 6.5h3c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5h-3v-3zm3.5 9H10v-3h3.5c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5z" />
+            </svg>
+          </ToolbarButton>
+          <ToolbarButton
+            onClick={() => editor.chain().focus().toggleItalic().run()}
+            isActive={editor.isActive('italic')}
+            title="Kursiv (Ctrl+I)"
+          >
+            <svg className="w-4 h-4" viewBox="0 0 24 24" fill="currentColor">
+              <path d="M10 4v3h2.21l-3.42 8H6v3h8v-3h-2.21l3.42-8H18V4z" />
+            </svg>
+          </ToolbarButton>
+
+          <div className="w-px h-5 bg-gray-300 dark:bg-gray-600 mx-1" />
+
+          {/* Headings */}
+          <ToolbarButton
+            onClick={() => editor.chain().focus().toggleHeading({ level: 2 }).run()}
+            isActive={editor.isActive('heading', { level: 2 })}
+            title="Ueberschrift 2"
+          >
+            <span className="text-xs font-bold">H2</span>
+          </ToolbarButton>
+          <ToolbarButton
+            onClick={() => editor.chain().focus().toggleHeading({ level: 3 }).run()}
+            isActive={editor.isActive('heading', { level: 3 })}
+            title="Ueberschrift 3"
+          >
+            <span className="text-xs font-bold">H3</span>
+          </ToolbarButton>
+          <ToolbarButton
+            onClick={() => editor.chain().focus().toggleHeading({ level: 4 }).run()}
+            isActive={editor.isActive('heading', { level: 4 })}
+            title="Ueberschrift 4"
+          >
+            <span className="text-xs font-bold">H4</span>
+          </ToolbarButton>
+
+          <div className="w-px h-5 bg-gray-300 dark:bg-gray-600 mx-1" />
+
+          {/* Lists */}
+          <ToolbarButton
+            onClick={() => editor.chain().focus().toggleBulletList().run()}
+            isActive={editor.isActive('bulletList')}
+            title="Aufzaehlung"
+          >
+            <svg className="w-4 h-4" viewBox="0 0 24 24" fill="currentColor">
+              <path d="M4 10.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0-6c-.83 0-1.5.67-1.5 1.5S3.17 7.5 4 7.5 5.5 6.83 5.5 6 4.83 4.5 4 4.5zm0 12c-.83 0-1.5.68-1.5 1.5s.68 1.5 1.5 1.5 1.5-.68 1.5-1.5-.67-1.5-1.5-1.5zM7 19h14v-2H7v2zm0-6h14v-2H7v2zm0-8v2h14V5H7z" />
+            </svg>
+          </ToolbarButton>
+          <ToolbarButton
+            onClick={() => editor.chain().focus().toggleOrderedList().run()}
+            isActive={editor.isActive('orderedList')}
+            title="Nummerierte Liste"
+          >
+            <svg className="w-4 h-4" viewBox="0 0 24 24" fill="currentColor">
+              <path d="M2 17h2v.5H3v1h1v.5H2v1h3v-4H2v1zm1-9h1V4H2v1h1v3zm-1 3h1.8L2 13.1v.9h3v-1H3.2L5 10.9V10H2v1zm5-6v2h14V5H7zm0 14h14v-2H7v2zm0-6h14v-2H7v2z" />
+            </svg>
+          </ToolbarButton>
+
+          <div className="w-px h-5 bg-gray-300 dark:bg-gray-600 mx-1" />
+
+          {/* Table */}
+          <ToolbarButton
+            onClick={() => editor.chain().focus().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run()}
+            title="Tabelle einfuegen (3x3)"
+          >
+            <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <rect x="3" y="3" width="18" height="18" rx="2" />
+              <line x1="3" y1="9" x2="21" y2="9" />
+              <line x1="3" y1="15" x2="21" y2="15" />
+              <line x1="9" y1="3" x2="9" y2="21" />
+              <line x1="15" y1="3" x2="15" y2="21" />
+            </svg>
+          </ToolbarButton>
+
+          {/* Blockquote */}
+          <ToolbarButton
+            onClick={() => editor.chain().focus().toggleBlockquote().run()}
+            isActive={editor.isActive('blockquote')}
+            title="Zitat"
+          >
+            <svg className="w-4 h-4" viewBox="0 0 24 24" fill="currentColor">
+              <path d="M6 17h3l2-4V7H5v6h3zm8 0h3l2-4V7h-6v6h3z" />
+            </svg>
+          </ToolbarButton>
+
+          {/* Code Block */}
+          <ToolbarButton
+            onClick={() => editor.chain().focus().toggleCodeBlock().run()}
+            isActive={editor.isActive('codeBlock')}
+            title="Code-Block"
+          >
+            <svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <polyline points="16,18 22,12 16,6" />
+              <polyline points="8,6 2,12 8,18" />
+            </svg>
+          </ToolbarButton>
+
+          <div className="w-px h-5 bg-gray-300 dark:bg-gray-600 mx-1" />
+
+          {/* Undo / Redo */}
+          <ToolbarButton
+            onClick={() => editor.chain().focus().undo().run()}
+            disabled={!editor.can().undo()}
+            title="Rueckgaengig (Ctrl+Z)"
+          >
+            <svg className="w-4 h-4" viewBox="0 0 24 24" fill="currentColor">
+              <path d="M12.5 8c-2.65 0-5.05.99-6.9 2.6L2 7v9h9l-3.62-3.62c1.39-1.16 3.16-1.88 5.12-1.88 3.54 0 6.55 2.31 7.6 5.5l2.37-.78C21.08 11.03 17.15 8 12.5 8z" />
+            </svg>
+          </ToolbarButton>
+          <ToolbarButton
+            onClick={() => editor.chain().focus().redo().run()}
+            disabled={!editor.can().redo()}
+            title="Wiederholen (Ctrl+Shift+Z)"
+          >
+            <svg className="w-4 h-4" viewBox="0 0 24 24" fill="currentColor">
+              <path d="M18.4 10.6C16.55 8.99 14.15 8 11.5 8c-4.65 0-8.58 3.03-9.96 7.22L3.9 16c1.05-3.19 4.05-5.5 7.6-5.5 1.95 0 3.73.72 5.12 1.88L13 16h9V7l-3.6 3.6z" />
+            </svg>
+          </ToolbarButton>
+        </div>
+      )}
+
+      {/* Editor Content */}
+      <EditorContent editor={editor} />
+    </div>
+  )
+}
diff --git a/admin-compliance/package-lock.json b/admin-compliance/package-lock.json
index 426fdc7..cf2fcbe 100644
--- a/admin-compliance/package-lock.json
+++ b/admin-compliance/package-lock.json
@@ -8,6 +8,14 @@
       "name": "breakpilot-compliance-sdk-admin",
       "version": "1.0.0",
       "dependencies": {
+        "@tiptap/extension-image": "^3.20.2",
+        "@tiptap/extension-table": "^3.20.2",
+        "@tiptap/extension-table-cell": "^3.20.2",
+        "@tiptap/extension-table-header": "^3.20.2",
+        "@tiptap/extension-table-row": "^3.20.2",
+        "@tiptap/pm": "^3.20.2",
+        "@tiptap/react": "^3.20.2",
+        "@tiptap/starter-kit": "^3.20.2",
         "bpmn-js": "^18.0.1",
         "jspdf": "^4.1.0",
         "jszip": "^3.10.1",
@@ -1043,6 +1051,34 @@
         }
       }
     },
+    "node_modules/@floating-ui/core": {
+      "version": "1.7.5",
+      "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.5.tgz",
+      "integrity": "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@floating-ui/utils": "^0.2.11"
+      }
+    },
+    "node_modules/@floating-ui/dom": {
+      "version": "1.7.6",
+      "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.6.tgz",
+      "integrity": "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@floating-ui/core": "^1.7.5",
+        "@floating-ui/utils": "^0.2.11"
+      }
+    },
+    "node_modules/@floating-ui/utils": {
+      "version": "0.2.11",
+      "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.11.tgz",
+      "integrity": "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==",
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/@img/colour": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.0.0.tgz",
@@ -1849,6 +1885,12 @@
         "react-dom": ">=17"
       }
     },
+    "node_modules/@remirror/core-constants": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@remirror/core-constants/-/core-constants-3.0.0.tgz",
+      "integrity": "sha512-42aWfPrimMfDKDi4YegyS7x+/0tlzaqwPQCULLanv3DMIlu96KTJR0fM5isWX2UViOqlGnX6YFgqWepcX+XMNg==",
+      "license": "MIT"
+    },
     "node_modules/@rolldown/pluginutils": {
       "version": "1.0.0-rc.2",
       "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.2.tgz",
@@ -2312,6 +2354,506 @@
         "@testing-library/dom": ">=7.21.4"
       }
     },
+    "node_modules/@tiptap/core": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/core/-/core-3.20.2.tgz",
+      "integrity": "sha512-zKW4LqZt+aNdvz9o4R0/j+D+gfhwzuFItwh7wbqz8g8bWi0jaV95VybeVFVKeg/KGTc3sAa4mm+hGgvgrY+Gvg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/pm": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-blockquote": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-blockquote/-/extension-blockquote-3.20.2.tgz",
+      "integrity": "sha512-tkzZzBdwu8pP6pRfYjGanyj4aMSdcr4TS/Z9dcFxA8SYhmBXB4FYTbURME8Eg+n5VIOh1/2c4R2mbOkfQd4GtQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-bold": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-bold/-/extension-bold-3.20.2.tgz",
+      "integrity": "sha512-NLqh6ewHcDDPveTCL2f6BQcsDI5lubNjiyzvuYr0ZO9AV5Fqw8TkYwoKNijiYlgGRtm+pZLhMnf45gbLJQoymg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-bubble-menu": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-bubble-menu/-/extension-bubble-menu-3.20.2.tgz",
+      "integrity": "sha512-Np9jHUBWPnFJMy3Qhup3udARJQnWkbwVxVaHlJdgEy5Hfy/HE/EnItXAxXeFjVZ57cl+kJYamdn1t8VfMOV3mg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@floating-ui/dom": "^1.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/pm": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-bullet-list": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-bullet-list/-/extension-bullet-list-3.20.2.tgz",
+      "integrity": "sha512-LHmp945at3YYl2VPIg0bopyJioi52xK+YRurOz8A440EgCdnAkFa0UDGHxK/e4Y0R2y3xbPl+VBl3HzZjXPFuw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/extension-list": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-code": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-code/-/extension-code-3.20.2.tgz",
+      "integrity": "sha512-4mwWtt88Cl7PT5IbQpwigPBlNmB3JUiOchPXJIfbGu7wUxAk7a37vhn8ptiM2IGKpBFum/1PZFUI+Ik7TLIZLg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-code-block": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-code-block/-/extension-code-block-3.20.2.tgz",
+      "integrity": "sha512-BpClHuUrOYArL8skifo6RSlBiAVDYkGkq22zVb9lNfrrRqJIlPhwDI8tCZh1sHbgDQPukb4lE5VMPnsEv5M1tw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/pm": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-document": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-document/-/extension-document-3.20.2.tgz",
+      "integrity": "sha512-HHlpUs1Y22YwDmJ0cmTGPrFPuHk8Q2wvYZeG5eFOEeBu7t4IiCU114slvIR+yrDZrzpPmwzMb8H71scR+moizg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-dropcursor": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-dropcursor/-/extension-dropcursor-3.20.2.tgz",
+      "integrity": "sha512-LpBZOOgTrFWkYneOWOd0xyB7HUGIZqrgEhL+Beohzxkx63uNRC3PxFAAXhju6wxcvQ49e/WMg++Z8EDwHb6f2Q==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/extensions": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-floating-menu": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-floating-menu/-/extension-floating-menu-3.20.2.tgz",
+      "integrity": "sha512-Ev9QuNmV/A2fMuu+XpEy1W+u8FOu75S7GVPtS+cYRQc/TYTKaxha0+j0eYvJzKLzKRguJNRlmPBDHGN7MnSY/w==",
+      "license": "MIT",
+      "optional": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@floating-ui/dom": "^1.0.0",
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/pm": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-gapcursor": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-gapcursor/-/extension-gapcursor-3.20.2.tgz",
+      "integrity": "sha512-IfQuD5XctZa+Xxy3mdjo9NTYbiMFqGPuzyh2ypHUqyuvIwxOIRhxTFaCijOGVYn1g3BH8nzGMhZ5rnZ48zIb6Q==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/extensions": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-hard-break": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-hard-break/-/extension-hard-break-3.20.2.tgz",
+      "integrity": "sha512-TdjJ54483D1PsGLOBQBvzTqIKc027hixP/xFul9KfXIpGG+YGqX0U2RO3oUyuv32fbU1ZVLMDfEBzR/ropsyDg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-heading": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-heading/-/extension-heading-3.20.2.tgz",
+      "integrity": "sha512-XKpSEMcER00yfMXiASPpCHHa4Tw6G78AUELFt2PiS0tTWdxNpXZ8y29glyR4LO5eBxGjF1jncO49T1DzDh48TQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-horizontal-rule": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-horizontal-rule/-/extension-horizontal-rule-3.20.2.tgz",
+      "integrity": "sha512-1Ds1xwl4XKWzXhZ8jG+G04BepExxuwtJuw+xbdMXkTD3YDE8KmbSrUIiLpA60Zq4qZmWIrX57F7mOBGaExyfCw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/pm": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-image": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-image/-/extension-image-3.20.2.tgz",
+      "integrity": "sha512-STo7T3NQ1TcF93NXRQDhb5YkepBRpYHY54yfBUmHl5cygYZzOMaGlM0nh8NeX54mh3wJ6+nxpApuM3Jbmg0I+w==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-italic": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-italic/-/extension-italic-3.20.2.tgz",
+      "integrity": "sha512-VAIXeJMx4g6WKqqNm8PYzoFrJaRNKLzLtqUXqYozKxnJLpF2HjsIrnBJV9PM+1FKK2Tic1UuowF4OI/6d162SA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-link": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-link/-/extension-link-3.20.2.tgz",
+      "integrity": "sha512-vnC72CFMUiCJuAt7Hi4T/hKvbY4DqBjqo9G6dkBfNJHXHmqGiGKvkgzm1m7P/R1EX1XYk8nifeCpW6q2uliFRQ==",
+      "license": "MIT",
+      "dependencies": {
+        "linkifyjs": "^4.3.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/pm": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-list": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-list/-/extension-list-3.20.2.tgz",
+      "integrity": "sha512-x9h1fDeaLah60WJTb6517nRbAKcbdBsTpmglqxQ9c827PUOUyiVEAu2o2cFEuOMw6Htvty4obOKBUgYi8EAgDA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/pm": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-list-item": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-list-item/-/extension-list-item-3.20.2.tgz",
+      "integrity": "sha512-6L+ZKOqD9jTmE313qFkrIk81jbk8v437zRa5Sa0/hyFMbupsNVKZoZZkzrq5vOkbz2oE0WpsFXIjcYaqAwJhyA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/extension-list": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-list-keymap": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-list-keymap/-/extension-list-keymap-3.20.2.tgz",
+      "integrity": "sha512-SKU+w93E9+TdSWeoJzjFLDbO+XC/QIRQ+PJ6Jruz1BJ6VXILmyVOw3jBwmiJjLo+5h4MNV2D/IHx1P7BpEkUhQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/extension-list": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-ordered-list": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-ordered-list/-/extension-ordered-list-3.20.2.tgz",
+      "integrity": "sha512-UmPrnvd9/cGcO2QQaESu57kXmkubxmazQmUTgRU2BiLMEWGPPvxnBbJkM/YYmYPFRCs+OTx+XO9ohCD1xqtQcQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/extension-list": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-paragraph": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-paragraph/-/extension-paragraph-3.20.2.tgz",
+      "integrity": "sha512-gTWAUmvCnv7OThFsYdyhacL4TM+sJMC/UeuW+drWaTBbo7dvejzkl4hF5B0ytmF3d/ko1GNr4ldTikYZ2xypMw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-strike": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-strike/-/extension-strike-3.20.2.tgz",
+      "integrity": "sha512-Jivcc5Hgw2moIDfVoLEuJumDtw38k2mzEMYt3oZQnvE5d0ttXhWWR0LbLm5LBX3oxlc74I3NSi+Q4ixQHiDtvA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-table": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-table/-/extension-table-3.20.2.tgz",
+      "integrity": "sha512-kURWr90j3sfuC2AkM73lwoWfeDxj+zWK38gbld58/cHUREoWK9lxFEdeCCZOge6Z97ZQRvqRiEGeQ/X3GmUiYg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/pm": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-table-cell": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-table-cell/-/extension-table-cell-3.20.2.tgz",
+      "integrity": "sha512-px+aTVMxQvsWcJRXHaqZwierMRxscwe9eJcPGwLvyAuX8dr0V5+l60RUA2bodQ1l/zOPvWIieTapZlfpRgMkKQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/extension-table": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-table-header": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-table-header/-/extension-table-header-3.20.2.tgz",
+      "integrity": "sha512-MGHxDI/qki4yyQ1+S/y4kdLDQcZnUWaCLOLmakC+mRQ9gcMNSNfSsdREE3rLDruX6MDBdUbaZe2qIf8iakl3bw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/extension-table": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-table-row": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-table-row/-/extension-table-row-3.20.2.tgz",
+      "integrity": "sha512-88rl6IslnmAN1wIt4s7uJmPJ+lk2OAqfaxdD6M6i16XXCoxDLfOTB0smb5hS3V50jAkwojndO6C00Iaz6lpZig==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/extension-table": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-text": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-text/-/extension-text-3.20.2.tgz",
+      "integrity": "sha512-I1rVt6JTi/itgsFqXp+JfxWn9fEewIxiIaaaMUmaCJ6HChQSvYlVWy1B/RixmbCCPaL/FxybEa/Tg9MugyOJYA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extension-underline": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extension-underline/-/extension-underline-3.20.2.tgz",
+      "integrity": "sha512-oVszIGkRtg8NLhop/t5kco6suWlDUKW9cqhL6wwd19aLztr+tMU/u8+kPG2cjjYZ+XoMZOoKfkOt7he2iU5/0A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/extensions": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/extensions/-/extensions-3.20.2.tgz",
+      "integrity": "sha512-gzntns6z/kTgwrX89ydc3rNqDsv8D8sAkyl8HE9X+2D9wtdCgNljevIR6MBNcxG7bVm2+XnId1P9YciCZLuefg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/pm": "^3.20.2"
+      }
+    },
+    "node_modules/@tiptap/pm": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/pm/-/pm-3.20.2.tgz",
+      "integrity": "sha512-tEMZlLy/6ms41PQtyjmniZ3tTd8elavd8htjYzHLPSHtz11zaYV9YjnmnwHK8gynhcSES1orO9z1U4nT4ZLpqg==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-changeset": "^2.3.0",
+        "prosemirror-collab": "^1.3.1",
+        "prosemirror-commands": "^1.6.2",
+        "prosemirror-dropcursor": "^1.8.1",
+        "prosemirror-gapcursor": "^1.3.2",
+        "prosemirror-history": "^1.4.1",
+        "prosemirror-inputrules": "^1.4.0",
+        "prosemirror-keymap": "^1.2.2",
+        "prosemirror-markdown": "^1.13.1",
+        "prosemirror-menu": "^1.2.4",
+        "prosemirror-model": "^1.24.1",
+        "prosemirror-schema-basic": "^1.2.3",
+        "prosemirror-schema-list": "^1.5.0",
+        "prosemirror-state": "^1.4.3",
+        "prosemirror-tables": "^1.6.4",
+        "prosemirror-trailing-node": "^3.0.0",
+        "prosemirror-transform": "^1.10.2",
+        "prosemirror-view": "^1.38.1"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      }
+    },
+    "node_modules/@tiptap/react": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/react/-/react-3.20.2.tgz",
+      "integrity": "sha512-eOfKkbaf9Qvia1xkjRXbJYy8FW7ampMkLt8yVcDhQf2fyip56sY+1ZuOoeXl+/lyDYNoXwoHJZrEcdseDPe0xw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/use-sync-external-store": "^0.0.6",
+        "fast-equals": "^5.3.3",
+        "use-sync-external-store": "^1.4.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      },
+      "optionalDependencies": {
+        "@tiptap/extension-bubble-menu": "^3.20.2",
+        "@tiptap/extension-floating-menu": "^3.20.2"
+      },
+      "peerDependencies": {
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/pm": "^3.20.2",
+        "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/@tiptap/starter-kit": {
+      "version": "3.20.2",
+      "resolved": "https://registry.npmjs.org/@tiptap/starter-kit/-/starter-kit-3.20.2.tgz",
+      "integrity": "sha512-QQ81QpwecXN3Rg0nWYC1nRCcWxlUtEua1X5j1NYUtY39SScuLbs3mMQ54P+u9ZeX31pzu/kuix5GQ0fw+SApOA==",
+      "license": "MIT",
+      "dependencies": {
+        "@tiptap/core": "^3.20.2",
+        "@tiptap/extension-blockquote": "^3.20.2",
+        "@tiptap/extension-bold": "^3.20.2",
+        "@tiptap/extension-bullet-list": "^3.20.2",
+        "@tiptap/extension-code": "^3.20.2",
+        "@tiptap/extension-code-block": "^3.20.2",
+        "@tiptap/extension-document": "^3.20.2",
+        "@tiptap/extension-dropcursor": "^3.20.2",
+        "@tiptap/extension-gapcursor": "^3.20.2",
+        "@tiptap/extension-hard-break": "^3.20.2",
+        "@tiptap/extension-heading": "^3.20.2",
+        "@tiptap/extension-horizontal-rule": "^3.20.2",
+        "@tiptap/extension-italic": "^3.20.2",
+        "@tiptap/extension-link": "^3.20.2",
+        "@tiptap/extension-list": "^3.20.2",
+        "@tiptap/extension-list-item": "^3.20.2",
+        "@tiptap/extension-list-keymap": "^3.20.2",
+        "@tiptap/extension-ordered-list": "^3.20.2",
+        "@tiptap/extension-paragraph": "^3.20.2",
+        "@tiptap/extension-strike": "^3.20.2",
+        "@tiptap/extension-text": "^3.20.2",
+        "@tiptap/extension-underline": "^3.20.2",
+        "@tiptap/extensions": "^3.20.2",
+        "@tiptap/pm": "^3.20.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/ueberdosis"
+      }
+    },
     "node_modules/@types/aria-query": {
       "version": "5.0.4",
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
@@ -2649,6 +3191,28 @@
       "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==",
       "license": "MIT"
     },
+    "node_modules/@types/linkify-it": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@types/linkify-it/-/linkify-it-5.0.0.tgz",
+      "integrity": "sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==",
+      "license": "MIT"
+    },
+    "node_modules/@types/markdown-it": {
+      "version": "14.1.2",
+      "resolved": "https://registry.npmjs.org/@types/markdown-it/-/markdown-it-14.1.2.tgz",
+      "integrity": "sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/linkify-it": "^5",
+        "@types/mdurl": "^2"
+      }
+    },
+    "node_modules/@types/mdurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@types/mdurl/-/mdurl-2.0.0.tgz",
+      "integrity": "sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==",
+      "license": "MIT"
+    },
     "node_modules/@types/node": {
       "version": "22.19.7",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.7.tgz",
@@ -2669,7 +3233,6 @@
       "version": "15.7.15",
       "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
       "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
-      "devOptional": true,
       "license": "MIT"
     },
     "node_modules/@types/raf": {
@@ -2683,7 +3246,6 @@
       "version": "18.3.27",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.27.tgz",
       "integrity": "sha512-cisd7gxkzjBKU2GgdYrTdtQx1SORymWyaAFhaxQPK9bYO9ot3Y5OikQRvY0VYQtvwjeQnizCINJAenh/V7MK2w==",
-      "devOptional": true,
       "license": "MIT",
       "dependencies": {
         "@types/prop-types": "*",
@@ -2694,7 +3256,6 @@
       "version": "18.3.7",
       "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
       "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
-      "dev": true,
       "license": "MIT",
       "peerDependencies": {
         "@types/react": "^18.0.0"
@@ -2707,6 +3268,12 @@
       "license": "MIT",
       "optional": true
     },
+    "node_modules/@types/use-sync-external-store": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/@types/use-sync-external-store/-/use-sync-external-store-0.0.6.tgz",
+      "integrity": "sha512-zFDAD+tlpf2r4asuHEj0XH6pY6i0g5NeAHPn+15wk3BV6JA69eERFXC1gyGThDkVa1zCyKr5jox1+2LbV/AMLg==",
+      "license": "MIT"
+    },
     "node_modules/@types/uuid": {
       "version": "10.0.0",
       "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-10.0.0.tgz",
@@ -2909,6 +3476,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "license": "Python-2.0"
+    },
     "node_modules/aria-query": {
       "version": "5.3.0",
       "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
@@ -3243,6 +3816,12 @@
       "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
       "license": "MIT"
     },
+    "node_modules/crelt": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/crelt/-/crelt-1.0.6.tgz",
+      "integrity": "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==",
+      "license": "MIT"
+    },
     "node_modules/css-line-break": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/css-line-break/-/css-line-break-2.1.0.tgz",
@@ -3752,6 +4331,18 @@
         "node": ">=6"
       }
     },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/estree-walker": {
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
@@ -4266,6 +4857,21 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/linkify-it": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.0.tgz",
+      "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==",
+      "license": "MIT",
+      "dependencies": {
+        "uc.micro": "^2.0.0"
+      }
+    },
+    "node_modules/linkifyjs": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/linkifyjs/-/linkifyjs-4.3.2.tgz",
+      "integrity": "sha512-NT1CJtq3hHIreOianA8aSXn6Cw0JzYOuDQbOrSPe7gqFnCpKP++MQe3ODgO3oh2GJFORkAAdqredOa60z63GbA==",
+      "license": "MIT"
+    },
     "node_modules/lodash": {
       "version": "4.17.23",
       "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
@@ -4324,6 +4930,35 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/markdown-it": {
+      "version": "14.1.1",
+      "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-14.1.1.tgz",
+      "integrity": "sha512-BuU2qnTti9YKgK5N+IeMubp14ZUKUUw7yeJbkjtosvHiP0AZ5c8IAgEMk79D0eC8F23r4Ac/q8cAIFdm2FtyoA==",
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1",
+        "entities": "^4.4.0",
+        "linkify-it": "^5.0.0",
+        "mdurl": "^2.0.0",
+        "punycode.js": "^2.3.1",
+        "uc.micro": "^2.1.0"
+      },
+      "bin": {
+        "markdown-it": "bin/markdown-it.mjs"
+      }
+    },
+    "node_modules/markdown-it/node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/mdn-data": {
       "version": "2.12.2",
       "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.12.2.tgz",
@@ -4331,6 +4966,12 @@
       "dev": true,
       "license": "CC0-1.0"
     },
+    "node_modules/mdurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-2.0.0.tgz",
+      "integrity": "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==",
+      "license": "MIT"
+    },
     "node_modules/merge2": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
@@ -4579,6 +5220,12 @@
       ],
       "license": "MIT"
     },
+    "node_modules/orderedmap": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/orderedmap/-/orderedmap-2.1.1.tgz",
+      "integrity": "sha512-TvAWxi0nDe1j/rtMcWcIj94+Ffe6n7zhow33h40SKxmsmozs6dz/e+EajymfoFcHd7sxNn8yHM8839uixMOV6g==",
+      "license": "MIT"
+    },
     "node_modules/pako": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz",
@@ -5053,6 +5700,201 @@
       "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
       "license": "MIT"
     },
+    "node_modules/prosemirror-changeset": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/prosemirror-changeset/-/prosemirror-changeset-2.4.0.tgz",
+      "integrity": "sha512-LvqH2v7Q2SF6yxatuPP2e8vSUKS/L+xAU7dPDC4RMyHMhZoGDfBC74mYuyYF4gLqOEG758wajtyhNnsTkuhvng==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-transform": "^1.0.0"
+      }
+    },
+    "node_modules/prosemirror-collab": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/prosemirror-collab/-/prosemirror-collab-1.3.1.tgz",
+      "integrity": "sha512-4SnynYR9TTYaQVXd/ieUvsVV4PDMBzrq2xPUWutHivDuOshZXqQ5rGbZM84HEaXKbLdItse7weMGOUdDVcLKEQ==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-state": "^1.0.0"
+      }
+    },
+    "node_modules/prosemirror-commands": {
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/prosemirror-commands/-/prosemirror-commands-1.7.1.tgz",
+      "integrity": "sha512-rT7qZnQtx5c0/y/KlYaGvtG411S97UaL6gdp6RIZ23DLHanMYLyfGBV5DtSnZdthQql7W+lEVbpSfwtO8T+L2w==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-model": "^1.0.0",
+        "prosemirror-state": "^1.0.0",
+        "prosemirror-transform": "^1.10.2"
+      }
+    },
+    "node_modules/prosemirror-dropcursor": {
+      "version": "1.8.2",
+      "resolved": "https://registry.npmjs.org/prosemirror-dropcursor/-/prosemirror-dropcursor-1.8.2.tgz",
+      "integrity": "sha512-CCk6Gyx9+Tt2sbYk5NK0nB1ukHi2ryaRgadV/LvyNuO3ena1payM2z6Cg0vO1ebK8cxbzo41ku2DE5Axj1Zuiw==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-state": "^1.0.0",
+        "prosemirror-transform": "^1.1.0",
+        "prosemirror-view": "^1.1.0"
+      }
+    },
+    "node_modules/prosemirror-gapcursor": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/prosemirror-gapcursor/-/prosemirror-gapcursor-1.4.1.tgz",
+      "integrity": "sha512-pMdYaEnjNMSwl11yjEGtgTmLkR08m/Vl+Jj443167p9eB3HVQKhYCc4gmHVDsLPODfZfjr/MmirsdyZziXbQKw==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-keymap": "^1.0.0",
+        "prosemirror-model": "^1.0.0",
+        "prosemirror-state": "^1.0.0",
+        "prosemirror-view": "^1.0.0"
+      }
+    },
+    "node_modules/prosemirror-history": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/prosemirror-history/-/prosemirror-history-1.5.0.tgz",
+      "integrity": "sha512-zlzTiH01eKA55UAf1MEjtssJeHnGxO0j4K4Dpx+gnmX9n+SHNlDqI2oO1Kv1iPN5B1dm5fsljCfqKF9nFL6HRg==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-state": "^1.2.2",
+        "prosemirror-transform": "^1.0.0",
+        "prosemirror-view": "^1.31.0",
+        "rope-sequence": "^1.3.0"
+      }
+    },
+    "node_modules/prosemirror-inputrules": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/prosemirror-inputrules/-/prosemirror-inputrules-1.5.1.tgz",
+      "integrity": "sha512-7wj4uMjKaXWAQ1CDgxNzNtR9AlsuwzHfdFH1ygEHA2KHF2DOEaXl1CJfNPAKCg9qNEh4rum975QLaCiQPyY6Fw==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-state": "^1.0.0",
+        "prosemirror-transform": "^1.0.0"
+      }
+    },
+    "node_modules/prosemirror-keymap": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/prosemirror-keymap/-/prosemirror-keymap-1.2.3.tgz",
+      "integrity": "sha512-4HucRlpiLd1IPQQXNqeo81BGtkY8Ai5smHhKW9jjPKRc2wQIxksg7Hl1tTI2IfT2B/LgX6bfYvXxEpJl7aKYKw==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-state": "^1.0.0",
+        "w3c-keyname": "^2.2.0"
+      }
+    },
+    "node_modules/prosemirror-markdown": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/prosemirror-markdown/-/prosemirror-markdown-1.13.4.tgz",
+      "integrity": "sha512-D98dm4cQ3Hs6EmjK500TdAOew4Z03EV71ajEFiWra3Upr7diytJsjF4mPV2dW+eK5uNectiRj0xFxYI9NLXDbw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/markdown-it": "^14.0.0",
+        "markdown-it": "^14.0.0",
+        "prosemirror-model": "^1.25.0"
+      }
+    },
+    "node_modules/prosemirror-menu": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/prosemirror-menu/-/prosemirror-menu-1.3.0.tgz",
+      "integrity": "sha512-TImyPXCHPcDsSka2/lwJ6WjTASr4re/qWq1yoTTuLOqfXucwF6VcRa2LWCkM/EyTD1UO3CUwiH8qURJoWJRxwg==",
+      "license": "MIT",
+      "dependencies": {
+        "crelt": "^1.0.0",
+        "prosemirror-commands": "^1.0.0",
+        "prosemirror-history": "^1.0.0",
+        "prosemirror-state": "^1.0.0"
+      }
+    },
+    "node_modules/prosemirror-model": {
+      "version": "1.25.4",
+      "resolved": "https://registry.npmjs.org/prosemirror-model/-/prosemirror-model-1.25.4.tgz",
+      "integrity": "sha512-PIM7E43PBxKce8OQeezAs9j4TP+5yDpZVbuurd1h5phUxEKIu+G2a+EUZzIC5nS1mJktDJWzbqS23n1tsAf5QA==",
+      "license": "MIT",
+      "dependencies": {
+        "orderedmap": "^2.0.0"
+      }
+    },
+    "node_modules/prosemirror-schema-basic": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/prosemirror-schema-basic/-/prosemirror-schema-basic-1.2.4.tgz",
+      "integrity": "sha512-ELxP4TlX3yr2v5rM7Sb70SqStq5NvI15c0j9j/gjsrO5vaw+fnnpovCLEGIcpeGfifkuqJwl4fon6b+KdrODYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-model": "^1.25.0"
+      }
+    },
+    "node_modules/prosemirror-schema-list": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/prosemirror-schema-list/-/prosemirror-schema-list-1.5.1.tgz",
+      "integrity": "sha512-927lFx/uwyQaGwJxLWCZRkjXG0p48KpMj6ueoYiu4JX05GGuGcgzAy62dfiV8eFZftgyBUvLx76RsMe20fJl+Q==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-model": "^1.0.0",
+        "prosemirror-state": "^1.0.0",
+        "prosemirror-transform": "^1.7.3"
+      }
+    },
+    "node_modules/prosemirror-state": {
+      "version": "1.4.4",
+      "resolved": "https://registry.npmjs.org/prosemirror-state/-/prosemirror-state-1.4.4.tgz",
+      "integrity": "sha512-6jiYHH2CIGbCfnxdHbXZ12gySFY/fz/ulZE333G6bPqIZ4F+TXo9ifiR86nAHpWnfoNjOb3o5ESi7J8Uz1jXHw==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-model": "^1.0.0",
+        "prosemirror-transform": "^1.0.0",
+        "prosemirror-view": "^1.27.0"
+      }
+    },
+    "node_modules/prosemirror-tables": {
+      "version": "1.8.5",
+      "resolved": "https://registry.npmjs.org/prosemirror-tables/-/prosemirror-tables-1.8.5.tgz",
+      "integrity": "sha512-V/0cDCsHKHe/tfWkeCmthNUcEp1IVO3p6vwN8XtwE9PZQLAZJigbw3QoraAdfJPir4NKJtNvOB8oYGKRl+t0Dw==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-keymap": "^1.2.3",
+        "prosemirror-model": "^1.25.4",
+        "prosemirror-state": "^1.4.4",
+        "prosemirror-transform": "^1.10.5",
+        "prosemirror-view": "^1.41.4"
+      }
+    },
+    "node_modules/prosemirror-trailing-node": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/prosemirror-trailing-node/-/prosemirror-trailing-node-3.0.0.tgz",
+      "integrity": "sha512-xiun5/3q0w5eRnGYfNlW1uU9W6x5MoFKWwq/0TIRgt09lv7Hcser2QYV8t4muXbEr+Fwo0geYn79Xs4GKywrRQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@remirror/core-constants": "3.0.0",
+        "escape-string-regexp": "^4.0.0"
+      },
+      "peerDependencies": {
+        "prosemirror-model": "^1.22.1",
+        "prosemirror-state": "^1.4.2",
+        "prosemirror-view": "^1.33.8"
+      }
+    },
+    "node_modules/prosemirror-transform": {
+      "version": "1.11.0",
+      "resolved": "https://registry.npmjs.org/prosemirror-transform/-/prosemirror-transform-1.11.0.tgz",
+      "integrity": "sha512-4I7Ce4KpygXb9bkiPS3hTEk4dSHorfRw8uI0pE8IhxlK2GXsqv5tIA7JUSxtSu7u8APVOTtbUBxTmnHIxVkIJw==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-model": "^1.21.0"
+      }
+    },
+    "node_modules/prosemirror-view": {
+      "version": "1.41.6",
+      "resolved": "https://registry.npmjs.org/prosemirror-view/-/prosemirror-view-1.41.6.tgz",
+      "integrity": "sha512-mxpcDG4hNQa/CPtzxjdlir5bJFDlm0/x5nGBbStB2BWX+XOQ9M8ekEG+ojqB5BcVu2Rc80/jssCMZzSstJuSYg==",
+      "license": "MIT",
+      "dependencies": {
+        "prosemirror-model": "^1.20.0",
+        "prosemirror-state": "^1.0.0",
+        "prosemirror-transform": "^1.1.0"
+      }
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
@@ -5063,6 +5905,15 @@
         "node": ">=6"
       }
     },
+    "node_modules/punycode.js": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode.js/-/punycode.js-2.3.1.tgz",
+      "integrity": "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/queue-microtask": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
@@ -5380,6 +6231,12 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/rope-sequence": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/rope-sequence/-/rope-sequence-1.3.4.tgz",
+      "integrity": "sha512-UT5EDe2cu2E/6O4igUr5PSFs23nvvukicWHx6GnOPlHAiiYbzNuCRQCuiUdHJQcqKalLKlrYJnjY0ySGsXNQXQ==",
+      "license": "MIT"
+    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -5899,6 +6756,12 @@
         "node": ">=14.17"
       }
     },
+    "node_modules/uc.micro": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-2.1.0.tgz",
+      "integrity": "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==",
+      "license": "MIT"
+    },
     "node_modules/undici": {
       "version": "7.20.0",
       "resolved": "https://registry.npmjs.org/undici/-/undici-7.20.0.tgz",
@@ -6204,6 +7067,12 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/w3c-keyname": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz",
+      "integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==",
+      "license": "MIT"
+    },
     "node_modules/w3c-xmlserializer": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
diff --git a/admin-compliance/package.json b/admin-compliance/package.json
index 56dc5d4..c4522b8 100644
--- a/admin-compliance/package.json
+++ b/admin-compliance/package.json
@@ -18,6 +18,14 @@
     "test:all": "vitest run && playwright test --project=chromium"
   },
   "dependencies": {
+    "@tiptap/extension-image": "^3.20.2",
+    "@tiptap/extension-table": "^3.20.2",
+    "@tiptap/extension-table-cell": "^3.20.2",
+    "@tiptap/extension-table-header": "^3.20.2",
+    "@tiptap/extension-table-row": "^3.20.2",
+    "@tiptap/pm": "^3.20.2",
+    "@tiptap/react": "^3.20.2",
+    "@tiptap/starter-kit": "^3.20.2",
     "bpmn-js": "^18.0.1",
     "jspdf": "^4.1.0",
     "jszip": "^3.10.1",
diff --git a/ai-compliance-sdk/cmd/server/main.go b/ai-compliance-sdk/cmd/server/main.go
index e6ca81b..98277d8 100644
--- a/ai-compliance-sdk/cmd/server/main.go
+++ b/ai-compliance-sdk/cmd/server/main.go
@@ -109,7 +109,7 @@ func main() {
 	portfolioHandlers := handlers.NewPortfolioHandlers(portfolioStore)
 	academyHandlers := handlers.NewAcademyHandlers(academyStore, trainingStore)
 	whistleblowerHandlers := handlers.NewWhistleblowerHandlers(whistleblowerStore)
-	iaceHandler := handlers.NewIACEHandler(iaceStore)
+	iaceHandler := handlers.NewIACEHandler(iaceStore, providerRegistry)
 	trainingHandlers := handlers.NewTrainingHandlers(trainingStore, contentGenerator)
 	ragHandlers := handlers.NewRAGHandlers(corpusVersionStore)
 
@@ -596,6 +596,7 @@ func main() {
 			iaceRoutes.GET("/projects/:id/tech-file", iaceHandler.ListTechFileSections)
 			iaceRoutes.PUT("/projects/:id/tech-file/:section", iaceHandler.UpdateTechFileSection)
 			iaceRoutes.POST("/projects/:id/tech-file/:section/approve", iaceHandler.ApproveTechFileSection)
+			iaceRoutes.POST("/projects/:id/tech-file/:section/generate", iaceHandler.GenerateSingleSection)
 			iaceRoutes.GET("/projects/:id/tech-file/export", iaceHandler.ExportTechFile)
 
 			// Monitoring
diff --git a/ai-compliance-sdk/internal/api/handlers/iace_handler.go b/ai-compliance-sdk/internal/api/handlers/iace_handler.go
index 68ace2b..255f441 100644
--- a/ai-compliance-sdk/internal/api/handlers/iace_handler.go
+++ b/ai-compliance-sdk/internal/api/handlers/iace_handler.go
@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/breakpilot/ai-compliance-sdk/internal/iace"
+	"github.com/breakpilot/ai-compliance-sdk/internal/llm"
 	"github.com/breakpilot/ai-compliance-sdk/internal/rbac"
 	"github.com/breakpilot/ai-compliance-sdk/internal/ucca"
 	"github.com/gin-gonic/gin"
@@ -22,21 +23,26 @@ import (
 // onboarding, regulatory classification, hazard/risk analysis, evidence management,
 // CE technical file generation, and post-market monitoring.
 type IACEHandler struct {
-	store      *iace.Store
-	engine     *iace.RiskEngine
-	classifier *iace.Classifier
-	checker    *iace.CompletenessChecker
-	ragClient  *ucca.LegalRAGClient
+	store        *iace.Store
+	engine       *iace.RiskEngine
+	classifier   *iace.Classifier
+	checker      *iace.CompletenessChecker
+	ragClient    *ucca.LegalRAGClient
+	techFileGen  *iace.TechFileGenerator
+	exporter     *iace.DocumentExporter
 }
 
 // NewIACEHandler creates a new IACEHandler with all required dependencies.
-func NewIACEHandler(store *iace.Store) *IACEHandler {
+func NewIACEHandler(store *iace.Store, providerRegistry *llm.ProviderRegistry) *IACEHandler {
+	ragClient := ucca.NewLegalRAGClient()
 	return &IACEHandler{
-		store:      store,
-		engine:     iace.NewRiskEngine(),
-		classifier: iace.NewClassifier(),
-		checker:    iace.NewCompletenessChecker(),
-		ragClient:  ucca.NewLegalRAGClient(),
+		store:       store,
+		engine:      iace.NewRiskEngine(),
+		classifier:  iace.NewClassifier(),
+		checker:     iace.NewCompletenessChecker(),
+		ragClient:   ragClient,
+		techFileGen: iace.NewTechFileGenerator(providerRegistry, ragClient, store),
+		exporter:    iace.NewDocumentExporter(),
 	}
 }
 
@@ -229,6 +235,28 @@ func (h *IACEHandler) InitFromProfile(c *gin.Context) {
 		return
 	}
 
+	// Parse compliance_scope to extract machine data
+	var scope struct {
+		MachineName            string   `json:"machine_name"`
+		MachineType            string   `json:"machine_type"`
+		IntendedUse            string   `json:"intended_use"`
+		HasSoftware            bool     `json:"has_software"`
+		HasFirmware            bool     `json:"has_firmware"`
+		HasAI                  bool     `json:"has_ai"`
+		IsNetworked            bool     `json:"is_networked"`
+		ApplicableRegulations  []string `json:"applicable_regulations"`
+	}
+	_ = json.Unmarshal(req.ComplianceScope, &scope)
+
+	// Parse company_profile to extract manufacturer
+	var profile struct {
+		CompanyName    string `json:"company_name"`
+		ContactName    string `json:"contact_name"`
+		ContactEmail   string `json:"contact_email"`
+		Address        string `json:"address"`
+	}
+	_ = json.Unmarshal(req.CompanyProfile, &profile)
+
 	// Store the profile and scope in project metadata
 	profileData := map[string]json.RawMessage{
 		"company_profile":  req.CompanyProfile,
@@ -236,9 +264,23 @@ func (h *IACEHandler) InitFromProfile(c *gin.Context) {
 	}
 	metadataBytes, _ := json.Marshal(profileData)
 	metadataRaw := json.RawMessage(metadataBytes)
+
+	// Build update request — fill project fields from scope/profile
 	updateReq := iace.UpdateProjectRequest{
 		Metadata: &metadataRaw,
 	}
+	if scope.MachineName != "" {
+		updateReq.MachineName = &scope.MachineName
+	}
+	if scope.MachineType != "" {
+		updateReq.MachineType = &scope.MachineType
+	}
+	if scope.IntendedUse != "" {
+		updateReq.Description = &scope.IntendedUse
+	}
+	if profile.CompanyName != "" {
+		updateReq.Manufacturer = &profile.CompanyName
+	}
 
 	project, err = h.store.UpdateProject(c.Request.Context(), projectID, updateReq)
 	if err != nil {
@@ -246,8 +288,65 @@ func (h *IACEHandler) InitFromProfile(c *gin.Context) {
 		return
 	}
 
+	ctx := c.Request.Context()
+
+	// Create initial components from scope
+	var createdComponents []iace.Component
+	if scope.HasSoftware {
+		comp, err := h.store.CreateComponent(ctx, iace.CreateComponentRequest{
+			ProjectID: projectID, Name: "Software", ComponentType: iace.ComponentTypeSoftware,
+			IsSafetyRelevant: true, IsNetworked: scope.IsNetworked,
+		})
+		if err == nil {
+			createdComponents = append(createdComponents, *comp)
+		}
+	}
+	if scope.HasFirmware {
+		comp, err := h.store.CreateComponent(ctx, iace.CreateComponentRequest{
+			ProjectID: projectID, Name: "Firmware", ComponentType: iace.ComponentTypeFirmware,
+			IsSafetyRelevant: true,
+		})
+		if err == nil {
+			createdComponents = append(createdComponents, *comp)
+		}
+	}
+	if scope.HasAI {
+		comp, err := h.store.CreateComponent(ctx, iace.CreateComponentRequest{
+			ProjectID: projectID, Name: "KI-Modell", ComponentType: iace.ComponentTypeAIModel,
+			IsSafetyRelevant: true, IsNetworked: scope.IsNetworked,
+		})
+		if err == nil {
+			createdComponents = append(createdComponents, *comp)
+		}
+	}
+	if scope.IsNetworked {
+		comp, err := h.store.CreateComponent(ctx, iace.CreateComponentRequest{
+			ProjectID: projectID, Name: "Netzwerk-Schnittstelle", ComponentType: iace.ComponentTypeNetwork,
+			IsSafetyRelevant: false, IsNetworked: true,
+		})
+		if err == nil {
+			createdComponents = append(createdComponents, *comp)
+		}
+	}
+
+	// Trigger initial classifications for applicable regulations
+	regulationMap := map[string]iace.RegulationType{
+		"machinery_regulation": iace.RegulationMachineryRegulation,
+		"ai_act":               iace.RegulationAIAct,
+		"cra":                  iace.RegulationCRA,
+		"nis2":                 iace.RegulationNIS2,
+	}
+	var triggeredRegulations []string
+	for _, regStr := range scope.ApplicableRegulations {
+		if regType, ok := regulationMap[regStr]; ok {
+			triggeredRegulations = append(triggeredRegulations, regStr)
+			// Create initial classification entry
+			h.store.UpsertClassification(ctx, projectID, regType, "pending", "medium", 0.5, "Initialisiert aus Compliance-Scope", nil, nil)
+		}
+	}
+
 	// Advance project status to onboarding
-	if err := h.store.UpdateProjectStatus(c.Request.Context(), projectID, iace.ProjectStatusOnboarding); err != nil {
+	if err := h.store.UpdateProjectStatus(ctx, projectID, iace.ProjectStatusOnboarding); err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
@@ -255,13 +354,15 @@ func (h *IACEHandler) InitFromProfile(c *gin.Context) {
 	// Add audit trail entry
 	userID := rbac.GetUserID(c)
 	h.store.AddAuditEntry(
-		c.Request.Context(), projectID, "project", projectID,
+		ctx, projectID, "project", projectID,
 		iace.AuditActionUpdate, userID.String(), nil, metadataBytes,
 	)
 
 	c.JSON(http.StatusOK, gin.H{
-		"message": "project initialized from profile",
-		"project": project,
+		"message":                "project initialized from profile",
+		"project":                project,
+		"components_created":     len(createdComponents),
+		"regulations_triggered":  triggeredRegulations,
 	})
 }
 
@@ -430,17 +531,21 @@ func (h *IACEHandler) CheckCompleteness(c *gin.Context) {
 		}
 	}
 
+	// Check audit trail for pattern matching
+	patternMatchingPerformed, _ := h.store.HasAuditEntryForType(c.Request.Context(), projectID, "pattern_matching")
+
 	// Build completeness context
 	completenessCtx := &iace.CompletenessContext{
-		Project:          project,
-		Components:       components,
-		Classifications:  classifications,
-		Hazards:          hazards,
-		Assessments:      allAssessments,
-		Mitigations:      allMitigations,
-		Evidence:         evidence,
-		TechFileSections: techFileSections,
-		HasAI:            hasAI,
+		Project:                  project,
+		Components:               components,
+		Classifications:          classifications,
+		Hazards:                  hazards,
+		Assessments:              allAssessments,
+		Mitigations:              allMitigations,
+		Evidence:                 evidence,
+		TechFileSections:         techFileSections,
+		HasAI:                    hasAI,
+		PatternMatchingPerformed: patternMatchingPerformed,
 	}
 
 	// Run the checker
@@ -1440,8 +1545,7 @@ func (h *IACEHandler) GenerateTechFile(c *gin.Context) {
 		)
 	}
 
-	// Generate each section with placeholder content
-	// TODO: Replace placeholder content with LLM-generated content based on project data
+	// Generate each section with LLM-based content
 	var sections []iace.TechFileSection
 	existingSections, _ := h.store.ListTechFileSections(c.Request.Context(), projectID)
 	existingMap := make(map[string]bool)
@@ -1455,16 +1559,11 @@ func (h *IACEHandler) GenerateTechFile(c *gin.Context) {
 			continue
 		}
 
-		content := fmt.Sprintf(
-			"[Auto-generated placeholder for '%s']\n\n"+
-				"Machine: %s\nManufacturer: %s\nType: %s\n\n"+
-				"TODO: Replace this placeholder with actual content. "+
-				"LLM-based generation will be integrated in a future release.",
-			def.Title,
-			project.MachineName,
-			project.Manufacturer,
-			project.MachineType,
-		)
+		// Generate content via LLM (falls back to structured placeholder if LLM unavailable)
+		content, _ := h.techFileGen.GenerateSection(c.Request.Context(), projectID, def.SectionType)
+		if content == "" {
+			content = fmt.Sprintf("[Sektion: %s — Inhalt wird generiert]", def.Title)
+		}
 
 		section, err := h.store.CreateTechFileSection(
 			c.Request.Context(), projectID, def.SectionType, def.Title, content,
@@ -1489,7 +1588,93 @@ func (h *IACEHandler) GenerateTechFile(c *gin.Context) {
 	c.JSON(http.StatusCreated, gin.H{
 		"sections_created": len(sections),
 		"sections":         sections,
-		"_note":            "TODO: LLM-based content generation not yet implemented",
+	})
+}
+
+// GenerateSingleSection handles POST /projects/:id/tech-file/:section/generate
+// Generates or regenerates a single tech file section using LLM.
+func (h *IACEHandler) GenerateSingleSection(c *gin.Context) {
+	projectID, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid project ID"})
+		return
+	}
+
+	sectionType := c.Param("section")
+	if sectionType == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "section type required"})
+		return
+	}
+
+	// Generate content via LLM
+	content, err := h.techFileGen.GenerateSection(c.Request.Context(), projectID, sectionType)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("generation failed: %v", err)})
+		return
+	}
+
+	// Find existing section and update, or create new
+	sections, _ := h.store.ListTechFileSections(c.Request.Context(), projectID)
+	var sectionID uuid.UUID
+	found := false
+	for _, s := range sections {
+		if s.SectionType == sectionType {
+			sectionID = s.ID
+			found = true
+			break
+		}
+	}
+
+	if found {
+		if err := h.store.UpdateTechFileSection(c.Request.Context(), sectionID, content); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+	} else {
+		title := sectionType // fallback
+		sectionTitles := map[string]string{
+			"general_description":       "General Description of the Machinery",
+			"risk_assessment_report":    "Risk Assessment Report",
+			"hazard_log_combined":       "Combined Hazard Log",
+			"essential_requirements":    "Essential Health and Safety Requirements",
+			"design_specifications":     "Design Specifications and Drawings",
+			"test_reports":              "Test Reports and Verification Results",
+			"standards_applied":         "Applied Harmonised Standards",
+			"declaration_of_conformity": "EU Declaration of Conformity",
+			"component_list":            "Component List",
+			"classification_report":     "Regulatory Classification Report",
+			"mitigation_report":         "Mitigation Measures Report",
+			"verification_report":       "Verification Report",
+			"evidence_index":            "Evidence Index",
+			"instructions_for_use":      "Instructions for Use",
+			"monitoring_plan":           "Post-Market Monitoring Plan",
+			"ai_intended_purpose":       "AI System Intended Purpose",
+			"ai_model_description":      "AI Model Description and Training Data",
+			"ai_risk_management":        "AI Risk Management System",
+			"ai_human_oversight":        "AI Human Oversight Measures",
+		}
+		if t, ok := sectionTitles[sectionType]; ok {
+			title = t
+		}
+
+		_, err := h.store.CreateTechFileSection(c.Request.Context(), projectID, sectionType, title, content)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+	}
+
+	// Audit trail
+	userID := rbac.GetUserID(c)
+	h.store.AddAuditEntry(
+		c.Request.Context(), projectID, "tech_file_section", projectID,
+		iace.AuditActionCreate, userID.String(), nil, nil,
+	)
+
+	c.JSON(http.StatusOK, gin.H{
+		"message":      "section generated",
+		"section_type": sectionType,
+		"content":      content,
 	})
 }
 
@@ -1631,9 +1816,8 @@ func (h *IACEHandler) ApproveTechFileSection(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"message": "tech file section approved"})
 }
 
-// ExportTechFile handles GET /projects/:id/tech-file/export
-// Exports all tech file sections as a combined JSON document.
-// TODO: Implement PDF export with proper formatting.
+// ExportTechFile handles GET /projects/:id/tech-file/export?format=pdf|xlsx|docx|md|json
+// Exports all tech file sections in the requested format.
 func (h *IACEHandler) ExportTechFile(c *gin.Context) {
 	projectID, err := uuid.Parse(c.Param("id"))
 	if err != nil {
@@ -1657,27 +1841,78 @@ func (h *IACEHandler) ExportTechFile(c *gin.Context) {
 		return
 	}
 
-	// Check if all sections are approved
-	allApproved := true
-	for _, s := range sections {
-		if s.Status != iace.TechFileSectionStatusApproved {
-			allApproved = false
-			break
-		}
+	// Load hazards, assessments, mitigations, classifications for export
+	hazards, _ := h.store.ListHazards(c.Request.Context(), projectID)
+	var allAssessments []iace.RiskAssessment
+	var allMitigations []iace.Mitigation
+	for _, hazard := range hazards {
+		assessments, _ := h.store.ListAssessments(c.Request.Context(), hazard.ID)
+		allAssessments = append(allAssessments, assessments...)
+		mitigations, _ := h.store.ListMitigations(c.Request.Context(), hazard.ID)
+		allMitigations = append(allMitigations, mitigations...)
 	}
-
 	classifications, _ := h.store.GetClassifications(c.Request.Context(), projectID)
-	riskSummary, _ := h.store.GetRiskSummary(c.Request.Context(), projectID)
 
-	c.JSON(http.StatusOK, gin.H{
-		"project":         project,
-		"sections":        sections,
-		"classifications": classifications,
-		"risk_summary":    riskSummary,
-		"all_approved":    allApproved,
-		"export_format":   "json",
-		"_note":           "PDF export will be available in a future release",
-	})
+	format := c.DefaultQuery("format", "json")
+	safeName := strings.ReplaceAll(project.MachineName, " ", "_")
+
+	switch format {
+	case "pdf":
+		data, err := h.exporter.ExportPDF(project, sections, hazards, allAssessments, allMitigations, classifications)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("PDF export failed: %v", err)})
+			return
+		}
+		c.Header("Content-Disposition", fmt.Sprintf(`attachment; filename="CE-Akte-%s.pdf"`, safeName))
+		c.Data(http.StatusOK, "application/pdf", data)
+
+	case "xlsx":
+		data, err := h.exporter.ExportExcel(project, sections, hazards, allAssessments, allMitigations)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Excel export failed: %v", err)})
+			return
+		}
+		c.Header("Content-Disposition", fmt.Sprintf(`attachment; filename="CE-Akte-%s.xlsx"`, safeName))
+		c.Data(http.StatusOK, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", data)
+
+	case "docx":
+		data, err := h.exporter.ExportDOCX(project, sections)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("DOCX export failed: %v", err)})
+			return
+		}
+		c.Header("Content-Disposition", fmt.Sprintf(`attachment; filename="CE-Akte-%s.docx"`, safeName))
+		c.Data(http.StatusOK, "application/vnd.openxmlformats-officedocument.wordprocessingml.document", data)
+
+	case "md":
+		data, err := h.exporter.ExportMarkdown(project, sections)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Markdown export failed: %v", err)})
+			return
+		}
+		c.Header("Content-Disposition", fmt.Sprintf(`attachment; filename="CE-Akte-%s.md"`, safeName))
+		c.Data(http.StatusOK, "text/markdown", data)
+
+	default:
+		// JSON export (original behavior)
+		allApproved := true
+		for _, s := range sections {
+			if s.Status != iace.TechFileSectionStatusApproved {
+				allApproved = false
+				break
+			}
+		}
+		riskSummary, _ := h.store.GetRiskSummary(c.Request.Context(), projectID)
+
+		c.JSON(http.StatusOK, gin.H{
+			"project":         project,
+			"sections":        sections,
+			"classifications": classifications,
+			"risk_summary":    riskSummary,
+			"all_approved":    allApproved,
+			"export_format":   "json",
+		})
+	}
 }
 
 // ============================================================================
diff --git a/ai-compliance-sdk/internal/iace/completeness.go b/ai-compliance-sdk/internal/iace/completeness.go
index f8bd366..ab1a64e 100644
--- a/ai-compliance-sdk/internal/iace/completeness.go
+++ b/ai-compliance-sdk/internal/iace/completeness.go
@@ -21,15 +21,16 @@ type GateDefinition struct {
 
 // CompletenessContext provides all project data needed to evaluate completeness gates.
 type CompletenessContext struct {
-	Project          *Project
-	Components       []Component
-	Classifications  []RegulatoryClassification
-	Hazards          []Hazard
-	Assessments      []RiskAssessment
-	Mitigations      []Mitigation
-	Evidence         []Evidence
-	TechFileSections []TechFileSection
-	HasAI            bool
+	Project                  *Project
+	Components               []Component
+	Classifications          []RegulatoryClassification
+	Hazards                  []Hazard
+	Assessments              []RiskAssessment
+	Mitigations              []Mitigation
+	Evidence                 []Evidence
+	TechFileSections         []TechFileSection
+	HasAI                    bool
+	PatternMatchingPerformed bool // set from audit trail (entity_type="pattern_matching")
 }
 
 // CompletenessResult contains the aggregated result of all gate checks.
@@ -145,10 +146,7 @@ func buildGateDefinitions() []GateDefinition {
 			Required:    false,
 			Recommended: true,
 			CheckFunc: func(ctx *CompletenessContext) bool {
-				// Check audit trail for pattern_matching entries
-				// Since we can't query audit trail from context, check if hazards
-				// have been created (proxy for pattern matching having been performed)
-				return len(ctx.Hazards) >= 3
+				return ctx.PatternMatchingPerformed
 			},
 		},
 
@@ -265,14 +263,17 @@ func buildGateDefinitions() []GateDefinition {
 			Label:    "Mitigations verified",
 			Required: true,
 			CheckFunc: func(ctx *CompletenessContext) bool {
-				// All mitigations with status "implemented" must also be verified
+				// All mitigations must be in a terminal state (verified or rejected).
+				// Planned and implemented mitigations block export — they haven't been
+				// verified yet, so the project cannot be considered complete.
+				if len(ctx.Mitigations) == 0 {
+					return true
+				}
 				for _, m := range ctx.Mitigations {
-					if m.Status == MitigationStatusImplemented {
-						// Implemented but not yet verified -> gate fails
+					if m.Status != MitigationStatusVerified && m.Status != MitigationStatusRejected {
 						return false
 					}
 				}
-				// All mitigations are either planned, verified, or rejected
 				return true
 			},
 		},
diff --git a/ai-compliance-sdk/internal/iace/completeness_test.go b/ai-compliance-sdk/internal/iace/completeness_test.go
index 7abcb23..1910e9a 100644
--- a/ai-compliance-sdk/internal/iace/completeness_test.go
+++ b/ai-compliance-sdk/internal/iace/completeness_test.go
@@ -33,7 +33,7 @@ func TestCompletenessCheck_EmptyContext(t *testing.T) {
 	// With nil project, most gates fail. However, some auto-pass:
 	// G06 (AI classification): auto-passes when HasAI=false
 	// G22 (critical/high mitigated): auto-passes when no critical/high assessments exist
-	// G23 (mitigations verified): auto-passes when no mitigations with status "implemented"
+	// G23 (mitigations verified): auto-passes when no mitigations (empty list)
 	// G42 (AI documents): auto-passes when HasAI=false
 	// That gives 4 required gates passing even with empty context.
 	if result.PassedRequired != 4 {
@@ -89,7 +89,8 @@ func TestCompletenessCheck_MinimalValidProject(t *testing.T) {
 			{ID: uuid.New(), ProjectID: projectID, SectionType: "risk_assessment_report"},
 			{ID: uuid.New(), ProjectID: projectID, SectionType: "hazard_log_combined"},
 		},
-		HasAI: false,
+		HasAI:                    false,
+		PatternMatchingPerformed: true,
 	}
 
 	result := checker.Check(ctx)
@@ -376,11 +377,11 @@ func TestCompletenessCheck_G23_MitigationsVerified(t *testing.T) {
 			wantG23Passed: false,
 		},
 		{
-			name: "planned mitigations pass G23 (not yet implemented)",
+			name: "planned mitigations fail G23 (not yet verified)",
 			mitigations: []Mitigation{
 				{HazardID: hazardID, Status: MitigationStatusPlanned},
 			},
-			wantG23Passed: true,
+			wantG23Passed: false,
 		},
 		{
 			name: "rejected mitigations pass G23",
@@ -390,12 +391,20 @@ func TestCompletenessCheck_G23_MitigationsVerified(t *testing.T) {
 			wantG23Passed: true,
 		},
 		{
-			name: "mix of verified planned rejected passes G23",
+			name: "mix of verified planned rejected fails G23",
 			mitigations: []Mitigation{
 				{HazardID: hazardID, Status: MitigationStatusVerified},
 				{HazardID: hazardID, Status: MitigationStatusPlanned},
 				{HazardID: hazardID, Status: MitigationStatusRejected},
 			},
+			wantG23Passed: false,
+		},
+		{
+			name: "mix of verified and rejected passes G23",
+			mitigations: []Mitigation{
+				{HazardID: hazardID, Status: MitigationStatusVerified},
+				{HazardID: hazardID, Status: MitigationStatusRejected},
+			},
 			wantG23Passed: true,
 		},
 	}
@@ -422,6 +431,48 @@ func TestCompletenessCheck_G23_MitigationsVerified(t *testing.T) {
 	}
 }
 
+func TestCompletenessCheck_G09_PatternMatchingPerformed(t *testing.T) {
+	checker := NewCompletenessChecker()
+
+	tests := []struct {
+		name          string
+		performed     bool
+		wantG09Passed bool
+	}{
+		{
+			name:          "pattern matching not performed fails G09",
+			performed:     false,
+			wantG09Passed: false,
+		},
+		{
+			name:          "pattern matching performed passes G09",
+			performed:     true,
+			wantG09Passed: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := &CompletenessContext{
+				Project:                  &Project{MachineName: "Test"},
+				PatternMatchingPerformed: tt.performed,
+			}
+
+			result := checker.Check(ctx)
+
+			for _, g := range result.Gates {
+				if g.ID == "G09" {
+					if g.Passed != tt.wantG09Passed {
+						t.Errorf("G09 Passed = %v, want %v", g.Passed, tt.wantG09Passed)
+					}
+					return
+				}
+			}
+			t.Error("G09 gate not found in results")
+		})
+	}
+}
+
 func TestCompletenessCheck_G24_ResidualRiskAccepted(t *testing.T) {
 	checker := NewCompletenessChecker()
 
diff --git a/ai-compliance-sdk/internal/iace/document_export.go b/ai-compliance-sdk/internal/iace/document_export.go
new file mode 100644
index 0000000..9203444
--- /dev/null
+++ b/ai-compliance-sdk/internal/iace/document_export.go
@@ -0,0 +1,1101 @@
+package iace
+
+import (
+	"archive/zip"
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/jung-kurt/gofpdf"
+	"github.com/xuri/excelize/v2"
+)
+
+// ExportFormat represents a supported document export format
+type ExportFormat string
+
+const (
+	ExportFormatPDF  ExportFormat = "pdf"
+	ExportFormatXLSX ExportFormat = "xlsx"
+	ExportFormatDOCX ExportFormat = "docx"
+	ExportFormatMD   ExportFormat = "md"
+	ExportFormatJSON ExportFormat = "json"
+)
+
+// DocumentExporter handles exporting CE technical file data into various formats
+type DocumentExporter struct{}
+
+// NewDocumentExporter creates a new DocumentExporter instance
+func NewDocumentExporter() *DocumentExporter {
+	return &DocumentExporter{}
+}
+
+// ============================================================================
+// PDF Export
+// ============================================================================
+
+// ExportPDF generates a PDF document containing the full CE technical file
+func (e *DocumentExporter) ExportPDF(
+	project *Project,
+	sections []TechFileSection,
+	hazards []Hazard,
+	assessments []RiskAssessment,
+	mitigations []Mitigation,
+	classifications []RegulatoryClassification,
+) ([]byte, error) {
+	if project == nil {
+		return nil, fmt.Errorf("project must not be nil")
+	}
+
+	pdf := gofpdf.New("P", "mm", "A4", "")
+	pdf.SetFont("Helvetica", "", 12)
+
+	// --- Cover Page ---
+	pdf.AddPage()
+	e.pdfCoverPage(pdf, project)
+
+	// --- Table of Contents ---
+	pdf.AddPage()
+	e.pdfTableOfContents(pdf, sections)
+
+	// --- Sections ---
+	for _, section := range sections {
+		pdf.AddPage()
+		e.pdfSection(pdf, section)
+	}
+
+	// --- Hazard Log ---
+	pdf.AddPage()
+	e.pdfHazardLog(pdf, hazards, assessments)
+
+	// --- Risk Matrix Summary ---
+	e.pdfRiskMatrixSummary(pdf, assessments)
+
+	// --- Mitigations Table ---
+	pdf.AddPage()
+	e.pdfMitigationsTable(pdf, mitigations)
+
+	// --- Regulatory Classifications ---
+	if len(classifications) > 0 {
+		pdf.AddPage()
+		e.pdfClassifications(pdf, classifications)
+	}
+
+	// --- Footer on every page ---
+	pdf.SetFooterFunc(func() {
+		pdf.SetY(-15)
+		pdf.SetFont("Helvetica", "I", 8)
+		pdf.SetTextColor(128, 128, 128)
+		pdf.CellFormat(0, 5,
+			fmt.Sprintf("CE-Akte %s | Generiert am %s | BreakPilot AI Compliance SDK",
+				project.MachineName, time.Now().Format("02.01.2006 15:04")),
+			"", 0, "C", false, 0, "")
+	})
+
+	var buf bytes.Buffer
+	if err := pdf.Output(&buf); err != nil {
+		return nil, fmt.Errorf("failed to generate PDF: %w", err)
+	}
+	return buf.Bytes(), nil
+}
+
+func (e *DocumentExporter) pdfCoverPage(pdf *gofpdf.Fpdf, project *Project) {
+	pdf.Ln(60)
+
+	// Machine name (large, bold, centered)
+	pdf.SetFont("Helvetica", "B", 28)
+	pdf.SetTextColor(0, 0, 0)
+	pdf.CellFormat(0, 15, "CE-Technische Akte", "", 1, "C", false, 0, "")
+	pdf.Ln(5)
+
+	pdf.SetFont("Helvetica", "B", 22)
+	pdf.CellFormat(0, 12, project.MachineName, "", 1, "C", false, 0, "")
+	pdf.Ln(15)
+
+	// Metadata block
+	pdf.SetFont("Helvetica", "", 12)
+	coverItems := []struct {
+		label string
+		value string
+	}{
+		{"Hersteller", project.Manufacturer},
+		{"Maschinentyp", project.MachineType},
+		{"CE-Kennzeichnungsziel", project.CEMarkingTarget},
+		{"Projektstatus", string(project.Status)},
+		{"Datum", time.Now().Format("02.01.2006")},
+	}
+
+	for _, item := range coverItems {
+		if item.value == "" {
+			continue
+		}
+		pdf.SetFont("Helvetica", "B", 12)
+		pdf.CellFormat(60, 8, item.label+":", "", 0, "R", false, 0, "")
+		pdf.SetFont("Helvetica", "", 12)
+		pdf.CellFormat(5, 8, "", "", 0, "", false, 0, "")
+		pdf.CellFormat(0, 8, item.value, "", 1, "L", false, 0, "")
+	}
+
+	if project.Description != "" {
+		pdf.Ln(15)
+		pdf.SetFont("Helvetica", "I", 10)
+		pdf.MultiCell(0, 5, project.Description, "", "C", false)
+	}
+}
+
+func (e *DocumentExporter) pdfTableOfContents(pdf *gofpdf.Fpdf, sections []TechFileSection) {
+	pdf.SetFont("Helvetica", "B", 16)
+	pdf.SetTextColor(50, 50, 50)
+	pdf.CellFormat(0, 10, "Inhaltsverzeichnis", "", 1, "L", false, 0, "")
+	pdf.SetTextColor(0, 0, 0)
+	pdf.SetDrawColor(200, 200, 200)
+	pdf.Line(10, pdf.GetY(), 200, pdf.GetY())
+	pdf.Ln(8)
+
+	pdf.SetFont("Helvetica", "", 11)
+
+	// Fixed sections first
+	fixedEntries := []string{
+		"Gefaehrdungsprotokoll",
+		"Risikomatrix-Zusammenfassung",
+		"Massnahmen-Uebersicht",
+	}
+
+	pageEstimate := 3 // Cover + TOC use pages 1-2, sections start at 3
+	for i, section := range sections {
+		pdf.CellFormat(10, 7, fmt.Sprintf("%d.", i+1), "", 0, "R", false, 0, "")
+		pdf.CellFormat(5, 7, "", "", 0, "", false, 0, "")
+		pdf.CellFormat(130, 7, section.Title, "", 0, "L", false, 0, "")
+		pdf.CellFormat(0, 7, fmt.Sprintf("~%d", pageEstimate+i), "", 1, "R", false, 0, "")
+	}
+
+	// Append fixed sections after document sections
+	startPage := pageEstimate + len(sections)
+	for i, entry := range fixedEntries {
+		idx := len(sections) + i + 1
+		pdf.CellFormat(10, 7, fmt.Sprintf("%d.", idx), "", 0, "R", false, 0, "")
+		pdf.CellFormat(5, 7, "", "", 0, "", false, 0, "")
+		pdf.CellFormat(130, 7, entry, "", 0, "L", false, 0, "")
+		pdf.CellFormat(0, 7, fmt.Sprintf("~%d", startPage+i), "", 1, "R", false, 0, "")
+	}
+}
+
+func (e *DocumentExporter) pdfSection(pdf *gofpdf.Fpdf, section TechFileSection) {
+	// Section heading
+	pdf.SetFont("Helvetica", "B", 14)
+	pdf.SetTextColor(50, 50, 50)
+	pdf.CellFormat(0, 10, section.Title, "", 1, "L", false, 0, "")
+	pdf.SetTextColor(0, 0, 0)
+
+	// Status badge
+	pdf.SetFont("Helvetica", "I", 9)
+	pdf.SetTextColor(100, 100, 100)
+	pdf.CellFormat(0, 5,
+		fmt.Sprintf("Typ: %s | Status: %s | Version: %d",
+			section.SectionType, string(section.Status), section.Version),
+		"", 1, "L", false, 0, "")
+	pdf.SetTextColor(0, 0, 0)
+
+	pdf.SetDrawColor(200, 200, 200)
+	pdf.Line(10, pdf.GetY(), 200, pdf.GetY())
+	pdf.Ln(5)
+
+	// Content
+	pdf.SetFont("Helvetica", "", 10)
+	if section.Content != "" {
+		pdf.MultiCell(0, 5, section.Content, "", "L", false)
+	} else {
+		pdf.SetFont("Helvetica", "I", 10)
+		pdf.SetTextColor(150, 150, 150)
+		pdf.CellFormat(0, 7, "(Kein Inhalt vorhanden)", "", 1, "L", false, 0, "")
+		pdf.SetTextColor(0, 0, 0)
+	}
+}
+
+// buildAssessmentMap creates a lookup from HazardID to its most recent RiskAssessment
+func buildAssessmentMap(assessments []RiskAssessment) map[string]*RiskAssessment {
+	m := make(map[string]*RiskAssessment)
+	for i := range assessments {
+		a := &assessments[i]
+		key := a.HazardID.String()
+		if existing, ok := m[key]; !ok || a.Version > existing.Version {
+			m[key] = a
+		}
+	}
+	return m
+}
+
+func (e *DocumentExporter) pdfHazardLog(pdf *gofpdf.Fpdf, hazards []Hazard, assessments []RiskAssessment) {
+	pdf.SetFont("Helvetica", "B", 14)
+	pdf.SetTextColor(50, 50, 50)
+	pdf.CellFormat(0, 10, "Gefaehrdungsprotokoll", "", 1, "L", false, 0, "")
+	pdf.SetTextColor(0, 0, 0)
+	pdf.SetDrawColor(200, 200, 200)
+	pdf.Line(10, pdf.GetY(), 200, pdf.GetY())
+	pdf.Ln(5)
+
+	if len(hazards) == 0 {
+		pdf.SetFont("Helvetica", "I", 10)
+		pdf.CellFormat(0, 7, "(Keine Gefaehrdungen erfasst)", "", 1, "L", false, 0, "")
+		return
+	}
+
+	assessMap := buildAssessmentMap(assessments)
+
+	// Table header
+	colWidths := []float64{10, 40, 30, 12, 12, 12, 30, 20}
+	headers := []string{"Nr", "Name", "Kategorie", "S", "E", "P", "Risiko", "OK"}
+
+	pdf.SetFont("Helvetica", "B", 9)
+	pdf.SetFillColor(240, 240, 240)
+	for i, h := range headers {
+		pdf.CellFormat(colWidths[i], 7, h, "1", 0, "C", true, 0, "")
+	}
+	pdf.Ln(-1)
+
+	pdf.SetFont("Helvetica", "", 8)
+	for i, hazard := range hazards {
+		if pdf.GetY() > 265 {
+			pdf.AddPage()
+			// Reprint header
+			pdf.SetFont("Helvetica", "B", 9)
+			pdf.SetFillColor(240, 240, 240)
+			for j, h := range headers {
+				pdf.CellFormat(colWidths[j], 7, h, "1", 0, "C", true, 0, "")
+			}
+			pdf.Ln(-1)
+			pdf.SetFont("Helvetica", "", 8)
+		}
+
+		a := assessMap[hazard.ID.String()]
+
+		sev, exp, prob := "", "", ""
+		riskLabel := "-"
+		acceptable := "-"
+		var rl RiskLevel
+
+		if a != nil {
+			sev = fmt.Sprintf("%d", a.Severity)
+			exp = fmt.Sprintf("%d", a.Exposure)
+			prob = fmt.Sprintf("%d", a.Probability)
+			rl = a.RiskLevel
+			riskLabel = riskLevelLabel(rl)
+			if a.IsAcceptable {
+				acceptable = "Ja"
+			} else {
+				acceptable = "Nein"
+			}
+		}
+
+		// Color-code the row based on risk level
+		r, g, b := riskLevelColor(rl)
+		pdf.SetFillColor(r, g, b)
+		fill := rl != ""
+
+		pdf.CellFormat(colWidths[0], 6, fmt.Sprintf("%d", i+1), "1", 0, "C", fill, 0, "")
+		pdf.CellFormat(colWidths[1], 6, pdfTruncate(hazard.Name, 22), "1", 0, "L", fill, 0, "")
+		pdf.CellFormat(colWidths[2], 6, pdfTruncate(hazard.Category, 16), "1", 0, "L", fill, 0, "")
+		pdf.CellFormat(colWidths[3], 6, sev, "1", 0, "C", fill, 0, "")
+		pdf.CellFormat(colWidths[4], 6, exp, "1", 0, "C", fill, 0, "")
+		pdf.CellFormat(colWidths[5], 6, prob, "1", 0, "C", fill, 0, "")
+		pdf.CellFormat(colWidths[6], 6, riskLabel, "1", 0, "C", fill, 0, "")
+		pdf.CellFormat(colWidths[7], 6, acceptable, "1", 0, "C", fill, 0, "")
+		pdf.Ln(-1)
+	}
+}
+
+func (e *DocumentExporter) pdfRiskMatrixSummary(pdf *gofpdf.Fpdf, assessments []RiskAssessment) {
+	pdf.Ln(10)
+	pdf.SetFont("Helvetica", "B", 14)
+	pdf.SetTextColor(50, 50, 50)
+	pdf.CellFormat(0, 10, "Risikomatrix-Zusammenfassung", "", 1, "L", false, 0, "")
+	pdf.SetTextColor(0, 0, 0)
+	pdf.SetDrawColor(200, 200, 200)
+	pdf.Line(10, pdf.GetY(), 200, pdf.GetY())
+	pdf.Ln(5)
+
+	counts := countByRiskLevel(assessments)
+
+	levels := []RiskLevel{
+		RiskLevelNotAcceptable,
+		RiskLevelVeryHigh,
+		RiskLevelCritical,
+		RiskLevelHigh,
+		RiskLevelMedium,
+		RiskLevelLow,
+		RiskLevelNegligible,
+	}
+
+	pdf.SetFont("Helvetica", "B", 9)
+	pdf.SetFillColor(240, 240, 240)
+	pdf.CellFormat(60, 7, "Risikostufe", "1", 0, "L", true, 0, "")
+	pdf.CellFormat(30, 7, "Anzahl", "1", 0, "C", true, 0, "")
+	pdf.Ln(-1)
+
+	pdf.SetFont("Helvetica", "", 9)
+	for _, level := range levels {
+		count := counts[level]
+		if count == 0 {
+			continue
+		}
+		r, g, b := riskLevelColor(level)
+		pdf.SetFillColor(r, g, b)
+		pdf.CellFormat(60, 6, riskLevelLabel(level), "1", 0, "L", true, 0, "")
+		pdf.CellFormat(30, 6, fmt.Sprintf("%d", count), "1", 0, "C", true, 0, "")
+		pdf.Ln(-1)
+	}
+
+	pdf.SetFont("Helvetica", "B", 9)
+	pdf.SetFillColor(240, 240, 240)
+	pdf.CellFormat(60, 7, "Gesamt", "1", 0, "L", true, 0, "")
+	pdf.CellFormat(30, 7, fmt.Sprintf("%d", len(assessments)), "1", 0, "C", true, 0, "")
+	pdf.Ln(-1)
+}
+
+func (e *DocumentExporter) pdfMitigationsTable(pdf *gofpdf.Fpdf, mitigations []Mitigation) {
+	pdf.SetFont("Helvetica", "B", 14)
+	pdf.SetTextColor(50, 50, 50)
+	pdf.CellFormat(0, 10, "Massnahmen-Uebersicht", "", 1, "L", false, 0, "")
+	pdf.SetTextColor(0, 0, 0)
+	pdf.SetDrawColor(200, 200, 200)
+	pdf.Line(10, pdf.GetY(), 200, pdf.GetY())
+	pdf.Ln(5)
+
+	if len(mitigations) == 0 {
+		pdf.SetFont("Helvetica", "I", 10)
+		pdf.CellFormat(0, 7, "(Keine Massnahmen erfasst)", "", 1, "L", false, 0, "")
+		return
+	}
+
+	colWidths := []float64{10, 45, 30, 30, 40}
+	headers := []string{"Nr", "Name", "Typ", "Status", "Verifikation"}
+
+	pdf.SetFont("Helvetica", "B", 9)
+	pdf.SetFillColor(240, 240, 240)
+	for i, h := range headers {
+		pdf.CellFormat(colWidths[i], 7, h, "1", 0, "C", true, 0, "")
+	}
+	pdf.Ln(-1)
+
+	pdf.SetFont("Helvetica", "", 8)
+	for i, m := range mitigations {
+		if pdf.GetY() > 265 {
+			pdf.AddPage()
+			pdf.SetFont("Helvetica", "B", 9)
+			pdf.SetFillColor(240, 240, 240)
+			for j, h := range headers {
+				pdf.CellFormat(colWidths[j], 7, h, "1", 0, "C", true, 0, "")
+			}
+			pdf.Ln(-1)
+			pdf.SetFont("Helvetica", "", 8)
+		}
+
+		pdf.CellFormat(colWidths[0], 6, fmt.Sprintf("%d", i+1), "1", 0, "C", false, 0, "")
+		pdf.CellFormat(colWidths[1], 6, pdfTruncate(m.Name, 25), "1", 0, "L", false, 0, "")
+		pdf.CellFormat(colWidths[2], 6, reductionTypeLabel(m.ReductionType), "1", 0, "C", false, 0, "")
+		pdf.CellFormat(colWidths[3], 6, mitigationStatusLabel(m.Status), "1", 0, "C", false, 0, "")
+		pdf.CellFormat(colWidths[4], 6, pdfTruncate(string(m.VerificationMethod), 22), "1", 0, "L", false, 0, "")
+		pdf.Ln(-1)
+	}
+}
+
+func (e *DocumentExporter) pdfClassifications(pdf *gofpdf.Fpdf, classifications []RegulatoryClassification) {
+	pdf.SetFont("Helvetica", "B", 14)
+	pdf.SetTextColor(50, 50, 50)
+	pdf.CellFormat(0, 10, "Regulatorische Klassifizierungen", "", 1, "L", false, 0, "")
+	pdf.SetTextColor(0, 0, 0)
+	pdf.SetDrawColor(200, 200, 200)
+	pdf.Line(10, pdf.GetY(), 200, pdf.GetY())
+	pdf.Ln(5)
+
+	for _, c := range classifications {
+		pdf.SetFont("Helvetica", "B", 11)
+		pdf.CellFormat(0, 7, regulationLabel(c.Regulation), "", 1, "L", false, 0, "")
+
+		pdf.SetFont("Helvetica", "", 10)
+		pdf.CellFormat(50, 6, "Klassifizierung:", "", 0, "L", false, 0, "")
+		pdf.CellFormat(0, 6, c.ClassificationResult, "", 1, "L", false, 0, "")
+
+		pdf.CellFormat(50, 6, "Risikostufe:", "", 0, "L", false, 0, "")
+		pdf.CellFormat(0, 6, riskLevelLabel(c.RiskLevel), "", 1, "L", false, 0, "")
+
+		if c.Reasoning != "" {
+			pdf.CellFormat(50, 6, "Begruendung:", "", 0, "L", false, 0, "")
+			pdf.MultiCell(0, 5, c.Reasoning, "", "L", false)
+		}
+		pdf.Ln(5)
+	}
+}
+
+// ============================================================================
+// Excel Export
+// ============================================================================
+
+// ExportExcel generates an XLSX workbook with project data across multiple sheets
+func (e *DocumentExporter) ExportExcel(
+	project *Project,
+	sections []TechFileSection,
+	hazards []Hazard,
+	assessments []RiskAssessment,
+	mitigations []Mitigation,
+) ([]byte, error) {
+	if project == nil {
+		return nil, fmt.Errorf("project must not be nil")
+	}
+
+	f := excelize.NewFile()
+	defer f.Close()
+
+	// --- Sheet 1: Uebersicht ---
+	overviewSheet := "Uebersicht"
+	f.SetSheetName("Sheet1", overviewSheet)
+	e.xlsxOverview(f, overviewSheet, project)
+
+	// --- Sheet 2: Gefaehrdungsprotokoll ---
+	hazardSheet := "Gefaehrdungsprotokoll"
+	f.NewSheet(hazardSheet)
+	e.xlsxHazardLog(f, hazardSheet, hazards, assessments)
+
+	// --- Sheet 3: Massnahmen ---
+	mitigationSheet := "Massnahmen"
+	f.NewSheet(mitigationSheet)
+	e.xlsxMitigations(f, mitigationSheet, mitigations)
+
+	// --- Sheet 4: Risikomatrix ---
+	matrixSheet := "Risikomatrix"
+	f.NewSheet(matrixSheet)
+	e.xlsxRiskMatrix(f, matrixSheet, assessments)
+
+	// --- Sheet 5: Sektionen ---
+	sectionSheet := "Sektionen"
+	f.NewSheet(sectionSheet)
+	e.xlsxSections(f, sectionSheet, sections)
+
+	buf, err := f.WriteToBuffer()
+	if err != nil {
+		return nil, fmt.Errorf("failed to write Excel: %w", err)
+	}
+	return buf.Bytes(), nil
+}
+
+func (e *DocumentExporter) xlsxOverview(f *excelize.File, sheet string, project *Project) {
+	headerStyle, _ := f.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Size: 11},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"D9E1F2"}},
+	})
+
+	f.SetColWidth(sheet, "A", "A", 30)
+	f.SetColWidth(sheet, "B", "B", 50)
+
+	rows := [][]string{
+		{"Eigenschaft", "Wert"},
+		{"Maschinenname", project.MachineName},
+		{"Maschinentyp", project.MachineType},
+		{"Hersteller", project.Manufacturer},
+		{"Beschreibung", project.Description},
+		{"CE-Kennzeichnungsziel", project.CEMarkingTarget},
+		{"Projektstatus", string(project.Status)},
+		{"Vollstaendigkeits-Score", fmt.Sprintf("%.1f%%", project.CompletenessScore*100)},
+		{"Erstellt am", project.CreatedAt.Format("02.01.2006 15:04")},
+		{"Aktualisiert am", project.UpdatedAt.Format("02.01.2006 15:04")},
+	}
+
+	for i, row := range rows {
+		rowNum := i + 1
+		f.SetCellValue(sheet, cellRef("A", rowNum), row[0])
+		f.SetCellValue(sheet, cellRef("B", rowNum), row[1])
+		if i == 0 {
+			f.SetCellStyle(sheet, cellRef("A", rowNum), cellRef("B", rowNum), headerStyle)
+		}
+	}
+}
+
+func (e *DocumentExporter) xlsxHazardLog(f *excelize.File, sheet string, hazards []Hazard, assessments []RiskAssessment) {
+	headerStyle, _ := f.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Size: 10, Color: "FFFFFF"},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{Horizontal: "center"},
+	})
+
+	headers := []string{"Nr", "Name", "Kategorie", "Beschreibung", "S", "E", "P", "A",
+		"Inherent Risk", "C_eff", "Residual Risk", "Risk Level", "Akzeptabel"}
+
+	colWidths := map[string]float64{
+		"A": 6, "B": 25, "C": 20, "D": 35, "E": 8, "F": 8, "G": 8, "H": 8,
+		"I": 14, "J": 10, "K": 14, "L": 18, "M": 12,
+	}
+	for col, w := range colWidths {
+		f.SetColWidth(sheet, col, col, w)
+	}
+
+	cols := []string{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M"}
+	for i, h := range headers {
+		f.SetCellValue(sheet, cellRef(cols[i], 1), h)
+	}
+	f.SetCellStyle(sheet, "A1", cellRef(cols[len(cols)-1], 1), headerStyle)
+
+	assessMap := buildAssessmentMap(assessments)
+
+	for i, hazard := range hazards {
+		row := i + 2
+		a := assessMap[hazard.ID.String()]
+
+		f.SetCellValue(sheet, cellRef("A", row), i+1)
+		f.SetCellValue(sheet, cellRef("B", row), hazard.Name)
+		f.SetCellValue(sheet, cellRef("C", row), hazard.Category)
+		f.SetCellValue(sheet, cellRef("D", row), hazard.Description)
+
+		if a != nil {
+			f.SetCellValue(sheet, cellRef("E", row), a.Severity)
+			f.SetCellValue(sheet, cellRef("F", row), a.Exposure)
+			f.SetCellValue(sheet, cellRef("G", row), a.Probability)
+			f.SetCellValue(sheet, cellRef("H", row), a.Avoidance)
+			f.SetCellValue(sheet, cellRef("I", row), fmt.Sprintf("%.1f", a.InherentRisk))
+			f.SetCellValue(sheet, cellRef("J", row), fmt.Sprintf("%.2f", a.CEff))
+			f.SetCellValue(sheet, cellRef("K", row), fmt.Sprintf("%.1f", a.ResidualRisk))
+			f.SetCellValue(sheet, cellRef("L", row), riskLevelLabel(a.RiskLevel))
+
+			acceptStr := "Nein"
+			if a.IsAcceptable {
+				acceptStr = "Ja"
+			}
+			f.SetCellValue(sheet, cellRef("M", row), acceptStr)
+
+			// Color-code the risk level cell
+			r, g, b := riskLevelColor(a.RiskLevel)
+			style, _ := f.NewStyle(&excelize.Style{
+				Fill: excelize.Fill{
+					Type:    "pattern",
+					Pattern: 1,
+					Color:   []string{rgbHex(r, g, b)},
+				},
+				Alignment: &excelize.Alignment{Horizontal: "center"},
+			})
+			f.SetCellStyle(sheet, cellRef("L", row), cellRef("L", row), style)
+		}
+	}
+}
+
+func (e *DocumentExporter) xlsxMitigations(f *excelize.File, sheet string, mitigations []Mitigation) {
+	headerStyle, _ := f.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Size: 10, Color: "FFFFFF"},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{Horizontal: "center"},
+	})
+
+	headers := []string{"Nr", "Name", "Typ", "Beschreibung", "Status", "Verifikationsmethode", "Ergebnis"}
+	cols := []string{"A", "B", "C", "D", "E", "F", "G"}
+
+	f.SetColWidth(sheet, "A", "A", 6)
+	f.SetColWidth(sheet, "B", "B", 25)
+	f.SetColWidth(sheet, "C", "C", 15)
+	f.SetColWidth(sheet, "D", "D", 35)
+	f.SetColWidth(sheet, "E", "E", 15)
+	f.SetColWidth(sheet, "F", "F", 22)
+	f.SetColWidth(sheet, "G", "G", 25)
+
+	for i, h := range headers {
+		f.SetCellValue(sheet, cellRef(cols[i], 1), h)
+	}
+	f.SetCellStyle(sheet, "A1", cellRef(cols[len(cols)-1], 1), headerStyle)
+
+	for i, m := range mitigations {
+		row := i + 2
+		f.SetCellValue(sheet, cellRef("A", row), i+1)
+		f.SetCellValue(sheet, cellRef("B", row), m.Name)
+		f.SetCellValue(sheet, cellRef("C", row), reductionTypeLabel(m.ReductionType))
+		f.SetCellValue(sheet, cellRef("D", row), m.Description)
+		f.SetCellValue(sheet, cellRef("E", row), mitigationStatusLabel(m.Status))
+		f.SetCellValue(sheet, cellRef("F", row), string(m.VerificationMethod))
+		f.SetCellValue(sheet, cellRef("G", row), m.VerificationResult)
+	}
+}
+
+func (e *DocumentExporter) xlsxRiskMatrix(f *excelize.File, sheet string, assessments []RiskAssessment) {
+	headerStyle, _ := f.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Size: 10, Color: "FFFFFF"},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{Horizontal: "center"},
+	})
+
+	f.SetColWidth(sheet, "A", "A", 25)
+	f.SetColWidth(sheet, "B", "B", 12)
+
+	f.SetCellValue(sheet, "A1", "Risikostufe")
+	f.SetCellValue(sheet, "B1", "Anzahl")
+	f.SetCellStyle(sheet, "A1", "B1", headerStyle)
+
+	counts := countByRiskLevel(assessments)
+
+	levels := []RiskLevel{
+		RiskLevelNotAcceptable,
+		RiskLevelVeryHigh,
+		RiskLevelCritical,
+		RiskLevelHigh,
+		RiskLevelMedium,
+		RiskLevelLow,
+		RiskLevelNegligible,
+	}
+
+	row := 2
+	for _, level := range levels {
+		count := counts[level]
+		f.SetCellValue(sheet, cellRef("A", row), riskLevelLabel(level))
+		f.SetCellValue(sheet, cellRef("B", row), count)
+
+		r, g, b := riskLevelColor(level)
+		style, _ := f.NewStyle(&excelize.Style{
+			Fill: excelize.Fill{
+				Type:    "pattern",
+				Pattern: 1,
+				Color:   []string{rgbHex(r, g, b)},
+			},
+		})
+		f.SetCellStyle(sheet, cellRef("A", row), cellRef("B", row), style)
+		row++
+	}
+
+	// Total row
+	totalStyle, _ := f.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"D9E1F2"}},
+	})
+	f.SetCellValue(sheet, cellRef("A", row), "Gesamt")
+	f.SetCellValue(sheet, cellRef("B", row), len(assessments))
+	f.SetCellStyle(sheet, cellRef("A", row), cellRef("B", row), totalStyle)
+}
+
+func (e *DocumentExporter) xlsxSections(f *excelize.File, sheet string, sections []TechFileSection) {
+	headerStyle, _ := f.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Size: 10, Color: "FFFFFF"},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{Horizontal: "center"},
+	})
+
+	f.SetColWidth(sheet, "A", "A", 25)
+	f.SetColWidth(sheet, "B", "B", 40)
+	f.SetColWidth(sheet, "C", "C", 15)
+
+	headers := []string{"Sektion", "Titel", "Status"}
+	cols := []string{"A", "B", "C"}
+
+	for i, h := range headers {
+		f.SetCellValue(sheet, cellRef(cols[i], 1), h)
+	}
+	f.SetCellStyle(sheet, "A1", cellRef(cols[len(cols)-1], 1), headerStyle)
+
+	for i, s := range sections {
+		row := i + 2
+		f.SetCellValue(sheet, cellRef("A", row), s.SectionType)
+		f.SetCellValue(sheet, cellRef("B", row), s.Title)
+		f.SetCellValue(sheet, cellRef("C", row), string(s.Status))
+	}
+}
+
+// ============================================================================
+// Markdown Export
+// ============================================================================
+
+// ExportMarkdown generates a Markdown document of the CE technical file sections
+func (e *DocumentExporter) ExportMarkdown(
+	project *Project,
+	sections []TechFileSection,
+) ([]byte, error) {
+	if project == nil {
+		return nil, fmt.Errorf("project must not be nil")
+	}
+
+	var buf bytes.Buffer
+
+	// Title
+	buf.WriteString(fmt.Sprintf("# CE-Akte: %s\n\n", project.MachineName))
+
+	// Metadata block
+	buf.WriteString("| Eigenschaft | Wert |\n")
+	buf.WriteString("|-------------|------|\n")
+	buf.WriteString(fmt.Sprintf("| Hersteller | %s |\n", project.Manufacturer))
+	buf.WriteString(fmt.Sprintf("| Maschinentyp | %s |\n", project.MachineType))
+	if project.CEMarkingTarget != "" {
+		buf.WriteString(fmt.Sprintf("| CE-Kennzeichnungsziel | %s |\n", project.CEMarkingTarget))
+	}
+	buf.WriteString(fmt.Sprintf("| Status | %s |\n", project.Status))
+	buf.WriteString(fmt.Sprintf("| Datum | %s |\n", time.Now().Format("02.01.2006")))
+	buf.WriteString("\n")
+
+	if project.Description != "" {
+		buf.WriteString(fmt.Sprintf("> %s\n\n", project.Description))
+	}
+
+	// Sections
+	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",
+			section.SectionType, string(section.Status), section.Version))
+		if section.Content != "" {
+			buf.WriteString(section.Content)
+			buf.WriteString("\n\n")
+		} else {
+			buf.WriteString("*(Kein Inhalt vorhanden)*\n\n")
+		}
+	}
+
+	// Footer
+	buf.WriteString("---\n\n")
+	buf.WriteString(fmt.Sprintf("*Generiert am %s mit BreakPilot AI Compliance SDK*\n",
+		time.Now().Format("02.01.2006 15:04")))
+
+	return buf.Bytes(), nil
+}
+
+// ============================================================================
+// DOCX Export (minimal OOXML via archive/zip)
+// ============================================================================
+
+// ExportDOCX generates a minimal DOCX file containing the CE technical file sections
+func (e *DocumentExporter) ExportDOCX(
+	project *Project,
+	sections []TechFileSection,
+) ([]byte, error) {
+	if project == nil {
+		return nil, fmt.Errorf("project must not be nil")
+	}
+
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+
+	// [Content_Types].xml
+	contentTypes := `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
+</Types>`
+	if err := addZipEntry(zw, "[Content_Types].xml", contentTypes); err != nil {
+		return nil, fmt.Errorf("failed to write [Content_Types].xml: %w", err)
+	}
+
+	// _rels/.rels
+	rels := `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
+</Relationships>`
+	if err := addZipEntry(zw, "_rels/.rels", rels); err != nil {
+		return nil, fmt.Errorf("failed to write _rels/.rels: %w", err)
+	}
+
+	// word/_rels/document.xml.rels
+	docRels := `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+</Relationships>`
+	if err := addZipEntry(zw, "word/_rels/document.xml.rels", docRels); err != nil {
+		return nil, fmt.Errorf("failed to write word/_rels/document.xml.rels: %w", err)
+	}
+
+	// word/document.xml — build the body
+	docXML := e.buildDocumentXML(project, sections)
+	if err := addZipEntry(zw, "word/document.xml", docXML); err != nil {
+		return nil, fmt.Errorf("failed to write word/document.xml: %w", err)
+	}
+
+	if err := zw.Close(); err != nil {
+		return nil, fmt.Errorf("failed to close ZIP: %w", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+func (e *DocumentExporter) buildDocumentXML(project *Project, sections []TechFileSection) string {
+	var body strings.Builder
+
+	// Title paragraph (Heading 1 style)
+	body.WriteString(docxHeading(fmt.Sprintf("CE-Akte: %s", project.MachineName), 1))
+
+	// Metadata paragraphs
+	metaLines := []string{
+		fmt.Sprintf("Hersteller: %s", project.Manufacturer),
+		fmt.Sprintf("Maschinentyp: %s", project.MachineType),
+	}
+	if project.CEMarkingTarget != "" {
+		metaLines = append(metaLines, fmt.Sprintf("CE-Kennzeichnungsziel: %s", project.CEMarkingTarget))
+	}
+	metaLines = append(metaLines,
+		fmt.Sprintf("Status: %s", project.Status),
+		fmt.Sprintf("Datum: %s", time.Now().Format("02.01.2006")),
+	)
+	for _, line := range metaLines {
+		body.WriteString(docxParagraph(line, false))
+	}
+
+	if project.Description != "" {
+		body.WriteString(docxParagraph("", false)) // blank line
+		body.WriteString(docxParagraph(project.Description, true))
+	}
+
+	// Sections
+	for _, section := range sections {
+		body.WriteString(docxHeading(section.Title, 2))
+		body.WriteString(docxParagraph(
+			fmt.Sprintf("Typ: %s | Status: %s | Version: %d",
+				section.SectionType, string(section.Status), section.Version),
+			true,
+		))
+
+		if section.Content != "" {
+			// Split content by newlines into separate paragraphs
+			for _, line := range strings.Split(section.Content, "\n") {
+				body.WriteString(docxParagraph(line, false))
+			}
+		} else {
+			body.WriteString(docxParagraph("(Kein Inhalt vorhanden)", true))
+		}
+	}
+
+	// Footer
+	body.WriteString(docxParagraph("", false))
+	body.WriteString(docxParagraph(
+		fmt.Sprintf("Generiert am %s mit BreakPilot AI Compliance SDK",
+			time.Now().Format("02.01.2006 15:04")),
+		true,
+	))
+
+	return fmt.Sprintf(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas"
+            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+            xmlns:o="urn:schemas-microsoft-com:office:office"
+            xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+            xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"
+            xmlns:v="urn:schemas-microsoft-com:vml"
+            xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
+            xmlns:w10="urn:schemas-microsoft-com:office:word"
+            xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+            xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"
+            xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup"
+            xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk"
+            xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml"
+            xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
+            mc:Ignorable="w14 wp14">
+  <w:body>
+%s
+  </w:body>
+</w:document>`, body.String())
+}
+
+// ============================================================================
+// JSON Export (convenience — returns marshalled project data)
+// ============================================================================
+
+// ExportJSON returns a JSON representation of the project export data
+func (e *DocumentExporter) ExportJSON(
+	project *Project,
+	sections []TechFileSection,
+	hazards []Hazard,
+	assessments []RiskAssessment,
+	mitigations []Mitigation,
+	classifications []RegulatoryClassification,
+) ([]byte, error) {
+	if project == nil {
+		return nil, fmt.Errorf("project must not be nil")
+	}
+
+	payload := map[string]interface{}{
+		"project":         project,
+		"sections":        sections,
+		"hazards":         hazards,
+		"assessments":     assessments,
+		"mitigations":     mitigations,
+		"classifications": classifications,
+		"exported_at":     time.Now().UTC().Format(time.RFC3339),
+		"format_version":  "1.0",
+	}
+
+	data, err := json.MarshalIndent(payload, "", "  ")
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal JSON: %w", err)
+	}
+	return data, nil
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+// riskLevelColor returns RGB values for color-coding a given risk level
+func riskLevelColor(level RiskLevel) (r, g, b int) {
+	switch level {
+	case RiskLevelNotAcceptable:
+		return 180, 0, 0 // dark red
+	case RiskLevelVeryHigh:
+		return 220, 40, 40 // red
+	case RiskLevelCritical:
+		return 255, 80, 80 // bright red
+	case RiskLevelHigh:
+		return 255, 165, 80 // orange
+	case RiskLevelMedium:
+		return 255, 230, 100 // yellow
+	case RiskLevelLow:
+		return 180, 230, 140 // light green
+	case RiskLevelNegligible:
+		return 140, 210, 140 // green
+	default:
+		return 240, 240, 240 // light gray (unassessed)
+	}
+}
+
+// riskLevelLabel returns a German display label for a risk level
+func riskLevelLabel(level RiskLevel) string {
+	switch level {
+	case RiskLevelNotAcceptable:
+		return "Nicht akzeptabel"
+	case RiskLevelVeryHigh:
+		return "Sehr hoch"
+	case RiskLevelCritical:
+		return "Kritisch"
+	case RiskLevelHigh:
+		return "Hoch"
+	case RiskLevelMedium:
+		return "Mittel"
+	case RiskLevelLow:
+		return "Niedrig"
+	case RiskLevelNegligible:
+		return "Vernachlaessigbar"
+	default:
+		return string(level)
+	}
+}
+
+// reductionTypeLabel returns a German label for a reduction type
+func reductionTypeLabel(rt ReductionType) string {
+	switch rt {
+	case ReductionTypeDesign:
+		return "Konstruktiv"
+	case ReductionTypeProtective:
+		return "Schutzmassnahme"
+	case ReductionTypeInformation:
+		return "Information"
+	default:
+		return string(rt)
+	}
+}
+
+// mitigationStatusLabel returns a German label for a mitigation status
+func mitigationStatusLabel(status MitigationStatus) string {
+	switch status {
+	case MitigationStatusPlanned:
+		return "Geplant"
+	case MitigationStatusImplemented:
+		return "Umgesetzt"
+	case MitigationStatusVerified:
+		return "Verifiziert"
+	case MitigationStatusRejected:
+		return "Abgelehnt"
+	default:
+		return string(status)
+	}
+}
+
+// regulationLabel returns a German label for a regulation type
+func regulationLabel(reg RegulationType) string {
+	switch reg {
+	case RegulationNIS2:
+		return "NIS-2 Richtlinie"
+	case RegulationAIAct:
+		return "EU AI Act"
+	case RegulationCRA:
+		return "Cyber Resilience Act"
+	case RegulationMachineryRegulation:
+		return "EU Maschinenverordnung 2023/1230"
+	default:
+		return string(reg)
+	}
+}
+
+// escapeXML escapes special XML characters in text content
+func escapeXML(s string) string {
+	var buf bytes.Buffer
+	if err := xml.EscapeText(&buf, []byte(s)); err != nil {
+		// Fallback: return input unchanged (xml.EscapeText should never error on valid UTF-8)
+		return s
+	}
+	return buf.String()
+}
+
+// countByRiskLevel counts assessments per risk level
+func countByRiskLevel(assessments []RiskAssessment) map[RiskLevel]int {
+	counts := make(map[RiskLevel]int)
+	for _, a := range assessments {
+		counts[a.RiskLevel]++
+	}
+	return counts
+}
+
+// pdfTruncate truncates a string for PDF cell display
+func pdfTruncate(s string, maxLen int) string {
+	runes := []rune(s)
+	if len(runes) <= maxLen {
+		return s
+	}
+	if maxLen <= 3 {
+		return string(runes[:maxLen])
+	}
+	return string(runes[:maxLen-3]) + "..."
+}
+
+// cellRef builds an Excel cell reference like "A1", "B12"
+func cellRef(col string, row int) string {
+	return fmt.Sprintf("%s%d", col, row)
+}
+
+// rgbHex converts RGB values to a hex color string (without #)
+func rgbHex(r, g, b int) string {
+	return fmt.Sprintf("%02X%02X%02X", r, g, b)
+}
+
+// addZipEntry writes a text file into a zip archive
+func addZipEntry(zw *zip.Writer, name, content string) error {
+	w, err := zw.Create(name)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write([]byte(content))
+	return err
+}
+
+// docxHeading builds a DOCX paragraph with a heading style
+func docxHeading(text string, level int) string {
+	// Map level to font size (in half-points): 1→32pt, 2→26pt, 3→22pt
+	sizes := map[int]int{1: 64, 2: 52, 3: 44}
+	sz, ok := sizes[level]
+	if !ok {
+		sz = 44
+	}
+	escaped := escapeXML(text)
+	return fmt.Sprintf(`    <w:p>
+      <w:pPr>
+        <w:pStyle w:val="Heading%d"/>
+        <w:spacing w:after="200"/>
+      </w:pPr>
+      <w:r>
+        <w:rPr><w:b/><w:sz w:val="%d"/><w:szCs w:val="%d"/></w:rPr>
+        <w:t xml:space="preserve">%s</w:t>
+      </w:r>
+    </w:p>
+`, level, sz, sz, escaped)
+}
+
+// docxParagraph builds a DOCX paragraph, optionally italic
+func docxParagraph(text string, italic bool) string {
+	escaped := escapeXML(text)
+	rpr := ""
+	if italic {
+		rpr = "<w:rPr><w:i/></w:rPr>"
+	}
+	return fmt.Sprintf(`    <w:p>
+      <w:r>
+        %s
+        <w:t xml:space="preserve">%s</w:t>
+      </w:r>
+    </w:p>
+`, rpr, escaped)
+}
diff --git a/ai-compliance-sdk/internal/iace/document_export_test.go b/ai-compliance-sdk/internal/iace/document_export_test.go
new file mode 100644
index 0000000..612991e
--- /dev/null
+++ b/ai-compliance-sdk/internal/iace/document_export_test.go
@@ -0,0 +1,305 @@
+package iace
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/google/uuid"
+)
+
+// createTestExportData builds a complete set of test data for document export tests.
+func createTestExportData() (*Project, []TechFileSection, []Hazard, []RiskAssessment, []Mitigation, []RegulatoryClassification) {
+	projectID := uuid.New()
+	hazardID1 := uuid.New()
+	hazardID2 := uuid.New()
+
+	project := &Project{
+		ID:              projectID,
+		MachineName:     "Robot Arm XY-200",
+		MachineType:     "industrial_robot",
+		Manufacturer:    "TestCorp GmbH",
+		Description:     "6-Achsen Industrieroboter fuer Schweissarbeiten",
+		CEMarkingTarget: "2023/1230",
+	}
+
+	sections := []TechFileSection{
+		{ID: uuid.New(), ProjectID: projectID, SectionType: "risk_assessment_report", Title: "Risikobeurteilung", Content: "Dies ist der Risikobeurteilungsbericht...", Status: TechFileSectionStatusApproved},
+		{ID: uuid.New(), ProjectID: projectID, SectionType: "hazard_log_combined", Title: "Gefaehrdungsprotokoll", Content: "Protokoll aller identifizierten Gefaehrdungen...", Status: TechFileSectionStatusGenerated},
+		{ID: uuid.New(), ProjectID: projectID, SectionType: "declaration_of_conformity", Title: "EU-Konformitaetserklaerung", Content: "Hiermit erklaeren wir...", Status: TechFileSectionStatusDraft},
+	}
+
+	hazards := []Hazard{
+		{ID: hazardID1, ProjectID: projectID, Name: "Quetschgefahr", Category: "mechanical", Description: "Quetschgefahr durch Roboterarm"},
+		{ID: hazardID2, ProjectID: projectID, Name: "Elektrischer Schlag", Category: "electrical", Description: "Gefahr durch freiliegende Kontakte"},
+	}
+
+	assessments := []RiskAssessment{
+		{ID: uuid.New(), HazardID: hazardID1, Severity: 4, Exposure: 3, Probability: 3, InherentRisk: 36, CEff: 0.7, ResidualRisk: 10.8, RiskLevel: RiskLevelHigh, IsAcceptable: false},
+		{ID: uuid.New(), HazardID: hazardID2, Severity: 2, Exposure: 2, Probability: 2, InherentRisk: 8, CEff: 0.8, ResidualRisk: 1.6, RiskLevel: RiskLevelLow, IsAcceptable: true},
+	}
+
+	mitigations := []Mitigation{
+		{ID: uuid.New(), HazardID: hazardID1, ReductionType: ReductionTypeDesign, Name: "Schutzabdeckung", Status: MitigationStatusVerified},
+		{ID: uuid.New(), HazardID: hazardID1, ReductionType: ReductionTypeProtective, Name: "Lichtschranke", Status: MitigationStatusVerified},
+		{ID: uuid.New(), HazardID: hazardID2, ReductionType: ReductionTypeInformation, Name: "Warnhinweis", Status: MitigationStatusPlanned},
+	}
+
+	classifications := []RegulatoryClassification{
+		{Regulation: RegulationMachineryRegulation, ClassificationResult: "Annex I", RiskLevel: RiskLevelHigh},
+		{Regulation: RegulationCRA, ClassificationResult: "Important", RiskLevel: RiskLevelMedium},
+	}
+
+	return project, sections, hazards, assessments, mitigations, classifications
+}
+
+// createEmptyExportData builds minimal test data with no hazards, sections, or mitigations.
+func createEmptyExportData() (*Project, []TechFileSection, []Hazard, []RiskAssessment, []Mitigation, []RegulatoryClassification) {
+	project := &Project{
+		ID:              uuid.New(),
+		MachineName:     "Empty Machine",
+		MachineType:     "test",
+		Manufacturer:    "TestCorp",
+		Description:     "",
+		CEMarkingTarget: "",
+	}
+	return project, nil, nil, nil, nil, nil
+}
+
+// ============================================================================
+// PDF Export Tests
+// ============================================================================
+
+func TestExportPDF_ValidOutput(t *testing.T) {
+	exporter := NewDocumentExporter()
+	project, sections, hazards, assessments, mitigations, classifications := createTestExportData()
+
+	data, err := exporter.ExportPDF(project, sections, hazards, assessments, mitigations, classifications)
+	if err != nil {
+		t.Fatalf("ExportPDF returned error: %v", err)
+	}
+
+	if len(data) == 0 {
+		t.Fatal("ExportPDF returned empty bytes")
+	}
+
+	// Valid PDF files start with %PDF-
+	if !bytes.HasPrefix(data, []byte("%PDF-")) {
+		t.Errorf("ExportPDF output does not start with %%PDF-, got first 10 bytes: %q", data[:min(10, len(data))])
+	}
+}
+
+func TestExportPDF_EmptyProject(t *testing.T) {
+	exporter := NewDocumentExporter()
+	project, sections, hazards, assessments, mitigations, classifications := createEmptyExportData()
+
+	data, err := exporter.ExportPDF(project, sections, hazards, assessments, mitigations, classifications)
+	if err != nil {
+		t.Fatalf("ExportPDF with empty project returned error: %v", err)
+	}
+
+	if len(data) == 0 {
+		t.Fatal("ExportPDF with empty project returned empty bytes")
+	}
+
+	// Should still produce a valid PDF even with no content
+	if !bytes.HasPrefix(data, []byte("%PDF-")) {
+		t.Errorf("ExportPDF output does not start with %%PDF-, got first 10 bytes: %q", data[:min(10, len(data))])
+	}
+}
+
+// ============================================================================
+// Excel Export Tests
+// ============================================================================
+
+func TestExportExcel_ValidOutput(t *testing.T) {
+	exporter := NewDocumentExporter()
+	project, sections, hazards, assessments, mitigations, _ := createTestExportData()
+
+	data, err := exporter.ExportExcel(project, sections, hazards, assessments, mitigations)
+	if err != nil {
+		t.Fatalf("ExportExcel returned error: %v", err)
+	}
+
+	if len(data) == 0 {
+		t.Fatal("ExportExcel returned empty bytes")
+	}
+
+	// xlsx is a zip archive, which starts with PK (0x50, 0x4b)
+	if !bytes.HasPrefix(data, []byte("PK")) {
+		t.Errorf("ExportExcel output does not start with PK (zip signature), got first 4 bytes: %x", data[:min(4, len(data))])
+	}
+}
+
+func TestExportExcel_EmptyProject(t *testing.T) {
+	exporter := NewDocumentExporter()
+	project, sections, hazards, assessments, mitigations, _ := createEmptyExportData()
+
+	data, err := exporter.ExportExcel(project, sections, hazards, assessments, mitigations)
+	if err != nil {
+		t.Fatalf("ExportExcel with empty project returned error: %v", err)
+	}
+
+	if len(data) == 0 {
+		t.Fatal("ExportExcel with empty project returned empty bytes")
+	}
+
+	// Should still produce a valid xlsx (zip) even with no data
+	if !bytes.HasPrefix(data, []byte("PK")) {
+		t.Errorf("ExportExcel output does not start with PK (zip signature), got first 4 bytes: %x", data[:min(4, len(data))])
+	}
+}
+
+// ============================================================================
+// Markdown Export Tests
+// ============================================================================
+
+func TestExportMarkdown_ContainsSections(t *testing.T) {
+	exporter := NewDocumentExporter()
+	project, sections, _, _, _, _ := createTestExportData()
+
+	data, err := exporter.ExportMarkdown(project, sections)
+	if err != nil {
+		t.Fatalf("ExportMarkdown returned error: %v", err)
+	}
+
+	if len(data) == 0 {
+		t.Fatal("ExportMarkdown returned empty bytes")
+	}
+
+	content := string(data)
+
+	// Should contain the project name
+	if !strings.Contains(content, project.MachineName) {
+		t.Errorf("ExportMarkdown output does not contain project name %q", project.MachineName)
+	}
+
+	// Should contain each section title
+	for _, section := range sections {
+		if !strings.Contains(content, section.Title) {
+			t.Errorf("ExportMarkdown output does not contain section title %q", section.Title)
+		}
+	}
+
+	// Should contain markdown header syntax
+	if !strings.Contains(content, "#") {
+		t.Error("ExportMarkdown output does not contain any markdown headers")
+	}
+}
+
+func TestExportMarkdown_EmptyProject(t *testing.T) {
+	exporter := NewDocumentExporter()
+	project, _, _, _, _, _ := createEmptyExportData()
+
+	data, err := exporter.ExportMarkdown(project, nil)
+	if err != nil {
+		t.Fatalf("ExportMarkdown with empty project returned error: %v", err)
+	}
+
+	if len(data) == 0 {
+		t.Fatal("ExportMarkdown with empty project returned empty bytes")
+	}
+
+	content := string(data)
+
+	// Should still contain the project name as a header even without sections
+	if !strings.Contains(content, project.MachineName) {
+		t.Errorf("ExportMarkdown output does not contain project name %q for empty project", project.MachineName)
+	}
+}
+
+// ============================================================================
+// DOCX Export Tests
+// ============================================================================
+
+func TestExportDOCX_ValidOutput(t *testing.T) {
+	exporter := NewDocumentExporter()
+	project, sections, _, _, _, _ := createTestExportData()
+
+	data, err := exporter.ExportDOCX(project, sections)
+	if err != nil {
+		t.Fatalf("ExportDOCX returned error: %v", err)
+	}
+
+	if len(data) == 0 {
+		t.Fatal("ExportDOCX returned empty bytes")
+	}
+
+	// docx is a zip archive, which starts with PK (0x50, 0x4b)
+	if !bytes.HasPrefix(data, []byte("PK")) {
+		t.Errorf("ExportDOCX output does not start with PK (zip signature), got first 4 bytes: %x", data[:min(4, len(data))])
+	}
+}
+
+func TestExportDOCX_EmptyProject(t *testing.T) {
+	exporter := NewDocumentExporter()
+	project, _, _, _, _, _ := createEmptyExportData()
+
+	data, err := exporter.ExportDOCX(project, nil)
+	if err != nil {
+		t.Fatalf("ExportDOCX with empty project returned error: %v", err)
+	}
+
+	if len(data) == 0 {
+		t.Fatal("ExportDOCX with empty project returned empty bytes")
+	}
+
+	// Should still produce a valid docx (zip) even with no sections
+	if !bytes.HasPrefix(data, []byte("PK")) {
+		t.Errorf("ExportDOCX output does not start with PK (zip signature), got first 4 bytes: %x", data[:min(4, len(data))])
+	}
+}
+
+// ============================================================================
+// Helper Function Tests
+// ============================================================================
+
+func TestRiskLevelLabel_AllLevels(t *testing.T) {
+	levels := []RiskLevel{
+		RiskLevelCritical,
+		RiskLevelHigh,
+		RiskLevelMedium,
+		RiskLevelLow,
+		RiskLevelNegligible,
+		RiskLevelNotAcceptable,
+		RiskLevelVeryHigh,
+	}
+
+	for _, level := range levels {
+		t.Run(string(level), func(t *testing.T) {
+			label := riskLevelLabel(level)
+			if label == "" {
+				t.Errorf("riskLevelLabel(%q) returned empty string", level)
+			}
+		})
+	}
+}
+
+func TestRiskLevelColor_AllLevels(t *testing.T) {
+	levels := []RiskLevel{
+		RiskLevelCritical,
+		RiskLevelHigh,
+		RiskLevelMedium,
+		RiskLevelLow,
+		RiskLevelNegligible,
+		RiskLevelNotAcceptable,
+		RiskLevelVeryHigh,
+	}
+
+	for _, level := range levels {
+		t.Run(string(level), func(t *testing.T) {
+			r, g, b := riskLevelColor(level)
+			// RGB values must be in valid range 0-255
+			if r < 0 || r > 255 {
+				t.Errorf("riskLevelColor(%q) red value %d out of range [0,255]", level, r)
+			}
+			if g < 0 || g > 255 {
+				t.Errorf("riskLevelColor(%q) green value %d out of range [0,255]", level, g)
+			}
+			if b < 0 || b > 255 {
+				t.Errorf("riskLevelColor(%q) blue value %d out of range [0,255]", level, b)
+			}
+		})
+	}
+}
+
diff --git a/ai-compliance-sdk/internal/iace/store.go b/ai-compliance-sdk/internal/iace/store.go
index f754eb1..7d395a4 100644
--- a/ai-compliance-sdk/internal/iace/store.go
+++ b/ai-compliance-sdk/internal/iace/store.go
@@ -1612,6 +1612,21 @@ func (s *Store) ListAuditTrail(ctx context.Context, projectID uuid.UUID) ([]Audi
 	return entries, nil
 }
 
+// HasAuditEntryForType checks if an audit trail entry exists for the given entity type within a project.
+func (s *Store) HasAuditEntryForType(ctx context.Context, projectID uuid.UUID, entityType string) (bool, error) {
+	var exists bool
+	err := s.pool.QueryRow(ctx, `
+		SELECT EXISTS(
+			SELECT 1 FROM iace_audit_trail
+			WHERE project_id = $1 AND entity_type = $2
+		)
+	`, projectID, entityType).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("has audit entry: %w", err)
+	}
+	return exists, nil
+}
+
 // ============================================================================
 // Hazard Library Operations
 // ============================================================================
diff --git a/ai-compliance-sdk/internal/iace/tech_file_generator.go b/ai-compliance-sdk/internal/iace/tech_file_generator.go
new file mode 100644
index 0000000..45b95f2
--- /dev/null
+++ b/ai-compliance-sdk/internal/iace/tech_file_generator.go
@@ -0,0 +1,679 @@
+package iace
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/breakpilot/ai-compliance-sdk/internal/llm"
+	"github.com/breakpilot/ai-compliance-sdk/internal/ucca"
+	"github.com/google/uuid"
+)
+
+// ============================================================================
+// TechFileGenerator — LLM-based generation of technical file sections
+// ============================================================================
+
+// TechFileGenerator generates technical file section content using LLM and RAG.
+type TechFileGenerator struct {
+	llmRegistry *llm.ProviderRegistry
+	ragClient   *ucca.LegalRAGClient
+	store       *Store
+}
+
+// NewTechFileGenerator creates a new TechFileGenerator.
+func NewTechFileGenerator(registry *llm.ProviderRegistry, ragClient *ucca.LegalRAGClient, store *Store) *TechFileGenerator {
+	return &TechFileGenerator{
+		llmRegistry: registry,
+		ragClient:   ragClient,
+		store:       store,
+	}
+}
+
+// SectionGenerationContext holds all project data needed for LLM section generation.
+type SectionGenerationContext struct {
+	Project         *Project
+	Components      []Component
+	Hazards         []Hazard
+	Assessments     map[uuid.UUID][]RiskAssessment // keyed by hazardID
+	Mitigations     map[uuid.UUID][]Mitigation     // keyed by hazardID
+	Classifications []RegulatoryClassification
+	Evidence        []Evidence
+	RAGContext      string // aggregated text from RAG search
+}
+
+// ============================================================================
+// Section type constants
+// ============================================================================
+
+const (
+	SectionRiskAssessmentReport = "risk_assessment_report"
+	SectionHazardLogCombined    = "hazard_log_combined"
+	SectionGeneralDescription   = "general_description"
+	SectionEssentialRequirements = "essential_requirements"
+	SectionDesignSpecifications = "design_specifications"
+	SectionTestReports          = "test_reports"
+	SectionStandardsApplied     = "standards_applied"
+	SectionDeclarationConformity = "declaration_of_conformity"
+	SectionAIIntendedPurpose    = "ai_intended_purpose"
+	SectionAIModelDescription   = "ai_model_description"
+	SectionAIRiskManagement     = "ai_risk_management"
+	SectionAIHumanOversight     = "ai_human_oversight"
+	SectionComponentList        = "component_list"
+	SectionClassificationReport = "classification_report"
+	SectionMitigationReport     = "mitigation_report"
+	SectionVerificationReport   = "verification_report"
+	SectionEvidenceIndex        = "evidence_index"
+	SectionInstructionsForUse   = "instructions_for_use"
+	SectionMonitoringPlan       = "monitoring_plan"
+)
+
+// ============================================================================
+// System prompts (German — CE compliance context)
+// ============================================================================
+
+var sectionSystemPrompts = map[string]string{
+	SectionRiskAssessmentReport: `Du bist CE-Experte fuer Maschinen- und KI-Sicherheit. Erstelle eine strukturierte Zusammenfassung der Risikobeurteilung gemaess ISO 12100 und EN ISO 13849. Gliederung: 1) Methodik, 2) Risikoueberblick (Anzahl Gefaehrdungen nach Risikostufe), 3) Kritische Risiken, 4) Akzeptanzbewertung, 5) Empfehlungen. Verwende Fachterminologie und beziehe dich auf die konkreten Projektdaten.`,
+
+	SectionHazardLogCombined: `Erstelle ein tabellarisches Gefaehrdungsprotokoll (Hazard Log) fuer die technische Dokumentation. Jede Gefaehrdung soll enthalten: ID, Bezeichnung, Kategorie, Lebenszyklusphase, Szenario, Schwere, Eintrittswahrscheinlichkeit, Risikolevel, Massnahmen und Status. Formatiere als strukturierte Tabelle in Markdown.`,
+
+	SectionGeneralDescription: `Erstelle eine allgemeine Maschinenbeschreibung fuer die technische Dokumentation gemaess EU-Maschinenverordnung 2023/1230 Anhang IV. Beschreibe: 1) Bestimmungsgemaesse Verwendung, 2) Aufbau und Funktion, 3) Systemkomponenten, 4) Betriebsbedingungen, 5) Schnittstellen. Verwende die bereitgestellten Projektdaten.`,
+
+	SectionEssentialRequirements: `Beschreibe die anwendbaren grundlegenden Anforderungen (Essential Health and Safety Requirements — EHSR) gemaess EU-Maschinenverordnung 2023/1230 Anhang III. Ordne jede Anforderung den relevanten Gefaehrdungen und Massnahmen zu. Beruecksichtige auch AI Act und CRA Anforderungen falls KI-Komponenten vorhanden sind.`,
+
+	SectionDesignSpecifications: `Erstelle eine Uebersicht der Konstruktionsdaten und Spezifikationen fuer die technische Dokumentation. Enthalten sein sollen: 1) Systemarchitektur, 2) Komponentenliste mit Sicherheitsrelevanz, 3) Software-/Firmware-Versionen, 4) Schnittstellenbeschreibungen, 5) Sicherheitsfunktionen. Beziehe dich auf die konkreten Komponenten.`,
+
+	SectionTestReports: `Erstelle eine Zusammenfassung der Pruefberichte und Verifikationsergebnisse. Gliederung: 1) Durchgefuehrte Pruefungen, 2) Pruefmethoden (Test, Analyse, Inspektion), 3) Ergebnisse pro Massnahme, 4) Offene Punkte, 5) Gesamtbewertung. Referenziere die konkreten Mitigationsmassnahmen und deren Verifikationsstatus.`,
+
+	SectionStandardsApplied: `Liste die angewandten harmonisierten Normen und technischen Spezifikationen auf. Ordne jede Norm den relevanten Anforderungen und Gefaehrdungskategorien zu. Beruecksichtige: ISO 12100, ISO 13849, IEC 62443, ISO/IEC 27001, sowie branchenspezifische Normen. Erklaere die Vermutungswirkung (Presumption of Conformity).`,
+
+	SectionDeclarationConformity: `Erstelle eine EU-Konformitaetserklaerung nach EU-Maschinenverordnung 2023/1230 Anhang IV. Enthalten sein muessen: 1) Hersteller-Angaben, 2) Produktidentifikation, 3) Angewandte Richtlinien und Verordnungen, 4) Angewandte Normen, 5) Bevollmaechtigter, 6) Ort, Datum, Unterschrift. Formales Dokument-Layout.`,
+
+	SectionAIIntendedPurpose: `Beschreibe den bestimmungsgemaessen Zweck des KI-Systems gemaess AI Act Art. 13 (Transparenzpflichten). Enthalten sein sollen: 1) Zweckbestimmung, 2) Einsatzbereich und -grenzen, 3) Zielgruppe, 4) Vorhersehbarer Fehlgebrauch, 5) Leistungskennzahlen, 6) Einschraenkungen und bekannte Risiken.`,
+
+	SectionAIModelDescription: `Beschreibe das KI-Modell, die Trainingsdaten und die Architektur gemaess AI Act Anhang IV. Enthalten: 1) Modelltyp und Architektur, 2) Trainingsdaten (Herkunft, Umfang, Qualitaet), 3) Validierungsmethodik, 4) Leistungsmetriken, 5) Bekannte Verzerrungen (Bias), 6) Energie-/Ressourcenverbrauch.`,
+
+	SectionAIRiskManagement: `Erstelle eine Beschreibung des KI-Risikomanagementsystems gemaess AI Act Art. 9. Gliederung: 1) Risikomanagement-Prozess, 2) Identifizierte Risiken fuer Gesundheit/Sicherheit/Grundrechte, 3) Risikomindernde Massnahmen, 4) Restrisiken, 5) Ueberwachungs- und Aktualisierungsverfahren.`,
+
+	SectionAIHumanOversight: `Beschreibe die Massnahmen zur menschlichen Aufsicht (Human Oversight) gemaess AI Act Art. 14. Enthalten: 1) Aufsichtskonzept, 2) Rollen und Verantwortlichkeiten, 3) Eingriffsmoglichkeiten, 4) Uebersteuern/Abschalten, 5) Schulungsanforderungen, 6) Informationspflichten an Nutzer.`,
+
+	SectionComponentList: `Erstelle eine detaillierte Komponentenliste fuer die technische Dokumentation. Pro Komponente: Name, Typ, Version, Beschreibung, Sicherheitsrelevanz, Vernetzungsstatus. Kennzeichne sicherheitsrelevante und vernetzte Komponenten besonders. Gruppiere nach Komponententyp.`,
+
+	SectionClassificationReport: `Erstelle einen Klassifizierungsbericht, der die regulatorische Einordnung des Produkts zusammenfasst. Pro Verordnung (MVO, AI Act, CRA, NIS2): Klassifizierungsergebnis, Risikoklasse, Begruendung, daraus resultierende Anforderungen. Bewerte die Gesamtkonformitaetslage.`,
+
+	SectionMitigationReport: `Erstelle einen Massnahmenbericht (Mitigation Report) fuer die technische Dokumentation. Gliederung nach 3-Stufen-Methode: 1) Inhaerent sichere Konstruktion (Design), 2) Technische Schutzmassnahmen (Protective), 3) Benutzerinformation (Information). Pro Massnahme: Status, Verifikation, zugeordnete Gefaehrdung.`,
+
+	SectionVerificationReport: `Erstelle einen Verifikationsbericht ueber alle durchgefuehrten Pruef- und Nachweisverfahren. Enthalten: 1) Verifikationsplan-Uebersicht, 2) Durchgefuehrte Pruefungen nach Methode, 3) Ergebnisse und Bewertung, 4) Offene Verifikationen, 5) Gesamtstatus der Konformitaetsnachweise.`,
+
+	SectionEvidenceIndex: `Erstelle ein Nachweisverzeichnis (Evidence Index) fuer die technische Dokumentation. Liste alle vorhandenen Nachweisdokumente auf: Dateiname, Beschreibung, zugeordnete Massnahme, Dokumenttyp. Identifiziere fehlende Nachweise und empfehle Ergaenzungen.`,
+
+	SectionInstructionsForUse: `Erstelle eine Gliederung fuer die Betriebsanleitung gemaess EU-Maschinenverordnung 2023/1230 Anhang III Abschnitt 1.7.4. Enthalten: 1) Bestimmungsgemaesse Verwendung, 2) Inbetriebnahme, 3) Sicherer Betrieb, 4) Wartung, 5) Restrisiken und Warnhinweise, 6) Ausserbetriebnahme. Beruecksichtige identifizierte Gefaehrdungen.`,
+
+	SectionMonitoringPlan: `Erstelle einen Post-Market-Monitoring-Plan fuer das Produkt. Enthalten: 1) Ueberwachungsziele, 2) Datenquellen (Kundenfeedback, Vorfaelle, Updates), 3) Ueberwachungsintervalle, 4) Eskalationsverfahren, 5) Dokumentationspflichten, 6) Verantwortlichkeiten. Beruecksichtige AI Act Art. 72 (Post-Market Monitoring) falls KI-Komponenten vorhanden.`,
+}
+
+// ============================================================================
+// RAG query mapping
+// ============================================================================
+
+func buildRAGQuery(sectionType string) string {
+	ragQueries := map[string]string{
+		SectionRiskAssessmentReport:  "Risikobeurteilung ISO 12100 Risikobewertung Maschine Gefaehrdungsanalyse",
+		SectionHazardLogCombined:     "Gefaehrdungsprotokoll Hazard Log Risikoanalyse Gefaehrdungsidentifikation",
+		SectionGeneralDescription:    "Maschinenbeschreibung technische Dokumentation bestimmungsgemaesse Verwendung",
+		SectionEssentialRequirements: "grundlegende Anforderungen EHSR Maschinenverordnung Anhang III Sicherheitsanforderungen",
+		SectionDesignSpecifications:  "Konstruktionsdaten Spezifikationen Systemarchitektur technische Dokumentation",
+		SectionTestReports:           "Pruefberichte Verifikation Validierung Konformitaetsbewertung Testberichte",
+		SectionStandardsApplied:      "harmonisierte Normen ISO 12100 ISO 13849 IEC 62443 Vermutungswirkung",
+		SectionDeclarationConformity: "EU-Konformitaetserklaerung Maschinenverordnung 2023/1230 Anhang IV CE-Kennzeichnung",
+		SectionAIIntendedPurpose:     "bestimmungsgemaesser Zweck KI-System AI Act Art. 13 Transparenz Intended Purpose",
+		SectionAIModelDescription:    "KI-Modell Trainingsdaten Architektur AI Act Anhang IV technische Dokumentation",
+		SectionAIRiskManagement:      "KI-Risikomanagementsystem AI Act Art. 9 Risikomanagement kuenstliche Intelligenz",
+		SectionAIHumanOversight:      "menschliche Aufsicht Human Oversight AI Act Art. 14 Kontrolle KI-System",
+		SectionComponentList:         "Komponentenliste Systemkomponenten sicherheitsrelevante Bauteile technische Dokumentation",
+		SectionClassificationReport:  "regulatorische Klassifizierung Risikoklasse AI Act CRA Maschinenverordnung",
+		SectionMitigationReport:      "Risikomindernde Massnahmen 3-Stufen-Methode ISO 12100 Schutzmassnahmen",
+		SectionVerificationReport:    "Verifikation Validierung Pruefnachweis Konformitaetsbewertung Pruefprotokoll",
+		SectionEvidenceIndex:         "Nachweisdokumente Evidence Konformitaetsnachweis Dokumentenindex",
+		SectionInstructionsForUse:    "Betriebsanleitung Benutzerinformation Maschinenverordnung Abschnitt 1.7.4 Sicherheitshinweise",
+		SectionMonitoringPlan:        "Post-Market-Monitoring Ueberwachungsplan AI Act Art. 72 Marktbeobachtung",
+	}
+
+	if q, ok := ragQueries[sectionType]; ok {
+		return q
+	}
+	return "CE-Konformitaet technische Dokumentation Maschinenverordnung AI Act"
+}
+
+// ============================================================================
+// BuildSectionContext — loads all project data + RAG context
+// ============================================================================
+
+// BuildSectionContext loads project data and RAG context for a given section type.
+func (g *TechFileGenerator) BuildSectionContext(ctx context.Context, projectID uuid.UUID, sectionType string) (*SectionGenerationContext, error) {
+	// Load project
+	project, err := g.store.GetProject(ctx, projectID)
+	if err != nil {
+		return nil, fmt.Errorf("load project: %w", err)
+	}
+	if project == nil {
+		return nil, fmt.Errorf("project %s not found", projectID)
+	}
+
+	// Load components
+	components, err := g.store.ListComponents(ctx, projectID)
+	if err != nil {
+		return nil, fmt.Errorf("load components: %w", err)
+	}
+
+	// Load hazards
+	hazards, err := g.store.ListHazards(ctx, projectID)
+	if err != nil {
+		return nil, fmt.Errorf("load hazards: %w", err)
+	}
+
+	// Load assessments and mitigations per hazard
+	assessments := make(map[uuid.UUID][]RiskAssessment)
+	mitigations := make(map[uuid.UUID][]Mitigation)
+	for _, h := range hazards {
+		a, err := g.store.ListAssessments(ctx, h.ID)
+		if err != nil {
+			return nil, fmt.Errorf("load assessments for hazard %s: %w", h.ID, err)
+		}
+		assessments[h.ID] = a
+
+		m, err := g.store.ListMitigations(ctx, h.ID)
+		if err != nil {
+			return nil, fmt.Errorf("load mitigations for hazard %s: %w", h.ID, err)
+		}
+		mitigations[h.ID] = m
+	}
+
+	// Load classifications
+	classifications, err := g.store.GetClassifications(ctx, projectID)
+	if err != nil {
+		return nil, fmt.Errorf("load classifications: %w", err)
+	}
+
+	// Load evidence
+	evidence, err := g.store.ListEvidence(ctx, projectID)
+	if err != nil {
+		return nil, fmt.Errorf("load evidence: %w", err)
+	}
+
+	// Perform RAG search for section-specific context
+	ragContext := ""
+	if g.ragClient != nil {
+		ragQuery := buildRAGQuery(sectionType)
+		results, ragErr := g.ragClient.SearchCollection(ctx, "bp_iace_libraries", ragQuery, nil, 5)
+		if ragErr == nil && len(results) > 0 {
+			var ragParts []string
+			for _, r := range results {
+				entry := fmt.Sprintf("[%s] %s", r.RegulationShort, truncateForPrompt(r.Text, 400))
+				ragParts = append(ragParts, entry)
+			}
+			ragContext = strings.Join(ragParts, "\n\n")
+		}
+		// RAG failure is non-fatal — we proceed without context
+	}
+
+	return &SectionGenerationContext{
+		Project:         project,
+		Components:      components,
+		Hazards:         hazards,
+		Assessments:     assessments,
+		Mitigations:     mitigations,
+		Classifications: classifications,
+		Evidence:        evidence,
+		RAGContext:       ragContext,
+	}, nil
+}
+
+// ============================================================================
+// GenerateSection — main entry point
+// ============================================================================
+
+// GenerateSection generates the content for a technical file section using LLM.
+// If LLM is unavailable, returns an enhanced placeholder with project data.
+func (g *TechFileGenerator) GenerateSection(ctx context.Context, projectID uuid.UUID, sectionType string) (string, error) {
+	sctx, err := g.BuildSectionContext(ctx, projectID, sectionType)
+	if err != nil {
+		return "", fmt.Errorf("build section context: %w", err)
+	}
+
+	// Build prompts
+	systemPrompt := getSystemPrompt(sectionType)
+	userPrompt := buildUserPrompt(sctx, sectionType)
+
+	// Attempt LLM generation
+	resp, err := g.llmRegistry.Chat(ctx, &llm.ChatRequest{
+		Messages: []llm.Message{
+			{Role: "system", Content: systemPrompt},
+			{Role: "user", Content: userPrompt},
+		},
+		Temperature: 0.15,
+		MaxTokens:   4096,
+	})
+	if err != nil {
+		// LLM unavailable — return structured fallback with real project data
+		return buildFallbackContent(sctx, sectionType), nil
+	}
+
+	return resp.Message.Content, nil
+}
+
+// ============================================================================
+// Prompt builders
+// ============================================================================
+
+func getSystemPrompt(sectionType string) string {
+	if prompt, ok := sectionSystemPrompts[sectionType]; ok {
+		return prompt
+	}
+	return "Du bist CE-Experte fuer technische Dokumentation. Erstelle den angeforderten Abschnitt der technischen Dokumentation basierend auf den bereitgestellten Projektdaten. Schreibe auf Deutsch, verwende Fachterminologie und beziehe dich auf die konkreten Daten."
+}
+
+func buildUserPrompt(sctx *SectionGenerationContext, sectionType string) string {
+	var b strings.Builder
+
+	if sctx == nil || sctx.Project == nil {
+		b.WriteString("## Maschine / System\n\n- Keine Projektdaten vorhanden.\n\n")
+		return b.String()
+	}
+
+	// Machine info — always included
+	b.WriteString("## Maschine / System\n\n")
+	b.WriteString(fmt.Sprintf("- **Name:** %s\n", sctx.Project.MachineName))
+	b.WriteString(fmt.Sprintf("- **Typ:** %s\n", sctx.Project.MachineType))
+	b.WriteString(fmt.Sprintf("- **Hersteller:** %s\n", sctx.Project.Manufacturer))
+	if sctx.Project.Description != "" {
+		b.WriteString(fmt.Sprintf("- **Beschreibung:** %s\n", sctx.Project.Description))
+	}
+	if sctx.Project.CEMarkingTarget != "" {
+		b.WriteString(fmt.Sprintf("- **CE-Kennzeichnungsziel:** %s\n", sctx.Project.CEMarkingTarget))
+	}
+	if sctx.Project.NarrativeText != "" {
+		b.WriteString(fmt.Sprintf("\n**Projektbeschreibung:** %s\n", truncateForPrompt(sctx.Project.NarrativeText, 500)))
+	}
+	b.WriteString("\n")
+
+	// Components — for most section types
+	if len(sctx.Components) > 0 && needsComponents(sectionType) {
+		b.WriteString("## Komponenten\n\n")
+		for i, c := range sctx.Components {
+			if i >= 20 {
+				b.WriteString(fmt.Sprintf("... und %d weitere Komponenten\n", len(sctx.Components)-20))
+				break
+			}
+			safety := ""
+			if c.IsSafetyRelevant {
+				safety = " [SICHERHEITSRELEVANT]"
+			}
+			networked := ""
+			if c.IsNetworked {
+				networked = " [VERNETZT]"
+			}
+			b.WriteString(fmt.Sprintf("- %s (Typ: %s)%s%s", c.Name, string(c.ComponentType), safety, networked))
+			if c.Description != "" {
+				b.WriteString(fmt.Sprintf(" — %s", truncateForPrompt(c.Description, 100)))
+			}
+			b.WriteString("\n")
+		}
+		b.WriteString("\n")
+	}
+
+	// Hazards + assessments — for risk-related sections
+	if len(sctx.Hazards) > 0 && needsHazards(sectionType) {
+		b.WriteString("## Gefaehrdungen und Risikobewertungen\n\n")
+		for i, h := range sctx.Hazards {
+			if i >= 30 {
+				b.WriteString(fmt.Sprintf("... und %d weitere Gefaehrdungen\n", len(sctx.Hazards)-30))
+				break
+			}
+			b.WriteString(fmt.Sprintf("### %s\n", h.Name))
+			b.WriteString(fmt.Sprintf("- Kategorie: %s", h.Category))
+			if h.SubCategory != "" {
+				b.WriteString(fmt.Sprintf(" / %s", h.SubCategory))
+			}
+			b.WriteString("\n")
+			if h.LifecyclePhase != "" {
+				b.WriteString(fmt.Sprintf("- Lebenszyklusphase: %s\n", h.LifecyclePhase))
+			}
+			if h.Scenario != "" {
+				b.WriteString(fmt.Sprintf("- Szenario: %s\n", truncateForPrompt(h.Scenario, 150)))
+			}
+			if h.PossibleHarm != "" {
+				b.WriteString(fmt.Sprintf("- Moeglicher Schaden: %s\n", h.PossibleHarm))
+			}
+			if h.AffectedPerson != "" {
+				b.WriteString(fmt.Sprintf("- Betroffene Person: %s\n", h.AffectedPerson))
+			}
+			b.WriteString(fmt.Sprintf("- Status: %s\n", string(h.Status)))
+
+			// Latest assessment
+			if assessments, ok := sctx.Assessments[h.ID]; ok && len(assessments) > 0 {
+				a := assessments[len(assessments)-1] // latest
+				b.WriteString(fmt.Sprintf("- Bewertung: S=%d E=%d P=%d → Risiko=%.1f (%s) %s\n",
+					a.Severity, a.Exposure, a.Probability,
+					a.ResidualRisk, string(a.RiskLevel),
+					acceptableLabel(a.IsAcceptable)))
+			}
+			b.WriteString("\n")
+		}
+	}
+
+	// Mitigations — for mitigation/verification sections
+	if needsMitigations(sectionType) {
+		designMeasures, protectiveMeasures, infoMeasures := groupMitigations(sctx)
+		if len(designMeasures)+len(protectiveMeasures)+len(infoMeasures) > 0 {
+			b.WriteString("## Risikomindernde Massnahmen (3-Stufen-Methode)\n\n")
+			writeMitigationGroup(&b, "Stufe 1: Inhaerent sichere Konstruktion (Design)", designMeasures)
+			writeMitigationGroup(&b, "Stufe 2: Technische Schutzmassnahmen (Protective)", protectiveMeasures)
+			writeMitigationGroup(&b, "Stufe 3: Benutzerinformation (Information)", infoMeasures)
+		}
+	}
+
+	// Classifications — for classification/standards sections
+	if len(sctx.Classifications) > 0 && needsClassifications(sectionType) {
+		b.WriteString("## Regulatorische Klassifizierungen\n\n")
+		for _, c := range sctx.Classifications {
+			b.WriteString(fmt.Sprintf("- **%s:** %s (Risiko: %s)\n",
+				string(c.Regulation), c.ClassificationResult, string(c.RiskLevel)))
+			if c.Reasoning != "" {
+				b.WriteString(fmt.Sprintf("  Begruendung: %s\n", truncateForPrompt(c.Reasoning, 200)))
+			}
+		}
+		b.WriteString("\n")
+	}
+
+	// Evidence — for evidence/verification sections
+	if len(sctx.Evidence) > 0 && needsEvidence(sectionType) {
+		b.WriteString("## Vorhandene Nachweise\n\n")
+		for i, e := range sctx.Evidence {
+			if i >= 30 {
+				b.WriteString(fmt.Sprintf("... und %d weitere Nachweise\n", len(sctx.Evidence)-30))
+				break
+			}
+			b.WriteString(fmt.Sprintf("- %s", e.FileName))
+			if e.Description != "" {
+				b.WriteString(fmt.Sprintf(" — %s", truncateForPrompt(e.Description, 100)))
+			}
+			b.WriteString("\n")
+		}
+		b.WriteString("\n")
+	}
+
+	// RAG context — if available
+	if sctx.RAGContext != "" {
+		b.WriteString("## Relevante Rechtsgrundlagen (RAG)\n\n")
+		b.WriteString(sctx.RAGContext)
+		b.WriteString("\n\n")
+	}
+
+	// Instruction
+	b.WriteString("---\n\n")
+	b.WriteString("Erstelle den Abschnitt basierend auf den obigen Daten. Schreibe auf Deutsch, verwende Markdown-Formatierung und beziehe dich auf die konkreten Projektdaten.\n")
+
+	return b.String()
+}
+
+// ============================================================================
+// Section type → data requirements
+// ============================================================================
+
+func needsComponents(sectionType string) bool {
+	switch sectionType {
+	case SectionGeneralDescription, SectionDesignSpecifications, SectionComponentList,
+		SectionEssentialRequirements, SectionAIModelDescription, SectionAIIntendedPurpose,
+		SectionClassificationReport, SectionInstructionsForUse:
+		return true
+	}
+	return false
+}
+
+func needsHazards(sectionType string) bool {
+	switch sectionType {
+	case SectionRiskAssessmentReport, SectionHazardLogCombined, SectionEssentialRequirements,
+		SectionMitigationReport, SectionVerificationReport, SectionTestReports,
+		SectionAIRiskManagement, SectionInstructionsForUse, SectionMonitoringPlan:
+		return true
+	}
+	return false
+}
+
+func needsMitigations(sectionType string) bool {
+	switch sectionType {
+	case SectionRiskAssessmentReport, SectionMitigationReport, SectionVerificationReport,
+		SectionTestReports, SectionEssentialRequirements, SectionAIRiskManagement,
+		SectionAIHumanOversight, SectionInstructionsForUse:
+		return true
+	}
+	return false
+}
+
+func needsClassifications(sectionType string) bool {
+	switch sectionType {
+	case SectionClassificationReport, SectionEssentialRequirements, SectionStandardsApplied,
+		SectionDeclarationConformity, SectionAIIntendedPurpose, SectionAIRiskManagement,
+		SectionGeneralDescription:
+		return true
+	}
+	return false
+}
+
+func needsEvidence(sectionType string) bool {
+	switch sectionType {
+	case SectionEvidenceIndex, SectionVerificationReport, SectionTestReports,
+		SectionMitigationReport:
+		return true
+	}
+	return false
+}
+
+// ============================================================================
+// Mitigation grouping helper
+// ============================================================================
+
+func groupMitigations(sctx *SectionGenerationContext) (design, protective, info []Mitigation) {
+	for _, mits := range sctx.Mitigations {
+		for _, m := range mits {
+			switch m.ReductionType {
+			case ReductionTypeDesign:
+				design = append(design, m)
+			case ReductionTypeProtective:
+				protective = append(protective, m)
+			case ReductionTypeInformation:
+				info = append(info, m)
+			}
+		}
+	}
+	return
+}
+
+func writeMitigationGroup(b *strings.Builder, title string, measures []Mitigation) {
+	if len(measures) == 0 {
+		return
+	}
+	b.WriteString(fmt.Sprintf("### %s\n\n", title))
+	for i, m := range measures {
+		if i >= 20 {
+			b.WriteString(fmt.Sprintf("... und %d weitere Massnahmen\n", len(measures)-20))
+			break
+		}
+		b.WriteString(fmt.Sprintf("- **%s** [%s]", m.Name, string(m.Status)))
+		if m.VerificationMethod != "" {
+			b.WriteString(fmt.Sprintf(" — Verifikation: %s", string(m.VerificationMethod)))
+			if m.VerificationResult != "" {
+				b.WriteString(fmt.Sprintf(" (%s)", m.VerificationResult))
+			}
+		}
+		b.WriteString("\n")
+		if m.Description != "" {
+			b.WriteString(fmt.Sprintf("  %s\n", truncateForPrompt(m.Description, 150)))
+		}
+	}
+	b.WriteString("\n")
+}
+
+// ============================================================================
+// Fallback content (when LLM is unavailable)
+// ============================================================================
+
+func buildFallbackContent(sctx *SectionGenerationContext, sectionType string) string {
+	var b strings.Builder
+
+	b.WriteString("[Automatisch generiert — LLM nicht verfuegbar]\n\n")
+
+	sectionTitle := sectionDisplayName(sectionType)
+	b.WriteString(fmt.Sprintf("# %s\n\n", sectionTitle))
+
+	b.WriteString(fmt.Sprintf("**Maschine:** %s (%s)\n", sctx.Project.MachineName, sctx.Project.MachineType))
+	b.WriteString(fmt.Sprintf("**Hersteller:** %s\n", sctx.Project.Manufacturer))
+	if sctx.Project.Description != "" {
+		b.WriteString(fmt.Sprintf("**Beschreibung:** %s\n", sctx.Project.Description))
+	}
+	b.WriteString("\n")
+
+	// Section-specific data summaries
+	switch sectionType {
+	case SectionComponentList, SectionGeneralDescription, SectionDesignSpecifications:
+		if len(sctx.Components) > 0 {
+			b.WriteString("## Komponenten\n\n")
+			b.WriteString(fmt.Sprintf("Anzahl: %d\n\n", len(sctx.Components)))
+			for _, c := range sctx.Components {
+				safety := ""
+				if c.IsSafetyRelevant {
+					safety = " [SICHERHEITSRELEVANT]"
+				}
+				b.WriteString(fmt.Sprintf("- %s (Typ: %s)%s\n", c.Name, string(c.ComponentType), safety))
+			}
+			b.WriteString("\n")
+		}
+
+	case SectionRiskAssessmentReport, SectionHazardLogCombined:
+		b.WriteString("## Risikoueberblick\n\n")
+		b.WriteString(fmt.Sprintf("Anzahl Gefaehrdungen: %d\n\n", len(sctx.Hazards)))
+		riskCounts := countRiskLevels(sctx)
+		for level, count := range riskCounts {
+			b.WriteString(fmt.Sprintf("- %s: %d\n", level, count))
+		}
+		b.WriteString("\n")
+		for _, h := range sctx.Hazards {
+			b.WriteString(fmt.Sprintf("- **%s** (%s) — Status: %s\n", h.Name, h.Category, string(h.Status)))
+		}
+		b.WriteString("\n")
+
+	case SectionMitigationReport:
+		design, protective, info := groupMitigations(sctx)
+		total := len(design) + len(protective) + len(info)
+		b.WriteString("## Massnahmenueberblick\n\n")
+		b.WriteString(fmt.Sprintf("Gesamt: %d Massnahmen\n", total))
+		b.WriteString(fmt.Sprintf("- Design: %d\n- Schutzmassnahmen: %d\n- Benutzerinformation: %d\n\n", len(design), len(protective), len(info)))
+		writeFallbackMitigationList(&b, "Design", design)
+		writeFallbackMitigationList(&b, "Schutzmassnahmen", protective)
+		writeFallbackMitigationList(&b, "Benutzerinformation", info)
+
+	case SectionClassificationReport:
+		if len(sctx.Classifications) > 0 {
+			b.WriteString("## Klassifizierungen\n\n")
+			for _, c := range sctx.Classifications {
+				b.WriteString(fmt.Sprintf("- **%s:** %s (Risiko: %s)\n",
+					string(c.Regulation), c.ClassificationResult, string(c.RiskLevel)))
+			}
+			b.WriteString("\n")
+		}
+
+	case SectionEvidenceIndex:
+		b.WriteString("## Nachweisverzeichnis\n\n")
+		b.WriteString(fmt.Sprintf("Anzahl Nachweise: %d\n\n", len(sctx.Evidence)))
+		for _, e := range sctx.Evidence {
+			desc := e.Description
+			if desc == "" {
+				desc = "(keine Beschreibung)"
+			}
+			b.WriteString(fmt.Sprintf("- %s — %s\n", e.FileName, desc))
+		}
+		b.WriteString("\n")
+
+	default:
+		// Generic fallback data summary
+		b.WriteString(fmt.Sprintf("- Komponenten: %d\n", len(sctx.Components)))
+		b.WriteString(fmt.Sprintf("- Gefaehrdungen: %d\n", len(sctx.Hazards)))
+		b.WriteString(fmt.Sprintf("- Klassifizierungen: %d\n", len(sctx.Classifications)))
+		b.WriteString(fmt.Sprintf("- Nachweise: %d\n", len(sctx.Evidence)))
+		b.WriteString("\n")
+	}
+
+	b.WriteString("---\n")
+	b.WriteString("*Dieser Abschnitt wurde ohne LLM-Unterstuetzung erstellt und enthaelt nur eine Datenuebersicht. Bitte erneut generieren, wenn der LLM-Service verfuegbar ist.*\n")
+
+	return b.String()
+}
+
+func writeFallbackMitigationList(b *strings.Builder, title string, measures []Mitigation) {
+	if len(measures) == 0 {
+		return
+	}
+	b.WriteString(fmt.Sprintf("### %s\n\n", title))
+	for _, m := range measures {
+		b.WriteString(fmt.Sprintf("- %s [%s]\n", m.Name, string(m.Status)))
+	}
+	b.WriteString("\n")
+}
+
+// ============================================================================
+// Utility helpers
+// ============================================================================
+
+func countRiskLevels(sctx *SectionGenerationContext) map[string]int {
+	counts := make(map[string]int)
+	for _, h := range sctx.Hazards {
+		if assessments, ok := sctx.Assessments[h.ID]; ok && len(assessments) > 0 {
+			latest := assessments[len(assessments)-1]
+			counts[string(latest.RiskLevel)]++
+		}
+	}
+	return counts
+}
+
+func acceptableLabel(isAcceptable bool) string {
+	if isAcceptable {
+		return "[AKZEPTABEL]"
+	}
+	return "[NICHT AKZEPTABEL]"
+}
+
+func sectionDisplayName(sectionType string) string {
+	names := map[string]string{
+		SectionRiskAssessmentReport:  "Zusammenfassung der Risikobeurteilung",
+		SectionHazardLogCombined:     "Gefaehrdungsprotokoll (Hazard Log)",
+		SectionGeneralDescription:    "Allgemeine Maschinenbeschreibung",
+		SectionEssentialRequirements: "Grundlegende Anforderungen (EHSR)",
+		SectionDesignSpecifications:  "Konstruktionsdaten und Spezifikationen",
+		SectionTestReports:           "Pruefberichte",
+		SectionStandardsApplied:      "Angewandte Normen",
+		SectionDeclarationConformity: "EU-Konformitaetserklaerung",
+		SectionAIIntendedPurpose:     "Bestimmungsgemaesser Zweck (KI)",
+		SectionAIModelDescription:    "KI-Modellbeschreibung",
+		SectionAIRiskManagement:      "KI-Risikomanagementsystem",
+		SectionAIHumanOversight:      "Menschliche Aufsicht (Human Oversight)",
+		SectionComponentList:         "Komponentenliste",
+		SectionClassificationReport:  "Klassifizierungsbericht",
+		SectionMitigationReport:      "Massnahmenbericht",
+		SectionVerificationReport:    "Verifikationsbericht",
+		SectionEvidenceIndex:         "Nachweisverzeichnis",
+		SectionInstructionsForUse:    "Betriebsanleitung (Gliederung)",
+		SectionMonitoringPlan:        "Post-Market-Monitoring-Plan",
+	}
+	if name, ok := names[sectionType]; ok {
+		return name
+	}
+	return sectionType
+}
+
+func truncateForPrompt(text string, maxLen int) string {
+	if len(text) <= maxLen {
+		return text
+	}
+	return text[:maxLen] + "..."
+}
diff --git a/ai-compliance-sdk/internal/iace/tech_file_generator_test.go b/ai-compliance-sdk/internal/iace/tech_file_generator_test.go
new file mode 100644
index 0000000..6a322a8
--- /dev/null
+++ b/ai-compliance-sdk/internal/iace/tech_file_generator_test.go
@@ -0,0 +1,521 @@
+package iace
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/google/uuid"
+)
+
+// ============================================================================
+// Test Helpers
+// ============================================================================
+
+// newTestSectionContext builds a SectionGenerationContext with realistic sample
+// data for a "Robot Arm XY-200" industrial robot project.
+func newTestSectionContext() *SectionGenerationContext {
+	projectID := uuid.New()
+	compSoftwareID := uuid.New()
+	compSensorID := uuid.New()
+	hazardHighID := uuid.New()
+	hazardLowID := uuid.New()
+
+	return &SectionGenerationContext{
+		Project: &Project{
+			ID:              projectID,
+			TenantID:        uuid.New(),
+			MachineName:     "Robot Arm XY-200",
+			MachineType:     "industrial_robot",
+			Manufacturer:    "TestCorp",
+			Description:     "6-axis industrial robot for automotive welding",
+			CEMarkingTarget: "2023/1230",
+			Status:          ProjectStatusHazardAnalysis,
+		},
+		Components: []Component{
+			{
+				ID:               compSoftwareID,
+				ProjectID:        projectID,
+				Name:             "SafetyPLC-500",
+				ComponentType:    ComponentTypeSoftware,
+				Version:          "3.2.1",
+				Description:      "Safety-rated programmable logic controller firmware",
+				IsSafetyRelevant: true,
+				IsNetworked:      true,
+			},
+			{
+				ID:               compSensorID,
+				ProjectID:        projectID,
+				Name:             "ProxSensor-LiDAR",
+				ComponentType:    ComponentTypeSensor,
+				Version:          "1.0.0",
+				Description:      "LiDAR proximity sensor for collision avoidance",
+				IsSafetyRelevant: false,
+				IsNetworked:      false,
+			},
+		},
+		Hazards: []Hazard{
+			{
+				ID:             hazardHighID,
+				ProjectID:      projectID,
+				ComponentID:    compSoftwareID,
+				Name:           "Software malfunction causing uncontrolled movement",
+				Description:    "Firmware fault leads to unpredictable arm trajectory",
+				Category:       "mechanical",
+				SubCategory:    "crushing",
+				Status:         HazardStatusAssessed,
+				LifecyclePhase: "normal_operation",
+				AffectedPerson: "operator",
+				PossibleHarm:   "Severe crushing injury to operator",
+			},
+			{
+				ID:             hazardLowID,
+				ProjectID:      projectID,
+				ComponentID:    compSensorID,
+				Name:           "Sensor drift causing delayed stop",
+				Description:    "Gradual sensor calibration loss reduces reaction time",
+				Category:       "electrical",
+				SubCategory:    "sensor_failure",
+				Status:         HazardStatusIdentified,
+				LifecyclePhase: "normal_operation",
+				AffectedPerson: "bystander",
+				PossibleHarm:   "Minor bruising",
+			},
+		},
+		Assessments: map[uuid.UUID][]RiskAssessment{
+			hazardHighID: {
+				{
+					ID:             uuid.New(),
+					HazardID:       hazardHighID,
+					Version:        1,
+					AssessmentType: AssessmentTypeInitial,
+					Severity:       5,
+					Exposure:       4,
+					Probability:    3,
+					Avoidance:      2,
+					InherentRisk:   120.0,
+					ResidualRisk:   85.0,
+					RiskLevel:      RiskLevelHigh,
+					IsAcceptable:   false,
+				},
+			},
+			hazardLowID: {
+				{
+					ID:             uuid.New(),
+					HazardID:       hazardLowID,
+					Version:        1,
+					AssessmentType: AssessmentTypeInitial,
+					Severity:       2,
+					Exposure:       3,
+					Probability:    2,
+					Avoidance:      4,
+					InherentRisk:   12.0,
+					ResidualRisk:   6.0,
+					RiskLevel:      RiskLevelLow,
+					IsAcceptable:   true,
+				},
+			},
+		},
+		Mitigations: map[uuid.UUID][]Mitigation{
+			hazardHighID: {
+				{
+					ID:            uuid.New(),
+					HazardID:      hazardHighID,
+					ReductionType: ReductionTypeDesign,
+					Name:          "Redundant safety controller",
+					Description:   "Dual-channel safety PLC with cross-monitoring",
+					Status:        MitigationStatusImplemented,
+				},
+				{
+					ID:            uuid.New(),
+					HazardID:      hazardHighID,
+					ReductionType: ReductionTypeProtective,
+					Name:          "Light curtain barrier",
+					Description:   "Type 4 safety light curtain around work envelope",
+					Status:        MitigationStatusVerified,
+				},
+			},
+			hazardLowID: {
+				{
+					ID:            uuid.New(),
+					HazardID:      hazardLowID,
+					ReductionType: ReductionTypeInformation,
+					Name:          "Calibration schedule warning",
+					Description:   "Automated alert when sensor calibration is overdue",
+					Status:        MitigationStatusPlanned,
+				},
+			},
+		},
+		Classifications: []RegulatoryClassification{
+			{
+				ID:                   uuid.New(),
+				ProjectID:            projectID,
+				Regulation:           RegulationMachineryRegulation,
+				ClassificationResult: "Annex I - High-Risk Machinery",
+				RiskLevel:            RiskLevelHigh,
+				Confidence:           0.92,
+			},
+		},
+		Evidence: []Evidence{
+			{
+				ID:          uuid.New(),
+				ProjectID:   projectID,
+				FileName:    "safety_plc_test_report.pdf",
+				Description: "Functional safety test report for SafetyPLC-500",
+			},
+		},
+		RAGContext: "",
+	}
+}
+
+// ============================================================================
+// Tests: buildUserPrompt
+// ============================================================================
+
+func TestBuildUserPrompt_RiskAssessmentReport(t *testing.T) {
+	sctx := newTestSectionContext()
+	prompt := buildUserPrompt(sctx, "risk_assessment_report")
+
+	// Must contain project identification
+	if !strings.Contains(prompt, "Robot Arm XY-200") {
+		t.Error("prompt should contain machine name 'Robot Arm XY-200'")
+	}
+	if !strings.Contains(prompt, "TestCorp") {
+		t.Error("prompt should contain manufacturer 'TestCorp'")
+	}
+
+	// Must reference hazard information
+	if !strings.Contains(prompt, "uncontrolled movement") || !strings.Contains(prompt, "Software malfunction") {
+		t.Error("prompt should contain hazard name or description for high-risk hazard")
+	}
+
+	// Must reference risk levels
+	if !strings.Contains(prompt, "high") && !strings.Contains(prompt, "High") && !strings.Contains(prompt, "HIGH") {
+		t.Error("prompt should reference the high risk level")
+	}
+}
+
+func TestBuildUserPrompt_ComponentList(t *testing.T) {
+	sctx := newTestSectionContext()
+	prompt := buildUserPrompt(sctx, "component_list")
+
+	// Must list component names
+	if !strings.Contains(prompt, "SafetyPLC-500") {
+		t.Error("prompt should contain component name 'SafetyPLC-500'")
+	}
+	if !strings.Contains(prompt, "ProxSensor-LiDAR") {
+		t.Error("prompt should contain component name 'ProxSensor-LiDAR'")
+	}
+
+	// Must reference component types
+	if !strings.Contains(prompt, "software") && !strings.Contains(prompt, "Software") {
+		t.Error("prompt should contain component type 'software'")
+	}
+	if !strings.Contains(prompt, "sensor") && !strings.Contains(prompt, "Sensor") {
+		t.Error("prompt should contain component type 'sensor'")
+	}
+}
+
+func TestBuildUserPrompt_EmptyProject(t *testing.T) {
+	sctx := &SectionGenerationContext{
+		Project:         nil,
+		Components:      nil,
+		Hazards:         nil,
+		Assessments:     nil,
+		Mitigations:     nil,
+		Classifications: nil,
+		Evidence:        nil,
+		RAGContext:       "",
+	}
+
+	// Should not panic on nil/empty data
+	prompt := buildUserPrompt(sctx, "general_description")
+	if prompt == "" {
+		t.Error("buildUserPrompt should return non-empty string even for empty context")
+	}
+}
+
+func TestBuildUserPrompt_MitigationReport(t *testing.T) {
+	sctx := newTestSectionContext()
+	prompt := buildUserPrompt(sctx, "mitigation_report")
+
+	// Must reference mitigation names
+	if !strings.Contains(prompt, "Redundant safety controller") {
+		t.Error("prompt should contain design mitigation 'Redundant safety controller'")
+	}
+	if !strings.Contains(prompt, "Light curtain barrier") {
+		t.Error("prompt should contain protective mitigation 'Light curtain barrier'")
+	}
+	if !strings.Contains(prompt, "Calibration schedule warning") {
+		t.Error("prompt should contain information mitigation 'Calibration schedule warning'")
+	}
+
+	// Must reference reduction types
+	hasDesign := strings.Contains(prompt, "design") || strings.Contains(prompt, "Design")
+	hasProtective := strings.Contains(prompt, "protective") || strings.Contains(prompt, "Protective")
+	hasInformation := strings.Contains(prompt, "information") || strings.Contains(prompt, "Information")
+	if !hasDesign {
+		t.Error("prompt should reference 'design' reduction type")
+	}
+	if !hasProtective {
+		t.Error("prompt should reference 'protective' reduction type")
+	}
+	if !hasInformation {
+		t.Error("prompt should reference 'information' reduction type")
+	}
+}
+
+func TestBuildUserPrompt_WithRAGContext(t *testing.T) {
+	sctx := newTestSectionContext()
+	sctx.RAGContext = "According to EN ISO 13849-1:2023, safety-related parts of control systems for machinery shall be designed and constructed using the principles of EN ISO 12100."
+
+	prompt := buildUserPrompt(sctx, "standards_applied")
+
+	if !strings.Contains(prompt, "EN ISO 13849-1") {
+		t.Error("prompt should include the RAG context referencing EN ISO 13849-1")
+	}
+	if !strings.Contains(prompt, "EN ISO 12100") {
+		t.Error("prompt should include the RAG context referencing EN ISO 12100")
+	}
+}
+
+func TestBuildUserPrompt_WithoutRAGContext(t *testing.T) {
+	sctx := newTestSectionContext()
+	sctx.RAGContext = ""
+
+	prompt := buildUserPrompt(sctx, "standards_applied")
+
+	// Should still produce a valid prompt without RAG context
+	if prompt == "" {
+		t.Error("prompt should be non-empty even without RAG context")
+	}
+	// Should still contain the project info
+	if !strings.Contains(prompt, "Robot Arm XY-200") {
+		t.Error("prompt should still contain machine name when no RAG context")
+	}
+}
+
+// ============================================================================
+// Tests: buildRAGQuery
+// ============================================================================
+
+func TestBuildRAGQuery_AllSectionTypes(t *testing.T) {
+	sectionTypes := []string{
+		"risk_assessment_report",
+		"hazard_log_combined",
+		"general_description",
+		"essential_requirements",
+		"design_specifications",
+		"test_reports",
+		"standards_applied",
+		"declaration_of_conformity",
+		"ai_intended_purpose",
+		"ai_model_description",
+		"ai_risk_management",
+		"ai_human_oversight",
+		"component_list",
+		"classification_report",
+		"mitigation_report",
+		"verification_report",
+		"evidence_index",
+		"instructions_for_use",
+		"monitoring_plan",
+	}
+
+	for _, st := range sectionTypes {
+		t.Run(st, func(t *testing.T) {
+			q := buildRAGQuery(st)
+			if q == "" {
+				t.Errorf("buildRAGQuery(%q) returned empty string", st)
+			}
+			// Each query should be at least a few words long to be useful
+			if len(q) < 10 {
+				t.Errorf("buildRAGQuery(%q) returned suspiciously short query: %q", st, q)
+			}
+		})
+	}
+}
+
+func TestBuildRAGQuery_UnknownSectionType(t *testing.T) {
+	q := buildRAGQuery("nonexistent_section_type")
+	// Should return a generic fallback query rather than an empty string
+	// (the function needs some query to send to RAG even for unknown types)
+	if q == "" {
+		t.Log("buildRAGQuery returned empty for unknown section type (may be acceptable if caller handles this)")
+	}
+}
+
+func TestBuildRAGQuery_QueriesAreDifferent(t *testing.T) {
+	// Different section types should produce different queries for targeted retrieval
+	q1 := buildRAGQuery("risk_assessment_report")
+	q2 := buildRAGQuery("declaration_of_conformity")
+	q3 := buildRAGQuery("monitoring_plan")
+
+	if q1 == q2 {
+		t.Error("risk_assessment_report and declaration_of_conformity should have different RAG queries")
+	}
+	if q2 == q3 {
+		t.Error("declaration_of_conformity and monitoring_plan should have different RAG queries")
+	}
+	if q1 == q3 {
+		t.Error("risk_assessment_report and monitoring_plan should have different RAG queries")
+	}
+}
+
+// ============================================================================
+// Tests: sectionSystemPrompts
+// ============================================================================
+
+func TestSectionSystemPrompts_Coverage(t *testing.T) {
+	requiredTypes := []string{
+		"risk_assessment_report",
+		"hazard_log_combined",
+		"general_description",
+		"essential_requirements",
+		"design_specifications",
+		"test_reports",
+		"standards_applied",
+		"declaration_of_conformity",
+		"component_list",
+		"classification_report",
+		"mitigation_report",
+		"verification_report",
+		"evidence_index",
+		"instructions_for_use",
+		"monitoring_plan",
+	}
+
+	for _, st := range requiredTypes {
+		t.Run(st, func(t *testing.T) {
+			prompt, ok := sectionSystemPrompts[st]
+			if !ok {
+				t.Errorf("sectionSystemPrompts missing entry for %q", st)
+				return
+			}
+			if prompt == "" {
+				t.Errorf("sectionSystemPrompts[%q] is empty", st)
+			}
+			// System prompts should contain meaningful instruction text
+			if len(prompt) < 50 {
+				t.Errorf("sectionSystemPrompts[%q] is suspiciously short (%d chars)", st, len(prompt))
+			}
+		})
+	}
+}
+
+func TestSectionSystemPrompts_ContainRoleInstruction(t *testing.T) {
+	// Each system prompt should instruct the LLM about its role as a compliance expert.
+	// Prompts are in German, so check for both German and English keywords.
+	keywords := []string{
+		"expert", "engineer", "compliance", "technical", "documentation", "safety",
+		"generate", "write", "create", "produce",
+		// German equivalents
+		"experte", "ingenieur", "erstelle", "beschreibe", "dokumentation", "sicherheit",
+		"risikobeurteilung", "konformit", "norm", "verordnung", "richtlinie",
+		"gefaehrdung", "massnahm", "verifikation", "uebersicht", "protokoll",
+		"abschnitt", "bericht", "maschin",
+	}
+	for st, prompt := range sectionSystemPrompts {
+		t.Run(st, func(t *testing.T) {
+			lower := strings.ToLower(prompt)
+			found := false
+			for _, kw := range keywords {
+				if strings.Contains(lower, kw) {
+					found = true
+					break
+				}
+			}
+			if !found {
+				t.Errorf("sectionSystemPrompts[%q] does not appear to contain a role or task instruction", st)
+			}
+		})
+	}
+}
+
+// ============================================================================
+// Tests: buildUserPrompt — additional section types
+// ============================================================================
+
+func TestBuildUserPrompt_ClassificationReport(t *testing.T) {
+	sctx := newTestSectionContext()
+	prompt := buildUserPrompt(sctx, "classification_report")
+
+	// Must reference classification data
+	if !strings.Contains(prompt, "machinery_regulation") && !strings.Contains(prompt, "Machinery") && !strings.Contains(prompt, "machinery") {
+		t.Error("prompt should reference the machinery regulation classification")
+	}
+}
+
+func TestBuildUserPrompt_EvidenceIndex(t *testing.T) {
+	sctx := newTestSectionContext()
+	prompt := buildUserPrompt(sctx, "evidence_index")
+
+	// Must reference evidence files
+	if !strings.Contains(prompt, "safety_plc_test_report.pdf") {
+		t.Error("prompt should reference evidence file name 'safety_plc_test_report.pdf'")
+	}
+}
+
+func TestBuildUserPrompt_GeneralDescription(t *testing.T) {
+	sctx := newTestSectionContext()
+	prompt := buildUserPrompt(sctx, "general_description")
+
+	// Must contain machine description
+	if !strings.Contains(prompt, "Robot Arm XY-200") {
+		t.Error("prompt should contain machine name")
+	}
+	if !strings.Contains(prompt, "industrial_robot") && !strings.Contains(prompt, "industrial robot") {
+		t.Error("prompt should contain machine type")
+	}
+	if !strings.Contains(prompt, "automotive welding") && !strings.Contains(prompt, "6-axis") {
+		t.Error("prompt should reference machine description content")
+	}
+}
+
+func TestBuildUserPrompt_DeclarationOfConformity(t *testing.T) {
+	sctx := newTestSectionContext()
+	prompt := buildUserPrompt(sctx, "declaration_of_conformity")
+
+	// Declaration needs manufacturer and CE target
+	if !strings.Contains(prompt, "TestCorp") {
+		t.Error("prompt should contain manufacturer for declaration of conformity")
+	}
+	if !strings.Contains(prompt, "2023/1230") && !strings.Contains(prompt, "CE") && !strings.Contains(prompt, "ce_marking") {
+		t.Error("prompt should reference CE marking target or regulation for declaration")
+	}
+}
+
+func TestBuildUserPrompt_MultipleHazardAssessments(t *testing.T) {
+	sctx := newTestSectionContext()
+
+	// Find the high-risk hazard ID from the assessments map
+	var highHazardID uuid.UUID
+	for hid, assessments := range sctx.Assessments {
+		if len(assessments) > 0 && assessments[0].RiskLevel == RiskLevelHigh {
+			highHazardID = hid
+			break
+		}
+	}
+
+	if highHazardID != uuid.Nil {
+		// Add a second assessment version (post-mitigation) for the high-risk hazard
+		sctx.Assessments[highHazardID] = append(sctx.Assessments[highHazardID], RiskAssessment{
+			ID:             uuid.New(),
+			HazardID:       highHazardID,
+			Version:        2,
+			AssessmentType: AssessmentTypePostMitigation,
+			Severity:       5,
+			Exposure:       4,
+			Probability:    1,
+			Avoidance:      4,
+			InherentRisk:   120.0,
+			ResidualRisk:   20.0,
+			RiskLevel:      RiskLevelMedium,
+			IsAcceptable:   true,
+		})
+	}
+
+	prompt := buildUserPrompt(sctx, "risk_assessment_report")
+	if prompt == "" {
+		t.Error("prompt should not be empty with multiple assessments")
+	}
+}
diff --git a/ai-compliance-sdk/internal/iace/user_journey_test.go b/ai-compliance-sdk/internal/iace/user_journey_test.go
new file mode 100644
index 0000000..3e4d6bd
--- /dev/null
+++ b/ai-compliance-sdk/internal/iace/user_journey_test.go
@@ -0,0 +1,487 @@
+package iace
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// buildFullValidContext returns a CompletenessContext where all required gates pass
+// and the project is ready for CE export.
+func buildFullValidContext() *CompletenessContext {
+	projectID := uuid.New()
+	componentID1 := uuid.New()
+	componentID2 := uuid.New()
+	hazardID1 := uuid.New()
+	hazardID2 := uuid.New()
+	hazardID3 := uuid.New()
+	mitigationID1 := uuid.New()
+	mitigationID2 := uuid.New()
+	mitigationID3 := uuid.New()
+	now := time.Now()
+
+	metadata, _ := json.Marshal(map[string]interface{}{
+		"operating_limits":   "Temperature: -10 to 50C, Humidity: 10-90% RH",
+		"foreseeable_misuse": "Use without protective equipment, exceeding load capacity",
+	})
+
+	return &CompletenessContext{
+		Project: &Project{
+			ID:              projectID,
+			TenantID:        uuid.New(),
+			MachineName:     "CNC-Fraese ProLine 5000",
+			MachineType:     "cnc_milling_machine",
+			Manufacturer:    "BreakPilot Maschinenbau GmbH",
+			Description:     "5-Achsen CNC-Fraesmaschine fuer Praezisionsfertigung im Metallbau",
+			Status:          ProjectStatusTechFile,
+			CEMarkingTarget: "2023/1230",
+			Metadata:        metadata,
+			CreatedAt:       now,
+			UpdatedAt:       now,
+		},
+		Components: []Component{
+			{
+				ID:               componentID1,
+				ProjectID:        projectID,
+				Name:             "Spindelantrieb",
+				ComponentType:    ComponentTypeMechanical,
+				IsSafetyRelevant: true,
+				Description:      "Hauptspindelantrieb mit Drehzahlregelung",
+				CreatedAt:        now,
+				UpdatedAt:        now,
+			},
+			{
+				ID:               componentID2,
+				ProjectID:        projectID,
+				Name:             "SPS Steuerung",
+				ComponentType:    ComponentTypeController,
+				IsSafetyRelevant: false,
+				IsNetworked:      true,
+				Description:      "Programmierbare Steuerung fuer Achsenbewegung",
+				CreatedAt:        now,
+				UpdatedAt:        now,
+			},
+		},
+		Classifications: []RegulatoryClassification{
+			{ID: uuid.New(), ProjectID: projectID, Regulation: RegulationAIAct, ClassificationResult: "Not applicable", RiskLevel: RiskLevelNegligible, Confidence: 0.95, CreatedAt: now, UpdatedAt: now},
+			{ID: uuid.New(), ProjectID: projectID, Regulation: RegulationMachineryRegulation, ClassificationResult: "Annex I", RiskLevel: RiskLevelHigh, Confidence: 0.9, CreatedAt: now, UpdatedAt: now},
+			{ID: uuid.New(), ProjectID: projectID, Regulation: RegulationNIS2, ClassificationResult: "Not in scope", RiskLevel: RiskLevelLow, Confidence: 0.85, CreatedAt: now, UpdatedAt: now},
+			{ID: uuid.New(), ProjectID: projectID, Regulation: RegulationCRA, ClassificationResult: "Default category", RiskLevel: RiskLevelMedium, Confidence: 0.88, CreatedAt: now, UpdatedAt: now},
+		},
+		Hazards: []Hazard{
+			{ID: hazardID1, ProjectID: projectID, ComponentID: componentID1, Name: "Quetschgefahr Spindel", Category: "mechanical", Description: "Quetschgefahr beim Werkzeugwechsel", Status: HazardStatusMitigated, CreatedAt: now, UpdatedAt: now},
+			{ID: hazardID2, ProjectID: projectID, ComponentID: componentID1, Name: "Schnittverletzung", Category: "mechanical", Description: "Schnittverletzung durch rotierende Fraeser", Status: HazardStatusMitigated, CreatedAt: now, UpdatedAt: now},
+			{ID: hazardID3, ProjectID: projectID, ComponentID: componentID2, Name: "Elektrischer Schlag", Category: "electrical", Description: "Kontakt mit spannungsfuehrenden Teilen", Status: HazardStatusAccepted, CreatedAt: now, UpdatedAt: now},
+		},
+		Assessments: []RiskAssessment{
+			{ID: uuid.New(), HazardID: hazardID1, Version: 1, AssessmentType: AssessmentTypePostMitigation, Severity: 3, Exposure: 2, Probability: 2, InherentRisk: 12, ControlMaturity: 4, ControlCoverage: 0.85, TestEvidenceStrength: 0.8, CEff: 0.75, ResidualRisk: 3.0, RiskLevel: RiskLevelLow, IsAcceptable: true, AssessedBy: uuid.New(), CreatedAt: now},
+			{ID: uuid.New(), HazardID: hazardID2, Version: 1, AssessmentType: AssessmentTypePostMitigation, Severity: 2, Exposure: 2, Probability: 1, InherentRisk: 4, ControlMaturity: 3, ControlCoverage: 0.9, TestEvidenceStrength: 0.7, CEff: 0.8, ResidualRisk: 0.8, RiskLevel: RiskLevelNegligible, IsAcceptable: true, AssessedBy: uuid.New(), CreatedAt: now},
+			{ID: uuid.New(), HazardID: hazardID3, Version: 1, AssessmentType: AssessmentTypePostMitigation, Severity: 2, Exposure: 1, Probability: 1, InherentRisk: 2, ControlMaturity: 4, ControlCoverage: 0.95, TestEvidenceStrength: 0.9, CEff: 0.9, ResidualRisk: 0.2, RiskLevel: RiskLevelNegligible, IsAcceptable: true, AssessedBy: uuid.New(), CreatedAt: now},
+		},
+		Mitigations: []Mitigation{
+			{ID: mitigationID1, HazardID: hazardID1, ReductionType: ReductionTypeDesign, Name: "Schutzhaube mit Verriegelung", Status: MitigationStatusVerified, VerificationMethod: VerificationMethodTest, VerificationResult: "Bestanden", CreatedAt: now, UpdatedAt: now},
+			{ID: mitigationID2, HazardID: hazardID2, ReductionType: ReductionTypeProtective, Name: "Lichtschranke Arbeitsbereich", Status: MitigationStatusVerified, VerificationMethod: VerificationMethodInspection, VerificationResult: "Bestanden", CreatedAt: now, UpdatedAt: now},
+			{ID: mitigationID3, HazardID: hazardID3, ReductionType: ReductionTypeInformation, Name: "Warnhinweis Hochspannung", Status: MitigationStatusVerified, VerificationMethod: VerificationMethodReview, VerificationResult: "Bestanden", CreatedAt: now, UpdatedAt: now},
+		},
+		Evidence: []Evidence{
+			{ID: uuid.New(), ProjectID: projectID, MitigationID: &mitigationID1, FileName: "pruefbericht_schutzhaube.pdf", FilePath: "/evidence/pruefbericht_schutzhaube.pdf", FileHash: "sha256:abc123", FileSize: 524288, MimeType: "application/pdf", Description: "Pruefbericht Schutzhaubenverriegelung", UploadedBy: uuid.New(), CreatedAt: now},
+			{ID: uuid.New(), ProjectID: projectID, MitigationID: &mitigationID2, FileName: "lichtschranke_abnahme.pdf", FilePath: "/evidence/lichtschranke_abnahme.pdf", FileHash: "sha256:def456", FileSize: 1048576, MimeType: "application/pdf", Description: "Abnahmeprotokoll Lichtschranke", UploadedBy: uuid.New(), CreatedAt: now},
+		},
+		TechFileSections: []TechFileSection{
+			{ID: uuid.New(), ProjectID: projectID, SectionType: "risk_assessment_report", Title: "Risikobeurteilung nach ISO 12100", Content: "Vollstaendige Risikobeurteilung der CNC-Fraese...", Version: 1, Status: TechFileSectionStatusApproved, CreatedAt: now, UpdatedAt: now},
+			{ID: uuid.New(), ProjectID: projectID, SectionType: "hazard_log_combined", Title: "Gefaehrdungsprotokoll", Content: "Protokoll aller identifizierten Gefaehrdungen...", Version: 1, Status: TechFileSectionStatusApproved, CreatedAt: now, UpdatedAt: now},
+		},
+		HasAI:                    false,
+		PatternMatchingPerformed: true,
+	}
+}
+
+// findGate searches through a CompletenessResult for a gate with the given ID.
+// Returns the gate and true if found, zero-value gate and false otherwise.
+func findGate(result CompletenessResult, gateID string) (CompletenessGate, bool) {
+	for _, g := range result.Gates {
+		if g.ID == gateID {
+			return g, true
+		}
+	}
+	return CompletenessGate{}, false
+}
+
+// ============================================================================
+// Test 1: Full User Journey
+// ============================================================================
+
+func TestCEWorkflow_FullUserJourney(t *testing.T) {
+	ctx := buildFullValidContext()
+	checker := NewCompletenessChecker()
+
+	// Step 1: Verify completeness check passes all required gates
+	result := checker.Check(ctx)
+
+	if !result.CanExport {
+		t.Error("CanExport should be true for fully valid project")
+		for _, g := range result.Gates {
+			if g.Required && !g.Passed {
+				t.Errorf("  Required gate %s (%s) failed: %s", g.ID, g.Label, g.Details)
+			}
+		}
+	}
+
+	if result.PassedRequired != result.TotalRequired {
+		t.Errorf("PassedRequired = %d, TotalRequired = %d; want all required gates to pass",
+			result.PassedRequired, result.TotalRequired)
+	}
+
+	// All required gates should individually pass
+	for _, g := range result.Gates {
+		if g.Required && !g.Passed {
+			t.Errorf("Required gate %s (%s) did not pass: %s", g.ID, g.Label, g.Details)
+		}
+	}
+
+	// Step 2: Export PDF and verify output
+	exporter := NewDocumentExporter()
+
+	pdfData, err := exporter.ExportPDF(
+		ctx.Project,
+		ctx.TechFileSections,
+		ctx.Hazards,
+		ctx.Assessments,
+		ctx.Mitigations,
+		ctx.Classifications,
+	)
+	if err != nil {
+		t.Fatalf("ExportPDF returned error: %v", err)
+	}
+	if len(pdfData) == 0 {
+		t.Fatal("ExportPDF returned empty bytes")
+	}
+	if !bytes.HasPrefix(pdfData, []byte("%PDF-")) {
+		t.Errorf("PDF output does not start with %%PDF-, got first 10 bytes: %q", pdfData[:min(10, len(pdfData))])
+	}
+
+	// Step 3: Export Excel and verify output
+	xlsxData, err := exporter.ExportExcel(
+		ctx.Project,
+		ctx.TechFileSections,
+		ctx.Hazards,
+		ctx.Assessments,
+		ctx.Mitigations,
+	)
+	if err != nil {
+		t.Fatalf("ExportExcel returned error: %v", err)
+	}
+	if len(xlsxData) == 0 {
+		t.Fatal("ExportExcel returned empty bytes")
+	}
+	if !bytes.HasPrefix(xlsxData, []byte("PK")) {
+		t.Errorf("Excel output does not start with PK (zip signature), got first 4 bytes: %x", xlsxData[:min(4, len(xlsxData))])
+	}
+
+	// Step 4: Export Markdown and verify output contains section titles
+	mdData, err := exporter.ExportMarkdown(ctx.Project, ctx.TechFileSections)
+	if err != nil {
+		t.Fatalf("ExportMarkdown returned error: %v", err)
+	}
+	if len(mdData) == 0 {
+		t.Fatal("ExportMarkdown returned empty bytes")
+	}
+	mdContent := string(mdData)
+	for _, section := range ctx.TechFileSections {
+		if !strings.Contains(mdContent, section.Title) {
+			t.Errorf("Markdown output missing section title %q", section.Title)
+		}
+	}
+	if !strings.Contains(mdContent, ctx.Project.MachineName) {
+		t.Errorf("Markdown output missing project name %q", ctx.Project.MachineName)
+	}
+
+	// Step 5: Export DOCX and verify output
+	docxData, err := exporter.ExportDOCX(ctx.Project, ctx.TechFileSections)
+	if err != nil {
+		t.Fatalf("ExportDOCX returned error: %v", err)
+	}
+	if len(docxData) == 0 {
+		t.Fatal("ExportDOCX returned empty bytes")
+	}
+	if !bytes.HasPrefix(docxData, []byte("PK")) {
+		t.Errorf("DOCX output does not start with PK (zip signature), got first 4 bytes: %x", docxData[:min(4, len(docxData))])
+	}
+}
+
+// ============================================================================
+// Test 2: High Risk Not Acceptable blocks export
+// ============================================================================
+
+func TestCEWorkflow_HighRiskNotAcceptable(t *testing.T) {
+	ctx := buildFullValidContext()
+
+	// Override: make one hazard high-risk and not acceptable
+	hazardID := ctx.Hazards[0].ID
+	ctx.Assessments[0] = RiskAssessment{
+		ID:             uuid.New(),
+		HazardID:       hazardID,
+		Version:        2,
+		AssessmentType: AssessmentTypePostMitigation,
+		Severity:       5,
+		Exposure:       4,
+		Probability:    4,
+		InherentRisk:   80,
+		ControlMaturity: 2,
+		ControlCoverage: 0.3,
+		CEff:           0.2,
+		ResidualRisk:   64,
+		RiskLevel:      RiskLevelHigh,
+		IsAcceptable:   false,
+		AssessedBy:     uuid.New(),
+		CreatedAt:      time.Now(),
+	}
+
+	checker := NewCompletenessChecker()
+	result := checker.Check(ctx)
+
+	if result.CanExport {
+		t.Error("CanExport should be false when a high-risk hazard is not acceptable")
+	}
+
+	// Verify G24 (residual risk accepted) specifically fails
+	g24, found := findGate(result, "G24")
+	if !found {
+		t.Fatal("G24 gate not found in results")
+	}
+	if g24.Passed {
+		t.Error("G24 should fail when a hazard has RiskLevelHigh and IsAcceptable=false")
+	}
+}
+
+// ============================================================================
+// Test 3: Incomplete mitigations block export
+// ============================================================================
+
+func TestCEWorkflow_IncompleteMitigationsBlockExport(t *testing.T) {
+	ctx := buildFullValidContext()
+
+	// Override: set mitigations to planned status (not yet verified)
+	for i := range ctx.Mitigations {
+		ctx.Mitigations[i].Status = MitigationStatusPlanned
+	}
+
+	checker := NewCompletenessChecker()
+	result := checker.Check(ctx)
+
+	if result.CanExport {
+		t.Error("CanExport should be false when mitigations are in planned status")
+	}
+
+	// Verify G23 (mitigations verified) specifically fails
+	g23, found := findGate(result, "G23")
+	if !found {
+		t.Fatal("G23 gate not found in results")
+	}
+	if g23.Passed {
+		t.Error("G23 should fail when mitigations are still in planned status")
+	}
+}
+
+// ============================================================================
+// Test 4: Mitigation hierarchy warning (information-only still allows export)
+// ============================================================================
+
+func TestCEWorkflow_MitigationHierarchyWarning(t *testing.T) {
+	ctx := buildFullValidContext()
+
+	// Override: set all mitigations to information type only (no design or protective)
+	for i := range ctx.Mitigations {
+		ctx.Mitigations[i].ReductionType = ReductionTypeInformation
+		ctx.Mitigations[i].Status = MitigationStatusVerified
+	}
+
+	checker := NewCompletenessChecker()
+	result := checker.Check(ctx)
+
+	// Information-only mitigations are advisory; no gate blocks this scenario.
+	// The project should still be exportable.
+	if !result.CanExport {
+		t.Error("CanExport should be true even with information-only mitigations (advisory, not gated)")
+		for _, g := range result.Gates {
+			if g.Required && !g.Passed {
+				t.Errorf("  Required gate %s (%s) failed: %s", g.ID, g.Label, g.Details)
+			}
+		}
+	}
+
+	// Verify all required gates still pass
+	if result.PassedRequired != result.TotalRequired {
+		t.Errorf("PassedRequired = %d, TotalRequired = %d; want all required gates to pass with information-only mitigations",
+			result.PassedRequired, result.TotalRequired)
+	}
+}
+
+// ============================================================================
+// Test 5: AI components require extra tech file sections
+// ============================================================================
+
+func TestCEWorkflow_AIComponentsExtraSections(t *testing.T) {
+	checker := NewCompletenessChecker()
+
+	t.Run("AI without AI tech file sections fails G42", func(t *testing.T) {
+		ctx := buildFullValidContext()
+		ctx.HasAI = true
+		// Add AI Act classification (needed for G06 to pass with HasAI=true)
+		for i := range ctx.Classifications {
+			if ctx.Classifications[i].Regulation == RegulationAIAct {
+				ctx.Classifications[i].ClassificationResult = "High Risk"
+				ctx.Classifications[i].RiskLevel = RiskLevelHigh
+			}
+		}
+		// TechFileSections has risk_assessment_report and hazard_log_combined but no AI sections
+
+		result := checker.Check(ctx)
+
+		g42, found := findGate(result, "G42")
+		if !found {
+			t.Fatal("G42 gate not found in results")
+		}
+		if g42.Passed {
+			t.Error("G42 should fail when HasAI=true but AI tech file sections are missing")
+		}
+		if result.CanExport {
+			t.Error("CanExport should be false when G42 fails")
+		}
+	})
+
+	t.Run("AI with AI tech file sections passes G42", func(t *testing.T) {
+		ctx := buildFullValidContext()
+		ctx.HasAI = true
+		// Add AI Act classification
+		for i := range ctx.Classifications {
+			if ctx.Classifications[i].Regulation == RegulationAIAct {
+				ctx.Classifications[i].ClassificationResult = "High Risk"
+				ctx.Classifications[i].RiskLevel = RiskLevelHigh
+			}
+		}
+		// Add the required AI tech file sections
+		now := time.Now()
+		ctx.TechFileSections = append(ctx.TechFileSections,
+			TechFileSection{
+				ID:          uuid.New(),
+				ProjectID:   ctx.Project.ID,
+				SectionType: "ai_intended_purpose",
+				Title:       "KI-Zweckbestimmung",
+				Content:     "Bestimmungsgemaesse Verwendung des KI-Systems...",
+				Version:     1,
+				Status:      TechFileSectionStatusApproved,
+				CreatedAt:   now,
+				UpdatedAt:   now,
+			},
+			TechFileSection{
+				ID:          uuid.New(),
+				ProjectID:   ctx.Project.ID,
+				SectionType: "ai_model_description",
+				Title:       "KI-Modellbeschreibung",
+				Content:     "Beschreibung des verwendeten KI-Modells...",
+				Version:     1,
+				Status:      TechFileSectionStatusApproved,
+				CreatedAt:   now,
+				UpdatedAt:   now,
+			},
+		)
+
+		result := checker.Check(ctx)
+
+		g42, found := findGate(result, "G42")
+		if !found {
+			t.Fatal("G42 gate not found in results")
+		}
+		if !g42.Passed {
+			t.Errorf("G42 should pass when HasAI=true and both AI tech file sections are present; details: %s", g42.Details)
+		}
+		if !result.CanExport {
+			t.Error("CanExport should be true when all gates pass including G42 with AI sections")
+			for _, g := range result.Gates {
+				if g.Required && !g.Passed {
+					t.Errorf("  Required gate %s (%s) failed: %s", g.ID, g.Label, g.Details)
+				}
+			}
+		}
+	})
+}
+
+// ============================================================================
+// Test 6: Export with empty/minimal project data
+// ============================================================================
+
+func TestCEWorkflow_ExportEmptyProject(t *testing.T) {
+	exporter := NewDocumentExporter()
+
+	minimalProject := &Project{
+		ID:           uuid.New(),
+		TenantID:     uuid.New(),
+		MachineName:  "Leeres Testprojekt",
+		MachineType:  "test",
+		Manufacturer: "TestCorp",
+		Status:       ProjectStatusDraft,
+		CreatedAt:    time.Now(),
+		UpdatedAt:    time.Now(),
+	}
+
+	t.Run("PDF export with empty project succeeds", func(t *testing.T) {
+		data, err := exporter.ExportPDF(minimalProject, nil, nil, nil, nil, nil)
+		if err != nil {
+			t.Fatalf("ExportPDF returned error for empty project: %v", err)
+		}
+		if len(data) == 0 {
+			t.Fatal("ExportPDF returned empty bytes for empty project")
+		}
+		if !bytes.HasPrefix(data, []byte("%PDF-")) {
+			t.Errorf("PDF output does not start with %%PDF-, got first 10 bytes: %q", data[:min(10, len(data))])
+		}
+	})
+
+	t.Run("Excel export with empty project succeeds", func(t *testing.T) {
+		data, err := exporter.ExportExcel(minimalProject, nil, nil, nil, nil)
+		if err != nil {
+			t.Fatalf("ExportExcel returned error for empty project: %v", err)
+		}
+		if len(data) == 0 {
+			t.Fatal("ExportExcel returned empty bytes for empty project")
+		}
+		if !bytes.HasPrefix(data, []byte("PK")) {
+			t.Errorf("Excel output does not start with PK (zip signature), got first 4 bytes: %x", data[:min(4, len(data))])
+		}
+	})
+
+	t.Run("Markdown export with empty project succeeds", func(t *testing.T) {
+		data, err := exporter.ExportMarkdown(minimalProject, nil)
+		if err != nil {
+			t.Fatalf("ExportMarkdown returned error for empty project: %v", err)
+		}
+		if len(data) == 0 {
+			t.Fatal("ExportMarkdown returned empty bytes for empty project")
+		}
+		mdContent := string(data)
+		if !strings.Contains(mdContent, minimalProject.MachineName) {
+			t.Errorf("Markdown output missing project name %q", minimalProject.MachineName)
+		}
+		if !strings.Contains(mdContent, "#") {
+			t.Error("Markdown output missing header markers")
+		}
+	})
+
+	t.Run("DOCX export with empty project succeeds", func(t *testing.T) {
+		data, err := exporter.ExportDOCX(minimalProject, nil)
+		if err != nil {
+			t.Fatalf("ExportDOCX returned error for empty project: %v", err)
+		}
+		if len(data) == 0 {
+			t.Fatal("ExportDOCX returned empty bytes for empty project")
+		}
+		if !bytes.HasPrefix(data, []byte("PK")) {
+			t.Errorf("DOCX output does not start with PK (zip signature), got first 4 bytes: %x", data[:min(4, len(data))])
+		}
+	})
+}
diff --git a/developer-portal/app/api/iace/page.tsx b/developer-portal/app/api/iace/page.tsx
new file mode 100644
index 0000000..8ac71d1
--- /dev/null
+++ b/developer-portal/app/api/iace/page.tsx
@@ -0,0 +1,1008 @@
+'use client'
+
+import { DevPortalLayout, ApiEndpoint, CodeBlock, ParameterTable, InfoBox } from '@/components/DevPortalLayout'
+
+export default function IACEApiPage() {
+  return (
+    <DevPortalLayout
+      title="IACE API"
+      description="Industrial AI Compliance Engine — CE-Risikobewertung, Gefahrenanalyse und Technische Dokumentation"
+    >
+      <h2>Uebersicht</h2>
+      <p>
+        Die IACE (Industrial AI Compliance Engine) API ermoeglicht die vollstaendige
+        CE-Risikobewertung fuer Maschinen und Industrieprodukte. Sie deckt den gesamten
+        Compliance-Lebenszyklus ab:
+      </p>
+      <ul>
+        <li>Projektmanagement und Onboarding</li>
+        <li>Komponentenverwaltung und Regulatorische Klassifizierung</li>
+        <li>Gefahrenanalyse mit 102 Hazard-Patterns (ISO 12100)</li>
+        <li>4-Faktor-Risikobewertung (S/E/P/A)</li>
+        <li>3-Stufen-Massnahmenhierarchie (Design, Schutz, Information)</li>
+        <li>Verifizierungsplaene und Evidenz-Management</li>
+        <li>LLM-gestuetzte Technische Dokumentation (CE Technical File)</li>
+        <li>Monitoring und Audit Trail</li>
+      </ul>
+
+      <InfoBox type="info" title="Basis-Pfad">
+        Alle Endpoints verwenden den Basis-Pfad <code>/sdk/v1/iace</code>.
+        Authentifizierung erfolgt ueber Bearer Token im Authorization-Header.
+      </InfoBox>
+
+      {/* ============================================================ */}
+      {/* PROJECT MANAGEMENT                                           */}
+      {/* ============================================================ */}
+
+      <h2>Project Management</h2>
+      <p>Erstellen und verwalten Sie IACE-Projekte fuer einzelne Maschinen oder Produkte.</p>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects" description="Neues IACE-Projekt erstellen" />
+
+      <h3>Request Body</h3>
+      <ParameterTable
+        parameters={[
+          { name: 'machine_name', type: 'string', required: true, description: 'Name der Maschine / des Produkts' },
+          { name: 'machine_type', type: 'string', required: true, description: 'Maschinentyp (z.B. "CNC-Fraesmaschine", "Industrieroboter")' },
+          { name: 'manufacturer', type: 'string', required: false, description: 'Hersteller-Name' },
+          { name: 'description', type: 'string', required: false, description: 'Beschreibung des Produkts und seiner Einsatzzwecke' },
+        ]}
+      />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "machine_name": "RoboArm X500",
+    "machine_type": "Industrieroboter",
+    "manufacturer": "TechCorp GmbH",
+    "description": "6-Achsen-Industrieroboter fuer Montagearbeiten"
+  }'`}
+      </CodeBlock>
+
+      <h3>Response (201 Created)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "id": "proj_a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+    "machine_name": "RoboArm X500",
+    "machine_type": "Industrieroboter",
+    "manufacturer": "TechCorp GmbH",
+    "description": "6-Achsen-Industrieroboter fuer Montagearbeiten",
+    "status": "draft",
+    "completeness_score": 0,
+    "created_at": "2026-03-16T10:00:00Z"
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects" description="Alle Projekte des Tenants auflisten" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X GET "https://api.breakpilot.io/sdk/v1/iace/projects" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": [
+    {
+      "id": "proj_a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+      "machine_name": "RoboArm X500",
+      "machine_type": "Industrieroboter",
+      "status": "in_progress",
+      "completeness_score": 72,
+      "hazard_count": 14,
+      "created_at": "2026-03-16T10:00:00Z"
+    }
+  ]
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id" description="Projektdetails inkl. Komponenten und Klassifizierungen laden" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X GET "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <ApiEndpoint method="PUT" path="/sdk/v1/iace/projects/:id" description="Projektfelder aktualisieren" />
+      <ApiEndpoint method="DELETE" path="/sdk/v1/iace/projects/:id" description="Projekt archivieren (Soft Delete)" />
+
+      {/* ============================================================ */}
+      {/* ONBOARDING                                                   */}
+      {/* ============================================================ */}
+
+      <h2>Onboarding</h2>
+      <p>Initialisierung aus Firmenprofil und Vollstaendigkeitspruefung.</p>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/init-from-profile" description="Projekt aus Company Profile und Compliance Scope initialisieren" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/init-from-profile" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "initialized_fields": ["manufacturer", "description", "machine_type"],
+    "suggested_regulations": ["machinery_regulation", "low_voltage", "emc"],
+    "message": "Projekt aus Firmenprofil initialisiert. 3 Felder uebernommen."
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/completeness-check" description="Vollstaendigkeitspruefung (25 Gates) durchfuehren" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/completeness-check" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "score": 72,
+    "total_gates": 25,
+    "passed_gates": 18,
+    "gates": [
+      { "id": "G01", "name": "Maschinenidentifikation", "status": "passed" },
+      { "id": "G02", "name": "Komponentenliste", "status": "passed" },
+      { "id": "G03", "name": "Regulatorische Klassifizierung", "status": "passed" },
+      { "id": "G04", "name": "Gefahrenanalyse", "status": "warning", "message": "3 Gefahren ohne Massnahmen" },
+      { "id": "G05", "name": "Risikobewertung", "status": "failed", "message": "5 Gefahren nicht bewertet" }
+    ]
+  }
+}`}
+      </CodeBlock>
+
+      {/* ============================================================ */}
+      {/* COMPONENTS                                                   */}
+      {/* ============================================================ */}
+
+      <h2>Components</h2>
+      <p>Verwalten Sie die Komponenten einer Maschine oder eines Produkts.</p>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/components" description="Komponente hinzufuegen" />
+
+      <h3>Request Body</h3>
+      <ParameterTable
+        parameters={[
+          { name: 'name', type: 'string', required: true, description: 'Komponentenname' },
+          { name: 'component_type', type: 'string', required: true, description: 'Typ (z.B. "actuator", "sensor", "controller", "structural")' },
+          { name: 'is_safety_relevant', type: 'boolean', required: false, description: 'Sicherheitsrelevante Komponente (default: false)' },
+        ]}
+      />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/components" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "name": "Servo-Antrieb Achse 1",
+    "component_type": "actuator",
+    "is_safety_relevant": true
+  }'`}
+      </CodeBlock>
+
+      <h3>Response (201 Created)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "id": "comp_1234abcd",
+    "name": "Servo-Antrieb Achse 1",
+    "component_type": "actuator",
+    "is_safety_relevant": true,
+    "created_at": "2026-03-16T10:05:00Z"
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id/components" description="Alle Komponenten des Projekts auflisten" />
+      <ApiEndpoint method="PUT" path="/sdk/v1/iace/projects/:id/components/:cid" description="Komponente aktualisieren" />
+      <ApiEndpoint method="DELETE" path="/sdk/v1/iace/projects/:id/components/:cid" description="Komponente loeschen" />
+
+      {/* ============================================================ */}
+      {/* REGULATORY CLASSIFICATION                                    */}
+      {/* ============================================================ */}
+
+      <h2>Regulatory Classification</h2>
+      <p>Automatische Klassifizierung nach anwendbaren Regulierungen (Maschinenverordnung, Niederspannung, EMV, etc.).</p>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/classify" description="Alle anwendbaren Regulierungen klassifizieren" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/classify" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "classifications": [
+      {
+        "regulation": "machinery_regulation",
+        "title": "Maschinenverordnung (EU) 2023/1230",
+        "applicable": true,
+        "confidence": 0.95,
+        "reason": "Industrieroboter faellt unter Annex I der Maschinenverordnung"
+      },
+      {
+        "regulation": "low_voltage",
+        "title": "Niederspannungsrichtlinie 2014/35/EU",
+        "applicable": true,
+        "confidence": 0.88,
+        "reason": "Betriebsspannung 400V AC"
+      },
+      {
+        "regulation": "ai_act",
+        "title": "AI Act (EU) 2024/1689",
+        "applicable": false,
+        "confidence": 0.72,
+        "reason": "Keine KI-Komponente identifiziert"
+      }
+    ]
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id/classifications" description="Klassifizierungsergebnisse abrufen" />
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/classify/:regulation" description="Einzelne Regulierung klassifizieren" />
+
+      {/* ============================================================ */}
+      {/* HAZARDS & PATTERN MATCHING                                   */}
+      {/* ============================================================ */}
+
+      <h2>Hazards &amp; Pattern Matching</h2>
+      <p>
+        Gefahrenanalyse nach ISO 12100 mit 102 Hazard-Patterns. Die Pattern-Matching-Engine
+        erkennt automatisch Gefahren basierend auf Maschinentyp, Komponenten und Energiequellen.
+      </p>
+
+      <InfoBox type="info" title="102 Hazard-Patterns">
+        Die Engine enthaelt 102 vordefinierte Gefahrenmuster (HP001-HP102), die nach
+        ISO 12100 Anhang A kategorisiert sind: mechanisch, elektrisch, thermisch, Laerm,
+        Vibration, Strahlung, Materialien/Substanzen und ergonomisch.
+      </InfoBox>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/hazards" description="Neue Gefahr erstellen" />
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id/hazards" description="Alle Gefahren des Projekts auflisten" />
+      <ApiEndpoint method="PUT" path="/sdk/v1/iace/projects/:id/hazards/:hid" description="Gefahr aktualisieren" />
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/hazards/suggest" description="KI-gestuetzte Gefahrenvorschlaege generieren" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/hazards/suggest" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "suggestions": [
+      {
+        "hazard_type": "mechanical",
+        "title": "Quetschgefahr durch bewegliche Roboterarme",
+        "description": "Unkontrollierte Bewegung der Achsen kann zu Quetschungen fuehren",
+        "iso_reference": "ISO 12100 Anhang A.1",
+        "severity": "high",
+        "confidence": 0.91
+      },
+      {
+        "hazard_type": "electrical",
+        "title": "Stromschlaggefahr bei Wartungsarbeiten",
+        "description": "Zugang zu spannungsfuehrenden Teilen bei geoeffnetem Schaltschrank",
+        "iso_reference": "ISO 12100 Anhang A.2",
+        "severity": "critical",
+        "confidence": 0.87
+      }
+    ]
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/match-patterns" description="Pattern-Matching-Engine ausfuehren (102 Patterns)" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/match-patterns" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "total_patterns_checked": 102,
+    "matches": 14,
+    "results": [
+      {
+        "pattern_id": "HP003",
+        "title": "Crushing hazard from linear actuator",
+        "category": "mechanical",
+        "match_score": 0.94,
+        "matched_components": ["Servo-Antrieb Achse 1", "Linearfuehrung"],
+        "matched_energy_sources": ["EN03"],
+        "suggested_hazard": {
+          "title": "Quetschgefahr durch Linearantrieb",
+          "severity": "high"
+        }
+      }
+    ]
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/apply-patterns" description="Pattern-Matching-Ergebnisse als Gefahren uebernehmen" />
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/hazards/:hid/suggest-measures" description="Massnahmenvorschlaege fuer eine Gefahr generieren" />
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/mitigations/:mid/suggest-evidence" description="Evidenz-Vorschlaege fuer eine Massnahme generieren" />
+
+      {/* ============================================================ */}
+      {/* RISK ASSESSMENT                                              */}
+      {/* ============================================================ */}
+
+      <h2>Risk Assessment</h2>
+      <p>
+        4-Faktor-Risikobewertung nach ISO 12100 mit den Parametern Schwere (S),
+        Exposition (E), Eintrittswahrscheinlichkeit (P) und Vermeidbarkeit (A).
+      </p>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/hazards/:hid/assess" description="Risiko bewerten (S/E/P/A, Inherent Risk, C_eff, Residual Risk)" />
+
+      <h3>Request Body</h3>
+      <ParameterTable
+        parameters={[
+          { name: 'severity', type: 'number (1-4)', required: true, description: 'Schwere: 1=gering, 2=mittel, 3=schwer, 4=toedlich' },
+          { name: 'exposure', type: 'number (1-4)', required: true, description: 'Exposition: 1=selten, 2=gelegentlich, 3=haeufig, 4=dauernd' },
+          { name: 'probability', type: 'number (1-4)', required: true, description: 'Eintrittswahrscheinlichkeit: 1=unwahrscheinlich, 2=moeglich, 3=wahrscheinlich, 4=sehr wahrscheinlich' },
+          { name: 'avoidance', type: 'number (1-4)', required: true, description: 'Vermeidbarkeit: 1=leicht, 2=moeglich, 3=schwer, 4=unmoeglich' },
+        ]}
+      />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/hazards/haz_5678/assess" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "severity": 4,
+    "exposure": 3,
+    "probability": 2,
+    "avoidance": 3
+  }'`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "hazard_id": "haz_5678",
+    "severity": 4,
+    "exposure": 3,
+    "probability": 2,
+    "avoidance": 3,
+    "inherent_risk": 12,
+    "risk_level": "high",
+    "c_eff": 0.65,
+    "residual_risk": 4.2,
+    "residual_risk_level": "medium",
+    "risk_acceptable": false,
+    "recommendation": "Zusaetzliche Schutzmassnahmen erforderlich. 3-Stufen-Hierarchie anwenden."
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id/risk-summary" description="Aggregierte Risikouebersicht des Projekts" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X GET "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/risk-summary" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "total_hazards": 14,
+    "assessed": 12,
+    "unassessed": 2,
+    "risk_distribution": {
+      "critical": 1,
+      "high": 4,
+      "medium": 5,
+      "low": 2
+    },
+    "residual_risk_distribution": {
+      "critical": 0,
+      "high": 1,
+      "medium": 3,
+      "low": 8
+    },
+    "average_c_eff": 0.71,
+    "overall_risk_acceptable": false
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/hazards/:hid/reassess" description="Risiko nach Massnahmen-Umsetzung neu bewerten" />
+
+      {/* ============================================================ */}
+      {/* MITIGATIONS                                                  */}
+      {/* ============================================================ */}
+
+      <h2>Mitigations</h2>
+      <p>
+        Massnahmenverwaltung nach der 3-Stufen-Hierarchie gemaess ISO 12100:
+      </p>
+      <ol>
+        <li><strong>Design</strong> — Inherent Safe Design (Gefahrenbeseitigung durch Konstruktion)</li>
+        <li><strong>Protective</strong> — Schutzeinrichtungen und technische Schutzmassnahmen</li>
+        <li><strong>Information</strong> — Benutzerinformation (Warnhinweise, Anleitungen, Schulungen)</li>
+      </ol>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/hazards/:hid/mitigations" description="Massnahme erstellen (3-Stufen-Hierarchie: design, protective, information)" />
+
+      <h3>Request Body</h3>
+      <ParameterTable
+        parameters={[
+          { name: 'title', type: 'string', required: true, description: 'Titel der Massnahme' },
+          { name: 'description', type: 'string', required: true, description: 'Beschreibung der Massnahme' },
+          { name: 'hierarchy_level', type: 'string', required: true, description: '"design" | "protective" | "information"' },
+          { name: 'responsible', type: 'string', required: false, description: 'Verantwortliche Person oder Rolle' },
+          { name: 'deadline', type: 'string (ISO 8601)', required: false, description: 'Umsetzungsfrist' },
+        ]}
+      />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/hazards/haz_5678/mitigations" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "title": "Schutzgitter mit Sicherheitsschalter",
+    "description": "Installation eines trennenden Schutzgitters mit Verriegelung nach ISO 14120",
+    "hierarchy_level": "protective",
+    "responsible": "Sicherheitsingenieur",
+    "deadline": "2026-04-30T00:00:00Z"
+  }'`}
+      </CodeBlock>
+
+      <h3>Response (201 Created)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "id": "mit_abcd1234",
+    "hazard_id": "haz_5678",
+    "title": "Schutzgitter mit Sicherheitsschalter",
+    "hierarchy_level": "protective",
+    "status": "planned",
+    "verified": false,
+    "created_at": "2026-03-16T11:00:00Z"
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="PUT" path="/sdk/v1/iace/mitigations/:mid" description="Massnahme aktualisieren" />
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/mitigations/:mid/verify" description="Massnahme als verifiziert markieren" />
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/validate-mitigation-hierarchy" description="3-Stufen-Hierarchie validieren" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/validate-mitigation-hierarchy" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "valid": false,
+    "violations": [
+      {
+        "hazard_id": "haz_5678",
+        "hazard_title": "Quetschgefahr durch Linearantrieb",
+        "issue": "Nur Information-Massnahmen vorhanden. Design- oder Schutzmassnahmen muessen vorrangig angewendet werden.",
+        "missing_levels": ["design", "protective"]
+      }
+    ],
+    "summary": {
+      "total_hazards_with_mitigations": 12,
+      "hierarchy_compliant": 9,
+      "hierarchy_violations": 3
+    }
+  }
+}`}
+      </CodeBlock>
+
+      {/* ============================================================ */}
+      {/* EVIDENCE                                                     */}
+      {/* ============================================================ */}
+
+      <h2>Evidence</h2>
+      <p>Evidenz-Dateien hochladen und verwalten (Pruefberichte, Zertifikate, Fotos, etc.).</p>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/evidence" description="Evidenz-Datei hochladen" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/evidence" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -F "file=@pruefbericht_schutzgitter.pdf" \\
+  -F "title=Pruefbericht Schutzgitter ISO 14120" \\
+  -F "evidence_type=test_report" \\
+  -F "linked_mitigation_id=mit_abcd1234"`}
+      </CodeBlock>
+
+      <h3>Response (201 Created)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "id": "evi_xyz789",
+    "title": "Pruefbericht Schutzgitter ISO 14120",
+    "evidence_type": "test_report",
+    "file_name": "pruefbericht_schutzgitter.pdf",
+    "file_size": 245760,
+    "linked_mitigation_id": "mit_abcd1234",
+    "created_at": "2026-03-16T12:00:00Z"
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id/evidence" description="Alle Evidenzen des Projekts auflisten" />
+
+      {/* ============================================================ */}
+      {/* VERIFICATION PLANS                                           */}
+      {/* ============================================================ */}
+
+      <h2>Verification Plans</h2>
+      <p>Verifizierungsplaene erstellen und abarbeiten.</p>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/verification-plan" description="Verifizierungsplan erstellen" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/verification-plan" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "title": "Schutzgitter-Verifizierung",
+    "description": "Pruefung der Schutzgitter nach ISO 14120",
+    "method": "inspection",
+    "linked_mitigation_id": "mit_abcd1234",
+    "planned_date": "2026-04-15T00:00:00Z"
+  }'`}
+      </CodeBlock>
+
+      <h3>Response (201 Created)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "id": "vp_plan001",
+    "title": "Schutzgitter-Verifizierung",
+    "method": "inspection",
+    "status": "planned",
+    "linked_mitigation_id": "mit_abcd1234",
+    "planned_date": "2026-04-15T00:00:00Z",
+    "created_at": "2026-03-16T12:30:00Z"
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="PUT" path="/sdk/v1/iace/verification-plan/:vid" description="Verifizierungsplan aktualisieren" />
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/verification-plan/:vid/complete" description="Verifizierung abschliessen" />
+
+      {/* ============================================================ */}
+      {/* CE TECHNICAL FILE                                            */}
+      {/* ============================================================ */}
+
+      <h2>CE Technical File</h2>
+      <p>
+        LLM-gestuetzte Generierung der Technischen Dokumentation (CE Technical File).
+        Die API generiert alle erforderlichen Abschnitte basierend auf den Projektdaten.
+      </p>
+
+      <InfoBox type="info" title="LLM-Generierung">
+        Die Generierung verwendet einen LLM-Service (qwen3:30b-a3b oder claude-sonnet-4-5)
+        fuer kontextbasierte Texterstellung. Alle generierten Abschnitte muessen vor der
+        Freigabe manuell geprueft werden (Human Oversight).
+      </InfoBox>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/tech-file/generate" description="Alle Tech-File-Abschnitte generieren (LLM-basiert)" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/tech-file/generate" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "sections_generated": 8,
+    "sections": [
+      {
+        "section": "general_description",
+        "title": "Allgemeine Beschreibung",
+        "status": "generated",
+        "word_count": 450
+      },
+      {
+        "section": "risk_assessment",
+        "title": "Risikobeurteilung",
+        "status": "generated",
+        "word_count": 1200
+      },
+      {
+        "section": "safety_requirements",
+        "title": "Sicherheitsanforderungen",
+        "status": "generated",
+        "word_count": 800
+      },
+      {
+        "section": "verification_results",
+        "title": "Verifizierungsergebnisse",
+        "status": "generated",
+        "word_count": 600
+      }
+    ],
+    "total_word_count": 4850,
+    "generation_time_ms": 12500
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id/tech-file" description="Alle Tech-File-Abschnitte auflisten" />
+      <ApiEndpoint method="PUT" path="/sdk/v1/iace/projects/:id/tech-file/:section" description="Abschnitt-Inhalt manuell aktualisieren" />
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/tech-file/:section/approve" description="Abschnitt freigeben (Human Oversight)" />
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/tech-file/:section/generate" description="Einzelnen Abschnitt (neu) generieren via LLM" />
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id/tech-file/export?format=pdf|xlsx|docx|md|json" description="Tech File exportieren" />
+
+      <h3>Export-Formate</h3>
+      <ParameterTable
+        parameters={[
+          { name: 'format', type: 'string', required: true, description: 'Export-Format: "pdf", "xlsx", "docx", "md", "json"' },
+        ]}
+      />
+
+      <CodeBlock language="bash" filename="cURL">
+{`# PDF Export
+curl -X GET "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/tech-file/export?format=pdf" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -o technical-file.pdf
+
+# Markdown Export
+curl -X GET "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/tech-file/export?format=md" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -o technical-file.md`}
+      </CodeBlock>
+
+      {/* ============================================================ */}
+      {/* MONITORING                                                   */}
+      {/* ============================================================ */}
+
+      <h2>Monitoring</h2>
+      <p>Post-Market-Surveillance: Monitoring-Ereignisse erfassen und verfolgen.</p>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/monitoring" description="Monitoring-Ereignis erstellen" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/monitoring" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "event_type": "incident",
+    "title": "Schutzgitter-Sensor Fehlausloesung",
+    "description": "Sicherheitssensor hat ohne erkennbaren Grund ausgeloest",
+    "severity": "medium",
+    "occurred_at": "2026-03-15T14:30:00Z"
+  }'`}
+      </CodeBlock>
+
+      <h3>Response (201 Created)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "id": "mon_evt001",
+    "event_type": "incident",
+    "title": "Schutzgitter-Sensor Fehlausloesung",
+    "severity": "medium",
+    "status": "open",
+    "occurred_at": "2026-03-15T14:30:00Z",
+    "created_at": "2026-03-16T08:00:00Z"
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id/monitoring" description="Monitoring-Ereignisse auflisten" />
+      <ApiEndpoint method="PUT" path="/sdk/v1/iace/projects/:id/monitoring/:eid" description="Monitoring-Ereignis aktualisieren" />
+
+      {/* ============================================================ */}
+      {/* LIBRARIES (PROJECT-INDEPENDENT)                              */}
+      {/* ============================================================ */}
+
+      <h2>Libraries (projektunabhaengig)</h2>
+      <p>
+        Stammdaten-Bibliotheken fuer die Gefahrenanalyse. Diese Endpoints sind
+        projektunabhaengig und liefern die Referenzdaten fuer die gesamte IACE-Engine.
+      </p>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/hazard-library" description="Gefahrenbibliothek (102 Eintraege)" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X GET "https://api.breakpilot.io/sdk/v1/iace/hazard-library" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": [
+    {
+      "id": "HP001",
+      "title": "Crushing hazard from closing mechanisms",
+      "category": "mechanical",
+      "iso_reference": "ISO 12100 Anhang A.1",
+      "typical_components": ["actuator", "press", "clamp"],
+      "severity_range": "medium-critical"
+    },
+    {
+      "id": "HP045",
+      "title": "Electric shock from exposed conductors",
+      "category": "electrical",
+      "iso_reference": "ISO 12100 Anhang A.2",
+      "typical_components": ["power_supply", "motor", "controller"],
+      "severity_range": "high-critical"
+    }
+  ],
+  "meta": {
+    "total": 102,
+    "categories": {
+      "mechanical": 28,
+      "electrical": 15,
+      "thermal": 10,
+      "noise": 8,
+      "vibration": 7,
+      "radiation": 9,
+      "materials": 12,
+      "ergonomic": 13
+    }
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/controls-library" description="Controls-Bibliothek" />
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/component-library" description="Komponentenbibliothek (C001-C120)" />
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/energy-sources" description="Energiequellen (EN01-EN20)" />
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/lifecycle-phases" description="ISO 12100 Lebenszyklusphasen" />
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/roles" description="Betroffene Personenrollen" />
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/evidence-types" description="Evidenz-Typen" />
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/protective-measures-library" description="Schutzmassnahmen-Bibliothek" />
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/hazard-patterns" description="Hazard-Pattern-Katalog" />
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/tags" description="Tag-Taxonomie" />
+
+      {/* ============================================================ */}
+      {/* AUDIT TRAIL                                                  */}
+      {/* ============================================================ */}
+
+      <h2>Audit Trail</h2>
+      <p>Lueckenloser Audit-Trail aller Projektaenderungen fuer Compliance-Nachweise.</p>
+
+      <ApiEndpoint method="GET" path="/sdk/v1/iace/projects/:id/audit-trail" description="Projekt-Audit-Trail abrufen" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X GET "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/audit-trail" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": [
+    {
+      "id": "aud_001",
+      "action": "hazard_created",
+      "entity_type": "hazard",
+      "entity_id": "haz_5678",
+      "user_id": "user_abc",
+      "changes": {
+        "title": "Quetschgefahr durch Linearantrieb",
+        "severity": "high"
+      },
+      "timestamp": "2026-03-16T10:15:00Z"
+    },
+    {
+      "id": "aud_002",
+      "action": "risk_assessed",
+      "entity_type": "hazard",
+      "entity_id": "haz_5678",
+      "user_id": "user_abc",
+      "changes": {
+        "inherent_risk": 12,
+        "risk_level": "high"
+      },
+      "timestamp": "2026-03-16T10:20:00Z"
+    },
+    {
+      "id": "aud_003",
+      "action": "tech_file_section_approved",
+      "entity_type": "tech_file",
+      "entity_id": "risk_assessment",
+      "user_id": "user_def",
+      "changes": {
+        "status": "approved",
+        "approved_by": "Dr. Mueller"
+      },
+      "timestamp": "2026-03-16T15:00:00Z"
+    }
+  ]
+}`}
+      </CodeBlock>
+
+      {/* ============================================================ */}
+      {/* RAG LIBRARY SEARCH                                           */}
+      {/* ============================================================ */}
+
+      <h2>RAG Library Search</h2>
+      <p>
+        Semantische Suche in der Compliance-Bibliothek via RAG (Retrieval-Augmented Generation).
+        Ermoeglicht kontextbasierte Anreicherung von Tech-File-Abschnitten.
+      </p>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/library-search" description="Compliance-Bibliothek via RAG durchsuchen" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/library-search" \\
+  -H "Authorization: Bearer YOUR_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "query": "Schutzeinrichtungen fuer Industrieroboter Maschinenverordnung",
+    "top_k": 5
+  }'`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "query": "Schutzeinrichtungen fuer Industrieroboter Maschinenverordnung",
+    "results": [
+      {
+        "id": "mr-annex-iii-1.1.4",
+        "title": "Maschinenverordnung Anhang III 1.1.4 — Schutzmassnahmen",
+        "content": "Trennende Schutzeinrichtungen muessen fest angebracht oder verriegelt sein...",
+        "source": "machinery_regulation",
+        "score": 0.93
+      }
+    ],
+    "total_results": 5,
+    "search_time_ms": 38
+  }
+}`}
+      </CodeBlock>
+
+      <ApiEndpoint method="POST" path="/sdk/v1/iace/projects/:id/tech-file/:section/enrich" description="Tech-File-Abschnitt mit RAG-Kontext anreichern" />
+
+      <CodeBlock language="bash" filename="cURL">
+{`curl -X POST "https://api.breakpilot.io/sdk/v1/iace/projects/proj_a1b2c3d4/tech-file/safety_requirements/enrich" \\
+  -H "Authorization: Bearer YOUR_API_KEY"`}
+      </CodeBlock>
+
+      <h3>Response (200 OK)</h3>
+      <CodeBlock language="json" filename="Response">
+{`{
+  "success": true,
+  "data": {
+    "section": "safety_requirements",
+    "enriched_content": "... (aktualisierter Abschnitt mit Regulierungsreferenzen) ...",
+    "citations_added": 4,
+    "sources": [
+      {
+        "id": "mr-annex-iii-1.1.4",
+        "title": "Maschinenverordnung Anhang III 1.1.4",
+        "relevance_score": 0.93
+      }
+    ]
+  }
+}`}
+      </CodeBlock>
+
+      {/* ============================================================ */}
+      {/* SDK INTEGRATION                                              */}
+      {/* ============================================================ */}
+
+      <h2>SDK Integration</h2>
+      <p>
+        Beispiel fuer die Integration der IACE-API in eine Anwendung:
+      </p>
+
+      <CodeBlock language="typescript" filename="iace-workflow.ts">
+{`import { getSDKBackendClient } from '@breakpilot/compliance-sdk'
+
+const client = getSDKBackendClient()
+
+// 1. Projekt erstellen
+const project = await client.post('/iace/projects', {
+  machine_name: 'RoboArm X500',
+  machine_type: 'Industrieroboter',
+  manufacturer: 'TechCorp GmbH'
+})
+
+// 2. Aus Firmenprofil initialisieren
+await client.post(\`/iace/projects/\${project.id}/init-from-profile\`)
+
+// 3. Komponenten hinzufuegen
+await client.post(\`/iace/projects/\${project.id}/components\`, {
+  name: 'Servo-Antrieb Achse 1',
+  component_type: 'actuator',
+  is_safety_relevant: true
+})
+
+// 4. Regulierungen klassifizieren
+const classifications = await client.post(
+  \`/iace/projects/\${project.id}/classify\`
+)
+
+// 5. Pattern-Matching ausfuehren
+const patterns = await client.post(
+  \`/iace/projects/\${project.id}/match-patterns\`
+)
+console.log(\`\${patterns.matches} Gefahren erkannt von \${patterns.total_patterns_checked} Patterns\`)
+
+// 6. Erkannte Patterns als Gefahren uebernehmen
+await client.post(\`/iace/projects/\${project.id}/apply-patterns\`)
+
+// 7. Risiken bewerten
+for (const hazard of await client.get(\`/iace/projects/\${project.id}/hazards\`)) {
+  await client.post(\`/iace/projects/\${project.id}/hazards/\${hazard.id}/assess\`, {
+    severity: 3, exposure: 2, probability: 2, avoidance: 2
+  })
+}
+
+// 8. Tech File generieren
+const techFile = await client.post(
+  \`/iace/projects/\${project.id}/tech-file/generate\`
+)
+console.log(\`\${techFile.sections_generated} Abschnitte generiert\`)
+
+// 9. PDF exportieren
+const pdf = await client.get(
+  \`/iace/projects/\${project.id}/tech-file/export?format=pdf\`
+)
+`}
+      </CodeBlock>
+
+      <InfoBox type="warning" title="Rate Limits &amp; LLM-Kosten">
+        LLM-basierte Endpoints (Tech-File-Generierung, Hazard-Suggest, RAG-Enrichment)
+        verbrauchen LLM-Tokens. Professional-Plan: 50 Generierungen/Tag.
+        Enterprise-Plan: unbegrenzt. Implementieren Sie Caching fuer wiederholte Anfragen.
+      </InfoBox>
+
+      <InfoBox type="success" title="Human Oversight">
+        Alle LLM-generierten Inhalte muessen vor der Freigabe manuell geprueft werden.
+        Die API erzwingt dies ueber den Approve-Workflow: generierte Abschnitte haben
+        den Status &quot;generated&quot; und muessen explizit auf &quot;approved&quot; gesetzt werden.
+      </InfoBox>
+    </DevPortalLayout>
+  )
+}
diff --git a/docs-src/services/sdk-modules/iace.md b/docs-src/services/sdk-modules/iace.md
index 127b6ff..409c67f 100644
--- a/docs-src/services/sdk-modules/iace.md
+++ b/docs-src/services/sdk-modules/iace.md
@@ -297,9 +297,14 @@ Fuer die Verifikation stehen **50 Nachweistypen** zur Auswahl:
 | GET | `/sdk/v1/iace/hazard-library` | Alle Gefaehrdungen (150+) |
 | GET | `/sdk/v1/iace/controls-library` | Alle Controls (200) |
 | GET | `/sdk/v1/iace/protective-measures-library` | Schutzmassnahmen-Bibliothek (160) |
+| GET | `/sdk/v1/iace/component-library` | Komponenten-Bibliothek (C001-C120) |
+| GET | `/sdk/v1/iace/energy-sources` | Energiequellen (EN01-EN20) |
+| GET | `/sdk/v1/iace/hazard-patterns` | Gefaehrdungs-Patterns (102) |
+| GET | `/sdk/v1/iace/tags` | Tag-Taxonomie |
 | GET | `/sdk/v1/iace/lifecycle-phases` | 25 Lebensphasen (DE/EN) |
 | GET | `/sdk/v1/iace/roles` | 20 betroffene Personengruppen (DE/EN) |
 | GET | `/sdk/v1/iace/evidence-types` | 50 Nachweistypen in 7 Kategorien |
+| POST | `/sdk/v1/iace/library-search` | RAG-Bibliothekssuche |
 
 ### Projektmanagement
 
@@ -311,12 +316,19 @@ Fuer die Verifikation stehen **50 Nachweistypen** zur Auswahl:
 | PUT | `/sdk/v1/iace/projects/:id` | Projekt aktualisieren |
 | DELETE | `/sdk/v1/iace/projects/:id` | Projekt archivieren |
 
-### Onboarding
+### Onboarding & Profil-Import
 
 | Methode | Pfad | Beschreibung |
 |---------|------|--------------|
 | POST | `/sdk/v1/iace/projects/:id/init-from-profile` | Projekt aus Company-Profile initialisieren |
-| POST | `/sdk/v1/iace/projects/:id/completeness-check` | 25-Gates-Pruefung |
+| POST | `/sdk/v1/iace/projects/:id/completeness-check` | 22-Gates-Pruefung |
+
+Der `init-from-profile` Endpoint uebernimmt Daten aus dem Company-Profile und Compliance-Scope:
+
+- **company_profile** → Hersteller-Name, Kontaktdaten
+- **compliance_scope** → Maschinenname, Typ, Zweckbeschreibung, Software/Firmware/KI-Flags
+- Erstellt automatisch initiale Komponenten (Software, Firmware, KI-Modell, Netzwerk)
+- Triggert initiale regulatorische Klassifizierungen fuer anwendbare Verordnungen
 
 ### Komponenten
 
@@ -364,9 +376,48 @@ Fuer die Verifikation stehen **50 Nachweistypen** zur Auswahl:
 | Methode | Pfad | Beschreibung |
 |---------|------|--------------|
 | GET | `/sdk/v1/iace/projects/:id/tech-file` | Technische Akte abrufen |
-| POST | `/sdk/v1/iace/projects/:id/tech-file/generate` | Akte generieren |
-| GET | `/sdk/v1/iace/projects/:id/tech-file/export` | Akte exportieren (PDF/Markdown) |
-| PUT | `/sdk/v1/iace/projects/:id/tech-file/sections/:sid` | Abschnitt aktualisieren |
+| POST | `/sdk/v1/iace/projects/:id/tech-file/generate` | Alle Sektionen generieren (LLM-basiert) |
+| POST | `/sdk/v1/iace/projects/:id/tech-file/:section/generate` | Einzelne Sektion (re-)generieren (LLM) |
+| PUT | `/sdk/v1/iace/projects/:id/tech-file/:section` | Abschnitt manuell aktualisieren |
+| POST | `/sdk/v1/iace/projects/:id/tech-file/:section/approve` | Abschnitt freigeben |
+| POST | `/sdk/v1/iace/projects/:id/tech-file/:section/enrich` | Abschnitt mit RAG-Kontext anreichern |
+| GET | `/sdk/v1/iace/projects/:id/tech-file/export?format=` | Akte exportieren (pdf/xlsx/docx/md/json) |
+
+#### Export-Formate
+
+| Format | MIME-Type | Inhalt |
+|--------|-----------|--------|
+| `pdf` | application/pdf | Vollstaendige CE-Akte mit Deckblatt, Inhaltsverzeichnis, Risikomatrix, Gefaehrdungsprotokoll |
+| `xlsx` | application/vnd.openxmlformats-officedocument.spreadsheetml.sheet | 5 Worksheets: Uebersicht, Gefaehrdungsprotokoll, Massnahmen, Risikomatrix, Sektionen |
+| `docx` | application/vnd.openxmlformats-officedocument.wordprocessingml.document | Word-Dokument mit allen Sektionen als formatierte Absaetze |
+| `md` | text/markdown | Markdown-Dokument mit Projekt-Metadaten und allen Sektionen |
+| `json` | application/json | JSON-Export mit Projekt, Sektionen, Klassifizierungen, Risikouebersicht |
+
+#### LLM-basierte Sektionsgenerierung (19 Sektionstypen)
+
+Die Tech-File-Generierung nutzt LLM (Ollama/Anthropic) mit RAG-Kontext aus dem CE-Corpus:
+
+| Sektion | Beschreibung |
+|---------|--------------|
+| `general_description` | Allgemeine Maschinenbeschreibung |
+| `risk_assessment_report` | Zusammenfassung der Risikobeurteilung |
+| `hazard_log_combined` | Tabellarisches Gefaehrdungsprotokoll |
+| `essential_requirements` | Grundlegende Anforderungen (MVO Anhang III) |
+| `design_specifications` | Konstruktionsdaten und Zeichnungen |
+| `test_reports` | Pruefberichte und Verifikationsergebnisse |
+| `standards_applied` | Angewandte harmonisierte Normen |
+| `declaration_of_conformity` | EU-Konformitaetserklaerung (MVO Anhang IV) |
+| `component_list` | Komponentenverzeichnis |
+| `classification_report` | Regulatorische Klassifikation |
+| `mitigation_report` | Massnahmen nach 3-Stufen-Hierarchie |
+| `verification_report` | Verifikationsplan und Ergebnisse |
+| `evidence_index` | Nachweisdokumenten-Index |
+| `instructions_for_use` | Sicherheitshinweise / Betriebsanleitung |
+| `monitoring_plan` | Post-Market Surveillance Plan |
+| `ai_intended_purpose` | KI: Bestimmungsgemaesser Zweck |
+| `ai_model_description` | KI: Modellbeschreibung und Trainingsdaten |
+| `ai_risk_management` | KI: Risikomanagementsystem |
+| `ai_human_oversight` | KI: Menschliche Aufsicht |
 
 ### Post-Market Monitoring
 
@@ -383,40 +434,59 @@ Fuer die Verifikation stehen **50 Nachweistypen** zur Auswahl:
 
 ---
 
-## Completeness Gates (25)
+## Completeness Gates (22)
 
-Das Modul prueft 25 Vollstaendigkeitstore vor dem CE-Export:
+Das Modul prueft 22 Vollstaendigkeitstore (20 Required, 2 Recommended) vor dem CE-Export:
 
-| Gate | Kategorie | Pflicht |
-|------|-----------|---------|
-| G01 | Projekt-Grunddaten vollstaendig | ✅ Required |
-| G02 | CE-Markierungsziel definiert | ✅ Required |
-| G03 | Mind. 1 Komponente erfasst | ✅ Required |
-| G04 | Regulatorische Klassifizierung abgeschlossen | ✅ Required |
-| G05 | HARA-Dokument vorhanden (Evidence) | ✅ Required |
-| G06 | Mind. 1 Gefaehrdung identifiziert | ✅ Required |
-| G07 | Alle Gefaehrdungen bewertet | ✅ Required |
-| G08 | Kein Restrisiko > critical ohne Akzeptanz | ✅ Required |
-| G09 | Mind. 1 Minderungsmassnahme je Gefaehrdung | ✅ Required |
-| G10 | Minderungsmassnahmen verifiziert | ✅ Required |
-| G11 | Verifikationsplan vorhanden | ✅ Required |
-| G12 | SIL/PL-Dokumentation (Evidence) | ✅ Required |
-| G13 | Technische Akte generiert | ✅ Required |
-| G14 | Konformitaetserklaerung bereit | ✅ Required |
-| G15 | Betriebsanleitung vorhanden | ✅ Required |
-| G16 | Wartungsanleitung vorhanden | Recommended |
-| G17 | Post-Market Monitoring aktiv | Recommended |
-| G18 | Cybersecurity-Massnahmen dokumentiert | Recommended |
-| G19 | AI-spezifische Anforderungen erfuellt | Recommended (bei AI) |
-| G20 | Kalibrierprotokolle vorhanden | Recommended |
-| G21 | SBOM generiert | Optional |
-| G22 | Penetrationstest durchgefuehrt | Optional |
-| G23 | EMV-Pruefung dokumentiert | Optional |
-| G24 | Lebenszyklusplan vorhanden | Optional |
-| G25 | Monitoring-Ereignisse protokolliert | Optional |
+### Onboarding (G01-G09)
+
+| Gate | Label | Pflicht |
+|------|-------|---------|
+| G01 | Machine identity set | ✅ Required |
+| G02 | Intended use described | ✅ Required |
+| G03 | Operating limits defined | ✅ Required |
+| G04 | Foreseeable misuse documented | ✅ Required |
+| G05 | Component tree exists | ✅ Required |
+| G06 | AI classification done (if applicable) | ✅ Required |
+| G07 | Safety relevance marked | ✅ Required |
+| G08 | Manufacturer info present | ✅ Required |
+| G09 | Pattern matching performed | Recommended |
+
+### Klassifizierung (G10-G13)
+
+| Gate | Label | Pflicht |
+|------|-------|---------|
+| G10 | AI Act classification complete | ✅ Required |
+| G11 | Machinery Regulation check done | ✅ Required |
+| G12 | NIS2 check done | ✅ Required |
+| G13 | CRA check done | ✅ Required |
+
+### Gefaehrdungen & Risiko (G20-G24)
+
+| Gate | Label | Pflicht |
+|------|-------|---------|
+| G20 | Hazards identified | ✅ Required |
+| G21 | All hazards assessed | ✅ Required |
+| G22 | Critical/High risks mitigated | ✅ Required |
+| G23 | **Mitigations verified** | ✅ Required |
+| G24 | Residual risk accepted | ✅ Required |
+
+!!! warning "G23 — Strenge Verifikationspflicht"
+    Alle Mitigations muessen den Status `verified` oder `rejected` haben. Mitigations im Status `planned` oder `implemented` blockieren den Export. Dies stellt sicher, dass keine Massnahme unueberprueft bleibt.
+
+### Evidence & Tech File (G30, G40-G42)
+
+| Gate | Label | Pflicht |
+|------|-------|---------|
+| G30 | Test evidence linked | Recommended |
+| G40 | Risk assessment report generated | ✅ Required |
+| G41 | Hazard log generated | ✅ Required |
+| G42 | AI documents present (if applicable) | ✅ Required |
 
 **Completeness Score:** `(passed_required/total_required)*80 + (passed_recommended/total_recommended)*15 + (passed_optional/total_optional)*5`
 
+**CanExport** ist nur `true`, wenn alle Required-Gates bestanden sind.
+
 ---
 
 ## CE RAG-Corpus