init

backend/templates/einheiten.md

@@ -0,0 +1,53 @@
+# Auftrag: Code-Ausschnitt in Einheiten zerlegen
+
+Du bekommst unten einen Ausschnitt der Datei `<DATEI>` aus einem Software-Projekt.
+Zerlege ihn in **Einheiten** und gib NUR die Einheiten-Abschnitte im unten definierten
+Format zurück — nichts davor, nichts danach, keine Code-Fences um das Gesamtergebnis.
+
+Diese Top-Level-Symbole des Ausschnitts MÜSSEN alle abgedeckt sein:
+<SYMBOLE>
+
+## Was ist eine Einheit
+
+Das Kleinste mit **eigener Verantwortung**, das sich in einem Satz beschreiben lässt —
+meist eine Funktion oder Klasse; mehrere kleine, zusammengehörige Symbole dürfen eine
+Einheit bilden (Hauptsymbol als ID, weitere je als `anker:`-Zeile). Jedes gelistete
+Symbol gehört zu genau einer Einheit (MECE).
+
+Hat der Ausschnitt KEINE def/class-Symbole (reines Skript, Konfiguration), erzeuge
+GENAU EINE Datei-Einheit mit der ID `<DATEI>` (ohne `::`) — erfinde NIE Pseudo-Symbole.
+
+## Ausgabeformat (exakt einhalten)
+
+```
+## <DATEI>::<hauptsymbol>
+beschreibung: <genau ein Satz: die Verantwortung — EINE Aufgabe, kein „und"-Katalog>
+input: <was die Einheit entgegennimmt — eine knappe Zeile>
+output: <was sie liefert bzw. bewirkt — eine knappe Zeile>
+entscheidungen:
+- <kurzer Satz: eine im Code getroffene Design-Entscheidung oder Garantie>
+  beleg: "<kurzes WÖRTLICHES Zitat aus dem Ausschnitt, das sie stützt>"
+kanten:
+- ruft-auf: <einheiten-id>
+- nutzt: <einheiten-id>
+- wird-genutzt-von: <einheiten-id>
+```
+
+Regeln:
+- `beschreibung:` genau EIN Satz, EINE Aufgabe. `input:`/`output:` sind Pflicht.
+- 2–5 Entscheidungen je Einheit: Design-Entscheidungen und Garantien, KEIN
+  Implementierungs-Nacherzählen. Jede hat GENAU EINE `beleg:`-Zeile auf eigener Zeile.
+- Der Beleg muss WÖRTLICH (Zeichen für Zeichen) im Ausschnitt vorkommen und ein
+  zusammenhängender Ausschnitt aus GENAU EINER Quellzeile sein — NIEMALS mehrere
+  Zeilen zu einer zusammenziehen. Max. ~60 Zeichen.
+- Kanten-Typen nur: `ruft-auf`, `nutzt`, `wird-genutzt-von`, `löst-aus`,
+  `wird-ausgelöst-von`. Hinter dem Ziel steht NICHTS mehr. Ziele in anderen Modulen
+  (aus Imports ableitbar) als `pfad/zur/datei.py::symbol`. Keine Kante erfinden —
+  lieber weniger als falsche.
+- Schreibe auf Deutsch.
+
+## Ausschnitt aus `<DATEI>`
+
+```python
+<QUELLE>
+```

backend/templates/nachfass.md

