Geführtes Update: "Anwendung ersetzen" im Update-Hinweis

Der Update-Hinweis bietet neben "Update Ordner öffnen" nun den Button "Anwendung ersetzen". Er kopiert das ZIP vom SMB-Laufwerk lokal, prüft es, entpackt es in einen eigenen Ordner neben der aktuellen Installation, übernimmt input/, output/ und eigene Templates und startet die neue EXE. Die alte Installation bleibt als Rückfallebene erhalten; eine angepasste settings.ini wird als settings.vorherige-version.ini aufbewahrt. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Template PDF erneuert. Neues und altes PDF sind nun enthalten
2026-11-03 12:55:12 +01:00 · 2026-11-03 12:15:10 +01:00 · 2026-11-03 12:06:05 +01:00 · 2026-11-03 11:58:53 +01:00 · 2026-11-03 11:58:32 +01:00 · 2026-11-03 11:53:55 +01:00
76 changed files with 4482 additions and 1983 deletions
@@ -0,0 +1,184 @@
+# Ziel
+
+Eine Python + Streamlit App für Windows, die aus einer Input-Excel-Datei (ein Sheet pro Monat mit Mitarbeiterdaten) und einem **PDF-Template** pro Mitarbeiter eine **PDF-Datei** generiert (eine Seite pro Monat, befüllt mit dessen Daten).
+
+**Ansatz**: openpyxl für Input-Parsing + PyMuPDF (fitz) für PDF-Generierung + Streamlit-UI.
+
+> **Hintergrund**: Das ursprüngliche Excel-Template war teilweise schreibgeschützt und konnte nicht mit openpyxl befüllt werden.
+> Daher wurde das Template als PDF exportiert. Im PDF wurden alle zu befüllenden Textstellen mit einem Platzhalter
+> im Format `{Feldname}_Field` markiert (z. B. `Antragsnummer_Field`, `Name_Field`). Die App sucht nach diesen
+> `_Field`-Markern und ersetzt sie durch die echten Daten.
+
+# Aufgabe
+
+Erstelle eine Windows App in dessen Oberfläche aus folgenden Bestandteilen aufgebaut ist:
+- mittels einem DropDown-Menü kann eine Datei aus dem inputfolder gewählt werden
+- mittels einem DropDown-Menü kann ein PDF-Template aus dem Templatefolder gewählt werden
+- ein Button um den Vorgang zu starten
+
+Die Funktion der App besteht darin, das Template-PDF mit Daten aus dem Input-File zu befüllen.
+Im Inputfile ist für alle Monate eines Jahres eine Liste aller Mitarbeitenden und in den Spalten alle Daten zur Befüllung des Templates.
+
+# Aufbau Input Datei
+
+- In der Input Datei ist für jeden Monat eines Jahres ein Sheet gespeichert.
+- In jedem Sheet befindet sich eine Tabelle (felder speichern in Input Schema json) mit Mitarbeitenden.
+- Für jeden Mitarbeitenden wird ein PDF erzeugt, das für jeden Monat eine Seite enthält, befüllt mit den Daten des Mitarbeiters für diesen Monat.
+
+# Aufbau PDF-Template
+
+- Das PDF-Template ist eine einseitige PDF-Datei, generiert aus der ursprünglichen XLSX-Vorlage.
+- Jede zu befüllende Textstelle enthält einen Platzhalter: den Feldnamen gefolgt von `_Field`
+  (z. B. `Antragsnummer_Field`, `Name_Field`, `Stellenanteil in %_Field`, …).
+- Die App sucht im PDF nach allen `_Field`-Texten, ermittelt deren Position und Schriftgröße,
+  und ersetzt sie durch die tatsächlichen Datenwerte.
+
+# README
+
+In der README.md ist ein kleine Doku wie das Programm zu benutzen ist und welche Konfigurationsparameter es gibt.
+
+---
+
+## Phasen-Plan
+
+### Phase 1: Projekt-Grundgerüst & Konfiguration
+
+1. **`requirements.txt` befüllen** — `streamlit`, `openpyxl`, `PyMuPDF`
+2. **`config/settings.ini` befüllen** — Pfade, Standardwerte
+   - Abschnitte: `[paths]` (input_dir, template_dir, output_dir), `[output]` (filename_pattern → `.pdf`)
+3. **`config/input-fields.json` Schema definieren** — Spalten der Input-Tabelle mit ihren exakten Überschriften
+   - JSON-Array mit `column` (Spaltenbuchstabe), `field_name` (exakte Überschrift aus der Excel-Tabelle), `type` (string|number|date), `required` (true|false)
+4. **`config/output-fields.json` Mapping definieren** — Welche Input-Felder in das PDF geschrieben werden
+   - JSON-Array mit `source_field` (exakte Spaltenüberschrift aus der Input-Tabelle), `format` (optional, z. B. "dd.mm.yyyy")
+   - Der Platzhalter im PDF ist immer `{source_field}_Field` – kein explizites `target_cell` mehr nötig
+
+### Phase 2: Core-Module (`src/`)
+
+5. **`src/__init__.py` + `src/models.py`** — Datenklassen
+   - `EmployeeRecord`: name, vorname, nachname, antragsnummer, qualifikation, funktion, taetigkeit, stellenanteil, monat, jahr, … (Felder aus input-fields.json)
+   - `AppConfig`: geladene settings.ini + input/output-schemas
+6. **`src/config.py`** — Konfigurations-Loader
+   - `load_settings()`: liest `config/settings.ini` mit `configparser`
+   - `load_input_schema()`: liest `config/input-fields.json`
+   - `load_output_mapping()`: liest `config/output-fields.json`
+   - `get_available_input_files()`: listet `.xlsx`-Dateien in `input/`
+   - `get_available_templates()`: listet `.pdf`-Dateien in `template/`
+7. **`src/parser.py`** — Input-Datei einlesen (unverändert: openpyxl für XLSX-Input)
+   - `parse_input_file(filepath, schema)`: öffnet Workbook, iteriert über alle Sheets (Monate)
+   - Extrahiert Monat/Jahr aus Sheet-Namen oder Sheet-Inhalt
+   - Für jedes Sheet: liest Zeilen anhand des Schemas, erzeugt `EmployeeRecord`-Liste
+   - Rückgabe: `list[EmployeeRecord]`
+
+### Phase 3: Writer & Validierung (PDF-basiert)
+
+8. **`src/writer.py`** — PDF-Output generieren (NEU: PyMuPDF)
+   - `generate_activity_reports(employee_records, template_path, mapping, config)`:
+     - **Pre-Scan**: Öffnet das Template-PDF einmal und sucht nach allen `_Field`-Platzhaltern,
+       ermittelt deren Position (bounding box) und Schriftgröße
+     - Gruppiert Records nach Mitarbeiter
+     - Für jeden Mitarbeiter:
+       - Erstellt ein neues PDF
+       - Für jeden Monats-Record: fügt eine Kopie der Template-Seite ein
+       - Ersetzt alle `_Field`-Platzhalter durch die tatsächlichen Daten (redact + insert_text)
+       - Speichert als `{nachname}_{vorname}_Tätigkeitsnachweis.pdf` in `output/`
+9. **`src/validator.py`** — Eingabevalidierung (angepasst für PDF)
+   - `validate_input_file(filepath, schema)`: unverändert (prüft XLSX-Input)
+   - `validate_template(template_path, mapping)`: prüft ob alle `_Field`-Platzhalter im PDF gefunden werden
+
+### Phase 4: Streamlit UI
+
+10. **`app.py`** — Streamlit-Oberfläche (angepasst für PDF-Templates)
+    - Layout:
+      - Titel + Beschreibung
+      - `st.selectbox` für Input-Datei (aus `input/`-Folder)
+        - **Sofort bei Auswahl**: Validierung + Parsing der Datei
+        - Anzeige: Anzahl gefundener Mitarbeiter, Auflistung aller enthaltenen Antragsnummern
+      - `st.selectbox` für PDF-Template (aus `template/`-Folder)
+        - **Sofort bei Auswahl**: Validierung des PDF-Templates (Prüfung aller `_Field`-Marker)
+        - Anzeige: Anzahl gefundener Platzhalter-Felder
+      - **Mitarbeiter-Liste** (erscheint nach erfolgreicher Input-Validierung)
+        - `st.multiselect` mit allen gefundenen Mitarbeiternamen, standardmäßig alle vorselektiert
+      - `st.button("Tätigkeitsnachweise generieren")`
+    - Bei Button-Click:
+      1. Filtere Employee Records auf selektierte Mitarbeiter
+      2. Generiere PDFs nur für selektierte Mitarbeiter und speichere in `output/`
+      3. Zeige Erfolgsmeldung mit Liste der erstellten PDF-Dateien
+
+### Phase 5: Start-Skript & Doku
+
+11. **`start.bat`** — Windows Batch-Startdatei (unverändert)
+12. **`README.md` aktualisieren** — Vollständige Doku
+
+---
+
+## Relevante Dateien (zu erstellen/ändern)
+
+| Datei | Aktion |
+|-------|--------|
+| `requirements.txt` | `PyMuPDF` hinzufügen |
+| `config/settings.ini` | filename_pattern auf `.pdf` ändern |
+| `config/output-fields.json` | `target_cell` entfernen (wird durch `_Field`-Marker ersetzt) |
+| `src/writer.py` | Komplett neu: PDF-basierte Generierung mit PyMuPDF |
+| `src/validator.py` | `validate_template` für PDF anpassen |
+| `src/config.py` | `get_available_templates` auf `.pdf` umstellen |
+| `app.py` | Template-Validierung für PDF anpassen |
+| `coldrun.py` | An PDF-Template anpassen |
+| `tests/test_e2e.py` | Tests für PDF-Output anpassen |
+| `.copilot/PLAN.md` | Dieser Plan – aktualisiert |
+| `.copilot/TASKS.md` | Aufgabenliste – aktualisiert |
+| `CHANGELOG.md` | Changelog – wird bei jedem Version-Build erweitert |
+
+## Projektstruktur
+
+```
+/
+├── .copilot/
+│   ├── PLAN.md             ← diese Datei
+│   └── TASKS.md            ← Aufgabenliste
+├── input/
+│   └── *.xlsx              ← Tabelle mit den Input-daten
+├── config/
+│   ├── settings.ini        ← Einstellungen der App
+│   ├── input-fields.json   ← Schema der Inputdaten-Tabelle
+│   └── output-fields.json  ← Mapping: Input-Feld → PDF-Platzhalter
+├── output/                 ← Zielordner für generierte PDF-Dateien
+├── template/
+│   └── *.pdf               ← PDF-Template mit _Field-Platzhaltern
+├── src/
+│   ├── __init__.py
+│   ├── models.py
+│   ├── config.py
+│   ├── parser.py
+│   ├── writer.py           ← PDF-basierte Generierung (PyMuPDF)
+│   └── validator.py
+├── app.py                  ← Streamlit-App
+├── coldrun.py              ← CLI Cold-Run
+├── start.bat               ← Windows batch zum Start der App
+├── README.md               ← README für Programmbenutzer
+├── CHANGELOG.md            ← Changelog (wird bei jedem Version-Build erweitert)
+└── requirements.txt        ← streamlit, openpyxl, PyMuPDF
+```
+
+## Versionierung & Changelog
+
+Immer wenn das Signal zum Build einer neuen Version gegeben wird (z. B. „Build Version X.Y“ oder „neue Version bauen“), wird das **Changelog-Logfile** (`CHANGELOG.md` im Projekt-Root) um die **most recent changes** erweitert. Der Eintrag enthält:
+
+- **Versionsnummer** (z. B. `v1.2.0`)
+- **Datum** des Builds
+- **Neue Funktionen** (Features)
+- **Behobene Fehler** (Bugfixes)
+- **Sonstige Änderungen** (z. B. Refactoring, Doku-Updates)
+
+Der Changelog wird im [Keep a Changelog](https://keepachangelog.com/)-Format gepflegt und nach Semantic Versioning (`MAJOR.MINOR.PATCH`) versioniert.
+
+> **Wichtig**: Der Changelog-Eintrag wird **vor** dem eigentlichen Build-Vorgang erstellt, sodass die neue Version dokumentiert ist, bevor der Code ausgeliefert wird.
+
+---
+
+## Verifikation
+
+1. **Input-Datei-Analyse**: `2025 JM.xlsx` mit openpyxl öffnen, Sheet-Namen prüfen, Spaltenüberschriften validieren
+2. **PDF-Template-Analyse**: `Tätigkeitsnachweise Stellenförderung.pdf` mit PyMuPDF öffnen, alle `_Field`-Platzhalter suchen → mit `output-fields.json` abgleichen
+3. **Unit-Test**: App mit vorhandener Input-Datei und PDF-Template ausführen, prüfen ob Output-PDFs korrekt befüllt sind
+4. **Edge Cases**: Leere Input-Zeilen, fehlende Monate, Mitarbeiter ohne Vorname, Sonderzeichen in Namen, Umlaute im PDF
+```
@@ -0,0 +1 @@
+
@@ -1,108 +0,0 @@
-# SAB Taetigkeitsnachweise Generator - Implementierungsplan
-
-## Ziel
-Monatliche SAB-Taetigkeitsnachweise automatisiert erzeugen auf Basis von:
- PS_PW.xlsx (monatliche gefoerderte Stunden je Projektanteil)
- Stellenbeschreibungen.xlsx (Stammdaten je Mitarbeiter/Funktion)
- Taetigkeitsnachweis Stellenfoerderung.xlsx (Ausgabevorlage)
-
-## Scope
- Nur Verzeichnisse unter Tool verwenden.
- Eingaben nur aus input.
- Vorlage nur aus template.
- Ausgaben nur nach output.
-
-## Annahmen
- PS_PW.xlsx und Stellenbeschreibungen.xlsx enthalten jeweils Tabelle1.
- Monatsmarker in PS_PW.xlsx stehen in Zeile 2 im Format ab 01.MM.YYYY.
- Name ist primaerer Match-Schluessel zwischen beiden Quellen.
- Template hat genau ein Quellblatt, das geklont wird.
-
-## Architektur
- cli: Kommandozeilen-Einstieg und Orchestrierung
- parser: Einlesen und Normalisierung der beiden Quelldateien
- matcher: Zuordnung und Disambiguierung
- validator: Source- und Business-Validierung
- writer: Template-Klonen, Zellen befuellen, Speichern
- model: gemeinsame Datentypen
- util: Konvertierung, Datums-/Text-Helfer, Logging
-
-## Reihenfolge (Task-Flow)
-1. T1 Plan finalisieren
-2. T2 Konfiguration definieren
-3. T3 Projektgeruest anlegen
-4. T4 Abhaengigkeiten einrichten
-5. T5 Parser PS_PW
-6. T6 Parser Stellenbeschreibungen
-7. T7 Foerderquote berechnen
-8. T8 Matching-Engine
-9. T9 Source-Validierung
-10. T10 Business-Validierung
-11. T11 Template-Verarbeitung
-12. T12 Dateinamen + Persistenz
-13. T13 CLI Pipeline
-14. T14 Vorschau + Bestaetigung
-15. T15 Smoke-Test
-16. T16 Fachtests
-17. T17 Ergebnisabnahme
-
-## Definition of Done je Task
-
-### T1 Plan final
- DoD: Dieser Plan ist vollstaendig, nachvollziehbar und in Reihenfolge mit klarer DoD-Liste dokumentiert.
-
-### T2 config.json
- DoD: Alle Pfade, Dateinamen, Sheetnamen, Spalten, Zielzellen und Dateinamenregeln sind extern konfigurierbar.
-
-### T3 Projektgeruest
- DoD: Ordner-/Modulstruktur steht, zentrale Datentypen und Fehler-/Log-Basis sind vorhanden.
-
-### T4 Abhaengigkeiten
- DoD: requirements gepflegt, lokale Installation dokumentiert, Ausfuehrung startet ohne Importfehler.
-
-### T5 Parser PS_PW
- DoD: Monatsspalte wird eindeutig gefunden, Records sind normalisiert und Mitarbeiterkontext korrekt vererbt.
-
-### T6 Parser Stellenbeschreibungen
- DoD: Stammdaten sauber eingelesen, Prozentwerte robust konvertiert, Mehrfacheintraege bleiben erhalten.
-
-### T7 Foerderquote
- DoD: Formel korrekt implementiert, Grenz-/Rundungsfaelle dokumentiert und testsicher.
-
-### T8 Matching
- DoD: Eindeutige Zuordnung pro aktivem Record oder klarer Fehlerstatus (missing/ambiguous).
-
-### T9 Source-Validierung
- DoD: Alle Struktur- und Formatpruefungen laufen vor Verarbeitung und liefern konkrete Fehlermeldungen.
-
-### T10 Business-Validierung
- DoD: Aktivitaet, Eindeutigkeit, Template-Regeln und Dateinamenkollisionen werden vor dem Schreiben geprueft.
-
-### T11 Template-Verarbeitung
- DoD: Ein Quellblatt wird pro Zuordnung geklont und korrekt mit assignment-spezifischen Werten befuellt.
-
-### T12 Dateinamen/Speichern
- DoD: Ausgabedateien folgen Muster Taetigkeitsnachweis_YYYY_MM_Vorname_Nachname.xlsx und werden konfliktfrei gespeichert.
-
-### T13 CLI
- DoD: generate.py akzeptiert month/year, orchestriert End-to-End und liefert sinnvolle Exit-Codes.
-
-### T14 Vorschau/Bestaetigung
- DoD: Vor Schreibzugriff wird Vorschau angezeigt; Abbruch ist ohne Dateiaenderung moeglich.
-
-### T15 Smoke-Test
- DoD: Mindestens ein realer Monatslauf erzeugt valide Dateien in output.
-
-### T16 Fachtests
- DoD: Abdeckung fuer Mehrfachzuordnung, fehlende Matches, ungueltige Monatsmarker und fehlende Struktur.
-
-### T17 Ergebnisabnahme
- DoD: Pflichtfelder, Monats-/Datumswerte und Taetigkeitstexte stimmen mit Template- und Fachregeln ueberein.
-
-## Risiko- und Entscheidungslog
- Name-Matching kann uneinheitliche Schreibweisen enthalten; ggf. Normalisierung (Whitespace/Kommas) zentral in util.
- Prozentvergleich kann Rundungsabweichungen haben; toleranzbasierten Vergleich definieren.
- Mehrdeutige Matches nicht still aufloesen; immer sichtbar validieren.
-
-## Start der Umsetzung
- Aktiver Schritt: T2 (Konfiguration als naechste technische Umsetzung)
@@ -1,121 +0,0 @@
-# SAB Taetigkeitsnachweise Generator - Aufgabenliste
-
-## Ziel
-Projekt vollstaendig umsetzen: aus PS_PW.xlsx und Stellenbeschreibungen.xlsx monatliche Taetigkeitsnachweise per Template erzeugen.
-
-## Arbeitsmodus
- [ ] Immer nur genau eine Aufgabe aktiv bearbeiten.
- [ ] Nach Abschluss jeder Aufgabe: Ergebnis pruefen und abhaken.
- [ ] Bei Blockern: Fehler dokumentieren und naechsten konkreten Schritt notieren.
- [ ] Nach jedem erledigten task einen git commit erzeugen
-
-## Phase 1 - Planung und Konfiguration
- [x] T1: Plan final im Plan-Dokument pflegen (Scope, Annahmen, Reihenfolge, DoD pro Aufgabe).
- [x] T2: `config.json` Struktur festlegen
-	- [ ] Pfade fuer `input/`, `template/`, `output/`
-	- [ ] Dateinamen der drei Excel-Dateien
-	- [ ] Sheetnamen und Spaltenzuordnung je Quelle
-	- [ ] Zielzellen-Mapping fuer Template
-	- [ ] Dateinamenmuster fuer Ausgaben
-	- [ ] Regeln fuer Monatsmarker und Datumsformat
-
-## Phase 2 - Projektgeruest und Basiskomponenten
- [x] T3: Python-Projektstruktur anlegen
-	- [x] Modulaufteilung (cli, parser, matcher, validator, writer, model, util)
-	- [x] Gemeinsame Datenmodelle (z. B. dataclasses) definieren
-	- [x] Zentrales Logging/Fehlermodell vorbereiten
- [x] T4: Abhaengigkeiten und Laufzeit vorbereiten
-	- [x] benoetigte Pakete festlegen (z. B. openpyxl, click)
-	- [x] requirements-Datei pflegen
-	- [x] Startkommando fuer lokale Ausfuehrung dokumentieren
-
-## Phase 3 - Einlesen der Quelldaten
- [x] T5: Parser fuer PS_PW.xlsx implementieren
-	- [x] Monatsmarker in Zeile 2 erkennen und parsen (`ab 01.MM.YYYY`)
-	- [x] Zielspalte fuer requested month/year eindeutig bestimmen
-	- [x] Mitarbeiterkontext ueber Mehrzeilen-Eintraege vererben
-	- [x] Werte normalisieren (`-`, `0`, leer, numerisch)
-	- [x] Normalisierte Records erzeugen
- [x] T6: Parser fuer Stellenbeschreibungen.xlsx implementieren
-	- [x] Felder ID, Antragsnummer, Name, Qualifikation, Stellenanteil, Funktion, Taetigkeit einlesen
-	- [x] Prozentwerte (deutsches Dezimalformat) robust in Zahlen umwandeln
-	- [x] Mehrfache Eintraege je Name korrekt behalten
-
-## Phase 4 - Matching und Fachlogik
- [x] T7: Foerderquote berechnen
-	- [x] Formel: funded_weekly_hours / contract_weekly_hours * 100
-	- [x] Rundungs-/Vergleichsregeln definieren
- [x] T8: Matching-Engine bauen
-	- [x] Primaerschluessel Name anwenden
-	- [x] Kandidaten via Stellenanteil/Foerderquote aufloesen
-	- [x] Ambigue und fehlende Treffer sauber markieren
-	- [x] Hinweise aus Bemerkungsspalte als Validierungshinweis weitergeben
-
-## Phase 5 - Validierung
- [x] T9: Source-Validierung implementieren
-	- [x] Dateien vorhanden und lesbar
-	- [x] Benoetigte Sheets vorhanden
-	- [x] Spalten vorhanden
-	- [x] Monatsmarker parsebar
-	- [x] Gewuenschter Monat exakt einmal vorhanden
-	- [x] Stunden-/Vertragswerte gueltig
- [x] T10: Business-Validierung implementieren
-	- [x] Mindestens ein aktiver Fall vorhanden
-	- [x] Jeder aktive Fall hat eindeutigen Match oder klaren Fehler
-	- [x] Template enthaelt genau ein Quellblatt
-	- [x] Dateinamenkollisionen vermeiden
-	- [x] Pflicht-Zielzellen vollstaendig konfiguriert
-
-## Phase 6 - Ausgabeerzeugung
- [x] T11: Template-Verarbeitung bauen
-	- [x] Template-Workbook laden
-	- [x] Sheet pro aktiver Zuordnung klonen
-	- [x] Inhalte assignment-spezifisch in Zielzellen schreiben
- [x] T12: Dateinamen und Speichern
-	- [x] Muster: `Taetigkeitsnachweis_YYYY_MM_Vorname_Nachname.xlsx`
-	- [x] Pro Mitarbeiter genau eine Datei pro Monat erzeugen
-	- [x] Bei mehreren Zuordnungen: mehrere Sheets in derselben Datei
-
-## Phase 7 - CLI und Benutzerfluss
- [x] T13: CLI in `generate.py` implementieren
-	- [x] Parameter `--month` und `--year`
-	- [x] Pipeline orchestrieren: parse -> match -> validate -> preview -> write
-	- [x] Kontrollierter Exit-Code bei Fehlern
- [x] T14: Vorschau + Bestaetigung vor Schreiben
-	- [x] Uebersicht zu Berichtsmonat, aktiven Faellen, Fehlern
-	- [x] Liste der geplanten Ausgabedateien
-	- [x] Interaktive Bestaetigung (Abbruch ohne Schreibzugriff moeglich)
-
-## Phase 8 - Tests und Abnahme
- [ ] T15: Smoke-Test fuer End-to-End-Lauf
-	- [x] Beispielmonat ausfuehren
-	- [x] Pipeline laeuft bis Dateiausgabe durch (0 Dateien, da 0 gematchte Faelle)
-	- [ ] Dateien in `output/` entstehen erwartungsgemaess
-	- [ ] DATENBLOCKER: `Stellenbeschreibungen.xlsx` enthaelt nur Meyer,Johannes (25%/75%).
-	      Alle anderen aktiven Mitarbeiter aus PS_PW.xlsx fehlen als Stammdaten.
-	      Meyer's Foerderquote (85%/15%) stimmt nicht mit eingetragenem Stellenanteil (25%/75%) ueberein.
-	      -> Stellenbeschreibungen.xlsx mit allen aktiven Mitarbeitern und korrekten Anteilen befuellen.
-	- [x] Template-Zielzellen konfiguriert (A3, A17, Q17, A21, Q21, A25, A31, I95)
-	- [x] Template-Sheet-Pfad konfiguriert (<MM_YYYY>_<Stellenbeschreibung>)
- [ ] T16: Fachtests definieren und ausfuehren
-	- [ ] Mehrfachzuordnung eines Mitarbeiters
-	- [ ] Fehlender Match
-	- [ ] Ungueltige Monatsmarker
-	- [ ] Fehlende Pflichtspalte/Sheet
- [ ] T17: Ergebnispruefung gegen Template-Regeln
-	- [ ] Pflichtfelder korrekt befuellt
-	- [ ] Taetigkeitstext inkl. Zeilenumbrueche korrekt
-	- [ ] Datums- und Monatsanzeige korrekt
-
-## Umsetzungsreihenfolge
-1. T1 -> T2
-2. T3 -> T4
-3. T5 und T6 (danach zusammenfuehren)
-4. T7 -> T8
-5. T9 -> T10
-6. T11 -> T12
-7. T13 -> T14
-8. T15 -> T16 -> T17
-
-## Aktueller Startpunkt
- [ ] Naechste aktive Aufgabe: T15 (Smoke-Test fuer End-to-End-Lauf)
@@ -1,322 +0,0 @@
---
-description: "Use when implementing, extending, or reviewing the application. Contains the full application masterplan, data sources, workbook mapping rules, and generation logic for SAB Tätigkeitsnachweise."
-applyTo: "**/*.py"
---
-
-# Application Masterplan: SAB Taetigkeitsnachweis Generator
-
-## Purpose
-
-A Python program that reads personnel allocation data from two Excel workbooks and generates monthly SAB Taetigkeitsnachweise as Excel files based on a dedicated template workbook.
-
-The application exists to replace a manual process that currently causes two recurring problems:
-
-1. Incomplete monthly Taetigkeitsnachweise because employees submit them late or not at all.
-2. Incorrect entries because staffing shares, project assignments, and role changes vary over time and are no longer reliable to maintain manually.
-
-The system must therefore produce monthly, auditable, and consistent output from a central data basis.
-
-## Project Scope and Paths
-
-The tool must operate exclusively below `Tool/`.
-
- Input files are read only from `Tool/input/`.
- Template files are read only from `Tool/template/`.
- Generated files are written only to `Tool/output/`.
- No runtime reads/writes are allowed outside `Tool/`.
-
-## Source Workbooks
-
-The implementation is based on three concrete Excel files.
-
-### 1. Allocation Overview: `PS_PW.xlsx`
-
-This workbook is the monthly allocation matrix that determines how many funded hours a person has in each project for each month.
-
-Observed structure in `Tabelle1`:
-
- Column `A`: Employee name in `Last name, First name` format.
- Column `B`: Contracted weekly hours / AV.
- Column `C`: Project or assignment key, e.g. `PS`, `PW`, `BeWo`, `NB`, `PS / NB`.
- Columns `D` to at least `H`: One funded-hours column per month.
- Row `2`: Month markers per column, e.g. `ab 01.01.2026`, `ab 01.02.2026`, `ab 01.03.2026`, `ab 01.04.2026`, `ab 01.05.2026`.
- Column `I` (or next free column after month values): Free-text remarks describing assignment changes.
-
-Interpretation rules:
-
- Each person can span multiple consecutive rows when they have multiple project shares.
- The first row of a person contains the name and total weekly hours.
- Following rows without a name belong to the same person and describe additional project shares.
- Numeric values in the month columns are funded weekly hours for the respective month.
- zero (0) or `-` means no funded share in that project for that month.
- Free-text remarks may contain clarifying timing details and must be surfaced in validation output, but the primary logic is driven by the structured columns, not by parsing remarks.
-
-### 2. Central Master Data: `Stellenbeschreibungen.xlsx`
-
-This workbook is the central basis data source for descriptive person/project content used to fill the SAB form.
-
-Observed structure in `Tabelle1`:
-
-| Column | Meaning |
-|---|---|
-| `A` | `ID` |
-| `B` | `Antragsnummer` |
-| `C` | `Name` |
-| `D` | `Qualifikation` |
-| `E` | `Stellenanteil` |
-| `F` | `Funktion` |
-| `G` | `Taetigkeit` |
-
-Interpretation rules:
-
- One employee can appear multiple times with different `Stellenanteil` and `Funktion` values.
- `Stellenanteil` is stored as a percentage-like value such as `25,00` or `75,00`.
- `Tätigkeit` contains multi-line free text that must be written into the SAB template unchanged except for Excel-compatible line break handling.
- `Antragsnummer` is sourced from this workbook when a matching employee/function combination exists.
-
-### 3. SAB Output Template: `Tätigkeitsnachweis Stellenförderung.xlsx`
-
-This workbook is the Excel output format mandated by SAB and is the dedicated template base for generated files.
-
-Template rule:
-
- The template workbook contains exactly one sheet.
- This one sheet is the blueprint that must be copied for generated sheets.
-
-Observed content blocks in the workbook:
-
- `Antragsnummer`
- `Name, Vorname`
- `Qualifikation`
- `Funktion`
- `Taetigkeiten inkl. Angaben zu Dienstreisen fuer das Projekt im Abrechnungszeitraum`
- final declaration / signature section
-
-The generator must treat this workbook as the authoritative structure for the output file. Placeholder values in the template, if present, are ignored and overwritten during generation. Exact target cells or named ranges are implementation details and must be externalized in configuration once confirmed.
-
-## Core Business Goal
-
-For a requested reporting month, generate one SAB Taetigkeitsnachweis per active employee assignment so that the document shows the correct funded staff share for that month.
-
-The generated workbook must combine:
-
- allocation hours from `PS_PW.xlsx`
- descriptive employee master data from `Stellenbeschreibungen.xlsx`
- layout and target cells from `Tätigkeitsnachweis Stellenförderung.xlsx`
-
-## Reporting Model
-
-### Reporting Period
-
-The CLI works on a single target month and year, for example `04/2026`.
-
-The application must determine the single month column from `PS_PW.xlsx` that matches the requested month.
-
-### Monthly Column Resolution
-
-The date markers in row `2` of `PS_PW.xlsx` define one column per month. For a target month:
-
-1. Read all month markers from row `2`.
-2. Parse each marker as first day of month (`ab 01.MM.YYYY`).
-3. Select the column whose parsed date exactly matches the requested month and year.
-4. Use this single column value as the funded weekly hours for that employee/project row.
-5. If the value is `-`, `0`, or empty, the employee/project combination is not active for that month.
-
-### Employee Grouping in `PS_PW.xlsx`
-
-Because some rows omit the employee name, the parser must normalize the sheet into records with an inherited person context.
-
-Normalized record shape:
-
-| Field | Source |
-|---|---|
-| `employee_name` | current non-empty value from column `A` |
-| `contract_hours_weekly` | current non-empty value from column `B` |
-| `project_key` | column `C` |
-| `monthly_hours` | single month column selected from `D+` via row `2` |
-| `notes` | remarks column when present |
-
-Rows without a project key are ignored.
-
-## Matching Logic Across Workbooks
-
-The generator must join records across the two source workbooks.
-
-### Primary Match Key
-
- `Name` in `Stellenbeschreibungen.xlsx` matches `employee_name` from normalized `PS_PW.xlsx` records.
-
-### Secondary Disambiguation
-
-If one person has multiple master-data rows in `Stellenbeschreibungen.xlsx`, choose the row whose `Stellenanteil` best matches the funded share derived from `PS_PW.xlsx` for the requested month.
-
-Derived funded share formula:
-
-$$
-Foerderquote = (funded_weekly_hours / contract_weekly_hours) * 100
-$$
-
-Example:
-
- contract weekly hours = `20`
- funded weekly hours = `10`
- Foerderquote = `50 %`
-
-Matching rule:
-
- Convert `Stellenbeschreibungen.xlsx`.`Stellenanteil` from German decimal text to a numeric percentage.
- Choose the row whose percentage equals the derived Foerderquote.
- If several rows match, prefer the one whose `Funktion` best matches the assignment context or require explicit disambiguation in validation output.
-
-### Missing Match Handling
-
-If no master-data row can be matched for an active allocation record:
-
- log a validation error
- do not silently invent qualification, function, or activity text
- depending on CLI mode, either skip that record or abort the full generation run
-
-## Output Workbook Structure
-
-Each generated file is an Excel workbook derived from the SAB template. One file corresponds to one employee for one reporting month.
-
-Sheet rule for multiple assignments:
-
- If an employee has one active assignment in the month, the output workbook contains one sheet.
- If an employee has multiple active assignments (multiple Stellen/Funktionen) in the month, the output workbook must contain one separate sheet per assignment.
- Every generated sheet is a copy of the single template sheet and is then filled with the assignment-specific data.
-
-Required logical output fields:
-
-| Output field | Source |
-|---|---|
-| `Antragsnummer` | `Stellenbeschreibungen.xlsx`.`Antragsnummer` |
-| `Name, Vorname` | matched employee name |
-| `Qualifikation` | `Stellenbeschreibungen.xlsx`.`Qualifikation` |
-| `Funktion` | `Stellenbeschreibungen.xlsx`.`Funktion` |
-| `Taetigkeiten ...` | `Stellenbeschreibungen.xlsx`.`Taetigkeit` |
-| reporting month label | derived from CLI month/year |
-| Foerderquote / Stellenanteil for the month | derived from `PS_PW.xlsx` and contract hours |
-| generated-on date | current system date |
-
-If the SAB sheet requires additional header or footer fields that are not yet represented in the example extraction, those mappings must be added to configuration, not hardcoded into business logic.
-
-## File Generation Strategy
-
- The generator creates one output workbook per employee and month.
- The generator copies the single configured template sheet as many times as needed.
- It writes the matched values into configured target cells.
- It saves one output file per employee for the target month.
-
-Recommended default filename pattern:
-
-`Tätigkeitsnachweis_<YYYY>_<MM>_<FirstName>_<LastName>.xlsx`
-
-If an employee has multiple active assignments in the same month, the resulting Excel file contains one separate sheet per assignment.
-
-## Validation Rules
-
-Before any workbook is written, the application must run a full validation phase.
-
-### Source Validation
-
-| Check | Description |
-|---|---|
-| Source files exist | `Tool/input/PS_PW.xlsx`, `Tool/input/Stellenbeschreibungen.xlsx`, and `Tool/template/Tätigkeitsnachweis Stellenförderung.xlsx` are readable |
-| Required sheets exist | `Tabelle1` exists in both source workbooks; configured template sheet exists |
-| Month-marker row valid | Row `2` in `PS_PW.xlsx` contains parseable monthly markers `ab 01.MM.YYYY` |
-| Requested month exists | Exactly one month column in `PS_PW.xlsx` matches the requested month/year |
-| Required columns exist | all configured columns are present in both source workbooks |
-| Hour values valid | resolved funded hour values are numeric, `0`, or `-` |
-| Contract hours valid | total weekly hours are numeric and greater than `0` |
-| Share values valid | derived Förderquote is between `0` and `100` unless explicitly allowed otherwise |
-| Master-data match exists | every active record can be matched to one descriptive row or is reported as ambiguous/missing |
-
-### Business Validation
-
-| Check | Description |
-|---|---|
-| Active assignment exists | at least one normalized allocation record resolves to funded hours > `0` in the requested month |
-| Match uniqueness | each generated output uses exactly one master-data row |
-| Template has one sheet | configured template workbook contains exactly one source sheet to clone |
-| Output filename unique | no two generated files resolve to the same path |
-| Required template targets configured | all mandatory target cells are configured before writing |
-
-Validation errors are logged and summarized. They must never be silently ignored.
-
-## Console Preview and Confirmation
-
-After validation and before writing files, show a preview similar to:
-
-```text
-=== Vorschau der ermittelten Werte ===
-Berichtsmonat : 04/2026
-PS_PW-Datei   : PS_PW.xlsx
-Stammdaten    : Stellenbeschreibungen.xlsx
-Vorlage       : Tätigkeitsnachweis Stellenförderung.xlsx
-Aktive Faelle : 8
-Fehler        : 0
-
--- Zu erzeugende Taetigkeitsnachweise ---
-  Mitarbeitende(r)       Projekt   Funktion              Stunden   Quote
-  Meyer, Johannes        PS        Produktionsschulleiter 10 / 40   25,00 %
-  Meyer, Johannes        PW        Soz. Paed              30 / 40   75,00 %
-  ...
-
-Moechten Sie die Dateien erzeugen? [j/N]
-```
-
- If validation errors exist, print them before the prompt.
- Continue only if the user explicitly confirms with `j`.
- Any other input aborts the run without writing output files.
-
-## Configuration Rules
-
-All environment-specific details must be stored in `config.json`.
-
-Configuration must include at least:
-
- path to `Tool/input/PS_PW.xlsx`
- path to `Tool/input/Stellenbeschreibungen.xlsx`
- path to `Tool/template/Tätigkeitsnachweis Stellenförderung.xlsx`
- source sheet names
- source column mappings
- row number for month markers in `PS_PW.xlsx`
- template sheet selection strategy
- output cell mappings
- output directory (`Tool/output/`)
- filename pattern
-
-No workbook-specific coordinates may be buried directly inside business logic.
-
-## CLI Requirements
-
-The CLI entry point is `generate.py` using Click.
-
-Required arguments:
-
- `--month` target month as `MM`
- `--year` target year as `YYYY`
-
-Optional arguments:
-
- `--employee` limit generation to one employee name
- `--project` limit generation to one project key
- `--dry-run` run validation and preview without writing files
-
-## Testing Requirements
-
-All business logic must be covered by tests in `tests/`.
-
-At minimum, tests must cover:
-
- inheritance of employee context across multiple `PS_PW.xlsx` rows
- resolution of the correct month column for a requested month
- conversion of German decimal percentages such as `25,00`
- Foerderquote calculation
- matching of one employee to multiple master-data rows by `Stellenanteil`
- skipping inactive `-` assignments
- validation for missing and ambiguous matches
- generation of collision-free output filenames
-
-Tests must not depend on real employee names or on the exact attached workbooks.
@@ -1,48 +0,0 @@
---
-applyTo: '**'
---
-
-<!-- skill: caveman | description: Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra, wenyan-lite, wenyan-full, wenyan-ultra. Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens", "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested. -->
-
-Respond terse like smart caveman. All technical substance stay. Only fluff die.
-
-## Persistence
-
-ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active
-if unsure. Off only: "stop caveman" / "normal mode".
-
-Default: full. Switch: `/caveman lite|full|ultra`.
-
-## Rules
-
-Drop: articles (a/an/the), filler (just/really/basically/actually/simply),
-pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short
-synonyms (big not extensive, fix not "implement a solution for"). Technical terms
-exact. Code blocks unchanged. Errors quoted exact.
-
-Pattern: `[thing] [action] [reason]. [next step].`
-
-Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is
-likely caused by..." Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
-
-## Intensity
-
-| Level | Behavior |
-|-------|----------|
-| lite | No filler/hedging. Keep articles + full sentences. Professional but tight |
-| full | Drop articles, fragments OK, short synonyms. Classic caveman |
-| ultra | Abbreviate (DB/auth/config/req/res/fn/impl), strip conjunctions, arrows for causality (X → Y), one word when one word enough |
-| wenyan-lite | Semi-classical. Drop filler/hedging but keep grammar structure, classical register |
-| wenyan-full | Maximum classical terseness. Fully 文言文. 80-90% character reduction |
-| wenyan-ultra | Extreme abbreviation while keeping classical Chinese feel. Maximum compression |
-
-## Auto-Clarity
-
-Drop caveman for: security warnings, irreversible action confirmations,
-multi-step sequences where fragment order risks misread, user asks to clarify or repeats
-question. Resume caveman after clear part done.
-
-## Boundaries
-
-Code/commits/PRs: write normal. "stop caveman" or "normal mode": revert. Level
-persist until changed or session end.
@@ -1,30 +0,0 @@
---
-applyTo: '**'
---
-
-This is a very professional terminal project on Windows.
-The outline and the structure of the project is very well planned and organized written down in the application masterplan instruction file. 
-
-# Write Code
-
-You must always make a plan before you write a programm or implement something!
-
-# Make a Plan
-
-Write down your plan into the planning file at: .github\copilot-plan.md
-
-# Create Tasks
-
- If your plan contains more than 3 issues to work on, create Tasks for every single issue.
- Write down the tasks into the task file: .github\copilot-tasks.md
- Work only a a single task at a time. Work every single task step by step.
-
-# Questions
-
-If the user or I do ask a question, you think about the question and if nessesary ask importand questions back to clarify the context. Than try to find information about the aked question and additional informations.
-
-If I ask a question, don't implement some solution directly, but ask me what to do and ask questions back to clarify the context if nessesary.
-
-# Commit changes in git 
-
-Git commits must be always atomic and be written in plain english.
@@ -1 +1,67 @@
-__pycache__
+### macOS
+# Finder metadata
+.DS_Store
+
+# Thumbnails
+._*
+
+# Custom folder icons
+Icon␍
+
+# Volume root files
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+### Windows
+# Windows thumbnail cache files
+Thumbs.db
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows shortcuts
+*.lnk
+
+### Linux
+# Backup files
+*~
+
+# Temporary files from deleted open files
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder
+.Trash-*
+
+# NFS temporary files
+.nfs*
+
+### VS Code
+# VSCode settings (keep shared configuration)
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+3_Archiv
+2_build
+
+# Python-Test- und Build-Artefakte
+__pycache__/
+.pytest_cache/
@@ -0,0 +1,9 @@
+input/
+output/
+.venv/
+__pycache__/
+.DS_Store
+.~lock.*#
+*.xlsx#
+~*.xlsx
+/versions
@@ -0,0 +1,184 @@
+# Changelog
+
+Alle nennenswerten Änderungen an diesem Projekt werden in dieser Datei dokumentiert.
+
+Das Format basiert auf [Keep a Changelog](https://keepachangelog.com/de/1.1.0/),
+und dieses Projekt folgt [Semantic Versioning](https://semver.org/lang/de/).
+
+---
+
+## [1.4] – 2026-11-03
+
+### Hinzugefügt
+
+- automatische Update Funktion
+---
+
+## [1.3.4] – 2026-11-03
+
+### Aktualisiert
+- Template PDF erneuert. Neues und altes PDF sind nun enthalten
+
+---
+
+## [1.3.3] – 2026-10-07
+
+### Behoben
+
+- internal development changes
+
+---
+
+## [1.3.2] – 2026-10-07
+
+### Hinzugefügt
+
+- **Input-Dateien hinzufügen**: Bei leerem Input-Ordner können `.xlsx`-Dateien per Drag-and-drop oder Dateiauswahl in den Input-Ordner kopiert werden
+- **Input-Ordner öffnen**: Ein Button öffnet den Input-Ordner direkt im Explorer
+- **Input-Ordner neu einlesen**: Dateiliste kann über Button aktualisiert werden
+
+### Behoben
+
+- EXE erkennt laufende Entwicklungsinstanz und fragt vor dem Neustart
+
+---
+
+## [1.3.1] – 2026-10-07
+
+### Behoben
+
+- Python script erkennt jetzt laufende Entwicklungsinstanz und fragt vor dem Neustart
+
+---
+
+## [1.3] – 2026-08-11
+
+### Hinzugefügt
+
+- **Monatsauswahl pro Mitarbeiter**: Tätigkeitsnachweise können nun für individuell gewählte Monate erzeugt werden.
+  - Die Monatsauswahl erscheint rechts neben der Mitarbeiterliste für die zuletzt angeklickte Person.
+  - Die Auswahl wird in Kurzform direkt hinter dem Namen angezeigt, z. B. `(Jan, Mär, Dez)`.
+  - Standardmäßig sind die letzten zwei vorhandenen Monate ausgewählt.
+  - Schaltflächen zum Auswählen bzw. Abwählen aller Monate ergänzen die Monatsliste.
+
+- **Versionsprüfung**: Die App prüft beim Start im zentralen SMB-Verzeichnis auf neuere
+  `Tätigkeitsnachweis-Generator vX.Y.Z.zip`- und künftig auch `.exe`-Dateien.
+
+- **Versionsanzeige**: Die aktuell installierte Programmversion wird dezent am unteren rechten Rand der App angezeigt.
+
+### Geändert
+
+- **Mitarbeiterauswahl**: Mitarbeiter sind nach dem Einlesen einer Input-Datei nicht mehr standardmäßig ausgewählt.
+  Die Buttons zum Auswählen bzw. Abwählen aller Mitarbeiter befinden sich direkt über der Mitarbeiterliste.
+
+- **Update-Hinweis**: Bei einer neueren zentralen Version wird ein schwebender Hinweis oben rechts angezeigt,
+  einschließlich Schließen- und Ordner-Schaltfläche.
+
+---
+
+## [1.2.1] – 2026-06-30
+
+### Behoben
+
+- **Build-Pipeline**: fix broken server start and page call
+
+---
+
+## [1.2] – 2026-06-30
+
+### Hinzugefügt
+
+- **Build-Pipeline** (`1_build-pipeline/`): Skripte zum Erstellen einer standalone `.exe`:
+  - `build.bat` / `build.py`: Orchestrierter Build mit **Semantic Versioning** – liest aktuelle Version
+    aus `CHANGELOG.md`, bump't nach Wahl (major/minor/patch) und aktualisiert das Changelog automatisch
+  - `build.spec`: PyInstaller-Spec-Datei mit allen Hidden Imports für Streamlit, openpyxl und PyMuPDF
+  - `run.py`: Einstiegspunkt für die gebundelte `.exe` – setzt Pfade via `APP_BASE_DIR`,
+    startet den Streamlit-Server und öffnet den Browser
+  - Ausgabe nach `2_build/` mit fertiger Ordnerstruktur (`config/`, `input/`, `template/`, `output/`)
+
+- **`app.py`** unterstützt jetzt `APP_BASE_DIR`-Umgebungsvariable für Pfadauflösung im gebundelten Modus
+
+### Geändert
+
+- **Statische Schriftgröße** (`src/writer.py`): Schriftgröße wird nicht mehr dynamisch aus dem PDF-Template extrahiert,
+  sondern statisch aus `settings.ini` (`[font]` → `fontsize`) gelesen, einheitlich für alle Felder.
+  `AppConfig` um `fontsize` erweitert, `config.py` lädt den Wert.
+
+- **Autoskalierung entfernt** (`src/writer.py`): Die automatische Schriftverkleinerung für lange Texte
+  (`Qualifikation_Field`, `Funktion_Field`) wurde ersatzlos gestrichen – alle Texte haben exakt dieselbe Größe.
+
+- **Vertikale Textzentrierung** (`src/writer.py`): Einzeilige Felder werden jetzt vertikal mittig im
+  Marker-Rechteck platziert. Mehrzeilige Felder (`Tätigkeiten_Field`, `Dienstreisen_Field`) bleiben
+  oben ausgerichtet.
+
+- **Doppelte Felder unterstützt** (`src/writer.py`): `Datum_Field` und andere Marker, die mehrfach im
+  PDF-Template vorkommen, werden jetzt alle mit demselben Wert befüllt.
+
+- **Stellenanteil-Formatierung** (`src/writer.py`): `Stellenanteil in %` wird mit deutschem Dezimalkomma
+  und zwei Nachkommastellen ausgegeben (z. B. `75` → `75,00`).
+
+---
+
+## [1.1] – 2026-06-24
+
+### Hinzugefügt
+
+- **Streamlit-Web-UI** (`app.py`) mit:
+  - Dropdown zur Auswahl der Input-Datei (`.xlsx`) aus dem `input/`-Ordner – mit Sofort-Validierung und Anzeige von Mitarbeiteranzahl, Antragsnummern und Einträgen pro Monat
+  - Dropdown zur Auswahl des PDF-Templates aus dem `template/`-Ordner – mit Sofort-Validierung und Anzeige gefundener `_Field`-Platzhalter
+  - Mitarbeiter-Multiselect-Liste mit „Alle auswählen“ / „Keine auswählen“-Buttons
+  - „Tätigkeitsnachweise generieren“-Button mit Fortschrittsanzeige
+  - Session-State-Caching für Validierung und Parsing (kein erneutes Einlesen bei UI-Reruns)
+  - Erfolgsmeldung mit Liste generierter Dateien und Button zum Öffnen des Output-Ordners
+
+- **PDF-basierte Generierung** (`src/writer.py`) via PyMuPDF (fitz):
+  - Pre-Scan aller `_Field`-Platzhalter im Template-PDF über **alle Seiten**
+  - Automatische Erkennung von Position (Bounding Box) und Schriftgröße jedes Platzhalters
+  - Redact + Insert-Text-Verfahren: Platzhalter werden geschwärzt und durch echte Daten ersetzt
+  - Unterstützung für **mehrseitige Templates** (z. B. 2 Seiten pro Monat)
+  - **Mehrzeilige Textboxen** (`Tätigkeiten_Field`, `Dienstreisen_Field`) mit automatischem Wortumbruch
+  - **Automatische Schriftgrößen-Anpassung** bei langen Texten in Qualifikation und Funktion (Autoscale)
+  - Prozentwerte werden als Ganzzahl ohne `%`-Zeichen ausgegeben
+  - Datumsformat `dd.mm.yyyy` wird automatisch aus dem Monatsfeld (`MM.JJ`) berechnet
+  - Ort standardmäßig „Dresden“
+  - Dateiname: `{Nachname}_{Vorname}_Tätigkeitsnachweis.pdf`
+
+- **Input-Parsing** (`src/parser.py`):
+  - Einlesen von `.xlsx`-Dateien mit openpyxl – ein Sheet pro Monat
+  - Monats-Sheet-Erkennung per Wildcard-Pattern (`* 20??`)
+  - Prozentwert-Konvertierung: Excel-Prozentwerte (0.5 → 50) oder Ganzzahlen (50 → 50)
+  - Automatisches Überspringen leerer Zeilen (Name oder Antragsnummer fehlt)
+  - Gruppierung der Records nach Mitarbeitername (`group_by_employee`)
+  - Hilfsfunktionen: `get_unique_antragsnummern`, `get_unique_employees`
+
+- **Validierung** (`src/validator.py`):
+  - Input-Datei: Prüft Existenz, Spaltenüberschriften (gegen `input-fields.json`), Datenzeilen pro Monats-Sheet
+  - Input-Daten: Erkennt leere Pflichtfelder pro Person und meldet betroffene Namen
+  - PDF-Template: Sucht alle `_Field`-Platzhalter im PDF und meldet fehlende
+  - Nicht-Monats-Sheets (z. B. „Alle Rollen“) werden ignoriert
+
+- **Konfigurationsdateien** (`config/`):
+  - `settings.ini`: Pfade für Input/Template/Output, Dateinamen-Pattern, Monats-Sheet-Pattern, Skip-Optionen
+  - `input-fields.json`: Spaltenschema der Input-Tabelle (9 Felder: ID, Kommentar, Antragsnummer, Name, Qualifikation, Funktion, Stellenanteil in %, Monat, Tätigkeit)
+  - `output-fields.json`: Mapping Input-Feld → `_Field`-Platzhalter im PDF (8 Felder)
+
+- **Datenmodell** (`src/models.py`):
+  - `EmployeeRecord`: Dataclass für eine Mitarbeiter-Zeile mit `month_index`- und `year`-Properties
+  - `FieldSchema`, `OutputMapping`, `AppConfig`, `ValidationResult`
+
+- **Cold Run** (`coldrun.py`): Headless-Generierung für die erste Person ohne GUI, automatisch mit erster Input- und Template-Datei
+
+- **Start-Skripte**: `start.bat` (Windows), `start.sh` / `start.command` (macOS/Linux)
+
+- **End-to-End-Tests** (`tests/test_e2e.py`):
+  - pytest-basiert mit realer Input-Datei (`2025 JM.xlsx`) und realem PDF-Template
+  - Prüft: 168 Datensätze, 19 Personen, 12 Monate
+  - Validiert Output-PDF: Seitenanzahl (24 Seiten = 12 × 2), Inhalte (Antragsnummer, Name, Stellenanteil, Qualifikation, Monat, Funktion, Tätigkeit), keine verbliebenen `_Field`-Platzhalter
+
+- **README.md**: Vollständige Dokumentation zu Setup, Bedienung, Konfiguration, Cold Run und Tests
+
+### Geändert
+
+- Template-Format von `.xlsx` auf **PDF** umgestellt (ursprüngliches Excel-Template war schreibgeschützt)
+- `config/output-fields.json`: `target_cell` entfernt – Mapping erfolgt jetzt über `_Field`-Platzhalter im PDF
+- `src/config.py`: `get_available_templates` filtert jetzt `.pdf`-Dateien
@@ -0,0 +1,181 @@
+
+# Tätigkeitsnachweis-Generator
+
+Streamlit-App zur automatisierten Erstellung von Tätigkeitsnachweisen aus Excel-Daten.
+
+## Setup
+
+1. **Python 3.9+ installieren** (falls nicht vorhanden): https://python.org
+2. **Virtuelle Umgebung erstellen und Abhängigkeiten installieren:**
+
+```bash
+python -m venv .venv
+.venv\Scripts\activate     # Windows
+pip install -r requirements.txt
+```
+
+3. **App starten:**
+
+```bash
+streamlit run app.py
+```
+
+Oder einfach `start.bat` (Windows) bzw. `./start.sh` (macOS/Linux) ausführen.
+
+## Cold Run – Headless-Generierung
+
+`coldrun.py` erzeugt ohne GUI einen Tätigkeitsnachweis für die erste Person –
+automatisch mit der ersten Input- und Template-Datei. Ergebnis wird auf macOS
+im Finder geöffnet.
+
+```bash
+# Kommandozeile
+.venv/bin/python coldrun.py
+
+# oder per Doppelklick (macOS)
+coldrun.command
+```
+
+## Bedienung
+
+1. **Input-Datei wählen** – Dropdown zeigt alle `.xlsx`-Dateien aus dem `input/`-Ordner
+   - Nach Auswahl wird die Datei sofort validiert
+   - Angezeigt werden: Anzahl Mitarbeiter, Antragsnummern, Einträge pro Monat
+2. **Template wählen** – Dropdown zeigt alle `.xlsx`-Dateien aus dem `template/`-Ordner
+   - Nach Auswahl wird das Template sofort validiert
+   - Angezeigt wird: Anzahl gefundener Zielfelder
+3. **Mitarbeiter auswählen** – Multiselect-Liste aller gefundenen Mitarbeiter
+   - Standardmäßig sind alle ausgewählt
+   - Nicht selektierte Mitarbeiter werden bei der Generierung übersprungen
+4. **"Tätigkeitsnachweise generieren"** klicken
+   - Die generierten Dateien werden im `output/`-Ordner abgelegt
+
+## Konfiguration
+
+Alle Einstellungen liegen im `config/`-Ordner:
+
+### `settings.ini`
+- `[paths]` – Ordner für Input, Template, Output
+- `[output]` – Dateinamen-Pattern (`{first_name}`, `{last_name}`)
+- `[parsing]` – Monats-Sheet-Erkennung, Leerzeilen-Verhalten
+
+### `input-fields.json`
+Definiert die Spalten der Input-Tabelle:
+- `column`: Spaltenbuchstabe (A, B, C…)
+- `field_name`: Exakte Spaltenüberschrift aus der Excel-Datei
+- `type`: `string` oder `number`
+- `required`: `true` oder `false`
+
+### `output-fields.json`
+Mapping von Input-Feldern auf Template-Zellen:
+- `source_field`: Exakte Spaltenüberschrift aus `input-fields.json`
+- `target_cell`: Zelladresse im Template (z. B. `"C16"`)
+- `format`: Optionaler Format-String (z. B. `"%.2f"` für Prozentwerte)
+
+## Erwartetes Input-Format
+
+- Eine `.xlsx`-Datei mit einem Sheet pro Monat (z. B. "Januar 2025", "Februar 2025", …)
+- Jedes Sheet hat in Zeile 1 die Spaltenüberschriften (laut `input-fields.json`)
+- Daten beginnen ab Zeile 2
+- Jede Zeile entspricht einer Mitarbeiter-Funktion-Kombination für diesen Monat
+
+## Output
+
+- Pro selektiertem Mitarbeiter wird eine `.xlsx`-Datei erstellt
+- Jeder Monat wird als eigenes Sheet (Kopie des Templates) eingefügt
+- Dateiname: `{Nachname}_{Vorname}_Tätigkeitsnachweis.xlsx`
+
+## Tests
+
+Beim Start über `start.bat` oder die neu gebaute EXE erscheint bei einer bereits
+laufenden Programminstanz ein Ja/Nein-Dialog. „Ja“ beendet die bisherige Instanz
+und startet die neue; „Nein“ lässt die bisherige Instanz geöffnet und bricht den
+neuen Start ab. Aktuelle Auswahlen gehen beim Beenden verloren. Ein fremdes
+Programm auf Port 8501 wird nicht beendet.
+
+Unter Windows führt `test.bat` alle Tests im Ordner `tests/` aus. Das Skript
+verwendet die Projektumgebung `.venv` und installiert bei Bedarf `pytest`.
+Per Doppelklick bleibt das Ergebnisfenster geöffnet. Für automatisierte Aufrufe:
+
+```powershell
+.\0_application\test.bat --no-pause
+```
+
+Dieser Aufruf erfolgt aus dem Projekt-Hauptordner. Bei fehlgeschlagenen Tests
+liefert das Skript einen Fehlercode und führt die übrigen Tests trotzdem aus.
+Beim Build laufen die Tests automatisch vor der Versionierung und dem Bauen.
+Beim Programmstart werden sie nicht ausgeführt.
+
+End-to-End-Tests parsen die feste Testdatei (`tests/fixture/2026 JM.xlsx`) und das
+PDF-Template (`template/Tätigkeitsnachweise Stellenförderung.pdf`) und validieren
+den gesamten Generierungs-Workflow.
+
+```bash
+# Test-Abhängigkeiten installieren
+.venv/bin/pip install pytest
+
+# Tests ausführen
+.venv/bin/python -m pytest tests -v
+```
+
+Die Tests prüfen:
+- Vorhandensein der Input- und Template-Dateien
+- Korrekte Parsierung (100 Datensätze, 17 Personen)
+- Vollständige PDF-Pipeline für die erste Person („Bardaus, Madalina“): fünf Monate
+  von Januar bis Mai 2026 mit zehn Seiten, Antragsnummer, Name, Stellenanteil,
+  Monat, Funktion, Tätigkeit, Ort und korrekten Monatsenddaten
+- Neustartlogik unter Windows mit simulierten Prozessen
+
+## Build und Deployment unter Windows
+
+Alle folgenden Befehle werden im Projekt-Hauptordner ausgeführt:
+
+```powershell
+# Interaktiv: Versionsänderung auswählen
+.\1_build-pipeline\build.bat
+
+# Bugfix-Version mit Changelog-Beschreibung
+.\1_build-pipeline\build.bat --bump patch --message "Fehler beim Programmstart behoben"
+
+# Ablauf anzeigen, ohne Tests, Build oder Deployment auszuführen
+.\1_build-pipeline\build.bat --bump patch --dry-run
+
+# Aktuelle Version mit aktualisiertem Changelog erneut als EXE bauen
+.\1_build-pipeline\build.bat --no-bump --no-deploy
+
+# Nur den letzten erfolgreichen Build bereitstellen (kein neuer Build)
+.\1_build-pipeline\deploy.bat
+
+# Deployment ohne abschließende Tasteneingabe
+.\1_build-pipeline\deploy.bat --no-pause
+```
+
+Die Pipeline führt zuerst alle Tests aus. Bei einem Testfehler bleiben Version
+und Changelog unverändert; Build und Deployment werden nicht gestartet.
+Nach erfolgreichen Tests aktualisiert sie die Version, erstellt die EXE und
+legt sie mit Konfiguration, PDF-Template, README und Changelog in `2_build/` ab.
+`release.json` hält die Version und Prüfsummen des erfolgreichen Builds fest.
+Bei einem Buildfehler wird der Changelog zurückgesetzt.
+
+Danach erzeugt das Deployment `Tätigkeitsnachweis-Generator vX.Y.Z.zip` und
+überträgt es an:
+
+```text
+j:\Fachbereiche\BO\Produktionsschule\Maßnahmeunterlagen\20_Personal\05_Tätigkeitsnachweise ESF\Nachweise-automatisiert-generieren\
+```
+
+Das Ziel muss bereits vorhanden und über VPN/SMB erreichbar sein. Ist es nicht
+erreichbar oder fehlen Schreibrechte, bricht das Deployment verständlich ab.
+Der lokale Build bleibt erhalten. Nach Wiederherstellung der VPN-Verbindung
+kann `deploy.bat` die Bereitstellung ohne erneutes Testen, Bauen oder Erhöhen
+der Versionsnummer wiederholen. Das Skript akzeptiert nur einen bestätigten,
+unveränderten Build mit `release.json`; ältere Builds müssen einmal neu gebaut
+werden.
+
+Das ZIP enthält leere `input/`- und `output/`-Ordner; Arbeitsdateien und
+Testdaten werden nicht mit ausgeliefert. Es wird zunächst als temporäre Datei
+übertragen, per Prüfsumme geprüft und erst dann unter dem Versionsnamen
+sichtbar gemacht. Bestehende Versionen mit anderem Inhalt werden nicht
+überschrieben. Ein identisches Paket kann erneut bereitgestellt werden.
+Die Neustarttests simulieren Prozesse und Dialogantworten; ein manueller
+Starttest der fertigen EXE bleibt vor der Weitergabe sinnvoll.
@@ -0,0 +1,75 @@
+# Tätigkeitsnachweis-Generator
+
+Programm zur automatisierten Erstellung von Tätigkeitsnachweisen aus Excel-Daten.
+Die aktuellesten Programmversion find sich immer hier: 
+"j:\Fachbereiche\BO\Produktionsschule\Maßnahmeunterlagen\20_Personal\05_Tätigkeitsnachweise ESF\Nachweise-automatisiert-generieren\" 
+
+Um das Programm zu starten: Doppelklick auf `Tätigkeitsnachweis-Generator.exe`
+
+## Bedienung
+
+1. **Input-Datei wählen** – Dropdown zeigt alle `.xlsx`-Dateien aus dem `input/`-Ordner
+   - Bei leerem Input-Ordner: „Input-Ordner öffnen“ öffnet den Explorer.
+   - Excel-Dateien können per Drag-and-drop hochgeladen werden. Sie werden in den
+     Input-Ordner kopiert; danach wird die Dateiliste automatisch neu eingelesen.
+   - Nach manuellem Kopieren im Explorer „Input-Ordner neu einlesen“ anklicken.
+   - Nach Auswahl wird die Datei sofort validiert
+   - Angezeigt werden: Anzahl Mitarbeiter, Antragsnummern, Einträge pro Monat
+2. **Template wählen** – Dropdown zeigt alle `.xlsx`-Dateien aus dem `template/`-Ordner
+   - Nach Auswahl wird das Template sofort validiert
+   - Angezeigt wird: Anzahl gefundener Zielfelder
+3. **Mitarbeiter auswählen** – Multiselect-Liste aller gefundenen Mitarbeiter
+   - Standardmäßig ist keiner ausgewählt
+   - Nicht selektierte Mitarbeiter werden bei der Generierung übersprungen
+4. **Mitarbeitermonate auswählen** – Multiselect-Liste aller verfügbaren Monate im Dokument. Vorselektiert sind die aktuell letzten beiden Monate.
+5. **"Tätigkeitsnachweise generieren"** klicken
+   - Die generierten Dateien werden im `output/`-Ordner abgelegt
+
+## Update
+
+Liegt eine neuere Version auf dem Laufwerk J:, erscheint oben rechts ein Hinweis.
+
+- **„Anwendung ersetzen“** richtet die neue Version in einem eigenen Ordner neben der
+  aktuellen ein (z. B. `Tätigkeitsnachweis-Generator v1.4.0`), übernimmt `input/`,
+  `output/` und eigene Template-Dateien und startet sie. Das folgende Rückfragefenster
+  mit „Ja“ bestätigen, dann wird die alte Version beendet.
+- Die alte Version bleibt als Ordner erhalten und kann gelöscht werden, sobald die neue läuft.
+- Wurde `settings.ini` angepasst, liegt die bisherige Datei als
+  `config/settings.vorherige-version.ini` daneben.
+- Desktop-Verknüpfungen zeigen weiterhin auf den alten Ordner und müssen neu angelegt werden.
+- **„Update Ordner öffnen“** öffnet das Verzeichnis auf J: für ein manuelles Update.
+
+## Konfiguration
+
+Alle Einstellungen liegen im `config/`-Ordner:
+
+### `settings.ini`
+- `[paths]` – Ordner für Input, Template, Output
+- `[output]` – Dateinamen-Pattern (`{first_name}`, `{last_name}`)
+- `[parsing]` – Monats-Sheet-Erkennung, Leerzeilen-Verhalten
+
+### `input-fields.json`
+Definiert die Spalten der Input-Tabelle:
+- `column`: Spaltenbuchstabe (A, B, C…)
+- `field_name`: Exakte Spaltenüberschrift aus der Excel-Datei
+- `type`: `string` oder `number`
+- `required`: `true` oder `false`
+
+### `output-fields.json`
+Mapping von Input-Feldern auf Template-Zellen:
+- `source_field`: Exakte Spaltenüberschrift aus `input-fields.json`
+- `target_cell`: Zelladresse im Template (z. B. `"C16"`)
+- `format`: Optionaler Format-String (z. B. `"%.2f"` für Prozentwerte)
+
+## Erwartetes Input-Format
+
+- Eine `.xlsx`-Datei mit einem Sheet pro Monat (z. B. "Januar 2025", "Februar 2025", …)
+- Jedes Sheet hat in Zeile 1 die Spaltenüberschriften (laut `input-fields.json`)
+- Daten beginnen ab Zeile 2
+- Jede Zeile entspricht einer Mitarbeiter-Funktion-Kombination für diesen Monat
+
+## Output
+
+- Pro selektiertem Mitarbeiter wird eine `.xlsx`-Datei erstellt
+- Jeder Monat wird als eigenes Sheet (Kopie des Templates) eingefügt
+- Dateiname: `{Nachname}_{Vorname}_Tätigkeitsnachweis.xlsx`
@@ -0,0 +1,588 @@
+"""Tätigkeitsnachweis-Generator – Streamlit App."""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import streamlit as st
+
+# Projekt-Root zum Python-Path hinzufügen
+# Im gebundelten Modus (PyInstaller) zeigt APP_BASE_DIR auf das Verzeichnis der .exe,
+# wo config/, input/, template/, output/ liegen. Im Entwicklungsmodus bleibt es None
+# und PROJECT_ROOT wird aus __file__ abgeleitet.
+_BASE_DIR = os.environ.get("APP_BASE_DIR")
+if _BASE_DIR:
+    PROJECT_ROOT = Path(_BASE_DIR).resolve()
+else:
+    PROJECT_ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.config import (
+    load_settings,
+    load_input_schema,
+    load_output_mapping,
+    get_available_input_files,
+    get_available_templates,
+)
+from src.models import AppConfig
+from src.parser import parse_input_file, group_by_employee, get_unique_antragsnummern, get_unique_employees
+from src.validator import validate_input_file, validate_template
+from src.writer import generate_activity_reports
+from version_check import UPDATE_DIR, get_latest_version
+from update_installer import can_replace_application, install_update, start_application
+
+
+def open_input_folder(directory: Path):
+    directory.mkdir(parents=True, exist_ok=True)
+    if sys.platform == "win32":
+        os.startfile(str(directory))
+    else:
+        subprocess.run(["open" if sys.platform == "darwin" else "xdg-open", str(directory)], check=True)
+
+
+def set_active_employee(employee_name: str):
+    """Merkt die zuletzt angeklickte Person für die Monatsliste."""
+    st.session_state.active_month_employee = employee_name
+
+
+def sync_employee_months(employee_name: str, months: list[str]):
+    """Übernimmt Monats-Checkboxen vor dem nächsten UI-Rendern."""
+    st.session_state.employee_months[employee_name] = {
+        month for month in months
+        if st.session_state.get(f"month_{employee_name}_{month}", False)
+    }
+
+
+def set_all_employee_months(employee_name: str, months: list[str], selected: bool):
+    """Setzt alle Monats-Checkboxen einer Person gesammelt."""
+    st.session_state.employee_months[employee_name] = set(months) if selected else set()
+    for month in months:
+        st.session_state[f"month_{employee_name}_{month}"] = selected
+
+# --- Seite konfigurieren ---
+st.set_page_config(
+    page_title="Tätigkeitsnachweis-Generator",
+    page_icon="📋",
+    layout="wide",
+)
+
+st.title("📋 Tätigkeitsnachweis-Generator")
+st.markdown("Erstellt Tätigkeitsnachweise aus Input-Daten und einem Excel-Template.")
+
+# --- Konfiguration laden ---
+CONFIG_DIR = PROJECT_ROOT / "config"
+
+@st.cache_data
+def load_app_config():
+    config = load_settings(CONFIG_DIR, PROJECT_ROOT)
+    config.input_schema = load_input_schema(CONFIG_DIR)
+    config.output_mapping = load_output_mapping(CONFIG_DIR)
+    return config
+
+try:
+    app_config = load_app_config()
+except Exception as e:
+    st.error(f"Fehler beim Laden der Konfiguration: {e}")
+    st.stop()
+
+# --- Versionsinformation für die dezente Anzeige am Seitenende ---
+current_version_text = ""
+try:
+    local_version, latest_version = get_latest_version()
+    current_version_text = f"v{'.'.join(map(str, local_version))}"
+    if latest_version:
+        available_version, update_path = latest_version
+        version_text = ".".join(map(str, available_version))
+        st.html(
+            f'''<style>
+            .update-notice {{
+                position: fixed; top: 4rem; right: 1rem; z-index: 10000;
+                width: 290px; padding: 8px 12px; color: #5f4700;
+                background: #fff8e1; border: 1px solid #e0b84c; border-radius: 8px;
+                box-shadow: 0 3px 12px rgba(0, 0, 0, .18); font-size: .85rem;
+            }}
+            #update-notice-dismiss {{ display:none; }}
+            #update-notice-dismiss:checked + .update-notice {{ display:none; }}
+            body:has(#update-notice-dismiss:checked) div.st-key-update_notice_open {{ display:none!important; }}
+            .update-notice__actions {{ display:flex; justify-content:flex-end; gap:8px; margin-top:8px; }}
+            .update-notice__actions--footer {{ min-height:60px; }}
+            .update-notice__button {{
+                display:inline-flex; align-items:center; justify-content:center;
+                width:26px; height:26px; color:#5f4700; background:#fffdf3;
+                border:1px solid #d9bd66; border-radius:5px; text-decoration:none;
+                font-size:1rem; line-height:1;
+            }}
+            .update-notice__button:hover {{ background:#f6e7b2; }}
+            div.st-key-update_notice_open {{
+                position:fixed; top:8.5rem; right:calc(1rem + 13px); z-index:10001;
+                width:264px; gap:6px;
+            }}
+            div.st-key-update_notice_open div[data-testid="stButton"] {{ margin:0; }}
+            div.st-key-update_notice_open div[data-testid="stButton"] button {{
+                width:100%; min-height:26px; height:26px; padding:0; color:#5f4700;
+                background:#fffdf3; border:1px solid #d9bd66; border-radius:5px;
+            }}
+            </style>
+            <input id="update-notice-dismiss" type="checkbox">
+            <aside class="update-notice" role="status">
+                <div class="update-notice__actions">
+                    <label class="update-notice__button" for="update-notice-dismiss" title="Hinweis schließen">×</label>
+                </div>
+                <strong>Neue Version v{version_text} verfügbar</strong>
+                <div class="update-notice__actions update-notice__actions--footer">
+                </div>
+            </aside>'''
+        )
+        with st.container(key="update_notice_open"):
+            if st.button("Update Ordner öffnen 📁", key="open_update_directory", help="Update-Ordner öffnen"):
+                if sys.platform == "win32":
+                    os.startfile(str(UPDATE_DIR))
+            replace_supported = can_replace_application()
+            replace_clicked = st.button(
+                "Anwendung ersetzen 🔄", key="replace_application",
+                disabled=not replace_supported or st.session_state.get("update_started", False),
+                help=("Neue Version neben der aktuellen einrichten, input/ und output/ übernehmen "
+                      "und starten. Die aktuelle Version bleibt als Ordner erhalten."
+                      if replace_supported else "Nur in der installierten Windows-Anwendung verfügbar."))
+        if replace_clicked:
+            try:
+                with st.spinner(f"Version v{version_text} wird eingerichtet …"):
+                    result = install_update(update_path, PROJECT_ROOT)
+                    start_application(result.target_dir)
+            except Exception as exc:  # Der umgebende Block verschluckt sonst jeden Fehler.
+                st.error(f"Update fehlgeschlagen: {exc}\n\n"
+                         "Alternativ das Update manuell aus dem Update-Ordner einrichten.")
+            else:
+                st.session_state.update_started = True
+                details = [f"Neuer Programmordner: `{result.target_dir}`"]
+                if result.already_installed:
+                    details.append("Die Version war dort bereits eingerichtet und wurde nur gestartet.")
+                else:
+                    details.append("Die Ordner input/ und output/ wurden übernommen.")
+                if result.previous_settings:
+                    details.append(f"Die bisherige settings.ini wurde als `{result.previous_settings.name}` aufbewahrt.")
+                details.append("Bitte im folgenden Fenster bestätigen, dass die alte Version beendet wird. "
+                               "Desktop-Verknüpfungen zeigen noch auf den alten Ordner.")
+                st.success(f"Version v{version_text} wird gestartet.\n\n" + "\n\n".join(details))
+except Exception:
+    pass
+
+# --- Session State initialisieren ---
+if "parsed_records" not in st.session_state:
+    st.session_state.parsed_records = []
+if "input_validated" not in st.session_state:
+    st.session_state.input_validated = False
+if "template_validated" not in st.session_state:
+    st.session_state.template_validated = False
+# Caches für Validierung/Parsing – nur bei Dateiwechsel neu ausführen
+if "last_input_file" not in st.session_state:
+    st.session_state.last_input_file = None
+if "last_template_file" not in st.session_state:
+    st.session_state.last_template_file = None
+if "cached_val_result" not in st.session_state:
+    st.session_state.cached_val_result = None
+if "cached_tpl_result" not in st.session_state:
+    st.session_state.cached_tpl_result = None
+if "employee_months" not in st.session_state:
+    st.session_state.employee_months = {}
+# --- Layout: zwei Spalten ---
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("1. Input-Datei")
+    input_files = get_available_input_files(app_config)
+    for message in st.session_state.pop("input_upload_messages", []):
+        st.success(message)
+    for message in st.session_state.pop("input_upload_errors", []):
+        st.error(message)
+    if not input_files:
+        with st.container(border=True, key="input_file_panel"):
+            st.markdown("**Excel-Datei hinzufügen**")
+            st.caption("Keine .xlsx-Dateien im Input/-Ordner gefunden.")
+            input_directory = Path(app_config.input_dir)
+            uploaded_files = st.file_uploader(
+                "Excel-Dateien hierher ziehen oder auswählen",
+                type=["xlsx"], accept_multiple_files=True,
+                key=f"input_upload_{st.session_state.get('input_upload_generation', 0)}",
+                label_visibility="collapsed",
+            )
+            if uploaded_files:
+                saved, errors = [], []
+                for uploaded_file in uploaded_files:
+                    try:
+                        name = uploaded_file.name
+                        if (Path(name).name != name or "/" in name or "\\" in name
+                                or Path(name).suffix.lower() != ".xlsx" or name.startswith("~")):
+                            raise ValueError("Bitte eine .xlsx-Datei mit gültigem Dateinamen auswählen.")
+                        input_directory.mkdir(parents=True, exist_ok=True)
+                        destination = input_directory / name
+                        counter = 1
+                        while True:
+                            try:
+                                with destination.open("xb") as output:
+                                    output.write(uploaded_file.getbuffer())
+                                break
+                            except FileExistsError:
+                                counter += 1
+                                destination = input_directory / f"{Path(name).stem} ({counter}).xlsx"
+                        saved.append(f"{destination.name} wurde in den Input-Ordner kopiert.")
+                    except (OSError, ValueError) as exc:
+                        errors.append(f"{uploaded_file.name} konnte nicht übernommen werden: {exc}")
+                st.session_state.input_upload_messages = saved
+                st.session_state.input_upload_errors = errors
+                st.session_state.input_upload_generation = st.session_state.get("input_upload_generation", 0) + 1
+                st.session_state.last_input_file = None
+                st.rerun()
+            st.caption("Dateien hierher ziehen oder auswählen. Sie werden automatisch im Input-Ordner gespeichert.")
+            folder_action, refresh_action = st.columns(2)
+            with folder_action:
+                if st.button("Ordner öffnen", icon="📁", key="open_input_directory", use_container_width=True):
+                    try:
+                        open_input_folder(input_directory)
+                    except (OSError, subprocess.SubprocessError) as exc:
+                        st.error(f"Der Input-Ordner konnte nicht geöffnet werden: {exc}")
+            with refresh_action:
+                if st.button("Neu einlesen", icon="🔄", key="refresh_input_directory", use_container_width=True,
+                             help="Dateiliste aktualisieren, nachdem Dateien im Explorer hinzugefügt wurden."):
+                    st.rerun()
+        selected_input = None
+        st.session_state.parsed_records = []
+        st.session_state.input_validated = False
+        st.session_state.last_input_file = None
+    else:
+        # Bei nur einer Datei: automatisch selektieren (keine Leerauswahl)
+        if len(input_files) == 1:
+            selected_input = st.selectbox(
+                "Input-Datei wählen:",
+                options=input_files,
+            )
+        else:
+            selected_input = st.selectbox(
+                "Input-Datei wählen:",
+                options=[""] + input_files,
+                format_func=lambda x: "– Bitte wählen –" if x == "" else x,
+            )
+
+    if selected_input:
+        input_path = Path(app_config.input_dir) / selected_input
+
+        # Nur validieren/parsen wenn sich die Datei geändert hat
+        if selected_input != st.session_state.last_input_file:
+            with st.spinner("Validiere Input-Datei…"):
+                val_result = validate_input_file(input_path, app_config.input_schema, app_config.month_sheet_pattern)
+
+            if val_result.is_valid:
+                records = parse_input_file(
+                    input_path,
+                    app_config.input_schema,
+                    app_config.month_sheet_pattern,
+                    app_config.skip_empty_name,
+                    app_config.skip_empty_antragsnummer,
+                )
+                st.session_state.parsed_records = records
+                st.session_state.input_validated = True
+            else:
+                st.session_state.parsed_records = []
+                st.session_state.input_validated = False
+
+            st.session_state.cached_val_result = val_result
+            st.session_state.last_input_file = selected_input
+        else:
+            val_result = st.session_state.cached_val_result
+
+        if not val_result.is_valid:
+            st.markdown(
+                '<div style="border:2px solid #e74c3c; border-radius:8px; padding:12px; '
+                'background:#fdedec; margin-bottom:12px">'
+                '<span style="color:#b03a2e; font-weight:bold; font-size:1.1em">'
+                '❌ Validierung fehlgeschlagen</span></div>',
+                unsafe_allow_html=True,
+            )
+            for err in val_result.errors:
+                st.error(f"🔴 {err}")
+            st.session_state.input_validated = False
+        else:
+            if val_result.warnings:
+                st.markdown(
+                    '<div style="border:2px solid #f39c12; border-radius:8px; padding:8px 12px; '
+                    'background:#fef9e7; margin-bottom:8px">'
+                    '<span style="color:#7d6608; font-weight:bold">'
+                    '⚠️ Hinweise</span></div>',
+                    unsafe_allow_html=True,
+                )
+                for warn in val_result.warnings:
+                    st.warning(warn)
+
+            # Zeige Zusammenfassung aus gecachten Records
+            records = st.session_state.parsed_records
+            employees = get_unique_employees(records)
+            antragsnummern = get_unique_antragsnummern(records)
+
+            st.success(f"✅ {len(records)} Einträge in {val_result.info.get('sheets_with_data', 0)} Monats-Sheets")
+            pills = " ".join(
+                f'<span style="display:inline-block; background:#e8f0fe; color:#1a73e8; '
+                f'border-radius:16px; padding:4px 12px; margin:3px; font-size:0.9em; '
+                f'white-space:nowrap">{an}</span>'
+                for an in antragsnummern
+            )
+            st.markdown(f"**Antragsnummern:**<br>{pills}", unsafe_allow_html=True)
+
+with col2:
+    st.subheader("2. Template")
+    template_files = get_available_templates(app_config)
+    if not template_files:
+        st.warning("Keine .pdf-Dateien im template/-Ordner gefunden.")
+        selected_template = None
+    else:
+        # Lock-Files herausfiltern
+        real_templates = [t for t in template_files if not t.startswith("~")]
+        if not real_templates:
+            real_templates = template_files
+        # Bei nur einem Template: automatisch selektieren (keine Leerauswahl)
+        if len(real_templates) == 1:
+            selected_template = st.selectbox(
+                "Template wählen:",
+                options=real_templates,
+            )
+        else:
+            selected_template = st.selectbox(
+                "Template wählen:",
+                options=[""] + real_templates,
+                format_func=lambda x: "– Bitte wählen –" if x == "" else x,
+            )
+
+    if selected_template:
+        # Nur validieren wenn sich das Template geändert hat
+        if selected_template != st.session_state.last_template_file:
+            template_path = Path(app_config.template_dir) / selected_template
+            with st.spinner("Validiere Template…"):
+                tpl_result = validate_template(template_path, app_config.output_mapping)
+            st.session_state.cached_tpl_result = tpl_result
+            st.session_state.last_template_file = selected_template
+            st.session_state.template_validated = tpl_result.is_valid
+        else:
+            tpl_result = st.session_state.cached_tpl_result
+
+        if not tpl_result.is_valid:
+            st.markdown(
+                '<div style="border:2px solid #e74c3c; border-radius:8px; padding:12px; '
+                'background:#fdedec; margin-bottom:12px">'
+                '<span style="color:#b03a2e; font-weight:bold; font-size:1.1em">'
+                '❌ Validierung fehlgeschlagen</span></div>',
+                unsafe_allow_html=True,
+            )
+            for err in tpl_result.errors:
+                st.error(f"🔴 {err}")
+            st.session_state.template_validated = False
+        else:
+            st.session_state.template_validated = True
+            found = tpl_result.info.get("found_fields", 0)
+            total = tpl_result.info.get("total_fields", 0)
+            st.success(f"✅ {found}/{total} Platzhalter-Felder gefunden")
+            if tpl_result.warnings:
+                st.markdown(
+                    '<div style="border:2px solid #f39c12; border-radius:8px; padding:8px 12px; '
+                    'background:#fef9e7; margin-bottom:8px">'
+                    '<span style="color:#7d6608; font-weight:bold">'
+                    '⚠️ Hinweise</span></div>',
+                    unsafe_allow_html=True,
+                )
+                for warn in tpl_result.warnings:
+                    st.warning(warn)
+
+# --- Mitarbeiter-Auswahl ---
+st.subheader("3. Mitarbeiter auswählen")
+
+if st.session_state.input_validated and st.session_state.parsed_records:
+    employees = get_unique_employees(st.session_state.parsed_records)
+    st.caption(f"{len(employees)} Mitarbeiter gefunden – wähle aus, für wen Tätigkeitsnachweise erstellt werden sollen:")
+
+    # Monatsbezeichnungen für die kompakte Anzeige hinter dem Namen
+    month_labels = {
+        "01": "Jan", "02": "Feb", "03": "Mär", "04": "Apr",
+        "05": "Mai", "06": "Jun", "07": "Jul", "08": "Aug",
+        "09": "Sep", "10": "Okt", "11": "Nov", "12": "Dez",
+    }
+
+    all_groups = group_by_employee(st.session_state.parsed_records)
+    available_months = {}
+    for emp in employees:
+        months = sorted({
+            record.monat.split(".", 1)[0].zfill(2)
+            for record in all_groups.get(emp, [])
+            if record.monat and record.monat.split(".", 1)[0].isdigit()
+        }, key=lambda value: int(value))
+        available_months[emp] = months
+        if emp not in st.session_state.employee_months:
+            st.session_state.employee_months[emp] = set(months[-2:])
+
+    # Mitarbeiter- und Monatsliste teilen sich die verfügbare Breite.
+    employee_col, month_col = st.columns(2)
+    with employee_col:
+        employee_btn_col1, employee_btn_col2 = st.columns(2)
+        if employee_btn_col1.button("☑ Alle auswählen", use_container_width=True):
+            for emp in employees:
+                st.session_state[f"sel_{emp}"] = True
+        if employee_btn_col2.button("☐ Keine auswählen", use_container_width=True):
+            for emp in employees:
+                st.session_state[f"sel_{emp}"] = False
+
+        with st.container(border=True):
+            selected_employees = []
+            for emp in employees:
+                key = f"sel_{emp}"
+                if key not in st.session_state:
+                    st.session_state[key] = False
+                selected_months = st.session_state.employee_months.get(emp, set())
+                short_months = ", ".join(month_labels[m] for m in available_months[emp] if m in selected_months)
+                label = f"{emp} ({short_months})" if short_months else f"{emp} (**keine Monate**)"
+                if st.checkbox(
+                    label,
+                    key=key,
+                    on_change=set_active_employee,
+                    args=(emp,),
+                ):
+                    selected_employees.append(emp)
+
+    with month_col:
+        selected_for_months = st.session_state.get("active_month_employee")
+        if selected_for_months not in employees:
+            selected_for_months = None
+
+        month_btn_col1, month_btn_col2 = st.columns(2)
+        month_btn_col1.button(
+            "☑ Alle Monate",
+            use_container_width=True,
+            disabled=not selected_for_months,
+            on_click=set_all_employee_months,
+            args=(selected_for_months, available_months[selected_for_months], True) if selected_for_months else ("", [], True),
+        )
+        month_btn_col2.button(
+            "☐ Keine Monate",
+            use_container_width=True,
+            disabled=not selected_for_months,
+            on_click=set_all_employee_months,
+            args=(selected_for_months, available_months[selected_for_months], False) if selected_for_months else ("", [], False),
+        )
+
+        with st.container(border=True):
+            st.caption("Monate für den angeklickten Mitarbeiter")
+            if selected_for_months:
+                st.write(selected_for_months)
+                month_values = {}
+                for month in available_months[selected_for_months]:
+                    month_key = f"month_{selected_for_months}_{month}"
+                    if month_key not in st.session_state:
+                        st.session_state[month_key] = month in st.session_state.employee_months[selected_for_months]
+                    month_values[month] = st.checkbox(
+                        f"{month_labels[month]} ({month})",
+                        key=month_key,
+                        on_change=sync_employee_months,
+                        args=(selected_for_months, available_months[selected_for_months]),
+                    )
+                st.session_state.employee_months[selected_for_months] = {
+                    month for month, checked in month_values.items() if checked
+                }
+            else:
+                st.info("Einen Mitarbeiter links auswählen, um seine Monate festzulegen.")
+
+    st.caption(f"{len(selected_employees)} von {len(employees)} Mitarbeitern ausgewählt")
+else:
+    selected_employees = []
+    if not st.session_state.input_validated:
+        st.info("Bitte zuerst eine gültige Input-Datei auswählen.")
+
+# --- Hilfsfunktion zum Öffnen von Dateien/Ordnern ---
+def open_path(path_str: str):
+    """Öffnet eine Datei mit dem Standardprogramm oder einen Ordner im Dateimanager.
+    Funktioniert plattformübergreifend: macOS, Windows, Linux."""
+    if sys.platform == "win32":
+        os.startfile(path_str)
+    elif sys.platform == "darwin":
+        subprocess.run(["open", path_str])
+    else:
+        subprocess.run(["xdg-open", path_str])
+
+
+# --- Generate Button ---
+st.divider()
+gen_col1, gen_col2, gen_col3 = st.columns([1, 1, 2])
+with gen_col1:
+    generate_clicked = st.button(
+        "🚀 Tätigkeitsnachweise generieren",
+        type="primary",
+        disabled=not (st.session_state.input_validated and st.session_state.template_validated and selected_employees),
+    )
+
+if generate_clicked:
+    if not selected_employees:
+        st.error("Keine Mitarbeiter ausgewählt.")
+    else:
+        # Filtere Records auf selektierte Mitarbeiter
+        all_groups = group_by_employee(st.session_state.parsed_records)
+        selected_groups = {
+            name: [
+                record for record in all_groups[name]
+                if record.monat.split(".", 1)[0].zfill(2)
+                in st.session_state.employee_months.get(name, set())
+            ]
+            for name in selected_employees
+            if name in all_groups
+        }
+        selected_groups = {name: records for name, records in selected_groups.items() if records}
+
+        if not selected_groups:
+            st.error("Für die ausgewählten Mitarbeiter sind keine Monate ausgewählt.")
+            st.stop()
+
+        template_path = Path(app_config.template_dir) / selected_template
+        output_dir = Path(app_config.output_dir)
+
+        with st.spinner(f"Generiere {len(selected_groups)} Tätigkeitsnachweise…"):
+            try:
+                generated = generate_activity_reports(
+                    employee_records=selected_groups,
+                    template_path=template_path,
+                    mapping=app_config.output_mapping,
+                    output_dir=output_dir,
+                    filename_pattern=app_config.filename_pattern,
+                    fontsize=app_config.fontsize,
+                )
+                st.session_state.generated_files = generated
+            except Exception as e:
+                st.error(f"Fehler bei der Generierung: {e}")
+
+# --- Generierte Dateien anzeigen (aus Session State, übersteht Reruns) ---
+if "generated_files" in st.session_state and st.session_state.generated_files:
+    generated = st.session_state.generated_files
+    st.success(f"✅ {len(generated)} Tätigkeitsnachweise erstellt:")
+    for i, fpath in enumerate(generated):
+        col_file, col_open, col_folder = st.columns([0.78, 0.11, 0.11])
+        with col_file:
+            st.markdown(f"📄 `{fpath.name}`")
+        with col_open:
+            st.button(
+                "🔗 Öffnen",
+                key=f"open_file_{i}",
+                on_click=open_path,
+                args=(str(fpath),),
+                help="Datei mit Standardprogramm öffnen",
+                use_container_width=True,
+            )
+        with col_folder:
+            st.button(
+                "📂",
+                key=f"open_folder_{i}",
+                on_click=open_path,
+                args=(str(fpath.parent),),
+                help="Ordner im Explorer öffnen",
+                use_container_width=True,
+            )
+
+if current_version_text:
+    st.markdown(
+        f'<div style="text-align:right; color:#888; font-size:0.8em; margin-top:2em;">'
+        f'Programmversion {current_version_text}</div>',
+        unsafe_allow_html=True,
+    )
@@ -0,0 +1,48 @@
+@echo off
+chcp 65001 >nul
+set "PYTHONUTF8=1"
+title Tätigkeitsnachweis-Generator – Cold Run
+echo ========================================
+echo   Cold Run – Headless-Generierung
+echo ========================================
+echo.
+
+:: Prüfe ob Python verfügbar ist
+where python >nul 2>nul
+if %ERRORLEVEL% neq 0 (
+    echo [FEHLER] Python wurde nicht gefunden.
+    echo Bitte installiere Python 3.9 oder neuer von https://python.org
+    pause
+    exit /b 1
+)
+
+echo [INFO] Python gefunden:
+python --version
+
+:: Prüfe ob venv existiert, sonst erstelle
+if not exist ".venv\Scripts\python.exe" (
+    echo [FEHLER] Virtuelle Umgebung nicht gefunden.
+    echo Bitte zuerst start.bat ausführen, um das Projekt einzurichten.
+    pause
+    exit /b 1
+)
+
+:: Aktiviere venv und installiere Abhängigkeiten
+call .venv\Scripts\activate.bat
+echo [INFO] Stelle sicher, dass Abhängigkeiten installiert sind...
+pip install -r requirements.txt --quiet
+if %ERRORLEVEL% neq 0 (
+    echo [FEHLER] Konnte Abhängigkeiten nicht installieren.
+    pause
+    exit /b 1
+)
+
+:: Starte Cold Run
+echo.
+echo [INFO] Starte Cold Run – generiere Tätigkeitsnachweis für erste Person...
+echo.
+python coldrun.py
+
+echo.
+echo [INFO] Cold Run abgeschlossen.
+pause
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Doppelklickbares Cold-Run-Script für macOS
+# Nimmt automatisch die erste Input-Datei + erstes Template und erzeugt
+# einen Tätigkeitsnachweis für die erste gelistete Person – ohne GUI.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+VENV_DIR=".venv"
+
+if [[ ! -x "$VENV_DIR/bin/python" ]]; then
+    echo "[FEHLER] Virtuelle Umgebung nicht gefunden."
+    echo "Bitte zuerst start.command ausführen, um das Projekt einzurichten."
+    read -p "Drücke Enter zum Beenden..."
+    exit 1
+fi
+
+echo "[INFO] Stelle sicher, dass Abhängigkeiten installiert sind…"
+"$VENV_DIR/bin/pip" install -r requirements.txt --quiet 2>/dev/null || true
+
+echo ""
+"$VENV_DIR/bin/python" coldrun.py
+
+echo ""
+read -p "Drücke Enter zum Beenden..."
@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Cold-Run Tätigkeitsnachweis-Generator.
+
+Nimmt automatisch die erste Input-Datei und das erste Template,
+erzeugt einen Tätigkeitsnachweis für die erste gelistete Person
+und öffnet das Ergebnis (macOS) – ohne GUI, ohne Fragen.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+# Projekt-Root
+PROJECT_ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.config import (
+    load_settings,
+    load_input_schema,
+    load_output_mapping,
+    get_available_input_files,
+    get_available_templates,
+)
+from src.parser import parse_input_file, group_by_employee, get_unique_employees
+from src.validator import validate_input_file, validate_template
+from src.writer import generate_activity_reports
+
+
+def main():
+    print("=" * 50)
+    print("  Tätigkeitsnachweis-Generator (Cold Run)")
+    print("=" * 50)
+    print()
+
+    # ── Konfiguration laden ──────────────────────────────────────────
+    config_dir = PROJECT_ROOT / "config"
+    config = load_settings(config_dir, PROJECT_ROOT)
+    config.input_schema = load_input_schema(config_dir)
+    config.output_mapping = load_output_mapping(config_dir)
+
+    # ── Erste Input-Datei ermitteln ───────────────────────────────────
+    input_files = get_available_input_files(config)
+    if not input_files:
+        print("[FEHLER] Keine .xlsx-Dateien im input/-Ordner gefunden.")
+        return 1
+
+    input_file = input_files[0]
+    input_path = Path(config.input_dir) / input_file
+    print(f"[INFO] Input-Datei:  {input_file}")
+
+    # ── Erstes Template ermitteln ─────────────────────────────────────
+    template_files = get_available_templates(config)
+    if not template_files:
+        print("[FEHLER] Keine .pdf-Dateien im template/-Ordner gefunden.")
+        return 1
+
+    template_file = template_files[0]
+    template_path = Path(config.template_dir) / template_file
+    print(f"[INFO] Template:     {template_file}")
+
+    # ── Template validieren ───────────────────────────────────────────
+    print()
+    print("[INFO] Validiere PDF-Template…")
+    tpl_result = validate_template(template_path, config.output_mapping)
+    if not tpl_result.is_valid:
+        for err in tpl_result.errors:
+            print(f"[FEHLER] {err}")
+        return 1
+    found = tpl_result.info.get("found_fields", "?")
+    total = tpl_result.info.get("total_fields", "?")
+    print(f"[OK]   {found}/{total} Platzhalter im Template gefunden.")
+
+    # ── Input validieren ──────────────────────────────────────────────
+    print()
+    print("[INFO] Validiere Input-Datei…")
+    inp_result = validate_input_file(input_path, config.input_schema, config.month_sheet_pattern)
+    if not inp_result.is_valid:
+        for err in inp_result.errors:
+            print(f"[FEHLER] {err}")
+        return 1
+    if inp_result.warnings:
+        for warn in inp_result.warnings:
+            print(f"[WARN]  {warn}")
+
+    # ── Input parsen ──────────────────────────────────────────────────
+    print()
+    print("[INFO] Parse Input-Datei…")
+    records = parse_input_file(
+        filepath=input_path,
+        schema=config.input_schema,
+        month_sheet_pattern=config.month_sheet_pattern,
+        skip_empty_name=config.skip_empty_name,
+        skip_empty_antragsnummer=config.skip_empty_antragsnummer,
+    )
+
+    employees = get_unique_employees(records)
+    print(f"[INFO] {len(records)} Einträge für {len(employees)} Personen gefunden.")
+
+    # ── Erste Person ermitteln ────────────────────────────────────────
+    grouped = group_by_employee(records)
+    first_person = sorted(grouped.keys())[0]
+    first_records = grouped[first_person]
+    print(f"[INFO] Erste Person:  {first_person} ({len(first_records)} Monate)")
+
+    # ── Reports generieren ────────────────────────────────────────────
+    print()
+    print("[INFO] Generiere Tätigkeitsnachweis…")
+    single_person = {first_person: first_records}
+    output_dir = Path(config.output_dir)
+    generated = generate_activity_reports(
+        employee_records=single_person,
+        template_path=template_path,
+        mapping=config.output_mapping,
+        output_dir=output_dir,
+        filename_pattern=config.filename_pattern,
+        fontsize=config.fontsize,
+    )
+
+    output_file = generated[0]
+    print(f"[OK]   Erstellt: {output_file.name}")
+    print(f"      Pfad:     {output_file}")
+
+    # ── Datei öffnen (macOS) ──────────────────────────────────────────
+    if sys.platform == "darwin":
+        print()
+        print("[INFO] Öffne Datei im Explorer")
+        subprocess.run(["open", str(output_file)], check=False)
+
+    print()
+    print("=" * 50)
+    print("  Fertig.")
+    print("=" * 50)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -0,0 +1,11 @@
+[
+  {"column": "A", "field_name": "ID", "type": "number", "required": false},
+  {"column": "B", "field_name": "Kommentar", "type": "string", "required": false},
+  {"column": "C", "field_name": "Antragsnummer", "type": "string", "required": true},
+  {"column": "D", "field_name": "Name", "type": "string", "required": true},
+  {"column": "E", "field_name": "Qualifikation", "type": "string", "required": true},
+  {"column": "F", "field_name": "Funktion", "type": "string", "required": true},
+  {"column": "G", "field_name": "Stellenanteil in %", "type": "number", "required": true},
+  {"column": "H", "field_name": "Monat (MM.JJ)", "type": "string", "required": true},
+  {"column": "I", "field_name": "Tätigkeit", "type": "string", "required": true}
+]
@@ -0,0 +1,10 @@
+[
+  {"source_field": "Antragsnummer",           "pdf_field": "Antragsnummer_Field",         "format": null},
+  {"source_field": "Name",                    "pdf_field": "Name_Field",                   "format": null},
+  {"source_field": "Stellenanteil in %",      "pdf_field": "Stellenanteil_Field",          "format": null},
+  {"source_field": "Qualifikation",           "pdf_field": "Qualifikation_Field",          "format": null},
+  {"source_field": "Monat (MM.JJ)",           "pdf_field": "Monat_Field",                  "format": null},
+  {"source_field": "Funktion",                "pdf_field": "Funktion_Field",               "format": null},
+  {"source_field": "Tätigkeit",               "pdf_field": "Tätigkeiten_Field",            "format": null},
+  {"source_field": "Datum",                   "pdf_field": "Datum_Field",                  "format": null}
+]
@@ -0,0 +1,22 @@
+[paths]
+input_dir = input
+template_dir = template
+output_dir = output
+
+[output]
+filename_pattern = {last_name}_{first_name}_Tätigkeitsnachweis.pdf
+
+[font]
+# Statische Schriftgröße (in Punkt) für alle Felder im PDF
+fontsize = 9
+
+[parsing]
+# Sheets whose names match these patterns are treated as monthly data sheets
+# Use * as wildcard. Sheets not matching are ignored (e.g. "Alle Rollen").
+month_sheet_pattern = * 20??
+
+# Skip rows where the employee name is empty
+skip_empty_name = true
+
+# Skip rows where Antragsnummer is missing
+skip_empty_antragsnummer = true
@@ -0,0 +1,3 @@
+streamlit>=1.28,<2.0
+openpyxl>=3.1,<4.0
+PyMuPDF>=1.23,<2.0
@@ -0,0 +1,117 @@
+"""Stop an existing instance of this application's Windows server."""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+_CONFIRM_SCRIPT = r'''
+function Confirm-ServerRestart {
+    Add-Type -AssemblyName System.Windows.Forms
+    $answer = [System.Windows.Forms.MessageBox]::Show(
+        "Es läuft bereits eine Version des Tätigkeitsnachweis-Generators.`n`nSoll das alte Programm beendet und die neue Version gestartet werden?`nDie aktuellen Auswahlen gehen dabei verloren.",
+        'Tätigkeitsnachweis-Generator',
+        [System.Windows.Forms.MessageBoxButtons]::YesNo,
+        [System.Windows.Forms.MessageBoxIcon]::Question,
+        [System.Windows.Forms.MessageBoxDefaultButton]::Button2
+    )
+    return $answer -eq [System.Windows.Forms.DialogResult]::Yes
+}
+'''
+
+
+def stop_existing_server(port: int = 8501) -> bool:
+    """Ask before stopping this app. Return False if the user declines."""
+    if os.name != "nt":
+        raise RuntimeError("Der kontrollierte Server-Neustart unterstützt nur Windows.")
+
+    app_path = Path(__file__).resolve().with_name("app.py")
+    app_paths = [str(app_path)]
+    if getattr(sys, "frozen", False):
+        # A locally built EXE in 2_build/ must also recognize the sibling
+        # development application, whose path differs from _MEIPASS/app.py.
+        exe_dir = Path(sys.executable).resolve().parent
+        development_app = exe_dir.parent / "0_application" / "app.py"
+        if exe_dir.name.lower() == "2_build" and development_app.is_file():
+            app_paths.append(str(development_app))
+    # Pass paths through the environment, never interpolate them into shell code.
+    env = dict(os.environ, APP_RESTART_PATH=str(app_path),
+               APP_RESTART_PATHS=json.dumps(app_paths), APP_RESTART_PID=str(os.getpid()),
+               APP_RESTART_PORT=str(port),
+               APP_RESTART_VENV=str(Path(app_path).parent / ".venv" / "Scripts"))
+    script = _CONFIRM_SCRIPT + r'''
+[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new()
+$ErrorActionPreference = 'Stop'
+try {
+$port = [int]$env:APP_RESTART_PORT
+$listeners = @(Get-NetTCPConnection -State Listen -ErrorAction Stop |
+    Where-Object { $_.LocalPort -eq $port })
+$processIds = @($listeners | Select-Object -ExpandProperty OwningProcess -Unique)
+$targets = @()
+foreach ($processId in $processIds) {
+    if ($processId -eq [int]$env:APP_RESTART_PID) {
+        throw "Der aktuelle Prozess belegt bereits Port $port."
+    }
+    $process = Get-CimInstance Win32_Process -Filter "ProcessId = $processId"
+    if (-not $process) { continue }
+    $isExe = $process.Name -eq 'Tätigkeitsnachweis-Generator.exe'
+    $command = $process.CommandLine
+    $matchesApp = $false
+    foreach ($appPath in ($env:APP_RESTART_PATHS | ConvertFrom-Json)) {
+        $appArgument = '(?i)\bstreamlit(?:\.exe)?"?\s+run\s+"?' +
+            [regex]::Escape($appPath) + '"?(?:\s|$)'
+        if ($command -match $appArgument) { $matchesApp = $true }
+    }
+    $isDev = $process.Name -match '^(python(?:w)?(?:\d+(?:\.\d+)*)?(?:w)?|streamlit)\.exe$' -and
+        $command -match '(?i)\bstreamlit(?:\.exe)?"?\s+run\s+' -and
+        ($matchesApp -or
+         ($command -match '(?i)\bstreamlit(?:\.exe)?"?\s+run\s+"?app\.py"?(?:\s|$)' -and
+          [IO.Path]::GetDirectoryName($process.ExecutablePath) -eq $env:APP_RESTART_VENV))
+    if (-not ($isExe -or $isDev)) {
+        throw "Port $port wird von einem anderen Programm verwendet (PID $processId, $($process.Name)). Bitte manuell prüfen."
+    }
+    $targets += $processId
+}
+if ($targets.Count -gt 0 -and -not (Confirm-ServerRestart)) {
+    exit 2
+}
+foreach ($processId in $targets) {
+    Stop-Process -Id $processId -Force -ErrorAction Stop
+}
+$deadline = (Get-Date).AddSeconds(10)
+do {
+    $remaining = @(Get-NetTCPConnection -State Listen -ErrorAction Stop |
+        Where-Object { $_.LocalPort -eq $port })
+    if ($remaining.Count -eq 0) { break }
+    Start-Sleep -Milliseconds 200
+} while ((Get-Date) -lt $deadline)
+if ($remaining.Count -gt 0) { throw "Port $port wurde nicht rechtzeitig freigegeben." }
+ConvertTo-Json -Compress -InputObject @($targets)
+} catch {
+    [Console]::Error.WriteLine($_.Exception.Message)
+    exit 1
+}
+'''
+    result = subprocess.run(
+        ["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", script],
+        env=env, capture_output=True, text=True, encoding="utf-8", errors="replace",
+    )
+    if result.returncode == 2:
+        return False
+    if result.returncode:
+        raise RuntimeError((result.stderr or "").strip() or "Der bestehende Server konnte nicht beendet werden.")
+    stopped = json.loads(result.stdout.strip() or "[]")
+    if stopped:
+        print(f"[INFO] Vorherige Instanz beendet (PID: {stopped}).", flush=True)
+    return True
+
+
+if __name__ == "__main__":
+    try:
+        if not stop_existing_server():
+            print("[INFO] Die bisherige Version bleibt geöffnet. Keine neue Instanz gestartet.")
+            raise SystemExit(2)
+    except (RuntimeError, OSError, subprocess.SubprocessError) as exc:
+        print(f"[FEHLER] {exc}")
+        raise SystemExit(1)
@@ -0,0 +1 @@
+"""Tätigkeitsnachweis-Generator package."""
@@ -0,0 +1,85 @@
+"""Tätigkeitsnachweis-Generator – Konfigurations-Loader."""
+
+import configparser
+import json
+import fnmatch
+from pathlib import Path
+from typing import Optional
+
+from .models import AppConfig, FieldSchema, OutputMapping
+
+
+def load_settings(config_dir: Path, project_root: Path) -> AppConfig:
+    """Lädt settings.ini und gibt ein AppConfig-Objekt zurück."""
+    ini_path = config_dir / "settings.ini"
+    if not ini_path.exists():
+        raise FileNotFoundError(f"settings.ini nicht gefunden: {ini_path}")
+
+    parser = configparser.ConfigParser()
+    parser.read(ini_path, encoding="utf-8")
+
+    paths = parser["paths"] if "paths" in parser else {}
+    output = parser["output"] if "output" in parser else {}
+    parsing = parser["parsing"] if "parsing" in parser else {}
+    font = parser["font"] if "font" in parser else {}
+
+    return AppConfig(
+        input_dir=str(project_root / paths.get("input_dir", "input")),
+        template_dir=str(project_root / paths.get("template_dir", "template")),
+        output_dir=str(project_root / paths.get("output_dir", "output")),
+        filename_pattern=output.get("filename_pattern", "{last_name}_{first_name}_Tätigkeitsnachweis.xlsx"),
+        month_sheet_pattern=parsing.get("month_sheet_pattern", "* 20??"),
+        skip_empty_name=parsing.getboolean("skip_empty_name", True),
+        skip_empty_antragsnummer=parsing.getboolean("skip_empty_antragsnummer", True),
+        fontsize=font.getfloat("fontsize", 11.0),
+    )
+
+
+def load_input_schema(config_dir: Path) -> list[FieldSchema]:
+    """Lädt input-fields.json."""
+    schema_path = config_dir / "input-fields.json"
+    if not schema_path.exists():
+        raise FileNotFoundError(f"input-fields.json nicht gefunden: {schema_path}")
+
+    with open(schema_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    return [FieldSchema(**item) for item in data]
+
+
+def load_output_mapping(config_dir: Path) -> list[OutputMapping]:
+    """Lädt output-fields.json."""
+    mapping_path = config_dir / "output-fields.json"
+    if not mapping_path.exists():
+        raise FileNotFoundError(f"output-fields.json nicht gefunden: {mapping_path}")
+
+    with open(mapping_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    return [OutputMapping(**item) for item in data]
+
+
+def get_available_files(directory: Path, extension: str = ".xlsx") -> list[str]:
+    """Listet alle Dateien mit der angegebenen Erweiterung im Verzeichnis auf."""
+    if not directory.exists():
+        return []
+    files = sorted(
+        f.name for f in directory.iterdir()
+        if f.is_file() and f.suffix.lower() == extension and not f.name.startswith("~")
+    )
+    return files
+
+
+def get_available_input_files(config: AppConfig) -> list[str]:
+    """Listet alle .xlsx-Dateien im input-Ordner."""
+    return get_available_files(Path(config.input_dir))
+
+
+def get_available_templates(config: AppConfig) -> list[str]:
+    """Listet alle .pdf-Dateien im template-Ordner."""
+    return get_available_files(Path(config.template_dir), extension=".pdf")
+
+
+def is_month_sheet(sheet_name: str, pattern: str) -> bool:
+    """Prüft, ob ein Sheet-Name dem Monatsmuster entspricht."""
+    return fnmatch.fnmatch(sheet_name.strip(), pattern)
@@ -0,0 +1,75 @@
+"""Tätigkeitsnachweis-Generator – Datenmodelle."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class EmployeeRecord:
+    """Eine Zeile aus einem Monats-Sheet der Input-Datei."""
+    name: str
+    antragsnummer: str
+    qualifikation: str
+    funktion: str
+    stellenanteil: str
+    monat: str          # z. B. "01.2025"
+    taetigkeit: str
+    id: Optional[int] = None
+    kommentar: Optional[str] = None
+
+    @property
+    def month_index(self) -> int:
+        """Extrahiere den Monatsindex (1–12) aus dem Monatsfeld."""
+        try:
+            return int(self.monat.split(".")[0])
+        except (ValueError, IndexError):
+            return 0
+
+    @property
+    def year(self) -> int:
+        """Extrahiere das Jahr aus dem Monatsfeld."""
+        try:
+            return int(self.monat.split(".")[1])
+        except (ValueError, IndexError):
+            return 0
+
+
+@dataclass
+class FieldSchema:
+    """Definition eines Feldes aus input-fields.json."""
+    column: str
+    field_name: str
+    type: str
+    required: bool
+
+
+@dataclass
+class OutputMapping:
+    """Definition eines Mappings aus output-fields.json."""
+    source_field: str
+    format: Optional[str] = None
+    pdf_field: Optional[str] = None  # Name des _Field-Platzhalters im PDF (z.B. "Auftragsnummer_Field")
+
+
+@dataclass
+class AppConfig:
+    """Gesamte App-Konfiguration."""
+    input_dir: str
+    template_dir: str
+    output_dir: str
+    filename_pattern: str
+    input_schema: list = field(default_factory=list)
+    output_mapping: list = field(default_factory=list)
+    month_sheet_pattern: str = "* 20??"
+    skip_empty_name: bool = True
+    skip_empty_antragsnummer: bool = True
+    fontsize: float = 11.0
+
+
+@dataclass
+class ValidationResult:
+    """Ergebnis einer Validierung."""
+    is_valid: bool
+    errors: list = field(default_factory=list)
+    warnings: list = field(default_factory=list)
+    info: dict = field(default_factory=dict)
@@ -0,0 +1,134 @@
+"""Input-Datei-Parser: liest monatliche Sheets und erzeugt EmployeeRecords."""
+
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+from openpyxl import load_workbook
+from openpyxl.utils import column_index_from_string
+
+from .config import is_month_sheet
+from .models import EmployeeRecord, FieldSchema
+
+
+def _to_text(value: Any) -> str:
+    if value is None:
+        return ""
+    return str(value).strip()
+
+
+def _to_int_or_none(value: Any) -> Optional[int]:
+    if value is None or str(value).strip() == "":
+        return None
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return None
+
+
+def _to_percent_string(value: Any) -> str:
+    """Wandelt einen Prozentwert in einen String ohne %-Zeichen um.
+
+    Excel speichert Prozentwerte als Dezimalbruch (50 % = 0.5).
+    Falls der Rohwert eine Zahl ≤ 1 ist, wird er als Excel-Prozentwert
+    interpretiert und mit 100 multipliziert.
+    """
+    if value is None or str(value).strip() == "":
+        return ""
+    # Falls es bereits ein String mit %-Zeichen ist
+    if isinstance(value, str):
+        return value.strip().rstrip("% ")
+    # Numerischer Wert: Excel-Prozentwert (0.5 = 50 %) oder Ganzzahl (50 = 50 %)
+    if isinstance(value, (int, float)):
+        if 0 < value <= 1:
+            return str(int(value * 100))
+        if value == 0:
+            return "0"
+        # Wert > 1: bereits als Ganzzahl gemeint (z. B. 50)
+        return str(int(value))
+    return str(value).strip()
+
+
+def _build_column_map(schema: list[FieldSchema]) -> dict[str, int]:
+    """Baut ein Mapping von field_name → 0-basierter Spaltenindex."""
+    col_map: dict[str, int] = {}
+    for field in schema:
+        col_map[field.field_name] = column_index_from_string(field.column) - 1
+    return col_map
+
+
+def parse_input_file(
+    filepath: Path,
+    schema: list[FieldSchema],
+    month_sheet_pattern: str = "* 20??",
+    skip_empty_name: bool = True,
+    skip_empty_antragsnummer: bool = True,
+) -> list[EmployeeRecord]:
+    """
+    Öffnet die Input-Datei, iteriert über alle Monats-Sheets
+    und gibt eine Liste von EmployeeRecords zurück.
+    """
+    wb = load_workbook(filepath, data_only=True)
+    col_map = _build_column_map(schema)
+    records: list[EmployeeRecord] = []
+
+    for sheet_name in wb.sheetnames:
+        if not is_month_sheet(sheet_name, month_sheet_pattern):
+            continue
+
+        ws = wb[sheet_name]
+        # Header ist Zeile 1, Daten ab Zeile 2
+        # min_col=1 explizit setzen für korrekte Spaltenzuordnung
+        schema_col_count = len(schema)
+        for row in ws.iter_rows(min_row=2, max_row=ws.max_row, min_col=1, max_col=schema_col_count, values_only=True):
+            name = _to_text(row[col_map.get("Name", 0)]) if len(row) > col_map.get("Name", 0) else ""
+            antragsnummer = _to_text(row[col_map.get("Antragsnummer", 0)]) if len(row) > col_map.get("Antragsnummer", 0) else ""
+
+            if skip_empty_name and not name:
+                continue
+            if skip_empty_antragsnummer and not antragsnummer:
+                continue
+
+            qualifikation = _to_text(row[col_map.get("Qualifikation", 0)]) if len(row) > col_map.get("Qualifikation", 0) else ""
+            funktion = _to_text(row[col_map.get("Funktion", 0)]) if len(row) > col_map.get("Funktion", 0) else ""
+            stellenanteil_raw = row[col_map.get("Stellenanteil in %", 0)] if len(row) > col_map.get("Stellenanteil in %", 0) else None
+            stellenanteil = _to_percent_string(stellenanteil_raw)
+            monat = _to_text(row[col_map.get("Monat (MM.JJ)", 0)]) if len(row) > col_map.get("Monat (MM.JJ)", 0) else ""
+            taetigkeit = _to_text(row[col_map.get("Tätigkeit", 0)]) if len(row) > col_map.get("Tätigkeit", 0) else ""
+            record_id = _to_int_or_none(row[col_map.get("ID", 0)]) if len(row) > col_map.get("ID", 0) else None
+            kommentar = _to_text(row[col_map.get("Kommentar", 1)]) if "Kommentar" in col_map and len(row) > col_map["Kommentar"] else None
+
+            records.append(EmployeeRecord(
+                id=record_id,
+                name=name,
+                antragsnummer=antragsnummer,
+                qualifikation=qualifikation,
+                funktion=funktion,
+                stellenanteil=stellenanteil,
+                monat=monat,
+                taetigkeit=taetigkeit,
+                kommentar=kommentar,
+            ))
+
+    wb.close()
+    return records
+
+
+def group_by_employee(records: list[EmployeeRecord]) -> dict[str, list[EmployeeRecord]]:
+    """Gruppiert Records nach Mitarbeitername."""
+    groups: dict[str, list[EmployeeRecord]] = {}
+    for record in records:
+        if record.name not in groups:
+            groups[record.name] = []
+        groups[record.name].append(record)
+    return groups
+
+
+def get_unique_antragsnummern(records: list[EmployeeRecord]) -> list[str]:
+    """Gibt eine sortierte Liste aller eindeutigen Antragsnummern zurück."""
+    return sorted(set(r.antragsnummer for r in records if r.antragsnummer))
+
+
+def get_unique_employees(records: list[EmployeeRecord]) -> list[str]:
+    """Gibt eine sortierte Liste aller eindeutigen Mitarbeiternamen zurück."""
+    return sorted(set(r.name for r in records if r.name))
@@ -0,0 +1,206 @@
+"""Validierung von Input-Dateien und Templates."""
+
+from pathlib import Path
+from typing import Optional
+
+import fitz  # PyMuPDF
+from openpyxl import load_workbook
+from openpyxl.utils import column_index_from_string
+
+from .config import is_month_sheet
+from .models import FieldSchema, OutputMapping, ValidationResult
+
+
+def validate_input_file(
+    filepath: Path,
+    schema: list[FieldSchema],
+    month_sheet_pattern: str = "* 20??",
+) -> ValidationResult:
+    """
+    Validiert eine Input-Datei:
+    - Datei existiert
+    - Erwartete Spalten sind vorhanden (Header in Zeile 1)
+    - Mindestens ein Monats-Daten-Sheet enthält Daten
+    - Nicht-Monats-Sheets (z. B. "Alle Rollen") werden übersprungen
+    """
+    errors: list[str] = []
+    warnings: list[str] = []
+    info: dict = {}
+
+    if not filepath.exists():
+        errors.append(f"Input-Datei nicht gefunden: {filepath}")
+        return ValidationResult(is_valid=False, errors=errors)
+
+    try:
+        wb = load_workbook(filepath, data_only=True)
+    except Exception as e:
+        errors.append(f"Datei konnte nicht geöffnet werden: {e}")
+        return ValidationResult(is_valid=False, errors=errors)
+
+    sheet_count = len(wb.sheetnames)
+    info["sheet_count"] = sheet_count
+    info["sheet_names"] = wb.sheetnames
+
+    # Prüfe nur Monats-Sheets (überspringe z. B. "Alle Rollen")
+    schema_col_count = len(schema)
+    sheets_with_data = 0
+    for sheet_name in wb.sheetnames:
+        if not is_month_sheet(sheet_name, month_sheet_pattern):
+            continue
+
+        ws = wb[sheet_name]
+        if ws.max_row < 2:
+            continue  # Kein Header + Daten
+
+        # min_col=1 explizit setzen, um Verschiebungen bei
+        # ws.min_column > 1 zu vermeiden
+        header_row = list(ws.iter_rows(
+            min_row=1, max_row=1, min_col=1, max_col=schema_col_count,
+            values_only=True,
+        ))[0]
+        missing_cols = []
+        for field in schema:
+            col_idx = column_index_from_string(field.column) - 1
+            if col_idx >= len(header_row):
+                missing_cols.append(f"{field.column} ({field.field_name})")
+                continue
+            header_val = str(header_row[col_idx]).strip() if header_row[col_idx] is not None else ""
+            if header_val != field.field_name:
+                warnings.append(
+                    f"Sheet '{sheet_name}', Spalte {field.column}: "
+                    f"Erwartet '{field.field_name}', gefunden '{header_val}'"
+                )
+
+        if not missing_cols:
+            sheets_with_data += 1
+
+        # Zähle Datenzeilen
+        data_rows = ws.max_row - 1
+        info[f"rows_{sheet_name}"] = data_rows
+
+    info["sheets_with_data"] = sheets_with_data
+    wb.close()
+
+    # ── Dateninhalts-Prüfung: leere Pflichtfelder ───────────────────
+    required_fields = [f for f in schema if f.required]
+    if required_fields and sheets_with_data > 0:
+        # Mapping field_name → column index
+        field_col_map: dict[str, int] = {}
+        for f in required_fields:
+            field_col_map[f.field_name] = column_index_from_string(f.column) - 1
+        max_col = max(field_col_map.values()) + 1
+
+        # {field_name: {name1, name2, ...}} für leere Pflichtwerte
+        empty_by_field: dict[str, set[str]] = {f.field_name: set() for f in required_fields}
+
+        wb2 = load_workbook(filepath, data_only=True)
+        for sheet_name in wb2.sheetnames:
+            if not is_month_sheet(sheet_name, month_sheet_pattern):
+                continue
+            ws = wb2[sheet_name]
+            if ws.max_row < 2:
+                continue
+            for row in ws.iter_rows(min_row=2, max_row=ws.max_row, min_col=1, max_col=max_col, values_only=True):
+                name_val = str(row[field_col_map.get("Name", 0)] or "").strip() if len(row) > field_col_map.get("Name", 0) else ""
+                if not name_val:
+                    continue
+                for f in required_fields:
+                    col_idx = field_col_map[f.field_name]
+                    if col_idx < len(row):
+                        cell_val = str(row[col_idx] or "").strip() if row[col_idx] is not None else ""
+                        if not cell_val:
+                            empty_by_field[f.field_name].add(name_val)
+        wb2.close()
+
+        for field_name, names in empty_by_field.items():
+            if names:
+                sorted_names = sorted(names)
+                total = len(sorted_names)
+                preview = sorted_names[:5]
+                suffix = " …" if total > 5 else ""
+                warnings.append(
+                    f"Feld '{field_name}' ist leer bei {total} Person(en): "
+                    f"{', '.join(preview)}{suffix}"
+                )
+    # ──────────────────────────────────────────────────────────────────
+
+    if sheets_with_data == 0:
+        errors.append("Kein Sheet mit den erwarteten Spalten gefunden.")
+
+    return ValidationResult(
+        is_valid=len(errors) == 0,
+        errors=errors,
+        warnings=warnings,
+        info=info,
+    )
+
+
+def validate_template(
+    template_path: Path,
+    mapping: list[OutputMapping],
+) -> ValidationResult:
+    """
+    Validiert ein PDF-Template:
+    - Datei existiert
+    - Alle _Field-Platzhalter (pdf_field) sind im PDF auf irgendeiner Seite vorhanden
+    """
+    errors: list[str] = []
+    warnings: list[str] = []
+    info: dict = {}
+
+    if not template_path.exists():
+        errors.append(f"Template-Datei nicht gefunden: {template_path}")
+        return ValidationResult(is_valid=False, errors=errors)
+
+    try:
+        doc = fitz.open(template_path)
+    except Exception as e:
+        errors.append(f"PDF-Template konnte nicht geöffnet werden: {e}")
+        return ValidationResult(is_valid=False, errors=errors)
+
+    if doc.page_count == 0:
+        errors.append("PDF-Template enthält keine Seiten.")
+        doc.close()
+        return ValidationResult(is_valid=False, errors=errors)
+
+    found_count = 0
+    missing_fields = []
+
+    for m in mapping:
+        if m.pdf_field is None:
+            continue  # Kein Marker erwartet
+
+        # Suche auf allen Seiten
+        found_any = False
+        for page_num in range(doc.page_count):
+            found = doc[page_num].search_for(m.pdf_field)
+            if found:
+                found_any = True
+                break
+
+        if found_any:
+            found_count += 1
+        else:
+            missing_fields.append(m.source_field)
+
+    # Zähle unique pdf_fields (nicht die source_fields, da Tätigkeit doppelt vorkommt)
+    unique_pdf_fields = set(m.pdf_field for m in mapping if m.pdf_field is not None)
+    total_pages = doc.page_count
+
+    doc.close()
+
+    info["found_fields"] = found_count
+    info["total_fields"] = len(unique_pdf_fields)
+    info["page_count"] = total_pages
+
+    if missing_fields:
+        errors.append(
+            f"Platzhalter nicht im PDF-Template gefunden: {', '.join(missing_fields)}"
+        )
+
+    return ValidationResult(
+        is_valid=len(errors) == 0,
+        errors=errors,
+        warnings=warnings,
+        info=info,
+    )
@@ -0,0 +1,289 @@
+"""PDF-basierte Activity-Report-Generierung.
+
+Verwendet ein mehrseitiges PDF-Template mit _Field-Platzhaltern.
+Für jeden Mitarbeiter wird ein PDF erzeugt (alle Template-Seiten pro Monat).
+Die _Field-Marker werden per PyMuPDF (fitz) gesucht und durch echte Daten ersetzt.
+"""
+
+import calendar
+from pathlib import Path
+
+import fitz  # PyMuPDF
+
+from .models import EmployeeRecord, OutputMapping
+
+
+# ─────────────────────────────────────────────
+# Namens-Helfer
+# ─────────────────────────────────────────────
+
+def _split_name_for_filename(name: str) -> tuple[str, str]:
+    """Teilt 'Nachname, Vorname' oder 'Vorname Nachname' in (Vorname, Nachname)."""
+    cleaned = str(name or "").strip()
+    if "," in cleaned:
+        last_name, first_name = [p.strip() for p in cleaned.split(",", 1)]
+        return first_name or "Unknown", last_name or "Unknown"
+    parts = cleaned.split()
+    if len(parts) >= 2:
+        return parts[0], parts[-1]
+    if len(parts) == 1:
+        return parts[0], "Unknown"
+    return "Unknown", "Unknown"
+
+
+def _format_value(value, fmt: str | None) -> str:
+    """Formatiert einen Wert gemäß Format-String."""
+    if value is None:
+        return ""
+    if fmt is None:
+        return str(value)
+    if "%" in fmt:
+        try:
+            return fmt % float(value)
+        except (ValueError, TypeError):
+            return str(value)
+    return str(value)
+
+
+def _format_month_for_template(monat_str: str) -> str:
+    """Konvertiert 'MM.JJ' zu 'MM.JJJJ'."""
+    monat_str = monat_str.strip()
+    parts = monat_str.split(".")
+    if len(parts) == 2:
+        month = parts[0]
+        year = parts[1]
+        if len(year) == 2:
+            year = "20" + year
+        return f"{month}.{year}"
+    return monat_str
+
+
+# ─────────────────────────────────────────────
+# Daten-Extraktion aus EmployeeRecord
+# ─────────────────────────────────────────────
+
+def _get_field_value(record: EmployeeRecord, employee_name: str, source_field: str) -> str:
+    """Liefert den formatierten Wert für ein Feld im PDF."""
+    if source_field == "Monat (MM.JJ)":
+        return _format_month_for_template(record.monat)
+    elif source_field == "Stellenanteil in %":
+        try:
+            value = int(float(str(record.stellenanteil).strip()))
+            return f"{value},00"
+        except (ValueError, TypeError):
+            return str(record.stellenanteil)
+    elif source_field == "Name":
+        return employee_name
+    elif source_field == "Antragsnummer":
+        return record.antragsnummer
+    elif source_field == "Qualifikation":
+        return record.qualifikation
+    elif source_field == "Funktion":
+        return record.funktion
+    elif source_field == "Tätigkeit":
+        return record.taetigkeit
+    elif source_field in ("Ort", "Ort 2"):
+        return "Dresden"
+    elif source_field == "Datum":
+        parts = record.monat.split(".")
+        if len(parts) == 2:
+            try:
+                month = int(parts[0])
+                year = int(parts[1])
+                last_day = calendar.monthrange(year, month)[1]
+                return f"{last_day:02d}.{month:02d}.{year}"
+            except (ValueError, IndexError):
+                return ""
+        return ""
+    return ""
+
+
+# ─────────────────────────────────────────────
+# PDF-Template Pre-Scan: _Field-Positionen auf ALLEN Seiten ermitteln
+# ─────────────────────────────────────────────
+
+def _scan_template_fields(
+    template_path: Path,
+    mapping: list[OutputMapping],
+    fontsize: float,
+) -> dict[str, list[dict]]:
+    """
+    Scannt ALLE Seiten des PDF-Templates nach _Field-Platzhaltern.
+    Rückgabe: dict[pdf_field] → Liste von {source_field, page_num, rect, fontsize, fontname, ...}
+    Felder mit pdf_field=None werden übersprungen.
+    """
+    doc = fitz.open(template_path)
+
+    # Sammle alle pdf_field → source_field Zuordnungen
+    pdf_to_source: dict[str, str] = {}
+    for m in mapping:
+        if m.pdf_field is not None:
+            pdf_to_source[m.pdf_field] = m.source_field
+
+    field_info: dict[str, list[dict]] = {}
+
+    # Alle Vorkommen aller PDF-Feld-Marker finden (alle Seiten)
+    for pdf_field, source_field in pdf_to_source.items():
+        occurrences: list[dict] = []
+        for page_num in range(doc.page_count):
+            page = doc[page_num]
+            found = page.search_for(pdf_field)
+            for rect in found:
+                occurrences.append({
+                    "source_field": source_field,
+                    "page_num": page_num,
+                    "rect": rect,
+                    "fontsize": fontsize,
+                    "fontname": "helv",
+                })
+        field_info[pdf_field] = occurrences
+
+    doc.close()
+    return field_info
+
+
+# ─────────────────────────────────────────────
+# Template-Seiten mit Daten befüllen
+# ─────────────────────────────────────────────
+
+def _fill_pdf_pages(
+    pages: list[fitz.Page],  # eine Page pro Template-Seite
+    record: EmployeeRecord,
+    employee_name: str,
+    mapping: list[OutputMapping],
+    field_info: dict[str, list[dict]],
+    fontsize: float,
+) -> None:
+    """Befüllt alle Template-Seiten: redacted _Field-Platzhalter und fügt echte Daten ein."""
+    # Mehrzeilige Felder, die als Textbox (mit Zeilenumbruch) behandelt werden
+    MULTILINE_FIELDS = {"Tätigkeiten_Field", "Dienstreisen_Field"}
+    TEXTBOX_WIDTH_PT = 400        # Breite der Textbox in Punkt
+
+    for m in mapping:
+        if m.pdf_field is None:
+            continue
+
+        occurrences = field_info.get(m.pdf_field, [])
+        if not occurrences:
+            continue  # Feld nicht im Template gefunden
+
+        value = _get_field_value(record, employee_name, m.source_field)
+        formatted = _format_value(value, m.format)
+
+        # Jedes Vorkommen des Feldes im PDF befüllen
+        for info in occurrences:
+            page_num = info["page_num"]
+            if page_num >= len(pages):
+                continue
+
+            page = pages[page_num]
+            rect = info["rect"]
+
+            # Platzhalter redacten
+            page.add_redact_annot(rect)
+            page.apply_redactions()
+
+            if not formatted:
+                continue
+
+            # Mehrzeilige Felder: Zeilenweise per insert_text schreiben
+            if m.pdf_field in MULTILINE_FIELDS:
+                # ... (unverändert)
+                clean_text = "\n".join(
+                    line for line in formatted.split("\n") if line.strip()
+                )
+                if not clean_text:
+                    continue
+
+                lines = clean_text.split("\n")
+                line_spacing = fontsize * 1.2
+
+                output_lines: list[str] = []
+                for line in lines:
+                    max_width = TEXTBOX_WIDTH_PT
+                    words = line.split(" ")
+                    current_line = ""
+                    for word in words:
+                        test_line = current_line + (" " if current_line else "") + word
+                        text_width = fitz.get_text_length(test_line, fontname="helv", fontsize=fontsize)
+                        if text_width <= max_width or not current_line:
+                            current_line = test_line
+                        else:
+                            output_lines.append(current_line)
+                            current_line = word
+                    if current_line:
+                        output_lines.append(current_line)
+
+                y = rect.y0 + fontsize
+                for current_line in output_lines:
+                    page.insert_text(
+                        (rect.x0, y), current_line,
+                        fontname="helv", fontsize=fontsize,
+                    )
+                    y += line_spacing
+            else:
+                # Einzeilige Felder: vertikal zentriert platzieren
+                mid_y = (rect.y0 + rect.y1) / 2
+                baseline_y = mid_y + fontsize * 0.35
+                page.insert_text(
+                    (rect.x0, baseline_y),
+                    formatted,
+                    fontname="helv",
+                    fontsize=fontsize,
+                )
+
+
+# ─────────────────────────────────────────────
+# Hauptfunktion: Reports generieren
+# ─────────────────────────────────────────────
+
+def generate_activity_reports(
+    employee_records: dict[str, list[EmployeeRecord]],
+    template_path: Path,
+    mapping: list[OutputMapping],
+    output_dir: Path,
+    filename_pattern: str,
+    fontsize: float = 11.0,
+) -> list[Path]:
+    """
+    Erzeugt für jeden Mitarbeiter ein PDF.
+    Pro Monat werden ALLE Template-Seiten kopiert und mit Daten befüllt.
+    """
+    output_dir.mkdir(parents=True, exist_ok=True)
+    generated_files: list[Path] = []
+
+    # Pre-Scan: Feld-Positionen auf allen Template-Seiten ermitteln
+    field_info = _scan_template_fields(template_path, mapping, fontsize)
+
+    for employee_name, records in employee_records.items():
+        if not records:
+            continue
+
+        first_name, last_name = _split_name_for_filename(employee_name)
+        safe_first = first_name.replace(" ", "_").replace("/", "_")
+        safe_last = last_name.replace(" ", "_").replace("/", "_")
+
+        filename = filename_pattern.format(first_name=safe_first, last_name=safe_last)
+        output_path = output_dir / filename
+
+        sorted_records = sorted(records, key=lambda r: r.month_index)
+
+        # Ergebnis-PDF erstellen
+        result_doc = fitz.open()
+
+        for record in sorted_records:
+            # Template frisch öffnen für jeden Monat
+            temp_doc = fitz.open(template_path)
+            pages = [temp_doc[i] for i in range(temp_doc.page_count)]
+
+            _fill_pdf_pages(pages, record, employee_name, mapping, field_info, fontsize)
+
+            # Alle modifizierten Seiten ins Ergebnis-PDF einfügen
+            result_doc.insert_pdf(temp_doc)
+            temp_doc.close()
+
+        result_doc.save(output_path)
+        result_doc.close()
+        generated_files.append(output_path)
+
+    return generated_files
@@ -0,0 +1,57 @@
+@echo off
+chcp 65001 >nul
+set "PYTHONUTF8=1"
+cd /d "%~dp0"
+title Tätigkeitsnachweis-Generator
+echo ========================================
+echo   Tätigkeitsnachweis-Generator
+echo ========================================
+echo.
+
+:: Prüfe ob Python verfügbar ist
+where python >nul 2>nul
+if %ERRORLEVEL% neq 0 (
+    echo [FEHLER] Python wurde nicht gefunden.
+    echo Bitte installiere Python 3.9 oder neuer von https://python.org
+    pause
+    exit /b 1
+)
+
+echo [INFO] Python gefunden:
+python --version
+
+:: Prüfe ob venv existiert, sonst erstelle
+if not exist ".venv\Scripts\python.exe" (
+    echo [INFO] Erstelle virtuelle Umgebung...
+    python -m venv .venv
+    if %ERRORLEVEL% neq 0 (
+        echo [FEHLER] Konnte venv nicht erstellen.
+        pause
+        exit /b 1
+    )
+)
+
+:: Aktiviere venv und installiere Abhängigkeiten
+call .venv\Scripts\activate.bat
+echo [INFO] Installiere Abhängigkeiten...
+pip install -r requirements.txt --quiet
+if %ERRORLEVEL% neq 0 (
+    echo [FEHLER] Konnte Abhängigkeiten nicht installieren.
+    pause
+    exit /b 1
+)
+
+:: Starte Streamlit
+echo.
+echo [INFO] Starte Tätigkeitsnachweis-Generator...
+echo [INFO] Die App öffnet sich im Browser unter http://localhost:8501
+echo.
+".venv\Scripts\python.exe" server_lifecycle.py
+if %ERRORLEVEL% equ 2 exit /b 0
+if %ERRORLEVEL% neq 0 (
+    pause
+    exit /b 1
+)
+".venv\Scripts\python.exe" -m streamlit run "%~dp0app.py" --server.port=8501 --server.address=localhost
+
+pause
@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Doppelklickbares Start-Script für macOS (.command wird von Finder automatisch im Terminal geöffnet)
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "========================================"
+echo "  Tätigkeitsnachweis-Generator"
+echo "========================================"
+echo ""
+
+if command -v python3 >/dev/null 2>&1; then
+    PYTHON_BIN="python3"
+elif command -v python >/dev/null 2>&1; then
+    PYTHON_BIN="python"
+else
+    echo "[FEHLER] Python wurde nicht gefunden."
+    echo "Bitte installiere Python 3.9+ von https://python.org"
+    read -p "Drücke Enter zum Beenden..."
+    exit 1
+fi
+
+echo "[INFO] Python: $("$PYTHON_BIN" --version)"
+
+VENV_DIR=".venv"
+if [[ ! -x "$VENV_DIR/bin/python" ]]; then
+    if [[ -d "$VENV_DIR" ]]; then
+        echo "[INFO] Erstelle venv neu..."
+        rm -rf "$VENV_DIR"
+    fi
+    echo "[INFO] Erstelle virtuelle Umgebung..."
+    "$PYTHON_BIN" -m venv "$VENV_DIR"
+fi
+
+echo "[INFO] Installiere Abhängigkeiten..."
+"$VENV_DIR/bin/pip" install -r requirements.txt --quiet
+
+echo ""
+echo "[INFO] Starte Tätigkeitsnachweis-Generator..."
+echo "[INFO] Browser: http://localhost:8501"
+echo ""
+"$VENV_DIR/bin/streamlit" run app.py
+
+read -p "Drücke Enter zum Beenden..."
@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Always run from this script's directory.
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "========================================"
+echo "  Tätigkeitsnachweis-Generator"
+echo "========================================"
+echo ""
+
+# Prüfe ob Python verfügbar ist
+if command -v python3 >/dev/null 2>&1; then
+    PYTHON_BIN="python3"
+elif command -v python >/dev/null 2>&1; then
+    PYTHON_BIN="python"
+else
+    echo "[FEHLER] Python wurde nicht gefunden."
+    echo "Bitte installiere Python 3.9 oder neuer von https://python.org"
+    exit 1
+fi
+
+echo "[INFO] Python gefunden:"
+"$PYTHON_BIN" --version
+
+# Prüfe ob venv existiert, sonst erstelle
+VENV_DIR=".venv"
+if [[ ! -x "$VENV_DIR/bin/python" ]]; then
+    if [[ -d "$VENV_DIR" ]]; then
+        echo "[INFO] Vorhandene venv ist nicht kompatibel. Erstelle neu..."
+        rm -rf "$VENV_DIR"
+    fi
+    echo "[INFO] Erstelle virtuelle Umgebung..."
+    "$PYTHON_BIN" -m venv "$VENV_DIR"
+fi
+
+# Aktiviere venv und installiere Abhängigkeiten
+echo "[INFO] Installiere Abhängigkeiten..."
+"$VENV_DIR/bin/pip" install -r requirements.txt --quiet
+
+# Starte Streamlit
+echo ""
+echo "[INFO] Starte Tätigkeitsnachweis-Generator..."
+echo "[INFO] Die App öffnet sich im Browser unter http://localhost:8501"
+echo ""
+"$VENV_DIR/bin/streamlit" run app.py
@@ -0,0 +1,34 @@
+# Aktualisieren der PDF Datei
+
+Wenn sich die PDF-Datei welche als Vorlagen genutzt wird geändert hat, kann diese nicht direkt vom Programm verwendet werden, da es die zu verwendenden Felder nicht erkennen kann. Wir müssen ihm kurz zeigen wo die zu nutzenden Felder sind.
+
+Öffne Dazu eine bereits bestehende *.odg Datei im Ordner template und schau Dir die Textfelder an, welche in die entsprechenden Felder gelegt, damit das Programm diese später erkennen kann.
+
+Öffne nun das neue PDF mit dem Programm Libre Office Writer und erzeuge in jedem Formularfeld ein Textfeld mit dem entspechenden Feldnamen wie im Beispiel-odg. Die Felder heißen einfach so wie sie im PDF genutzt werden plus Unterstrich Field. Also:
+- Antragsnummer_Field
+- Name_Field
+- Qulifikation_Field
+- Funktion_Field
+- Stellenanteil_Field
+- Monat_Field
+
+In das Feld Tätigkeiten muss kein neues Textfeld eingefügt werden, weil es schon ein Textfeld ist, daher kann in dieses direkt
+- Tätigkeiten_Field
+
+eingetragen werden.
+
+Auf Seite zwei muss nur ein Feld
+- Datum_Field
+
+erzeugt werden. Denn dieses kann einfach kopiert und im zweiten Datumfeld plaziert werden.
+Für die beiden Ortsfelder muss auch jeweils ein Textfeld eingefügt werden, dieses enthält aber einfach den Text:
+- Dresden
+
+da es vom Programm nicht geändert wird
+
+# Styling
+Um einen einheitlichen look zu garantieren müssen alle eingefügten Textfelder wie folgt gestyled sein:
+- das Textfeld selber füllt das komplette Feld bis an alle 4 Ränder aus
+- Textgröße: 12 pt
+- Font/Schriftart: Arial
+- Absatz Textausrichtung: mittig
@@ -0,0 +1,45 @@
+@echo off
+chcp 65001 >nul
+setlocal
+set "PYTHONUTF8=1"
+cd /d "%~dp0"
+title Taetigkeitsnachweis-Generator - Tests
+
+echo ========================================
+echo   Alle Tests ausfuehren
+echo ========================================
+echo.
+
+if not exist ".venv\Scripts\python.exe" (
+    echo [FEHLER] Die virtuelle Umgebung fehlt. Bitte zuerst start.bat ausfuehren.
+    set "TEST_EXIT_CODE=1"
+    goto finish
+)
+
+".venv\Scripts\python.exe" -c "import pytest" >nul 2>nul
+if errorlevel 1 (
+    echo [INFO] Installiere pytest in der Projektumgebung...
+    ".venv\Scripts\python.exe" -m pip install pytest
+    if errorlevel 1 (
+        echo [FEHLER] pytest konnte nicht installiert werden.
+        set "TEST_EXIT_CODE=1"
+        goto finish
+    )
+)
+
+REM Keine Abbruchoption: Auch nach fehlgeschlagenen Tests laeuft die Suite weiter.
+REM Ohne Cache funktioniert der Testlauf auch bei gesperrtem pytest-Cache.
+".venv\Scripts\python.exe" -m pytest tests -v -p no:cacheprovider
+set "TEST_EXIT_CODE=%ERRORLEVEL%"
+
+echo.
+if "%TEST_EXIT_CODE%"=="0" (
+    echo [OK] Alle Tests bestanden.
+) else (
+    echo [FEHLER] Testlauf nicht erfolgreich. Details stehen oben.
+)
+
+:finish
+REM Fuer automatisierte Aufrufe: test.bat --no-pause
+if /I not "%~1"=="--no-pause" pause
+exit /b %TEST_EXIT_CODE%
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Doppelklickbares Test-Script für macOS (.command wird von Finder automatisch im Terminal geöffnet)
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "========================================"
+echo "  Tätigkeitsnachweis-Generator – Tests"
+echo "========================================"
+echo ""
+
+VENV_DIR=".venv"
+
+if [[ ! -x "$VENV_DIR/bin/python" ]]; then
+    echo "[FEHLER] Virtuelle Umgebung nicht gefunden."
+    echo "Bitte zuerst start.command ausführen, um das Projekt einzurichten."
+    read -p "Drücke Enter zum Beenden..."
+    exit 1
+fi
+
+echo "[INFO] Stelle sicher, dass pytest installiert ist..."
+"$VENV_DIR/bin/pip" install pytest --quiet 2>/dev/null || true
+
+echo ""
+echo "[INFO] Führe End-to-End-Tests aus…"
+echo ""
+
+"$VENV_DIR/bin/python" -m pytest tests -v
+
+echo ""
+read -p "Drücke Enter zum Beenden..."
@@ -0,0 +1 @@
+"""Tests für den Tätigkeitsnachweis-Generator."""
@@ -0,0 +1,191 @@
+"""Verify pipeline gates and deployment against temporary local directories."""
+
+import importlib.util
+from pathlib import Path
+import sys
+from unittest.mock import patch, Mock
+import zipfile
+
+import pytest
+
+PIPELINE_DIR = Path(__file__).resolve().parents[2] / "1_build-pipeline"
+sys.path.insert(0, str(PIPELINE_DIR))
+import deploy
+
+spec = importlib.util.spec_from_file_location("build_pipeline", PIPELINE_DIR / "build.py")
+build = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(build)
+
+
+TEMPLATE_NAMES = ["template/A Vorlage.pdf", "template/B Vorlage.PDF"]
+IGNORED_NAMES = ["template/_alt.pdf", "template/.versteckt.pdf", "template/A Vorlage.odg"]
+
+
+@pytest.fixture
+def release(tmp_path):
+    directory = tmp_path / "build"
+    directory.mkdir()
+    for name in deploy.PACKAGE_FILES + TEMPLATE_NAMES:
+        path = directory / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(b"test release payload")
+    deploy.write_release_manifest(directory, "1.3")
+    target = tmp_path / "share"
+    target.mkdir()
+    return directory, target
+
+
+def test_deployment_packages_release_without_work_files(release):
+    directory, target = release
+    for name in IGNORED_NAMES:
+        (directory / name).write_bytes(b"ignored")
+    for folder in ["input", "output"]:
+        (directory / folder).mkdir()
+        (directory / folder / "private.xlsx").write_bytes(b"private")
+    result = deploy.deploy(directory, target)
+    assert result.name == "Tätigkeitsnachweis-Generator v1.3.0.zip"
+    with zipfile.ZipFile(result) as archive:
+        assert set(archive.namelist()) == set(deploy.PACKAGE_FILES + TEMPLATE_NAMES + ["input/", "output/"])
+        assert archive.testzip() is None
+    assert not list(target.glob(".upload-*"))
+    # An unchanged release can be retried without overwriting the published ZIP.
+    original_time = result.stat().st_mtime_ns
+    assert deploy.deploy(directory, target) == result
+    assert result.stat().st_mtime_ns == original_time
+
+
+def test_missing_vpn_target_is_not_created(release):
+    directory, target = release
+    missing = target / "missing-share"
+    with pytest.raises(OSError, match="VPN"):
+        deploy.deploy(directory, missing)
+    assert not missing.exists()
+    assert not list(directory.glob("*.zip"))
+
+
+def test_changed_payload_is_not_deployed(release):
+    directory, target = release
+    (directory / deploy.EXE_NAME).write_bytes(b"different executable")
+    with pytest.raises(ValueError, match="verändert"):
+        deploy.deploy(directory, target)
+    assert not list(target.iterdir())
+
+
+def test_unconfirmed_old_build_is_not_deployed(release):
+    directory, target = release
+    (directory / deploy.MANIFEST_NAME).unlink()
+    with pytest.raises(ValueError, match="bestätigter Build"):
+        deploy.deploy(directory, target)
+
+
+def test_existing_different_release_is_preserved(release):
+    directory, target = release
+    existing = target / "Tätigkeitsnachweis-Generator v1.3.0.zip"
+    existing.write_bytes(b"already published")
+    with pytest.raises(FileExistsError, match="anderem Inhalt"):
+        deploy.deploy(directory, target)
+    assert existing.read_bytes() == b"already published"
+
+
+def test_interrupted_upload_is_not_published(release):
+    directory, target = release
+    with patch.object(deploy.shutil, "copyfile", side_effect=OSError("VPN disconnected")):
+        with pytest.raises(OSError, match="lokale Build bleibt erhalten"):
+            deploy.deploy(directory, target)
+    assert not list(target.iterdir())
+    assert list(directory.glob("*.zip"))
+    assert deploy.validate_release(directory) == "1.3.0"
+
+
+def test_corrupt_upload_is_not_published(release):
+    directory, target = release
+    def corrupt_copy(source, destination):
+        Path(destination).write_bytes(b"corrupted")
+    with patch.object(deploy.shutil, "copyfile", side_effect=corrupt_copy):
+        with pytest.raises(OSError):
+            deploy.deploy(directory, target)
+    assert not list(target.iterdir())
+
+
+@pytest.fixture
+def pipeline(tmp_path, monkeypatch):
+    changelog = tmp_path / "CHANGELOG.md"
+    changelog.write_text("## [1.3]\n\nOriginal release\n", encoding="utf-8")
+    version_file = tmp_path / ".last_version"
+    version_file.write_text("1.3", encoding="utf-8")
+    monkeypatch.setattr(build, "CHANGELOG_PATH", changelog)
+    monkeypatch.setattr(build, "VERSION_FILE", version_file)
+    monkeypatch.setattr(build, "BUILD_OUTPUT_DIR", tmp_path)
+    monkeypatch.setattr(sys, "argv", ["build.py", "--bump", "patch", "--message", "Fix"])
+    events = []
+    names = ["_run_tests", "_ensure_pyinstaller", "_prepare_build_dir", "_run_pyinstaller",
+             "_copy_to_build", "write_release_manifest", "_cleanup", "_print_summary", "deploy"]
+    mocks = {}
+    for name in names:
+        mocks[name] = Mock(side_effect=lambda *args, _name=name: events.append(_name))
+        monkeypatch.setattr(build, name, mocks[name])
+    return changelog, version_file, events, mocks
+
+
+def test_pipeline_tests_build_then_deploy(pipeline):
+    changelog, version_file, events, mocks = pipeline
+    build.main()
+    assert events == ["_run_tests", "_ensure_pyinstaller", "_prepare_build_dir", "_run_pyinstaller",
+                      "_copy_to_build", "write_release_manifest", "_cleanup", "_print_summary", "deploy"]
+    assert version_file.read_text() == "1.3.1"
+    assert "## [1.3.1]" in changelog.read_text(encoding="utf-8")
+
+
+def test_failing_tests_prevent_version_change_build_and_deploy(pipeline):
+    changelog, version_file, events, mocks = pipeline
+    original = changelog.read_bytes()
+    mocks["_run_tests"].side_effect = SystemExit(1)
+    with pytest.raises(SystemExit):
+        build.main()
+    assert changelog.read_bytes() == original
+    assert version_file.read_text() == "1.3"
+    mocks["_run_pyinstaller"].assert_not_called()
+    mocks["deploy"].assert_not_called()
+
+
+def test_build_failure_rolls_back_changelog_and_prevents_deployment(pipeline):
+    changelog, version_file, events, mocks = pipeline
+    original = changelog.read_text(encoding="utf-8")
+    mocks["_run_pyinstaller"].side_effect = SystemExit(1)
+    with pytest.raises(SystemExit):
+        build.main()
+    assert changelog.read_text(encoding="utf-8") == original
+    assert version_file.read_text() == "1.3"
+    mocks["deploy"].assert_not_called()
+    mocks["_cleanup"].assert_called_once()
+
+
+def test_deploy_failure_keeps_successful_build_version(pipeline):
+    changelog, version_file, events, mocks = pipeline
+    mocks["deploy"].side_effect = OSError("VPN unavailable")
+    with pytest.raises(SystemExit):
+        build.main()
+    assert version_file.read_text() == "1.3.1"
+    assert "## [1.3.1]" in changelog.read_text(encoding="utf-8")
+    mocks["write_release_manifest"].assert_called_once()
+
+
+def test_dry_run_does_not_test_build_or_deploy(pipeline, monkeypatch):
+    changelog, version_file, events, mocks = pipeline
+    monkeypatch.setattr(sys, "argv", ["build.py", "--bump", "patch", "--dry-run"])
+    build.main()
+    assert not events
+    assert version_file.read_text() == "1.3"
+
+
+def test_rebuild_preserves_changelog_and_version(pipeline, monkeypatch):
+    changelog, version_file, events, mocks = pipeline
+    original = changelog.read_bytes()
+    monkeypatch.setattr(sys, "argv", ["build.py", "--no-bump", "--no-deploy"])
+    build.main()
+    assert changelog.read_bytes() == original
+    assert version_file.read_text() == "1.3"
+    mocks["write_release_manifest"].assert_called_once_with(build.BUILD_OUTPUT_DIR, "1.3")
+    mocks["_run_tests"].assert_called_once()
+    mocks["_run_pyinstaller"].assert_called_once()
+    mocks["deploy"].assert_not_called()
@@ -0,0 +1,121 @@
+"""End-to-end checks using the fixed 2026 workbook and the PDF template."""
+
+import sys
+from pathlib import Path
+
+import fitz
+import pytest
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.config import load_settings, load_input_schema, load_output_mapping
+from src.parser import parse_input_file, group_by_employee, get_unique_employees
+from src.writer import generate_activity_reports
+
+CONFIG_DIR = PROJECT_ROOT / "config"
+INPUT_FILE = Path(__file__).resolve().parent / "fixture" / "2026 JM.xlsx"
+TEMPLATE_FILE = PROJECT_ROOT / "template" / "06-2026 Tätigkeitsnachweise Stellenförderung.pdf"
+
+
+@pytest.fixture(scope="module")
+def app_config():
+    config = load_settings(CONFIG_DIR, PROJECT_ROOT)
+    config.input_schema = load_input_schema(CONFIG_DIR)
+    config.output_mapping = load_output_mapping(CONFIG_DIR)
+    return config
+
+
+@pytest.fixture(scope="module")
+def parsed_records(app_config):
+    assert INPUT_FILE.is_file(), f"Testdatei nicht gefunden: {INPUT_FILE}"
+    return parse_input_file(
+        filepath=INPUT_FILE,
+        schema=app_config.input_schema,
+        month_sheet_pattern=app_config.month_sheet_pattern,
+        skip_empty_name=app_config.skip_empty_name,
+        skip_empty_antragsnummer=app_config.skip_empty_antragsnummer,
+    )
+
+
+@pytest.fixture
+def output_dir(tmp_path):
+    out = tmp_path / "output"
+    out.mkdir()
+    return out
+
+
+class TestEndToEndFirstPerson:
+    def test_input_file_exists(self):
+        assert INPUT_FILE.is_file(), f"Testdatei nicht gefunden: {INPUT_FILE}"
+
+    def test_template_file_exists(self):
+        assert TEMPLATE_FILE.is_file(), f"PDF-Template nicht gefunden: {TEMPLATE_FILE}"
+
+    def test_template_has_field_markers(self, app_config):
+        with fitz.open(TEMPLATE_FILE) as doc:
+            missing = [
+                mapping.pdf_field
+                for mapping in app_config.output_mapping
+                if mapping.pdf_field is not None
+                and not any(page.search_for(mapping.pdf_field) for page in doc)
+            ]
+        assert not missing, f"Folgende _Field-Platzhalter fehlen im PDF: {missing}"
+
+    def test_parse_real_input(self, parsed_records):
+        # Fixed expectations for tests/fixture/2026 JM.xlsx.
+        assert len(parsed_records) == 100
+        employees = get_unique_employees(parsed_records)
+        assert len(employees) == 17
+        assert employees[0] == "Bardaus, Madalina"
+        first_records = group_by_employee(parsed_records)[employees[0]]
+        assert [record.monat for record in first_records] == [
+            "01.2026", "02.2026", "03.2026", "04.2026", "05.2026"
+        ]
+        for record in first_records:
+            assert record.antragsnummer == "100781516"
+            assert record.funktion == "Psychologin"
+            assert record.stellenanteil == "50"
+            assert record.qualifikation == ""
+            assert record.taetigkeit.startswith("Psychologische Betreuung")
+
+    def test_full_pipeline_first_person(self, app_config, parsed_records, output_dir):
+        grouped = group_by_employee(parsed_records)
+        assert len(grouped) == 17
+        first_person = sorted(grouped)[0]
+        assert first_person == "Bardaus, Madalina"
+        assert len(grouped[first_person]) == 5
+        generated = generate_activity_reports(
+            employee_records={first_person: grouped[first_person]},
+            template_path=TEMPLATE_FILE,
+            mapping=app_config.output_mapping,
+            output_dir=output_dir,
+            filename_pattern=app_config.filename_pattern,
+            fontsize=app_config.fontsize,
+        )
+        assert len(generated) == 1
+        output_file = generated[0]
+        assert output_file.is_file()
+        assert output_file.name == "Bardaus_Madalina_Tätigkeitsnachweis.pdf"
+        with fitz.open(output_file) as doc:
+            assert doc.page_count == 10  # Five months, two pages per month.
+            assert "_Field" not in "".join(page.get_text() for page in doc)
+            # Independently specified month ends include February's 28 days.
+            expected_months = [
+                ("01.2026", "31.01.2026"),
+                ("02.2026", "28.02.2026"),
+                ("03.2026", "31.03.2026"),
+                ("04.2026", "30.04.2026"),
+                ("05.2026", "31.05.2026"),
+            ]
+            for index, (month, month_end) in enumerate(expected_months):
+                data_text = doc[index * 2].get_text()
+                signature_text = doc[index * 2 + 1].get_text()
+                for value in [
+                    "100781516", "Bardaus, Madalina", "50,00", month,
+                    "Psychologin", "Psychologische Betreuung",
+                ]:
+                    assert value in data_text, f"{value!r} fehlt für {month}"
+                assert "100781516" not in signature_text
+                assert "Dresden" in signature_text
+                assert month_end in signature_text
@@ -0,0 +1,192 @@
+"""Exercise the actual PowerShell logic with simulated Windows processes."""
+
+import os
+from pathlib import Path
+import subprocess
+import sys
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import server_lifecycle
+
+
+@unittest.skipUnless(os.name == "nt", "Windows process management")
+class ServerLifecycleTests(unittest.TestCase):
+    def simulate(self, process, listening=True, stop_error=False, confirm=True, frozen=False):
+        captured = {}
+
+        def capture(command, **kwargs):
+            captured.update(script=command[-1], env=kwargs["env"])
+            return subprocess.CompletedProcess(command, 0, "[]", "")
+
+        root = Path(__file__).resolve().parents[2]
+        with patch.object(server_lifecycle.subprocess, "run", side_effect=capture), \
+                patch.object(server_lifecycle.sys, "frozen", frozen, create=True), \
+                patch.object(server_lifecycle.sys, "executable", str(root / "2_build" / "Tätigkeitsnachweis-Generator.exe")), \
+                patch.object(server_lifecycle, "__file__", str(root / "_MEI-test" / "server_lifecycle.py") if frozen else server_lifecycle.__file__):
+            server_lifecycle.stop_existing_server()
+
+        setup = r'''
+$script:occupied = LISTENING
+function Get-NetTCPConnection {
+    param($State, $ErrorAction)
+    if ($script:occupied) { [pscustomobject]@{ LocalPort=8501; OwningProcess=12345 } }
+}
+function Get-CimInstance {
+    param($ClassName, $Filter)
+    PROCESS
+}
+function Stop-Process {
+    param($Id, [switch]$Force, $ErrorAction)
+    [Console]::Error.WriteLine('STOP_CALLED')
+    STOP
+    $script:occupied = $false
+}
+'''.replace("LISTENING", "$true" if listening else "$false")
+        setup = setup.replace("PROCESS", process).replace(
+            "\n    STOP\n", "\n    throw 'simulated access denied'\n" if stop_error else "\n")
+        confirm_mock = """
+function Confirm-ServerRestart {
+    [Console]::Error.WriteLine('CONFIRM_CALLED')
+    return ANSWER
+}
+""".replace("ANSWER", "$true" if confirm else "$false")
+        script = captured["script"].replace(server_lifecycle._CONFIRM_SCRIPT, confirm_mock)
+        command = [
+            "powershell.exe", "-NoProfile", "-NonInteractive", "-Command",
+            setup + script,
+        ]
+        # Explicit pipes keep both outputs available independently of pytest's
+        # own console capture. communicate() drains both pipes concurrently.
+        with subprocess.Popen(
+            command, env=captured["env"], stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE, text=True, errors="replace",
+        ) as child:
+            try:
+                stdout, stderr = child.communicate(timeout=30)
+            except subprocess.TimeoutExpired:
+                child.kill()
+                child.communicate()
+                raise
+            self.assertIsInstance(stdout, str, "stdout wurde nicht erfasst")
+            self.assertIsInstance(stderr, str, "stderr wurde nicht erfasst")
+            return subprocess.CompletedProcess(command, child.returncode, stdout, stderr)
+
+    def test_free_port(self):
+        result = self.simulate("throw 'should not inspect a process'", listening=False)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), "[]")
+        self.assertNotIn("CONFIRM_CALLED", result.stderr)
+
+    def test_previous_exe_is_stopped(self):
+        result = self.simulate(
+            "[pscustomobject]@{ Name='Tätigkeitsnachweis-Generator.exe'; CommandLine=''; ExecutablePath='' }")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), "[12345]")
+        self.assertIn("CONFIRM_CALLED", result.stderr)
+        self.assertIn("STOP_CALLED", result.stderr)
+
+    def test_declining_preserves_previous_instance(self):
+        result = self.simulate(
+            "[pscustomobject]@{ Name='Tätigkeitsnachweis-Generator.exe'; CommandLine=''; ExecutablePath='' }",
+            confirm=False)
+        self.assertEqual(result.returncode, 2, result.stderr)
+        self.assertIn("CONFIRM_CALLED", result.stderr)
+        self.assertNotIn("STOP_CALLED", result.stderr)
+
+    def test_declining_returns_false_to_launcher(self):
+        with patch.object(server_lifecycle.subprocess, "run", return_value=
+                          subprocess.CompletedProcess([], 2, "", "")):
+            self.assertFalse(server_lifecycle.stop_existing_server())
+
+    def test_development_absolute_path_is_stopped(self):
+        result = self.simulate(r'''[pscustomobject]@{
+            Name='python.exe'; ExecutablePath='C:\Python\python.exe';
+            CommandLine=('python -m streamlit run "' + $env:APP_RESTART_PATH + '"')
+        }''')
+        self.assertEqual(result.returncode, 0, result.stderr)
+
+    def test_legacy_development_start_is_stopped(self):
+        result = self.simulate(r'''[pscustomobject]@{
+            Name='python.exe'; CommandLine='streamlit.exe run app.py';
+            ExecutablePath=($env:APP_RESTART_VENV + '\python.exe')
+        }''')
+        self.assertEqual(result.returncode, 0, result.stderr)
+
+    def test_versioned_python_prompts_before_stopping(self):
+        # Windows Store Python reports the real interpreter name even when
+        # launched through the venv's python.exe.
+        process = r'''[pscustomobject]@{
+            Name='python3.13.exe';
+            ExecutablePath='C:\Program Files\WindowsApps\Python\python3.13.exe';
+            CommandLine=('".venv\Scripts\python.exe" -m streamlit run "' +
+                $env:APP_RESTART_PATH + '" --server.port=8501 --server.address=localhost')
+        }'''
+        with self.subTest(answer="yes"):
+            result = self.simulate(process, confirm=True)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            self.assertIn("CONFIRM_CALLED", result.stderr)
+            self.assertIn("STOP_CALLED", result.stderr)
+        with self.subTest(answer="no"):
+            result = self.simulate(process, confirm=False)
+            self.assertEqual(result.returncode, 2, result.stderr)
+            self.assertIn("CONFIRM_CALLED", result.stderr)
+            self.assertNotIn("STOP_CALLED", result.stderr)
+
+    def test_unrelated_versioned_python_is_preserved(self):
+        result = self.simulate(r'''[pscustomobject]@{
+            Name='python3.13.exe'; ExecutablePath='C:\Python\python3.13.exe';
+            CommandLine='python -m streamlit run "C:\other-project\app.py"'
+        }''')
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("PID 12345", result.stderr)
+        self.assertNotIn("CONFIRM_CALLED", result.stderr)
+        self.assertNotIn("STOP_CALLED", result.stderr)
+
+    def test_exe_recognizes_sibling_development_server(self):
+        process = r'''[pscustomobject]@{
+            Name='python3.13.exe'; ExecutablePath='C:\Python\python3.13.exe';
+            CommandLine=('".venv\Scripts\python.exe" -m streamlit run "' +
+                (($env:APP_RESTART_PATHS | ConvertFrom-Json)[1]) +
+                '" --server.port=8501 --server.address=localhost')
+        }'''
+        for answer, expected_code in [(True, 0), (False, 2)]:
+            with self.subTest(confirm=answer):
+                result = self.simulate(process, frozen=True, confirm=answer)
+                self.assertEqual(result.returncode, expected_code, result.stderr)
+                self.assertIn("CONFIRM_CALLED", result.stderr)
+                if answer:
+                    self.assertIn("STOP_CALLED", result.stderr)
+                else:
+                    self.assertNotIn("STOP_CALLED", result.stderr)
+
+    def test_exe_preserves_unrelated_development_server(self):
+        result = self.simulate(r'''[pscustomobject]@{
+            Name='python3.13.exe'; ExecutablePath='C:\Python\python3.13.exe';
+            CommandLine='python -m streamlit run "C:\other-project\app.py"'
+        }''', frozen=True)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertNotIn("CONFIRM_CALLED", result.stderr)
+        self.assertNotIn("STOP_CALLED", result.stderr)
+
+    def test_unrelated_server_is_preserved(self):
+        result = self.simulate(r'''[pscustomobject]@{
+            Name='python.exe'; CommandLine='streamlit run app.py';
+            ExecutablePath='C:\other-project\.venv\Scripts\python.exe'
+        }''')
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("PID 12345", result.stderr)
+        self.assertNotIn("STOP_CALLED", result.stderr)
+        self.assertNotIn("CONFIRM_CALLED", result.stderr)
+
+    def test_stop_failure_aborts_start(self):
+        result = self.simulate(
+            "[pscustomobject]@{ Name='Tätigkeitsnachweis-Generator.exe'; CommandLine=''; ExecutablePath='' }",
+            stop_error=True)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("simulated access denied", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,121 @@
+"""Tests für das Einrichten einer neuen Version neben der aktuellen Installation."""
+
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+import zipfile
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import update_installer
+from update_installer import EXE_NAME, UpdateError, install_update
+
+
+class InstallUpdateTests(unittest.TestCase):
+    def setUp(self):
+        self._temporary = tempfile.TemporaryDirectory()
+        self.root = Path(self._temporary.name).resolve()
+        self.current = self.root / "Tätigkeitsnachweis-Generator v1.3.3"
+        for folder in ["input", "output/2026", "config", "template"]:
+            (self.current / folder).mkdir(parents=True)
+        (self.current / EXE_NAME).write_bytes(b"old")
+        (self.current / "input" / "daten.xlsx").write_bytes(b"input")
+        (self.current / "output" / "2026" / "nachweis.pdf").write_bytes(b"output")
+        (self.current / "config" / "settings.ini").write_bytes(b"[a]\nx=1\n")
+        (self.current / "template" / "vorlage.pdf").write_bytes(b"old template")
+        (self.current / "template" / "eigene.pdf").write_bytes(b"own template")
+        self.share = self.root / "share"
+        self.share.mkdir()
+
+    def tearDown(self):
+        self._temporary.cleanup()
+
+    def make_zip(self, files=None, version="1.4.0"):
+        files = files if files is not None else {
+            EXE_NAME: b"new",
+            "config/settings.ini": b"[a]\nx=1\n",
+            "template/vorlage.pdf": b"new template",
+            "input/": b"", "output/": b"",
+        }
+        path = self.share / f"Tätigkeitsnachweis-Generator v{version}.zip"
+        with zipfile.ZipFile(path, "w") as package:
+            for name, content in files.items():
+                package.writestr(name, content)
+        return path
+
+    def test_installs_next_to_current_and_copies_user_data(self):
+        result = install_update(self.make_zip(), self.current)
+        target = self.root / "Tätigkeitsnachweis-Generator v1.4.0"
+        self.assertEqual(result.target_dir, target)
+        self.assertFalse(result.already_installed)
+        self.assertIsNone(result.previous_settings)
+        self.assertEqual((target / EXE_NAME).read_bytes(), b"new")
+        self.assertEqual((target / "input" / "daten.xlsx").read_bytes(), b"input")
+        self.assertEqual((target / "output" / "2026" / "nachweis.pdf").read_bytes(), b"output")
+        self.assertEqual((target / "template" / "vorlage.pdf").read_bytes(), b"new template")
+        self.assertEqual((target / "template" / "eigene.pdf").read_bytes(), b"own template")
+        # Die alte Installation bleibt unverändert.
+        self.assertEqual((self.current / EXE_NAME).read_bytes(), b"old")
+        self.assertEqual([p.name for p in self.root.iterdir() if p.name.startswith(".")], [])
+
+    def test_keeps_changed_settings_next_to_new_ones(self):
+        (self.current / "config" / "settings.ini").write_text("[a]\nx=2\n", encoding="utf-8")
+        result = install_update(self.make_zip(), self.current)
+        config = result.target_dir / "config"
+        self.assertEqual((config / "settings.ini").read_text(encoding="utf-8"), "[a]\nx=1\n")
+        self.assertEqual(result.previous_settings, config / "settings.vorherige-version.ini")
+        self.assertEqual(result.previous_settings.read_text(encoding="utf-8"), "[a]\nx=2\n")
+
+    def test_existing_installation_is_only_reused(self):
+        zip_path = self.make_zip()
+        install_update(zip_path, self.current)
+        result = install_update(zip_path, self.current)
+        self.assertTrue(result.already_installed)
+
+    def test_rejects_package_without_exe(self):
+        with self.assertRaisesRegex(UpdateError, "keine"):
+            install_update(self.make_zip({"README.md": b"x"}), self.current)
+        self.assertFalse((self.root / "Tätigkeitsnachweis-Generator v1.4.0").exists())
+
+    def test_rejects_path_traversal(self):
+        with self.assertRaisesRegex(UpdateError, "ungültigen Pfad"):
+            install_update(self.make_zip({EXE_NAME: b"x", "../evil.txt": b"x"}), self.current)
+        self.assertFalse((self.root / "evil.txt").exists())
+
+    def test_rejects_broken_zip_and_cleans_up(self):
+        broken = self.share / "Tätigkeitsnachweis-Generator v1.4.0.zip"
+        broken.write_bytes(b"no zip")
+        with self.assertRaisesRegex(UpdateError, "keine gültige ZIP"):
+            install_update(broken, self.current)
+        self.assertEqual(sorted(p.name for p in self.root.iterdir()), sorted([self.current.name, "share"]))
+
+    def test_unreachable_share_gives_vpn_hint(self):
+        with self.assertRaisesRegex(UpdateError, "VPN"):
+            install_update(self.share / "Tätigkeitsnachweis-Generator v1.4.0.zip", self.current)
+
+    def test_refuses_existing_folder_without_program(self):
+        (self.root / "Tätigkeitsnachweis-Generator v1.4.0").mkdir()
+        with self.assertRaisesRegex(UpdateError, "existiert bereits"):
+            install_update(self.make_zip(), self.current)
+
+
+class StartApplicationTests(unittest.TestCase):
+    @unittest.skipUnless(sys.platform == "win32", "Windows-Prozessflags")
+    def test_starts_new_exe_with_clean_bundle_environment(self):
+        target = Path("C:/neu")
+        environment = {"PATH": "x", "APP_BASE_DIR": "alt", "_MEIPASS2": "alt",
+                       "_PYI_APPLICATION_HOME_DIR": "alt", "STREAMLIT_SERVER_PORT": "8501"}
+        with patch.dict(update_installer.os.environ, environment, clear=True), \
+                patch.object(update_installer.subprocess, "Popen") as popen:
+            update_installer.start_application(target)
+        args, kwargs = popen.call_args
+        self.assertEqual(args[0], [str(target / EXE_NAME)])
+        self.assertEqual(kwargs["cwd"], target)
+        self.assertEqual(kwargs["env"], {"PATH": "x", "PYINSTALLER_RESET_ENVIRONMENT": "1"})
+        self.assertTrue(kwargs["creationflags"] & subprocess.CREATE_NEW_CONSOLE)
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,137 @@
+"""Richtet eine neue Programmversion neben der aktuellen Installation ein.
+
+Ablauf von "Anwendung ersetzen":
+1. ZIP vom SMB-Laufwerk lokal zwischenspeichern und prüfen.
+2. In einen Zwischenordner neben der aktuellen Installation entpacken.
+3. input/ und output/ sowie eigene Template-PDFs übernehmen.
+4. Zwischenordner in "Tätigkeitsnachweis-Generator vX.Y.Z" umbenennen.
+5. Neue EXE starten; sie beendet die alte Instanz nach Rückfrage selbst.
+
+Die alte Installation bleibt unverändert als Rückfallebene erhalten.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+
+EXE_NAME = "Tätigkeitsnachweis-Generator.exe"
+USER_DATA_DIRS = ("input", "output")
+SETTINGS_FILE = Path("config") / "settings.ini"
+
+
+class UpdateError(Exception):
+    """Fehler mit einer Meldung, die direkt angezeigt werden kann."""
+
+
+@dataclass
+class UpdateResult:
+    target_dir: Path
+    already_installed: bool = False
+    previous_settings: Path | None = None
+
+
+def can_replace_application() -> bool:
+    """Nur die gebaute Windows-EXE kann sich selbst ersetzen."""
+    return sys.platform == "win32" and bool(getattr(sys, "frozen", False))
+
+
+def _check_members(package: zipfile.ZipFile) -> None:
+    names = package.namelist()
+    for name in names:
+        path = PurePosixPath(name.replace("\\", "/"))
+        if path.is_absolute() or ".." in path.parts or ":" in name:
+            raise UpdateError(f"Das Update-Paket enthält einen ungültigen Pfad: {name}")
+    if EXE_NAME not in names:
+        raise UpdateError(f"Das Update-Paket enthält keine {EXE_NAME}.")
+    if package.testzip() is not None:
+        raise UpdateError("Das Update-Paket ist beschädigt. Bitte später erneut versuchen.")
+
+
+def _copy_user_data(current_dir: Path, staging_dir: Path) -> None:
+    for folder in USER_DATA_DIRS:
+        source = current_dir / folder
+        if source.is_dir():
+            shutil.copytree(source, staging_dir / folder, dirs_exist_ok=True)
+    # Eigene Templates übernehmen, ohne die mitgelieferten zu überschreiben.
+    templates = current_dir / "template"
+    if templates.is_dir():
+        (staging_dir / "template").mkdir(exist_ok=True)
+        for path in templates.iterdir():
+            destination = staging_dir / "template" / path.name
+            if path.is_file() and not destination.exists():
+                shutil.copy2(path, destination)
+
+
+def _keep_previous_settings(current_dir: Path, staging_dir: Path) -> Path | None:
+    """Neue settings.ini gilt; abweichende alte Einstellungen bleiben daneben erhalten."""
+    old, new = current_dir / SETTINGS_FILE, staging_dir / SETTINGS_FILE
+    if not old.is_file() or (new.is_file() and old.read_bytes() == new.read_bytes()):
+        return None
+    new.parent.mkdir(parents=True, exist_ok=True)
+    backup = new.with_name("settings.vorherige-version.ini")
+    shutil.copy2(old, backup)
+    return backup
+
+
+def install_update(zip_path: Path, current_dir: Path) -> UpdateResult:
+    """Entpackt zip_path neben current_dir und übernimmt die Nutzerdaten."""
+    current_dir = current_dir.resolve()
+    target_dir = current_dir.parent / zip_path.stem
+    if target_dir == current_dir:
+        raise UpdateError("Diese Version ist bereits die laufende Installation.")
+    if (target_dir / EXE_NAME).is_file():
+        return UpdateResult(target_dir, already_installed=True)
+    if target_dir.exists():
+        raise UpdateError(
+            f"Der Ordner {target_dir} existiert bereits, enthält aber kein Programm. "
+            "Bitte den Ordner entfernen oder umbenennen und erneut versuchen.")
+
+    staging_dir = current_dir.parent / f".{zip_path.stem}.update"
+    try:
+        shutil.rmtree(staging_dir, ignore_errors=True)
+        with tempfile.TemporaryDirectory(prefix="taetigkeitsnachweis-update-") as temporary:
+            # Erst lokal kopieren: ein VPN-Abbruch trifft so nur die Kopie.
+            local_zip = Path(temporary) / zip_path.name
+            try:
+                shutil.copyfile(zip_path, local_zip)
+            except OSError as exc:
+                raise UpdateError(
+                    "Das Update konnte nicht vom Netzlaufwerk geladen werden. "
+                    "Bitte VPN-Verbindung und Laufwerk J: prüfen.") from exc
+            try:
+                with zipfile.ZipFile(local_zip) as package:
+                    _check_members(package)
+                    package.extractall(staging_dir)
+            except zipfile.BadZipFile as exc:
+                raise UpdateError("Das Update-Paket ist keine gültige ZIP-Datei.") from exc
+        _copy_user_data(current_dir, staging_dir)
+        previous_settings = _keep_previous_settings(current_dir, staging_dir)
+        staging_dir.rename(target_dir)
+    except UpdateError:
+        shutil.rmtree(staging_dir, ignore_errors=True)
+        raise
+    except OSError as exc:
+        shutil.rmtree(staging_dir, ignore_errors=True)
+        raise UpdateError(
+            f"Die neue Version konnte nicht eingerichtet werden ({exc}). "
+            f"Bitte Schreibrechte für {current_dir.parent} prüfen.") from exc
+    if previous_settings is not None:
+        previous_settings = target_dir / SETTINGS_FILE.parent / previous_settings.name
+    return UpdateResult(target_dir, previous_settings=previous_settings)
+
+
+def start_application(target_dir: Path) -> None:
+    """Startet die neue EXE in einem eigenen Konsolenfenster wie per Doppelklick."""
+    env = {key: value for key, value in os.environ.items()
+           if key != "APP_BASE_DIR" and not key.startswith(("STREAMLIT_", "_MEIPASS", "_PYI_"))}
+    # Sonst übernimmt die neue EXE Pfade aus dem Bundle der laufenden alten EXE.
+    env["PYINSTALLER_RESET_ENVIRONMENT"] = "1"
+    subprocess.Popen(
+        [str(target_dir / EXE_NAME)], cwd=target_dir, env=env, close_fds=True,
+        creationflags=subprocess.CREATE_NEW_CONSOLE | subprocess.CREATE_NEW_PROCESS_GROUP,
+    )
@@ -0,0 +1,49 @@
+"""Prüft auf neuere Programmversionen im zentralen SMB-Verzeichnis."""
+
+import re
+from pathlib import Path
+
+UPDATE_DIR = Path(r"j:\Fachbereiche\BO\Produktionsschule\Maßnahmeunterlagen\20_Personal\05_Tätigkeitsnachweise ESF\Nachweise-automatisiert-generieren")
+VERSION_PATTERN = re.compile(r"Tätigkeitsnachweis-Generator v(\d+)\.(\d+)\.(\d+)(?:\.\d+)?\.(zip|exe)$", re.IGNORECASE)
+CHANGELOG_PATTERN = re.compile(r"^## \[(\d+)\.(\d+)(?:\.(\d+))?\]", re.MULTILINE)
+
+
+def get_latest_version():
+    match = CHANGELOG_PATTERN.search(Path(__file__).with_name("CHANGELOG.md").read_text(encoding="utf-8"))
+    current = tuple(int(part or 0) for part in match.groups()) if match else (0, 0, 0)
+    try:
+        available = UPDATE_DIR.exists()
+    except OSError:
+        available = False
+    if not available:
+        return current, None
+    newer = []
+    try:
+        paths = UPDATE_DIR.iterdir()
+        for path in paths:
+            found = VERSION_PATTERN.fullmatch(path.name)
+            if found:
+                version = tuple(int(found.group(i)) for i in range(1, 4))
+                if version > current:
+                    newer.append((version, path))
+    except OSError:
+        return current, None
+    if newer:
+        return current, max(newer)
+    return current, None
+
+
+def main() -> int:
+    current, latest = get_latest_version()
+    print(f"[INFO] Lokale Version: v{'.'.join(map(str, current))}")
+    if latest:
+        version, path = latest
+        print(f"[HINWEIS] Neuere Version verfügbar: v{'.'.join(map(str, version))}")
+        print(f"[HINWEIS] Datei: {path}")
+    else:
+        print("[INFO] Keine neuere Version gefunden oder Update-Verzeichnis nicht erreichbar.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -0,0 +1 @@
+1.4
@@ -0,0 +1,47 @@
+@echo off
+chcp 65001 >nul
+setlocal enabledelayedexpansion
+set "PYTHONUTF8=1"
+
+cd /d "%~dp0"
+cd ..
+
+echo ============================================================
+echo   Tätigkeitsnachweis-Generator – Build-Pipeline
+echo ============================================================
+echo.
+
+REM ── Virtuelle Umgebung aktivieren ────────────────────────────
+if exist "0_application\.venv\Scripts\python.exe" (
+    set PYTHON=0_application\.venv\Scripts\python.exe
+    echo [OK] Virtuelle Umgebung gefunden
+) else if exist ".venv\Scripts\python.exe" (
+    set PYTHON=.venv\Scripts\python.exe
+    echo [OK] Virtuelle Umgebung gefunden
+) else (
+    echo [WARN] Keine virtuelle Umgebung gefunden, nutze System-Python
+    set PYTHON=python
+)
+
+echo.
+
+REM ── Parameter durchreichen ──────────────────────────────────
+set ARGS=%*
+if "%ARGS%"=="" (
+    echo Starte interaktiven Build …
+    echo.
+)
+
+REM ── Build ausführen ─────────────────────────────────────────
+%PYTHON% "1_build-pipeline\build.py" %ARGS%
+
+if errorlevel 1 (
+    echo.
+    echo [FEHLER] Pipeline fehlgeschlagen. Details stehen oben.
+    pause
+    exit /b 1
+)
+
+echo.
+echo Tests, Build und Deployment abgeschlossen.
+pause
@@ -0,0 +1,457 @@
+"""Build-Orchestrierung mit Semantic Versioning.
+
+Liest die aktuelle Version aus CHANGELOG.md, bump't sie gemäß
+Benutzereingabe (major/minor/patch), aktualisiert das Changelog
+führt zuerst alle Tests aus, baut via PyInstaller eine standalone .exe
+nach 2_build/ und stellt sie anschließend als ZIP auf dem SMB-Laufwerk bereit.
+
+Verwendung:
+    python build.py                  # interaktiver Modus
+    python build.py --bump minor     # nicht-interaktiv
+    python build.py --bump patch --message "Hotfix: PDF-Schriftgröße korrigiert"
+"""
+
+import argparse
+import os
+import re
+import shutil
+import subprocess
+import sys
+from datetime import date
+from pathlib import Path
+from typing import Optional
+
+from deploy import deploy, is_template_pdf, write_release_manifest
+
+# ── Pfade ───────────────────────────────────────────────────────
+BUILD_PIPELINE_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = BUILD_PIPELINE_DIR.parent
+APP_DIR = PROJECT_ROOT / "0_application"
+BUILD_OUTPUT_DIR = PROJECT_ROOT / "2_build"
+CHANGELOG_PATH = APP_DIR / "CHANGELOG.md"
+SPEC_PATH = BUILD_PIPELINE_DIR / "build.spec"
+VERSION_FILE = BUILD_PIPELINE_DIR / ".last_version"
+
+# ── Versions-Helfer ─────────────────────────────────────────────
+
+def _read_changelog() -> str:
+    """Liest das gesamte CHANGELOG.md."""
+    if not CHANGELOG_PATH.exists():
+        return ""
+    return CHANGELOG_PATH.read_text(encoding="utf-8")
+
+
+def _write_changelog(content: str) -> None:
+    """Schreibt CHANGELOG.md."""
+    CHANGELOG_PATH.write_text(content, encoding="utf-8")
+
+
+def get_current_version() -> Optional[str]:
+    """Ermittelt die aktuellste Version aus CHANGELOG.md.
+
+    Sucht nach dem ersten Vorkommen von '## [X.Y.Z]' oder '## [X.Y]'.
+    """
+    content = _read_changelog()
+    if not content:
+        return None
+    match = re.search(r"##\s*\[(\d+\.\d+(?:\.\d+)?)\]", content)
+    return match.group(1) if match else None
+
+
+def bump_version(current: str, bump_type: str) -> str:
+    """Erhöht eine Semantic-Version.
+
+    Args:
+        current: Aktuelle Version (z.B. '1.1' oder '1.1.0')
+        bump_type: 'major', 'minor' oder 'patch'
+
+    Returns:
+        Neue Version als String.
+    """
+    parts = current.split(".")
+    # Normalisiere auf 3 Teile (MAJOR.MINOR.PATCH)
+    while len(parts) < 3:
+        parts.append("0")
+    major, minor, patch = map(int, parts[:3])
+
+    if bump_type == "major":
+        major += 1
+        minor = 0
+        patch = 0
+    elif bump_type == "minor":
+        minor += 1
+        patch = 0
+    elif bump_type == "patch":
+        patch += 1
+    else:
+        raise ValueError(f"Unbekannter Bump-Typ: {bump_type}")
+
+    # Gib kurzes Format zurück wenn Patch=0
+    if patch == 0:
+        return f"{major}.{minor}"
+    return f"{major}.{minor}.{patch}"
+
+
+def update_changelog(
+    new_version: str,
+    bump_type: str,
+    message: Optional[str] = None,
+) -> None:
+    """Fügt einen neuen Versionseintrag am Anfang des Changelogs ein.
+
+    Args:
+        new_version: Die neue Version (z.B. '1.2')
+        bump_type: Art des Bumps (für die Sektions-Vorlage)
+        message: Optionale Beschreibung der Änderungen.
+    """
+    today = date.today().isoformat()
+    old_content = _read_changelog()
+
+    # Sektionen-Vorlage je nach Bump-Typ
+    sections = _build_sections(bump_type, message)
+
+    header = (
+        f"## [{new_version}] – {today}\n\n"
+        f"{sections}\n"
+        f"---\n\n"
+    )
+
+    # Nach dem ersten '---' einfügen (nach dem Dateikopf von Keep a Changelog)
+    # oder einfach am Anfang nach der ersten Zeile
+    lines = old_content.splitlines(keepends=True)
+
+    # Finde die erste Version-Header-Zeile (## [X.Y...)
+    insert_idx = None
+    for i, line in enumerate(lines):
+        if re.match(r"##\s*\[\d+\.\d+", line):
+            insert_idx = i
+            break
+
+    if insert_idx is not None:
+        new_content = "".join(lines[:insert_idx]) + header + "".join(lines[insert_idx:])
+    else:
+        # Fallback: nach dem Dateikopf (nach dem ersten '---')
+        for i, line in enumerate(lines):
+            if line.strip() == "---":
+                insert_idx = i + 1
+                break
+        if insert_idx is not None:
+            new_content = "".join(lines[:insert_idx]) + "\n" + header + "".join(lines[insert_idx:])
+        else:
+            new_content = old_content + "\n" + header
+
+    _write_changelog(new_content)
+    print(f"  ✓ CHANGELOG.md aktualisiert → [{new_version}]")
+
+
+def _wait_for_changelog_edit() -> None:
+    """Gibt dem Benutzer Zeit, den neuen Changelog-Eintrag zu bearbeiten.
+
+    Der Build liest CHANGELOG.md erst nach dieser Pause; Änderungen in der
+    Datei fließen also in den Build ein.
+    """
+    print(f"\n✏️  Bitte den neuen Eintrag jetzt bearbeiten und speichern:\n   {CHANGELOG_PATH}")
+    try:
+        input("   Danach Enter drücken, um den Build fortzusetzen (Strg+C bricht ab) … ")
+    except (EOFError, KeyboardInterrupt):
+        print("\nAbgebrochen.")
+        raise KeyboardInterrupt
+
+
+def _build_sections(bump_type: str, message: Optional[str]) -> str:
+    """Baut die Sektionen für den Changelog-Eintrag."""
+    if message:
+        if bump_type == "major":
+            return f"### Hinzugefügt\n\n- {message}\n"
+        elif bump_type == "minor":
+            return f"### Hinzugefügt\n\n- {message}\n"
+        else:
+            return f"### Behoben\n\n- {message}\n"
+
+    # Standard-Vorlagen
+    if bump_type == "major":
+        return (
+            "### Hinzugefügt\n\n"
+            "- \n\n"
+            "### Geändert\n\n"
+            "- \n\n"
+            "### Entfernt\n\n"
+            "- \n"
+        )
+    elif bump_type == "minor":
+        return (
+            "### Hinzugefügt\n\n"
+            "- \n\n"
+            "### Geändert\n\n"
+            "- \n"
+        )
+    else:
+        return (
+            "### Behoben\n\n"
+            "- \n"
+        )
+
+
+# ── Build ───────────────────────────────────────────────────────
+
+def _run_tests() -> None:
+    """Test with the same interpreter used to build the application."""
+    try:
+        import pytest  # noqa: F401
+    except ImportError:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "pytest"])
+    print("\n[INFO] Führe alle Tests aus ...", flush=True)
+    result = subprocess.run(
+        [sys.executable, "-m", "pytest", str(APP_DIR / "tests"), "-v", "-p", "no:cacheprovider"],
+        cwd=str(PROJECT_ROOT),
+    )
+    if result.returncode != 0:
+        print("[FEHLER] Tests fehlgeschlagen. Kein Build und kein Deployment.")
+        raise SystemExit(1)
+
+def _ensure_pyinstaller() -> None:
+    """Stellt sicher, dass PyInstaller installiert ist."""
+    try:
+        import PyInstaller  # noqa: F401
+    except ImportError:
+        print("⚙ PyInstaller wird installiert …")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "pyinstaller"])
+        print("  ✓ PyInstaller installiert")
+
+
+def _prepare_build_dir() -> None:
+    """Bereitet das 2_build/-Verzeichnis vor."""
+    BUILD_OUTPUT_DIR.mkdir(exist_ok=True)
+
+    # Erstelle/aktualisiere Unterordner
+    for folder in ["input", "output", "template", "config"]:
+        target = BUILD_OUTPUT_DIR / folder
+        target.mkdir(exist_ok=True)
+
+    # Liefere die zum aktuellen Quellstand gehörende Konfiguration aus.
+    config_src = APP_DIR / "config"
+    config_dst = BUILD_OUTPUT_DIR / "config"
+    if config_src.exists():
+        for f in config_src.iterdir():
+            if f.is_file():
+                shutil.copy2(f, config_dst / f.name)
+
+    shutil.copy2(CHANGELOG_PATH, BUILD_OUTPUT_DIR / "CHANGELOG.md")
+
+    # Alle Template-PDFs ausliefern (ohne Dateien mit '_' oder '.' am Anfang).
+    # Veraltete PDFs aus früheren Builds werden entfernt.
+    tpl_src = APP_DIR / "template"
+    tpl_dst = BUILD_OUTPUT_DIR / "template"
+    wanted = {p.name for p in tpl_src.iterdir() if is_template_pdf(p)}
+    for old_pdf in tpl_dst.iterdir():
+        if is_template_pdf(old_pdf) and old_pdf.name not in wanted:
+            old_pdf.unlink()
+    for name in sorted(wanted):
+        shutil.copy2(tpl_src / name, tpl_dst / name)
+
+    # README für input-Ordner
+    input_readme = BUILD_OUTPUT_DIR / "input" / "_DATEIEN_HIER_ABLEGEN_.txt"
+    if not input_readme.exists():
+        input_readme.write_text(
+            "Excel-Dateien (.xlsx) in diesen Ordner legen.\n"
+            "Die App erkennt sie automatisch.\n",
+            encoding="utf-8",
+        )
+
+    # README für template-Ordner
+    tpl_readme = BUILD_OUTPUT_DIR / "template" / "_DATEIEN_HIER_ABLEGEN_.txt"
+    if not tpl_readme.exists():
+        tpl_readme.write_text(
+            "PDF-Templates (.pdf) mit _Field-Platzhaltern in diesen Ordner legen.\n"
+            "Die App erkennt sie automatisch.\n",
+            encoding="utf-8",
+        )
+
+    # README.md aus 0_application/ kopieren
+    readme_src = APP_DIR / "README.md"
+    if readme_src.exists():
+        shutil.copy2(readme_src, BUILD_OUTPUT_DIR / "README.md")
+        print("  ✓ README.md nach 2_build/ kopiert")
+
+    print(f"  ✓ 2_build/ vorbereitet")
+
+
+def _run_pyinstaller() -> Path:
+    """Führt PyInstaller mit der Spec-Datei aus.
+
+    Returns:
+        Pfad zur erstellten .exe.
+    """
+    print("\n🔨 PyInstaller baut .exe …")
+    print("   (Dies kann einige Minuten dauern)\n")
+
+    result = subprocess.run(
+        [
+            sys.executable, "-m", "PyInstaller",
+            str(SPEC_PATH),
+            "--distpath", str(BUILD_PIPELINE_DIR / "dist"),
+            "--workpath", str(BUILD_PIPELINE_DIR / "build_temp"),
+            "--noconfirm",
+            "--clean",
+        ],
+        cwd=str(PROJECT_ROOT),
+        capture_output=False,
+    )
+
+    if result.returncode != 0:
+        print("\n❌ PyInstaller-Build fehlgeschlagen!")
+        sys.exit(1)
+
+    exe_path = BUILD_PIPELINE_DIR / "dist" / "Tätigkeitsnachweis-Generator.exe"
+    if not exe_path.exists():
+        print(f"\n❌ .exe nicht gefunden: {exe_path}")
+        sys.exit(1)
+
+    print(f"  ✓ .exe erstellt: {exe_path.name}")
+    return exe_path
+
+
+def _copy_to_build(exe_path: Path) -> Path:
+    """Kopiert die .exe nach 2_build/."""
+    dest = BUILD_OUTPUT_DIR / exe_path.name
+    shutil.copy2(exe_path, dest)
+    print(f"  ✓ .exe nach 2_build/ kopiert")
+    return dest
+
+
+def _cleanup() -> None:
+    """Räumt temporäre Build-Artefakte auf."""
+    for d in ["dist", "build_temp"]:
+        path = BUILD_PIPELINE_DIR / d
+        if path.exists():
+            shutil.rmtree(path, ignore_errors=True)
+    print("  ✓ Temporäre Dateien entfernt")
+
+
+def _save_version(version: str) -> None:
+    """Speichert die Version für spätere Referenz."""
+    VERSION_FILE.write_text(version)
+
+
+def _print_summary(version: str, exe_path: Path) -> None:
+    """Gibt eine Build-Zusammenfassung aus."""
+    print(f"\n{'='*60}")
+    print(f"  ✅ Build {version} erfolgreich!")
+    print(f"  📂 {exe_path}")
+    print(f"{'='*60}\n")
+    print("Auslieferungs-Struktur (2_build/):")
+    print("  ├── Tätigkeitsnachweis-Generator.exe")
+    print("  ├── config/       ← Konfiguration (editierbar)")
+    print("  ├── input/        ← Excel-Dateien hier ablegen")
+    print("  ├── template/     ← PDF-Templates hier ablegen")
+    print("  └── output/       ← Generierte PDFs erscheinen hier")
+
+
+# ── CLI ─────────────────────────────────────────────────────────
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Build mit Semantic Versioning",
+    )
+    version_options = parser.add_mutually_exclusive_group()
+    version_options.add_argument(
+        "--bump",
+        choices=["major", "minor", "patch"],
+        help="Version bump-Typ (ohne Angabe: interaktiv)",
+    )
+    version_options.add_argument("--no-bump", action="store_true",
+                                 help="Aktuelle Version erneut bauen; Changelog unverändert übernehmen")
+    parser.add_argument("--no-deploy", action="store_true",
+                        help="Nur lokal bauen, ohne anschließendes Deployment")
+    parser.add_argument(
+        "--message", "-m",
+        help="Changelog-Beschreibung für diese Version",
+    )
+    parser.add_argument(
+        "--no-pause", action="store_true",
+        help="Nicht auf die Bearbeitung des Changelogs warten (z.B. für CI)",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Nur anzeigen, was passieren würde (kein Build)",
+    )
+    args = parser.parse_args()
+
+    # ── Version ermitteln ────────────────────────────────────
+    current = get_current_version()
+    if not current:
+        if args.no_bump:
+            parser.error("Für --no-bump muss eine Version im CHANGELOG.md vorhanden sein.")
+        print("❌ Keine Version in CHANGELOG.md gefunden. Beginne mit 0.1.")
+        current = "0.1"
+
+    print(f"\n📋 Aktuelle Version: {current}")
+
+    # Bump-Typ bestimmen
+    bump_type = args.bump
+    if not bump_type and not args.no_bump:
+        print("\nWelche Art von Änderung?")
+        print("  [1] major – inkompatible API-Änderungen")
+        print("  [2] minor – neue Funktionalität (abwärtskompatibel)")
+        print("  [3] patch – Bugfixes")
+        try:
+            choice = input("  → ").strip()
+            bump_type = {"1": "major", "2": "minor", "3": "patch"}.get(choice, "minor")
+        except (EOFError, KeyboardInterrupt):
+            print("\nAbgebrochen.")
+            sys.exit(0)
+
+    new_version = current if args.no_bump else bump_version(current, bump_type)
+    print(f"🚀 Neue Version:    {new_version}")
+
+    if args.dry_run:
+        print("\n[Trockenlauf – kein Build]")
+        print("  Würde zuerst alle Tests ausführen")
+        if not args.no_bump:
+            print(f"  Würde CHANGELOG.md aktualisieren: [{new_version}]")
+        print(f"  Würde PyInstaller-Build starten")
+        if not args.no_deploy:
+            print("  Würde anschließend ein versioniertes ZIP auf dem SMB-Laufwerk bereitstellen")
+        return
+
+    _run_tests()
+
+    previous_changelog = _read_changelog()
+    try:
+        _ensure_pyinstaller()
+        (BUILD_OUTPUT_DIR / "release.json").unlink(missing_ok=True)
+        if not args.no_bump:
+            print("\n📝 Changelog …")
+            update_changelog(new_version, bump_type, args.message)
+            if not args.no_pause and sys.stdin.isatty():
+                _wait_for_changelog_edit()
+        _prepare_build_dir()
+        exe_path = _run_pyinstaller()
+        final_exe = _copy_to_build(exe_path)
+        write_release_manifest(BUILD_OUTPUT_DIR, new_version)
+    except (Exception, SystemExit, KeyboardInterrupt):
+        _write_changelog(previous_changelog)
+        raise
+    finally:
+        _cleanup()
+
+    _save_version(new_version)
+    _print_summary(new_version, final_exe)
+    if args.no_deploy:
+        print("[INFO] Lokaler Build abgeschlossen; Deployment nicht angefordert.")
+        return
+    try:
+        deploy()
+    except (OSError, ValueError, KeyError) as exc:
+        print(f"[FEHLER] {exc}")
+        print("[INFO] Der Build ist fertig. Deployment später mit 1_build-pipeline\\deploy.bat wiederholen.")
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (OSError, ValueError, subprocess.CalledProcessError) as exc:
+        print(f"[FEHLER] Pipeline abgebrochen: {exc}")
+        raise SystemExit(1)
@@ -0,0 +1,162 @@
+# -*- mode: python ; coding: utf-8 -*-
+"""PyInstaller Spec-Datei für den Tätigkeitsnachweis-Generator.
+
+Baut eine standalone .exe aus run.py, die Streamlit, openpyxl und
+PyMuPDF (fitz) enthält.
+
+Verwendung:
+    pyinstaller build.spec
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Pfade relativ zum Speicherort dieser Spec-Datei
+# PyInstaller stellt SPECPATH bereit (__file__ existiert in exec()-Kontext nicht)
+_SPEC_DIR = Path(SPECPATH).resolve()
+_PROJECT_ROOT = _SPEC_DIR.parent
+_APP_DIR = _PROJECT_ROOT / "0_application"
+
+# ── Streamlit & PyMuPDF Hidden Imports ──────────────────────────
+# Streamlit hat viele dynamische Imports; collect_all holt alles.
+# PyMuPDF (fitz) braucht die native DLL.
+
+hiddenimports = [
+    # Streamlit-Komponenten
+    "streamlit",
+    "streamlit.web.bootstrap",
+    "streamlit.runtime",
+    "streamlit.runtime.scriptrunner",
+    "streamlit.runtime.state",
+    "streamlit.runtime.caching",
+    "streamlit.watcher",
+    "streamlit.watcher.local_sources_watcher",
+    "streamlit.watcher.poll_path_watcher",
+    "streamlit.watcher.event_based_path_watcher",
+    "streamlit.elements",
+    "streamlit.elements.arrow",
+    "streamlit.elements.pyplot",
+    "streamlit.elements.altair",
+    "streamlit.elements.plotly",
+    "streamlit.proto",
+    # openpyxl
+    "openpyxl",
+    "openpyxl.cell",
+    "openpyxl.styles",
+    # PyMuPDF
+    "fitz",
+    # Standard-Libs die manchmal übersehen werden
+    "tornado",
+    "watchdog",
+    "pandas",
+    "numpy",
+    "PIL",
+    "altair",
+    "pyarrow",
+    "git",
+    "blinker",
+    "rich",
+    "pydeck",
+]
+
+# ── Binaries (PyMuPDF DLL) ──────────────────────────────────────
+binaries = []
+
+# Finde die PyMuPDF-DLL
+try:
+    import fitz
+    fitz_dir = Path(fitz.__file__).parent
+    for f in fitz_dir.iterdir():
+        if f.suffix.lower() in (".dll", ".pyd", ".so", ".dylib"):
+            binaries.append((str(f), "fitz"))
+except ImportError:
+    pass
+
+# ── Data Files ──────────────────────────────────────────────────
+datas = [
+    (str(_APP_DIR / "app.py"), "."),
+    (str(_APP_DIR / "version_check.py"), "."),
+    (str(_APP_DIR / "update_installer.py"), "."),
+    (str(_APP_DIR / "CHANGELOG.md"), "."),
+    (str(_APP_DIR / "src"), "src"),
+    (str(_APP_DIR / "config"), "config"),
+]
+
+# ── Alle Streamlit-Abhängigkeiten & Metadaten VOR Analysis() sammeln ─
+from PyInstaller.utils.hooks import collect_all, copy_metadata
+
+streamlit_datas, streamlit_binaries, streamlit_hidden = collect_all("streamlit")
+datas.extend(streamlit_datas)
+binaries.extend(streamlit_binaries)
+hiddenimports.extend(streamlit_hidden)
+
+# Package-Metadaten: streamlit & Co. nutzen importlib.metadata.version(),
+# das die METADATA-Dateien aus dem dist-info-Ordner benötigt.
+for pkg in ["streamlit", "pyarrow", "numpy", "pandas", "altair", "openpyxl"]:
+    try:
+        datas += copy_metadata(pkg)
+    except Exception:
+        pass
+
+# Deduplizieren (Datas und Hiddenimports)
+hiddenimports = list(set(hiddenimports))
+seen = set()
+_unique_datas = []
+for src, dst in datas:
+    key = (src, dst)
+    if key not in seen:
+        seen.add(key)
+        _unique_datas.append((src, dst))
+datas = _unique_datas
+
+# ── Analyse ─────────────────────────────────────────────────────
+a = Analysis(
+    [str(_SPEC_DIR / "run.py")],
+    pathex=[str(_APP_DIR)],
+    binaries=binaries,
+    datas=datas,
+    hiddenimports=hiddenimports,
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[
+        "tkinter",
+        "matplotlib",
+        "scipy",
+        "IPython",
+        "jupyter",
+        "notebook",
+        "sqlalchemy",
+    ],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=None,
+    noarchive=False,
+)
+
+# ── PyZ ─────────────────────────────────────────────────────────
+pyz = PYZ(a.pure, a.zipped_data, cipher=None)
+
+# ── EXE ─────────────────────────────────────────────────────────
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    [],
+    name="Tätigkeitsnachweis-Generator",
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,  # True = Konsolenfenster sichtbar (zeigt Streamlit-Logs)
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)
@@ -0,0 +1,18 @@
+@echo off
+chcp 65001 >nul
+setlocal
+set "PYTHONUTF8=1"
+cd /d "%~dp0.."
+
+if exist "0_application\.venv\Scripts\python.exe" (
+    set "DEPLOY_PYTHON=0_application\.venv\Scripts\python.exe"
+) else if exist ".venv\Scripts\python.exe" (
+    set "DEPLOY_PYTHON=.venv\Scripts\python.exe"
+) else (
+    set "DEPLOY_PYTHON=python"
+)
+
+"%DEPLOY_PYTHON%" "1_build-pipeline\deploy.py"
+set "DEPLOY_EXIT_CODE=%ERRORLEVEL%"
+if /I not "%~1"=="--no-pause" pause
+exit /b %DEPLOY_EXIT_CODE%
@@ -0,0 +1,160 @@
+"""Package and publish the last successful build to the SMB update directory."""
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import tempfile
+import zipfile
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+BUILD_DIR = PROJECT_ROOT / "2_build"
+DEPLOY_DIR = Path(r"j:\Fachbereiche\BO\Produktionsschule\Maßnahmeunterlagen\20_Personal\05_Tätigkeitsnachweise ESF\Nachweise-automatisiert-generieren")
+EXE_NAME = "Tätigkeitsnachweis-Generator.exe"
+MANIFEST_NAME = "release.json"
+PACKAGE_FILES = [
+    EXE_NAME, "README.md", "CHANGELOG.md",
+    "config/settings.ini", "config/input-fields.json", "config/output-fields.json",
+]
+
+
+def is_template_pdf(path: Path) -> bool:
+    """Nur *.pdf, die nicht mit '_' oder '.' beginnen, gelten als Template."""
+    return path.is_file() and path.suffix.lower() == ".pdf" and not path.name.startswith(("_", "."))
+
+
+def template_files(base_dir: Path) -> list[str]:
+    """Relative Pfade aller Template-PDFs in base_dir/template (sortiert)."""
+    folder = base_dir / "template"
+    if not folder.is_dir():
+        return []
+    return [f"template/{p.name}" for p in sorted(folder.iterdir()) if is_template_pdf(p)]
+
+
+def package_files(build_dir: Path) -> list[str]:
+    """Alle Dateien des Release-Pakets: feste Dateien plus alle Template-PDFs."""
+    return PACKAGE_FILES + template_files(build_dir)
+
+
+def normalize_version(version: str) -> str:
+    if not re.fullmatch(r"\d+\.\d+(?:\.\d+)?", version):
+        raise ValueError(f"Ungültige Versionsnummer: {version}")
+    return ".".join(str(int(part)) for part in (version.split(".") + ["0"])[:3])
+
+
+def file_hash(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for block in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def write_release_manifest(build_dir: Path, version: str) -> None:
+    """Record the version and all payload hashes after a successful build."""
+    manifest = {
+        "version": normalize_version(version),
+        "files": {name: file_hash(build_dir / name) for name in package_files(build_dir)},
+    }
+    (build_dir / MANIFEST_NAME).write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def validate_release(build_dir: Path) -> str:
+    if not (build_dir / MANIFEST_NAME).is_file():
+        raise ValueError("Kein bestätigter Build vorhanden. Bitte zuerst build.bat ausführen.")
+    manifest = json.loads((build_dir / MANIFEST_NAME).read_text(encoding="utf-8"))
+    version = normalize_version(manifest["version"])
+    for name in package_files(build_dir):
+        path = build_dir / name
+        if not path.is_file() or file_hash(path) != manifest.get("files", {}).get(name):
+            raise ValueError(f"Build-Datei fehlt oder wurde nach dem Build verändert: {name}. Bitte neu bauen.")
+    return version
+
+
+def check_deploy_target(target_dir: Path) -> None:
+    """Never create the SMB destination: a missing mount must be an error."""
+    try:
+        if not target_dir.is_dir():
+            raise OSError("Verzeichnis ist nicht verfügbar")
+        # Actually access the directory; exists() alone does not check read access.
+        with os.scandir(target_dir) as entries:
+            next(entries, None)
+    except OSError as exc:
+        raise OSError(
+            f"Deployment-Ziel nicht erreichbar: {target_dir}\n"
+            "Bitte VPN-Verbindung und Netzlaufwerk J: prüfen und deploy.bat erneut starten."
+        ) from exc
+
+
+def deploy(build_dir: Path = BUILD_DIR, target_dir: Path = DEPLOY_DIR) -> Path:
+    version = validate_release(build_dir)
+    check_deploy_target(target_dir)
+    archive_name = f"Tätigkeitsnachweis-Generator v{version}.zip"
+    archive = build_dir / archive_name
+    descriptor, temporary = tempfile.mkstemp(prefix="release-", suffix=".zip", dir=build_dir)
+    os.close(descriptor)
+    temporary = Path(temporary)
+    try:
+        with zipfile.ZipFile(temporary, "w", zipfile.ZIP_DEFLATED) as package:
+            for name in package_files(build_dir):
+                package.write(build_dir / name, name)
+            for directory in ["input/", "output/"]:
+                # Fixed timestamps keep repeated deployments byte-identical.
+                package.writestr(zipfile.ZipInfo(directory, date_time=(2020, 1, 1, 0, 0, 0)), b"")
+        with zipfile.ZipFile(temporary) as package:
+            if package.testzip() is not None:
+                raise ValueError("Das erzeugte ZIP-Paket ist beschädigt.")
+        temporary.replace(archive)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+    destination = target_dir / archive_name
+    if destination.exists():
+        if file_hash(destination) == file_hash(archive):
+            print(f"[OK] Diese Version ist bereits unverändert bereitgestellt: {destination}")
+            return destination
+        raise FileExistsError(f"{destination} existiert bereits mit anderem Inhalt. Bitte eine neue Version bauen.")
+
+    # Write access is checked by creating the staging file on the actual share.
+    remote_temporary = None
+    try:
+        descriptor, name = tempfile.mkstemp(prefix=".upload-", suffix=".tmp", dir=target_dir)
+        os.close(descriptor)
+        remote_temporary = Path(name)
+        shutil.copyfile(archive, remote_temporary)
+        if file_hash(remote_temporary) != file_hash(archive):
+            raise OSError("Die Prüfsumme nach der SMB-Übertragung stimmt nicht überein.")
+        # On Windows rename refuses to overwrite another published release.
+        remote_temporary.rename(destination)
+    except OSError as exc:
+        raise OSError(
+            "Deployment fehlgeschlagen. VPN-Verbindung und Schreibrechte prüfen. "
+            "Der erfolgreiche lokale Build bleibt erhalten; erneut mit deploy.bat starten."
+        ) from exc
+    finally:
+        if remote_temporary is not None:
+            try:
+                remote_temporary.unlink(missing_ok=True)
+            except OSError:
+                pass  # The VPN may have disconnected during transfer.
+    print(f"[OK] Deployment abgeschlossen: {destination}")
+    return destination
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Letzten erfolgreichen Build auf dem SMB-Laufwerk bereitstellen")
+    parser.parse_args()
+    try:
+        deploy()
+    except (OSError, ValueError, KeyError) as exc:
+        print(f"[FEHLER] {exc}")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -0,0 +1,109 @@
+"""Einstiegspunkt für die gebundelte Tätigkeitsnachweis-Generator .exe.
+
+Wird von PyInstaller als Entry-Point verwendet. Im gebundelten Modus
+(sys.frozen = True) liegen die Python-Dateien (app.py, src/) in sys._MEIPASS,
+während die Daten-Ordner (config/, input/, template/, output/) neben der .exe
+erwartet werden.
+
+Dieses Skript:
+1. Setzt APP_BASE_DIR auf das Verzeichnis der .exe
+2. Fügt sys._MEIPASS zum Python-Pfad hinzu (für src/-Imports)
+3. Startet den Streamlit-Server und öffnet den Browser
+"""
+
+import os
+import subprocess
+import sys
+import threading
+import time
+import webbrowser
+from pathlib import Path
+
+if not getattr(sys, "frozen", False):
+    sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "0_application"))
+from server_lifecycle import stop_existing_server
+
+
+def _get_base_dir() -> Path:
+    """Verzeichnis der .exe (bzw. des Skripts im Entwicklungsmodus)."""
+    if getattr(sys, 'frozen', False):
+        return Path(sys.executable).resolve().parent
+    else:
+        # Entwicklungsmodus: run.py liegt in 1_build-pipeline/,
+        # die App in 0_application/
+        return Path(__file__).resolve().parent.parent / "0_application"
+
+
+def _get_app_path() -> str:
+    """Pfad zur app.py (gebundelt oder im Entwicklungsmodus)."""
+    if getattr(sys, 'frozen', False):
+        return os.path.join(sys._MEIPASS, "app.py")
+    else:
+        return str(Path(__file__).resolve().parent.parent / "0_application" / "app.py")
+
+
+def _ensure_dirs(base_dir: Path) -> None:
+    """Stellt sicher, dass input/, output/, template/, config/ existieren."""
+    for folder in ["input", "output", "template", "config"]:
+        (base_dir / folder).mkdir(exist_ok=True)
+
+
+def main() -> None:
+    # Only open the browser/start Streamlit once the previous server has stopped.
+    try:
+        if not stop_existing_server():
+            print("[INFO] Die bisherige Version bleibt geöffnet. Keine neue Instanz gestartet.")
+            return
+    except (RuntimeError, OSError, subprocess.SubprocessError) as exc:
+        print(f"[FEHLER] Server-Neustart fehlgeschlagen: {exc}", file=sys.stderr)
+        raise SystemExit(1)
+    base_dir = _get_base_dir()
+
+    # Im gebundelten Modus: sys._MEIPASS enthält src/ und app.py
+    if getattr(sys, 'frozen', False):
+        if sys._MEIPASS not in sys.path:
+            sys.path.insert(0, sys._MEIPASS)
+
+    # APP_BASE_DIR teilt app.py mit, wo die Daten-Ordner liegen
+    os.environ["APP_BASE_DIR"] = str(base_dir)
+
+    _ensure_dirs(base_dir)
+
+    # ── Streamlit-Konfiguration ──────────────────────────
+    os.environ["STREAMLIT_SERVER_ADDRESS"] = "localhost"
+    os.environ["STREAMLIT_SERVER_PORT"] = "8501"
+    os.environ["STREAMLIT_SERVER_HEADLESS"] = "true"
+    os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+    os.environ["STREAMLIT_SERVER_ENABLE_CORS"] = "false"
+    os.environ["STREAMLIT_SERVER_ENABLE_XSRF_PROTECTION"] = "false"
+
+    # Browser manuell öffnen
+    def _open_browser() -> None:
+        time.sleep(2)
+        webbrowser.open("http://localhost:8501")
+
+    threading.Thread(target=_open_browser, daemon=True).start()
+
+    # ── Streamlit via CLI-Codepfad starten ───────────────
+    # Dieser Weg ist identisch zu 'streamlit run app.py' und
+    # funktioniert im PyInstaller-Bundle zuverlässiger als
+    # bootstrap.run() mit Streamlit >= 1.58.
+    sys.argv = [
+        "streamlit", "run", _get_app_path(),
+        "--server.port=8501",
+        "--server.address=localhost",
+        "--server.headless=true",
+        "--browser.gatherUsageStats=false",
+        "--server.enableCORS=false",
+        "--server.enableXsrfProtection=false",
+        "--global.developmentMode=false",
+    ]
+    try:
+        from streamlit.cli import main as cli_main
+    except ImportError:
+        from streamlit.web.cli import main as cli_main
+    cli_main()
+
+
+if __name__ == "__main__":
+    main()
@@ -1,20 +0,0 @@
-# SAB Taetigkeitsnachweise Tool
-
-## Setup
-
-1. Create and activate a virtual environment.
-2. Install dependencies:
-
-```bash
-pip install -r requirements.txt
-```
-
-## Local run command
-
-Use module execution from the project root:
-
-```bash
-python -m src.taetigkeitsnachweis.cli --version
-```
-
-Current CLI is a scaffold. Full generation pipeline is implemented in later tasks.
@@ -1,84 +0,0 @@
-{
-  "paths": {
-    "input_dir": "input",
-    "template_dir": "template",
-    "output_dir": "output"
-  },
-  "files": {
-    "allocation_workbook": "PS_PW.xlsx",
-    "masterdata_workbook": "Stellenbeschreibungen.xlsx",
-    "template_workbook": "Tätigkeitsnachweis Stellenförderung.xlsx"
-  },
-  "sheets": {
-    "allocation": "Tabelle1",
-    "masterdata": "Tabelle1",
-    "template_source": "<MM_YYYY>_<Stellenbeschreibung>"
-  },
-  "allocation": {
-    "header_month_marker_row": 2,
-    "columns": {
-      "employee_name": "A",
-      "contract_hours_weekly": "B",
-      "project_key": "C",
-      "first_month_column": "D",
-      "remarks": "I"
-    },
-    "month_marker": {
-      "prefix": "ab ",
-      "date_format": "%d.%m.%Y",
-      "exact_first_day_required": true
-    },
-    "inactive_values": [
-      "",
-      "-",
-      "0",
-      0
-    ]
-  },
-  "masterdata": {
-    "columns": {
-      "id": "A",
-      "antragsnummer": "B",
-      "name": "C",
-      "qualifikation": "D",
-      "project_scope": "E",
-      "stellenanteil": "F",
-      "funktion": "G",
-      "taetigkeit": "H"
-    },
-    "decimal": {
-      "decimal_separator": ",",
-      "thousands_separator": "."
-    }
-  },
-  "matching": {
-    "name_normalization": {
-      "trim": true,
-      "collapse_spaces": true,
-      "case_insensitive": true
-    },
-    "share_tolerance_percent": 0.5,
-    "prefer_function_hint": true
-  },
-  "output": {
-    "filename_pattern": "Taetigkeitsnachweis_{year}_{month}_{first_name}_{last_name}.xlsx",
-    "one_workbook_per_employee": true,
-    "one_sheet_per_assignment": true,
-    "sheet_name_pattern": "{index}_{funktion}"
-  },
-  "template_targets": {
-    "antragsnummer": "A3",
-    "name_vorname": "A17",
-    "qualifikation": "A21",
-    "funktion": "A25",
-    "taetigkeiten": "A31",
-    "reporting_month_label": "Q21",
-    "foerderquote": "Q17",
-    "generated_on": "I95"
-  },
-  "runtime": {
-    "abort_on_validation_errors": true,
-    "preview_before_write": true,
-    "confirm_before_write": true
-  }
-}
@@ -1,158 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import click
-
-from src.taetigkeitsnachweis.errors import TaetigkeitsnachweisError
-from src.taetigkeitsnachweis.logging_utils import configure_logging
-from src.taetigkeitsnachweis.matcher import match_assignments
-from src.taetigkeitsnachweis.parser import parse_allocation_records, parse_masterdata_records
-from src.taetigkeitsnachweis.validator import validate_business_rules, validate_sources
-from src.taetigkeitsnachweis.writer import (
-    build_employee_workbooks,
-    build_output_filename,
-    save_employee_workbooks,
-)
-
-
-def _load_config(project_root: Path) -> dict:
-    config_path = project_root / "config.json"
-    with config_path.open("r", encoding="utf-8") as config_file:
-        return json.load(config_file)
-
-
-def _print_issues(issues: list, title: str) -> None:
-    if not issues:
-        return
-    click.echo(title)
-    for issue in issues:
-        click.echo(f"- [{issue.severity}] {issue.code}: {issue.message}")
-
-
-def _print_preview(month: int, year: int, matched_assignments: list, planned_files: list[str]) -> None:
-    click.echo("=== Vorschau der ermittelten Werte ===")
-    click.echo(f"Berichtsmonat : {month:02d}/{year}")
-    click.echo(f"Aktive Faelle : {len(matched_assignments)}")
-    click.echo("--- Zu erzeugende Taetigkeitsnachweise ---")
-    for item in matched_assignments:
-        click.echo(
-            "- "
-            f"{item.allocation.employee_name} | "
-            f"{item.masterdata.funktion} | "
-            f"{item.foerderquote_percent:.2f}%"
-        )
-
-    click.echo("--- Geplante Ausgabedateien ---")
-    for file_name in planned_files:
-        click.echo(f"- {file_name}")
-
-
-@click.command()
-@click.option("--month", type=click.IntRange(1, 12), required=True)
-@click.option("--year", type=click.IntRange(2000, 2100), required=True)
-@click.option("--yes", is_flag=True, default=False, help="Skip interactive confirmation.")
-@click.option("--skip-errors", is_flag=True, default=False, help="Generate files for matched records, skip unresolved ones.")
-def main(month: int, year: int, yes: bool, skip_errors: bool) -> None:
-    configure_logging()
-    project_root = Path(__file__).resolve().parent
-
-    try:
-        config = _load_config(project_root)
-
-        source_issues = validate_sources(
-            config=config,
-            report_month=month,
-            report_year=year,
-            project_root=project_root,
-        )
-        _print_issues(source_issues, "=== Source validation ===")
-        if any(issue.severity == "error" for issue in source_issues):
-            raise click.ClickException("Source validation failed.")
-
-        allocation_records = parse_allocation_records(
-            config=config,
-            report_month=month,
-            report_year=year,
-            project_root=project_root,
-        )
-        masterdata_records = parse_masterdata_records(
-            config=config,
-            project_root=project_root,
-        )
-
-        matched_assignments, match_issues = match_assignments(
-            allocation_records=allocation_records,
-            masterdata_records=masterdata_records,
-            config=config,
-        )
-        _print_issues(match_issues, "=== Matching issues ===")
-
-        business_issues = validate_business_rules(
-            config=config,
-            report_month=month,
-            report_year=year,
-            allocation_records=allocation_records,
-            matched_assignments=matched_assignments,
-            project_root=project_root,
-        )
-        _print_issues(business_issues, "=== Business validation ===")
-
-        all_issues = [*match_issues, *business_issues]
-        has_errors = any(issue.severity == "error" for issue in all_issues)
-        if has_errors and not skip_errors:
-            raise click.ClickException("Validation failed after matching.")
-        if has_errors and skip_errors:
-            click.echo("Warnhinweis: Fehler vorhanden. Weiterfahrt mit --skip-errors (nur gematchte Faelle werden erzeugt).")
-
-        filename_pattern = config["output"]["filename_pattern"]
-        unique_employees = sorted({item.allocation.employee_name for item in matched_assignments})
-        planned_files = [
-            build_output_filename(
-                filename_pattern=filename_pattern,
-                employee_name=employee_name,
-                report_year=year,
-                report_month=month,
-            )
-            for employee_name in unique_employees
-        ]
-
-        _print_preview(
-            month=month,
-            year=year,
-            matched_assignments=matched_assignments,
-            planned_files=planned_files,
-        )
-
-        if not yes:
-            confirmed = click.confirm("Dateien jetzt schreiben?", default=False)
-            if not confirmed:
-                click.echo("Abbruch ohne Schreibzugriff.")
-                return
-
-        employee_workbooks = build_employee_workbooks(
-            config=config,
-            matched_assignments=matched_assignments,
-            report_month=month,
-            report_year=year,
-            project_root=project_root,
-        )
-        output_paths = save_employee_workbooks(
-            config=config,
-            employee_workbooks=employee_workbooks,
-            report_month=month,
-            report_year=year,
-            project_root=project_root,
-        )
-
-        click.echo("=== Generated files ===")
-        for output_path in output_paths:
-            click.echo(f"- {output_path}")
-
-    except TaetigkeitsnachweisError as exc:
-        raise click.ClickException(str(exc)) from exc
-
-
-if __name__ == "__main__":
-    main()
@@ -1,2 +0,0 @@
-click>=8.1,<9.0
-openpyxl>=3.1,<4.0
@@ -1,7 +0,0 @@
-"""SAB Taetigkeitsnachweis generator package."""
-
-__all__ = [
-    "models",
-    "errors",
-    "logging_utils",
-]
@@ -1,34 +0,0 @@
-"""CLI entrypoint and orchestration layer."""
-
-from __future__ import annotations
-
-import argparse
-
-
-def build_parser() -> argparse.ArgumentParser:
-	parser = argparse.ArgumentParser(
-		prog="taetigkeitsnachweis",
-		description="SAB Taetigkeitsnachweise generator",
-	)
-	parser.add_argument(
-		"--version",
-		action="store_true",
-		help="Show tool version and exit.",
-	)
-	return parser
-
-
-def main() -> int:
-	parser = build_parser()
-	args = parser.parse_args()
-
-	if args.version:
-		print("taetigkeitsnachweis 0.1.0")
-		return 0
-
-	print("CLI scaffold ready. Full pipeline will be added in Task T13.")
-	return 0
-
-
-if __name__ == "__main__":
-	raise SystemExit(main())
@@ -1,14 +0,0 @@
-class TaetigkeitsnachweisError(Exception):
-    """Base exception for all domain-specific failures."""
-
-
-class ConfigurationError(TaetigkeitsnachweisError):
-    """Raised when configuration is missing or invalid."""
-
-
-class ValidationError(TaetigkeitsnachweisError):
-    """Raised when source or business validation fails."""
-
-
-class MatchingError(TaetigkeitsnachweisError):
-    """Raised when records cannot be matched uniquely."""
@@ -1,8 +0,0 @@
-import logging
-
-
-def configure_logging(level: int = logging.INFO) -> None:
-    logging.basicConfig(
-        level=level,
-        format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
-    )
@@ -1,160 +0,0 @@
-"""Record matching logic across allocation and master data."""
-
-from __future__ import annotations
-
-import re
-import unicodedata
-from typing import Any
-
-from .errors import ValidationError
-from .models import AllocationRecord, MasterDataRecord, MatchedAssignment, ValidationIssue
-
-
-def calculate_foerderquote_percent(allocation: AllocationRecord, precision: int = 2) -> float:
-    if allocation.contract_hours_weekly <= 0:
-        raise ValidationError(
-            "contract_hours_weekly must be greater than 0 for foerderquote calculation."
-        )
-    raw_share = (allocation.funded_hours_weekly / allocation.contract_hours_weekly) * 100.0
-    return round(raw_share, precision)
-
-
-def _normalize_name(name: str) -> str:
-    compact = re.sub(r"\s+", " ", name.strip())
-    no_accents = "".join(
-        ch for ch in unicodedata.normalize("NFKD", compact) if not unicodedata.combining(ch)
-    )
-    return no_accents.casefold()
-
-
-def _name_keys(name: str) -> set[str]:
-    normalized = _normalize_name(name)
-    keys = {normalized}
-    if "," in normalized:
-        last_name, first_name = [part.strip() for part in normalized.split(",", 1)]
-        if first_name and last_name:
-            keys.add(f"{first_name} {last_name}")
-            keys.add(f"{last_name}, {first_name}")
-    else:
-        tokens = normalized.split()
-        if len(tokens) >= 2:
-            first_name = tokens[0]
-            last_name = tokens[-1]
-            keys.add(f"{first_name} {last_name}")
-            keys.add(f"{last_name}, {first_name}")
-    return {re.sub(r"\s+", " ", key).strip() for key in keys if key.strip()}
-
-
-def _disambiguate_by_project_key(
-    candidates: list[MasterDataRecord],
-    project_key: str,
-) -> MasterDataRecord | None:
-    """Return the single candidate matching allocation project key via masterdata project_scope."""
-    parts = [
-        token.strip().casefold()
-        for token in re.split(r"[/,;|]", project_key)
-        if token.strip()
-    ]
-    project_tokens = set(parts or [project_key.strip().casefold()])
-
-    matched = []
-    for candidate in candidates:
-        candidate_scope = (candidate.project_scope or "PS").strip().casefold()
-        if candidate_scope in project_tokens:
-            matched.append(candidate)
-
-    return matched[0] if len(matched) == 1 else None
-
-
-def match_assignments(
-    allocation_records: list[AllocationRecord],
-    masterdata_records: list[MasterDataRecord],
-    config: dict[str, Any],
-) -> tuple[list[MatchedAssignment], list[ValidationIssue]]:
-    # Build lookup by all normalized name variants
-    master_by_name: dict[str, list[MasterDataRecord]] = {}
-    for record in masterdata_records:
-        for key in _name_keys(record.name):
-            master_by_name.setdefault(key, []).append(record)
-
-    # Deduplicate so the same record does not appear twice for one name key
-    for key in master_by_name:
-        seen_ids: set[str] = set()
-        deduped: list[MasterDataRecord] = []
-        for rec in master_by_name[key]:
-            if rec.record_id not in seen_ids:
-                seen_ids.add(rec.record_id)
-                deduped.append(rec)
-        master_by_name[key] = deduped
-
-    matched: list[MatchedAssignment] = []
-    issues: list[ValidationIssue] = []
-
-    for allocation in allocation_records:
-        # Collect all master-data candidates for this employee name
-        candidate_map: dict[str, MasterDataRecord] = {}
-        for key in _name_keys(allocation.employee_name):
-            for candidate in master_by_name.get(key, []):
-                candidate_map[candidate.record_id] = candidate
-        candidates = list(candidate_map.values())
-
-        if not candidates:
-            issues.append(
-                ValidationIssue(
-                    code="MISSING_MASTERDATA",
-                    message=(
-                        f"No master-data match for employee '{allocation.employee_name}' "
-                        f"(project '{allocation.project_key}')."
-                    ),
-                    severity="error",
-                    context=allocation.employee_name,
-                )
-            )
-            continue
-
-        # Single candidate: use directly
-        if len(candidates) == 1:
-            selected = candidates[0]
-        else:
-            # Multiple candidates: disambiguate by explicit project scope column.
-            selected = _disambiguate_by_project_key(candidates, allocation.project_key)
-            if selected is None:
-                issues.append(
-                    ValidationIssue(
-                        code="AMBIGUOUS_MASTERDATA",
-                        message=(
-                            f"Ambiguous master-data for '{allocation.employee_name}' / "
-                            f"'{allocation.project_key}': {len(candidates)} rows, "
-                            f"none or multiple match project_scope. "
-                            f"project_scope values: {[c.project_scope for c in candidates]}"
-                        ),
-                        severity="error",
-                        context=allocation.employee_name,
-                    )
-                )
-                continue
-
-        foerderquote = calculate_foerderquote_percent(allocation)
-
-        if allocation.notes:
-            issues.append(
-                ValidationIssue(
-                    code="ALLOCATION_NOTE",
-                    message=(
-                        f"Note for '{allocation.employee_name}' / "
-                        f"'{allocation.project_key}': {allocation.notes}"
-                    ),
-                    severity="warning",
-                    context=allocation.employee_name,
-                )
-            )
-
-        matched.append(
-            MatchedAssignment(
-                allocation=allocation,
-                masterdata=selected,
-                foerderquote_percent=foerderquote,
-            )
-        )
-
-    return matched, issues
@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Optional
-
-
-@dataclass(frozen=True)
-class AllocationRecord:
-    employee_name: str
-    contract_hours_weekly: float
-    project_key: str
-    funded_hours_weekly: float
-    notes: str = ""
-
-
-@dataclass(frozen=True)
-class MasterDataRecord:
-    record_id: str
-    antragsnummer: str
-    name: str
-    qualifikation: str
-    project_scope: str
-    stellenanteil_percent: float
-    funktion: str
-    taetigkeit: str
-
-
-@dataclass(frozen=True)
-class MatchedAssignment:
-    allocation: AllocationRecord
-    masterdata: MasterDataRecord
-    foerderquote_percent: float
-
-
-@dataclass(frozen=True)
-class ValidationIssue:
-    code: str
-    message: str
-    severity: str = "error"
-    context: Optional[str] = None
@@ -1,289 +0,0 @@
-"""Parsing and normalization for source workbooks."""
-
-from __future__ import annotations
-
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-from openpyxl import load_workbook
-from openpyxl.utils.cell import column_index_from_string
-
-from .errors import ValidationError
-from .models import AllocationRecord, MasterDataRecord
-
-
-def _to_text(value: Any) -> str:
-    if value is None:
-        return ""
-    return str(value).strip()
-
-
-def _to_float(value: Any, field_name: str) -> float:
-    if value is None or str(value).strip() == "":
-        raise ValidationError(f"Missing numeric value for {field_name}.")
-
-    text = str(value).strip().replace(",", ".")
-    try:
-        return float(text)
-    except ValueError as exc:
-        raise ValidationError(f"Invalid numeric value for {field_name}: {value}") from exc
-
-
-def _to_float_or_none(value: Any) -> float | None:
-    if value is None or str(value).strip() == "":
-        return None
-
-    text = str(value).strip().replace(",", ".")
-    try:
-        return float(text)
-    except ValueError:
-        return None
-
-
-def _parse_german_decimal(
-    value: Any,
-    field_name: str,
-    decimal_separator: str,
-    thousands_separator: str,
-) -> float:
-    if value is None or str(value).strip() == "":
-        raise ValidationError(f"Missing numeric value for {field_name}.")
-
-    text = str(value).strip()
-    if thousands_separator:
-        text = text.replace(thousands_separator, "")
-    if decimal_separator:
-        text = text.replace(decimal_separator, ".")
-
-    try:
-        return float(text)
-    except ValueError as exc:
-        raise ValidationError(f"Invalid numeric value for {field_name}: {value}") from exc
-
-
-def _parse_month_marker(value: Any, prefix: str, date_format: str) -> datetime | None:
-    marker = _to_text(value)
-    if not marker:
-        return None
-
-    if not marker.lower().startswith(prefix.lower()):
-        return None
-
-    date_text = marker[len(prefix) :].strip()
-    return datetime.strptime(date_text, date_format)
-
-
-def _resolve_month_column_index(
-    worksheet: Any,
-    header_row: int,
-    first_month_col: str,
-    target_month: int,
-    target_year: int,
-    month_prefix: str,
-    month_date_format: str,
-) -> int:
-    start_index = column_index_from_string(first_month_col)
-    matched_columns: list[int] = []
-
-    for column_index in range(start_index, worksheet.max_column + 1):
-        value = worksheet.cell(row=header_row, column=column_index).value
-        parsed = _parse_month_marker(value, month_prefix, month_date_format)
-        if parsed is None:
-            continue
-        if parsed.month == target_month and parsed.year == target_year:
-            matched_columns.append(column_index)
-
-    if len(matched_columns) == 0:
-        raise ValidationError(
-            f"No month column found for {target_month:02d}/{target_year} in allocation workbook."
-        )
-
-    if len(matched_columns) > 1:
-        raise ValidationError(
-            f"Multiple month columns found for {target_month:02d}/{target_year} in allocation workbook."
-        )
-
-    return matched_columns[0]
-
-
-def _is_inactive_value(value: Any, inactive_values: list[Any]) -> bool:
-    normalized = _to_text(value)
-    if normalized in {"", "-"}:
-        return True
-
-    for inactive in inactive_values:
-        if str(inactive).strip() == normalized:
-            return True
-
-    return False
-
-
-def parse_allocation_records(
-    config: dict[str, Any],
-    report_month: int,
-    report_year: int,
-    project_root: Path,
-) -> list[AllocationRecord]:
-    allocation_cfg = config["allocation"]
-    columns_cfg = allocation_cfg["columns"]
-    files_cfg = config["files"]
-    sheets_cfg = config["sheets"]
-    paths_cfg = config["paths"]
-
-    workbook_path = (
-        project_root
-        / paths_cfg["input_dir"]
-        / files_cfg["allocation_workbook"]
-    )
-
-    if not workbook_path.exists():
-        raise ValidationError(f"Allocation workbook not found: {workbook_path}")
-
-    workbook = load_workbook(workbook_path, data_only=True)
-    sheet_name = sheets_cfg["allocation"]
-    if sheet_name not in workbook.sheetnames:
-        raise ValidationError(f"Sheet '{sheet_name}' not found in {workbook_path.name}")
-    worksheet = workbook[sheet_name]
-
-    header_row = allocation_cfg["header_month_marker_row"]
-    month_marker_cfg = allocation_cfg["month_marker"]
-    month_column = _resolve_month_column_index(
-        worksheet=worksheet,
-        header_row=header_row,
-        first_month_col=columns_cfg["first_month_column"],
-        target_month=report_month,
-        target_year=report_year,
-        month_prefix=month_marker_cfg["prefix"],
-        month_date_format=month_marker_cfg["date_format"],
-    )
-
-    employee_col = column_index_from_string(columns_cfg["employee_name"])
-    contract_col = column_index_from_string(columns_cfg["contract_hours_weekly"])
-    project_col = column_index_from_string(columns_cfg["project_key"])
-    remarks_col = column_index_from_string(columns_cfg["remarks"])
-    inactive_values = allocation_cfg.get("inactive_values", ["", "-", "0", 0])
-
-    current_employee = ""
-    current_contract_hours: float | None = None
-    normalized_records: list[AllocationRecord] = []
-
-    for row_index in range(header_row + 1, worksheet.max_row + 1):
-        row_employee = _to_text(worksheet.cell(row=row_index, column=employee_col).value)
-        row_contract = worksheet.cell(row=row_index, column=contract_col).value
-        row_project = _to_text(worksheet.cell(row=row_index, column=project_col).value)
-
-        if row_employee:
-            current_employee = row_employee
-            current_contract_hours = _to_float_or_none(row_contract)
-
-        if not row_project:
-            continue
-
-        if not current_employee or current_contract_hours is None:
-            raise ValidationError(
-                f"Project row {row_index} has no inherited employee context."
-            )
-
-        month_value = worksheet.cell(row=row_index, column=month_column).value
-        if _is_inactive_value(month_value, inactive_values):
-            continue
-
-        funded_hours = _to_float(month_value, f"funded_hours row {row_index}")
-        if funded_hours <= 0:
-            continue
-
-        if current_contract_hours <= 0:
-            raise ValidationError(
-                f"Contract hours must be > 0 for employee '{current_employee}'"
-            )
-
-        notes = _to_text(worksheet.cell(row=row_index, column=remarks_col).value)
-        normalized_records.append(
-            AllocationRecord(
-                employee_name=current_employee,
-                contract_hours_weekly=current_contract_hours,
-                project_key=row_project,
-                funded_hours_weekly=funded_hours,
-                notes=notes,
-            )
-        )
-
-    workbook.close()
-    return normalized_records
-
-
-def parse_masterdata_records(
-    config: dict[str, Any],
-    project_root: Path,
-) -> list[MasterDataRecord]:
-    files_cfg = config["files"]
-    sheets_cfg = config["sheets"]
-    paths_cfg = config["paths"]
-    master_cfg = config["masterdata"]
-    columns_cfg = master_cfg["columns"]
-    decimal_cfg = master_cfg["decimal"]
-
-    workbook_path = (
-        project_root
-        / paths_cfg["input_dir"]
-        / files_cfg["masterdata_workbook"]
-    )
-
-    if not workbook_path.exists():
-        raise ValidationError(f"Master data workbook not found: {workbook_path}")
-
-    workbook = load_workbook(workbook_path, data_only=True)
-    sheet_name = sheets_cfg["masterdata"]
-    if sheet_name not in workbook.sheetnames:
-        raise ValidationError(f"Sheet '{sheet_name}' not found in {workbook_path.name}")
-    worksheet = workbook[sheet_name]
-
-    id_col = column_index_from_string(columns_cfg["id"])
-    antragsnummer_col = column_index_from_string(columns_cfg["antragsnummer"])
-    name_col = column_index_from_string(columns_cfg["name"])
-    qualifikation_col = column_index_from_string(columns_cfg["qualifikation"])
-    project_scope_col = column_index_from_string(columns_cfg["project_scope"])
-    stellenanteil_col = column_index_from_string(columns_cfg["stellenanteil"])
-    funktion_col = column_index_from_string(columns_cfg["funktion"])
-    taetigkeit_col = column_index_from_string(columns_cfg["taetigkeit"])
-
-    records: list[MasterDataRecord] = []
-
-    for row_index in range(2, worksheet.max_row + 1):
-        name = _to_text(worksheet.cell(row=row_index, column=name_col).value)
-        if not name:
-            continue
-
-        stellenanteil_raw = worksheet.cell(row=row_index, column=stellenanteil_col).value
-        stellenanteil = _to_float_or_none(stellenanteil_raw)
-        if stellenanteil is None:
-            stellenanteil = 0.0
-
-        project_scope = _to_text(
-            worksheet.cell(row=row_index, column=project_scope_col).value
-        )
-        if not project_scope:
-            project_scope = "PS"
-
-        records.append(
-            MasterDataRecord(
-                record_id=_to_text(worksheet.cell(row=row_index, column=id_col).value),
-                antragsnummer=_to_text(
-                    worksheet.cell(row=row_index, column=antragsnummer_col).value
-                ),
-                name=name,
-                qualifikation=_to_text(
-                    worksheet.cell(row=row_index, column=qualifikation_col).value
-                ),
-                project_scope=project_scope,
-                stellenanteil_percent=stellenanteil,
-                funktion=_to_text(worksheet.cell(row=row_index, column=funktion_col).value),
-                taetigkeit=_to_text(
-                    worksheet.cell(row=row_index, column=taetigkeit_col).value
-                ),
-            )
-        )
-
-    workbook.close()
-    return records
@@ -1 +0,0 @@
-"""Shared utility helpers."""
@@ -1,383 +0,0 @@
-"""Source and business rule validation."""
-
-from __future__ import annotations
-
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-from openpyxl import load_workbook
-from openpyxl.utils.cell import column_index_from_string
-
-from .models import AllocationRecord, MatchedAssignment, ValidationIssue
-
-
-def _to_text(value: Any) -> str:
-    if value is None:
-        return ""
-    return str(value).strip()
-
-
-def _to_float_or_none(value: Any) -> float | None:
-    text = _to_text(value)
-    if not text:
-        return None
-    text = text.replace(",", ".")
-    try:
-        return float(text)
-    except ValueError:
-        return None
-
-
-def _parse_month_marker(value: Any, prefix: str, date_format: str) -> datetime | None:
-    marker = _to_text(value)
-    if not marker or not marker.lower().startswith(prefix.lower()):
-        return None
-
-    date_text = marker[len(prefix) :].strip()
-    try:
-        return datetime.strptime(date_text, date_format)
-    except ValueError:
-        return None
-
-
-def validate_sources(
-    config: dict[str, Any],
-    report_month: int,
-    report_year: int,
-    project_root: Path,
-) -> list[ValidationIssue]:
-    issues: list[ValidationIssue] = []
-
-    paths_cfg = config["paths"]
-    files_cfg = config["files"]
-    sheets_cfg = config["sheets"]
-    allocation_cfg = config["allocation"]
-    allocation_cols = allocation_cfg["columns"]
-    month_cfg = allocation_cfg["month_marker"]
-
-    input_dir = project_root / paths_cfg["input_dir"]
-    template_dir = project_root / paths_cfg["template_dir"]
-
-    allocation_path = input_dir / files_cfg["allocation_workbook"]
-    masterdata_path = input_dir / files_cfg["masterdata_workbook"]
-    template_path = template_dir / files_cfg["template_workbook"]
-
-    for required_path in [allocation_path, masterdata_path, template_path]:
-        if not required_path.exists():
-            issues.append(
-                ValidationIssue(
-                    code="MISSING_FILE",
-                    message=f"Required file not found: {required_path}",
-                    severity="error",
-                )
-            )
-
-    if any(issue.code == "MISSING_FILE" for issue in issues):
-        return issues
-
-    allocation_wb = load_workbook(allocation_path, data_only=True)
-    master_wb = load_workbook(masterdata_path, data_only=True)
-
-    allocation_sheet_name = sheets_cfg["allocation"]
-    master_sheet_name = sheets_cfg["masterdata"]
-
-    if allocation_sheet_name not in allocation_wb.sheetnames:
-        issues.append(
-            ValidationIssue(
-                code="MISSING_SHEET",
-                message=f"Sheet '{allocation_sheet_name}' missing in {allocation_path.name}",
-                severity="error",
-            )
-        )
-
-    if master_sheet_name not in master_wb.sheetnames:
-        issues.append(
-            ValidationIssue(
-                code="MISSING_SHEET",
-                message=f"Sheet '{master_sheet_name}' missing in {masterdata_path.name}",
-                severity="error",
-            )
-        )
-
-    if any(issue.code == "MISSING_SHEET" for issue in issues):
-        allocation_wb.close()
-        master_wb.close()
-        return issues
-
-    allocation_ws = allocation_wb[allocation_sheet_name]
-    master_ws = master_wb[master_sheet_name]
-
-    required_allocation_columns = [
-        allocation_cols["employee_name"],
-        allocation_cols["contract_hours_weekly"],
-        allocation_cols["project_key"],
-        allocation_cols["first_month_column"],
-        allocation_cols["remarks"],
-    ]
-    max_allocation_col = allocation_ws.max_column
-    for col_name in required_allocation_columns:
-        if column_index_from_string(col_name) > max_allocation_col:
-            issues.append(
-                ValidationIssue(
-                    code="MISSING_COLUMN",
-                    message=f"Allocation column '{col_name}' is not present.",
-                    severity="error",
-                )
-            )
-
-    master_cols = config["masterdata"]["columns"]
-    required_master_columns = [
-        master_cols["id"],
-        master_cols["antragsnummer"],
-        master_cols["name"],
-        master_cols["qualifikation"],
-        master_cols["project_scope"],
-        master_cols["stellenanteil"],
-        master_cols["funktion"],
-        master_cols["taetigkeit"],
-    ]
-    max_master_col = master_ws.max_column
-    for col_name in required_master_columns:
-        if column_index_from_string(col_name) > max_master_col:
-            issues.append(
-                ValidationIssue(
-                    code="MISSING_COLUMN",
-                    message=f"Master-data column '{col_name}' is not present.",
-                    severity="error",
-                )
-            )
-
-    header_row = allocation_cfg["header_month_marker_row"]
-    first_month_col = column_index_from_string(allocation_cols["first_month_column"])
-    month_matches: list[int] = []
-    parseable_markers = 0
-
-    for col_idx in range(first_month_col, allocation_ws.max_column + 1):
-        marker_value = allocation_ws.cell(row=header_row, column=col_idx).value
-        parsed = _parse_month_marker(
-            marker_value,
-            month_cfg["prefix"],
-            month_cfg["date_format"],
-        )
-        if parsed is None:
-            continue
-
-        parseable_markers += 1
-        if parsed.month == report_month and parsed.year == report_year:
-            month_matches.append(col_idx)
-
-    if parseable_markers == 0:
-        issues.append(
-            ValidationIssue(
-                code="INVALID_MONTH_MARKERS",
-                message="No parseable month marker found in allocation header row.",
-                severity="error",
-            )
-        )
-
-    if len(month_matches) == 0:
-        issues.append(
-            ValidationIssue(
-                code="MONTH_NOT_FOUND",
-                message=f"Requested month {report_month:02d}/{report_year} not found in allocation sheet.",
-                severity="error",
-            )
-        )
-    elif len(month_matches) > 1:
-        issues.append(
-            ValidationIssue(
-                code="MONTH_AMBIGUOUS",
-                message=f"Requested month {report_month:02d}/{report_year} appears in multiple columns.",
-                severity="error",
-            )
-        )
-
-    if len(month_matches) == 1:
-        month_column = month_matches[0]
-        employee_col = column_index_from_string(allocation_cols["employee_name"])
-        contract_col = column_index_from_string(allocation_cols["contract_hours_weekly"])
-        project_col = column_index_from_string(allocation_cols["project_key"])
-
-        current_contract_value: float | None = None
-
-        for row_idx in range(header_row + 1, allocation_ws.max_row + 1):
-            employee_value = _to_text(allocation_ws.cell(row=row_idx, column=employee_col).value)
-            contract_raw = allocation_ws.cell(row=row_idx, column=contract_col).value
-            parsed_contract = _to_float_or_none(contract_raw)
-
-            if employee_value:
-                current_contract_value = parsed_contract
-
-            project_key = _to_text(allocation_ws.cell(row=row_idx, column=project_col).value)
-            if not project_key:
-                continue
-
-            if current_contract_value is None or current_contract_value <= 0:
-                issues.append(
-                    ValidationIssue(
-                        code="INVALID_CONTRACT_HOURS",
-                        message=(
-                            f"Invalid inherited contract weekly hours at row {row_idx}."
-                        ),
-                        severity="error",
-                    )
-                )
-
-            monthly_value = allocation_ws.cell(row=row_idx, column=month_column).value
-            monthly_text = _to_text(monthly_value)
-            if monthly_text in {"", "-", "0"}:
-                continue
-
-            monthly_hours = _to_float_or_none(monthly_value)
-            if monthly_hours is None:
-                issues.append(
-                    ValidationIssue(
-                        code="INVALID_HOUR_VALUE",
-                        message=f"Invalid funded hour value at row {row_idx}.",
-                        severity="error",
-                    )
-                )
-
-    allocation_wb.close()
-    master_wb.close()
-    return issues
-
-
-def _split_name_for_filename(name: str) -> tuple[str, str]:
-    cleaned = _to_text(name)
-    if "," in cleaned:
-        last_name, first_name = [part.strip() for part in cleaned.split(",", 1)]
-        return first_name or "Unknown", last_name or "Unknown"
-
-    parts = cleaned.split()
-    if len(parts) >= 2:
-        return parts[0], parts[-1]
-    if len(parts) == 1:
-        return parts[0], "Unknown"
-    return "Unknown", "Unknown"
-
-
-def _build_output_filename(pattern: str, year: int, month: int, employee_name: str) -> str:
-    first_name, last_name = _split_name_for_filename(employee_name)
-    safe_first = first_name.replace(" ", "_")
-    safe_last = last_name.replace(" ", "_")
-    return pattern.format(
-        year=year,
-        month=f"{month:02d}",
-        first_name=safe_first,
-        last_name=safe_last,
-    )
-
-
-def validate_business_rules(
-    config: dict[str, Any],
-    report_month: int,
-    report_year: int,
-    allocation_records: list[AllocationRecord],
-    matched_assignments: list[MatchedAssignment],
-    project_root: Path,
-) -> list[ValidationIssue]:
-    issues: list[ValidationIssue] = []
-
-    if len(allocation_records) == 0:
-        issues.append(
-            ValidationIssue(
-                code="NO_ACTIVE_ASSIGNMENT",
-                message="No active allocation record found for the requested month.",
-                severity="error",
-            )
-        )
-
-    matched_keys: set[tuple[str, str, float]] = set()
-    for item in matched_assignments:
-        key = (
-            item.allocation.employee_name,
-            item.allocation.project_key,
-            item.allocation.funded_hours_weekly,
-        )
-        if key in matched_keys:
-            issues.append(
-                ValidationIssue(
-                    code="DUPLICATE_MATCH",
-                    message=(
-                        f"Duplicate matched assignment for '{item.allocation.employee_name}' "
-                        f"and project '{item.allocation.project_key}'."
-                    ),
-                    severity="error",
-                    context=item.allocation.employee_name,
-                )
-            )
-        matched_keys.add(key)
-
-    paths_cfg = config["paths"]
-    files_cfg = config["files"]
-    template_path = (
-        project_root
-        / paths_cfg["template_dir"]
-        / files_cfg["template_workbook"]
-    )
-
-    if template_path.exists():
-        template_wb = load_workbook(template_path, data_only=True)
-        configured_sheet = config["sheets"].get("template_source", "")
-        if configured_sheet not in template_wb.sheetnames:
-            issues.append(
-                ValidationIssue(
-                    code="TEMPLATE_SHEET_MISSING",
-                    message=(
-                        f"Configured template sheet '{configured_sheet}' not found in template workbook."
-                    ),
-                    severity="error",
-                )
-            )
-        template_wb.close()
-    else:
-        issues.append(
-            ValidationIssue(
-                code="MISSING_TEMPLATE",
-                message=f"Template workbook not found: {template_path}",
-                severity="error",
-            )
-        )
-
-    template_targets = config.get("template_targets", {})
-    missing_targets = [name for name, cell in template_targets.items() if not _to_text(cell)]
-    if missing_targets:
-        issues.append(
-            ValidationIssue(
-                code="MISSING_TEMPLATE_TARGETS",
-                message=(
-                    "Mandatory template target cells not configured: "
-                    + ", ".join(missing_targets)
-                ),
-                severity="error",
-            )
-        )
-
-    filename_pattern = config["output"]["filename_pattern"]
-    filename_to_employee: dict[str, str] = {}
-    for assignment in matched_assignments:
-        filename = _build_output_filename(
-            filename_pattern,
-            report_year,
-            report_month,
-            assignment.allocation.employee_name,
-        )
-        previous_owner = filename_to_employee.get(filename)
-        if previous_owner is None:
-            filename_to_employee[filename] = assignment.allocation.employee_name
-            continue
-        if previous_owner != assignment.allocation.employee_name:
-            issues.append(
-                ValidationIssue(
-                    code="FILENAME_COLLISION",
-                    message=(
-                        f"Output filename collision between '{previous_owner}' and "
-                        f"'{assignment.allocation.employee_name}' -> {filename}"
-                    ),
-                    severity="error",
-                )
-            )
-
-    return issues
@@ -1,153 +0,0 @@
-"""Template-based output workbook writer."""
-
-from __future__ import annotations
-
-from collections import defaultdict
-from datetime import date
-from pathlib import Path
-from typing import Any
-
-from openpyxl import Workbook, load_workbook
-
-from .models import MatchedAssignment
-
-
-def _split_name_for_filename(name: str) -> tuple[str, str]:
-    cleaned = str(name or "").strip()
-    if "," in cleaned:
-        last_name, first_name = [part.strip() for part in cleaned.split(",", 1)]
-        return first_name or "Unknown", last_name or "Unknown"
-
-    parts = cleaned.split()
-    if len(parts) >= 2:
-        return parts[0], parts[-1]
-    if len(parts) == 1:
-        return parts[0], "Unknown"
-    return "Unknown", "Unknown"
-
-
-def _normalize_sheet_title(raw_title: str, fallback_index: int) -> str:
-    cleaned = (raw_title or "").strip().replace("[", "(").replace("]", ")")
-    if not cleaned:
-        cleaned = f"Assignment_{fallback_index}"
-    return cleaned[:31]
-
-
-def _set_target_value(worksheet: Any, target_cell: str, value: Any) -> None:
-    if not target_cell:
-        return
-    worksheet[target_cell] = value
-
-
-def build_employee_workbooks(
-    config: dict[str, Any],
-    matched_assignments: list[MatchedAssignment],
-    report_month: int,
-    report_year: int,
-    project_root: Path,
-) -> dict[str, Workbook]:
-    paths_cfg = config["paths"]
-    files_cfg = config["files"]
-    output_cfg = config["output"]
-    targets = config.get("template_targets", {})
-
-    template_path = (
-        project_root
-        / paths_cfg["template_dir"]
-        / files_cfg["template_workbook"]
-    )
-
-    assignments_by_employee: dict[str, list[MatchedAssignment]] = defaultdict(list)
-    for assignment in matched_assignments:
-        assignments_by_employee[assignment.allocation.employee_name].append(assignment)
-
-    workbooks: dict[str, Workbook] = {}
-    month_label = f"{report_month:02d}/{report_year}"
-    today_label = date.today().strftime("%d.%m.%Y")
-
-    for employee_name, assignments in assignments_by_employee.items():
-        workbook = load_workbook(template_path)
-        template_sheet_name = config["sheets"].get("template_source", "")
-        if template_sheet_name and template_sheet_name in workbook.sheetnames:
-            base_sheet = workbook[template_sheet_name]
-        else:
-            base_sheet = workbook.worksheets[0]
-
-        for index, assignment in enumerate(assignments, start=1):
-            if index == 1:
-                sheet = base_sheet
-            else:
-                sheet = workbook.copy_worksheet(base_sheet)
-
-            sheet_name_pattern = output_cfg.get("sheet_name_pattern", "{index}_{funktion}")
-            raw_sheet_name = sheet_name_pattern.format(
-                index=index,
-                funktion=assignment.masterdata.funktion,
-            )
-            sheet.title = _normalize_sheet_title(raw_sheet_name, index)
-
-            _set_target_value(sheet, targets.get("antragsnummer", ""), assignment.masterdata.antragsnummer)
-            _set_target_value(sheet, targets.get("name_vorname", ""), assignment.allocation.employee_name)
-            _set_target_value(sheet, targets.get("qualifikation", ""), assignment.masterdata.qualifikation)
-            _set_target_value(sheet, targets.get("funktion", ""), assignment.masterdata.funktion)
-            _set_target_value(sheet, targets.get("taetigkeiten", ""), assignment.masterdata.taetigkeit)
-            _set_target_value(sheet, targets.get("reporting_month_label", ""), month_label)
-            _set_target_value(sheet, targets.get("foerderquote", ""), f"{assignment.foerderquote_percent:.2f} %")
-            _set_target_value(sheet, targets.get("generated_on", ""), today_label)
-
-        workbooks[employee_name] = workbook
-
-    return workbooks
-
-
-def build_output_filename(
-    filename_pattern: str,
-    employee_name: str,
-    report_year: int,
-    report_month: int,
-) -> str:
-    first_name, last_name = _split_name_for_filename(employee_name)
-    safe_first = first_name.replace(" ", "_")
-    safe_last = last_name.replace(" ", "_")
-    return filename_pattern.format(
-        year=report_year,
-        month=f"{report_month:02d}",
-        first_name=safe_first,
-        last_name=safe_last,
-    )
-
-
-def save_employee_workbooks(
-    config: dict[str, Any],
-    employee_workbooks: dict[str, Workbook],
-    report_month: int,
-    report_year: int,
-    project_root: Path,
-) -> list[Path]:
-    paths_cfg = config["paths"]
-    output_cfg = config["output"]
-    filename_pattern = output_cfg["filename_pattern"]
-
-    output_dir = project_root / paths_cfg["output_dir"]
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    saved_paths: list[Path] = []
-    used_names: set[str] = set()
-
-    for employee_name, workbook in employee_workbooks.items():
-        filename = build_output_filename(
-            filename_pattern=filename_pattern,
-            employee_name=employee_name,
-            report_year=report_year,
-            report_month=report_month,
-        )
-        if filename in used_names:
-            raise ValueError(f"Output filename collision detected: {filename}")
-
-        used_names.add(filename)
-        output_path = output_dir / filename
-        workbook.save(output_path)
-        workbook.close()
-        saved_paths.append(output_path)
-
-    return saved_paths
Author	SHA1	Message	Date
RobandClaude Opus 5.5	cb059ac20d	Geführtes Update: "Anwendung ersetzen" im Update-Hinweis Der Update-Hinweis bietet neben "Update Ordner öffnen" nun den Button "Anwendung ersetzen". Er kopiert das ZIP vom SMB-Laufwerk lokal, prüft es, entpackt es in einen eigenen Ordner neben der aktuellen Installation, übernimmt input/, output/ und eigene Templates und startet die neue EXE. Die alte Installation bleibt als Rückfallebene erhalten; eine angepasste settings.ini wird als settings.vorherige-version.ini aufbewahrt. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-03 12:55:12 +01:00
Rob	5e2fab7fd3	Template PDF erneuert. Neues und altes PDF sind nun enthalten	2026-11-03 12:15:10 +01:00
Rob	0ec5de50bb	build pipeline wartet nun darauf das das changelog aktualisiert wurde	2026-11-03 12:06:05 +01:00
Rob	fb191449d1	wording für windows angepasst	2026-11-03 11:58:53 +01:00
Rob	4e3b2237ff	Neues PDF wurde geliefert und entspechend für das Programm vorbereitet (siehe README im template folder)	2026-11-03 11:58:32 +01:00
RobandClaude Sonnet 5.5	7de6984ebc	build: alle Template-PDFs automatisch in Build und Release aufnehmen Alle *.pdf im template-Ordner werden ausgeliefert; Dateien mit '_' oder '.' am Anfang sowie andere Dateitypen werden ignoriert. Veraltete PDFs im Build-Ordner werden entfernt. Tests entsprechend angepasst. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-11-03 11:53:55 +01:00
Rob	2237779e56	add: wenn input folder leer -> hochladen von xlxs Dateien vereinfacht	2026-10-07 21:16:46 +02:00
Rob	7d63063024	build option eingefügt um zu builden ohne die version zu inkrementieren und zu deployen	2026-10-07 20:45:33 +02:00
Rob	2aad2c9d99	CI: build pipeline testet nun immer automatisch vor dem build alle Test. Ausserdem gibts einen deploy-pfad	2026-10-07 20:44:51 +02:00
Rob	971459c9bf	fix: Erkennung von bereits laufendem Server und dessen beendung. incl. Tests	2026-10-07 19:49:39 +02:00
Rob	1519b96c7b	fix: Unicode Zeichen in Windows terminal	2026-10-07 19:48:00 +02:00
Rob	eaffa78e9c	Testdaten als fixture hinterlegt	2026-10-07 19:46:36 +02:00
Rob	34730276d7	v1.3	2026-08-11 09:44:51 +02:00
Rob	c12b15e021	feat: add version check with message in app window	2026-08-11 09:37:55 +02:00
Rob	d027bedcb8	Auswählbare Mitarbeitermonate in separater Multiselektliste hinzugefügt	2026-08-10 19:37:03 +02:00
Rob	eb1dd45e57	setup README for dev and end user	2026-08-10 18:19:59 +02:00
Rob	6f1d807f3c	copy readme into build	2026-06-30 21:35:48 +02:00
Rob	635323ae50	build version v1.2.1	2026-06-30 21:31:14 +02:00
Rob	2c7d69cf78	gitignore	2026-06-30 21:30:44 +02:00
Rob	c9dac7b9b8	add build pipline	2026-06-30 21:28:28 +02:00
Rob	94e245a3a0	move the whole app in subfolder	2026-06-30 15:34:47 +02:00
Rob	fa3e99dec0	Stelle Stellenanteil dezimal dar	2026-06-30 15:05:12 +02:00
Rob	8fde588b8f	Keine Zentrierung für Tätigkeiten. Doppeltes Datum anzeigen.	2026-06-30 10:52:45 +02:00
Rob	87f8150bd3	empty tasks	2026-06-30 09:50:34 +02:00
Rob	b498af39d9	Vergrößere alle Textfelder auf das gesamte Formularfeld und zeichne Text mittig.	2026-06-30 09:50:25 +02:00
Rob	2247c42e81	use static font size over all document texts	2026-06-30 09:43:25 +02:00
Rob	23cb3c35b3	version v1.1	2026-06-24 08:38:50 +02:00
Rob	dbbd86ece0	add: changelog zum Plan	2026-06-24 08:35:31 +02:00
Rob	557f987ee1	fix konsole error message on app start	2026-06-24 08:14:54 +02:00
Rob	b084120c0d	fix: empty field: Qualifikation and Funktion	2026-06-24 08:14:29 +02:00
Rob	9f0e3cc8fc	fix: nur die erste Person hatte im Tätigkeitenfeld etwas stehen	2026-06-23 12:40:29 +02:00
Rob	932585882e	Merge branch 'pdf-as-template' # Conflicts: # template/Tätigkeitsnachweise Stellenförderung.pdf	2026-06-23 11:54:09 +02:00
Rob	3e9cd39859	unnötiges Feld entfernt	2026-06-23 11:51:00 +02:00
Rob	9bdd90c073	ouput pdf: text styling	2026-06-23 11:50:44 +02:00
Rob	e50f423304	input validierung für Qualifikationsfeld. Wenn keine Daten -> Platzhalter im template löschen	2026-06-23 11:49:54 +02:00
Rob	ef219e00ba	add; coldrun.bat	2026-06-23 11:00:36 +02:00
Rob	30f3ffaded	neues cleanes template.pdf	2026-06-23 09:58:32 +02:00
Rob	a4a678d11e	coldrun: jetzt auch mit validierung	2026-06-16 21:57:18 +02:00
Rob	7a6d35d8a1	add: leere pdf als template	2026-06-16 21:56:58 +02:00
Rob	93c31655bd	nimn Johannes Datei als xlsx template	2026-06-16 21:21:43 +02:00
trnq1ll0	169d2167e0	Kompletter Umbau in einem Rutsch auf PDF als template Grundlage	2026-06-16 20:46:45 +02:00
trnq1ll0	dbe325d305	add: ColdRun-Mode in dem automatisch ein kompletter Durchlauf stattfindet ohne GUI	2026-06-10 21:51:17 +02:00
trnq1ll0	6e541a04df	add first test tools	2026-06-10 21:27:27 +02:00
trnq1ll0	6fda6aea6b	automatisch selektieren wenn in Input- oder Template-Ordner nur ein Element/File liegt	2026-06-10 17:16:43 +02:00
trnq1ll0	9a44f8904e	Rahmen um MItarbeiterliste	2026-06-10 17:12:32 +02:00
trnq1ll0	b05849e673	fix: Stellenanteil in Prozentangabe und jeweiliges Monatsende als Datum eintragen	2026-06-10 17:03:46 +02:00
trnq1ll0	0d390f79b4	add: open generated files an folder on click	2026-06-10 16:05:19 +02:00
trnq1ll0	f4afd4b2e5	input Validierung und UI handling fühlbar beschleunigt	2026-06-10 08:33:34 +02:00
trnq1ll0	31cdc7747f	fix: input validierung überspringt erstes sheet, weil diese nur zur Übersicht ist	2026-06-10 07:59:02 +02:00
trnq1ll0	1e44aaab9d	erzeuge macos start.command	2026-06-09 10:17:14 +02:00
trnq1ll0	39d3ee8baf	template mit 36 Monaten erzeugt. Denn es werden keine sheets selber erstellt.	2026-06-09 10:14:35 +02:00
trnq1ll0	56d605c0cb	fix: es werden nun die richtigen Felder beschrieben	2026-06-09 09:33:57 +02:00
trnq1ll0	19dfc06272	add start.sh	2026-06-09 08:48:41 +02:00
trnq1ll0	044e4df783	deepseek den plan umsetzen lassen	2026-06-09 08:33:47 +02:00
trnq1ll0	6c60a72e0f	first shot plan	2026-06-08 22:56:16 +02:00
				`@@ -0,0 +1 @@`
				`"""Tätigkeitsnachweis-Generator package."""`
				`@@ -0,0 +1 @@`
				`"""Tests für den Tätigkeitsnachweis-Generator."""`