@@ -0,0 +1,33 @@
+# Auftrag: Fehlende Einheiten ergänzen
+
+Ein Ausschnitt der Datei `<DATEI>` wurde bereits in Einheiten zerlegt (Bestand unten).
+Die Abdeckungsprüfung meldet, dass folgende Top-Level-Symbole noch KEINER Einheit
+zugeordnet sind:
+
+<FEHLEND>
+
+Erzeuge NUR die fehlenden Einheiten-Abschnitte im selben Format wie der Bestand —
+nichts davor, nichts danach, keine Wiederholung bestehender Einheiten, keine
+Code-Fences um das Gesamtergebnis.
+
+NUR WENN ein fehlendes Symbol ein unselbstständiger Hilfssatellit einer bestehenden
+Einheit ist — es wird AUSSCHLIESSLICH vom Hauptsymbol dieser Einheit verwendet und hat
+keine eigene Verantwortung — darfst du statt einer neuen Einheit eine Zeile
+`ergaenze-anker: <DATEI>::<symbol> zu <bestehende-einheiten-id>` ausgeben.
+Im Zweifel IMMER eine eigene Einheit. Symbole mit benennbarer eigener Aufgabe
+(Exception-Klasse, Schema-Bauer, Konstante mit Bedeutung) sind IMMER eigene Einheiten.
+
+Format-Regeln wie beim Erst-Scan: `beschreibung:` (ein Satz), `input:`, `output:`,
+2–5 `entscheidungen:` mit je GENAU EINER `beleg:`-Zeile (WÖRTLICHES Zitat aus GENAU
+EINER Quellzeile, max. ~60 Zeichen), `kanten:` nur mit den bekannten Typen.
+Schreibe auf Deutsch.
+
+## Bestand (bereits zerlegte Einheiten dieses Ausschnitts)
+
+<VORHANDEN>
+
+## Ausschnitt aus `<DATEI>`
+
+```python
+<QUELLE>
+```

backend/templates/sichten-architektur.md

@@ -0,0 +1,29 @@
+# Auftrag: Architektur-Sicht aggregieren
+
+Unten stehen alle Einheiten des Projekts `<PROJEKT>` (ID + Beschreibung + Kanten).
+Aggregiere daraus die **Architektur-Sicht**: die Komponenten des Systems und ihre
+Beziehungen. Beschreibe NUR, was Einheiten und Kanten belegen.
+
+## Ausgabeformat (exakt einhalten)
+
+```
+# Architektur: <PROJEKT>
+
+## Komponente: <kurzer Name, OHNE Klammern, OHNE „und">
+beschreibung: <EIN kurzer Satz: die Verantwortung der Komponente>
+einheiten: <einheiten-id>, <einheiten-id>, …
+beziehungen:
+- nutzt: <andere Komponente (exakter Name)>
+- wird-genutzt-von: <andere Komponente (exakter Name)>
+```
+
+Regeln:
+- 3–8 Komponenten; jede Einheit gehört zu GENAU EINER Komponente (MECE).
+- Eine Beziehung nur, wenn mindestens eine Kante zwischen Einheiten der beiden
+  Komponenten sie trägt — keine Beziehung erfinden.
+- `einheiten:` nur IDs, die unten wirklich vorkommen (exakte Schreibweise).
+- Schreibe auf Deutsch. Gib NUR das Markdown aus, ohne Code-Fences drumherum.
+
+## Einheiten von `<PROJEKT>` (mit Kanten)
+
+<EINHEITEN>

backend/templates/sichten-features.md

@@ -0,0 +1,51 @@
+# Auftrag: Feature-Sicht und Kern aggregieren
+
+Unten stehen alle Einheiten des Projekts `<PROJEKT>` (ID + Ein-Satz-Beschreibung).
+Aggregiere daraus die **Feature-Sicht** (was kann das Projekt aus Betreibersicht?)
+und den **Kern** (was trägt das Projekt?). Beschreibe NUR, was die Einheiten belegen —
+erfinde nichts aus Weltwissen.
+
+WICHTIG — Zielgruppe ist die GESCHÄFTSFÜHRUNG, nicht Entwickler:
+- Beschreibe, WAS das Produkt kann und WOZU es gut ist — NIE, wie es im Code
+  umgesetzt ist.
+- Verboten: Code-Begriffe und Jargon (Funktions-/Modul-/Dateinamen, Backticks,
+  Wörter wie Präfix, Spawn, Semaphore, CLI, Cache, Payload, Thread, Lock, Registry,
+  Callback, Endpoint). Wenn du so ein Wort brauchst, beschreibe stattdessen die
+  Wirkung in Alltagssprache.
+- Titel und Sätze so, dass sie jemand ohne Programmierkenntnisse sofort versteht.
+  Beispiel: statt „Markiert einen Schlüssel-Präfix global als abgebrochen" →
+  „Laufende Arbeiten lassen sich gezielt stoppen".
+- Die `einheiten:`-Referenzzeilen bleiben unverändert technisch (exakte IDs) —
+  sie sind Maschinen-Verweise, keine Leser-Texte.
+
+## Ausgabeformat (exakt einhalten; zuerst der Kern, dann die Bereiche)
+
+```
+# Kern: <PROJEKT>
+<2-4 Sätze: wofür das Projekt existiert und was es im Kern tut>
+
+tragende-einheiten: <einheiten-id>, <einheiten-id>, …
+
+# Bereich: <kurzer Name, OHNE Klammern, OHNE „und">
+beschreibung: <EIN kurzer Satz, der den Kern des Bereichs trifft — keine Aufzählung>
+
+## Feature: <Titel OHNE „und" — genau EINE Aufgabe> [kern|rand]
+beschreibung: <EIN kurzer Satz ohne „und"-Aufzählung>
+
+### <Teilfeature: Fähigkeits-Satz aus Betreibersicht, z. B. „Kann nach Abbruch fortsetzen">
+einheiten: <einheiten-id>, <einheiten-id>
+```
+
+Regeln:
+- 3–10 Bereiche; MECE je Ebene: Bereiche zerlegen das Projekt, Features ihren Bereich,
+  Teilfeatures ihr Feature — vollständig, überschneidungsfrei.
+- Braucht ein Titel „und", mach zwei Bereiche/Features daraus.
+- `[kern]` = trägt das Projekt, `[rand]` = Komfort/Beiwerk.
+- `einheiten:` listet NUR IDs, die unten wirklich vorkommen (exakte Schreibweise);
+  jedes Teilfeature hat mindestens eine. Jede Einheit sollte in mindestens einem
+  Teilfeature auftauchen; reine interne Helfer dürfen unreferenziert bleiben.
+- Schreibe auf Deutsch. Gib NUR das Markdown aus, ohne Code-Fences drumherum.
+
+## Einheiten von `<PROJEKT>`
+
+<EINHEITEN>

backend/templates/sichten-flows.md

@@ -0,0 +1,26 @@
+# Auftrag: Flow-Sicht aggregieren
+
+Unten stehen alle Einheiten des Projekts `<PROJEKT>` (ID + Beschreibung + Kanten).
+Aggregiere daraus die **Flow-Sicht**: die wichtigsten Abläufe des Systems als
+Schrittfolgen. Beschreibe NUR Abläufe, die die Einheiten und ihre Kanten belegen.
+
+## Ausgabeformat (exakt einhalten)
+
+```
+# Flows: <PROJEKT>
+
+## Flow: <kurzer Titel des Ablaufs, OHNE „und">
+1. <Schritt in einem Satz> — <einheiten-id>
+2. <Schritt in einem Satz> — <einheiten-id>, <einheiten-id>
+```
+
+Regeln:
+- 2–6 Flows, je 3–10 Schritte; nur die tragenden Abläufe, keine Randfälle.
+- Jeder Schritt endet mit ` — ` und mindestens einer Einheiten-ID, die unten wirklich
+  vorkommt (exakte Schreibweise).
+- Die Schrittfolge muss zu den Kanten passen (wer ruft wen) — nichts erfinden.
+- Schreibe auf Deutsch. Gib NUR das Markdown aus, ohne Code-Fences drumherum.
+
+## Einheiten von `<PROJEKT>` (mit Kanten)
+
+<EINHEITEN>