Grotti 3.6.0: Lauf-Identität nach Filament-Pause, robustere Queue, Projekte/Aufträge list-first und API-Polish.

Grotti 3.5.2: Zu wenig Rest blockiert den Start nicht mehr, und ein anlaufender Druck wird nicht als Neustart neu eingereiht.
Grotti 3.5.1: MCP-Anweisung für Clients, Queue-Strip nur bei Ablauf, Start wartet auf printing.
2026-10-25 08:24:24 +01:00 · 2026-10-21 21:04:28 +02:00 · 2026-10-20 21:39:22 +02:00 · 2026-10-19 11:35:59 +02:00 · 2026-10-19 11:14:24 +02:00 · 2026-10-18 22:06:56 +02:00
167 changed files with 22698 additions and 2156 deletions
@@ -9,7 +9,7 @@ Grotti ist ein eigenständiges Repo. Alles, was das Tool betrifft, bleibt hier.

 - Sprache: Deutsch, in Oberfläche, Meldungen, Doku und Commits.
 - Jede Änderung bekommt einen Eintrag in `CHANGELOG.md` unter `[Unreleased]` (Neu, Geändert, Behoben).
- Version in `grotti/version.py` nach SemVer: Patch für Fehlerbehebung, Minor für Funktion, Major für Bruch an API oder Datenbankschema. Beim Release `[Unreleased]` in `[x.y.z] – Datum` umbenennen. Git-Tag `vX.Y.Z`.
+- **Version/`version.py` nur erhöhen, wenn der Nutzer explizit Release sagt.** Keine Zwischen-Patches von allein. Beim Release: SemVer (Patch/Minor/Major), `[Unreleased]` → `[x.y.z] – Datum`, Git-Tag `vX.Y.Z`.
 - Nutzer-Anleitung: `docs/Anleitung-*.md` unter `/doku`. Technik/Debug: `docs/internal/` — nicht in der App.
 - CSS-Version in `web/templates/layout.html` (`grotti.css?v=`) erhöhen, wenn sich `grotti.css` ändert.
 - Keine freie G-code-Konsole, kein `FIRMWARE_RESTART` (GoKlipper deadlockt). Druckstarts brauchen `confirm: true`.
@@ -2,7 +2,16 @@
 config.json
 data/

+# Slice-/Watch-Ordner: nur der Platzhalter im Git, Inhalt lokal
+slice/*
+!slice/.gitkeep
+
 .venv/
 __pycache__/
 *.pyc
 _tmp_*
+%s
+
+# gebaute .deb (Skript legt sie hier ab)
+packaging/dist/*
+!packaging/dist/.gitkeep
@@ -4,7 +4,7 @@ Grotti ist ein eigenständiges Repo. Alles, was das Tool betrifft, bleibt hier.

 - Sprache: Deutsch, in Oberfläche, Meldungen, Doku und Commits.
 - Jede Änderung bekommt einen Eintrag in `CHANGELOG.md` unter `[Unreleased]` (Neu, Geändert, Behoben).
- Version in `grotti/version.py` nach SemVer: Patch für Fehlerbehebung, Minor für Funktion, Major für Bruch an API oder Datenbankschema. Beim Release `[Unreleased]` in `[x.y.z] – Datum` umbenennen. Git-Tag `vX.Y.Z`.
+- **Version/`version.py` nur erhöhen, wenn der Nutzer explizit Release sagt.** Keine Zwischen-Patches von allein. Beim Release: SemVer (Patch/Minor/Major), `[Unreleased]` → `[x.y.z] – Datum`, Git-Tag `vX.Y.Z`.
 - Nutzer-Anleitung: `docs/Anleitung-*.md`, gerendert unter `/doku`. Technik und Debug: `docs/internal/` — erscheint **nicht** in der App (inkl. MCP.md, Anycubic-Stack, …).
 - CSS-Version in `web/templates/layout.html` (`grotti.css?v=`) erhöhen, wenn sich `grotti.css` ändert.
 - Keine freie G-code-Konsole, kein `FIRMWARE_RESTART` (GoKlipper deadlockt). Druckstarts brauchen `confirm: true`.
@@ -4,6 +4,303 @@ Alle Änderungen an Grotti. Format nach [Keep a Changelog](https://keepachangelo

 ## [Unreleased]

+## [3.6.0] – 2026-10-25
+
+### Neu
+
+- **Projekte:** Kennzahlen (Läufe, Zeit, Filament, Kosten), Tab Läufe, Einreihen / Alle einreihen, Filter Aktiv/Fertig, Deep-Link `#id`. API: `GET …/laeufe`, `POST …/einreihen`.
+- **Wand-Cockpit:** Block „Als Nächstes“ — Nochmal, Queue-Hinweis, passende Dateien (Start oder Anpassen unter Dateien).
+- **Querverlinkung:** Datei/Projekt/Spule/Auftrag/Drucker verlinkt in Protokoll, Bericht, Warteschlange, Aufträge, Material, Statistik (Projektfilter), Dateien.
+- **API für Apps:** `POST /auth/token`, QR bei Token-Erzeugung, Server-Filter für Dateien/Queue/Spulen (`limit`/`offset`, `X-Total-Count`), `?token=` für Datei-Vorschau und Assets, `/version` mit `api`/`features`, Aktions-Alias `resume`/`cancel`. Doku: `docs/internal/API.md`, `openapi.yaml`.
+- **Pi:** Umzugsanleitung Windows→Pi, Skript `scripts/pfade_umziehen.py` im `.deb`.
+- **Protokoll Verbinden:** Verdachtspaare nach Runout manuell zusammenlegen (`POST /laeufe/<id>/verbinden`). Liste zeigt Rollenwechsel, mehrere Spulen und Pausendauer.
+- **Reparatur:** `scripts/laeufe_reparieren.py` findet Alt-Paare und verwaiste Live-Läufe (Probelauf standardmäßig). Orphan-Übernahme nur bei gleicher Datei und wenn der Live-Lauf wirklich verschwindet; kein Host-Fallback auf fremde offene Drucke.
+
+### Geändert
+
+- **Projekte / Aufträge:** Liste zuerst (volle Breite); Formular und Detail nur bei Neu, Auswahl oder Bearbeiten — wie Material. Aufträge: Positionen ohne `prompt()`, Kopf-Button „Neuer Auftrag“.
+- **Layout:** `.edit-split.is-idle`, Split/Panel ab 1080px einspaltig; Pfad-Ellipsis in Tabellen; Protokoll-Hilfe einklappbar; Queue-Aktionen mit Textlabels; Jetzt-Seite zeigt „Alles erledigt“; Aktivität Drucker-Filter als Select; Statistik-Filter unter „Weitere Filter“; Nav Aufträge = Clipboard-Icon; Mobile-Mehr gruppiert.
+- **Material-Routing:** PLA ist PLA. Meta, Matte, Silk und die Marke halten die Queue nicht mehr an; liegt die genannte Sorte am Drucker, wird sie weiter bevorzugt. Ein anderer Typ (PETG statt PLA) bleibt ein Wartegrund.
+- **mcp** auf `2.0.0` gepinnt.
+- **Lauf-Identität:** Zusammenlegen nur mit Beweis (`print_duration` fortgesetzt + Lücke ≤ 5 s, oder Watcher „druckt weiter“). Leere History-Hüllen werden nicht gespeichert. `sync_history` unter Advisory-Lock; Abzug atomar. Doku: `docs/internal/Lauf-Identitaet.md`.
+- **Queue `print_active`:** Nur `complete` = fertig. `cancelled`/`standby` werden entprellt; echter Abbruch heißt „Druck abgebrochen“, nicht „Fertig.“. Kein Auto-Retry nach Abbruch. Worker respektiert Abbruch während Upload. `print_queue.run_id` + höchstens ein `running` pro Host.
+- **Wand Runout:** Hinweis nennt ACE-Platz und verlinkt Material mit vorausgefülltem Drucker/Platz.
+- **Live-UI:** SSE `queue`/`drucker` aktualisiert Warteschlange und Protokoll.
+
+### Behoben
+
+- **Legacy-Kameras-Seite:** totes Template entfernt (Route leitete schon auf die Wand um).
+- **Laufende Charge bleibt am History-Job:** Kommt die Moonraker-Job-ID, übernimmt dieser Lauf die Nummer. Sie fällt nicht weg, nur weil der Druck noch läuft.
+- **Alte History-Jobs verbrauchen die Charge von heute:** Eine Filament-Pause öffnet eine zweite Job-ID. Bleibt die ohne Ende und ohne Dauer in der History stehen, hing Grotti sie als neuen Druck an den heutigen Tag und buchte das Filament noch einmal ab. Die Job-ID bleibt am ursprünglichen Lauf, eine leere Hülle überschreibt ihn nicht, und die Charge trägt das Startdatum des Drucks.
+- **Kontaktverlust spaltet den Druck:** Zwei fehlende Polls melden den Drucker offline, lassen den Lauf aber offen und ziehen nichts ab. Dieselbe Charge läuft weiter, wenn derselbe Auftrag wieder da ist. Erst fertig, Abbruch, Fehler oder ein anderer Auftrag schließt den Lauf.
+- **Queue bleibt auf „Druckstart kann eine Minute dauern“, während der Drucker längst druckt:** Der Abschluss hat `await_print` erst geprüft, wenn der Drucker wieder frei war, und den laufenden Druck dann als Start-Timeout gewertet.
+- **Strombericht ohne Düse/Bett nach Pause:** Beim Zusammenlegen zweier History-Jobs bleiben Temperatur- und ED-Proben am Lauf. Vorher wurden die Proben des Folgejobs gelöscht, der Bericht fiel auf die Grundlast zurück.
+- **Filament-Pause spaltet das Protokoll:** Setzt Anycubic nach dem Fortsetzen eine neue History-Job-ID, bleibt es ein Lauf. Der Abbruch-Teil wird nicht noch einmal als ganzer Druck abgezogen.
+- **Materialwechsel öffnet trotzdem einen zweiten Auftrag:** Moonraker liefert die History neueste zuerst. Die Fortsetzung kam vor dem abgebrochenen Teil an die Reihe, fand keinen Vorgänger und wurde ein eigener Lauf; der alte Teil wurde als Abbruch abgezogen. Der Abgleich geht jetzt pro Drucker von alt nach neu. Eine eingeklappte Job-ID setzt den laufenden Druck nicht mehr auf „Abgebrochen“ zurück, und der zusammengelegte Lauf hat kein Ende, solange er druckt.
+- **Fertig vor History bucht doppelt:** Live-Lauf wird geschlossen ohne Abzug; History bucht. Fallback nach 10 min ohne History.
+- **Abbruch + schnelles Nochmal:** Frischer Neustart (Dauer nahe 0) wird nicht mehr als Filament-Fortsetzung zusammengelegt.
+- **Alter Lauf auf der neuen Spule:** Der History-Abgleich zieht einen Druck nur von Rollen ab, die vor dem Druckende schon existierten. Die Rolle, die gerade im ACE liegt, bekommt keine alten Jobs.
+- **Projektfilter leer neben „Wurzel“:** Ein gewähltes Projekt hebt den Ordnerfilter „Wurzel“ auf. Ein Ordner zeigt auch die Dateien in seinen Unterordnern.
+
+## [3.5.2] – 2026-10-21
+
+### Geändert
+
+- **Wenig Rest:** ACE oder Spule unter dem Dateigewicht warnt unter Dateien, bricht Start und Warteschlange nicht mehr ab. Falsche Sorte bleibt ein Wartegrund.
+
+### Behoben
+
+- **Queue „Nochmal — Start abgebrochen (Neustart)“ während der Drucker anläuft:** Nach dem Upload bleibt der Auftrag in `await_print`, bis Moonraker druckt. Die 45-Sekunden-Regel gilt nur noch, wenn der Upload-Thread weg ist. Wand und Seitenleiste zeigen „startet“ und dass es etwa eine Minute dauern kann.
+
+## [3.5.1] – 2026-10-20
+
+### Geändert
+
+- **MCP:** Server-Anweisung für Clients (Ablauf, confirm, Filament-Pause, Platten-Quittung, kein G-code), damit der Agent die Tools in der richtigen Reihenfolge nutzt.
+- **Wand:** „Aus der Warteschlange“-Strip nur noch bei Ablauf (mit Schritten); einfacher Queue-Druck zeigt nur DRUCKT.
+
+### Behoben
+
+- **Queue zu früh „Fertig.“:** Nach Start bleibt Phase `starting`, bis Moonraker `printing` meldet — alter `complete`/`standby` schließt den Job nicht mehr.
+
+## [3.5.0] – 2026-10-19
+
+### Neu
+
+- **Doku:** interne Makro-Referenz `docs/internal/Makros-Kobra.md` (Nicht-tun, Vanilla-Klipper-Alltag, ACE, LeviQ/Wipe für S1 und K3).
+- **Pagination:** Dateien, Protokoll, Material, Aufträge, Warteschlange, Aktivität, Projekte — max. 40 Zeilen pro Seite (Zurück/Weiter).
+- **Logging:** `log_level` in der Config; Kernpfade schreiben nach stdout (unter systemd → `journalctl -u grotti`).
+- **Debian-Paket:** `packaging/build-deb.sh` baut `.deb` mit venv, systemd-Unit und PostgreSQL-`postinst` (Peer-Auth). Anleitung: `docs/Anleitung-Installation-Pi.md`.
+
+### Geändert
+
+- **Config:** `GROTTI_CONFIG` bzw. `/etc/grotti/config.json` für Paket-Install; sonst Repo-`config.json`.
+- **README:** Banner, Badges, Feature-Übersicht und Community-Screenshots oben; Setup/API darunter; Pi-`.deb`-Hinweis.
+
+### Behoben
+
+- **Queue „braucht Eryone PLA Lite“ trotz PLA-Spule:** Basis-Profil (ohne Meta/Matte/Silk) matcht nach Typ; Slice-Hex-Farbe (`#26A69A`) blockiert Lagerfarbe „Grau“ nicht mehr.
+- **Dateien Info-Popup:** Details-Popup wird nicht mehr vom Bibliothek-Scroll abgeschnitten; Position fixed mit Flip nach oben, besserer Kontrast.
+
+## [3.4.0] – 2026-10-18
+
+### Neu
+
+- **Dateien:** Umbenennen in der Bibliothek (Stift-Icon; Endung bleibt erhalten).
+
+### Behoben
+
+- **Queue „druckt schon“ bei Folgejobs:** Einfach-Druck bleibt `running` bis Moonraker fertig — nicht mehr sofort `done` nach Start (sonst startete der nächste Job zu früh).
+- **Bedarf „443 g fehlen“ trotz voller Spulen:** Slice-Farbe `#26A69A` matchte nicht Lagerfarbe „Grau“ → Rest 0. Bei Hex-Farbe zählt jetzt der Rest gleicher Sorte; archivierte Spulen nicht.
+- **Falsches „Material nachlegen“ bei manueller Pause:** Anycubic meldet `active_filament.empty=true` auch ohne Runout (`tool`/`gate` = −1). Heuristik nur noch bei Meldung/`reason_for_pause`/10107, aktivem Tool + differenziertem `gate_status`, oder G-code-Store.
+- **gklib 10111 nach Einfarbig-Upload:** Orca-Zeile `; filament_colour_type` wird beim Senden entfernt (nur Einfarbig; Multicolor unangetastet).
+- **Protokoll „druckt“ nach Offline:** Live-Läufe werden bei anhaltendem Offline als `interrupted` geschlossen (z. B. gklib-Shutdown).
+- **Sorte „Sunlu PLA“ vs. Eryone PLA:** Basis-Profil ohne Meta/Matte/Silk matcht nach Material-Typ (Marke egal); Varianten bleiben streng.
+
+## [3.3.0] – 2026-10-18
+
+### Neu
+
+- **Projekte** `/projekte`: Arbeitsmappe mit Ordner unter dem Slice-Pfad (`projects.folder`); G-code-Zuordnung per Sync; Upload weiterer Dateien (STEP/STL/PDF/…); Nav unter Verwalten.
+- **Dateien:** Uploads in Slice-Ordner verschieben (werden Watch); Löschen für Upload und Watch (nur unter Slice/`eingang`); kompaktere Bibliothek-Filter.
+- **Material:** Filter Sorte/Farbe; leere/archivierte Spulen ausgeblendet (Filter **Archiv**); Buttons **Leer**, **Archivieren**, **Wiederherstellen** (`archived_at`).
+- **Wand:** kleines Kamera-Snapshot-Thumb auf jeder Karte (nie Stream); Menüpunkt Kameras entfernt, `/kameras` → Wand.
+
+### Geändert
+
+- **Technik-Cockpit:** kompakte Fact-Chips; Steuerung in Gruppen Heizung / Druck / ACE-Plätze.
+- **Protokoll:** kurze Dateinamen, festere Spaltenbreiten.
+- **Statistik:** kompakte Filter inkl. Farbe, Auto-Laden, KPI Primär/Sekundär.
+- **Orca-Login:** Session 30 Tage (überlebt App-Fenster schließen); kein zweites Chrome mit demselben Profil (sonst erneutes Anmelden).
+- **Druckbericht:** Kosten-Torte und Tabelle inkl. Filament (nicht nur Strom); Summe = Material + Energie.
+- **Dateien:** Starten / Einreihen / Ablauf mit einem Klick (kein Zwei-Klick mehr). API weiter mit `confirm: true`.
+- **Senden:** Zwei Start-Modi statt drei — **Dieser Drucker** (frei → sofort, sonst Warteschlange) und **Nächster passender** (Grotti wählt nach Sorte).
+- **Material-Routing:** Match auf Katalog-Sorte aus Orca-`filament_settings_id` (PLA Meta ≠ Matte ≠ Silk); falsche Variante wartet mit Grund. Farbe bleibt soft. Bei Auto-Wahl baut Grotti die ACE-Map aus den Spulen am Claim-Drucker. Bestehende Dateien: **Dateien neu lesen**.
+- **Wand:** Bei Filament-Pause Hinweis, die neue Rolle unter Material dem Drucker zuzuweisen — sonst zählt der Verbrauch weiter zur alten Spule.
+- Anleitung Material/ACE: Rollenwechsel während Pause klargestellt.
+
+### Behoben
+
+- **Orca/Anycubic öffnet zwei Browserfenster:** Nachbearbeitung läuft oft 2× — Debounce (~25 s) öffnet nur noch eines. Deep-Link lädt fehlende `paint_index` nach (ACE zeigt sonst fälschlich T0/T1).
+- **Dateien-Tab hängt nach Orca:** 3D-Pfad erst nach ACE/Senden (Idle); Debounce ignoriert Anycubic-Zeitstempel im Dateinamen; erneuter Export aktualisiert den offenen Tab statt ein zweites Fenster.
+- **Orca/Anycubic → Desktop-Fenster:** `orca_senden` öffnet Grotti als Chrome/Edge-App (`browser: app`). Anycubic-Dialog nur vermeiden durch **G-code exportieren**, nicht Remote Print / Aufgabe starten.
+- Anleitung Orca: Grotti unter **Gerät** per Device-UI-URL (`http://127.0.0.1:8770/`); Upload-zum-Host weiter meiden.
+- **ACE-Map mit Lücken-T (Bambu/Anycubic):** UI behält Slicer-`Tn` (z. B. T1+T10). Beim Senden verdichtet Grotti auf T0…n und schreibt passende `.acm` — sonst gklib **10011700 invalid filament id** bzw. Hang bei Map-Mismatch. Senden prüft Map gegen T-Befehle. Bestehende Dateien: **Dateien neu lesen**.
+- **10011700 trotz dichter UI-Map:** Verdichtung hängt am G-code (`T1`/`T10`), nicht daran, ob die Map schon 0/1 zeigt — sonst blieb T10 auf dem Drucker. Grotti neu starten, Clip erneut senden.
+- **Abräumen ließ Lauf offen:** Urteil und Platte waren quittiert, der Live-Lauf blieb `in_progress` (Moonraker-History oft ohne Endzeit). Abräumen und Watcher (`printing`→`complete`) schließen den Lauf jetzt als `completed` inkl. Materialabzug.
+- **Rollenwechsel während Pause:** Einlegen hängt Abschnitte/Ereignisse auch an offene History-Jobs (nicht nur `live:`). Send-Spule und Lauf-Spule werden mitgezogen; Abzug bevorzugt die Rolle am Drucker statt eines veralteten Send-Hints.
+
+## [3.2.0] – 2026-10-18
+
+### Neu
+
+- **Jetzt-Liste** / Topbar-Chips / Mobile-Tab `/jetzt`: Platte räumen, Queue-Fehler, Bedarf, Wartung, Aufträge, Material-Wartegründe; Farm-ETA; Filament-Pause → „Material nachlegen“.
+- **`GET /api/v1/jetzt`**, **`GET /api/v1/prognose`**, **`GET /api/v1/suche`** (Ctrl+K).
+- **Filament-Pause:** Pause + ACE/`mmu`/Runout-Hinweis → Event `spule`, Jetzt-Eintrag, Alert.
+- **Druckbericht:** Strom-Aufschlüsselung (Grundlast / Düse / Bett / Trockner) mit Tortendiagramm.
+- **Material-Routing:** „Nächster freier“ bevorzugt passende Rolle/Farbe/Rest; sonst Wartegrund in der Queue.
+- **Termine** (`due_at`) sortieren die Warteschlange vor der Priorität.
+- **Auto-Retry** (einmal, Einstellung) bei Queue-/Ablauf-Fehler.
+- **Gleich nochmal drucken** im Abräumen-Dialog.
+- **Tagesbericht** 7 Uhr (Telegram/ntfy) und Push bei Wartung fällig, Bedarf, Auftrag überfällig.
+- **Kosten pro Teil** und Stück-Yield in Bericht, Auftrag und Statistik.
+- **Undo-Toast** beim Entfernen aus der Warteschlange; **Ctrl+K**-Suche.
+- **Design-Polish:** Lucide-Icons (`icons.svg`), Schrift Inter, Tokens/Komponenten; Topbar und Sidebar-Gruppen.
+- **Kamera-Stream:** Snapshot oder MJPEG in Einstellungen und auf der Kameras-Seite.
+- **Community-Screenshots** unter `docs/community/`.
+- Einstellungen: Abschnitts-Navigation, Autosave, Drucker als Karten mit Dialog.
+- Cockpit: Alltag oben, **Technik**-Fold (Steuerung, Verlauf, 3D, Bettnetz) standardmäßig zu.
+
+### Geändert
+
+- **Live-Status** in der Topbar (Chips + Popover); Mobile-Tab **Jetzt**.
+- **PA12-CF** in Grotti als PA12-CF; am ACE als PA6-CF (ACE kennt den Typ nicht).
+- Falsche Sorte warnt in Dateien, hält die Queue nicht an; zu wenig Rest blockiert weiter.
+- Alert-Hygiene: `spule`/`start`/`auth` quiet; Sidebar-Label „Meldungen“.
+- Status als Chip; Einstellungen-Nav mit Icons; Autosave; Light-Theme; `tabular-nums`.
+- Begriffe: Queue-Eintrag = Druck; Empty-States mit Handlung; Primär-/Danger-Buttons.
+- Cool-Park blockiert den Queue-Tick nicht mehr (Worker).
+- Kunden und Positionen bearbeiten/löschen unter Aufträge.
+- `projekte.html` / `ideen.html` entfernt (Redirect bleibt).
+
+### Behoben
+
+- **Bedarf/Wartung/Auftrag-Spam:** Ops-Alerts Dedup-Art und Event-`kind` stimmten nicht überein (jede Minute derselbe Hinweis).
+- **Platte belegt nach Neustart:** Watcher setzte bereits Quittiertes wieder auf `needs_clear`.
+- **„Pausiert“ nach Abbruch/Offline:** Live-Lauf blieb offen bei Offline→standby.
+- **Regal-Modus:** Sidebar-Menü unter Desktop-Breite ausgeblendet.
+
+## [3.1.0] – 2026-10-18
+
+### Neu
+
+- **Bedarf in der UI:** Sidebar-Warnung, Karte unter Material, Chip in der Warteschlange.
+- **Start-Zeitfenster** je Drucker in den Einstellungen (Queue nur im Fenster).
+- **HT/NT-Tarif** in den Energie-Einstellungen.
+- **ntfy-Test** wie bei Telegram.
+- **Helles Theme** (Dunkel / Hell / System) pro Browser.
+- Statistik: Balkendiagramme Druckzeit/Verbrauch, Empty-State ohne Daten.
+- Wartung: KPIs, Empty-State, Reset mit Bestätigung (`armButton`).
+
+### Geändert
+
+- Cockpit und Warteschlange nutzen SSE/`createPoller` statt hartem 5‑s-Intervall.
+- Shared-`config.token` wird nicht mehr als Auth akzeptiert — nur noch Session und `grt_…`-Tokens.
+- Legacy-Alias `GET /api/drucker` entfernt (nur `/api/v1/drucker`).
+
+### Behoben
+
+- SSE unter waitress: Hop-by-Hop-Header `Connection` entfernt (sonst Fehler auf `/api/v1/stream`).
+- Bedarf: Material/Farbe aus `files.filaments` statt nicht existierender Spalten.
+- Chrome: Service-Worker lieferte bei Fehlern die Startseite statt der angeklickten Route; „Mehr“-Dialog blockierte die Navigation; SSE und Poller liefen parallel und stauten Verbindungen.
+
+## [3.0.0] – 2026-10-18
+
+Major: neue Tabellen (Aufträge, Wartung), Projekte/Ideen → Aufträge, Navigation umgebaut, Dev-Server → waitress, Schema über Migrationen.
+
+**Vor dem Update:** `pg_dump` der Datenbank. Danach Grotti starten (Migrationen 003–009 laufen automatisch).
+
+### Neu
+
+- **Aufträge:** Kunden, Positionen (Datei × Menge), Fortschritt, Einreihen, Lieferschein; Migration aus Projekten/Ideen; API `/api/v1/kunden`, `/api/v1/auftraege`; MCP-Lesetools.
+- **Ausschuss-Pflicht:** Dialog beim „Platte geräumt“ (Urteil, Grund, Stückzahlen).
+- **Wartung:** Laufzähler und Verschleißteile, Seite `/wartung`.
+- **Bedarf:** Queue vs. Spulenrest (`GET /api/v1/bedarf`).
+- **ntfy** neben Telegram; **Backup**-ZIP (pg_dump + data/); **Zeitfenster** je Drucker; optional HT/NT-Tarif.
+- **SSE** Live-Stream `/api/v1/stream`, Verbindungsbanner, PWA-Manifest/Service-Worker.
+- Migrationen unter `grotti/migrations/`, Connection-Pool, Indizes, Sample-Retention.
+- Mobile-Nav mit „Mehr“-Sheet; Anleitungen Aufträge und Wartung.
+
+### Geändert
+
+- Server: waitress; Threads starten in `server.main()`.
+- Navigation: Aufträge statt Projekte/Ideen; Wartung; Dateien-/Statistik-Icons.
+- Kontrast `--faint`, `prefers-reduced-motion`, Touch-Ziele, Print-CSS.
+- Upload-Whitelist, Host-Validierung, ProxyFix, Settings-Lock, `?token=` nur Bilder.
+- Spulenabzug History ohne blinde Rate; Chargen-Locks; MCP `temp`/`percent`.
+
+### Behoben
+
+- Hängende Queue-Starts nach Neustart; Worker-Rollback; `snapshot()`-Exceptions.
+- Toast-Dedupe; ACE-Map bei Send-Vorbereitung; Spulenwarnung mit ACE.
+
+## [2.10.0] – 2026-10-18
+
+### Neu
+
+- Einstellungen: Slice-Ordner (`watch_dir`) setzen; Repo-Ordner `slice/` als Standard (Inhalt gitignored).
+- Orca-Nachbearbeitung: `scripts/orca_senden.py` lädt den Export nach Grotti und öffnet `/dateien?file=…` (Drucker, ACE, Einreihen in der UI); Anleitung unter Doku.
+- Bibliothek: Ordner unter dem Slice-Pfad anlegen und Watch-Dateien verschieben (ID/Projekt bleiben); API `…/dateien/ordner`, `…/verschieben`.
+- Bibliothek: Filter Material und Ordner, Sortierung (Neueste / Name / Material / Ordner / Druckzeit / Gewicht), Suche auch in Material und Projekt; Filter bleiben im Browser; Gruppenköpfe bei Sort Material/Ordner.
+- Cockpit: Verlauf (Temp/ED) des aktuellen oder letzten Drucks, Link zum Bericht; gemeinsame Chart-Hilfe in `api.js`.
+- Druckbericht-Verlauf: Zeitachse (links °C, rechts ED %), gestrichelte Soll-Linien, Einschaltdauer Düse/Bett; Aufheizen wird dichter erfasst.
+- Stromschätzung aus ED: Einstellungen → Düse-/Bett-Watt; Bericht zeigt kWh (ED oder pauschal).
+- Einstellungen → Dieser Browser: Zeitzone für Anzeigezeiten (Browser automatisch oder z. B. Europe/Berlin).
+
+### Geändert
+
+- Energie-Defaults: Grundlast 40 W (Elektronik), Düse 60 W, Bett 220 W; Hinweis in den Einstellungen, wenn Düse/Bett 0 (nur pauschal).
+- Druckbericht: Start/Ende als lesbare Ortszeit (`17.10.2026, 15:09 – 15:46`) statt ISO.
+- Sidebar **Läuft jetzt**: eine Zeile pro Drucker (Name · % · Fertig-Uhr), Fortschritt in der Zeile; Klick öffnet die Warteschlange, × bricht ab.
+- Spulenakte: KPI-Kacheln statt Fließtext; Druckzeilen mit Datum, Charge `D-…`, Kurzname, Gramm und Status.
+- Material-Spulenformular: Marke, Chargen und Technik unter „Weitere Angaben“ eingeklappt.
+- Druck-Etikett: „Soll … g“ statt „Ziel“ (Slicer-Filamentmenge, wie im Bericht).
+- Tasten-Grenze im Ablauf: dokumentierter Default 3 mm (kalt an der Düse sonst Fehlalarm); Anleitung und Technik-Notiz angepasst.
+- `requirements.txt` mit festen Versionen; `requirements-dev.txt` mit pytest.
+- Unbenutzte Helfer entfernt (`printers.load_printers`, Mesh-Vergleich 3×3, `fetch_bed_mesh`, `last_sample_at`, …).
+
+### Behoben
+
+- Druckbericht: Objekt-Etiketten kollidieren nicht mehr, wenn dieselbe Chargennummer schon an einem anderen Lauf hängt (Seite `/protokoll/<id>` lieferte 500).
+- Orca-Nachbearbeitung: Export unter dem Slice-Ordner (inkl. Unterordner) wird als Watch-Datei übernommen statt flachem Upload; Temp-Dateien `.gcode.pp` erkannt.
+- Material: Rest-Gramm im Spulenformular akzeptiert Dezimalwerte (Abzug lieferte z. B. 501,34 g — Browser blockierte bei `step=1`).
+
+
+## [2.5.1] – 2026-10-17
+
+### Neu
+
+- Cockpit-Steuerung: ACE-Trockner starten/stoppen (Temp, Dauer), nur wenn ein ACE hängt.
+- Cockpit-Steuerung: bestückte ACE-Plätze mit Sorte und Farbe aus Grotti an den Drucker schreiben.
+- Wand-Kacheln zeigen das Druck-Vorschaubild (Moonraker-Thumbnail) in der Job-Zeile.
+- **Druckbericht** `/protokoll/<id>`: Soll/Ist-Gramm, Spulenanteile, Temperaturverlauf, Ereignisse, Charge.
+- **Statistik** `/statistik`: Auslastung, Erfolg, Verbrauch, Ausschuss, Schätztreue; CSV-Export.
+- Spulenakte unter Material: verdruckte Gramm, Ausschuss, Leer-in aus dem Wochenverbrauch.
+- Etiketten pro Druck oder Objekt (`D-YYYYMMDD-nnnn`), QR auf den Bericht; Scan von `D-…` öffnet den Bericht.
+- Spulenabzug nach Ist (`filament_used`); Abbruch nur anteilig; Mehrfarb-Anteile als Schätzwert; Rest darf ins Minus.
+- Rollenwechsel während Druck/Pause (Einlegen) teilt den Verbrauch in Abschnitte.
+
+### Geändert
+
+- Statistik: Zeitraum per Knopf (Tag, Woche, Monat, Gestern, Letzte Woche, Letzter Monat, Alles); Bis-Datum zählt inklusiv; CSV übernimmt denselben Filter.
+- Druck-Charge `D-…` wieder während des Laufs (Protokoll, Wand-Etikett, Bericht); Adoption übernimmt die Nummer auf den History-Job. Ausschuss: gedruckte Bögen verwerfen, Charge bleibt.
+- Dateien → ACE-Zuordnung: Platz-Dropdown zeigt bei bekannter Spule Material, Farbe, Name und Restgramm.
+
+### Behoben
+
+- Spulenakte blieb leer: Abzug schrieb oft kein `run_spools` (hängende History-Läufe, Abzug vor Akte-Tabelle); Nachzug ohne erneuten Rest-Abzug, Abzug schreibt `run_spools` vor `deducted`.
+- Protokoll: keine Doppel-„druckt“-Zeilen mehr (Live + History); Watcher hängt am History-Job, sobald Moonraker ihn kennt; Liste blendet überzählige Live-Zeilen aus.
+- Platte geräumt: `needs_clear` nach Watcher-Ende und History-Sync (nur wenn kein Live-Druck); neuer Druckstart bricht alte Live-Läufe ab.
+- Druck-Etikett: Material schon während des Laufs (Send/ACE/Spule); QR bleibt im 70‑mm-Bogen.
+- Druckstart: Dateien mit altem `stored_path` (z. B. nach Umzug von `3DP/…/Uebersicht` nach Grotti) werden unter `data/eingang/<name>` wiedergefunden statt „liegt nicht mehr auf der Platte“.
+- Wand/Sidebar: Dateiname springt nicht mehr alle paar Sekunden, wenn Moonraker kurz keinen Namen liefert; 3D-Pfad-Caption flackert nicht mehr mit „wird gelesen …“.
+- Dateien: Hinweis zu fehlendem ACE-Trailer nur noch bei Mehrfarb (nicht als Warnung bei Monoteilen).
+- 3D-Pfad wirkte gesprenkelt: Ausdünnen behält ganze Schichten dicht (statt Stichproben entlang der Bahn); keine Parallel-Offsets.
+- Toolpath-API mit `Cache-Control: no-store`, damit der Browser keinen alten Pfad behält.
+- Senden: Dateinamen mit Nicht-ASCII (z. B. CJK) werden für Moonraker/Rinkhals auf ASCII normalisiert — sonst Fehler 10115 „gcode … not found“.
+
+## [2.2.2] – 2026-10-15
+
+### Behoben
+
+- 3D-Pfad: bei großen G-codes zerbrach das Ausdünnen die Segment-Paare — Viewer zeigte nur Objekt-Umrisse, keinen Druckfortschritt (grün/grau).
+
+## [2.2.1] – 2026-10-15
+
+### Geändert
+
+- Anleitungen mit relativen Bild- und Kapitelpfaden (`../web/static/doku/…`, `Anleitung-*.md`), damit Screenshots und Querverweise auch auf Git lesbar sind; die App schreibt sie beim Rendern auf `/static/…` bzw. `/doku/…` um.
+
 ## [2.2.0] – 2026-10-15

 ### Neu
@@ -1,108 +1,156 @@
-# Grotti
+<p align="center">
+  <img src="docs/brand/readme-banner.png" alt="Grotti" width="720">
+</p>

-Steuert die 3D-Drucker im Haus von einer Weboberfläche aus: Live-Zustand, Dateien senden, Warteschlange, Abläufe für den Kobra 3 (drucken, abkühlen, abschieben, prüfen), Material, Projekte und ein Protokoll, was wann passiert ist.
+<p align="center">
+  <strong>Farm-Manager für Moonraker-Drucker</strong><br>
+  Eine Oberfläche für die ganze Farm: Wand, Warteschlange, Material, Abläufe und Protokoll.<br>
+  <em>Benannt nach der Mühle Grotti — sie mahlt ohne Pause, was man ihr aufträgt.</em>
+</p>

-Der Name kommt von der Mühle Grotti: sie mahlt ohne Pause, was man ihr aufträgt.
+<p align="center">
+  <a href="https://git.gundel.dev/dg/grotti"><img src="https://img.shields.io/badge/Version-3.6.0-e85d04?style=flat-square" alt="Version 3.6.0"></a>
+  <img src="https://img.shields.io/badge/Python-3.11+-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python 3.11+">
+  <img src="https://img.shields.io/badge/PostgreSQL-14+-4169E1?style=flat-square&logo=postgresql&logoColor=white" alt="PostgreSQL">
+  <img src="https://img.shields.io/badge/Moonraker-Klipper-2ecc71?style=flat-square" alt="Moonraker">
+  <img src="https://img.shields.io/badge/UI-Deutsch-111827?style=flat-square" alt="UI Deutsch">
+  <img src="https://img.shields.io/badge/Self--hosted-lokal-6b7280?style=flat-square" alt="Self-hosted">
+</p>

-Die Drucker laufen mit Rinkhals (Kobra 3, Kobra S1). Grotti spricht sie über Moonraker an.
+<p align="center">
+  <a href="#features">Features</a> ·
+  <a href="#screenshots">Screenshots</a> ·
+  <a href="#schnellstart">Schnellstart</a> ·
+  <a href="#api">API</a> ·
+  <a href="CHANGELOG.md">Changelog</a> ·
+  <a href="docs/community/README.md">Community</a>
+</p>

-Aktuelle Version: siehe `grotti/version.py`, Änderungen in [CHANGELOG.md](CHANGELOG.md).
+---

-## Voraussetzungen
+<p align="center">
+  <img src="docs/community/01-druckerwand.png" alt="Druckerwand" width="900">
+</p>

- Python 3.11
- PostgreSQL (eine leere Datenbank `grotti` reicht, das Schema legt Grotti selbst an)
- Drucker im selben Netz mit Moonraker auf Port 80
+## Features

-## Einrichten
+| | |
+| --- | --- |
+| **Druckerwand & Cockpit** | Live-Status, Temps, Pause/Cancel, Farm-ETA |
+| **Warteschlange** | Priorität, „nächster freier“, Material-Match, ACE-Map |
+| **Dateien & Projekte** | Slice-Watch, Senden, Umbenennen, Projektordner |
+| **Kobra-3-Ablauf** | Druck → Abkühlen → Schieben → Tasten |
+| **Material** | Spulen, Restgewicht, Bedarf, Chargen |
+| **Aufträge & Statistik** | Kunden, Lieferschein, Kosten (€ Material+Strom) |
+| **Betrieb** | Auth (Session/`grt_…`), Telegram/ntfy, PWA |
+
+Stack: **Python · Flask · PostgreSQL · Moonraker** (Rinkhals auf Kobra 3 / S1).
+
+## Screenshots
+
+<p align="center">
+  <img src="docs/community/06-jetzt.png" alt="Jetzt-Liste" width="440">
+  &nbsp;
+  <img src="docs/community/02-warteschlange.png" alt="Warteschlange" width="440">
+</p>
+<p align="center">
+  <img src="docs/community/09-dateien.png" alt="Dateien" width="440">
+  &nbsp;
+  <img src="docs/community/03-material.png" alt="Material" width="440">
+</p>
+<p align="center">
+  <img src="docs/community/05-statistik.png" alt="Statistik" width="440">
+  &nbsp;
+  <img src="docs/community/07-cockpit.png" alt="Cockpit" width="440">
+</p>
+
+Weitere Bilder und Post-Text: [`docs/community/`](docs/community/README.md).
+
+## Schnellstart
+
+**Voraussetzungen:** Python 3.11, PostgreSQL (leere DB `grotti`), Drucker mit Moonraker im LAN.

 ```powershell
 cd D:\Projekte\Grotti
 python -m venv .venv
 .\.venv\Scripts\pip install -r requirements.txt
 copy config.example.json config.json
-```
-
-`config.json` anpassen:
-
-| Schlüssel | Bedeutung |
-| --- | --- |
-| `host`, `port` | Wo die Oberfläche lauscht. Standard `127.0.0.1:8770`. |
-| `database_url` | PostgreSQL-Verbindung. |
-| `data_dir` | Uploads, Vorschaubilder, Cache. Standard `data`. |
-| `watch_dir` | Slice-Ordner, der beobachtet wird. Leer = nur Upload. |
-| `token` | Wenn gesetzt, braucht die API `Authorization: Bearer <token>`. |
-| `fqdn` | Öffentliche Basis-URL für Spulen-Etiketten-QR. Leer = Request-Host. |
-| `energy` | Watt und Strompreis für die Kosten im Protokoll. |
-| `telegram`, `alerts` | Bot und welche Ereignisse als Nachricht kommen. |
-| `auto_queue` | Wenn `false`, startet die Warteschlange nichts Neues. |
-
-Die Drucker stehen beim ersten Start in `drucker.json` und landen dann in der Datenbank. Danach werden sie unter Einstellungen gepflegt.
-
-```json
-[{ "name": "Kobra 3 da26", "host": "10.10.1.60" }]
-```
-
-Die Familie (Kobra 3 oder S1) liest Grotti aus dem Namen.
-
-## Starten
-
-```powershell
 .\.venv\Scripts\python.exe server.py
 ```

-Dann <http://127.0.0.1:8770/> öffnen. Bedienungsanleitung mit Screenshots in der Oberfläche unter **Doku** (Kapitel `Anleitung-*`), Technik-Notizen darunter.
+Dann <http://127.0.0.1:8770/>. Bedienung unter **Doku** in der App (`docs/Anleitung-*.md`).

-`config.json` und `data/` sind lokal und nicht im Git.
+### Raspberry Pi (`.deb`)
+
+Auf dem Pi (arm64 / Bookworm) bauen und installieren — PostgreSQL und systemd-Dienst werden mit eingerichtet:
+
+```bash
+bash packaging/build-deb.sh
+sudo apt install ./packaging/dist/grotti_*_arm64.deb
+journalctl -u grotti -f
+```
+
+Details: [docs/Anleitung-Installation-Pi.md](docs/Anleitung-Installation-Pi.md). Öffentliches apt-Repo folgt später.
+
+`config.json` und `data/` bleiben lokal (nicht im Git). Drucker zuerst in `drucker.json`, danach unter Einstellungen.
+
+| Schlüssel | Bedeutung |
+| --- | --- |
+| `host`, `port` | Oberfläche (Standard `127.0.0.1:8770`) |
+| `database_url` | PostgreSQL |
+| `watch_dir` | Slice-Ordner (oder leer = nur Upload) |
+| `energy` / `telegram` / `alerts` | Kosten und Benachrichtigungen |
+
+Schema-Migrationen laufen beim Start (`grotti/migrations/`). Vor Major-Updates: `pg_dump`.

 ## Ordner

 | Pfad | Inhalt |
 | --- | --- |
-| `server.py` | Start, Datenbank vorbereiten, Hintergrund-Threads |
-| `grotti/` | Kern: Moonraker, Warteschlange (`print_queue.py`), Senden (`send_queue.py`), Abräumen (`eject.py`), Zustandswächter (`watcher.py`), Ereignisse und Telegram (`notify.py`), Datenbank (`store.py`, `schema.sql`) |
-| `web/` | Flask-App (`app.py`), Seiten (`templates/`), CSS und JS (`static/`) |
-| `docs/` | Bedienungsanleitung (`Anleitung-*.md`) unter `/doku`; Technik unter `docs/internal/` (nicht in der App) |
-| `web/static/doku/` | Screenshots für die Anleitung |
-| `CHANGELOG.md` | Änderungen je Version |
+| `server.py` | Start, DB, Hintergrund-Threads |
+| `grotti/` | Moonraker, Queue, Senden, Abräumen, Watcher, Store |
+| `web/` | Flask, Templates, CSS/JS, Branding |
+| `docs/` | Anleitungen (`/doku`), Community-Screens, Technik unter `internal/` |
+| `CHANGELOG.md` | Versionen |

 ## API

-Alles unter `/api/v1`, JSON. Auth: Session-Cookie (UI) oder `Authorization: Bearer grt_…` (API-Token unter Einstellungen). Optional noch Shared-`token` in der Config (Migrationsbrücke).
+Alles unter `/api/v1`, JSON. Auth: Session oder `Authorization: Bearer grt_…` (kein CSRF). Referenz: [`docs/internal/API.md`](docs/internal/API.md), OpenAPI-Skizze [`docs/internal/openapi.yaml`](docs/internal/openapi.yaml).

 | Methode und Pfad | Zweck |
 | --- | --- |
-| `POST /auth/setup`, `/auth/login`, `/auth/logout` | Ersten Admin, Login, Logout |
+| `POST /auth/setup`, `/auth/login`, `/auth/token`, `/auth/logout` | Admin, Session-Login, App-Token, Logout |
 | `GET /me`, `/users`, `/tokens` | Konto, Benutzer (Admin), API-Tokens |
-| `GET /version` | Version |
-| `GET /drucker?live=1` | Drucker mit Live-Zustand, laufendem und wartendem Auftrag |
-| `POST /drucker/<host>/<aktion>` | Pause, Fortsetzen, Abbrechen, Fehler löschen |
-| `POST /drucker/<host>/steuern` | Temperatur, Speed, Flow, Lüfter |
-| `GET /dateien`, `POST /dateien` | Bibliothek, Upload |
-| `POST /senden` | Datei an Drucker. `confirm: true` ist Pflicht. `when_free: true` reiht ein. |
-| `GET /druck-queue`, `POST /druck-queue`, `PATCH /druck-queue/<id>` | Warteschlange (`confirm` beim Einreihen) |
-| `POST /spulen/<id>/einlegen` | Spule an Drucker/Platz; alte Rolle dort ins Regal |
-| `POST /ablauf` | Ablauf für Kobra 3 einreihen |
-| `GET /ereignisse?host=&kind=&since=&limit=` | Aktivität |
-| `POST /ereignisse/gelesen` | Alerts als gelesen |
-| `GET /spulen`, `GET /laeufe`, `GET /projekte` | Material, Protokoll, Projekte |
+| `GET /version` | Version, `api`, `features` |
+| `GET`/`PATCH /einstellungen`, `POST /telegram/test`, `/ntfy/test` | Config und Push-Probe |
+| `GET /drucker?live=1` | Drucker mit Live-Zustand |
+| `POST /drucker/<host>/<aktion>` | `pause`, `fortsetzen`/`resume`, `abbrechen`/`cancel` |
+| `POST /drucker/<host>/steuern` | Temperatur, Speed, Flow, Lüfter, ACE, `clear_error`, E-Stop |
+| `POST /drucker/<host>/abraeumen` | Platte geräumt (`confirm`) |
+| `GET`/`POST /dateien`, `PATCH`/`DELETE /dateien/<id>` | Bibliothek (Filter `family`, `material`, `project_id`, …) |
+| `POST /senden`, `GET`/`POST /druck-queue` | Senden und Warteschlange (`confirm`) |
+| `GET`/`POST /projekte`, `…/einreihen`, Assets | Projekte |
+| `GET /spulen`, `POST /spulen/<id>/einlegen` | Material |
+| `GET /laeufe`, `/statistik`, `/ereignisse`, `/stream` | Protokoll, Statistik, SSE |

-MCP: `python -m grotti.mcp_server` mit `GROTTI_URL` und `GROTTI_TOKEN` (siehe `docs/internal/MCP.md`).
+MCP: `python -m grotti.mcp_server` mit `GROTTI_URL` / `GROTTI_TOKEN` → `docs/internal/MCP.md`.

 ## Sicherheit

- Login Pflicht (Setup legt den ersten Admin an). Rollen: Admin, Operator.
- Druckstarts brauchen `confirm: true`. Die Oberfläche fragt per Zwei-Klick.
- Keine freie G-code-Konsole; Firmware-Neustart über Grotti ist gesperrt.
- Für Internet: Reverse Proxy mit TLS; nicht den Entwickler-Server öffentlich freigeben.
+- Login Pflicht. Rollen: Admin, Operator.
+- Druckstarts brauchen `confirm: true` (Zwei-Klick in der UI).
+- Keine freie G-code-Konsole; kein `FIRMWARE_RESTART` über Grotti.
+- Nach außen: Reverse Proxy mit TLS.

-## Versionen und Changelog
+## Versionen

- Versionierung nach [SemVer](https://semver.org/lang/de/): Patch für Fehlerbehebung, Minor für neue Funktion, Major für Bruch an API oder Datenbankschema.
- Jede Änderung kommt in `CHANGELOG.md` unter `[Unreleased]` (Neu, Geändert, Behoben).
- Beim Release: Version in `grotti/version.py` setzen, `[Unreleased]` in `[x.y.z] – Datum` umbenennen, Git-Tag `vX.Y.Z`.
- Ändert sich `web/static/grotti.css` oder `api.js`, in `layout.html` den `?v=` hochzählen.
+- SemVer in `grotti/version.py`, Einträge in [CHANGELOG.md](CHANGELOG.md).
+- Release: `[Unreleased]` → `[x.y.z] – Datum`, Tag `vX.Y.Z`.
+- CSS/JS-Cache: `?v=` in `layout.html` mitziehen.

-## Repo
+---

-Eigenes Repository: <https://git.gundel.dev/dg/grotti>. Doku zum Tool gehört nach `docs/`.
+<p align="center">
+  <img src="web/static/brand/logo.png" alt="" width="72"><br>
+  <sub>Repo: <a href="https://git.gundel.dev/dg/grotti">git.gundel.dev/dg/grotti</a></sub>
+</p>
@@ -2,12 +2,14 @@
  "host": "127.0.0.1",
  "port": 8770,
  "data_dir": "data",
-  "watch_dir": "",
+  "watch_dir": "slice",
  "database_url": "postgresql://[email protected]:5432/grotti",
  "token": "",
  "secret_key": "",
  "fqdn": "",
+  "log_level": "INFO",
  "auto_queue": true,
+  "auto_retry": true,
  "oauth": {
    "enabled": false,
    "issuer": "",
@@ -16,23 +18,38 @@
    "redirect_uri": ""
  },
  "energy": {
-    "watts": 120,
+    "watts": 40,
+    "nozzle_watts": 60,
+    "bed_watts": 220,
    "euro_per_kwh": 0.35,
    "dryer_watts": 0,
    "dry_hours": 0,
    "waste_percent": 0,
-    "utilization": 50
+    "utilization": 50,
+    "tariff": {
+      "ht_euro": 0.35,
+      "nt_euro": 0.22,
+      "nt_from": "22:00",
+      "nt_to": "06:00"
+    }
  },
  "telegram": {
    "enabled": false,
    "bot_token": "",
    "chat_id": ""
  },
+  "ntfy": {
+    "enabled": false,
+    "server": "https://ntfy.sh",
+    "topic": "",
+    "token": ""
+  },
  "alerts": {
    "fertig": true,
    "fehler": true,
    "offline": true,
    "queue": true,
+    "spule": true,
    "ablauf": false,
    "start": false
  }
@@ -1,8 +1,8 @@
 # ACE und Spulen

-Stand **15.10.2026**. Mehrfarb-Drucke brauchen vor dem Start eine Zuordnung Datei-Farbe → ACE-Platz und eine passende Spule am Drucker.
+Stand **21.10.2026**. Mehrfarb-Drucke brauchen vor dem Start eine Zuordnung Datei-Farbe → ACE-Platz und eine passende Spule am Drucker.

-![ACE-Zuordnung beim Senden](/static/doku/ace-zuordnung.png)
+![ACE-Zuordnung beim Senden](../web/static/doku/ace-zuordnung.png)

 ## Spule einlegen

@@ -12,28 +12,43 @@ Stand **15.10.2026**. Mehrfarb-Drucke brauchen vor dem Start eine Zuordnung Date

 Es gibt **kein freies Spulen-Dropdown** beim Start: Grotti nimmt die Rolle(n), die am Ziel-Drucker liegen. Material-Mismatch oder zu wenig Rest → Warnung vor dem Start.

-Etiketten mit QR: [Material und mehr](Anleitung-Material).
+### Rollenwechsel während Pause
+
+Während Druck oder Pause die neue Spule unter Material dem Drucker zuweisen und speichern. Grotti schließt den Abschnitt der alten Rolle und öffnet einen neuen — im Druckbericht erscheinen dann zwei Spulenzeilen und Ereignisse. Nur Filament am Gerät laden ohne Zuweisung: Abzug und Protokoll bleiben bei der alten Rolle.
+
+Wenn Moonraker den Druck nach Filament-Pause als neuen History-Job führt, übernimmt Grotti die neu zugewiesene Rolle für den fortgesetzten Teil (Send- und Lauf-Spule werden beim Einlegen aktualisiert). Die beiden Job-IDs bleiben **ein** Protokoll-Lauf, wenn die Druckdauer fortgesetzt wird oder die Wand „druckt weiter“ gesehen hat.
+
+Etiketten mit QR: [Material und mehr](Anleitung-Material.md).

 ## ACE-Map beim Senden

 Unter **Dateien → Optionen → ACE-Zuordnung**:

- Jede Farbe aus der Datei (`paint_index`) einem **ACE-Platz** zuordnen
+- Jede Farbe aus der Datei (`Tn` / Slicer-`paint_index`) einem **ACE-Platz** zuordnen
+- Bei Bambu-/Anycubic-Dateien sind die Nummern oft **nicht 0–3** (z. B. T1 und T10 bei 16 Slots) — Grotti zeigt `T…`, verdichtet beim Senden aber auf T0…n (sonst Fehler **invalid filament id**)
+- Liegt unter Material eine Spule auf dem Platz, zeigt die Liste Name, Farbe und Restgramm mit — Vorauswahl bevorzugt die **Katalog-Sorte** aus dem Orca-Profil (Meta/Matte …)
 - Ohne passende Map schreibt der Drucker oft **„cannot parse the file“** und startet nicht
 - Grotti legt die Sidecar `*.gcode.acm` an und schickt sie mit

+Bei **Nächster passender** (kein Drucker gewählt) baut Grotti die Map erst beim Claim aus den Spulen am gewählten Drucker. Passt der Typ nicht (PETG statt PLA) → Wartegrund in der Queue. Meta/Matte/Silk halten nicht an; die genannte Sorte wird nur bevorzugt.
+
 Externe Spule / keine ACE-Slots: keine `.acm` nötig.

+Nach einem Grotti-Update mit ACE-Farben: unter Dateien **neu lesen**, damit alte Einträge die echten `Tn` bekommen.
+
 ## Typische Fehler

 | Symptom | Check |
 | --- | --- |
 | „cannot parse the file“ | ACE-Zuordnung vollständig? Farben richtig? |
-| Material-Warnung | Eingelegte Sorte ≠ Datei — Spule wechseln oder Slice prüfen |
-| Rest zu gering | Andere Spule oder leichteres Teil |
+| „T… fehlt in der Map“ | Datei neu lesen, Zuordnung erneut setzen (Slicer-T ≠ ACE-Platz) |
+| **invalid filament id** (10011700) | Alte Grotti-Version ohne T-Verdichtung, oder Map nicht neu gesetzt. Grotti neu starten, Datei neu lesen, nochmal senden. |
+| Material-Warnung | Eingelegte Sorte ≠ Datei. Der Start geht trotzdem. PA12-CF steht in Grotti so, an den ACE geht PA6-CF. |
+| Rest zu gering | Warnung unter Dateien („nur … g, Datei braucht … g“). Der Start geht trotzdem; leer pausiert der Drucker. |
 | ACE blinkt nicht / kein Wechsel | Spule und Platz prüfen, ggf. Druck neu starten |
+| Drucker hängt kurz nach Multi-Color-Start | Oft falsche Map (T10 gemappt als Platz 0). Neu lesen + Zuordnung. |

 ## Weiter

- [Dateien senden](Anleitung-Dateien)
- [Material](Anleitung-Material)
+- [Dateien senden](Anleitung-Dateien.md)
+- [Material](Anleitung-Material.md)
@@ -0,0 +1,20 @@
+# Aufträge
+
+Stand **18.10.2026**. Kundenaufträge mit Positionen (Datei × Menge), Fortschritt und Lieferschein.
+
+## Seite Aufträge
+
+Unter **Aufträge** legst du Kunden und Aufträge an. Status: Idee → Angebot → Bestätigt → Druckt → Fertig → Geliefert → Bezahlt.
+
+Pro Position: Datei, Stückzahl, optional Preis und Material. **Einreihen** schickt die Position in die Warteschlange (`confirm`). Fertige gute Stücke aus dem Abräumen-Dialog zählen auf den Fortschritt „n von m“.
+
+## Lieferschein
+
+Im Auftrag **Lieferschein** öffnen: Positionen, Chargen `D-…`, druckbar. Danach Status auf **Geliefert** setzen.
+
+## Weiter
+
+- [Projekte](Anleitung-Projekte.md) (Arbeitsmappe / Konstruktion — nicht dasselbe wie Auftrag)
+- [Warteschlange](Anleitung-Warteschlange.md)
+- [Material](Anleitung-Material.md)
+- [Protokoll / Bericht](Anleitung-Oberflaeche.md)
@@ -1,27 +1,34 @@
 # Dateien senden

-Stand **15.10.2026**. Seite `/dateien` — Bibliothek links, Senden rechts.
+Stand **18.10.2026**. Seite `/dateien` — Bibliothek links, Senden rechts.

-![Dateien: Bibliothek und Senden](/static/doku/dateien-flow.png)
+![Dateien: Bibliothek und Senden](../web/static/doku/dateien-flow.png)

 ## Bibliothek

- Suche, Filter nach Maschine und Projekt
+- Kompakte Filterleiste: Suche, Maschine, Projekt, Material, Ordner, Sortierung
+- Filter: Maschine, Projekt, Material, Ordner (Unterordner unter dem Slice-Ordner; Uploads als „Upload“)
+- Sortierung: Neueste, Name, Material, Ordner, Druckzeit, Gewicht — bei Material/Ordner mit Gruppenköpfen
+- Auswahl der Filter bleibt im Browser merken
 - Vorschaubild, Material, Zeit, Gewicht, Schichthöhe
 - Info-Popup mit Slice-Metadaten (Kopf und Footer)
 - **Hochladen** per Knopf oder Drag & Drop
- **Ordner neu lesen**, wenn `watch_dir` in der Config auf den Slice-Ordner zeigt
+- Mit gesetztem Slice-Ordner ([Einstellungen](Anleitung-Einstellungen.md)): **Ordner anlegen**; Watch- **und** Upload-Dateien per Auswahl **verschieben** (Upload wird zur Watch-Datei im Slice-Ordner)
+- **Umbenennen** (Stift-Icon) — Datei auf der Platte und in der Bibliothek; Endung `.gcode`/`.3mf` bleibt, wenn du sie weglässt
+- **Löschen** (Papierkorb, Zwei-Klick) für jede Bibliotheksdatei — entfernt Eintrag und Datei auf der Platte (nur unter Slice-Ordner oder `eingang`)
+- **Ordner neu lesen**, wenn unter Einstellungen ein Slice-Ordner gesetzt ist

-Ohne `watch_dir` geht nur manueller Upload — das reicht für den Alltag.
+Ohne Slice-Ordner geht nur manueller Upload; Verschieben in Ordner braucht den Slice-Pfad.
+
+Projekte mit eigenem Ordner: [Projekte](Anleitung-Projekte.md).

 ## Senden: drei Schritte

 1. **Datei** wählen (Klick in der Liste).
 2. **Drucker** wählen — Kacheln zeigen Live-Zustand und eingelegte Rolle. Passt die Maschine nicht, ist die Kachel blass.
-3. **Wann:**
-   - **Jetzt** — sofort senden und starten (Zwei-Klick)
-   - **Wenn frei** — in die Warteschlange für diesen Drucker
-   - **Nächster freier** — erster passender freier Drucker
+3. **Start:**
+   - **Dieser Drucker** — frei und Platte klar → sofort starten; sonst Warteschlange für diesen Drucker
+   - **Nächster passender** — Grotti wählt den nächsten freien Drucker mit passendem Typ (PLA, PETG, …). Die genannte Sorte (Meta, Matte) wird bevorzugt, wenn sie liegt; sonst reicht derselbe Typ.

 Auswahl merkt sich der Browser (`localStorage`).

@@ -31,7 +38,7 @@ Unter Optionen u. a.:

 - **Bettnetz / Auto-Level** beim MQTT-Start (Anycubic)
 - Maschinen-Override, Projekt zuweisen
- **ACE-Zuordnung** — siehe [ACE und Spulen](Anleitung-ACE)
+- **ACE-Zuordnung** — siehe [ACE und Spulen](Anleitung-ACE.md)

 ## Warum es dauert

@@ -39,11 +46,17 @@ Große Dateien brauchen oft **eine Minute**. In der Sidebar unter **Senden** sie

 ## Nach dem Start

- Fortschritt auf der [Wand](Anleitung-Wand) und in der Sidebar **Läuft jetzt**
- Bei „Wenn frei“: Eintrag unter [Warteschlange](Anleitung-Warteschlange)
+- Fortschritt auf der [Wand](Anleitung-Wand.md) und in der Sidebar **Läuft jetzt**
+- Bei Warteschlange / Nächster passender: Eintrag unter [Warteschlange](Anleitung-Warteschlange.md)
 - Später unter **Protokoll** mit **Nochmal** (inkl. gespeicherter ACE-Map)

+## Aus Orca
+
+Nach dem G-code-Export kann Orca die Datei direkt nach Grotti laden und diese Seite mit der Datei öffnen — siehe [Orca an Grotti](Anleitung-Orca.md).
+
 ## Weiter

- [ACE und Spulen](Anleitung-ACE)
- [Warteschlange](Anleitung-Warteschlange)
+- [Projekte](Anleitung-Projekte.md)
+- [Orca an Grotti](Anleitung-Orca.md)
+- [ACE und Spulen](Anleitung-ACE.md)
+- [Warteschlange](Anleitung-Warteschlange.md)
@@ -1,6 +1,6 @@
 # Einrichtung

-Stand **15.10.2026**. Grotti auf dem Haus-PC installieren und den Browser öffnen. Die Drucker brauchen vorher Moonraker (Rinkhals auf Kobra 3 und S1).
+Stand **24.10.2026**. Grotti auf dem Haus-PC oder Raspberry Pi installieren und den Browser öffnen. Die Drucker brauchen vorher Moonraker (Rinkhals auf Kobra 3 und S1).

 ## Was du brauchst

@@ -27,14 +27,14 @@ copy config.example.json config.json
 | `host`, `port` | Wo die Oberfläche lauscht. Standard `127.0.0.1:8770`. |
 | `database_url` | PostgreSQL-Verbindung. |
 | `data_dir` | Uploads, Vorschaubilder, Cache. Standard `data`. |
-| `watch_dir` | Slice-Ordner, den Grotti beobachtet. Leer = nur manueller Upload. |
+| `watch_dir` | Slice-Ordner (meist unter **Einstellungen** setzen). Leer = nur manueller Upload. Standard-Vorschlag: Ordner `slice` im Repo. |
 | `token` | Optionaler Shared-API-Token (Übergang). Mit Benutzerverwaltung nutzt du API-Tokens unter Einstellungen. |
 | `fqdn` | Öffentliche Basis-URL für QR auf Spulen-Etiketten. Leer = Request-Host. |
 | `auto_queue` | `false` stoppt neue „wenn frei“-Starts. |
 | `energy`, `telegram`, `alerts` | Kosten im Protokoll und Telegram — später auch unter Einstellungen. |
 | `secret_key` | Für Login-Sessions. Beim ersten Start wird ein Wert erzeugt, wenn leer. |

-Drucker beim ersten Start über `drucker.json` (Seed). Danach pflegt man sie unter [Einstellungen](Anleitung-Einstellungen).
+Drucker beim ersten Start über `drucker.json` (Seed). Danach pflegt man sie unter [Einstellungen](Anleitung-Einstellungen.md).

 ```json
 [{ "name": "Kobra 3 da26", "host": "10.10.1.60" }]
@@ -50,17 +50,19 @@ Die Familie (Kobra 3 oder S1) liest Grotti aus dem Namen.

 Dann <http://127.0.0.1:8770/> öffnen. Beim ersten Start legst du den Admin-Benutzer an. Nach Code-Änderungen an Python oft neu starten.

-![Druckerwand nach dem Start](/static/doku/wand-uebersicht.png)
+![Druckerwand nach dem Start](../web/static/doku/wand-uebersicht.png)

 ## Sicherheit

- Druckstart nur mit Bestätigung (Zwei-Klick in der UI bzw. `confirm: true` in der API).
+- Druckstart über die API nur mit `confirm: true` (Dateien-UI: ein Klick).
 - Keine freie G-code-Konsole; Firmware-Neustart über Grotti ist gesperrt.
- Benutzer und API-Tokens unter Einstellungen. Für Zugriff aus dem Internet: Reverse Proxy mit TLS, nicht den Entwickler-Server öffentlich freigeben.
+- Benutzer und API-Tokens unter Einstellungen. App-Kopplung: Token erzeugen und QR scannen, oder `POST /api/v1/auth/token` mit Benutzer/Passwort. Push aufs Handy: **ntfy** (kein FCM). API-Referenz: intern `docs/internal/API.md`.
+- Für Zugriff aus dem Internet: Reverse Proxy mit TLS, nicht den Entwickler-Server öffentlich freigeben.
 - `config.json` und `data/` bleiben lokal, nicht im Git.
+- Raspberry Pi: [Installation auf dem Pi](Anleitung-Installation-Pi.md) (`.deb`, Umzug Windows→Pi).

 ## Weiter

- [Oberfläche](Anleitung-Oberflaeche) — Navigation und Sidebar
- [Dateien senden](Anleitung-Dateien) — erster Druck
+- [Oberfläche](Anleitung-Oberflaeche.md) — Navigation und Sidebar
+- [Dateien senden](Anleitung-Dateien.md) — erster Druck
 - Ausführlich im `README.md` im Projektordner
@@ -1,44 +1,51 @@
 # Einstellungen

-Stand **15.10.2026**. Seite `/einstellungen` — Drucker, Automatik, Anzeige, Telegram, Energie.
+Stand **18.10.2026**. Seite `/einstellungen` — Drucker, Automatik, Anzeige, Telegram/ntfy, Energie.

-![Einstellungen: Drucker](/static/doku/einstellungen-drucker.png)
+![Einstellungen: Drucker](../web/static/doku/einstellungen-drucker.png)

 ## Dieser Browser

- **Desktop** oder **Regal (Touch)** — nur lokal im Browser, siehe [Oberfläche](Anleitung-Oberflaeche).
+- **Desktop** oder **Regal (Touch)** — nur lokal im Browser, siehe [Oberfläche](Anleitung-Oberflaeche.md).
+- **Darstellung** — Dunkel, Hell oder System (folgt dem Gerät).
+- **Zeitzone** — Browser automatisch oder fest (z. B. Europe/Berlin) für Protokoll, Bericht und Aktivität.

 ## Automatik

-Checkbox **Automatik-Warteschlange** (`auto_queue`). Aus = keine neuen „wenn frei“-Starts. Laufende Abläufe und manuelle „Jetzt“-Starts bleiben möglich.
+Checkbox **Automatik-Warteschlange** (`auto_queue`). Aus = keine neuen Queue-Starts. Laufende Abläufe und manuelle Sofort-Starts bleiben möglich.
+
+## Slice-Ordner
+
+Pfad zum Ordner, den die Bibliothek beobachtet (Export aus Orca/Anycubic, **Ordner neu lesen**, Unterordner). **Standardordner** setzt `slice` im Grotti-Repo. Leer = nur Hochladen. Nur Admin; der Ordner wird beim Speichern angelegt, falls er fehlt.

 ## Drucker

-Tabelle: Name, Host, Familie, **gesperrt**.
+Pro Drucker: Name, Host, Familie, **gesperrt**, optional **Start-Zeitfenster**.

 - Seed beim allerersten Start aus `drucker.json`, danach nur noch hier (Datenbank).
 - Familie aus dem Namen (Kobra 3 / S1) oder gesetzt.
 - **Gesperrt:** keine neuen Queue-Starts auf diesem Host.
+- **Zeitfenster:** Queue startet nur zwischen Von/Bis (z. B. 22:00–06:00). Optional Max.-Stunden für Nachtjobs.

 ## FQDN

 Öffentliche Basis-URL für QR-Codes auf Spulen-Etiketten. Leer = Host aus dem aktuellen Request. Wichtig, wenn du Etiketten von einem Handy scannst, das nicht `127.0.0.1` kennt.

-## Telegram und Alerts
+## Telegram, ntfy und Alerts

-Bot-Token und Chat-ID. Pro Ereignisart an/aus (Fertig, Fehler, Offline, Queue, …). Test-Knopf zum Prüfen. Wichtige Ereignisse stehen auch in der Sidebar unter Alerts.
+Telegram: Bot-Token und Chat-ID, pro Ereignisart an/aus, Test-Knopf. **ntfy:** Server, Topic, optional Token — gleiche Meldungen, unabhängig schaltbar, ebenfalls mit Test. Ereignisse stehen auch in der Sidebar unter Alerts.

 ## Benutzer und API-Tokens

-Unter **Benutzer** (nur Admin) legst du Konten mit Rolle Admin oder Operator an. Unter **API-Tokens** erzeugst du Schlüssel für Home-Automation, App oder MCP — der Klartext erscheint nur einmal (`Authorization: Bearer grt_…`).
+Unter **Benutzer** (nur Admin) legst du Konten mit Rolle Admin oder Operator an. Unter **API-Tokens** erzeugst du Schlüssel für Home-Automation, App oder MCP — der Klartext erscheint nur einmal (`Authorization: Bearer grt_…`), dazu ein QR mit Server-URL und Token zum Scannen. Alternativ stellt die App `POST /api/v1/auth/token` mit Benutzer/Passwort aus. Ein Shared-`token` in der Config-Datei gilt nicht mehr.

 MCP (optional): Token erzeugen, dann `python -m grotti.mcp_server` mit `GROTTI_URL` und `GROTTI_TOKEN`. Für nur Lesen: `GROTTI_MCP_READ_ONLY=1`.

 ## Energie

-Watt und Strompreis für die Kosten im **Protokoll**. Optional Trockner/Ausschuss/Auslastung für die Kalkulation.
+**Grundlast W** (Elektronik/Motion, nicht die Heizer) und Strompreis für die Kosten im **Protokoll**. **Düse W** / **Bett W** zusammen mit ED-Proben im Verlauf → Schätzung „aus ED“; stehen sie auf 0, bleibt es bei Dauer × Grundlast („pauschal“). Typisch Kobra: Grundlast ~40 W, Düse ~60 W, Bett ~200–300 W. Optional **HT/NT-Tarif** mit Zeiten und Preisen — Grotti gewichtet dann die Stromkosten nach Uhrzeit. Beim Speichern warnt die Seite, wenn Düse oder Bett noch 0 sind.

 ## Weiter

- [Einrichtung](Anleitung-Einrichtung) (Config-Datei)
- [Störungen](Anleitung-Stoerungen)
+- [Einrichtung](Anleitung-Einrichtung.md) (Config-Datei)
+- [Störungen](Anleitung-Stoerungen.md)
@@ -0,0 +1,120 @@
+# Installation auf dem Raspberry Pi
+
+Stand **18.10.2026**. Phase 1: Installation per `.deb`-Datei. Ein öffentliches apt-Repository kommt später.
+
+## Voraussetzungen
+
+- Raspberry Pi OS **Bookworm** (64-Bit / arm64), Pi 4 oder 5 empfohlen
+- Netz zu den Druckern (Moonraker/Rinkhals)
+- ca. 1 GB freier Speicher für Paket + PostgreSQL
+
+## Paket bauen (auf dem Pi oder arm64-Host)
+
+Im geklonten Repo:
+
+```bash
+sudo apt install -y python3-venv rsync dpkg-dev
+bash packaging/build-deb.sh
+```
+
+Ergebnis: `packaging/dist/grotti_<version>_arm64.deb`
+
+## Installieren
+
+```bash
+sudo apt install ./packaging/dist/grotti_*_arm64.deb
+```
+
+Das zieht **PostgreSQL** mit, legt Benutzer `grotti`, Datenbank `grotti` und den Dienst an.
+
+- Oberfläche: `http://<pi-ip>:8770/`
+- Config: `/etc/grotti/config.json` (wird bei Updates nicht überschrieben)
+- Daten: `/var/lib/grotti/`
+- Slice-Ordner: `/var/lib/grotti/slice` (unter Einstellungen änderbar)
+
+Beim ersten Aufruf Admin-Konto anlegen (wie gewohnt).
+
+## Logging
+
+Logs gehen nach **journald**:
+
+```bash
+journalctl -u grotti -f
+journalctl -u grotti --since "1h ago"
+journalctl -u grotti -n 200
+```
+
+Log-Level in `/etc/grotti/config.json`:
+
+```json
+"log_level": "INFO"
+```
+
+Werte: `DEBUG`, `INFO`, `WARNING`, `ERROR`. Danach:
+
+```bash
+sudo systemctl restart grotti
+```
+
+## Dienst
+
+```bash
+sudo systemctl status grotti
+sudo systemctl restart grotti
+sudo systemctl stop grotti
+```
+
+## Update
+
+Neue `.deb` bauen bzw. holen, dann erneut:
+
+```bash
+sudo apt install ./packaging/dist/grotti_*_arm64.deb
+```
+
+Config und `/var/lib/grotti` bleiben erhalten.
+
+## Deinstallieren
+
+```bash
+sudo apt remove grotti          # Dienst weg, Daten bleiben
+sudo apt purge grotti           # zusätzlich /etc/grotti
+# optional Datenbank:
+# sudo -u postgres dropdb grotti
+# sudo -u postgres dropuser grotti
+# sudo rm -rf /var/lib/grotti
+```
+
+## Umzug Windows → Pi
+
+1. **Backup auf dem alten Rechner** (Einstellungen → Backup) oder `pg_dump` der PostgreSQL-Datenbank.
+2. Auf dem Pi Grotti per `.deb` installieren (oben).
+3. Backup einspielen (Einstellungen → Backup wiederherstellen) **oder** `pg_restore` in die DB `grotti`.
+4. Slice-Ordner nach `/var/lib/grotti/slice` kopieren (rsync/scp).
+5. Absolute Windows-Pfade in der DB umschreiben (Dry-Run zuerst):
+
+```bash
+sudo -u grotti /opt/grotti/venv/bin/python /opt/grotti/scripts/pfade_umziehen.py \
+  --database-url 'postgresql:///grotti?host=/var/run/postgresql' \
+  --from 'D:/dein/slice' --to /var/lib/grotti/slice
+# prüfen, dann mit --apply
+```
+
+(Alternativ aus dem Repo-Clone mit derselben DB-URL.)
+
+6. Unter Einstellungen: `watch_dir` = `/var/lib/grotti/slice`, ggf. `fqdn` auf die Pi-URL.
+7. In Orca „Senden an Grotti“ auf `http://<pi-ip>:8770/` umstellen.
+8. `sudo systemctl restart grotti` und unter **Dateien → Ordner neu lesen**.
+
+## Last auf dem Pi
+
+- Watcher und Toolpath-Cache liegen unter `/var/lib/grotti/`. Bei wenig Speicher Toolpath-Cache-Ordner (`data/toolpath`) gelegentlich leeren.
+- Wenige SSE-Clients sind unkritisch; viele offene Browser-Tabs mit Kamera-Stream belasten CPU/Netz.
+- Empfohlen: Pi 4/5 mit SSD oder schneller SD, nicht parallel schwere Builds auf demselben Gerät.
+
+## Hinweise
+
+- Standard lauscht auf `0.0.0.0:8770` (LAN). Für Internet: Reverse Proxy mit TLS.
+- Drucker unter **Einstellungen** anlegen (kein vorgefülltes `drucker.json` nötig).
+- Öffentliches `apt install grotti` ohne Datei: kommt mit dem Repo-Server (Phase 2).
+- `.deb` auf dem Ziel-Pi bauen (`bash packaging/build-deb.sh`), damit arm64-Wheels (`psycopg`, `cryptography`) passen.
@@ -1,32 +1,44 @@
 # Material und mehr

-Stand **15.10.2026**. Spulen, Etiketten, Projekte, Protokoll, Kameras, Aktivität und Ideen.
+Stand **18.10.2026**. Spulen, Etiketten, Aufträge, Protokoll, Statistik, Aktivität.

-![Material: Spulen](/static/doku/material-spule.png)
+![Material: Spulen](../web/static/doku/material-spule.png)

 ## Material

 Zwei Reiter: **Spulen** und **Sorten**.

-**Spulen:** Filter Alle / Am Drucker / Regal / Wenig Rest. Formular bei Auswahl oder „Neue Spule“. Ort = Drucker · ACE/extern oder Regal. Scan-Feld im Seitenkopf (QR vom Etikett).
+Oben die Karte **Bedarf aus Warteschlange**, wenn wartende Jobs Filament brauchen: Queue-Gewicht vs. Spulenrest je Sorte/Farbe. Fehlmengen erscheinen auch in der Sidebar und als Chip in der Warteschlange.
+
+**Spulen:** Filter Alle / Am Drucker / Regal / Wenig Rest / Archiv; zusätzlich Sorte und Farbe. Leere und archivierte Spulen sind standardmäßig ausgeblendet — **Archiv** zeigt sie. Formular bei Auswahl oder „Neue Spule“. **Leer** setzt Rest auf 0, legt die Rolle ins Regal und archiviert; **Archivieren** / **Wiederherstellen** ohne Restzwang. Ort = Drucker · ACE/extern oder Regal. Scan-Feld im Seitenkopf (QR vom Etikett). Unter der ausgewählten Spule die **Akte**: verdruckte Gramm, Ausschuss, Leer-in.

 **Sorten:** Profile (Dichte, Preis, Maschinen). „Spule damit anlegen“ wechselt zum Spulen-Reiter.

 ### Etikett und QR

-Pro Spule ein Etikett mit Chargennummer und QR. Der Code öffnet Material mit der Spule vorausgewählt. Dafür in den Einstellungen ggf. **FQDN** setzen (öffentliche URL), sonst gilt der Host aus dem Request.
+Pro Spule ein Etikett mit Chargennummer `S-…` und QR. Der Code öffnet Material mit der Spule vorausgewählt. Dafür in den Einstellungen ggf. **FQDN** setzen (öffentliche URL), sonst gilt der Host aus dem Request.

-## Projekte
+Druck-Etiketten (`D-…`) kommen vom Druckbericht: ein Etikett für den ganzen Lauf oder je Objekt. Scan von `D-…` öffnet den Bericht.

-Unter **Projekte** Aufträge mit Notiz und Kalkulation. Dateien lassen sich einem Projekt zuweisen (Bibliothek / Senden).
+## Aufträge

-## Protokoll
+Unter **Aufträge** Kunden, Positionen und Fortschritt. Dateien lassen sich einem Auftrag zuweisen; siehe [Aufträge](Anleitung-Auftraege.md).

-Abgeschlossene Läufe: Dauer, Gramm, Kosten, Urteil. **Nochmal** startet denselben Job inkl. gespeicherter ACE-Map und Bettnetz-Option.
+## Protokoll und Statistik
+
+Abgeschlossene Läufe: Dauer, Ist-Gramm, Kosten, Urteil. Zeile öffnet den **Druckbericht** (Soll/Ist, Spulen, Temperaturverlauf, Kosten-Aufschlüsselung Filament + Strom mit Tortendiagramm, Charge). **Nochmal** startet denselben Job inkl. gespeicherter ACE-Map und Bettnetz-Option (nicht während der Druck noch läuft).
+
+Nach Filament-Ende: neue Spule unter **Material** dem Drucker/ACE-Platz zuweisen (Ort setzen und speichern — das legt den Rollenwechsel im Lauf an), am Gerät laden, an der Wand **Weiter**. Nur physisch nachlegen reicht nicht. Die Zuweisung gilt auch, wenn Moonraker den Druck nach der Pause als neuen Job zählt — Grotti hält das als **einen** Lauf (gleiche Charge). Im Protokoll siehst du bei Rollenwechsel die Spulennamen; falls doch zwei Zeilen stehen, **Läufe holen** oder **Verbinden**.
+
+Unter **Statistik** KPIs, Balkendiagramme (Druckzeit je Drucker, Verbrauch je Material), Tabellen und CSV-Export. Zeitraum per Knopf oder Von/Bis.
+
+Druck-Etiketten (`D-…`) schon während des Drucks: an der Wand **Etikett**, im Druckbericht **Etikett Druck** / **Etiketten Objekte**. Auf dem Bogen steht das Sollgewicht aus dem Slicer (geplante Filamentmenge). Bei Ausschuss die gedruckten Bögen wegwerfen; die Charge bleibt im Protokoll.
+
+Abzug nach dem Druck nimmt das Ist aus `filament_used` (Abbruch nur anteilig). Mehrfarb-Anteile sind als Schätzwert gekennzeichnet. Restgramm darf unter 0 gehen.

 ## Kameras

-`/kameras` — alle Snapshots nebeneinander mit Live-Zustand. Praktisch auf dem Regal-Tablet.
+Auf der **Druckerwand** erscheint je Drucker ein kleines Snapshot-Bild (ca. alle 3 s), wenn eine Webcam erreichbar ist. Klick öffnet das Cockpit — dort gilt weiter die Einstellung Snapshot/Stream unter Einstellungen → Dieser Browser. Die frühere Seite `/kameras` leitet auf die Wand um.

 ## Aktivität

@@ -38,5 +50,5 @@ Zeitstrahl: Starts, Schritte, Fertig, Fehler, Abbrüche, offline. Filter nach Dr

 ## Weiter

- [ACE und Spulen](Anleitung-ACE)
- [Einstellungen](Anleitung-Einstellungen)
+- [ACE und Spulen](Anleitung-ACE.md)
+- [Einstellungen](Anleitung-Einstellungen.md)
@@ -1,37 +1,49 @@
 # Oberfläche

-Stand **15.10.2026**. Wie die App aufgebaut ist — Menü, Live-Leiste, Desktop und Regal.
+Stand **18.10.2026**. Wie die App aufgebaut ist — Menü, Jetzt-Liste, Desktop und Regal.

 ## Navigation

-Links (Desktop): **Drucker**, **Dateien**, **Kameras**, **Aktivität**, **Warteschlange**, **Protokoll**, **Material**, **Projekte**. Darunter **Einstellungen**, **Ideen**, **Doku**. Fuß: Version (öffnet die Doku).
+Links (Desktop), gruppiert: **Live** (Drucker, Dateien, Warteschlange, Aufträge), **Rückschau** (Protokoll, Statistik, Aktivität), **Verwalten** (Projekte, Material, Wartung). Darüber im Inhaltsbereich die **Topbar**: Suche, Live-Chips, Einstellungen, Doku und Benutzer-Menü (Abmelden, Version).

-Unter ca. 760 px: untere Leiste mit den wichtigsten Seiten. Das Seitenmenü lässt sich zur Icon-Rail einklappen.
+Unter ca. 760 px: untere Leiste (Drucker, Dateien, Warteschlange, **Jetzt**, Mehr) plus **Mehr**-Sheet (inkl. Aktivität und Abmelden). Das Seitenmenü lässt sich zur Icon-Rail einklappen.

-![Seitenleiste mit Live-Boxen](/static/doku/sidebar-live.png)
+Shortcut **Ctrl+K** (Mac: Cmd+K) oder der Suche-Knopf in der Topbar: Suche über Drucker, Dateien, Spulen, Chargen und Aufträge.

-## Live-Leiste
+## Jetzt

-Unter dem Menü, eigene Scrollfläche. Boxen auf- und zuklappbar (Merker im Browser):
+Desktop: Chips in der Topbar (**Jetzt**, laufende Drucker, Senden, Meldungen). Klick öffnet ein Popover mit Liste und Aktionen. Bei mehreren Läufen zusätzlich **Alles fertig um …**.

-| Box | Inhalt |
+Mobile / Touch: Tab **Jetzt** in der unteren Leiste (mit Badge) öffnet `/jetzt` — dieselbe Liste als volle Seite. Aktivität liegt unter **Mehr**.
+
+| Priorität | Inhalt |
 | --- | --- |
-| **Läuft jetzt** | Laufende Aufträge und Abläufe, Schrittleiste, Abbrechen. Auch Direktstarts ohne Queue-Zeile. |
-| **Wartet** | Wartende Aufträge: Priorität, Abbrechen. Gestoppte Abläufe mit Fortsetzen. |
-| **Aufgaben** | Platte belegt ohne laufenden Ablauf — **geräumt** (Zwei-Klick). |
-| **Senden** | Uploads mit MB-Fortschritt. |
-| **Alerts** | Ungelesene wichtige Ereignisse; als gelesen markieren oder zur Aktivität. |
+| Platte räumen | Quittieren mit Urteil (optional „gleich nochmal“) |
+| Material nachlegen | Druck pausiert, Filament vermutlich leer (ACE/Runout) — Spule zuweisen, dann an der Wand **Weiter** |
+| Druck fehlgeschlagen | Fortsetzen / Ausblenden |
+| Spule fehlt | Link zu Material / Bedarf |
+| Wartung fällig | Link zu Wartung |
+| Auftrag überfällig | Link zu Aufträgen |
+| Wartet auf Material | Wartegrund aus dem Routing |
+
+Aktualisierung über Live-Stream (SSE), sonst Polling.

 ## Desktop und Regal

 Unter **Einstellungen → Dieser Browser**:

 - **Desktop** — normale Dichte
- **Regal (Touch)** — größere Bedienelemente, kompaktere Nav, Sidebar oft eingeklappt
+- **Regal (Touch)** — größere Bedienelemente, Sidebar oft eingeklappt; auf schmalem Viewport die untere Leiste. Alle Menüpunkte bleiben in der Sidebar sichtbar.
+- **Darstellung** — Dunkel, Hell oder System
+- **Zeitzone** — Browser oder fest (z. B. Europe/Berlin) für Uhrzeiten in Protokoll und Bericht
+- **Kamera** — Snapshot (schonend, alle paar Sekunden) oder Stream (flüssig, hält eine Verbindung). Gilt für das Cockpit; Wand-Thumbs sind immer Snapshot.

 Shortcut in der URL: `?shelf=1` bzw. `?shelf=0`. Nur dieser Browser (`localStorage`).

+Drucker-Cockpit: Alltag (Job, ETA, Rolle, Steuerung der Aktionen) oben; **Technik** (Steuerung, Verlauf, 3D-Pfad, Bettnetz) zugeklappt.
+
 ## Weiter

- [Druckerwand](Anleitung-Wand)
- [Dateien senden](Anleitung-Dateien)
+- [Druckerwand](Anleitung-Wand.md)
+- [Dateien senden](Anleitung-Dateien.md)
+- [Projekte](Anleitung-Projekte.md)
@@ -0,0 +1,84 @@
+# Orca an Grotti
+
+Stand **18.10.2026**. Nach dem Export landet der G-code in der Bibliothek und Grotti öffnet sich als **eigenes Fenster** (Chrome/Edge-App auf dem Desktop). Drucker, ACE-Platz und Einreihen wählst du dort.
+
+## Einmal einrichten
+
+1. Grotti starten und im Browser anmelden (die Session bleibt für die Senden-Seite).
+2. Unter **Einstellungen → API-Token** ein Token anlegen (Rolle Operator reicht). Den Wert `grt_…` nur einmal sichtbar.
+3. Datei `data/orca-senden.json` anlegen (gleicher Ordner wie `config.json`):
+
+```json
+{
+  "url": "http://127.0.0.1:8770",
+  "token": "grt_…",
+  "browser": "app"
+}
+```
+
+`url` ist die Adresse, unter der du Grotti im Browser öffnest.  
+`browser`: `app` (Standard) = eigenes Desktop-Fenster; `tab` = klassischer Browser-Tab.
+
+4. Im **Prozessprofil** (Druckqualität, z. B. „0.20mm Standard“): **Sonstiges → Nachbearbeitungsskripte**, eine Zeile:
+
+```text
+D:\Projekte\Grotti\.venv\Scripts\python.exe D:\Projekte\Grotti\scripts\orca_senden.py
+```
+
+Gilt für **OrcaSlicer** und **AnycubicSlicerNext**. Pfade anpassen. Der Slicer hängt den Export-Pfad selbst an.
+
+### Gerät-Reiter = Grotti (nur OrcaSlicer)
+
+Damit unter **Gerät** die Grotti-Oberfläche erscheint:
+
+1. Orca → Drucker-Dropdown → **Physikalischer Drucker** (Verbindung/Stecker-Symbol).
+2. **Host-Typ:** z. B. `Octo/Klipper` (egal, solange du nicht „Drucken“ an den Host schickst).
+3. **Hostname / API:** leer lassen — oder nur eine Dummy-Adresse. **Nicht** die Moonraker-IP eines Kobras eintragen.
+4. **Device UI / Web-UI-URL:** `http://127.0.0.1:8770/` (Grotti muss laufen).
+5. Speichern → Reiter **Gerät** öffnen → einmal bei Grotti anmelden.
+
+Wichtig: Den Orca-Button **Drucken / Upload zum Host** nicht nutzen — der spricht Moonraker/OctoPrint und umgeht ACE-Zuordnung in Grotti. Weiterhin **G-code exportieren** + Nachbearbeitungsskript.
+
+In **AnycubicSlicerNext** steckt unter Gerät/Arbeitsfläche die Anycubic-Cloud — dort lässt sich Grotti so nicht einbinden.
+
+## Ablauf (wichtig bei Anycubic)
+
+**Nicht** „Remote Print“ / „Aufgabe starten“ / Cloud-Dialog — der Anycubic-Dialog lässt sich von Grotti nicht abschalten.
+
+Stattdessen:
+
+1. Slicen, dann **G-code exportieren** / **Platte schreiben** (Ziel: Slice-Ordner; Unterordner ok).
+2. Das Nachbearbeitungsskript lädt die Datei nach Grotti und öffnet das Grotti-Fenster.
+3. Drucker wählen, unter Optionen Farbe → ACE-Platz, **Dieser Drucker** oder **Nächster passender**, dann **Starten**.
+
+Erstes App-Fenster: einmal bei Grotti anmelden (eigenes Profil unter `data/grotti-app-profile`). Die Session hält **30 Tage** und überlebt das Schließen des Fensters. Läuft das Fenster noch, startet Orca kein zweites Chrome (sonst leeres Profil → erneutes Login) — die neue Datei wird im offenen Fenster ausgewählt.
+
+Test ohne Orca:
+
+```powershell
+D:\Projekte\Grotti\.venv\Scripts\python.exe D:\Projekte\Grotti\scripts\orca_senden.py C:\pfad\datei.gcode
+```
+
+## Störungen
+
+| Symptom | Check |
+| --- | --- |
+| Anycubic-Dialog trotz Grotti | Du hast Remote Print / Aufgabe starten genutzt → nur **G-code exportieren** |
+| Meldungsfenster „Config fehlt“ | `data/orca-senden.json` anlegen |
+| „Grotti nicht erreichbar“ | Server läuft? `url` stimmt? |
+| „Token fehlt oder stimmt nicht“ | Token neu anlegen, in der JSON eintragen |
+| App-Fenster will Login | Einmal anmelden (Session 30 Tage). Profil: `data/grotti-app-profile`. Zweites Chrome-Fenster schließen, nur eines offen lassen. Grotti neu starten nach Update. |
+| Browser-Tab statt Fenster | In `orca-senden.json` `"browser": "app"` setzen (oder Chrome/Edge fehlt) |
+| Zwei Fenster / Tab hängt | Debounce (~25 s); erneuter Export aktualisiert den offenen Tab. 3D-Pfad lädt verzögert |
+| ACE zeigt T0/T1 statt T1/T10 | Seite neu laden oder **Ordner neu lesen**; Deep-Link zieht `paint_index` nach |
+| Skript läuft nicht | Export wirklich speichern; Zeile im **Prozessprofil**; Python-Pfad prüfen |
+
+## Was Grotti nicht kann
+
+- Den **Anycubic-Cloud-/Aufgabe-Dialog** unterdrücken (liegt im Slicer, nicht im Skript).
+- Sich in Anycubics Reiter **Arbeitsfläche** einbetten. In **Orca** dagegen: Device-UI-URL → Grotti unter **Gerät** (siehe oben).
+
+## Weiter
+
+- [Dateien senden](Anleitung-Dateien.md)
+- [ACE und Spulen](Anleitung-ACE.md)
@@ -0,0 +1,41 @@
+# Projekte
+
+Stand **24.10.2026**. Arbeitsmappen unter `/projekte` — getrennt von Kunden-[Aufträgen](Anleitung-Auftraege.md).
+
+## Wozu
+
+Ein **Projekt** bündelt Konstruktion und Druckdateien in einem Ordner unter dem [Slice-Pfad](Anleitung-Einstellungen.md), z. B. `Projekte/2609_002`.
+
+| | Projekt | Auftrag |
+| --- | --- | --- |
+| Zweck | Konstruktion + Slice-Dateien | Kunde, Menge, Lieferschein |
+| Ort | Ordner auf der Platte | nur in der Datenbank |
+| Seite | `/projekte` | `/auftraege` |
+
+## Anlegen
+
+**Neues Projekt** — Name, Status, optional Ordner (Standard: `Projekte/<Kurzname>`). Mit gesetztem Slice-Ordner legt Grotti den Ordner an.
+
+Filter **Aktiv** / **Fertig** / **Alle** in der Liste. G-code und 3MF in diesem Ordner (oder dorthin [verschoben](Anleitung-Dateien.md)) werden dem Projekt zugeordnet und erscheinen in der Druck-Bibliothek.
+
+## Detail
+
+Im Projekt siehst du Kennzahlen (Läufe, Druckzeit, Filament, Kosten) und drei Tabs:
+
+- **Druckdateien** — Link zur Bibliothek (`?file=` / `?project=`), **Einreihen** pro Datei oder **Alle einreihen** (Warteschlange, mit Bestätigung)
+- **Läufe** — letzte Drucke mit Link zum Protokoll / Bericht
+- **Weitere Dateien** — STEP, STL, PDF, SolidWorks usw. (nicht in der Druck-Bibliothek)
+
+Wenn jede Datei mindestens einmal ok gedruckt wurde, schlägt Grotti vor, den Status auf **fertig** zu setzen.
+
+Deep-Link: `/projekte#<id>`.
+
+## Löschen
+
+Projekt löschen (Zwei-Klick) entfernt den Datensatz und den Ordner **inkl. Inhalt** (`force`). Druckdateien in der Bibliothek verlieren nur die Projekt-Zuordnung, wenn sie woanders liegen; Dateien im Projektordner sind mit dem Ordner weg.
+
+## Weiter
+
+- [Dateien](Anleitung-Dateien.md)
+- [Aufträge](Anleitung-Auftraege.md)
+- [Einstellungen](Anleitung-Einstellungen.md)
@@ -31,7 +31,7 @@ Was tun: Abbruch über Grotti (nicht nur am Display), auf der Wand den Task-Hinw

 ## ACE / „cannot parse“

-ACE-Zuordnung unter Dateien → Optionen prüfen. Spulen am richtigen Platz. Siehe [ACE und Spulen](Anleitung-ACE).
+ACE-Zuordnung unter Dateien → Optionen prüfen. Spulen am richtigen Platz. Siehe [ACE und Spulen](Anleitung-ACE.md).

 ## Offline

@@ -45,6 +45,14 @@ Im Cockpit (nur bei aktivem Druck/Heizen). Danach oft **Strom aus und wieder an*

 Oft noch Verarbeitung auf dem Drucker. In der Sidebar unter **Senden** den Fortschritt beobachten. Nach einem Grotti-Update den Dienst einmal neu starten.

+## „gcode … not found“ (10115)
+
+Oft Dateinamen mit Nicht-ASCII-Zeichen (z. B. Chinesisch). Grotti normalisiert den Namen beim Senden auf ASCII. Nochmal senden; in der Bibliothek darf der Originalname bleiben.
+
+## Drucker „heruntergefahren“ / 10111 / 506 nach Upload
+
+Oft **Einfarbig**-G-code mit `; filament_colour_type` (Orca) — gklib stürzt ab. Grotti entfernt die Zeile beim Senden nur bei Einfarbig. Multicolor bleibt unverändert. Betroffene Drucker: Display-Reboot oder Strom aus/an, dann in Grotti ggf. **Fehler löschen**.
+
 ## Wo nachschauen

 - Sidebar: Alerts, Läuft, Wartet, Senden
@@ -52,5 +60,5 @@ Oft noch Verarbeitung auf dem Drucker. In der Sidebar unter **Senden** den Forts

 ## Weiter

- [Druckerwand](Anleitung-Wand)
- [Warteschlange](Anleitung-Warteschlange)
+- [Druckerwand](Anleitung-Wand.md)
+- [Warteschlange](Anleitung-Warteschlange.md)
@@ -1,14 +1,15 @@
 # Druckerwand

-Stand **15.10.2026**. Startseite `/` — eine Karte je Drucker. Klick öffnet das Cockpit.
+Stand **24.10.2026**. Startseite `/` — eine Karte je Drucker. Klick öffnet das Cockpit.

-![Druckerwand](/static/doku/wand-uebersicht.png)
+![Druckerwand](../web/static/doku/wand-uebersicht.png)

 ## Karte

 Pro Drucker siehst du:

 - Zustand (Chip), Fertig-Uhrzeit, Fortschrittsbalken
+- Kleines Kamerabild (Snapshot ca. alle 3 s), wenn eine Webcam erreichbar ist — Klick öffnet das Cockpit
 - Restzeit, Schicht, Laufzeit
 - Temperaturen Düse/Bett (mit Ziel)
 - Dateiname, bei ACE oft Farb-Swatches
@@ -18,7 +19,7 @@ Aktionen auf der Karte brauchen oft **zwei Klicks** (erster Klick „scharf“,

 | Aktion | Wann |
 | --- | --- |
-| **Pause** / **Weiter** | Während des Drucks |
+| **Pause** / **Weiter** | Während des Drucks; nach Materialwechsel gelber Hinweis mit ACE-Platz → Link zu Material (Drucker/Platz vorausgefüllt), Speichern, dann **Weiter**. Dieselbe Charge läuft weiter. |
 | **Abbrechen** | Druck oder Pause |
 | **Fehler löschen** | Zustand Fehler — räumt den hängenden Fehler, Heizung aus |
 | **Platte geräumt** | Nach Fertig, wenn die Platte wieder frei ist |
@@ -30,14 +31,16 @@ Während eines Abräum-Ablaufs blendet Grotti „Platte geräumt“ aus — der

 URL mit Hash: `/#<host>` (z. B. nach Klick auf die Karte).

-![Cockpit eines Druckers](/static/doku/cockpit.png)
+![Cockpit eines Druckers](../web/static/doku/cockpit.png)

 Inhalt:

- **Kamera** — nur wenn eine Webcam erreichbar ist; sonst bleibt der Platz weg
+- **Kamera** — nur wenn eine Webcam erreichbar ist; sonst bleibt der Platz weg. Modus Snapshot/Stream unter Einstellungen → Dieser Browser (gilt nur im Cockpit; die Wand-Thumbs sind immer Snapshot)
 - Status, Temps inkl. Bauraum wo verfügbar, Lüfter
- **Steuerung:** Zieltemperaturen, Speed, Flow, Fan — fest vorgegebene Befehle, keine freie Konsole
+- **Steuerung:** Zieltemperaturen, Speed, Flow, Fan — fest vorgegebene Befehle, keine freie Konsole. Mit ACE zusätzlich Trockner (Temp, Dauer, Start/Stopp) und pro bestücktem Platz **an den Drucker** (Sorte und Farbe aus der Grotti-Spule)
 - **E-Stop** nur bei printing/paused/heating (Zwei-Klick). Danach oft Strom aus/an
+- **Verlauf** Temperatur und ED des aktuellen oder letzten Drucks; Links zu Datei und Druckbericht (dort Kosten: Filament + Grundlast/Düse/Bett)
+- **Als Nächstes** (nur wenn der Drucker frei und die Platte quittiert ist): **Nochmal** der letzten Datei, Hinweis zur Warteschlange, passende Dateien nach Familie/Material — Start mit Standardwerten oder **Anpassen…** unter Dateien
 - **3D-Pfad** der laufenden oder gewählten Datei; Objekte ausschließen (mit Bestätigung)
 - **Bettnetz**-Heatmap, wenn vorhanden

@@ -45,10 +48,10 @@ Inhalt:

 - Gesperrte Drucker (Einstellungen) starten keine neuen „wenn frei“-Jobs.
 - Live-Daten kommen mit wenigen Sekunden Verzögerung.
- Ein Task-Hinweis auf der Karte zeigt, wenn auf dem Drucker noch ein alter Auftrag hängt — siehe [Störungen](Anleitung-Stoerungen).
+- Ein Task-Hinweis auf der Karte zeigt, wenn auf dem Drucker noch ein alter Auftrag hängt — siehe [Störungen](Anleitung-Stoerungen.md).

 ## Weiter

- [Dateien senden](Anleitung-Dateien)
- [Warteschlange und Ablauf](Anleitung-Warteschlange)
- [Störungen](Anleitung-Stoerungen)
+- [Dateien senden](Anleitung-Dateien.md)
+- [Warteschlange und Ablauf](Anleitung-Warteschlange.md)
+- [Störungen](Anleitung-Stoerungen.md)
@@ -1,8 +1,8 @@
 # Warteschlange und Ablauf

-Stand **15.10.2026**. Aufträge „wenn frei“, Priorität, und der Kobra-3-Ablauf (drucken → abkühlen → schieben → tasten).
+Stand **18.10.2026**. Aufträge in der Warteschlange (Dieser Drucker / Nächster passender), Priorität, und der Kobra-3-Ablauf (drucken → abkühlen → schieben → tasten).

-![Warteschlange](/static/doku/warteschlange.png)
+![Warteschlange](../web/static/doku/warteschlange.png)

 ## Seite Warteschlange

@@ -16,11 +16,13 @@ Pro Auftrag:

 Unter **Läuft** siehst du auch Direktstarts ohne Queue-Zeile (Link zur Wand).

-Dieselbe Information steht kompakt in der Sidebar (**Läuft jetzt** / **Wartet**).
+Dieselbe Information steht kompakt in der Sidebar (**Läuft jetzt** / **Wartet**). Unter **Läuft jetzt** eine Zeile pro Drucker; Klick öffnet diese Seite, × bricht ab.
+
+Reicht der Spulenrest nicht für wartende Jobs, erscheint oben ein **Fehlmenge**-Hinweis (Details unter Material → Bedarf) und in der Sidebar unter **Bedarf**.

 ## Wann startet ein wartender Auftrag?

-Sobald der Drucker bereit ist (`standby` / fertig / abgebrochen), die **Platte frei** ist und der Drucker nicht gesperrt. Automatik aus (`auto_queue`) oder gesperrt → keine neuen Starts; laufende Abläufe laufen weiter.
+Sobald der Drucker bereit ist (`standby` / fertig / abgebrochen), die **Platte frei** ist und der Drucker nicht gesperrt. Automatik aus (`auto_queue`) oder gesperrt → keine neuen Starts; laufende Abläufe laufen weiter. Mit **Start-Zeitfenster** in den Einstellungen nur innerhalb von Von/Bis.

 ## Ablauf (nur Kobra 3)

@@ -34,7 +36,7 @@ Drucken → Abkühlen → Schieben → Tasten → (Wiederholung)
 | --- | --- |
 | **Abkühlen** | Wartet, bis Bett und Düse unter der Grenze sind. PLA löst sich oft von selbst. |
 | **Schieben** | Extruder schiebt das Teil von hinten nach vorn in die Kiste. |
-| **Tasten** | LeviQ-Netz tippt; Maß aus `Result is z=`. Über 1 mm stoppt den Ablauf. |
+| **Tasten** | LeviQ-Netz tippt; Maß aus `Result is z=`. Über 3 mm stoppt den Ablauf (Default; enger geht unter Einstellungen/Ablauf). |

 Aktueller Schritt: auf der Druckerkarte und in der Sidebar. Abbrechen an beiden Stellen. Jeder Schritt landet unter **Aktivität**.

@@ -48,5 +50,5 @@ Aktueller Schritt: auf der Druckerkarte und in der Sidebar. Abbrechen an beiden

 ## Weiter

- [Druckerwand](Anleitung-Wand)
- [Störungen](Anleitung-Stoerungen)
+- [Druckerwand](Anleitung-Wand.md)
+- [Störungen](Anleitung-Stoerungen.md)
@@ -0,0 +1,12 @@
+# Wartung
+
+Stand **18.10.2026**. Druckstunden, Filament-Meter und Verschleißteile je Drucker.
+
+## Seite Wartung
+
+Unter **Wartung** siehst du je Drucker die Summe aus dem Protokoll (Stunden, Meter, Starts). Teile mit Soll-Lebensdauer (Stunden oder Meter) und Einbaudatum; bei Reset wird der Zählerstand protokolliert.
+
+## Weiter
+
+- [Einstellungen](Anleitung-Einstellungen.md)
+- [Statistik](Anleitung-Oberflaeche.md)
@@ -0,0 +1,47 @@
+# Grotti — Community-Vorstellung
+
+Screenshots aus dem laufenden Betrieb (v3.4.0, Okt. 2026). Zielgruppe: mittlere bis große Printfarmen.
+
+Logo und Repo-Banner: [`docs/brand/`](../brand/). Haupt-README: [`../../README.md`](../../README.md).
+
+---
+
+## Kurztext (zum Posten)
+
+**Grotti** ist ein Farm-Manager für Moonraker/Klipper-Drucker — gebaut für den Alltag mit mehreren Maschinen, nicht für den Einzelplatz.
+
+Statt zehn Tabs und Excel: eine Wand, eine Warteschlange, Material und Abräumen an einem Ort. Orca/AnycubicSlicerNext schicken den G-code per Nachbearbeitungsskript rein; Grotti wählt den nächsten freien Drucker (inkl. ACE-Farbe/Rest), startet im Zeitfenster und meldet, wenn die Platte geräumt werden muss oder Spule fehlt.
+
+**Was schon geht**
+
+- **Druckerwand + Cockpit** — Live-Status, Temps, Pause/Cancel/E-Stop, Farm-ETA („Alles fertig um …“)
+- **Jetzt-Liste** — Platte räumen, Materialbedarf, Wartung, überfällige Aufträge als To-do oben
+- **Warteschlange** — Priorität, Termine, Auto-Retry, Routing „nächster freier“ mit Material-Match
+- **Kobra-3-Ablauf** — Druck → Abkühlen → Schieben → Tasten (unbeaufsichtigte Serie)
+- **Material** — Spulen am Drucker/Regal, Chargen, Restgewicht, Fehlmenge aus der Queue
+- **Aufträge** — Kunden, Positionen, Einreihen, Lieferschein, Stück-Fortschritt aus dem Abräumen
+- **Kosten & Statistik** — Material + Strom (auch HT/NT), €/Teil, Yield, Ausschussgründe
+- **Wartung** — Laufstunden/Filamentmeter, Verschleißteile mit Intervallen
+- **Betrieb** — Auth (Session/API-Token), Telegram/ntfy, PWA/Regal-Touch, Ctrl+K-Suche
+
+Stack: Python, PostgreSQL, Moonraker. UI auf Deutsch. Self-hosted.
+
+Fragen und Feedback willkommen.
+
+---
+
+## Screenshots
+
+| Datei | Inhalt |
+| --- | --- |
+| [01-druckerwand.png](01-druckerwand.png) | Farm-Übersicht, gruppiert nach Modell |
+| [06-jetzt.png](06-jetzt.png) | Jetzt-Popover: Abräumen + Materialbedarf |
+| [07-cockpit.png](07-cockpit.png) | Einzeldrucker mit Job, Spule, Steuerung |
+| [02-warteschlange.png](02-warteschlange.png) | Queue mit Status und Fehlmenge |
+| [09-dateien.png](09-dateien.png) | Bibliothek + Senden an mehrere Drucker |
+| [03-material.png](03-material.png) | Spulenbestand und Bedarf aus der Queue |
+| [04-auftraege.png](04-auftraege.png) | Kundenaufträge und Positionen |
+| [05-statistik.png](05-statistik.png) | KPIs: Läufe, Kosten, Erfolg, Schätztreue |
+| [08-wartung.png](08-wartung.png) | Laufzeit und Filament je Maschine |
+
+Empfohlene Reihenfolge im Post: Wand → Jetzt → Warteschlange → Material → Statistik.
@@ -0,0 +1,86 @@
+# Grotti HTTP-API (`/api/v1`)
+
+Stand für Android/App-Clients und Integrationen. Nutzer-Anleitungen bleiben unter `docs/Anleitung-*.md`.
+
+## Auth
+
+| Weg | Header / Cookie | CSRF |
+| --- | --- | --- |
+| Session | Cookie nach `POST /auth/login` | `X-CSRF-Token` bei mutierenden API-Calls |
+| Bearer | `Authorization: Bearer grt_…` | nicht nötig |
+
+**Token ausstellen**
+
+- Eingeloggt: `POST /tokens` `{name, role?}` → Klartext einmalig in `token`
+- Ohne Session (App): `POST /auth/token` `{username, password, device_name?, role?}` → `201` mit `token` + `user` (Rate-Limit wie Login)
+
+Öffentlich ohne Login: `/auth/status`, `/auth/login`, `/auth/token`, `/auth/setup`, `/version`.
+
+Rollen: `operator` ≤ `admin`. Admin-only u. a. Benutzer, Backup, volle Einstellungen, Drucker anlegen.
+
+**Medien mit Query-Token** (nur GET): `?token=grt_…` für Kamera, Live-Vorschau, Datei-Vorschau (`/dateien/<id>/vorschau`), Projekt-Assets.
+
+## Fehler
+
+```json
+{"error": "Text", "code": "kurzcode"}
+```
+
+HTTP-Status: 400/401/403/404/409/429/503. Bild-Endpunkte liefern bei fehlendem Bild ebenfalls dieses JSON (nicht nur leeren 404).
+
+## Pagination
+
+Listen akzeptieren `limit` / `offset` wo sinnvoll. Antwort bleibt ein **JSON-Array**; Gesamtzahl im Header `X-Total-Count`.
+
+Ohne `limit` liefern `/dateien` und `/spulen` die volle Liste (Web-UI).
+
+## Bestätigung
+
+Mutierende Druckaktionen brauchen oft `"confirm": true`:
+
+- `POST /senden`, `POST /druck-queue`, `POST /ablauf`
+- `POST /projekte/<id>/einreihen`, `POST /auftraege/<id>/einreihen`
+- `POST /drucker/<host>/abraeumen`
+- `steuern` mit `emergency_stop`, `clear_error`, `exclude_object`
+
+## Server-Info
+
+`GET /version` → `{name, version, api: 1, features: [...]}`.
+
+## SSE Live
+
+`GET /stream` (Session-Cookie oder Bearer). Events:
+
+| Event | Bedeutung |
+| --- | --- |
+| `ping` | Keepalive (~15 s), Payload `{}` |
+| `drucker` | Live-Zustand der Drucker geändert |
+| `queue` | Druckwarteschlange geändert |
+| `senden` | Sende-Auftrag geändert |
+| `ereignis` | Neues Ereignis / Aktivität |
+| `aufgaben` | Offene Aufgaben (Platte …) |
+
+Ohne Stream: Client pollt `/drucker?live=1`, `/jetzt`, `/druck-queue`.
+
+## Push an Geräte
+
+Grotti sendet **kein** FCM. Empfohlen: **ntfy** (Topic unter Einstellungen). Die App kann denselben Topic abonnieren; Secrets (ntfy-Token) bleiben serverseitig.
+
+## Wichtige Ressourcen
+
+| Bereich | Pfade |
+| --- | --- |
+| Drucker | `GET /drucker?live=1`, `POST /drucker/<host>/pause\|fortsetzen\|abbrechen` (Alias `resume`/`cancel`), `…/steuern`, `…/abraeumen` |
+| Dateien | `GET /dateien?family=&material=&project_id=&host=&q=&limit=&offset=`, Upload multipart, `…/vorschau`, `…/pfad` |
+| Senden / Queue | `POST /senden`, `GET /senden-zuletzt?host=&file_id=`, `GET\|POST /druck-queue?host=&status=`, `POST /ablauf` |
+| Projekte | `GET\|POST /projekte`, `GET /projekte/<id>`, `…/laeufe`, `POST …/einreihen`, Assets |
+| Aufträge | `GET\|POST /auftraege`, Positionen, `…/einreihen` |
+| Material | `GET /spulen?aktiv=1`, Akte, Einlegen |
+| Protokoll | `GET /laeufe`, `GET /laeufe/<id>`, `GET /statistik?project_id=` |
+| Kamera | `GET /kamera?host=`, `…/stream` |
+
+Pfadnamen sind überwiegend **deutsch**. Aktionen: deutsch + englische Alias für Pause/Resume/Cancel.
+
+## MCP
+
+`python -m grotti.mcp_server` nutzt dieselbe REST-API (Teilmenge). Siehe `docs/internal/MCP.md`.
@@ -6,7 +6,7 @@ Nach dem Druck kann Grotti auf der **Kobra 3** Bett und Düse abkühlen und die

 ## Quittierung vs. Schieben

- **Wand „Platte geräumt“:** Nur Quittierung. Tabelle `bed_status`, API `POST /api/v1/drucker/<host>/abraeumen` mit `confirm`. Fährt keine Bahn. `needs_clear` setzt der Watcher bei Druckende/Abbruch/Fehler (nicht schon beim Start). Solange gesetzt, startet „wenn frei“ den nächsten Job nicht.
+- **Wand „Platte geräumt“:** Quittierung + optional Urteil. Tabelle `bed_status`, API `POST /api/v1/drucker/<host>/abraeumen` mit `confirm`. Fährt keine Bahn. Offener Live-Lauf wird als `completed` geschlossen (History von Moonraker oft ohne Endzeit). `needs_clear` setzt der Watcher beim Live-Übergang Druckende/Abbruch/Fehler (nicht schon beim Start; nicht blind beim ersten Blick nach Neustart). Solange gesetzt, startet „wenn frei“ den nächsten Job nicht.
 - **Ablauf (Dateien):** Drucken → Abkühlen → Schieben → Tasten, dann der nächste Druck mit LeviQ. Eine Bestätigung beim Einreihen; Schieben läuft ohne zweite Rückfrage. Nach erfolgreichem Schieben ist die Platte automatisch quittiert.
 - **Normale Drucke** und „Nochmal“ schieben nicht — nach dem Druck muss man auf der Wand quittieren.

@@ -17,7 +17,7 @@ Unter **Dateien** erscheint die Karte **Ablauf**, sobald mindestens eine Kobra 3
 - **Drucken** — Datei, Bettnetz (LeviQ) standardmäßig an
 - **Abkühlen** — Heizung aus, Lüfter an, Düse in die Bettmitte, warten bis Bett/Düse unter den Grenzen
 - **Schieben** — Bahn mit einstellbaren Zahlen, danach Lüfter aus
- **Tasten** — kein `G28 Z`. **Mit aktivem LeviQ-Netz** (kein `BED_MESH_CLEAR`): `Result` = Höhe über der lokalen Platte. Bezugspunkt + Tastpunkt (x/y) einstellbar. Maß: letztes `Result is z=` aus dem Store. Über 1 mm = Restteil.
+- **Tasten** — kein `G28 Z`. **Mit aktivem LeviQ-Netz** (kein `BED_MESH_CLEAR`): `Result` = Höhe über der lokalen Platte. Bezugspunkt + Tastpunkt (x/y) einstellbar. Maß: letztes `Result is z=` aus dem Store. Über `max_delta_mm` (Default 3 mm) = Restteil. Enge 1 mm/2,5 mm-Werte aus alten Abläufen werden auf 3 mm angehoben (kalt an der Düse sonst Fehlalarm).

 Darunter **wie oft hintereinander**. Einreihen legt einen Eintrag in die Warteschlange „Wenn frei“. **Schieben testen** fährt die Bahn auf einer freien Kobra 3 (Bestätigung „Bett ist leer“). Werte merkt sich der Browser lokal.

@@ -134,8 +134,23 @@ Ohne Map: Rinkhals füllt oft Identity T0→Platz0 … — deshalb Grotti bei ei
 | Slots anzeigen | Moonraker `mmu` (Rinkhals) | `mmu_ace.py` |
 | Kein Firmware-Restart | abgelehnt | Rinkhals #32, `patch_klipper_restart` |

+## History nach Filament-Pause
+
+Runout, Rolle tauschen, Fortsetzen: Anycubic schließt den History-Job als `cancelled` und öffnet eine neue Job-ID. Beobachtet am 2026-10-25 auf Kobra 3 A1 (`000040` → `000041`):
+
+- Der neue `start_time` liegt etwa 0,04 s nach dem `end_time` des alten.
+- `print_duration` und `total_duration` sind an beiden Einträgen gleich und laufen weiter. Der Zähler beginnt nicht bei 0.
+- `/server/history/list` liefert neueste zuerst. Grotti sortiert pro Drucker nach `start_time`, sonst kommt die Fortsetzung vor ihrem Vorgänger dran (`jobs.history_in_order`).
+- Nach dem Zusammenlegen hängt die alte Job-ID in `run_jobs` am Lauf. `store.history_job_retired` überspringt sie, sonst schreibt sie `cancelled` zurück.
+- Zusammenlegen nur mit Beweis: `print_duration` fortgesetzt und Lücke ≤ 5 s, oder Watcher `paused→printing` (`docs/internal/Lauf-Identitaet.md`).
+
 ## Offene Grenzen

 - Quellcode von **gkapi** (Task-State-Machine, exakte 10101-Bedingungen) ist nicht öffentlich.
 - Deadlock in **FIRMWARE_RESTART** ist beobachtet und in Rinkhals abgefangen, Root Cause im Binary nicht freigelegt.
 - Kobra X / K4-Stack ist ein anderes System (C++-Klipper), nicht GoKlipper — für unsere Drucker irrelevant.
+
+## Siehe auch
+
+- [Makros-Kobra](Makros-Kobra.md) — Nicht-tun, Vanilla-Alltag, ACE, LeviQ/Wipe je Druckertyp
+
@@ -1,6 +1,6 @@
 # Chargen, Etiketten und 3D-Viewer

-Stand 14.10.2026.
+Stand 17.10.2026.

 ## Spulen-Chargen

@@ -10,9 +10,15 @@ Scannen: auf Material den Code tippen oder per USB-Handscanner (Tastatur + Enter

 Etikett: `/etikett/<id>`, Druck über den Browser. QR per lokalem `qrcode.min.js` (`web/static/`). Basis-URL für den QR kommt aus Einstellungen → **FQDN** (`config.json` Key `fqdn`); leer = Host der aktuellen Anfrage. Beispiel: `https://grotti.example.de/material?spool=12`.

+## Druck-Chargen
+
+`D-YYYYMMDD-0001` vergibt der Watcher am aktiven Lauf (History-Job, sonst Live). Die nächste Nummer zählt Läufe und schon vergebene Objekt-Etiketten, damit eine Charge nicht doppelt entsteht. `adopt_live_run` übernimmt die Nummer nur auf einen fertigen History-Lauf ohne eigene Charge. Objekt-Etiketten (`D-…-01`) wandern nur mit, wenn der Ziel-Lauf dieselbe Charge behält; sonst fallen sie mit dem Live-Lauf weg und werden unter der verbleibenden Charge neu vergeben.
+
+Druck über `/etikett/lauf/<id>?mode=druck|objekt`. Auf dem Bogen: Charge, **Soll … g** (Slicer-Filamentmenge), Drucker, Material (Abzug oder Send/ACE/Lauf-Spule), QR 20 mm im 70‑mm-Bogen. Wand: Knopf **Etikett** bei Druck/Pause. Urteil Ausschuss ändert die Charge nicht — gedruckte Bögen verwerfen.
+
 ## 3D-Pfad

-`GET /api/v1/dateien/<id>/pfad` liefert einen gedünnten Toolpath (bis ca. 120 000 Punkte, plus `layer_breaks`, Cache-`version` 5) aus dem lokalen G-code. Die Dateien-Seite und das Cockpit zeichnen ihn mit Three.js.
+`GET /api/v1/dateien/<id>/pfad` liefert einen gedünnten Toolpath (bis ca. 220 000 Punkte, plus `layer_breaks`, Cache-`version` 8) aus dem lokalen G-code. Thinning behält ganze Z-Höhen dicht und lässt nur ganze Schichten weg (sonst gesprenkelte Wände). Die Dateien-Seite und das Cockpit zeichnen ihn mit Three.js.

 Darstellung: nur Extrusionswege. Preview = orange. Live: gedruckt leicht verdickt grün, offen grau; Schnitt nach `progress`. Parser akzeptiert `E.39`/`Z.6`. Bett: Gitter 10 mm, mm-Sprites, Legende.

@@ -1,6 +1,8 @@
 # Grotti-Dateien Metadaten

-`stored_path` liegt nur in der DB und in Rohzeilen (`get_file_row`, `list_file_rows`). Die API-Antwort (`file_out` / `GET /api/v1/dateien`) enthält den Pfad bewusst nicht.
+`stored_path` liegt nur in der DB und in Rohzeilen (`get_file_row`, `list_file_rows`). Die API-Antwort (`file_out` / `GET /api/v1/dateien`) enthält den Pfad bewusst nicht — stattdessen berechnet `folder` den Relativ-Elternordner unter `watch_dir` (Uploads → `Upload`).
+
+Verschieben einer Watch-Datei: Dateisystem unter `watch_dir` + `UPDATE files.stored_path` über dieselbe ID (`library.move_file`), damit Projekt/Spule erhalten bleiben. Reiner Re-Scan nach manuellem Verschieben würde die ID verlieren.

 `POST /api/v1/dateien/neu-lesen` liest Watch-Ordner neu und ruft `refresh_file_meta` auf Rohzeilen auf — nicht auf `list_files`, sonst `KeyError: 'stored_path'`.

@@ -12,7 +14,7 @@ In der Bibliothek gespeichert:

 | Feld | Bedeutung |
 |------|-----------|
-| `filaments` | Typ/Farbe (`paint_info` oder `filament_type`/`filament_colour`) |
+| `filaments` | Typ/Farbe (`paint_info` oder `filament_type`/`filament_colour`) plus `profile` aus `filament_settings_id` (Sorte, z. B. Sunlu PLA Meta) |
 | `weight_g` / `estimated_s` | Filamentgewicht und Druckzeit |
 | `printer_family` | aus `printer_model` |
 | `slice_meta` | jsonb: `layer_height`, `layers`, `max_z_mm`, `nozzle_mm`, `temp_nozzle`, `temp_bed`, `slicer` |
@@ -0,0 +1,26 @@
+# Druckbericht und Statistik
+
+Stand **17.10.2026**.
+
+## Tabellen
+
+- `runs`: zusätzlich `weight_planned_g`, `weight_used_g`, `weight_source`, `filament_used_mm`/`filament_total_mm`, `progress_last`, `estimated_s`, `chargen_nr`, `message`, `objects`
+- `run_spools`: Abzug je Spule (`is_estimate` bei Mehrfarb)
+- `run_segments`: Abschnitte bei Rollenwechsel (Einlegen während Druck/Pause)
+- `run_samples`: Temperatur/Soll/ED (`nozzle_power`/`bed_power`) — alle ~30 s, beim Aufheizen ~10 s; Proben schon vor `printing`, wenn Targets gesetzt und Auftrag/Live-Lauf bekannt
+- `run_labels`: Objekt-Chargen `D-…-01`
+- `events.run_id`: optionaler Bezug zum Lauf
+
+## Abzug
+
+`grotti/usage.py` rechnet Ist-Gramm aus `filament_used` / `filament_total` × Soll. Abbruch ohne Extrusion: 0. Ohne Zähler: Fortschritt × Soll (Schätzwert). Fertig ohne Messgröße: Soll bleibt, Quelle `estimate`.
+
+`apply_deduction` schreibt zuerst `run_spools`, dann `deducted`/`remaining_g` (auch unter 0); `ensure_run_chargen` oft schon während des Laufs. Ohne `run_spools` bleibt die Spulenakte leer.
+
+## Live
+
+`StateWatcher` hängt am offenen History-Job oder legt `live:…` an, schreibt Proben, vergibt `chargen_nr`, merkt Objektnamen. Vor neuem Start: `abandon_live_runs`. `sync_history` übernimmt Proben/Segmente (`adopt_live_run`, nicht auf ältere fertige Jobs derselben Datei). Die Live-Charge geht nur auf einen fertigen Lauf ohne Nummer über; Objekt-Etiketten nur zusammen mit dieser Charge. Sonst werden sie neu vergeben, statt eine fremde `D-…-01` zu blockieren.
+
+## Statistik-Filter
+
+`since` inklusiv, reines `until` als Datum (`YYYY-MM-DD`) inklusiv (intern Folgetag exklusiv). Presets in der UI setzen Von/Bis. CSV nutzt dieselben Query-Parameter.
@@ -1,55 +1,40 @@
 # Grotti: Alltag und Oberfläche

-Stand **14.10.2026**, v1.4.0.
+Stand **18.10.2026**, v3.3.0.

 ## Design

- Dunkles UI mit Orange-Akzent, Lucide-ähnliche Stroke-Icons (SVG-Sprite in `layout.html`).
- Kurze Seitenuntertitel; Technik-/Config-Hinweise liegen in der Doku, nicht als Fließtext in den Formularen.
- Einheitliche Seitenköpfe, Toolbar-Filter, kompakte Tabellen, Formularfelder mit kleinen Labels, Empty-States mit Icon.
- **Anzeige pro Browser** (Einstellungen → Dieser Browser): `Desktop` oder `Regal (Touch)` in `localStorage grotti-display`. Shortcut `?shelf=1` / `?shelf=0`. Regal: größere Controls, kompakte Nav (Drucker/Kameras/Warteschlange), Sidebar default eingeklappt.
- Seitenmenü einklappbar (Icon-Rail, `grotti-nav-collapsed`). Unter 760 px weiter Bottom-Nav.
+- Dunkles UI mit Orange-Akzent; Light-Theme über dieselben Tokens (`html[data-theme]`).
+- Schrift **Inter** (variable, lokal unter `web/static/fonts/`).
+- Icons: **Lucide** als Sprite `web/static/icons.svg` (bauen mit `python scripts/build_icons.py`), IDs `i-<name>`.
+- Komponenten: Toolbar, Card-Head, KPI-Karten, Chips (Zustände + Queue + Urteile), Dialog-Kopf/Fuß, Empty-States, Skeleton.
+- Primär: `btn-primary` / `go-btn`; Danger: `btn-danger` / `warn`; Icon-Buttons mit `title`/`aria-label`.
+- **Anzeige pro Browser**: Desktop oder Regal (Touch); Zeitzone; Nav einklappbar.
+- PWA: `manifest.webmanifest` + Service-Worker (Shell-Cache inkl. Icons/Font).
+- Live: SSE `/api/v1/stream` plus Poll-Fallback; Verbindungsbanner.
+- Ctrl+K: globale Suche (`/api/v1/suche`); Knopf in der Topbar.
+- Kamera: Snapshot (gecacht) oder MJPEG-Stream (`/api/v1/kamera/stream`), Browser-Einstellung `grotti-camera`.

-## Seitenleiste
+## Seitenleiste und Topbar

- Hauptmenü: Drucker, Dateien, Kameras, Aktivität, Warteschlange, Protokoll, Material, Projekte. Darunter Einstellungen, Ideen, Doku (mit Icons); Fuß **© by dominic@gundel.dev** und Version (Changelog).
- Live-Leiste, eigene Scrollfläche, Boxen auf- und zuklappbar (Zustand in `localStorage` `grotti-live-closed`):
-  - **Läuft jetzt**: laufende Aufträge und Abläufe mit Schrittleiste, Durchlauf `n/m`, aktueller Phase und ×-Abbrechen; auch Direktstarts ohne Queue.
-  - **Wartet**: wartende Aufträge mit Ziel, Priorität hoch/runter, Abbrechen; die letzten Fehler mit Fortsetzen/ausblenden.
-  - **Aufgaben**: Platte belegt ohne Ablauf — „geräumt“ per Zwei-Klick.
-  - **Senden**: laufende Uploads mit Fortschritt.
-  - **Alerts**: ungelesene wichtige Ereignisse, „gelesen“, Link auf Aktivität.
- Aktualisierung: Senden 2 s, Queue 4 s, Aufgaben/Alerts 8 s.
+- Sidebar: Abschnittslabels **Live** / **Rückschau** / **Verwalten** (ohne Live-Panel).
+- Topbar-Live-Chips (**Jetzt** · Läufe · Senden · Meldungen) mit Popover; Farm-ETA nur bei mehreren Läufen.
+- Mobile: Tab **Jetzt** (`/jetzt`) statt Aktivität in der unteren Leiste; Aktivität unter Mehr.
+- Topbar: Suche, Einstellungen, Doku, Benutzer-Menü (Avatar → Abmelden, Version, Copyright).
+- Mobile: Bottom-Nav Drucker · Dateien · Warteschlange · Aktivität · **Mehr** (Sheet inkl. Abmelden); Topbar ausgeblendet, Suche als Icon in der Brand-Zeile.

-## Wand
+## Wand und Abräumen

- Karte je Drucker: Zustandschip, Fertig-Uhrzeit groß, Fortschrittsbalken, drei Kacheln (Rest, Schicht, Läuft), Temperaturbalken Düse/Bett mit Ziel, Datei. Klick auf die Karte öffnet das Cockpit. Pause, Abbrechen, Fehler löschen und Platte geräumt bleiben auf der Karte (Zwei-Klick).
- Laufender Ablauf als Streifen mit Schrittleiste und Abbrechen. Wartende Aufträge für diesen Drucker als Hinweis.
- Streifen „Fehler“ mit **Fehler löschen** und „Platte belegt“ mit **Platte geräumt** (während eines Ablaufs ausgeblendet, der räumt selbst).
- **Cockpit** (Hash `/#<host>`): Kamera (Frame-Vorladen; zugeklappt oder ohne Kamera → eine Spalte, kein leeres 16:10), Status, Temps inkl. Bauraum wenn vorhanden, Lüfter-Icons, Steuerung, 3D-Pfad (Exclude-Object), Bettnetz. E-Stop nur bei printing/paused/heating, Zwei-Klick. Live vom Watcher.
+- Karten + Cockpit; Technik-Fold mit Icons je Abschnitt.
+- **Platte geräumt** öffnet Dialog: gut/Ausschuss, Grund, Stückzahlen.

-## Dateien und Senden
+## Aufträge und Wartung

- Links Bibliothek: Suche, Filter Maschine/Projekt, Vorschaubild; Zeile zeigt Material, Zeit, Gewicht, Schichthöhe, Maschine, Projekt; Details per Info-Popup. Metadaten aus G-code-Kopf **und** Footer. Hochladen / Ordner neu lesen.
- Rechts der Flow: Datei → Drucker (Live-Zustand, eingelegte Rolle) → Wann (Jetzt / Wenn frei / Nächster freier) oder Reiter Ablauf.
- Kein freies Spulen-Dropdown: Abzug nimmt die Rolle(n) am Ziel-Drucker zur Startzeit. ACE: Zuordnung Datei-Farbe → Platz. Warnung bei Material-Mismatch oder zu wenig Rest.
- Startknopf mit Zwei-Klick bei „Jetzt“. Auswahl in `localStorage` `grotti-send-v1`.
+- `/auftraege`: Kunden, Positionen, Einreihen, Lieferschein. Status als Chip.
+- `/wartung`: Stunden/Meter und Verschleißteile.

-## Material
+## Dateien, Material, Statistik

- Reiter **Spulen** / **Sorten**. Scan-Feld im Seitenkopf.
- Spulen: Filter Alle / Am Drucker / Regal / Wenig Rest + Suche. Formular nur bei Auswahl oder „Neue Spule“ (× schließt). Ort = Drucker · ACE/extern bzw. Regal.
- Sorten: Profile (Dichte, mm³/s, Preis, Maschinen). Anlegen/ändern/löschen; „Spule damit anlegen“ wechselt zum Spulen-Reiter.
-
-## Warteschlange
-
- Seite `/warteschlange`: Filter Läuft / Wartet / Fehler / Historie. Priorität, Abbrechen, Fortsetzen.
- Unter **Läuft** / **Alle aktiv** auch Direktstarts aus `/laeuft` (ohne Queue-Zeile), mit Fortschritt und Link zur Wand.
-
-## Aktivität
-
- Zeitstrahl nach Tagen. Filter in der URL. Ungelesene Alerts markiert.
-
-## Kameras und Handy
-
- Kamerakacheln mit Live-Zustand (`live=1`). Snapshot-Cache 2 s. Unter 760 px: Schnellmenü Drucker / Dateien / Aktivität.
+- Bibliothek mit Toolbar/Suche; Senden-Schritte nummeriert.
+- Material: Spulen/Sorten-Tabs, Filter-Toolbar.
+- Statistik: KPI-Karten mit Icons.
@@ -0,0 +1,31 @@
+# Lauf-Identität: ein physischer Druck = ein Lauf
+
+## Regel
+
+Zusammengelegt wird nur mit **Beweis**, nicht nur wegen Zeit und Dateiname:
+
+1. Der neue Moonraker-Job hat `print_duration` ≥ Dauer des Vorgängers − 30 s, und die Lücke `end→start` ist höchstens 5 s (Anycubic setzt `end_time` erst beim Fortsetzen).
+2. Oder der Watcher hat `paused → printing` bei gleicher Datei gesehen (`watcher_resume`, `printers.active_run_id`).
+
+Ein Neustart mit `print_duration` ≤ 60 s wird nie zusammengelegt.
+
+## Pfade
+
+| Pfad | Datei |
+| --- | --- |
+| Beweis | `jobs.is_filament_resume` |
+| Fold | `jobs.fold_filament_resume` |
+| Abgleich | `jobs.sync_history` (Advisory-Lock) |
+| Job-Aliase | `run_jobs` + `history_job_retired` |
+| Leere Hülle | übersprungen in `_sync_one_job` |
+| Live-Abzug | erst History; Fallback nach 10 min (`LIVE_DEDUCT_FALLBACK_S`) |
+| Manuell | `POST /api/v1/laeufe/<id>/verbinden` |
+
+## Queue
+
+In `print_active` heißt nur `complete` fertig. `cancelled`/`standby` werden entprellt (`TERMINAL_CONFIRM_HITS`). Echter Abbruch → Status `cancelled`, nicht „Fertig.“.
+
+## Reparatur
+
+`scripts/laeufe_reparieren.py` (Probelauf standardmäßig, `--apply` nach Freigabe).
+Verwaiste `live:`-Läufe nur an offenen History-Jobs **derselben Datei**; `adopt_live_run` greift geschlossene Live-Läufe nur ≤ 2 h.
@@ -1,6 +1,8 @@
 # MCP-Server

-Stand **15.10.2026**. Agenten steuern Grotti nur über die HTTP-API mit einem API-Token.
+Stand **19.10.2026**. Agenten steuern Grotti nur über die HTTP-API mit einem API-Token.
+
+Beim Connect bekommt der Client die Server-Anweisung aus `grotti/mcp_server.py` (`INSTRUCTIONS`): Deutsch antworten, Host und Datei-id nachschlagen, erst lesen dann schreiben, `confirm=true` nur auf klaren Wunsch, Warteschlange vor Sofortstart, Filament-Pause nicht blind fortsetzen, `clear_bed` ist nur eine Quittung, kein G-code und kein Firmware-Restart.

 ## Start

@@ -0,0 +1,195 @@
+# Makros und G-code: Kobra S1 und Kobra 3
+
+Stand **19.10.2026**. Interne Referenz — nicht unter `/doku`. Messwerte und Bettnetz-Story: `D:\Projekte\3DP\FDM\Wissen\Drucker\` (`Kobra S1.md`, `Kobra 3.md`). Stack: [Anycubic-Stack](Anycubic-Stack.md).
+
+Quellen: `printer/gcode/help` (11.10. auf den Maschinen), GoKlipper/`extras_ace.go`, Rinkhals-RE `GOKLIPPER_ACE_GCODE_COMMANDS.md`, Grotti-Policy.
+
+---
+
+## Nicht tun
+
+| Nicht | Warum | Stattdessen |
+| --- | --- | --- |
+| `FIRMWARE_RESTART` / `RESTART` | gklib Deadlock bis Power-Cycle (Rinkhals #32) | Display-Reboot oder Strom; hängenden Job: **Fehler löschen** (`SDCARD_RESET_FILE`) |
+| `LEVIQ` / `LEVIQ2` aus Mainsail | Heizung + volle Nivellierfolge, fährt unerwartet | Am Display Auto-Level; Einzelschritte nur bewusst |
+| `SAVE_CONFIG` aus Mainsail | schreibt u. a. Z-Offset mit | Dauerhaft nur gezielt / nach Display-Nivellieren |
+| Nur Moonraker-Cancel | Anycubic-Task bleibt → Start-Code **10101** | Cancel + MQTT-stop (Grotti `abbrechen`) |
+| Community-`ACE_SET_SLOT` / manuelles `G9111` als Grotti-Pfad | Grotti mappt über `.acm` + MQTT | Map in der App; Slice-`G9111` im Start-G-code belassen |
+| `minimum_cruise_ratio` auf **0** (S1) | Moonraker hängt auf dieser Firmware | bei **0,05** belassen |
+| `G28 Y` mit Teilen auf dem Bett (K3) | Sensorless-Home nach **vorn** über die Teile | Bett leeren; Abräumen ohne `G28 Z` |
+| Blind `FEED` / `FEED_FILAMENT` ohne Unwind | Blockade bis Neustart (RE-Doku) | Unload/Unwind-Sequenz einhalten |
+| `SET_KINEMATIC_POSITION` mit erfundener Z nach Stepper-aus | Portal sackt → Null daneben, Probe „No trigger“ oder Crash | echte letzte XYZ; oder Bett leer + `G28` |
+| Freie G-code-Konsole in Grotti für Experimente | Policy | nur bekannte, bestätigte Scripts |
+| Abräumen-Makro in `printer.cfg` pflegen | Rinkhals schreibt Config neu | Grotti schickt Scripts per Moonraker |
+
+---
+
+## Vanilla-Klipper-Alltag (beide Typen)
+
+Befehl → was er macht. Anycubic-Hinweis nur wo nötig.
+
+### Homes und Bewegung
+
+| Befehl | Funktion |
+| --- | --- |
+| `G28` | Homed die genannten Achsen (ohne Argument: alle). **K3:** Y-Home fährt nach vorn — Bett muss leer sein. |
+| `G0` / `G1` | Lineare Bewegung / Extrusion. Absolute/relative Modi wie üblich (`G90`/`G91`, `M82`/`M83`). |
+| `M400` | Wartet, bis alle Moves fertig sind. |
+| `SET_VELOCITY_LIMIT` | Limits für Speed/Accel zur Laufzeit. |
+| `SET_KINEMATIC_POSITION` | Setzt die interne Position ohne zu fahren. Nach `M84`/Leerlauf riskant — siehe „Nicht tun“. |
+| `SET_IDLE_TIMEOUT` | Idle-Zeit bis Stepper aus. Abräumen hält Idle bewusst länger. |
+| `M84` / `M18` | Stepper aus → Achsen unhomed. Slice-Ende K3 macht das oft; Abräumen entfernt es beim Upload. |
+
+### Heizen
+
+| Befehl | Funktion |
+| --- | --- |
+| `M104` / `M109` | Düse Soll / warten bis erreicht. |
+| `M140` / `M190` | Bett Soll / warten. |
+| `TURN_OFF_HEATERS` | Düse und Bett aus. |
+| `PID_CALIBRATE` | PID für Extruder oder Bett kalibrieren. Danach oft `SAVE_CONFIG` — auf diesen Maschinen vorsichtig. |
+| `M106` / `M107` | Teilkühlung an / aus. |
+
+### Drucklauf
+
+| Befehl | Funktion |
+| --- | --- |
+| `PAUSE` / `RESUME` / `CANCEL_PRINT` | Rinkhals-Makros um Pause/Weiter/Abbruch. Moonraker-Cancel allein räumt den Anycubic-Task nicht. |
+| `SDCARD_RESET_FILE` | Löscht hängenden virtual-sdcard-/Druckstatus („Fehler löschen“ in Grotti). |
+| `PRINT_STATS` | Status des laufenden/letzten Jobs (Objekt auch über Moonraker). |
+
+### Bettnetz und Probe
+
+| Befehl | Funktion |
+| --- | --- |
+| `BED_MESH_CALIBRATE` | Tastet das Netz und schaltet es aktiv. |
+| `BED_MESH_OUTPUT` | Gibt die Punkte aus, ohne zu fahren. |
+| `BED_MESH_MAP` | Schreibt das interpolierte Netz in die Konsole. |
+| `BED_MESH_CLEAR` | Schaltet die Korrektur aus. |
+| `BED_MESH_OFFSET` | Verschiebt das Netz in X/Y. |
+| `BED_MESH_PROFILE` | `LOAD` / `SAVE` / `REMOVE` für Profile. Dauerhaft erst mit `SAVE_CONFIG`. |
+| `PROBE` | Ein Tastpunkt an der aktuellen Position. |
+| `PROBE_ACCURACY` | Mehrfach tasten, Streuung ausgeben. |
+| `PROBE_CALIBRATE` | Sensor kalibrieren (nicht der Z-Regler am Display). |
+| `Z_OFFSET_APPLY_PROBE` | Laufenden G-code-Offset in `probe.z_offset` schreiben. |
+| `SET_GCODE_OFFSET` | Offset nur für den aktuellen Auftrag. |
+| `SAVE_CONFIG` | Schreibt Config dauerhaft — **nicht** blind aus Mainsail. |
+
+### Diagnose
+
+| Befehl | Funktion |
+| --- | --- |
+| `QUERY_ENDSTOPS` / `M119` | Endstop-Zustände. |
+| `GET_POSITION` / `M114` | Toolhead-/Stepper-Position. |
+| `QUERY_ADC` | ADC-Werte (z. B. Thermistoren). |
+| `DUMP_TMC` | TMC-Register (Stepper nennen). |
+
+### Slice-Start Anycubic
+
+| Befehl | Funktion |
+| --- | --- |
+| `G9111` | Vorheizen aus dem Slicer: typisch `bedTemp=…` und `extruderTemp=…`. Steht im Maschinen-Start-G-code. Grotti ersetzt das nicht und startet auch nicht darüber. |
+
+---
+
+## ACE (gemeinsam)
+
+Zwei Namenswelten:
+
+1. **Open-Source** GoKlipper `extras_ace.go` (BunnyACE-Stil): `ACE_CHANGE_TOOL`, `ACE_FEED`, `ACE_RETRACT`, `ACE_SET_SLOT`, `ACE_QUERY_SLOTS`, `ACE_START_DRYING` / `ACE_STOP_DRYING`, Feed-Assist, Endless Spool, …
+2. **Ausgeliefertes Binary** (Rinkhals-RE): u. a. `FEED_FILAMENT`, `UNWIND_FILAMENT`, `UNWIND_ALL_FILAMENT`, `SET_CURRENT_FILAMENT`, `ACE_INFO`, `ACE_STATUS`, Cutter-/Pipe-Befehle.
+
+Grotti nutzt **keine** Community-Makros `ACE_SET_SLOT` / manuelles Tool-Mapping per G-code. Zuordnung: Sidecar `.acm` + MQTT `ams_settings` ([Senden-Queue](Senden-Queue.md), [ACE-Live](ACE-Live.md)). Slots anzeigen: Moonraker-Objekt `mmu` (Rinkhals). Trocknen: Moonraker `POST /server/filament_hub/start_drying` (nicht zwingend der G-code).
+
+| Befehl (Auswahl) | Funktion |
+| --- | --- |
+| `ACE_CHANGE_TOOL` / Tool-Macros `T0`… | Werkzeugwechsel über ACE. |
+| `ACE_FEED` / `FEED_FILAMENT` | Filament vom Gate zur Düse laden. **Vorher unloaden.** |
+| `ACE_RETRACT` / `UNWIND_FILAMENT` | Zurückziehen / parkieren. |
+| `ACE_SET_SLOT` | Inventar Slot setzen — Grotti meidet das. |
+| `ACE_START_DRYING` / `ACE_STOP_DRYING` | Trockner; alternativ `filament_hub`-API. |
+| `ACE_ENABLE_ENDLESS_SPOOL` / `…_DISABLE` / `…_STATUS` | Endless Spool. |
+
+Details und Parameter: Rinkhals `docs/GOKLIPPER_ACE_GCODE_COMMANDS.md` (lokal unter `D:\Projekte\_ref\Rinkhals\`).
+
+---
+
+## Kobra S1 — Anycubic-Makros
+
+Config-Sektion heißt `[leviQ3]`, die Befehle auf dem Gerät heißen **`LEVIQ2`**. Stecken in GoKlipper. Hilfe gelesen 11.10. über `printer/gcode/help`.
+
+### LeviQ2
+
+| Befehl | Funktion |
+| --- | --- |
+| `LEVIQ2` | Ganze Nivellierfolge: heizen, wischen, antasten. **Nicht** aus Mainsail. `SYNC=enable` startet danach neu. |
+| `LEVIQ2_PREHEATING` | Vorheizen: Bett 55 °C, Düse 170 °C, dann `HOME_XY`. `S` = Düsentemp, `E` = Temp nach dem Wischen. |
+| `LEVIQ2_WIPING` | Wischen: Netz löschen, Düse auf 140 °C, intern `G9112`, dann `G28 Z`. |
+| `LEVIQ2_PROBE` | Antasten: `BED_MESH_CALIBRATE`, Lüfter/Bett aus, Z auf 20 mm, `HOME_XY`, Düse aus. |
+| `LEVIQ_SET_ZERO` | Z-Basis und Home-Position auf 0. |
+| `LEVIQ2_AUTO_ZOFFSET` | Löscht laut Hilfe den Koeffizienten K. |
+| `LEVIQ2_AUTO_ZOFFSET_ON_OFF` | Schaltet automatischen Z-Offset. |
+| `LEVIQ2_TEMP_OFFSET` | Temperaturausgleich (`expansion_factor` / `zoffset_base` in der Config). Fehlt im veröffentlichten Quelltext. |
+| `HOME_XY` | Nur X/Y homen (von LeviQ-Schritten genutzt). |
+
+Netz: 5×5, X/Y 5–245 mm. Details: Wissen `Kobra S1.md`.
+
+### Wipe (Pad hinten)
+
+| Befehl | Funktion |
+| --- | --- |
+| `WIPE_ENTER` | Anfahrt Pad (Y 250 → X 81, Y 273). |
+| `WIPE_NOZZLE` | Wischbahn; wiederholt die Strecke X 96↔81. |
+| `WIPE_STOP` | Kurze Stopp-Bahnen, dann X 75. |
+| `WIPE_EXIT` | Weg vom Pad (X 83, Y 250). |
+| `TO_THROW_POSITION` | Position zum Abwerfen (~X 47, Y 276). |
+| `MOVE_TO_SWEEP_POSITION` | Wisch-/Kehrposition (gleiche Gegend). |
+| `MOVE_TO_IMPACT_POSITION` | Weg vom Pad nach vorn rechts (Y 25, X 261). |
+| `PRINT_LINE` | Purge-Linie bei Y 251, Z 0,28 bis X 125. |
+
+---
+
+## Kobra 3 — Anycubic-Makros
+
+Befehle gelesen 11.10. auf `da26` (`92ee`/`6e41` gleiche `printer.generated.cfg`). Im veröffentlichten Quelltext heißen Teile noch `LEVIQ3_*` / `LEVIQ2_PROBE` — auf den drei Druckern gelten die Namen unten.
+
+### LeviQ
+
+| Befehl | Funktion |
+| --- | --- |
+| `LEVIQ` | Ganze Folge inkl. Z-Offset-Rechnung. **Nicht** aus Mainsail. `SYNC=enable` startet danach neu. |
+| `LEVIQ_PREHEATING` | Z-Basis 0, Bett 60 °C, Düse 170 °C, `HOME_XY`, auf Düse warten. `S` / `E` wie bei S1. |
+| `LEVIQ_WIPING` | Netz löschen, Düse 140 °C, `G9112`, `G28 Z`. |
+| `LEVIQ_PROBE` | `BED_MESH_CALIBRATE`, Lüfter/Bett aus, Z auf 30 mm, `HOME_XY`, Düse aus. |
+| `LEVIQ_SET_ZERO` | Z-Basis und Home auf 0. |
+| `LEVIQ_AUTO_ZOFFSET` | Löscht Koeffizient K (Hilfe). |
+| `LEVIQ_AUTO_ZOFFSET_ON_OFF` | Automatischen Z-Offset schalten (oft an). |
+| `LEVIQ_TEMP_OFFSET` | Temperaturausgleich (Hilfezeile „LEVIQ3 TEMP OFFSET“). Fehlt im Open-Source-Code. |
+| `HOME_XY` | Nur X/Y homen. |
+
+Netz: 5×5, X 15–240, Y 15–235 mm. Details: Wissen `Kobra 3.md`.
+
+### Wipe
+
+| Befehl | Funktion |
+| --- | --- |
+| `WIPE_NOZZLE` | Dreimal `SINGLE_WIPE_NOZZLE` (Y 260/259, X 46–90, Z −0,8↔1, Lüfter an). |
+| `SINGLE_WIPE_NOZZLE` | Eine einzelne Wischbahn. |
+| `MOVE_HEAT_POS` | Z 15, dann X 278 (Heiz-/Parknahe Position). |
+| `UNDERLINE` | Purge-Linie Z 0,28 bis X 180, ~40 mm Extrusion. |
+| `MOVE_END_POS` | Ende/Park X 5, Y 242. |
+
+### Wägezelle
+
+| Befehl | Funktion |
+| --- | --- |
+| `CS1237_DUMP` | Debug-Ausgabe zum CS1237 (Z-Sensor / Kraft). Moonraker liefert keine laufende Gramm-Anzeige; `probe.last_z_result` fehlt. |
+
+---
+
+## Siehe auch
+
+- [Anycubic-Stack](Anycubic-Stack.md) — MQTT-Start/Stop, 10101, kein Firmware-Restart
+- [Senden-Queue](Senden-Queue.md) — `.acm`, kein Community-ACE-Makro
+- [Abraeumen](Abraeumen.md) — K3 Farm-Scripts statt Druckermakro
+- [ACE-Live](ACE-Live.md) — Live-Mapping und Trailer
@@ -12,7 +12,7 @@ Seite `/einstellungen`: Druckernamen/Host/Familie/gesperrt (PostgreSQL `printers

 ## Druckwarteschlange „wenn frei“

-Dateien → „Wenn frei“ oder „Nächster freier“ → `when_free` in `POST /api/v1/senden`. Einträge in `print_queue`; Dispatcher startet, sobald der Host (oder ein freier Drucker) `standby`/`complete`/`cancelled` ist, Platte frei und nicht gesperrt. **Alle freien Drucker im selben Tick** (Upload/Start je Host im Worker parallel) — nicht einer alle ~8 s. Sidebar und Seite `/warteschlange`. Sofort-Senden bleibt über die Send-Queue (mehrere Worker). Hängender Fehler wird nur geräumt, wenn für den Host ein Auftrag wartet. Ablauf: Phase `starting` vor Upload; Timeout 10 min ohne `print_active`.
+Dateien → „Dieser Drucker“ (belegt) oder „Nächster passender“ → `when_free` in `POST /api/v1/senden`. Einträge in `print_queue`; Dispatcher startet, sobald der Host (oder ein freier Drucker) `standby`/`complete`/`cancelled` ist, Platte frei und nicht gesperrt. Material-Score: Katalog-Sorte aus `filament_settings_id` (streng), Farbe soft; bei ACE und leerer Map baut Grotti die Zuordnung aus Spulen. **Alle freien Drucker im selben Tick** (Upload/Start je Host im Worker parallel) — nicht einer alle ~8 s. Sidebar und Seite `/warteschlange`. Sofort-Senden bleibt über die Send-Queue (mehrere Worker). Hängender Fehler wird nur geräumt, wenn für den Host ein Auftrag wartet. Ablauf: Phase `starting` vor Upload; Timeout 10 min ohne `print_active`.

 ## Spulen

@@ -27,7 +27,7 @@ Jedes Ereignis landet in `events` und auf der Seite `/aktivitaet`. Telegram ist
 | `fertig` | Watcher, `printing`→`complete` | nein, Platte unter „Aufgaben“ | an |
 | `fehler` | Watcher, Zustand `error` | ja | an |
 | `abbruch` | Watcher, `printing`/`paused`→`cancelled`/`standby` | ja | wie `fehler` |
-| `offline` | Watcher, ≥2 Polls weg; auch „wieder erreichbar“ | ja | an |
+| `offline` | Watcher, ≥2 Polls weg; auch „wieder erreichbar“. Beendet den Lauf nicht und zieht nichts ab — der letzte Druckzustand bleibt gemerkt | ja | an |
 | `spule` | Watcher, Rest unter Job-Gewicht | ja | an |
 | `queue` | Dispatcher: Queue-Fehler, Ablauf gestoppt | ja | an |
 | `start` | Watcher: Druck startet, Pause, Fortsetzen | nein | aus |
@@ -3,3 +3,11 @@
 Diese Dateien sind für Entwicklung und Agenten — **nicht** unter `/doku` in der App.

 Nutzer-Handbuch: `docs/Anleitung-*.md`.
+
+| Datei | Inhalt |
+| --- | --- |
+| [API.md](API.md) | HTTP-API für App/Integrationen (Auth, confirm, SSE, Filter) |
+| [openapi.yaml](openapi.yaml) | OpenAPI-Skizze (Client-Generator) |
+| [MCP.md](MCP.md) | MCP-Server und Tool-Ablauf |
+| [Makros-Kobra.md](Makros-Kobra.md) | G-code/Makros Kobra S1 und 3: Nicht-tun, Vanilla-Alltag, ACE, LeviQ/Wipe |
+| [Anycubic-Stack.md](Anycubic-Stack.md) | GoKlipper, MQTT-Start/Stop, ACE-Kanäle |
@@ -18,7 +18,9 @@ Ab 12.10.2026: Start legt Hintergrund-Aufträge an (`pending` → `running` →

 ## Slice-Ordner / Upload

-`watch_dir` in `config.json` zeigt auf den Slice-Ordner der Bibliothek. Ohne Ordner geht Hochladen über die Dateien-Seite trotzdem.
+Slice-Ordner unter **Einstellungen** (persistiert als `watch_dir`). Ohne Ordner geht Hochladen über die Dateien-Seite trotzdem.
+
+**Dateinamen:** Moonraker-Multipart nutzt nur noch einen ASCII-`filename` (`moonraker.safe_upload_name`). Früher standen Nicht-ASCII-Zeichen in `filename*=UTF-8''…`, während `filename=` Unterstriche bekam — gklib speicherte A, Start suchte B → **10115 not found**.

 ## ACE / `.acm`

@@ -0,0 +1,180 @@
+openapi: 3.0.3
+info:
+  title: Grotti API
+  version: "1"
+  description: |
+    JSON unter /api/v1. Auth: Session-Cookie oder Bearer grt_….
+    Mutierende Session-Calls brauchen Header X-CSRF-Token.
+    Siehe docs/internal/API.md.
+servers:
+  - url: /api/v1
+paths:
+  /version:
+    get:
+      summary: Server-Info
+      security: []
+      responses:
+        "200":
+          description: name, version, api, features
+  /auth/login:
+    post:
+      summary: Session-Login
+      security: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [username, password]
+              properties:
+                username: { type: string }
+                password: { type: string }
+      responses:
+        "200":
+          description: user + csrf
+  /auth/token:
+    post:
+      summary: Passwort → API-Token (App)
+      security: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [username, password]
+              properties:
+                username: { type: string }
+                password: { type: string }
+                device_name: { type: string }
+                role: { type: string, enum: [operator, admin] }
+      responses:
+        "201":
+          description: token (einmalig) + user
+  /drucker:
+    get:
+      summary: Druckerliste
+      parameters:
+        - name: live
+          in: query
+          schema: { type: integer, enum: [0, 1] }
+      responses:
+        "200":
+          description: Array Drucker
+  /drucker/{host}/{action}:
+    post:
+      summary: Pause / Fortsetzen / Abbrechen
+      parameters:
+        - name: host
+          in: path
+          required: true
+          schema: { type: string }
+        - name: action
+          in: path
+          required: true
+          schema:
+            type: string
+            enum: [pause, fortsetzen, abbrechen, resume, cancel]
+      responses:
+        "200":
+          description: OK
+  /dateien:
+    get:
+      summary: Bibliothek
+      parameters:
+        - { name: family, in: query, schema: { type: string } }
+        - { name: material, in: query, schema: { type: string } }
+        - { name: project_id, in: query, schema: { type: integer } }
+        - { name: host, in: query, schema: { type: string } }
+        - { name: q, in: query, schema: { type: string } }
+        - { name: limit, in: query, schema: { type: integer } }
+        - { name: offset, in: query, schema: { type: integer } }
+      responses:
+        "200":
+          description: Array Dateien; Header X-Total-Count
+          headers:
+            X-Total-Count:
+              schema: { type: integer }
+  /senden:
+    post:
+      summary: Druck starten oder einreihen
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [file_id, confirm]
+              properties:
+                file_id: { type: integer }
+                hosts: { type: array, items: { type: string } }
+                confirm: { type: boolean }
+                when_free: { type: boolean }
+                ace_maps: { type: object }
+                bed_leveling: { type: boolean }
+      responses:
+        "202":
+          description: jobs
+  /druck-queue:
+    get:
+      summary: Warteschlange
+      parameters:
+        - { name: host, in: query, schema: { type: string } }
+        - { name: status, in: query, schema: { type: string } }
+        - { name: limit, in: query, schema: { type: integer } }
+        - { name: offset, in: query, schema: { type: integer } }
+      responses:
+        "200":
+          description: Array; X-Total-Count
+    post:
+      summary: Einreihen
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [file_id, confirm]
+      responses:
+        "200":
+          description: Queue-Eintrag
+  /projekte/{id}/einreihen:
+    post:
+      summary: Projektdateien einreihen
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema: { type: integer }
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [confirm]
+              properties:
+                confirm: { type: boolean }
+                file_ids: { type: array, items: { type: integer } }
+                menge: { type: integer }
+      responses:
+        "201":
+          description: jobs
+  /stream:
+    get:
+      summary: SSE Live-Events
+      responses:
+        "200":
+          description: text/event-stream (drucker, queue, senden, ereignis, ping)
+components:
+  securitySchemes:
+    bearerAuth:
+      type: http
+      scheme: bearer
+      bearerFormat: grt_
+    cookieAuth:
+      type: apiKey
+      in: cookie
+      name: session
+security:
+  - bearerAuth: []
+  - cookieAuth: []
@@ -73,13 +73,182 @@ def normalize_mapping(raw):
            ams = int(item.get("ams_index"))
        except (TypeError, ValueError):
            continue
-        if paint < 0 or ams < 0 or ams > 7 or paint in seen:
+        # paint_index = Slicer-T (oft 0–15 bei Bambu), ams_index = ACE-Platz 0–7
+        if paint < 0 or paint > 63 or ams < 0 or ams > 7 or paint in seen:
            continue
        seen.add(paint)
        out.append({"paint_index": paint, "ams_index": ams})
    return out


+def filament_for_paint(filaments, paint):
+    """Filament-Eintrag zur Slicer-T-Nummer; Fallback Array-Index für Alt-Daten."""
+    filaments = filaments or []
+    try:
+        paint = int(paint)
+    except (TypeError, ValueError):
+        return {}
+    for index, row in enumerate(filaments):
+        if not isinstance(row, dict):
+            continue
+        try:
+            key = int(row.get("paint_index"))
+        except (TypeError, ValueError):
+            key = index
+        if key == paint:
+            return row
+    if 0 <= paint < len(filaments) and isinstance(filaments[paint], dict):
+        return filaments[paint]
+    return {}
+
+
+def densify_mapping(mapping):
+    """Slicer-T mit Lücken (T1/T10) → dichte 0…n−1 für gklib/ACE.
+
+    gklib meldet bei zu hoher Filament-ID ``invalid filament id`` (10011700).
+    Rückgabe: (remap alt→neu, dichte Map). Identity → ({}, unverändert).
+    """
+    mapping = normalize_mapping(mapping)
+    paints = sorted(item["paint_index"] for item in mapping)
+    if not paints or paints == list(range(len(paints))):
+        return {}, mapping
+    remap = {old: new for new, old in enumerate(paints)}
+    dense = [
+        {"paint_index": remap[item["paint_index"]], "ams_index": item["ams_index"]}
+        for item in mapping
+    ]
+    return remap, dense
+
+
+def remap_filaments(filaments, remap):
+    """paint_index der Filament-Metadaten mit densify-Remap mitziehen."""
+    if not remap:
+        return list(filaments or [])
+    out = []
+    for row in filaments or []:
+        if not isinstance(row, dict):
+            continue
+        copy = dict(row)
+        try:
+            old = int(row.get("paint_index"))
+        except (TypeError, ValueError):
+            out.append(copy)
+            continue
+        if old in remap:
+            copy["paint_index"] = remap[old]
+        out.append(copy)
+    return out
+
+
+def align_tools_for_ace(content, mapping, filaments=None):
+    """G-code-T und ACE-Map auf dichte 0…n−1 bringen.
+
+    Maßgeblich sind die ``Tn`` im G-code. Die UI-Map darf echte Slicer-Indizes
+    (T1/T10) oder fälschlich kompakte 0/1 haben — ACE-Plätze werden in
+    Sortierreihenfolge der Map-Einträge den sortierten T-Nummern zugeordnet.
+    Sonst: ACM 0/1 + G-code T10 → 10011700 invalid filament id.
+    """
+    from grotti.parse import tools_used_in_gcode
+
+    mapping = normalize_mapping(mapping)
+    used = sorted(tools_used_in_gcode(content))
+    if not mapping:
+        return content, mapping, list(filaments or []), {}
+    if not used:
+        remap, dense = densify_mapping(mapping)
+        new_content = rewrite_gcode_tools(content, remap) if remap else content
+        return new_content, dense, remap_filaments(filaments, remap), remap
+
+    if len(mapping) != len(used):
+        from grotti.errors import GrottiError
+
+        raise GrottiError(
+            "ACE-Zuordnung (%d Farben) passt nicht zum G-code (T%s). "
+            "Datei neu lesen und Zuordnung erneut setzen."
+            % (len(mapping), ", T".join(str(t) for t in used)),
+            "ace",
+        )
+
+    mapped_paints = {item["paint_index"] for item in mapping}
+    paints_match_gcode = mapped_paints == set(used)
+    if paints_match_gcode:
+        ams_by_tool = {item["paint_index"]: item["ams_index"] for item in mapping}
+        ams_order = [ams_by_tool[tool] for tool in used]
+    else:
+        # UI kompakt 0…n−1, G-code sparse — Reihenfolge der Map = Reihenfolge der Farben
+        ordered = sorted(mapping, key=lambda item: item["paint_index"])
+        ams_order = [item["ams_index"] for item in ordered]
+
+    remap = {old: new for new, old in enumerate(used)}
+    dense = [
+        {"paint_index": index, "ams_index": ams_order[index]}
+        for index in range(len(used))
+    ]
+
+    source = list(filaments or [])
+    if paints_match_gcode:
+        new_fils = remap_filaments(source, remap)
+    else:
+        # Metadaten folgen der Map-Reihenfolge (0,1,…), nicht den G-code-T
+        ordered_paints = sorted(item["paint_index"] for item in mapping)
+        new_fils = []
+        for index, tool in enumerate(used):
+            row = filament_for_paint(source, ordered_paints[index]) or (
+                source[index] if index < len(source) and isinstance(source[index], dict) else {}
+            )
+            if not row:
+                row = filament_for_paint(source, tool) or {}
+            copy = dict(row) if isinstance(row, dict) else {}
+            copy["paint_index"] = index
+            new_fils.append(copy)
+
+    # Identity-Remap weglassen (schon T0…n−1)
+    if used == list(range(len(used))):
+        return content, dense, new_fils, {}
+    new_content = rewrite_gcode_tools(content, remap)
+    return new_content, dense, new_fils, remap
+
+
+_TOOL_NUM_RE = re.compile(
+    rb"^(?P<prefix>(?:MMU_CHANGE_TOOL(?:_STANDALONE)?[^\n]*?\bTOOL=)|T)(?P<num>\d{1,2})\b",
+    re.I,
+)
+_REF_TOOLS_RE = re.compile(rb"^(;\s*referenced_tools\s*=\s*)(.+?)\s*$", re.I)
+
+
+def rewrite_gcode_tools(content, remap):
+    """Tn / TOOL=n / referenced_tools laut Remap umschreiben (T10 vor T1)."""
+    if not content or not remap:
+        return content
+    text = content if isinstance(content, (bytes, bytearray)) else str(content).encode("utf-8", "replace")
+    lines = text.splitlines(keepends=True)
+    out = []
+    for line in lines:
+        stripped = line[:-2] if line.endswith(b"\r\n") else (line[:-1] if line.endswith(b"\n") else line)
+        ending = line[len(stripped) :]
+        ref = _REF_TOOLS_RE.match(stripped)
+        if ref:
+            parts = []
+            for bit in ref.group(2).split(b","):
+                raw = bit.strip()
+                try:
+                    number = int(raw)
+                except ValueError:
+                    parts.append(raw)
+                    continue
+                parts.append(str(remap.get(number, number)).encode("ascii"))
+            out.append(ref.group(1) + b",".join(parts) + ending)
+            continue
+        match = _TOOL_NUM_RE.match(stripped)
+        if match:
+            old = int(match.group("num"))
+            if old in remap:
+                new = str(remap[old]).encode("ascii")
+                stripped = stripped[: match.start("num")] + new + stripped[match.end("num") :]
+        out.append(stripped + ending)
+    return b"".join(out)
+
+
 def build_acm(filaments, mapping, slots):
    filaments = filaments or []
    slots = slots or []
@@ -88,7 +257,7 @@ def build_acm(filaments, mapping, slots):
    for item in normalize_mapping(mapping):
        paint = item["paint_index"]
        ams = item["ams_index"]
-        filament = filaments[paint] if 0 <= paint < len(filaments) else {}
+        filament = filament_for_paint(filaments, paint)
        slot = slot_by_index.get(ams) or {}
        paint_color = color_channels(filament.get("color")) or [0, 0, 0]
        ams_color = color_channels(slot.get("color")) or paint_color
@@ -24,7 +24,7 @@ from cryptography.hazmat.primitives import padding
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

 CRED_TTL = 300
-INFO_TTL = 10
+INFO_TTL = 45
 FAIL_TTL = 45
 _CRED_CACHE = {}
 _INFO_CACHE = {}
@@ -0,0 +1,92 @@
+"""Datenbank- und Datenordner-Backup."""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import zipfile
+from datetime import datetime
+from pathlib import Path
+from urllib.parse import urlparse
+
+
+def backup_dir(cfg):
+    base = Path(cfg.get("data_dir") or "data")
+    path = base / "backup"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _safe_name(name):
+    name = re.sub(r"[^\w.\-]+", "_", name or "")
+    return name[:180] or "backup.zip"
+
+
+def create_backup(cfg):
+    """ZIP mit pg_dump (stdout) und data/ ohne toolpath/ und backup/."""
+    data_dir = Path(cfg.get("data_dir") or "data")
+    out_dir = backup_dir(cfg)
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    filename = _safe_name("grotti-%s.zip" % stamp)
+    dest = out_dir / filename
+
+    url = cfg.get("database_url") or ""
+    parsed = urlparse(url)
+    db_name = (parsed.path or "/grotti").lstrip("/") or "grotti"
+    env = {}
+    if parsed.password:
+        env["PGPASSWORD"] = parsed.password
+
+    cmd = ["pg_dump", "--no-owner", "--no-acl", db_name]
+    if parsed.hostname:
+        cmd[1:1] = ["-h", parsed.hostname]
+    if parsed.port:
+        cmd[1:1] = ["-p", str(parsed.port)]
+    if parsed.username:
+        cmd[1:1] = ["-U", parsed.username]
+
+    proc = subprocess.run(cmd, capture_output=True, env={**os.environ, **env})
+    if proc.returncode != 0:
+        err = (proc.stderr or b"").decode("utf-8", "replace").strip()
+        raise RuntimeError(err or "pg_dump fehlgeschlagen.")
+
+    skip_dirs = {"toolpath", "backup"}
+    with zipfile.ZipFile(dest, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr("database.sql", proc.stdout)
+        if data_dir.is_dir():
+            for path in sorted(data_dir.rglob("*")):
+                if not path.is_file():
+                    continue
+                rel = path.relative_to(data_dir)
+                if rel.parts and rel.parts[0] in skip_dirs:
+                    continue
+                zf.write(path, "data/" + rel.as_posix())
+    return {
+        "name": filename,
+        "path": str(dest),
+        "size": dest.stat().st_size,
+    }
+
+
+def list_backups(cfg):
+    out_dir = backup_dir(cfg)
+    items = []
+    for path in sorted(out_dir.glob("*.zip"), reverse=True):
+        try:
+            size = path.stat().st_size
+        except OSError:
+            size = 0
+        items.append({"name": path.name, "size": size})
+    return items
+
+
+def backup_path(cfg, name):
+    out_dir = backup_dir(cfg)
+    safe = _safe_name(name)
+    path = (out_dir / safe).resolve()
+    if not str(path).startswith(str(out_dir.resolve())):
+        return None
+    if not path.is_file():
+        return None
+    return path
@@ -0,0 +1,105 @@
+"""Filament-Bedarf aus wartender Queue vs. Spulenrest."""
+
+from __future__ import annotations
+
+import re
+
+_HEX_COLOR_RE = re.compile(r"^#?[0-9a-f]{6}([0-9a-f]{2})?$", re.I)
+
+
+def _group_key(material_type, color):
+    return (
+        (material_type or "").strip().lower(),
+        (color or "").strip().lower(),
+    )
+
+
+def _is_slicer_hex(color):
+    """Orca/Anycubic speichert oft #26A69A — Lagerfarben heißen „Grau“/„Weiß“."""
+    return bool(_HEX_COLOR_RE.match((color or "").strip()))
+
+
+def _stock_for_need(stock_map, mat, color):
+    """Exakte Farbe zuerst; bei Slice-Hex oder leerer Farbe: Summe gleicher Sorte."""
+    key = _group_key(mat, color)
+    exact = stock_map.get(key, 0.0)
+    if exact > 0.5:
+        return exact
+    if not color or _is_slicer_hex(color):
+        mat_key = (mat or "").strip().lower()
+        return sum(
+            grams
+            for (m, _c), grams in stock_map.items()
+            if m == mat_key and grams > 0
+        )
+    return exact
+
+
+def compute(conn):
+    """Wartende Jobs × Dateigewicht vs. Spulenrest, gruppiert nach Sorte/Farbe."""
+    queue_rows = conn.execute(
+        """
+        SELECT q.id, q.spool_id, q.repeat_total, q.repeat_done,
+               f.weight_g, f.filaments,
+               s.material_type AS spool_material, s.color AS spool_color
+        FROM print_queue q
+        JOIN files f ON f.id = q.file_id
+        LEFT JOIN spools s ON s.id = q.spool_id
+        WHERE q.status = 'waiting'
+        """
+    ).fetchall()
+
+    needed_map = {}
+    for row in queue_rows:
+        filaments = row.get("filaments") or []
+        first = filaments[0] if isinstance(filaments, list) and filaments else {}
+        if not isinstance(first, dict):
+            first = {}
+        mat = (row.get("spool_material") or first.get("type") or "").strip()
+        color = (row.get("spool_color") or first.get("color") or "").strip()
+        key = _group_key(mat, color)
+        try:
+            repeats = max(1, int(row.get("repeat_total") or 1) - int(row.get("repeat_done") or 0))
+        except (TypeError, ValueError):
+            repeats = 1
+        weight = float(row.get("weight_g") or 0) * repeats
+        if key not in needed_map:
+            needed_map[key] = {
+                "material_type": mat,
+                "color": color,
+                "weight_g": 0.0,
+                "jobs": 0,
+            }
+        needed_map[key]["weight_g"] += weight
+        needed_map[key]["jobs"] += 1
+
+    spool_rows = conn.execute(
+        """
+        SELECT material_type, color, COALESCE(SUM(remaining_g), 0) AS remaining_g
+        FROM spools
+        WHERE archived_at IS NULL
+        GROUP BY material_type, color
+        """
+    ).fetchall()
+
+    stock_map = {}
+    for row in spool_rows:
+        key = _group_key(row.get("material_type"), row.get("color"))
+        stock_map[key] = stock_map.get(key, 0.0) + float(row.get("remaining_g") or 0)
+
+    needed = sorted(
+        needed_map.values(),
+        key=lambda x: (-x["weight_g"], x["material_type"], x["color"]),
+    )
+    shortfall = []
+    for item in needed:
+        have = _stock_for_need(stock_map, item["material_type"], item["color"])
+        gap = item["weight_g"] - have
+        if gap > 0.5:
+            shortfall.append({
+                **item,
+                "remaining_g": have,
+                "shortfall_g": gap,
+            })
+    shortfall.sort(key=lambda x: (-x["shortfall_g"], x["material_type"], x["color"]))
+    return {"needed": needed, "shortfall": shortfall}
@@ -136,7 +136,7 @@ MATERIALS = [
    {
        "name": "Sunlu PA12-CF",
        "brand": "Sunlu",
-        "material_type": "PA",
+        "material_type": "PA12-CF",
        "density": 1.08,
        "volumetric": 8,
        "volumetric_s1": 8,
@@ -157,6 +157,14 @@ MATERIALS = [
    },
 ]

+def ace_material_type(material_type):
+    """Typ für den ACE. PA12-CF gibt es dort nicht, der Platz heißt PA6-CF."""
+    text = (material_type or "").strip()
+    if text.lower() == "pa12-cf":
+        return "PA6-CF"
+    return text
+
+
 SOLIDS = [
    {"id": "schwarz", "name": "Schwarz", "hex": "#1c1c1c"},
    {"id": "weiss", "name": "Weiß", "hex": "#f4f4f4"},
@@ -1,24 +1,76 @@
 """Host, Port, Datenordner und Datenbank kommen aus config.json."""

 import json
+import os
 import secrets
+import threading
 from pathlib import Path

+from grotti.errors import GrottiError
+
 ROOT = Path(__file__).resolve().parent.parent
 LOOPBACK = {"127.0.0.1", "::1", "localhost"}
-CONFIG_PATH = ROOT / "config.json"
+DEFAULT_WATCH_REL = "slice"
+_SETTINGS_LOCK = threading.Lock()
+
+
+def config_path():
+    """GROTTI_CONFIG, sonst /etc/grotti/config.json (Paket), sonst Repo-config.json."""
+    env = (os.environ.get("GROTTI_CONFIG") or "").strip()
+    if env:
+        return Path(env)
+    etc = Path("/etc/grotti/config.json")
+    if etc.is_file():
+        return etc
+    return ROOT / "config.json"
+
+
+CONFIG_PATH = config_path()
+
+
+def _tariff(raw):
+    tariff = raw.get("tariff") if isinstance(raw, dict) else None
+    if not isinstance(tariff, dict) or not tariff:
+        return None
+    try:
+        ht = float(tariff.get("ht_euro"))
+        nt = float(tariff.get("nt_euro"))
+    except (TypeError, ValueError):
+        return None
+    return {
+        "ht_euro": ht,
+        "nt_euro": nt,
+        "nt_from": str(tariff.get("nt_from") or "22:00").strip(),
+        "nt_to": str(tariff.get("nt_to") or "06:00").strip(),
+    }


 def _energy(raw):
    energy = raw.get("energy") or {}
-    return {
-        "watts": float(energy.get("watts", 120)),
+    out = {
+        "watts": float(energy.get("watts", 40)),
+        "nozzle_watts": float(energy.get("nozzle_watts", 60)),
+        "bed_watts": float(energy.get("bed_watts", 220)),
        "euro_per_kwh": float(energy.get("euro_per_kwh", 0.35)),
        "dryer_watts": float(energy.get("dryer_watts", 0)),
        "dry_hours": float(energy.get("dry_hours", 0)),
        "waste_percent": float(energy.get("waste_percent", 0)),
        "utilization": float(energy.get("utilization", 50)),
    }
+    tariff = _tariff(energy)
+    if tariff:
+        out["tariff"] = tariff
+    return out
+
+
+def _ntfy(raw):
+    ntfy = raw.get("ntfy") or {}
+    return {
+        "enabled": bool(ntfy.get("enabled")),
+        "server": str(ntfy.get("server") or "https://ntfy.sh").rstrip("/"),
+        "topic": str(ntfy.get("topic") or ""),
+        "token": str(ntfy.get("token") or ""),
+    }


 def _telegram(raw):
@@ -37,6 +89,7 @@ def _alerts(raw):
        "fehler": bool(alerts.get("fehler", True)),
        "offline": bool(alerts.get("offline", True)),
        "queue": bool(alerts.get("queue", True)),
+        "spule": bool(alerts.get("spule", True)),
        "ablauf": bool(alerts.get("ablauf", False)),
        "start": bool(alerts.get("start", False)),
    }
@@ -82,9 +135,11 @@ def _ensure_secret_key(path, raw):


 def load():
-    path = CONFIG_PATH
+    path = config_path()
    if not path.exists():
-        path.write_text((ROOT / "config.example.json").read_text(encoding="utf-8"), encoding="utf-8")
+        example = ROOT / "config.example.json"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(example.read_text(encoding="utf-8"), encoding="utf-8")
    raw = json.loads(path.read_text(encoding="utf-8"))
    host = (raw.get("host") or "127.0.0.1").strip()
    token = raw.get("token") or ""
@@ -99,10 +154,10 @@ def load():
    data_dir = Path(raw.get("data_dir") or "data")
    if not data_dir.is_absolute():
        data_dir = ROOT / data_dir
-    watch = (raw.get("watch_dir") or "").strip()
-    watch_dir = Path(watch) if watch else None
-    if watch_dir and not watch_dir.is_absolute():
-        watch_dir = (ROOT / watch_dir).resolve()
+    watch_dir, _stored = parse_watch_dir(raw.get("watch_dir") or "", create=False, missing_ok=True)
+    printers_file = Path(raw.get("printers_file") or (ROOT / "drucker.json"))
+    if not printers_file.is_absolute():
+        printers_file = ROOT / printers_file
    return {
        "host": host,
        "port": int(raw.get("port") or 8770),
@@ -113,11 +168,14 @@ def load():
        "secret_key": secret_key,
        "oauth": _oauth(raw),
        "fqdn": normalize_fqdn(raw.get("fqdn") or ""),
-        "printers_file": ROOT / "drucker.json",
+        "printers_file": printers_file,
+        "log_level": str(raw.get("log_level") or "INFO").strip() or "INFO",
        "energy": _energy(raw),
        "telegram": _telegram(raw),
+        "ntfy": _ntfy(raw),
        "alerts": _alerts(raw),
        "auto_queue": bool(raw.get("auto_queue", True)),
+        "auto_retry": bool(raw.get("auto_retry", True)),
        "_raw": raw,
        "_path": path,
    }
@@ -130,12 +188,50 @@ def mask_token(token):
    return token[:4] + "…" + token[-2:]


+def parse_watch_dir(value, *, create=False, missing_ok=False):
+    """Pfad aus Einstellungen/Config → (Path|None, gespeicherter String).
+
+    Relativ zum Repo-Root. Leer = aus. create legt den Ordner an.
+    """
+    text = str(value or "").strip()
+    if not text:
+        return None, ""
+    path = Path(text)
+    if not path.is_absolute():
+        path = (ROOT / path).resolve()
+    else:
+        path = path.resolve()
+    if path.exists() and not path.is_dir():
+        raise GrottiError("Der Slice-Ordner ist keine Ordner.", "watch")
+    if create:
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+        except OSError as exc:
+            raise GrottiError("Slice-Ordner konnte nicht angelegt werden: %s" % exc, "watch") from exc
+    elif not path.is_dir():
+        if missing_ok:
+            return None, text
+        raise GrottiError("Slice-Ordner fehlt: %s" % path, "watch")
+    try:
+        stored = path.relative_to(ROOT.resolve()).as_posix()
+    except ValueError:
+        stored = str(path)
+    return path, stored
+
+
+def default_watch_suggestion():
+    """Absoluter Standardpfad (Repo/slice) für die Einstellungen."""
+    return str((ROOT / DEFAULT_WATCH_REL).resolve())
+
+
 def settings_public(cfg):
    tg = cfg.get("telegram") or {}
    oauth = cfg.get("oauth") or {}
    return {
        "watch_dir": str(cfg.get("watch_dir") or ""),
+        "watch_dir_default": default_watch_suggestion(),
        "auto_queue": bool(cfg.get("auto_queue", True)),
+        "auto_retry": bool(cfg.get("auto_retry", True)),
        "fqdn": str(cfg.get("fqdn") or ""),
        "legacy_token_set": bool(cfg.get("token")),
        "energy": dict(cfg.get("energy") or {}),
@@ -145,6 +241,13 @@ def settings_public(cfg):
            "bot_token_set": bool(tg.get("bot_token")),
            "chat_id": str(tg.get("chat_id") or ""),
        },
+        "ntfy": {
+            "enabled": bool((cfg.get("ntfy") or {}).get("enabled")),
+            "server": str((cfg.get("ntfy") or {}).get("server") or "https://ntfy.sh"),
+            "topic": str((cfg.get("ntfy") or {}).get("topic") or ""),
+            "token": mask_token((cfg.get("ntfy") or {}).get("token") or ""),
+            "token_set": bool((cfg.get("ntfy") or {}).get("token")),
+        },
        "alerts": dict(cfg.get("alerts") or {}),
        "oauth": {
            "enabled": bool(oauth.get("enabled")),
@@ -155,8 +258,43 @@ def settings_public(cfg):
    }


-def save_settings(cfg, energy=None, telegram=None, alerts=None, auto_queue=None, fqdn=None):
-    """Schreibt energy/telegram/alerts/auto_queue/fqdn zurück nach config.json und aktualisiert cfg."""
+def save_settings(
+    cfg,
+    energy=None,
+    telegram=None,
+    ntfy=None,
+    alerts=None,
+    auto_queue=None,
+    auto_retry=None,
+    fqdn=None,
+    watch_dir=None,
+):
+    """Schreibt Einstellungen zurück nach config.json und aktualisiert cfg."""
+    with _SETTINGS_LOCK:
+        return _save_settings_locked(
+            cfg,
+            energy=energy,
+            telegram=telegram,
+            ntfy=ntfy,
+            alerts=alerts,
+            auto_queue=auto_queue,
+            auto_retry=auto_retry,
+            fqdn=fqdn,
+            watch_dir=watch_dir,
+        )
+
+
+def _save_settings_locked(
+    cfg,
+    energy=None,
+    telegram=None,
+    ntfy=None,
+    alerts=None,
+    auto_queue=None,
+    auto_retry=None,
+    fqdn=None,
+    watch_dir=None,
+):
    path = cfg.get("_path") or CONFIG_PATH
    raw = dict(cfg.get("_raw") or {})
    if path.exists():
@@ -167,19 +305,37 @@ def save_settings(cfg, energy=None, telegram=None, alerts=None, auto_queue=None,
    if auto_queue is not None:
        raw["auto_queue"] = bool(auto_queue)
        cfg["auto_queue"] = bool(auto_queue)
+    if auto_retry is not None:
+        raw["auto_retry"] = bool(auto_retry)
+        cfg["auto_retry"] = bool(auto_retry)
+    if watch_dir is not None:
+        resolved, stored = parse_watch_dir(watch_dir, create=True, missing_ok=False)
+        raw["watch_dir"] = stored
+        cfg["watch_dir"] = resolved
    if fqdn is not None:
        normalized = normalize_fqdn(fqdn)
        raw["fqdn"] = normalized
        cfg["fqdn"] = normalized
    if energy is not None:
-        raw["energy"] = {
-            "watts": float(energy.get("watts", 120)),
+        raw_energy = {
+            "watts": float(energy.get("watts", 40)),
+            "nozzle_watts": float(energy.get("nozzle_watts", 60)),
+            "bed_watts": float(energy.get("bed_watts", 220)),
            "euro_per_kwh": float(energy.get("euro_per_kwh", 0.35)),
            "dryer_watts": float(energy.get("dryer_watts", 0)),
            "dry_hours": float(energy.get("dry_hours", 0)),
            "waste_percent": float(energy.get("waste_percent", 0)),
            "utilization": float(energy.get("utilization", 50)),
        }
+        tariff_in = energy.get("tariff") if isinstance(energy.get("tariff"), dict) else None
+        if tariff_in:
+            raw_energy["tariff"] = {
+                "ht_euro": float(tariff_in.get("ht_euro", raw_energy["euro_per_kwh"])),
+                "nt_euro": float(tariff_in.get("nt_euro", raw_energy["euro_per_kwh"])),
+                "nt_from": str(tariff_in.get("nt_from") or "22:00"),
+                "nt_to": str(tariff_in.get("nt_to") or "06:00"),
+            }
+        raw["energy"] = raw_energy
        cfg["energy"] = _energy(raw)
    if telegram is not None:
        current = _telegram(raw)
@@ -192,12 +348,25 @@ def save_settings(cfg, energy=None, telegram=None, alerts=None, auto_queue=None,
            "chat_id": str(telegram.get("chat_id", current["chat_id"]) or ""),
        }
        cfg["telegram"] = _telegram(raw)
+    if ntfy is not None:
+        current = _ntfy(raw)
+        token = ntfy.get("token")
+        if token is None or token == "" or "…" in str(token) or str(token).startswith("••••"):
+            token = current["token"]
+        raw["ntfy"] = {
+            "enabled": bool(ntfy.get("enabled", current["enabled"])),
+            "server": str(ntfy.get("server", current["server"]) or "https://ntfy.sh").rstrip("/"),
+            "topic": str(ntfy.get("topic", current["topic"]) or ""),
+            "token": str(token or ""),
+        }
+        cfg["ntfy"] = _ntfy(raw)
    if alerts is not None:
        raw["alerts"] = {
            "fertig": bool(alerts.get("fertig", True)),
            "fehler": bool(alerts.get("fehler", True)),
            "offline": bool(alerts.get("offline", True)),
            "queue": bool(alerts.get("queue", True)),
+            "spule": bool(alerts.get("spule", True)),
            "ablauf": bool(alerts.get("ablauf", False)),
            "start": bool(alerts.get("start", False)),
        }
@@ -1,5 +1,9 @@
 """Dieselbe Rechnung wie in der Druckkalkulation."""

+from datetime import datetime, timedelta, timezone
+
+from grotti.time_window import _in_segment, _parse_hm
+

 def calculate(job, material):
    part_g = float(job.get("weight_g") or 0) * max(1, float(job.get("qty") or 1))
@@ -37,6 +41,225 @@ def calculate(job, material):
    }


-def energy_cost(duration_s, energy):
-    hours = float(duration_s or 0) / 3600
-    return (float(energy["watts"]) / 1000) * hours * float(energy["euro_per_kwh"])
+def _parse_ts(value):
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value.timestamp()
+    text = str(value).strip()
+    if not text:
+        return None
+    try:
+        return datetime.fromisoformat(text.replace("Z", "+00:00")).timestamp()
+    except ValueError:
+        return None
+
+
+def _avg_power(a, b):
+    vals = [float(v) for v in (a, b) if isinstance(v, (int, float)) and not isinstance(v, bool)]
+    if not vals:
+        return 0.0
+    return max(0.0, min(1.0, sum(vals) / len(vals)))
+
+
+def _ed_print_parts(samples, base_w, nozzle_w, bed_w):
+    """Trapez: Grundlast / Düse / Bett getrennt. None wenn zu wenig ED-Proben."""
+    if not samples or len(samples) < 2:
+        return None
+    base_kwh = 0.0
+    nozzle_kwh = 0.0
+    bed_kwh = 0.0
+    ed_steps = 0
+    # Max. Intervall: 3× Normal-Sample (90 s), damit Lücken nicht die ED fortschreiben
+    max_dt = 90.0
+    for i in range(len(samples) - 1):
+        a, b = samples[i], samples[i + 1]
+        t0 = _parse_ts(a.get("sampled_at"))
+        t1 = _parse_ts(b.get("sampled_at"))
+        if t0 is None or t1 is None or t1 <= t0:
+            continue
+        dt = min(t1 - t0, max_dt)
+        hours = dt / 3600.0
+        pn0, pn1 = a.get("nozzle_power"), b.get("nozzle_power")
+        pb0, pb1 = a.get("bed_power"), b.get("bed_power")
+        has_ed = any(
+            isinstance(v, (int, float)) and not isinstance(v, bool)
+            for v in (pn0, pn1, pb0, pb1)
+        )
+        if has_ed:
+            ed_steps += 1
+        ed_n = _avg_power(pn0, pn1)
+        ed_b = _avg_power(pb0, pb1)
+        base_kwh += (float(base_w) / 1000.0) * hours
+        nozzle_kwh += (float(nozzle_w) * ed_n / 1000.0) * hours
+        bed_kwh += (float(bed_w) * ed_b / 1000.0) * hours
+    if ed_steps < 1:
+        return None
+    return {
+        "base_kwh": base_kwh,
+        "nozzle_kwh": nozzle_kwh,
+        "bed_kwh": bed_kwh,
+        "print_kwh": base_kwh + nozzle_kwh + bed_kwh,
+    }
+
+
+def _is_nt_moment(moment, tariff):
+    start_t = _parse_hm(tariff.get("nt_from"))
+    end_t = _parse_hm(tariff.get("nt_to"))
+    if start_t is None or end_t is None:
+        return False
+    now_t = moment.timetz().replace(tzinfo=None)
+    return _in_segment(now_t, start_t, end_t)
+
+
+def effective_euro_per_kwh(duration_s, energy, end_dt=None):
+    energy = energy or {}
+    tariff = energy.get("tariff")
+    if not tariff or not duration_s or float(duration_s) <= 0:
+        return float(energy.get("euro_per_kwh") or 0)
+    end = end_dt if isinstance(end_dt, datetime) else datetime.now(timezone.utc).astimezone()
+    if end.tzinfo is None:
+        end = end.replace(tzinfo=timezone.utc)
+    start = end - timedelta(seconds=float(duration_s))
+    step = 300.0
+    t = start
+    nt_s = 0.0
+    total = 0.0
+    while t < end:
+        chunk = min(step, (end - t).total_seconds())
+        if _is_nt_moment(t, tariff):
+            nt_s += chunk
+        total += chunk
+        t += timedelta(seconds=chunk)
+    if total <= 0:
+        return float(energy.get("euro_per_kwh") or 0)
+    nt_frac = nt_s / total
+    ht = float(tariff.get("ht_euro") or energy.get("euro_per_kwh") or 0)
+    nt = float(tariff.get("nt_euro") or ht)
+    return nt_frac * nt + (1.0 - nt_frac) * ht
+
+
+def _part(key, label, kwh, euro):
+    kwh = float(kwh or 0)
+    return {
+        "key": key,
+        "label": label,
+        "kwh": kwh,
+        "cost": kwh * float(euro or 0),
+    }
+
+
+def energy_estimate(duration_s, energy, samples=None, end_dt=None):
+    """Strom aus ED-Proben oder pauschal Dauer × Watt.
+
+    Quelle ``ed`` nur wenn Düse-/Bett-Watt gesetzt und Proben mit power vorliegen.
+    ``parts`` listet Grundlast / Düse / Bett / Trockner (kWh + €).
+    """
+    energy = energy or {}
+    euro = effective_euro_per_kwh(duration_s, energy, end_dt=end_dt)
+    dry_kwh = (float(energy.get("dryer_watts") or 0) / 1000) * float(energy.get("dry_hours") or 0)
+    base_w = float(energy.get("watts") or 0)
+    nozzle_w = float(energy.get("nozzle_watts") or 0)
+    bed_w = float(energy.get("bed_watts") or 0)
+
+    parts_map = None
+    source = "flat"
+    if (nozzle_w > 0 or bed_w > 0) and samples:
+        parts_map = _ed_print_parts(samples, base_w, nozzle_w, bed_w)
+        if parts_map is not None:
+            source = "ed"
+
+    if parts_map is None:
+        hours = float(duration_s or 0) / 3600
+        parts_map = {
+            "base_kwh": (base_w / 1000) * hours,
+            "nozzle_kwh": 0.0,
+            "bed_kwh": 0.0,
+            "print_kwh": (base_w / 1000) * hours,
+        }
+        source = "flat"
+
+    print_kwh = float(parts_map["print_kwh"])
+    kwh = print_kwh + dry_kwh
+    parts = [
+        _part("base", "Grundlast", parts_map["base_kwh"], euro),
+        _part("nozzle", "Düse", parts_map["nozzle_kwh"], euro),
+        _part("bed", "Bett", parts_map["bed_kwh"], euro),
+        _part("dryer", "Trockner", dry_kwh, euro),
+    ]
+    parts = [p for p in parts if p["kwh"] > 1e-6]
+    return {
+        "kwh": kwh,
+        "print_kwh": print_kwh,
+        "dry_kwh": dry_kwh,
+        "base_kwh": float(parts_map["base_kwh"]),
+        "nozzle_kwh": float(parts_map["nozzle_kwh"]),
+        "bed_kwh": float(parts_map["bed_kwh"]),
+        "cost": kwh * euro,
+        "euro_per_kwh": euro,
+        "source": source,
+        "parts": parts,
+    }
+
+
+def energy_cost(duration_s, energy, samples=None, end_dt=None):
+    return energy_estimate(duration_s, energy, samples, end_dt=end_dt)["cost"]
+
+
+def offer_from_file(file_row, material_price, machine_rate_per_h, setup_min, margin):
+    """Angebots-Schätzung aus Datei-Gewicht und Druckzeit."""
+    weight_g = float((file_row or {}).get("weight_g") or 0)
+    est_s = float((file_row or {}).get("estimated_s") or 0)
+    hours = est_s / 3600.0 if est_s > 0 else 0.0
+    mat = float(material_price or 0)
+    rate = float(machine_rate_per_h or 0)
+    setup_h = float(setup_min or 0) / 60.0
+    material_cost = (weight_g / 1000.0) * mat
+    machine_cost = hours * rate + setup_h * rate
+    subtotal = material_cost + machine_cost
+    pct = float(margin or 0)
+    total = subtotal * (1.0 + pct / 100.0) if subtotal > 0 else 0.0
+    return {
+        "weight_g": weight_g,
+        "hours": hours,
+        "material_cost": material_cost,
+        "machine_cost": machine_cost,
+        "subtotal": subtotal,
+        "margin_percent": pct,
+        "total": total,
+    }
+
+
+def order_actuals(conn, order_id):
+    """Summe Kosten, Zeit und Ausschuss der verknüpften Läufe."""
+    row = conn.execute(
+        """
+        SELECT
+            COALESCE(SUM(r.filament_cost + r.energy_cost), 0) AS cost_total,
+            COALESCE(SUM(r.duration_s), 0) AS duration_s,
+            COALESCE(SUM(r.pieces_ok), 0) AS pieces_ok,
+            COALESCE(SUM(r.pieces_bad), 0) AS pieces_bad,
+            COALESCE(SUM(r.weight_g) FILTER (WHERE r.verdict = 'ausschuss'), 0) AS scrap_g,
+            COUNT(*) FILTER (WHERE r.verdict = 'ausschuss') AS scrap_runs
+        FROM order_items oi
+        JOIN runs r ON r.order_item_id = oi.id
+        WHERE oi.order_id = %s
+        """,
+        (order_id,),
+    ).fetchone()
+    pieces_ok = int(row["pieces_ok"] or 0)
+    cost_total = float(row["cost_total"] or 0)
+    return {
+        "cost_total": cost_total,
+        "duration_s": float(row["duration_s"] or 0),
+        "pieces_ok": pieces_ok,
+        "pieces_bad": int(row["pieces_bad"] or 0),
+        "scrap_g": float(row["scrap_g"] or 0),
+        "scrap_runs": int(row["scrap_runs"] or 0),
+        "cost_per_part": (cost_total / pieces_ok) if pieces_ok > 0 else None,
+        "yield_percent": (
+            100.0 * pieces_ok / (pieces_ok + int(row["pieces_bad"] or 0))
+            if (pieces_ok + int(row["pieces_bad"] or 0)) > 0
+            else None
+        ),
+    }
@@ -0,0 +1,153 @@
+"""Tagesbericht und Push für Wartung/Bedarf/Termine."""
+
+from __future__ import annotations
+
+import threading
+import time
+from datetime import date, datetime, timedelta, timezone
+
+from grotti import bedarf as bedarf_mod
+from grotti import jetzt as jetzt_mod
+from grotti import notify
+from grotti import store
+from grotti.db import connect
+
+
+def _yesterday_stats(conn):
+    today = date.today()
+    yesterday = today - timedelta(days=1)
+    start = datetime.combine(yesterday, datetime.min.time(), tzinfo=timezone.utc)
+    end = datetime.combine(today, datetime.min.time(), tzinfo=timezone.utc)
+    row = conn.execute(
+        """
+        SELECT
+            COUNT(*) AS runs,
+            COALESCE(SUM(duration_s), 0) AS duration_s,
+            COALESCE(SUM(weight_used_g), 0) AS grams,
+            COALESCE(SUM(CASE WHEN verdict = 'ausschuss' THEN 1 ELSE 0 END), 0) AS scrap,
+            COALESCE(SUM(pieces_ok), 0) AS pieces_ok,
+            COALESCE(SUM(pieces_bad), 0) AS pieces_bad
+        FROM runs
+        WHERE started_at >= %s AND started_at < %s
+        """,
+        (start, end),
+    ).fetchone()
+    return {
+        "date": yesterday.isoformat(),
+        "runs": int(row["runs"] or 0),
+        "duration_s": float(row["duration_s"] or 0),
+        "grams": float(row["grams"] or 0),
+        "scrap": int(row["scrap"] or 0),
+        "pieces_ok": int(row["pieces_ok"] or 0),
+        "pieces_bad": int(row["pieces_bad"] or 0),
+    }
+
+
+def build_text(conn, watcher_latest=None, printers=None):
+    stats = _yesterday_stats(conn)
+    waiting = len([
+        j for j in store.list_print_queue(conn, limit=200)["items"]
+        if j.get("status") == "waiting"
+    ])
+    eta = jetzt_mod.farm_eta([
+        {"remain": (live or {}).get("remain") or 0}
+        for live in (watcher_latest or [])
+        if (live or {}).get("state") in ("printing", "paused", "heating")
+    ])
+    lines = [
+        "Grotti Tagesbericht %s" % stats["date"],
+        "Läufe: %d · Druckzeit: %.1f h · Material: %.0f g" % (
+            stats["runs"], stats["duration_s"] / 3600.0, stats["grams"],
+        ),
+        "Ausschuss-Läufe: %d · Stück gut/schlecht: %d/%d" % (
+            stats["scrap"], stats["pieces_ok"], stats["pieces_bad"],
+        ),
+        "Heute in Warteschlange: %d" % waiting,
+    ]
+    if eta.get("all_done_in_s"):
+        at = datetime.now(timezone.utc) + timedelta(seconds=eta["all_done_in_s"])
+        lines.append("Laufende Drucke fertig gegen %s Uhr" % at.astimezone().strftime("%H:%M"))
+    overdue = jetzt_mod.overdue_orders(conn, limit=5)
+    if overdue:
+        lines.append("Überfällig: " + ", ".join(o["title"] for o in overdue))
+    short = (bedarf_mod.compute(conn).get("shortfall") or [])[:3]
+    if short:
+        bits = []
+        for item in short:
+            label = " ".join(x for x in [item.get("material_type"), item.get("color")] if x) or "Filament"
+            bits.append("%s (−%sg)" % (label, int(item.get("shortfall_g") or 0)))
+        lines.append("Bedarf: " + ", ".join(bits))
+    parts = jetzt_mod.overdue_maintenance(conn, printers or store.list_printers(conn), limit=5)
+    if parts:
+        lines.append("Wartung: " + ", ".join("%s/%s" % (p["printer"], p["label"]) for p in parts))
+    return "\n".join(lines)
+
+
+def push_ops_alerts(conn, cfg, printers=None):
+    """Einmalige Push-Hinweise für Bedarf, Wartung, Termine (mit Dedup über Events).
+
+    kind beim Speichern muss zum Dedup-Check passen — sonst jede Minute ein neuer Eintrag
+    (DailyReportThread tickt alle 60 s).
+    """
+    printers = printers or store.list_printers(conn)
+    for order in jetzt_mod.overdue_orders(conn, limit=10):
+        msg = "Auftrag überfällig: %s (fällig %s)" % (order["title"], order.get("due_at") or "")
+        key = "order:%s" % order["id"]
+        if not store.recent_event_kind(conn, key, "auftrag", within_s=86400):
+            notify.record(conn, cfg, key, order["title"], "auftrag", msg, dedupe_s=86400)
+    for part in jetzt_mod.overdue_maintenance(conn, printers, limit=10):
+        msg = "Wartung fällig: %s · %s" % (part["printer"], part["label"])
+        key = "maint:%s" % part["id"]
+        if not store.recent_event_kind(conn, key, "wartung", within_s=86400):
+            notify.record(conn, cfg, key, part["printer"], "wartung", msg, dedupe_s=86400)
+    for item in (bedarf_mod.compute(conn).get("shortfall") or [])[:5]:
+        label = " ".join(x for x in [item.get("material_type"), item.get("color")] if x) or "Filament"
+        msg = "Bedarf: %s — %s g fehlen" % (label, int(item.get("shortfall_g") or 0))
+        key = "bedarf:%s:%s" % (item.get("material_type") or "", item.get("color") or "")
+        if not store.recent_event_kind(conn, key, "bedarf", within_s=21600):
+            notify.record(conn, cfg, key, label, "bedarf", msg, dedupe_s=21600)
+
+
+class DailyReportThread:
+    """Sendet um 7:00 Ortszeit den Tagesbericht und prüft periodisch Ops-Alerts."""
+
+    def __init__(self, database_url, cfg, watcher=None):
+        self.database_url = database_url
+        self.cfg = cfg
+        self.watcher = watcher
+        self._stop = threading.Event()
+        self._thread = None
+        self._last_report_day = None
+
+    def start(self):
+        if self._thread and self._thread.is_alive():
+            return
+        self._thread = threading.Thread(target=self._loop, name="grotti-daily", daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._stop.set()
+
+    def _loop(self):
+        while not self._stop.wait(60):
+            try:
+                self._tick()
+            except Exception:
+                pass
+
+    def _tick(self):
+        now = datetime.now().astimezone()
+        with connect(self.database_url) as conn:
+            push_ops_alerts(conn, self.cfg, store.list_printers(conn))
+            conn.commit()
+            if now.hour == 7 and now.minute < 2:
+                day = now.date().isoformat()
+                if self._last_report_day == day:
+                    return
+                latest = (self.watcher.latest if self.watcher else None) or []
+                text = build_text(conn, latest, store.list_printers(conn))
+                notify.send_telegram(self.cfg, text)
+                notify.send_ntfy(self.cfg, text)
+                store.add_event(conn, "", "Grotti", "fertig", text.split("\n")[0])
+                conn.commit()
+                self._last_report_day = day
@@ -1,6 +1,9 @@
-"""PostgreSQL-Verbindung und Schema."""
+"""PostgreSQL-Verbindung, Pool und Migrationen."""
+
+from __future__ import annotations

 import re
+import threading
 from contextlib import contextmanager
 from pathlib import Path
 from urllib.parse import urlparse, urlunparse
@@ -8,22 +11,109 @@ from urllib.parse import urlparse, urlunparse
 import psycopg
 from psycopg import sql
 from psycopg.rows import dict_row
+from psycopg_pool import ConnectionPool

-SCHEMA = (Path(__file__).parent / "schema.sql").read_text(encoding="utf-8")
+from grotti import logutil
+
+log = logutil.get("grotti.db")
+
+MIGRATIONS_DIR = Path(__file__).parent / "migrations"
+SCHEMA_LEGACY = Path(__file__).parent / "schema.sql"
+
+_pool: ConnectionPool | None = None
+_pool_lock = threading.Lock()
+_user_count_cache = {"n": None, "at": 0.0}
+_USER_COUNT_TTL = 5.0


 def database_name(url):
    name = urlparse(url).path.lstrip("/")
    if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name or ""):
-        raise SystemExit("Der Datenbankname in database_url darf nur Buchstaben, Zahlen und Unterstrich enthalten.")
+        raise SystemExit(
+            "Der Datenbankname in database_url darf nur Buchstaben, Zahlen und Unterstrich enthalten."
+        )
    return name


-def apply_schema(conn):
-    for statement in SCHEMA.split(";"):
+def _migration_files():
+    files = sorted(MIGRATIONS_DIR.glob("*.sql"))
+    out = []
+    for path in files:
+        match = re.match(r"^(\d+)_", path.name)
+        if not match:
+            continue
+        out.append((int(match.group(1)), path))
+    return out
+
+
+def _split_statements(text):
+    """Einfache Trennung an Semikolon — Migrationen ohne Funktionen mit ; im Körper."""
+    parts = []
+    for statement in text.split(";"):
        cleaned = statement.strip()
        if cleaned:
-            conn.execute(cleaned)
+            parts.append(cleaned)
+    return parts
+
+
+def _ensure_version_table(conn):
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS schema_version (
+            version integer PRIMARY KEY,
+            name text NOT NULL,
+            applied_at timestamptz NOT NULL DEFAULT now()
+        )
+        """
+    )
+
+
+def _applied_versions(conn):
+    rows = conn.execute("SELECT version FROM schema_version ORDER BY version").fetchall()
+    return {int(row["version"] if isinstance(row, dict) else row[0]) for row in rows}
+
+
+def _legacy_schema_present(conn):
+    row = conn.execute(
+        """
+        SELECT 1 FROM information_schema.tables
+        WHERE table_schema = 'public' AND table_name = 'printers'
+        """
+    ).fetchone()
+    return bool(row)
+
+
+def apply_migrations(conn):
+    """Wendet fehlende Migrationen an. Bestehende Installationen ohne Version bekommen 001 gutgeschrieben."""
+    _ensure_version_table(conn)
+    applied = _applied_versions(conn)
+    migrations = _migration_files()
+    if not migrations and SCHEMA_LEGACY.exists():
+        # Fallback: altes schema.sql einmalig
+        for statement in _split_statements(SCHEMA_LEGACY.read_text(encoding="utf-8")):
+            conn.execute(statement)
+        return
+
+    if not applied and _legacy_schema_present(conn):
+        # Schema war schon da (vor Migrationssystem) → Basis als angewandt markieren.
+        base = next((m for m in migrations if m[0] == 1), None)
+        if base:
+            conn.execute(
+                "INSERT INTO schema_version (version, name) VALUES (%s, %s) ON CONFLICT DO NOTHING",
+                (1, base[1].name),
+            )
+            applied.add(1)
+
+    for version, path in migrations:
+        if version in applied:
+            continue
+        text = path.read_text(encoding="utf-8")
+        for statement in _split_statements(text):
+            conn.execute(statement)
+        conn.execute(
+            "INSERT INTO schema_version (version, name) VALUES (%s, %s)",
+            (version, path.name),
+        )


 def prepare(url):
@@ -31,14 +121,16 @@ def prepare(url):
    admin = urlunparse(urlparse(url)._replace(path="/postgres"))
    try:
        with psycopg.connect(admin, autocommit=True, connect_timeout=5) as conn:
-            exists = conn.execute("SELECT 1 FROM pg_database WHERE datname = %s", (name,)).fetchone()
+            exists = conn.execute(
+                "SELECT 1 FROM pg_database WHERE datname = %s", (name,)
+            ).fetchone()
            if not exists:
                conn.execute(sql.SQL("CREATE DATABASE {}").format(sql.Identifier(name)))
-    except psycopg.Error:
-        pass
+    except psycopg.Error as exc:
+        log.warning("Datenbank anlegen: %s", exc)
    try:
-        with psycopg.connect(url, connect_timeout=5) as conn:
-            apply_schema(conn)
+        with psycopg.connect(url, row_factory=dict_row, connect_timeout=5) as conn:
+            apply_migrations(conn)
            conn.commit()
    except psycopg.Error as exc:
        raise SystemExit(
@@ -50,9 +142,50 @@ def prepare(url):
        ) from exc


+def init_pool(url, min_size=2, max_size=16):
+    global _pool
+    with _pool_lock:
+        if _pool is not None:
+            return _pool
+        _pool = ConnectionPool(
+            conninfo=url,
+            min_size=min_size,
+            max_size=max_size,
+            kwargs={"row_factory": dict_row, "connect_timeout": 5},
+            open=True,
+            name="grotti",
+        )
+        return _pool
+
+
+def close_pool():
+    global _pool
+    with _pool_lock:
+        if _pool is not None:
+            _pool.close()
+            _pool = None
+
+
+def get_pool():
+    if _pool is None:
+        raise RuntimeError("Datenbank-Pool ist nicht gestartet.")
+    return _pool
+
+
@contextmanager
-def connect(url):
-    conn = psycopg.connect(url, row_factory=dict_row)
+def connect(url=None):
+    """Verbindung aus dem Pool, sonst einmalig direkt (Tests / prepare)."""
+    if _pool is not None:
+        with _pool.connection() as conn:
+            try:
+                yield conn
+            except Exception:
+                conn.rollback()
+                raise
+        return
+    if not url:
+        raise RuntimeError("Keine database_url und kein Pool.")
+    conn = psycopg.connect(url, row_factory=dict_row, connect_timeout=5)
    try:
        yield conn
    except Exception:
@@ -60,3 +193,35 @@ def connect(url):
        raise
    finally:
        conn.close()
+
+
+def cached_user_count(conn):
+    """Zählt Benutzer mit kurzem Cache — vermeidet count(*) bei jedem Request."""
+    import time
+
+    now = time.monotonic()
+    cached = _user_count_cache["n"]
+    if cached is not None and (now - _user_count_cache["at"]) < _USER_COUNT_TTL:
+        return cached
+    n = int(conn.execute("SELECT COUNT(*) AS n FROM users").fetchone()["n"])
+    _user_count_cache["n"] = n
+    _user_count_cache["at"] = now
+    return n
+
+
+def invalidate_user_count():
+    _user_count_cache["n"] = None
+    _user_count_cache["at"] = 0.0
+
+
+def prune_run_samples(conn, keep_days=90):
+    """Alte Temperaturproben löschen (Retention)."""
+    days = max(7, int(keep_days))
+    row = conn.execute(
+        """
+        DELETE FROM run_samples
+        WHERE sampled_at < now() - (%s || ' days')::interval
+        """,
+        (str(days),),
+    )
+    return row.rowcount if row is not None else 0
@@ -55,8 +55,8 @@ DEFAULT_SWEEP = {
 # Ein Punkt in der Bettmitte — kein LeviQ, kein 3×3, kein Heizen.
 DEFAULT_CHECK = {
    "type": "check",
-    # Result is z= gegen Grenze. Temporär 3 mm — kalter Kunststoff an der Düse
-    # tastet sonst oft 1–2 mm und meldet Restteil. Später wieder straffen.
+    # Result is z= gegen Grenze. 3 mm: kalter Kunststoff an der Düse
+    # tastet sonst oft 1–2 mm und meldet Restteil.
    "max_delta_mm": 3.0,
    "timeout_min": 2,
    "x": 125.0,
@@ -454,11 +454,6 @@ def sweep_lower_to_push_script(sweep):
    ])


-def sweep_probe_height_script(sweep):
-    """Kompatibel: hoch, hinten, langsam auf z_push."""
-    return sweep_go_back_high_script(sweep) + "\n" + sweep_lower_to_push_script(sweep)
-
-
 def assert_clear_before_lower(live, sweep, min_z_mm=15.0):
    """Vor dem Senken: Toolhead muss noch klar über dem Bett stehen."""
    pos = (live or {}).get("position") or []
@@ -562,100 +557,6 @@ def check_lift_script(check):
    ])


-def _axis_coords(lo, hi, count):
-    if count <= 1:
-        return [(lo + hi) / 2.0]
-    return [lo + (hi - lo) * i / (count - 1) for i in range(count)]
-
-
-def _matrix_ok(matrix):
-    if not isinstance(matrix, list) or not matrix:
-        return False
-    width = None
-    for row in matrix:
-        if not isinstance(row, list) or not row:
-            return False
-        if width is None:
-            width = len(row)
-        if len(row) != width:
-            return False
-        for value in row:
-            if not isinstance(value, (int, float)):
-                return False
-    return True
-
-
-def interpolate_mesh_z(mesh, x, y):
-    """Bilinear aus Roh-probed_matrix. Klipper: Zeile 0 = mesh_min Y."""
-    matrix = mesh.get("matrix") if isinstance(mesh, dict) else None
-    if not _matrix_ok(matrix):
-        return None
-    mesh_min = mesh.get("mesh_min") or [0, 0]
-    mesh_max = mesh.get("mesh_max") or [0, 0]
-    try:
-        x0, y0 = float(mesh_min[0]), float(mesh_min[1])
-        x1, y1 = float(mesh_max[0]), float(mesh_max[1])
-    except (TypeError, ValueError, IndexError):
-        return None
-    rows = len(matrix)
-    cols = len(matrix[0])
-    if cols < 1 or rows < 1:
-        return None
-    if abs(x1 - x0) < 1e-9 or abs(y1 - y0) < 1e-9:
-        return float(matrix[0][0])
-    tx = 0.0 if cols == 1 else (float(x) - x0) / (x1 - x0) * (cols - 1)
-    ty = 0.0 if rows == 1 else (float(y) - y0) / (y1 - y0) * (rows - 1)
-    tx = max(0.0, min(float(cols - 1), tx))
-    ty = max(0.0, min(float(rows - 1), ty))
-    c0 = int(tx)
-    r0 = int(ty)
-    c1 = min(cols - 1, c0 + 1)
-    r1 = min(rows - 1, r0 + 1)
-    fx = tx - c0
-    fy = ty - r0
-    z00 = float(matrix[r0][c0])
-    z10 = float(matrix[r0][c1])
-    z01 = float(matrix[r1][c0])
-    z11 = float(matrix[r1][c1])
-    z0 = z00 * (1 - fx) + z10 * fx
-    z1 = z01 * (1 - fx) + z11 * fx
-    return z0 * (1 - fy) + z1 * fy
-
-
-def mesh_delta_mm(baseline, measured):
-    """Max |Δ| und Mittel |Δ|: Messpunkte gegen interpoliertes Baseline-Netz."""
-    if not isinstance(baseline, dict) or not _matrix_ok(baseline.get("matrix")):
-        raise GrottiError("Kein Bettnetz zum Vergleich — vorher nivellieren.", "mesh")
-    if not isinstance(measured, dict) or not _matrix_ok(measured.get("matrix")):
-        raise GrottiError("Neues Bettnetz fehlt nach dem Antasten.", "mesh")
-    matrix = measured["matrix"]
-    mesh_min = measured.get("mesh_min") or [0, 0]
-    mesh_max = measured.get("mesh_max") or [0, 0]
-    try:
-        x0, y0 = float(mesh_min[0]), float(mesh_min[1])
-        x1, y1 = float(mesh_max[0]), float(mesh_max[1])
-    except (TypeError, ValueError, IndexError) as exc:
-        raise GrottiError("Messnetz ohne gültigen Bereich.", "mesh") from exc
-    rows = len(matrix)
-    cols = len(matrix[0])
-    xs = _axis_coords(x0, x1, cols)
-    ys = _axis_coords(y0, y1, rows)
-    deltas = []
-    for ri, y in enumerate(ys):
-        for ci, x in enumerate(xs):
-            expected = interpolate_mesh_z(baseline, x, y)
-            if expected is None:
-                raise GrottiError("Baseline-Netz lässt sich nicht interpolieren.", "mesh")
-            deltas.append(abs(float(matrix[ri][ci]) - expected))
-    if not deltas:
-        raise GrottiError("Keine Messpunkte zum Vergleich.", "mesh")
-    return {
-        "max_delta_mm": max(deltas),
-        "mean_delta_mm": sum(deltas) / len(deltas),
-        "points": len(deltas),
-    }
-
-
 def step_label(step):
    if not isinstance(step, dict):
        return ""
@@ -0,0 +1,42 @@
+"""Thread-sicherer Pub/Sub für Server-Sent Events (Live-UI)."""
+
+from __future__ import annotations
+
+import threading
+from queue import Empty, Queue
+
+_lock = threading.Lock()
+_subscribers: list[Queue] = []
+
+
+def subscribe() -> Queue:
+    q: Queue = Queue(maxsize=256)
+    with _lock:
+        _subscribers.append(q)
+    return q
+
+
+def unsubscribe(q: Queue) -> None:
+    with _lock:
+        try:
+            _subscribers.remove(q)
+        except ValueError:
+            pass
+
+
+def publish(kind: str, payload: dict | None = None) -> None:
+    msg = {"kind": kind or "message", "payload": payload if payload is not None else {}}
+    with _lock:
+        targets = list(_subscribers)
+    for q in targets:
+        try:
+            q.put_nowait(msg)
+        except Exception:
+            pass
+
+
+def wait_event(q: Queue, timeout_s: float) -> dict | None:
+    try:
+        return q.get(timeout=timeout_s)
+    except Empty:
+        return None
@@ -0,0 +1,293 @@
+"""Aggregierte „Jetzt“-Handlungsliste für Sidebar und Mobile."""
+
+from __future__ import annotations
+
+from datetime import date, datetime, timezone
+
+from grotti import bedarf as bedarf_mod
+from grotti import maintenance
+from grotti import store
+
+
+def _filename_label(filename):
+    name = (filename or "").strip()
+    for suffix in (".gcode.3mf", ".gcode", ".3mf"):
+        if name.lower().endswith(suffix):
+            name = name[: -len(suffix)]
+            break
+    while name and name[0].isdigit():
+        parts = name.split("-", 1)
+        if len(parts) == 2 and parts[0].isdigit():
+            name = parts[1]
+        else:
+            break
+    return name or filename or ""
+
+
+def _iso_remain(remain_s):
+    remain = float(remain_s or 0)
+    if remain <= 0:
+        return None
+    at = datetime.now(timezone.utc).timestamp() + remain
+    return datetime.fromtimestamp(at, tz=timezone.utc).isoformat()
+
+
+def farm_eta(running_items):
+    """Früheste und späteste Fertig-Zeit aus laufenden Drucken."""
+    remains = [
+        float(item.get("remain") or 0)
+        for item in (running_items or [])
+        if float(item.get("remain") or 0) > 0
+    ]
+    if not remains:
+        return {"all_done_at": None, "all_done_in_s": None, "next_free_in_s": None}
+    return {
+        "all_done_at": _iso_remain(max(remains)),
+        "all_done_in_s": max(remains),
+        "next_free_in_s": min(remains),
+    }
+
+
+def overdue_orders(conn, limit=8):
+    today = date.today()
+    rows = conn.execute(
+        """
+        SELECT o.*, c.name AS customer_name
+        FROM orders o
+        LEFT JOIN customers c ON c.id = o.customer_id
+        WHERE o.due_at IS NOT NULL
+          AND o.due_at < %s
+          AND o.status NOT IN ('fertig', 'geliefert', 'bezahlt')
+        ORDER BY o.due_at ASC, o.id ASC
+        LIMIT %s
+        """,
+        (today, int(limit)),
+    ).fetchall()
+    out = []
+    for row in rows:
+        out.append({
+            "id": row["id"],
+            "title": row["title"],
+            "status": row["status"],
+            "due_at": row["due_at"].isoformat() if row.get("due_at") else None,
+            "customer": row.get("customer_name") or "",
+        })
+    return out
+
+
+def overdue_maintenance(conn, printers, limit=8):
+    items = []
+    for printer in printers or []:
+        host = printer.get("host") or ""
+        counters = maintenance.counters_for_host(conn, host)
+        rows = conn.execute(
+            "SELECT * FROM maintenance_parts WHERE printer_host = %s ORDER BY label, part_key, id",
+            (host,),
+        ).fetchall()
+        for row in rows:
+            part = maintenance.part_out(row, counters, conn=conn)
+            if not (part.get("overdue_hours") or part.get("overdue_meters")):
+                continue
+            items.append({
+                "id": part["id"],
+                "host": host,
+                "printer": printer.get("name") or host,
+                "label": part.get("label") or part.get("part_key") or "Teil",
+                "overdue_hours": bool(part.get("overdue_hours")),
+                "overdue_meters": bool(part.get("overdue_meters")),
+            })
+            if len(items) >= limit:
+                return items
+    return items
+
+
+def build(conn, watcher_latest, printers=None, send_jobs=None):
+    """Priorisierte Handlungsliste + laufende Drucke + Farm-ETA."""
+    printers = printers if printers is not None else store.list_printers(conn)
+    clears = store.bed_clear_map(conn)
+    busy_hosts = {
+        row["host"]
+        for row in conn.execute(
+            "SELECT DISTINCT host FROM print_queue WHERE status = 'running'"
+        ).fetchall()
+    }
+    queue = store.list_print_queue(conn, limit=80)["items"]
+    waiting = [j for j in queue if j.get("status") == "waiting"]
+    errors = [j for j in queue if j.get("status") == "error"]
+    running_q = [j for j in queue if j.get("status") == "running"]
+
+    actions = []
+
+    for live in watcher_latest or []:
+        host = live.get("host") or ""
+        state = (live.get("state") or "").lower()
+        if state == "paused" and (live.get("filament_empty") or (live.get("pause_reason") or "").strip()):
+            actions.append({
+                "kind": "filament_pause",
+                "priority": 12,
+                "host": host,
+                "printer": live.get("name") or host,
+                "title": "Material nachlegen",
+                "detail": (live.get("pause_reason") or "Drucker pausiert — Filament leer?").strip(),
+                "filename": live.get("filename") or "",
+                "href": "/#" + host,
+            })
+
+    for live in watcher_latest or []:
+        host = live.get("host") or ""
+        state = (live.get("state") or "").lower()
+        if not clears.get(host) or host in busy_hosts or state in ("printing", "paused", "heating"):
+            continue
+        actions.append({
+            "kind": "clear",
+            "priority": 10,
+            "host": host,
+            "printer": live.get("name") or host,
+            "title": "Platte räumen",
+            "detail": _filename_label(live.get("filename") or ""),
+            "filename": live.get("filename") or "",
+            "href": "/#" + host,
+        })
+
+    for job in errors[:6]:
+        actions.append({
+            "kind": "queue_error",
+            "priority": 20,
+            "id": job.get("id"),
+            "host": job.get("host") or "",
+            "printer": job.get("printer_name") or job.get("host") or "",
+            "title": "Druck fehlgeschlagen",
+            "detail": job.get("message") or _filename_label(job.get("filename") or ""),
+            "filename": job.get("filename") or "",
+            "is_ablauf": bool(job.get("is_ablauf")),
+            "step_index": job.get("step_index"),
+            "step_label_current": job.get("step_label_current") or "",
+            "href": "/warteschlange",
+        })
+
+    bedarf = bedarf_mod.compute(conn)
+    for item in (bedarf.get("shortfall") or [])[:5]:
+        label = " · ".join(
+            x for x in [item.get("material_type"), item.get("color")] if x
+        ) or "Filament"
+        actions.append({
+            "kind": "bedarf",
+            "priority": 30,
+            "title": "Spule fehlt",
+            "detail": "%s — %s g fehlen" % (label, int(item.get("shortfall_g") or 0)),
+            "material_type": item.get("material_type") or "",
+            "color": item.get("color") or "",
+            "shortfall_g": item.get("shortfall_g") or 0,
+            "href": "/material#bedarf",
+        })
+
+    for part in overdue_maintenance(conn, printers):
+        actions.append({
+            "kind": "wartung",
+            "priority": 40,
+            "id": part["id"],
+            "host": part["host"],
+            "printer": part["printer"],
+            "title": "Wartung fällig",
+            "detail": "%s · %s" % (part["printer"], part["label"]),
+            "href": "/wartung",
+        })
+
+    for order in overdue_orders(conn):
+        actions.append({
+            "kind": "auftrag",
+            "priority": 50,
+            "id": order["id"],
+            "title": "Auftrag überfällig",
+            "detail": "%s · fällig %s" % (order["title"], order.get("due_at") or ""),
+            "due_at": order.get("due_at"),
+            "href": "/auftraege",
+        })
+
+    shortfall = bedarf.get("shortfall") or []
+    for job in waiting[:8]:
+        tip = (job.get("wait_reason") or "").strip()
+        if not tip and shortfall:
+            # Fallback ohne Routing-Hinweis
+            tip = ""
+        if not tip:
+            continue
+        actions.append({
+            "kind": "waiting",
+            "priority": 60,
+            "id": job.get("id"),
+            "host": job.get("host") or "",
+            "printer": job.get("printer_name") or job.get("host") or "",
+            "title": "Wartet auf Material",
+            "detail": tip,
+            "filename": job.get("filename") or "",
+            "reason": tip,
+            "href": "/warteschlange",
+        })
+
+    actions.sort(key=lambda a: (a.get("priority") or 99, a.get("id") or 0))
+
+    live_by_host = {}
+    running = []
+    for live in watcher_latest or []:
+        state = (live.get("state") or "").lower()
+        if state not in ("printing", "paused", "heating"):
+            continue
+        item = {
+            "host": live.get("host") or "",
+            "name": live.get("name") or "",
+            "state": state,
+            "progress": live.get("progress") or 0,
+            "remain": live.get("remain") or 0,
+            "filename": live.get("filename") or "",
+            "filament_empty": bool(live.get("filament_empty")),
+            "pause_reason": (live.get("pause_reason") or "").strip(),
+            "queue_id": None,
+        }
+        live_by_host[item["host"]] = item
+        running.append(item)
+    for job in running_q:
+        host = job.get("host") or ""
+        if host in live_by_host:
+            live_by_host[host]["queue_id"] = job.get("id")
+            live_by_host[host]["is_ablauf"] = bool(job.get("is_ablauf"))
+            live_by_host[host]["step_labels"] = job.get("step_labels")
+            live_by_host[host]["display_step_index"] = job.get("display_step_index")
+            live_by_host[host]["step_index"] = job.get("step_index")
+        else:
+            phase = (job.get("phase") or "").lower()
+            starting = phase in ("starting", "await_print")
+            running.append({
+                "host": host,
+                "name": job.get("printer_name") or host,
+                "state": "starting" if starting else "running",
+                "starting": starting,
+                "progress": job.get("progress") or 0,
+                "remain": job.get("remain") or 0,
+                "filename": job.get("filename") or "",
+                "message": job.get("message") or "",
+                "queue_id": job.get("id"),
+                "is_ablauf": bool(job.get("is_ablauf")),
+            })
+
+    sends = []
+    for job in send_jobs or []:
+        if job.get("status") in ("pending", "running"):
+            sends.append(job)
+        elif job.get("status") == "error" and len(sends) < 2:
+            sends.append(job)
+
+    alert_kinds = list(store.ALERT_EVENT_KINDS)
+    alert_items = store.list_events(conn, limit=5, unread_only=True, kinds=alert_kinds)
+    unread = store.unread_event_count(conn, kinds=alert_kinds)
+
+    return {
+        "actions": actions,
+        "running": running,
+        "waiting_count": len(waiting),
+        "sends": sends[:5],
+        "alerts": alert_items,
+        "unread_alerts": unread,
+        "eta": farm_eta(running),
+        "bedarf_shortfall": len(shortfall),
+    }
@@ -1,5 +1,7 @@
 """Watch-Ordner, Upload und Vorschaubild."""

+import re
+import shutil
 import time
 import zipfile
 from pathlib import Path
@@ -10,6 +12,8 @@ from grotti.parse import embedded_png, inspect_file, safe_zip_name

 _LAST_WATCH_SYNC = 0.0
 _WATCH_MIN_INTERVAL_S = 20
+_FOLDER_PART = re.compile(r"^[A-Za-z0-9._\- äöüÄÖÜß]+$")
+_MAX_FOLDER_DEPTH = 6


 def skip_path(path, data_dir):
@@ -36,7 +40,7 @@ def sync_watch(conn, cfg, force=False):
    global _LAST_WATCH_SYNC
    folder = cfg["watch_dir"]
    if folder is None:
-        return {"gelesen": 0, "hinweis": "In config.json watch_dir auf den Slice-Ordner setzen."}
+        return {"gelesen": 0, "hinweis": "Unter Einstellungen den Slice-Ordner setzen."}
    if not folder.exists():
        return {"gelesen": 0, "hinweis": "Der Watch-Ordner fehlt: %s" % folder}
    now = time.monotonic()
@@ -55,10 +59,55 @@ def sync_watch(conn, cfg, force=False):
        except (OSError, zipfile.BadZipFile):
            continue
    store.forget_missing_watch(conn, seen)
+    link_watch_files_to_projects(conn, cfg)
    _LAST_WATCH_SYNC = now
    return {"gelesen": len(seen), "hinweis": ""}


+def _apply_meta(conn, file_id, row, meta):
+    store.update_file(
+        conn,
+        file_id,
+        {
+            "printer_family": meta.get("printer_family") or row.get("printer_family"),
+            "filaments": meta.get("filaments") or [],
+            "weight_g": meta.get("weight_g") or 0,
+            "estimated_s": meta.get("estimated_s") or 0,
+            "thumb_entry": meta.get("thumb_entry") or "",
+            "kind": meta.get("kind") or row.get("kind"),
+            "plate": meta.get("plate") or "",
+            "slice_meta": meta.get("slice_meta") or {},
+        },
+    )
+
+
+def refresh_one_file(conn, file_id, watch_dir=None):
+    """Eine Datei neu parsen (paint_index / ACE). None wenn nicht gefunden."""
+    row = store.get_file_row(conn, file_id)
+    if not row:
+        return None
+    stored = row.get("stored_path") or ""
+    path = Path(stored) if stored else None
+    if path is not None and path.is_file():
+        try:
+            meta = meta_for(path)
+            _apply_meta(conn, file_id, row, meta)
+            row = store.get_file_row(conn, file_id) or row
+        except (OSError, zipfile.BadZipFile):
+            pass
+    return store.file_out(row, watch_dir=watch_dir)
+
+
+def filaments_need_paint_index(filaments):
+    rows = filaments if isinstance(filaments, list) else []
+    if len(rows) < 2:
+        return False
+    for item in rows:
+        if not isinstance(item, dict) or "paint_index" not in item:
+            return True
+    return False
+
+
 def refresh_file_meta(conn, force=False):
    """Metadaten bestehender Dateien neu lesen (z. B. paint_info → filaments)."""
    if not force:
@@ -76,27 +125,17 @@ def refresh_file_meta(conn, force=False):
            meta = meta_for(path)
        except (OSError, zipfile.BadZipFile):
            continue
-        store.update_file(
-            conn,
-            row["id"],
-            {
-                "printer_family": meta.get("printer_family") or row.get("printer_family"),
-                "filaments": meta.get("filaments") or [],
-                "weight_g": meta.get("weight_g") or 0,
-                "estimated_s": meta.get("estimated_s") or 0,
-                "thumb_entry": meta.get("thumb_entry") or "",
-                "kind": meta.get("kind") or row.get("kind"),
-                "plate": meta.get("plate") or "",
-                "slice_meta": meta.get("slice_meta") or {},
-            },
-        )
+        _apply_meta(conn, row["id"], row, meta)
        updated += 1
    return updated


 def safe_filename(name):
    base = Path(name).name.replace("\\", "_").replace("/", "_").replace('"', "")
-    return base or "datei.gcode"
+    base = base.strip().strip(".")
+    if not base or base in (".", ".."):
+        return "datei.gcode"
+    return base


 def unique_path(directory, filename):
@@ -113,6 +152,394 @@ def unique_path(directory, filename):
    return candidate


+def require_watch_dir(cfg):
+    folder = cfg.get("watch_dir")
+    if not folder:
+        raise GrottiError("Kein Slice-Ordner gesetzt — unter Einstellungen festlegen.", "watch")
+    root = Path(folder).resolve()
+    if not root.is_dir():
+        raise GrottiError("Der Slice-Ordner fehlt: %s" % root, "watch")
+    return root
+
+
+def normalize_folder(rel):
+    """Relativpfad unter watch_dir; leer = Wurzel. Kein .., begrenzte Tiefe."""
+    text = str(rel or "").strip().replace("\\", "/").strip("/")
+    if not text:
+        return ""
+    parts = []
+    for part in text.split("/"):
+        part = part.strip()
+        if not part or part in (".", ".."):
+            raise GrottiError("Ungültiger Ordnername.", "ordner")
+        if not _FOLDER_PART.match(part):
+            raise GrottiError(
+                "Ordnername nur Buchstaben, Ziffern, Leerzeichen, . _ -.",
+                "ordner",
+            )
+        parts.append(part)
+    if len(parts) > _MAX_FOLDER_DEPTH:
+        raise GrottiError("Ordner zu tief verschachtelt (max. %s)." % _MAX_FOLDER_DEPTH, "ordner")
+    return "/".join(parts)
+
+
+def path_under_watch(watch_dir, rel_folder, name=None):
+    """Absoluter Pfad unter watch_dir; wirft bei Escape."""
+    root = Path(watch_dir).resolve()
+    folder = normalize_folder(rel_folder)
+    target = root if not folder else (root / folder)
+    if name:
+        target = target / safe_filename(name)
+    resolved = target.resolve()
+    if resolved != root and root not in resolved.parents:
+        raise GrottiError("Pfad außerhalb des Slice-Ordners.", "ordner")
+    return resolved
+
+
+def list_folders(cfg):
+    """Unterordner unter watch_dir (auch leer), relativ, sortiert."""
+    try:
+        root = require_watch_dir(cfg)
+    except GrottiError:
+        return []
+    data_dir = cfg.get("data_dir")
+    found = set()
+    for path in root.rglob("*"):
+        if not path.is_dir():
+            continue
+        if data_dir is not None and skip_path(path, data_dir):
+            continue
+        try:
+            rel = path.resolve().relative_to(root).as_posix()
+        except ValueError:
+            continue
+        if rel and rel != ".":
+            found.add(rel)
+    return sorted(found, key=lambda s: s.lower())
+
+
+def create_folder(cfg, rel):
+    root = require_watch_dir(cfg)
+    folder = normalize_folder(rel)
+    if not folder:
+        raise GrottiError("Ordnername fehlt.", "ordner")
+    target = path_under_watch(root, folder)
+    target.mkdir(parents=True, exist_ok=True)
+    return folder
+
+
+def delete_folder(cfg, rel):
+    root = require_watch_dir(cfg)
+    folder = normalize_folder(rel)
+    if not folder:
+        raise GrottiError("Die Wurzel lässt sich nicht löschen.", "ordner")
+    target = path_under_watch(root, folder)
+    if not target.is_dir():
+        raise GrottiError("Der Ordner fehlt.", "ordner", 404)
+    try:
+        next(target.iterdir())
+        raise GrottiError("Ordner ist nicht leer.", "ordner")
+    except StopIteration:
+        pass
+    target.rmdir()
+    return folder
+
+
+def _link_file_to_project_folder(conn, file_id, stored_path, watch_dir):
+    """Wenn Pfad unter einem Projekt-Ordner liegt → project_id setzen."""
+    folder = store.file_folder(stored_path, "watch", watch_dir)
+    if not folder:
+        return
+    for row in store.list_project_folders(conn):
+        base = (row.get("folder") or "").strip().replace("\\", "/").strip("/")
+        if not base:
+            continue
+        if folder == base or folder.startswith(base + "/"):
+            store.set_file_project(conn, file_id, row["id"])
+            return
+
+
+def move_file(conn, cfg, file_id, folder):
+    """Watch- oder Upload-Datei in Slice-Unterordner (oder Wurzel); Upload wird Watch."""
+    root = require_watch_dir(cfg)
+    folder = normalize_folder(folder)
+    row = store.get_file_row(conn, file_id)
+    if not row:
+        raise GrottiError("Die Datei fehlt.", "datei", 404)
+    source = row.get("source") or ""
+    if source not in ("watch", "upload"):
+        raise GrottiError("Diese Datei lässt sich nicht verschieben.", "datei")
+    src = Path(row.get("stored_path") or "")
+    if not src.is_file():
+        raise GrottiError("Die Datei liegt nicht mehr auf der Platte.", "datei", 404)
+    dest_dir = path_under_watch(root, folder)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / src.name
+    if dest.resolve() == src.resolve() and source == "watch":
+        return store.file_out(row, watch_dir=root)
+    if dest.exists() and dest.resolve() != src.resolve():
+        dest = unique_path(dest_dir, src.name)
+    try:
+        shutil.move(str(src), str(dest))
+    except OSError as exc:
+        raise GrottiError("Verschieben fehlgeschlagen: %s" % exc, "ordner") from exc
+    stat = dest.stat()
+    store.update_file_location(
+        conn,
+        file_id,
+        str(dest.resolve()),
+        name=dest.name,
+        size_bytes=stat.st_size,
+        mtime=stat.st_mtime,
+        source="watch",
+    )
+    _link_file_to_project_folder(conn, file_id, str(dest.resolve()), root)
+    row = store.get_file_row(conn, file_id)
+    return store.file_out(row, watch_dir=root)
+
+
+def path_allowed_for_delete(stored_path, cfg):
+    """Nur Dateien unter Slice-Ordner oder data/eingang."""
+    try:
+        resolved = Path(stored_path).resolve()
+    except (OSError, ValueError):
+        return False
+    roots = []
+    watch = cfg.get("watch_dir")
+    if watch:
+        roots.append(Path(watch).resolve())
+    data_dir = cfg.get("data_dir")
+    if data_dir:
+        roots.append((Path(data_dir) / "eingang").resolve())
+    for root in roots:
+        try:
+            if resolved == root or root in resolved.parents:
+                return True
+        except OSError:
+            continue
+    return False
+
+
+def delete_library_file(conn, cfg, file_id):
+    """Bibliotheksdatei löschen (Upload oder Watch) — DB + Datei auf der Platte."""
+    row = store.get_file_row(conn, file_id)
+    if not row:
+        raise GrottiError("Die Datei fehlt.", "datei", 404)
+    stored = row.get("stored_path") or ""
+    if stored and not path_allowed_for_delete(stored, cfg):
+        raise GrottiError("Löschen außerhalb von Slice-Ordner oder Eingang ist nicht erlaubt.", "datei")
+    store.delete_file(conn, file_id)
+    if stored:
+        Path(stored).unlink(missing_ok=True)
+    return row
+
+
+def _ensure_print_suffix(new_name, old_name):
+    """Endung .gcode / .3mf / .gcode.3mf behalten, wenn der Nutzer sie weglässt."""
+    name = safe_filename(new_name)
+    low = name.lower()
+    old_low = (old_name or "").lower()
+    if low.endswith(".gcode.3mf") or low.endswith(".3mf") or low.endswith(".gcode"):
+        return name
+    if old_low.endswith(".gcode.3mf"):
+        return name + ".gcode.3mf"
+    if old_low.endswith(".3mf"):
+        return name + ".3mf"
+    if old_low.endswith(".gcode"):
+        return name + ".gcode"
+    return name
+
+
+def rename_library_file(conn, cfg, file_id, new_name):
+    """Datei im selben Ordner umbenennen — Platte + DB."""
+    row = store.get_file_row(conn, file_id)
+    if not row:
+        raise GrottiError("Die Datei fehlt.", "datei", 404)
+    src = Path(row.get("stored_path") or "")
+    if not src.is_file():
+        raise GrottiError("Die Datei liegt nicht mehr auf der Platte.", "datei", 404)
+    if not path_allowed_for_delete(str(src), cfg):
+        raise GrottiError("Umbenennen außerhalb von Slice-Ordner oder Eingang ist nicht erlaubt.", "datei")
+    final = _ensure_print_suffix(new_name, row.get("name") or src.name)
+    if not final or final in (".", ".."):
+        raise GrottiError("Ungültiger Dateiname.", "datei")
+    dest = src.with_name(final)
+    if dest.resolve() == src.resolve():
+        return store.file_out(row, watch_dir=cfg.get("watch_dir"))
+    if dest.exists():
+        raise GrottiError("Unter diesem Namen liegt schon eine Datei.", "datei")
+    try:
+        src.rename(dest)
+    except OSError as exc:
+        raise GrottiError("Umbenennen fehlgeschlagen: %s" % exc, "datei") from exc
+    stat = dest.stat()
+    store.update_file_location(
+        conn,
+        file_id,
+        str(dest.resolve()),
+        name=dest.name,
+        size_bytes=stat.st_size,
+        mtime=stat.st_mtime,
+    )
+    row = store.get_file_row(conn, file_id)
+    return store.file_out(row, watch_dir=cfg.get("watch_dir"))
+
+
+_PRINT_SUFFIXES = (".gcode", ".3mf", ".gcode.3mf")
+
+
+def is_print_filename(name):
+    low = (name or "").lower()
+    return any(low.endswith(suf) for suf in _PRINT_SUFFIXES)
+
+
+def project_slug(name):
+    """Ordner-sichere Kurzform aus Projektnamen."""
+    text = re.sub(r"[^\w\- äöüÄÖÜß.]+", "-", (name or "").strip(), flags=re.UNICODE)
+    text = re.sub(r"\s+", "-", text)
+    text = re.sub(r"-{2,}", "-", text).strip("-.")
+    text = text[:60] or "projekt"
+    return normalize_folder(text)
+
+
+def ensure_project_folder(cfg, folder_rel):
+    """Projektordner unter watch_dir anlegen; gibt normalisierten Relativpfad zurück."""
+    root = require_watch_dir(cfg)
+    folder = normalize_folder(folder_rel)
+    if not folder:
+        raise GrottiError("Projektordner fehlt.", "ordner")
+    path_under_watch(root, folder).mkdir(parents=True, exist_ok=True)
+    return folder
+
+
+def default_project_folder(name):
+    return "Projekte/" + project_slug(name)
+
+
+def link_watch_files_to_projects(conn, cfg):
+    """Watch-Dateien in Projektordnern dem passenden Projekt zuordnen."""
+    watch = cfg.get("watch_dir")
+    if not watch:
+        return 0
+    projects = store.list_project_folders(conn)
+    if not projects:
+        return 0
+    linked = 0
+    for row in store.list_file_rows(conn):
+        if (row.get("source") or "") != "watch":
+            continue
+        folder = store.file_folder(row.get("stored_path"), "watch", watch)
+        if not folder:
+            continue
+        for proj in projects:
+            base = (proj.get("folder") or "").strip().replace("\\", "/").strip("/")
+            if not base:
+                continue
+            if folder == base or folder.startswith(base + "/"):
+                if row.get("project_id") != proj["id"]:
+                    store.set_file_project(conn, row["id"], proj["id"])
+                    linked += 1
+                break
+    return linked
+
+
+def list_project_assets(cfg, folder_rel):
+    """Nicht-Druckdateien im Projektordner (flach + Unterordner)."""
+    root = require_watch_dir(cfg)
+    folder = normalize_folder(folder_rel)
+    if not folder:
+        return []
+    base = path_under_watch(root, folder)
+    if not base.is_dir():
+        return []
+    items = []
+    for path in sorted(base.rglob("*")):
+        if not path.is_file() or skip_path(path, cfg["data_dir"]):
+            continue
+        if is_print_filename(path.name):
+            continue
+        try:
+            rel = path.resolve().relative_to(base).as_posix()
+        except ValueError:
+            continue
+        stat = path.stat()
+        items.append({
+            "name": path.name,
+            "rel": rel,
+            "size_bytes": stat.st_size,
+            "mtime": stat.st_mtime,
+        })
+    return items
+
+
+def resolve_project_asset(cfg, folder_rel, rel_name):
+    """Sicheren Pfad zu einer Asset-Datei im Projektordner."""
+    root = require_watch_dir(cfg)
+    folder = normalize_folder(folder_rel)
+    if not folder:
+        raise GrottiError("Projektordner fehlt.", "ordner")
+    base = path_under_watch(root, folder)
+    rel = str(rel_name or "").replace("\\", "/").strip("/")
+    if not rel or ".." in rel.split("/"):
+        raise GrottiError("Ungültiger Dateiname.", "datei")
+    target = (base / rel).resolve()
+    if base not in target.parents and target != base:
+        raise GrottiError("Pfad außerhalb des Projektordners.", "ordner")
+    if not target.is_file():
+        raise GrottiError("Die Datei fehlt.", "datei", 404)
+    return target
+
+
+def save_project_asset(cfg, folder_rel, filename, content):
+    root = require_watch_dir(cfg)
+    folder = normalize_folder(folder_rel)
+    if not folder:
+        raise GrottiError("Projektordner fehlt.", "ordner")
+    dest_dir = path_under_watch(root, folder)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    path = unique_path(dest_dir, filename)
+    path.write_bytes(content)
+    return {
+        "name": path.name,
+        "rel": path.name,
+        "size_bytes": path.stat().st_size,
+        "mtime": path.stat().st_mtime,
+    }
+
+
+def delete_project_asset(cfg, folder_rel, rel_name):
+    path = resolve_project_asset(cfg, folder_rel, rel_name)
+    path.unlink(missing_ok=True)
+    return True
+
+
+def delete_project_disk_folder(cfg, folder_rel, force=False):
+    """Projektordner auf der Platte entfernen (leer oder force inkl. Inhalt)."""
+    if not folder_rel:
+        return
+    try:
+        root = require_watch_dir(cfg)
+    except GrottiError:
+        return
+    folder = normalize_folder(folder_rel)
+    if not folder:
+        return
+    target = path_under_watch(root, folder)
+    if not target.is_dir():
+        return
+    if force:
+        shutil.rmtree(target, ignore_errors=True)
+        return
+    try:
+        next(target.iterdir())
+        raise GrottiError(
+            "Projektordner ist nicht leer — mit Bestätigung inkl. Inhalt löschen.",
+            "ordner",
+        )
+    except StopIteration:
+        target.rmdir()
+
+
 def save_upload(conn, filename, content, cfg, project_id=None):
    directory = cfg["data_dir"] / "eingang"
    directory.mkdir(parents=True, exist_ok=True)
@@ -142,8 +569,30 @@ def ensure_library_gcode(conn, cfg, host, filename):
    return save_upload(conn, name, content, cfg)


-def printer_file(row):
-    path = Path(row["stored_path"])
+def resolve_stored_path(conn, row, data_dir=None):
+    """Gespeicherter Pfad, ggf. nach Umzug von data_dir unter eingang/<name> wiederfinden."""
+    stored = (row or {}).get("stored_path") or ""
+    path = Path(stored) if stored else None
+    if path and path.is_file():
+        return path
+    name = (row or {}).get("name") or (path.name if path else "")
+    if not name or data_dir is None:
+        return None
+    candidate = Path(data_dir) / "eingang" / name
+    if not candidate.is_file():
+        return None
+    resolved = str(candidate.resolve())
+    file_id = (row or {}).get("id")
+    if file_id and conn is not None:
+        conn.execute("UPDATE files SET stored_path = %s WHERE id = %s", (resolved, file_id))
+    row["stored_path"] = resolved
+    return candidate.resolve()
+
+
+def printer_file(row, conn=None, data_dir=None):
+    path = resolve_stored_path(conn, row, data_dir) if (conn is not None or data_dir is not None) else Path(row["stored_path"])
+    if path is None:
+        path = Path(row.get("stored_path") or "")
    if not path.is_file():
        raise GrottiError("Die Datei liegt nicht mehr auf der Platte.", "datei", 404)
    if row["kind"] == "gcode":
@@ -153,9 +602,9 @@ def printer_file(row):
    return path.name, path.read_bytes(), row["plate"] or ""


-def preview_png(row):
-    path = Path(row["stored_path"])
-    if not path.is_file():
+def preview_png(row, conn=None, data_dir=None):
+    path = resolve_stored_path(conn, row, data_dir) if (conn is not None or data_dir is not None) else Path(row["stored_path"])
+    if path is None or not path.is_file():
        return None
    entry = row["thumb_entry"]
    if row["kind"] == "gcode":
@@ -0,0 +1,52 @@
+"""Zentraler Logger für Dienst und journald (stdout)."""
+
+from __future__ import annotations
+
+import logging
+import sys
+
+_CONFIGURED = False
+
+LEVELS = {
+    "critical": logging.CRITICAL,
+    "error": logging.ERROR,
+    "warning": logging.WARNING,
+    "warn": logging.WARNING,
+    "info": logging.INFO,
+    "debug": logging.DEBUG,
+}
+
+
+def parse_level(value, default=logging.INFO):
+    if isinstance(value, int):
+        return value
+    text = str(value or "").strip().lower()
+    return LEVELS.get(text, default)
+
+
+def setup(level="INFO"):
+    """Root-Logger einmalig auf stdout (systemd → journald)."""
+    global _CONFIGURED
+    resolved = parse_level(level)
+    root = logging.getLogger()
+    if _CONFIGURED:
+        root.setLevel(resolved)
+        return root
+    root.handlers.clear()
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(
+        logging.Formatter(
+            "%(asctime)s %(levelname)s [%(name)s] %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+    )
+    root.addHandler(handler)
+    root.setLevel(resolved)
+    logging.getLogger("waitress").setLevel(logging.WARNING)
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+    _CONFIGURED = True
+    return root
+
+
+def get(name="grotti"):
+    return logging.getLogger(name)
@@ -0,0 +1,156 @@
+"""Wartungs-Teile und Laufzähler aus dem Protokoll."""
+
+from __future__ import annotations
+
+def _baseline(conn, host, part_key):
+    row = conn.execute(
+        """
+        SELECT hours_at, meters_at FROM maintenance_log
+        WHERE printer_host = %s AND part_key = %s AND event IN ('install', 'reset')
+        ORDER BY created_at DESC, id DESC
+        LIMIT 1
+        """,
+        (host, part_key),
+    ).fetchone()
+    if not row:
+        return 0.0, 0.0
+    return float(row.get("hours_at") or 0), float(row.get("meters_at") or 0)
+
+
+def counters_for_host(conn, host):
+    """Summe Druckzeit, Filament und Anzahl Läufe für einen Host."""
+    host = (host or "").strip()
+    if not host:
+        return {"hours": 0.0, "meters": 0.0, "runs": 0}
+    row = conn.execute(
+        """
+        SELECT
+            COALESCE(SUM(duration_s), 0) AS duration_s,
+            COALESCE(SUM(filament_used_mm), 0) AS meters,
+            COUNT(*) AS runs
+        FROM runs
+        WHERE printer_host = %s AND state = 'completed'
+        """,
+        (host,),
+    ).fetchone()
+    if not row:
+        return {"hours": 0.0, "meters": 0.0, "runs": 0}
+    return {
+        "hours": float(row.get("duration_s") or 0) / 3600.0,
+        "meters": float(row.get("meters") or 0),
+        "runs": int(row.get("runs") or 0),
+    }
+
+
+def part_out(row, counters=None, conn=None):
+    counters = counters or {}
+    life_h = float(row.get("life_hours") or 0)
+    life_m = float(row.get("life_meters") or 0)
+    hours_total = float(counters.get("hours") or 0)
+    meters_total = float(counters.get("meters") or 0)
+    host = row["printer_host"]
+    part_key = row["part_key"]
+    base_h, base_m = (0.0, 0.0)
+    if conn is not None:
+        base_h, base_m = _baseline(conn, host, part_key)
+    hours_since = max(0.0, hours_total - base_h)
+    meters_since = max(0.0, meters_total - base_m)
+    installed = row.get("installed_at")
+    return {
+        "id": row["id"],
+        "printer_host": host,
+        "part_key": part_key,
+        "label": row.get("label") or "",
+        "installed_at": installed.isoformat() if hasattr(installed, "isoformat") else str(installed or ""),
+        "life_hours": life_h,
+        "life_meters": life_m,
+        "note": row.get("note") or "",
+        "hours_since": hours_since,
+        "meters_since": meters_since,
+        "overdue_hours": life_h > 0 and hours_since >= life_h,
+        "overdue_meters": life_m > 0 and meters_since >= life_m,
+    }
+
+
+def list_for_api(conn, printers):
+    out = []
+    for printer in printers or []:
+        host = printer.get("host") or ""
+        counters = counters_for_host(conn, host)
+        rows = conn.execute(
+            "SELECT * FROM maintenance_parts WHERE printer_host = %s ORDER BY label, part_key, id",
+            (host,),
+        ).fetchall()
+        out.append({
+            "host": host,
+            "name": printer.get("name") or host,
+            "counters": counters,
+            "parts": [part_out(r, counters, conn=conn) for r in rows],
+        })
+    return out
+
+
+def create_part(conn, printer_host, part_key, label="", life_hours=0, life_meters=0, note=""):
+    printer_host = (printer_host or "").strip()
+    part_key = (part_key or "").strip()
+    if not printer_host or not part_key:
+        raise ValueError("Drucker und part_key nötig.")
+    row = conn.execute(
+        """
+        INSERT INTO maintenance_parts (printer_host, part_key, label, life_hours, life_meters, note)
+        VALUES (%s, %s, %s, %s, %s, %s)
+        RETURNING *
+        """,
+        (
+            printer_host,
+            part_key,
+            (label or part_key).strip(),
+            float(life_hours or 0),
+            float(life_meters or 0),
+            (note or "").strip(),
+        ),
+    ).fetchone()
+    counters = counters_for_host(conn, printer_host)
+    conn.execute(
+        """
+        INSERT INTO maintenance_log (printer_host, part_key, event, hours_at, meters_at, note)
+        VALUES (%s, %s, 'install', %s, %s, %s)
+        """,
+        (printer_host, part_key, counters["hours"], counters["meters"], (note or "").strip()),
+    )
+    return part_out(row, counters, conn=conn)
+
+
+def reset_part(conn, part_id):
+    row = conn.execute(
+        "SELECT * FROM maintenance_parts WHERE id = %s",
+        (int(part_id),),
+    ).fetchone()
+    if not row:
+        return None
+    host = row["printer_host"]
+    counters = counters_for_host(conn, host)
+    conn.execute(
+        """
+        INSERT INTO maintenance_log (printer_host, part_key, event, hours_at, meters_at, note)
+        VALUES (%s, %s, 'reset', %s, %s, %s)
+        """,
+        (
+            host,
+            row["part_key"],
+            counters["hours"],
+            counters["meters"],
+            row.get("note") or "",
+        ),
+    )
+    updated = conn.execute(
+        """
+        UPDATE maintenance_parts
+        SET installed_at = now()
+        WHERE id = %s
+        RETURNING *
+        """,
+        (int(part_id),),
+    ).fetchone()
+    fresh_counters = counters_for_host(conn, host)
+    return part_out(updated, fresh_counters, conn=conn)
@@ -57,6 +57,51 @@ def _write_guard():
        raise RuntimeError("MCP läuft im Read-only-Modus (GROTTI_MCP_READ_ONLY).")


+# Wird beim Connect an den Client gegeben (Claude, Cursor, …).
+INSTRUCTIONS = """\
+Grotti steuert eine 3D-Drucker-Farm (Anycubic Kobra, Klipper/Moonraker).
+Antworte dem Nutzer auf Deutsch. Handle nur über diese Tools.
+
+Identität
+- Drucker über das Feld host (IP). Den Namen nur zur Anzeige nutzen. Hosts nie raten: erst list_printers oder get_printer.
+- Dateien über die numerische id aus list_files (Feld id), nicht über den Dateinamen allein.
+- Vor jedem Schreibzugriff den aktuellen Stand lesen.
+
+Lesen
+- Farm: list_printers (live=true). Ein Drucker: get_printer(host).
+- Läuft: list_running. Warteschlange: list_queue. Ereignisse: list_events.
+- Bibliothek: list_files. Spulen: list_spools. Filament-Fehlmenge: bedarf_lesen.
+- Kundenaufträge: auftraege_lesen. Verschleißteile: wartung_lesen.
+
+Zustand (Feld state)
+- printing: druckt. paused: Pause. standby: frei. complete: fertig, Platte oft noch belegt.
+- error: Fehler, nicht einfach neu starten. offline: nicht erreichbar.
+- progress ist 0…1. filament_empty oder pause_reason bei Pause heißt Filament leer.
+  Dann dem Nutzer sagen, die neue Spule in Grotti dem Drucker zuzuweisen, und erst danach resume_printer.
+  Eine Filament-Pause nicht blind fortsetzen.
+
+Schreiben
+confirm=true nur setzen, wenn der Nutzer diese Aktion in diesem Zug klar will. Nicht vorauseilend bestätigen.
+- enqueue_when_free: Datei in die Warteschlange. host leer = Grotti wählt den nächsten Drucker mit passender Sorte. host gesetzt = dieser Drucker, sobald er frei ist und die Platte klar ist. Das ist der normale Weg.
+- enqueue_print: sofort senden und starten. Nur wenn der Nutzer einen Sofortstart auf einem genannten freien Drucker will (state standby, Platte frei). Große Dateien brauchen oft etwa eine Minute bis zum Start.
+- Den Material-Match macht Grotti (PLA Meta ist nicht Matte und nicht Silk). Eine falsche Maschine nicht erzwingen. Eine Ablehnung wörtlich weitergeben.
+- bed_leveling=true nur auf ausdrücklichen Wunsch (Bettnetz / Auto-Level).
+- pause_printer und resume_printer während des Drucks, ohne confirm.
+- cancel_printer bricht den Druck ab und braucht confirm=true. Bei Unklarheit erst nachfragen.
+- clear_bed ist nur die Quittung „Platte ist leer“ und schiebt nichts physisch. Erst aufrufen, wenn der Nutzer sagt, das Teil ist herunter. Ohne diese Quittung startet der nächste „wenn frei“-Job nicht.
+- steer_temp (Düse und Bett in °C), steer_speed (Prozent), steer_fan (0–100): nur diese Werte. Kein freier G-code.
+
+Grenzen
+- Keine G-code-Konsole, kein Firmware-Restart, kein E-Stop, keine Benutzer- oder Token-Verwaltung. Diese Lücken nicht umgehen.
+- Im Read-only-Modus (GROTTI_MCP_READ_ONLY) schlagen Schreib-Tools fehl. Das sagen und nicht wiederholen.
+- Gesperrte Drucker und ausgeschaltete Automatik starten keine Warteschlangen-Jobs. Den Fehler nennen.
+
+Antworten
+- Kurz und konkret: Druckername, host, Datei, Zustand, was du getan hast.
+- Den Fehlertext von Grotti zitieren. Keinen Workaround außerhalb der Tools erfinden.
+"""
+
+
 def main():
    try:
        from mcp.server.fastmcp import FastMCP
@@ -67,23 +112,17 @@ def main():
        )
        sys.exit(1)

-    server = FastMCP(
-        "grotti",
-        instructions=(
-            "Grotti steuert die 3D-Drucker-Farm. Destruktive Aktionen brauchen "
-            "confirm=true. Kein freier G-code, kein Firmware-Restart."
-        ),
-    )
+    server = FastMCP("grotti", instructions=INSTRUCTIONS)

    @server.tool()
    def list_printers(live: bool = True) -> str:
-        """Druckerliste mit optionalem Live-Zustand."""
+        """Alle Drucker. live=true liefert Zustand, Temps, Fortschritt, Dateiname. Host ist die IP."""
        q = "?live=1" if live else "?live=0"
        return json.dumps(_api("GET", "/drucker" + q), ensure_ascii=False, indent=2)

    @server.tool()
    def get_printer(host: str) -> str:
-        """Einen Drucker anhand Host/IP aus der Live-Liste."""
+        """Einen Drucker anhand host (IP) aus der Live-Liste. Host vorher über list_printers holen."""
        rows = _api("GET", "/drucker?live=1") or []
        for row in rows:
            if row.get("host") == host:
@@ -115,7 +154,7 @@ def main():

    @server.tool()
    def list_files(limit: int = 50) -> str:
-        """Dateien in der Bibliothek."""
+        """Dateien in der Bibliothek. Die numerische id ist die file_id fürs Einreihen und Starten."""
        rows = _api("GET", "/dateien") or []
        return json.dumps(rows[: max(1, min(limit, 200))], ensure_ascii=False, indent=2)

@@ -124,6 +163,27 @@ def main():
        """Spulen / Materialbestand."""
        return json.dumps(_api("GET", "/spulen"), ensure_ascii=False, indent=2)

+    @server.tool()
+    def auftraege_lesen(limit: int = 30, status: str = "") -> str:
+        """Aufträge (optional nach Status filtern)."""
+        st = (status or "").strip().lower()
+        q = "?status=" + urllib.parse.quote(st) if st else ""
+        rows = _api("GET", "/auftraege" + q) or []
+        cap = max(1, min(limit, 200))
+        if len(rows) > cap:
+            rows = rows[:cap]
+        return json.dumps(rows, ensure_ascii=False, indent=2)
+
+    @server.tool()
+    def bedarf_lesen() -> str:
+        """Filament-Bedarf (Queue vs. Spulenrest)."""
+        return json.dumps(_api("GET", "/bedarf"), ensure_ascii=False, indent=2)
+
+    @server.tool()
+    def wartung_lesen() -> str:
+        """Wartungsteile und Zählerstände."""
+        return json.dumps(_api("GET", "/wartung"), ensure_ascii=False, indent=2)
+
    @server.tool()
    def get_version() -> str:
        """Grotti-Version."""
@@ -160,7 +220,7 @@ def main():

    @server.tool()
    def clear_bed(host: str, confirm: bool = False) -> str:
-        """Platte als geräumt quittieren (kein physisches Schieben)."""
+        """Quittung, dass der Nutzer die Platte geleert hat. Schiebt nichts. confirm muss true sein. Danach kann die Warteschlange den nächsten Job starten."""
        _write_guard()
        if not confirm:
            raise RuntimeError("Quittierung braucht confirm=true.")
@@ -180,7 +240,7 @@ def main():
        confirm: bool = False,
        bed_leveling: bool = False,
    ) -> str:
-        """Datei in die Warteschlange („wenn frei“). confirm muss true sein."""
+        """Datei in die Warteschlange. host leer: Grotti wählt den nächsten Drucker mit passender Sorte. host gesetzt: dieser Drucker, sobald frei und Platte klar. confirm muss true sein. Normaler Weg zum Drucken."""
        _write_guard()
        if not confirm:
            raise RuntimeError("Einreihen braucht confirm=true.")
@@ -199,7 +259,7 @@ def main():
        confirm: bool = False,
        bed_leveling: bool = False,
    ) -> str:
-        """Sofort senden und starten. confirm muss true sein."""
+        """Sofort an diesen host senden und starten. Nur bei freiem Drucker (standby, Platte frei) und klarem Sofortstart-Wunsch. confirm muss true sein."""
        _write_guard()
        if not confirm:
            raise RuntimeError("Start braucht confirm=true.")
@@ -220,11 +280,11 @@ def main():
        out = []
        if nozzle is not None:
            out.append(_api("POST", "/drucker/%s/steuern" % urllib.parse.quote(host), {
-                "action": "nozzle", "value": nozzle,
+                "action": "nozzle", "temp": nozzle,
            }))
        if bed is not None:
            out.append(_api("POST", "/drucker/%s/steuern" % urllib.parse.quote(host), {
-                "action": "bed", "value": bed,
+                "action": "bed", "temp": bed,
            }))
        if not out:
            raise RuntimeError("nozzle und/oder bed angeben.")
@@ -236,7 +296,7 @@ def main():
        _write_guard()
        return json.dumps(
            _api("POST", "/drucker/%s/steuern" % urllib.parse.quote(host), {
-                "action": "speed", "value": speed,
+                "action": "speed", "percent": speed,
            }),
            ensure_ascii=False,
        )
@@ -247,7 +307,7 @@ def main():
        _write_guard()
        return json.dumps(
            _api("POST", "/drucker/%s/steuern" % urllib.parse.quote(host), {
-                "action": "fan", "value": fan,
+                "action": "fan", "percent": fan,
            }),
            ensure_ascii=False,
        )
@@ -0,0 +1,305 @@
+CREATE TABLE IF NOT EXISTS projects (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    name text NOT NULL,
+    notes text NOT NULL DEFAULT '',
+    status text NOT NULL DEFAULT 'idee',
+    quote jsonb NOT NULL DEFAULT '{}'::jsonb,
+    created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS spools (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    name text NOT NULL,
+    brand text NOT NULL DEFAULT '',
+    material_type text NOT NULL DEFAULT '',
+    color text NOT NULL DEFAULT '',
+    price_per_kg double precision NOT NULL DEFAULT 0,
+    density double precision NOT NULL DEFAULT 1.24,
+    volumetric double precision NOT NULL DEFAULT 12,
+    remaining_g double precision NOT NULL DEFAULT 1000,
+    printer_host text NOT NULL DEFAULT '',
+    created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS files (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    project_id bigint REFERENCES projects (id) ON DELETE SET NULL,
+    spool_id bigint REFERENCES spools (id) ON DELETE SET NULL,
+    name text NOT NULL,
+    stored_path text NOT NULL,
+    source text NOT NULL,
+    kind text NOT NULL,
+    printer_family text NOT NULL DEFAULT '',
+    filaments jsonb NOT NULL DEFAULT '[]'::jsonb,
+    weight_g double precision NOT NULL DEFAULT 0,
+    estimated_s double precision NOT NULL DEFAULT 0,
+    thumb_entry text NOT NULL DEFAULT '',
+    plate text NOT NULL DEFAULT '',
+    size_bytes bigint NOT NULL DEFAULT 0,
+    mtime double precision NOT NULL DEFAULT 0,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    UNIQUE (source, stored_path)
+);
+
+ALTER TABLE files ADD COLUMN IF NOT EXISTS slice_meta jsonb NOT NULL DEFAULT '{}'::jsonb;
+
+CREATE TABLE IF NOT EXISTS sends (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    printer_host text NOT NULL,
+    filename text NOT NULL,
+    file_id bigint REFERENCES files (id) ON DELETE SET NULL,
+    project_id bigint REFERENCES projects (id) ON DELETE SET NULL,
+    spool_id bigint REFERENCES spools (id) ON DELETE SET NULL,
+    created_at timestamptz NOT NULL DEFAULT now()
+);
+
+ALTER TABLE sends ADD COLUMN IF NOT EXISTS ace_map jsonb NOT NULL DEFAULT '[]'::jsonb;
+ALTER TABLE sends ADD COLUMN IF NOT EXISTS bed_leveling boolean NOT NULL DEFAULT false;
+
+CREATE TABLE IF NOT EXISTS runs (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    printer_host text NOT NULL,
+    printer_name text NOT NULL DEFAULT '',
+    filename text NOT NULL DEFAULT '',
+    file_id bigint REFERENCES files (id) ON DELETE SET NULL,
+    project_id bigint REFERENCES projects (id) ON DELETE SET NULL,
+    spool_id bigint REFERENCES spools (id) ON DELETE SET NULL,
+    state text NOT NULL DEFAULT '',
+    started_at timestamptz,
+    ended_at timestamptz,
+    duration_s double precision NOT NULL DEFAULT 0,
+    weight_g double precision NOT NULL DEFAULT 0,
+    filament_cost double precision NOT NULL DEFAULT 0,
+    energy_cost double precision NOT NULL DEFAULT 0,
+    moonraker_job_id text NOT NULL,
+    deducted boolean NOT NULL DEFAULT false,
+    needs_spool boolean NOT NULL DEFAULT false,
+    verdict text NOT NULL DEFAULT '',
+    material_type text NOT NULL DEFAULT '',
+    UNIQUE (printer_host, moonraker_job_id)
+);
+
+CREATE INDEX IF NOT EXISTS files_project ON files (project_id);
+
+CREATE INDEX IF NOT EXISTS runs_started ON runs (started_at DESC);
+
+CREATE TABLE IF NOT EXISTS printers (
+    id uuid PRIMARY KEY,
+    name text NOT NULL,
+    host text NOT NULL UNIQUE,
+    family text NOT NULL DEFAULT '',
+    created_at timestamptz NOT NULL DEFAULT now()
+);
+
+ALTER TABLE printers ADD COLUMN IF NOT EXISTS locked boolean NOT NULL DEFAULT false;
+
+CREATE TABLE IF NOT EXISTS ideas (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    title text NOT NULL,
+    body text NOT NULL DEFAULT '',
+    status text NOT NULL DEFAULT 'offen',
+    created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS materials (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    name text NOT NULL UNIQUE,
+    brand text NOT NULL DEFAULT '',
+    material_type text NOT NULL DEFAULT '',
+    density double precision NOT NULL,
+    volumetric double precision NOT NULL,
+    volumetric_s1 double precision,
+    machines text NOT NULL DEFAULT 'beide',
+    price_per_kg double precision NOT NULL DEFAULT 0,
+    note text NOT NULL DEFAULT ''
+);
+
+ALTER TABLE spools ADD COLUMN IF NOT EXISTS colors jsonb NOT NULL DEFAULT '[]'::jsonb;
+ALTER TABLE spools ADD COLUMN IF NOT EXISTS ace_slot smallint;
+ALTER TABLE spools ADD COLUMN IF NOT EXISTS material_id bigint REFERENCES materials (id) ON DELETE SET NULL;
+ALTER TABLE spools ADD COLUMN IF NOT EXISTS chargen_nr text;
+ALTER TABLE spools ADD COLUMN IF NOT EXISTS hersteller_charge text NOT NULL DEFAULT '';
+ALTER TABLE spools ADD COLUMN IF NOT EXISTS code text;
+
+CREATE UNIQUE INDEX IF NOT EXISTS spools_chargen_nr ON spools (chargen_nr) WHERE chargen_nr IS NOT NULL AND chargen_nr <> '';
+CREATE UNIQUE INDEX IF NOT EXISTS spools_code ON spools (code) WHERE code IS NOT NULL AND code <> '';
+-- Ein ACE-Platz gehört höchstens einer Spule.
+CREATE UNIQUE INDEX IF NOT EXISTS spools_host_slot
+    ON spools (printer_host, ace_slot)
+    WHERE printer_host <> '' AND ace_slot IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS events (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    host text NOT NULL DEFAULT '',
+    printer text NOT NULL DEFAULT '',
+    kind text NOT NULL,
+    message text NOT NULL DEFAULT '',
+    filename text NOT NULL DEFAULT '',
+    created_at timestamptz NOT NULL DEFAULT now(),
+    read_at timestamptz
+);
+
+CREATE INDEX IF NOT EXISTS events_unread ON events (read_at, created_at DESC);
+
+CREATE TABLE IF NOT EXISTS print_queue (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    file_id bigint NOT NULL REFERENCES files (id) ON DELETE CASCADE,
+    host text NOT NULL DEFAULT '',
+    family text NOT NULL DEFAULT '',
+    priority integer NOT NULL DEFAULT 100,
+    status text NOT NULL DEFAULT 'waiting',
+    spool_id bigint REFERENCES spools (id) ON DELETE SET NULL,
+    ace_map jsonb NOT NULL DEFAULT '[]'::jsonb,
+    bed_leveling boolean NOT NULL DEFAULT false,
+    override_machine boolean NOT NULL DEFAULT false,
+    message text NOT NULL DEFAULT '',
+    steps jsonb NOT NULL DEFAULT '[]'::jsonb,
+    step_index integer NOT NULL DEFAULT 0,
+    repeat_total integer NOT NULL DEFAULT 1,
+    repeat_done integer NOT NULL DEFAULT 0,
+    phase text NOT NULL DEFAULT '',
+    phase_started_at timestamptz,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS steps jsonb NOT NULL DEFAULT '[]'::jsonb;
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS step_index integer NOT NULL DEFAULT 0;
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS repeat_total integer NOT NULL DEFAULT 1;
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS repeat_done integer NOT NULL DEFAULT 0;
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS phase text NOT NULL DEFAULT '';
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS phase_started_at timestamptz;
+
+CREATE INDEX IF NOT EXISTS print_queue_waiting ON print_queue (status, priority, id);
+CREATE INDEX IF NOT EXISTS print_queue_running_host ON print_queue (host, status) WHERE status = 'running';
+
+-- Nach dem Druck: Platte manuell quittieren, bevor „wenn frei“ den nächsten Job startet.
+CREATE TABLE IF NOT EXISTS bed_status (
+    host text PRIMARY KEY,
+    needs_clear boolean NOT NULL DEFAULT false,
+    cleared_at timestamptz,
+    message text NOT NULL DEFAULT ''
+);
+
+CREATE TABLE IF NOT EXISTS users (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    username text NOT NULL UNIQUE,
+    password_hash text NOT NULL,
+    role text NOT NULL DEFAULT 'operator',
+    active boolean NOT NULL DEFAULT true,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    last_login timestamptz
+);
+
+CREATE TABLE IF NOT EXISTS api_tokens (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    user_id bigint NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+    name text NOT NULL DEFAULT '',
+    token_hash text NOT NULL UNIQUE,
+    token_prefix text NOT NULL DEFAULT '',
+    role text NOT NULL DEFAULT 'operator',
+    created_at timestamptz NOT NULL DEFAULT now(),
+    last_used timestamptz,
+    revoked_at timestamptz,
+    expires_at timestamptz
+);
+
+CREATE INDEX IF NOT EXISTS api_tokens_user ON api_tokens (user_id) WHERE revoked_at IS NULL;
+
+-- OIDC später: Identitäten an lokale User binden.
+CREATE TABLE IF NOT EXISTS oauth_identities (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    user_id bigint NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+    provider text NOT NULL,
+    subject text NOT NULL,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    UNIQUE (provider, subject)
+);
+
+-- Druckbericht: Soll/Ist, Charge, Live-Fortschritt
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS weight_planned_g double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS weight_used_g double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS weight_source text NOT NULL DEFAULT '';
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS filament_used_mm double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS filament_total_mm double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS progress_last double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS estimated_s double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS chargen_nr text;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS message text NOT NULL DEFAULT '';
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS objects jsonb NOT NULL DEFAULT '[]'::jsonb;
+
+CREATE UNIQUE INDEX IF NOT EXISTS runs_chargen_nr
+    ON runs (chargen_nr) WHERE chargen_nr IS NOT NULL AND chargen_nr <> '';
+
+ALTER TABLE events ADD COLUMN IF NOT EXISTS run_id bigint REFERENCES runs (id) ON DELETE SET NULL;
+CREATE INDEX IF NOT EXISTS events_run ON events (run_id) WHERE run_id IS NOT NULL;
+
+-- Abzug je Spule (Messwert oder Schätzwert)
+CREATE TABLE IF NOT EXISTS run_spools (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    run_id bigint NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    spool_id bigint NOT NULL REFERENCES spools (id) ON DELETE RESTRICT,
+    ace_slot smallint,
+    weight_g double precision NOT NULL DEFAULT 0,
+    weight_planned_g double precision NOT NULL DEFAULT 0,
+    cost double precision NOT NULL DEFAULT 0,
+    is_estimate boolean NOT NULL DEFAULT false,
+    UNIQUE (run_id, spool_id, ace_slot)
+);
+
+CREATE INDEX IF NOT EXISTS run_spools_spool ON run_spools (spool_id);
+CREATE INDEX IF NOT EXISTS run_spools_run ON run_spools (run_id);
+
+-- Abschnitte bei Rollenwechsel mitten im Druck
+CREATE TABLE IF NOT EXISTS run_segments (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    run_id bigint NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    spool_id bigint NOT NULL REFERENCES spools (id) ON DELETE RESTRICT,
+    ace_slot smallint,
+    mm_start double precision NOT NULL DEFAULT 0,
+    mm_end double precision,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    closed_at timestamptz
+);
+
+CREATE INDEX IF NOT EXISTS run_segments_run ON run_segments (run_id);
+CREATE INDEX IF NOT EXISTS run_segments_open
+    ON run_segments (run_id) WHERE mm_end IS NULL;
+
+-- Temperatur / Fortschritt während des Drucks
+CREATE TABLE IF NOT EXISTS run_samples (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    run_id bigint NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    sampled_at timestamptz NOT NULL DEFAULT now(),
+    nozzle double precision,
+    nozzle_target double precision,
+    bed double precision,
+    bed_target double precision,
+    chamber double precision,
+    fan double precision,
+    speed_factor double precision,
+    extrude_factor double precision,
+    layer integer,
+    progress double precision,
+    filament_used_mm double precision,
+    mmu_tool smallint,
+    nozzle_power double precision,
+    bed_power double precision
+);
+
+CREATE INDEX IF NOT EXISTS run_samples_run_time ON run_samples (run_id, sampled_at);
+
+ALTER TABLE run_samples ADD COLUMN IF NOT EXISTS nozzle_power double precision;
+ALTER TABLE run_samples ADD COLUMN IF NOT EXISTS bed_power double precision;
+
+-- Objekt-Chargen für Etiketten
+CREATE TABLE IF NOT EXISTS run_labels (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    run_id bigint NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    object_name text NOT NULL DEFAULT '',
+    chargen_nr text NOT NULL,
+    excluded boolean NOT NULL DEFAULT false,
+    UNIQUE (run_id, object_name)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS run_labels_chargen ON run_labels (chargen_nr);
@@ -0,0 +1,6 @@
+-- Heiße Abfragepfade für Sends, Läufe, Dateien und Ereignisse.
+CREATE INDEX IF NOT EXISTS sends_host_filename ON sends (printer_host, filename);
+CREATE INDEX IF NOT EXISTS sends_host_file ON sends (printer_host, file_id);
+CREATE INDEX IF NOT EXISTS runs_host_state ON runs (printer_host, state);
+CREATE INDEX IF NOT EXISTS files_name ON files (name);
+CREATE INDEX IF NOT EXISTS events_host_kind_created ON events (host, kind, created_at DESC);
@@ -0,0 +1,3 @@
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS verdict_reason text NOT NULL DEFAULT '';
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS pieces_ok int NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS pieces_bad int NOT NULL DEFAULT 0;
@@ -0,0 +1,25 @@
+CREATE TABLE IF NOT EXISTS maintenance_parts (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    printer_host text NOT NULL,
+    part_key text NOT NULL,
+    label text NOT NULL DEFAULT '',
+    installed_at timestamptz NOT NULL DEFAULT now(),
+    life_hours double precision NOT NULL DEFAULT 0,
+    life_meters double precision NOT NULL DEFAULT 0,
+    note text NOT NULL DEFAULT ''
+);
+
+CREATE INDEX IF NOT EXISTS maintenance_parts_host ON maintenance_parts (printer_host);
+
+CREATE TABLE IF NOT EXISTS maintenance_log (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    printer_host text NOT NULL,
+    part_key text NOT NULL,
+    event text NOT NULL DEFAULT '',
+    hours_at double precision NOT NULL DEFAULT 0,
+    meters_at double precision NOT NULL DEFAULT 0,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    note text NOT NULL DEFAULT ''
+);
+
+CREATE INDEX IF NOT EXISTS maintenance_log_host ON maintenance_log (printer_host, created_at DESC);
@@ -0,0 +1 @@
+ALTER TABLE printers ADD COLUMN IF NOT EXISTS start_window jsonb NOT NULL DEFAULT '{}'::jsonb;
@@ -0,0 +1,63 @@
+CREATE TABLE IF NOT EXISTS customers (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    name text NOT NULL,
+    email text NOT NULL DEFAULT '',
+    notes text NOT NULL DEFAULT '',
+    created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS orders (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    customer_id bigint REFERENCES customers (id) ON DELETE SET NULL,
+    title text NOT NULL,
+    status text NOT NULL DEFAULT 'idee',
+    due_at date,
+    notes text NOT NULL DEFAULT '',
+    quote jsonb NOT NULL DEFAULT '{}'::jsonb,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS order_items (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    order_id bigint NOT NULL REFERENCES orders (id) ON DELETE CASCADE,
+    file_id bigint REFERENCES files (id) ON DELETE SET NULL,
+    qty int NOT NULL DEFAULT 1,
+    unit_price double precision NOT NULL DEFAULT 0,
+    material_type text NOT NULL DEFAULT '',
+    color text NOT NULL DEFAULT '',
+    done_ok int NOT NULL DEFAULT 0,
+    done_bad int NOT NULL DEFAULT 0,
+    note text NOT NULL DEFAULT ''
+);
+
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS order_item_id bigint REFERENCES order_items (id) ON DELETE SET NULL;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS order_item_id bigint REFERENCES order_items (id) ON DELETE SET NULL;
+
+INSERT INTO orders (title, status, notes, quote, created_at)
+SELECT
+    p.name,
+    CASE p.status
+        WHEN 'bereit' THEN 'angebot'
+        WHEN 'druckt' THEN 'druckt'
+        WHEN 'fertig' THEN 'fertig'
+        ELSE 'idee'
+    END,
+    p.notes,
+    p.quote,
+    p.created_at
+FROM projects p
+WHERE NOT EXISTS (SELECT 1 FROM orders o WHERE o.title = p.name AND o.created_at = p.created_at);
+
+INSERT INTO orders (title, status, notes, created_at)
+SELECT
+    i.title,
+    CASE i.status WHEN 'erledigt' THEN 'fertig' ELSE 'idee' END,
+    i.body,
+    i.created_at
+FROM ideas i
+WHERE NOT EXISTS (SELECT 1 FROM orders o WHERE o.title = i.title AND o.created_at = i.created_at);
+
+CREATE INDEX IF NOT EXISTS orders_status ON orders (status, updated_at DESC);
+CREATE INDEX IF NOT EXISTS order_items_order ON order_items (order_id);
+CREATE INDEX IF NOT EXISTS runs_order_item ON runs (order_item_id) WHERE order_item_id IS NOT NULL;
@@ -0,0 +1,3 @@
+-- Auto-Retry und Routing-Hinweise in der Warteschlange.
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS retry_count integer NOT NULL DEFAULT 0;
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS wait_reason text NOT NULL DEFAULT '';
@@ -0,0 +1,8 @@
+-- PA12-CF bleibt in Grotti die echte Sorte. Der ACE kennt nur PA6-CF.
+UPDATE materials
+SET material_type = 'PA12-CF'
+WHERE name = 'Sunlu PA12-CF' AND material_type = 'PA';
+
+UPDATE spools
+SET material_type = 'PA12-CF'
+WHERE name = 'Sunlu PA12-CF' AND material_type = 'PA';
@@ -0,0 +1,2 @@
+-- Leere/alte Spulen aus der Alltagsliste nehmen
+ALTER TABLE spools ADD COLUMN IF NOT EXISTS archived_at timestamptz;
@@ -0,0 +1,2 @@
+-- Projekt-Arbeitsmappe: Relativordner unter dem Slice-Pfad
+ALTER TABLE projects ADD COLUMN IF NOT EXISTS folder text NOT NULL DEFAULT '';
@@ -0,0 +1,16 @@
+-- Jede Moonraker-Job-ID bleibt einem Lauf zugeordnet, auch nach dem Zusammenlegen.
+CREATE TABLE IF NOT EXISTS run_jobs (
+    printer_host text NOT NULL,
+    job_id text NOT NULL,
+    run_id bigint NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    PRIMARY KEY (printer_host, job_id)
+);
+
+CREATE INDEX IF NOT EXISTS run_jobs_run ON run_jobs (run_id);
+
+INSERT INTO run_jobs (printer_host, job_id, run_id)
+SELECT printer_host, moonraker_job_id, id
+FROM runs
+WHERE moonraker_job_id <> ''
+  AND moonraker_job_id NOT LIKE 'live:%'
+ON CONFLICT DO NOTHING;
@@ -0,0 +1,6 @@
+-- Last active run per printer (survives Grotti restart during pause)
+ALTER TABLE printers
+    ADD COLUMN IF NOT EXISTS active_run_id bigint REFERENCES runs (id) ON DELETE SET NULL;
+
+CREATE INDEX IF NOT EXISTS printers_active_run ON printers (active_run_id)
+    WHERE active_run_id IS NOT NULL;
@@ -0,0 +1,10 @@
+-- Queue item points at the run it started. At most one running job per host.
+ALTER TABLE print_queue
+    ADD COLUMN IF NOT EXISTS run_id bigint REFERENCES runs (id) ON DELETE SET NULL;
+
+CREATE INDEX IF NOT EXISTS print_queue_run ON print_queue (run_id)
+    WHERE run_id IS NOT NULL;
+
+CREATE UNIQUE INDEX IF NOT EXISTS print_queue_one_running_per_host
+    ON print_queue (host)
+    WHERE status = 'running' AND host <> '';
@@ -8,8 +8,11 @@ import urllib.parse
 import urllib.request
 from concurrent.futures import ThreadPoolExecutor

+from grotti import logutil
 from grotti.parse import embedded_png

+log = logutil.get("grotti.moonraker")
+
 META_CACHE = {}
 CAMERA_CACHE = {}
 EMBEDDED = {}
@@ -17,6 +20,16 @@ SLOT_CACHE = {}
 MESH_CACHE = {}
 OBJECT_CACHE = {}
 THUMB_RE_LIMIT = 180_000
+_CACHE_MAX = 128
+
+
+def _trim_cache(cache, max_items=_CACHE_MAX):
+    """Einfache Größenbegrenzung (älteste Keys zuerst bei dict-Reihenfolge)."""
+    while len(cache) > max_items:
+        try:
+            cache.pop(next(iter(cache)))
+        except StopIteration:
+            break


 def matrix_rows(points):
@@ -50,31 +63,6 @@ def _raw_matrix(points):
    return []


-def fetch_bed_mesh(host):
-    """Roh-Bettnetz von Moonraker (ohne UI-Spiegelung)."""
-    url = "http://%s/printer/objects/query?bed_mesh" % host
-    payload = fetch_json(url, timeout=10)
-    status = (payload.get("result") or {}).get("status") or {}
-    mesh = status.get("bed_mesh") or {}
-    matrix = _raw_matrix(mesh.get("probed_matrix"))
-    if not matrix:
-        matrix = _raw_matrix(mesh.get("mesh_matrix"))
-    mesh_min = mesh.get("mesh_min")
-    mesh_max = mesh.get("mesh_max")
-    if not (isinstance(mesh_min, (list, tuple)) and len(mesh_min) >= 2):
-        mesh_min = None
-    if not (isinstance(mesh_max, (list, tuple)) and len(mesh_max) >= 2):
-        mesh_max = None
-    if not matrix or mesh_min is None or mesh_max is None:
-        return None
-    return {
-        "matrix": matrix,
-        "mesh_min": [float(mesh_min[0]), float(mesh_min[1])],
-        "mesh_max": [float(mesh_max[0]), float(mesh_max[1])],
-        "profile": mesh.get("profile_name") or "",
-    }
-
-
 def store_mesh(host, shown, profile=""):
    if not shown:
        return
@@ -118,11 +106,6 @@ class PrinterError(Exception):
        self.message = message


-def is_timeout(exc):
-    text = (getattr(exc, "message", None) or str(exc) or "").lower()
-    return "zu lange nicht geantwortet" in text or "timed out" in text
-
-
 def fetch_json(url, timeout=4):
    request = urllib.request.Request(url, headers={"Accept": "application/json"})
    with urllib.request.urlopen(request, timeout=timeout) as response:
@@ -165,18 +148,53 @@ def post_json(host, path, payload, timeout=20):
        raise PrinterError("Der Drucker ist nicht erreichbar.") from exc


+def safe_upload_name(filename):
+    """Dateiname für Moonraker/Rinkhals/gklib — nur ASCII.
+
+    `filename` vs. `filename*` mit CJK führte zu Upload unter `_` und Start
+    unter dem Originalnamen → Fehler 10115 „gcode … not found“.
+    """
+    raw = (filename or "").replace("\\", "/")
+    parts = [part for part in raw.split("/") if part]
+    base = parts[-1] if parts else "job.gcode"
+    out = []
+    for ch in base:
+        if ch.isascii() and ch not in '"\\':
+            out.append(ch if ch not in " \t" else "_")
+        else:
+            out.append("_")
+    text = "".join(out)
+    while "__" in text:
+        text = text.replace("__", "_")
+    while "_-" in text or "-_" in text:
+        text = text.replace("_-", "-").replace("-_", "-")
+    text = text.strip("._-") or "job"
+    lower = text.lower()
+    if not (lower.endswith(".gcode") or lower.endswith(".gcode.3mf") or lower.endswith(".3mf") or lower.endswith(".acm")):
+        # Suffix vom Original behalten, falls nur der Stamm zerstört wurde
+        if base.lower().endswith(".gcode.3mf"):
+            text += ".gcode.3mf"
+        elif base.lower().endswith(".gcode"):
+            text += ".gcode"
+        elif base.lower().endswith(".acm"):
+            text += ".acm"
+    if parts:
+        parts[-1] = text
+        return "/".join(parts)
+    return text
+
+
 def multipart(filename, content):
    boundary = "----GrottiBoundary7f3a"
-    ascii_name = "".join(ch if ch.isascii() and ch not in '"\\' else "_" for ch in filename) or "job.gcode"
-    quoted = urllib.parse.quote(filename)
+    name = safe_upload_name(filename)
    fields = (
        "--%s\r\nContent-Disposition: form-data; name=\"root\"\r\n\r\ngcodes\r\n" % boundary
    ).encode("ascii")
    head = (
        "--%s\r\n"
-        "Content-Disposition: form-data; name=\"file\"; filename=\"%s\"; filename*=UTF-8''%s\r\n"
+        "Content-Disposition: form-data; name=\"file\"; filename=\"%s\"\r\n"
        "Content-Type: application/octet-stream\r\n\r\n"
-    ) % (boundary, ascii_name, quoted)
+    ) % (boundary, name)
    tail = ("\r\n--%s--\r\n" % boundary).encode("ascii")
    return boundary, fields + head.encode("ascii") + content + tail

@@ -217,6 +235,7 @@ def upload_timeout(size):


 def upload(host, filename, content, on_progress=None):
+    filename = safe_upload_name(filename)
    boundary, body = multipart(filename, content)
    stream = _UploadBody(body, on_progress=on_progress)
    request = urllib.request.Request(
@@ -236,7 +255,8 @@ def upload(host, filename, content, on_progress=None):
    except (urllib.error.URLError, TimeoutError) as exc:
        raise PrinterError("Hochladen ist fehlgeschlagen.") from exc
    item = (payload.get("result") or {}).get("item") or {}
-    return item.get("path") or filename
+    # Immer denselben ASCII-Namen nutzen, den wir hochgeladen haben
+    return safe_upload_name(item.get("path") or filename)


 def start_print(host, filename, bed_leveling=False, ams_settings=None):
@@ -336,6 +356,11 @@ def steuern(host, action, params=None):
    """Whitelist-Steuerung ohne freie Konsole."""
    params = params if isinstance(params, dict) else {}
    action = (action or "").strip()
+    # MCP und ältere Clients schicken "value" statt temp/percent.
+    if "temp" not in params and params.get("value") is not None and action in ("nozzle", "bed", "dryer_start"):
+        params = {**params, "temp": params["value"]}
+    if "percent" not in params and params.get("value") is not None and action in ("speed", "flow", "fan"):
+        params = {**params, "percent": params["value"]}

    def pct(key, default=100, lo=0, hi=200):
        try:
@@ -381,6 +406,64 @@ def steuern(host, action, params=None):
        if not re.fullmatch(r"[A-Za-z0-9._+\-]+", name):
            raise PrinterError("Ungültiger Objektname.")
        return gcode_script(host, "EXCLUDE_OBJECT NAME=%s" % name, timeout=20)
+    if action == "dryer_start":
+        try:
+            unit = int(params.get("id"))
+        except (TypeError, ValueError) as exc:
+            raise PrinterError("ACE-Box muss 0 oder 1 sein.") from exc
+        if unit not in (0, 1):
+            raise PrinterError("ACE-Box muss 0 oder 1 sein.")
+        try:
+            temp = int(round(float(params.get("temp"))))
+            duration = int(round(float(params.get("duration"))))
+        except (TypeError, ValueError) as exc:
+            raise PrinterError("Temperatur und Dauer müssen Zahlen sein.") from exc
+        if temp < 35 or temp > 65:
+            raise PrinterError("Trockner-Temperatur außerhalb 35–65 °C.")
+        if duration < 1 or duration > 720:
+            raise PrinterError("Trockner-Dauer außerhalb 1–720 Minuten.")
+        return post_json(
+            host,
+            "/server/filament_hub/start_drying",
+            {"id": unit, "temp": temp, "duration": duration, "fan_speed": 0},
+            timeout=15,
+        )
+    if action == "dryer_stop":
+        try:
+            unit = int(params.get("id"))
+        except (TypeError, ValueError) as exc:
+            raise PrinterError("ACE-Box muss 0 oder 1 sein.") from exc
+        if unit not in (0, 1):
+            raise PrinterError("ACE-Box muss 0 oder 1 sein.")
+        return post_json(host, "/server/filament_hub/stop_drying", {"id": unit}, timeout=15)
+    if action == "slot_setzen":
+        hub_id = _int_or_none(params.get("id"))
+        index = _int_or_none(params.get("index"))
+        if hub_id not in (0, 1) or index is None or index < 0 or index > 3:
+            raise PrinterError("ACE-Platz ungültig.")
+        material = str(params.get("type") or "").strip()
+        if not material:
+            raise PrinterError("Die Spule braucht eine Sorte.")
+        color = params.get("color")
+        if not isinstance(color, dict):
+            raise PrinterError("Die Spule braucht eine Farbe.")
+        try:
+            red = max(0, min(255, int(color.get("R"))))
+            green = max(0, min(255, int(color.get("G"))))
+            blue = max(0, min(255, int(color.get("B"))))
+        except (TypeError, ValueError) as exc:
+            raise PrinterError("Die Spule braucht eine Farbe.") from exc
+        return post_json(
+            host,
+            "/printer/filament_hub/set_filament_info",
+            {
+                "id": hub_id,
+                "index": index,
+                "type": material,
+                "color": {"R": red, "G": green, "B": blue},
+            },
+            timeout=15,
+        )
    if action == "firmware_restart":
        # GoKlipper/Rinkhals: FIRMWARE_RESTART deadlocked gklib (Rinkhals #32).
        raise PrinterError(
@@ -427,6 +510,7 @@ def metadata(host, path):
    except (urllib.error.URLError, TimeoutError, json.JSONDecodeError, KeyError):
        data = {}
    META_CACHE[key] = (now, data)
+    _trim_cache(META_CACHE)
    return data


@@ -453,9 +537,11 @@ def embedded_preview(host, path):
            text = response.read().decode("utf-8", "replace")
    except (urllib.error.URLError, TimeoutError):
        EMBEDDED[key] = None
+        _trim_cache(EMBEDDED)
        return None
    png = embedded_png(text)
    EMBEDDED[key] = png
+    _trim_cache(EMBEDDED)
    return png


@@ -563,6 +649,80 @@ def extract_slots(status):
    return found[:8]


+def _int_or_none(value):
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    return int(value)
+
+
+def extract_dryers(status):
+    """Echte ACE-Boxen aus mmu_machine (num_gates > 0), Dummy-Unit bleibt weg."""
+    machine = (status or {}).get("mmu_machine")
+    if not isinstance(machine, dict):
+        return []
+    found = []
+    for unit_id in (0, 1):
+        unit = machine.get("unit_%d" % unit_id)
+        if not isinstance(unit, dict):
+            continue
+        gates = _int_or_none(unit.get("num_gates"))
+        if gates is None or gates < 1:
+            continue
+        found.append({
+            "id": unit_id,
+            "status": str(unit.get("dryer_status") or "stop"),
+            "temp": _int_or_none(unit.get("dryer_temp")) or 0,
+            "target": _int_or_none(unit.get("dryer_target_temp")) or 0,
+            "remain": _int_or_none(unit.get("dryer_remaining")) or 0,
+            "humidity": _int_or_none(unit.get("dryer_humidity")) or 0,
+            "gates": gates,
+        })
+    return found
+
+
+def ace_hub_index(ace_slot):
+    """Grotti-Platz 1–8 → Moonraker id (0/1) und index in der Box (0–3)."""
+    try:
+        slot = int(ace_slot)
+    except (TypeError, ValueError) as exc:
+        raise PrinterError("ACE-Platz muss 1–8 sein.") from exc
+    if slot < 1 or slot > 8:
+        raise PrinterError("ACE-Platz muss 1–8 sein.")
+    return (slot - 1) // 4, (slot - 1) % 4
+
+
+def spool_rgb(spool):
+    """Erste Farbe der Spule als RGB-Dict für set_filament_info."""
+    colors = (spool or {}).get("colors") or []
+    if isinstance(colors, str):
+        try:
+            colors = json.loads(colors)
+        except (json.JSONDecodeError, TypeError):
+            colors = []
+    hex_value = ""
+    if isinstance(colors, list):
+        for item in colors:
+            if isinstance(item, dict) and item.get("hex"):
+                hex_value = str(item["hex"]).strip()
+                break
+            if isinstance(item, str) and item.strip():
+                hex_value = item.strip()
+                break
+    if not hex_value:
+        hex_value = str((spool or {}).get("color") or "").strip()
+    if hex_value.startswith("#"):
+        hex_value = hex_value[1:]
+    if len(hex_value) == 8:
+        hex_value = hex_value[:6]
+    if len(hex_value) != 6 or any(ch not in "0123456789abcdefABCDEF" for ch in hex_value):
+        return None
+    return {
+        "R": int(hex_value[0:2], 16),
+        "G": int(hex_value[2:4], 16),
+        "B": int(hex_value[4:6], 16),
+    }
+
+
 def slots(host, status=None):
    if status is not None:
        found = extract_slots(status)
@@ -607,6 +767,16 @@ def fan_values(status):
    return speed, rpm


+def _heater_power(entry):
+    """Klipper-Einschaltdauer 0…1 (ED), sonst None."""
+    if not isinstance(entry, dict):
+        return None
+    power = entry.get("power")
+    if isinstance(power, (int, float)) and not isinstance(power, bool):
+        return max(0.0, min(1.0, float(power)))
+    return None
+
+
 def _object_names(host):
    now = time.time()
    cached = OBJECT_CACHE.get(host)
@@ -722,6 +892,99 @@ def enrich_error_message(host, stats, status):
    return " · ".join(bits) if bits else (raw or "Unbekannter Fehler — in Mainsail prüfen")


+_FILAMENT_HINT_RE = re.compile(
+    r"filament|runout|out of fil|no fil|fil.?empty|10107|"
+    r"material.?leer|spule.?leer|filament.?gerissen|filament.?fehlt|"
+    r"filament.?sensor|out of material",
+    re.I,
+)
+
+
+def last_filament_gcode_hint(host, limit=40):
+    """Letzte G-code-Zeile, die auf Filament-Ende / Runout hindeutet."""
+    try:
+        payload = fetch_json("http://%s/server/gcode_store?count=%d" % (host, int(limit)), timeout=3)
+    except (urllib.error.URLError, TimeoutError, json.JSONDecodeError, KeyError, OSError):
+        return ""
+    items = ((payload.get("result") or {}).get("gcode_store") or [])
+    for item in reversed(items):
+        if not isinstance(item, dict):
+            continue
+        text = (item.get("message") or "").strip()
+        if not text or not _FILAMENT_HINT_RE.search(text):
+            continue
+        low = text.lower()
+        if "10107" in low:
+            return "Filament gerissen oder leer (10107)"
+        return text[:160]
+    return ""
+
+
+def _mmu_tool_index(mmu):
+    """Aktives ACE/MMU-Tool, sonst None. −1 / fehlend = kein Tool (Anycubic-Normalfall)."""
+    if not isinstance(mmu, dict):
+        return None
+    tool = mmu.get("tool")
+    if not isinstance(tool, (int, float)) or isinstance(tool, bool):
+        tool = mmu.get("gate")
+    if not isinstance(tool, (int, float)) or isinstance(tool, bool):
+        return None
+    tool_i = int(tool)
+    return tool_i if tool_i >= 0 else None
+
+
+def filament_out_hint(mmu, message="", host=None):
+    """Vermutetes Material-Ende bei Pause: (code, Text) oder (None, None).
+
+    Quellen: print_stats.message, mmu.reason_for_pause, gate_status bei aktivem Tool,
+    active_filament.empty nur mit aktivem Tool, optional G-code-Store (host).
+
+    Nicht: active_filament.empty allein — Anycubic ACE meldet empty=true auch
+    beim normalen Druck und bei manueller Pause (tool/gate = −1).
+    """
+    text = (message or "").strip()
+    if text and _FILAMENT_HINT_RE.search(text):
+        if "10107" in text.lower():
+            return "message", "Filament gerissen oder leer (10107)"
+        return "message", text[:160]
+
+    if isinstance(mmu, dict) and mmu:
+        rfp = (mmu.get("reason_for_pause") or "").strip()
+        if rfp and _FILAMENT_HINT_RE.search(rfp):
+            if "10107" in rfp.lower():
+                return "reason", "Filament gerissen oder leer (10107)"
+            return "reason", rfp[:160]
+
+        tool_i = _mmu_tool_index(mmu)
+        states = mmu.get("gate_status")
+        # gate_status==0 nur, wenn Status differenziert (nicht alle 0 = Anycubic-Unknown)
+        if (
+            tool_i is not None
+            and isinstance(states, list)
+            and tool_i < len(states)
+            and int(states[tool_i] or 0) == 0
+            and any(int(s or 0) != 0 for s in states)
+        ):
+            return "gate_empty", "ACE-Platz %d leer" % (tool_i + 1)
+
+        active = mmu.get("active_filament")
+        if (
+            tool_i is not None
+            and isinstance(active, dict)
+            and (
+                active.get("empty") is True
+                or str(active.get("empty") or "").lower() in ("1", "true")
+            )
+        ):
+            return "active_empty", "Aktives Filament leer (ACE)"
+
+    if host:
+        hint = last_filament_gcode_hint(host)
+        if hint:
+            return "gcode", hint
+    return None, None
+
+
 def exclude_status(host):
    """Klipper [exclude_object] — leer, wenn Modul fehlt oder Query scheitert."""
    empty = {"objects": [], "excluded": [], "current": None}
@@ -831,6 +1094,8 @@ def query(host):
    extras = []
    if "probe" in names:
        extras.append("probe")
+    if "mmu_machine" in names:
+        extras.append("mmu_machine")
    url = "http://%s/printer/objects/query?%s" % (host, "&".join([base] + extras))
    payload = fetch_json(url)
    status = payload["result"]["status"]
@@ -838,6 +1103,21 @@ def query(host):
    card = status.get("virtual_sdcard") or {}
    extruder = status.get("extruder") or {}
    bed = status.get("heater_bed") or {}
+    mmu = status.get("mmu") or {}
+    mmu_tool = mmu.get("tool")
+    if not isinstance(mmu_tool, (int, float)) or isinstance(mmu_tool, bool):
+        mmu_tool = mmu.get("gate")
+    if isinstance(mmu_tool, (int, float)) and not isinstance(mmu_tool, bool):
+        mmu_tool = int(mmu_tool)
+        if mmu_tool < 0:
+            mmu_tool = None
+    else:
+        mmu_tool = None
+    filament_used = stats.get("filament_used")
+    if not isinstance(filament_used, (int, float)) or isinstance(filament_used, bool):
+        filament_used = None
+    else:
+        filament_used = float(filament_used)
    raw_name = stats.get("filename") or ""
    filename = raw_name.replace("\\", "/").rsplit("/", 1)[-1] if raw_name else ""
    meta = metadata(host, raw_name) if raw_name else {}
@@ -871,6 +1151,15 @@ def query(host):
    message = stats.get("message") or ""
    if (state or "").lower() == "error":
        message = enrich_error_message(host, stats, status)
+    pause_code, pause_reason = None, ""
+    filament_empty = False
+    if (state or "").lower() == "paused":
+        # G-code-Store nur bei Pause abfragen — sonst unnötige Last.
+        pause_code, pause_reason = filament_out_hint(mmu, message, host=host)
+        filament_empty = bool(pause_code)
+        if filament_empty and pause_reason:
+            if not message or message.lower() in ("paused", "pause", "pausiert"):
+                message = pause_reason
    toolhead = status.get("toolhead") or {}
    axis_max = toolhead.get("axis_maximum") or []
    z_max = None
@@ -880,6 +1169,8 @@ def query(host):
        "ok": True,
        "state": state,
        "message": message,
+        "filament_empty": filament_empty,
+        "pause_reason": pause_reason or "",
        "homed_axes": toolhead.get("homed_axes") or "",
        "position": toolhead.get("position") or [],
        "z_max": z_max,
@@ -892,12 +1183,21 @@ def query(host):
        "elapsed": stats.get("print_duration") or 0,
        "nozzle": extruder.get("temperature"),
        "nozzle_target": extruder.get("target"),
+        "nozzle_power": _heater_power(extruder),
        "bed": bed.get("temperature"),
        "bed_target": bed.get("target"),
+        "bed_power": _heater_power(bed),
        "chamber": chamber,
        "chamber_target": chamber_target,
+        "filament_used": filament_used,
+        "filament_total": meta.get("filament_total") or 0,
+        "mmu_tool": mmu_tool,
        "material": card.get("filament_type") or meta.get("filament_type") or "",
-        "weight": meta.get("filament_weight_total") or 0,
+        "weight": (
+            sum(float(x or 0) for x in meta["filament_weight_total"])
+            if isinstance(meta.get("filament_weight_total"), list)
+            else (meta.get("filament_weight_total") or 0)
+        ),
        "height": meta.get("object_height") or 0,
        "layer_height": meta.get("layer_height") or card.get("layer_height") or 0,
        "estimated": meta.get("estimated_time") or 0,
@@ -915,6 +1215,7 @@ def query(host):
        "speed_factor": speed_factor,
        "extrude_factor": extrude_factor,
        "slots": slots(host, status),
+        "dryers": extract_dryers(status),
        "exclude": exclude_status(host),
        "anycubic_task": _anycubic_task_field(host),
    }
@@ -941,11 +1242,15 @@ def snapshot(printers):
        }
        try:
            card.update(query(printer["host"]))
-        except (urllib.error.URLError, TimeoutError, json.JSONDecodeError, KeyError) as error:
+        except Exception as error:
+            # Auch RemoteDisconnected / IncompleteRead / ValueError — sonst fällt der ganze Tick aus.
+            log.warning("snapshot %s: %s", printer.get("host"), error)
            card.update({
                "ok": False,
                "state": "offline",
                "message": str(error),
+                "filament_empty": False,
+                "pause_reason": "",
                "camera": "",
                "has_camera": False,
                "fan": None,
@@ -956,6 +1261,7 @@ def snapshot(printers):
                "speed_factor": None,
                "extrude_factor": None,
                "slots": [],
+                "dryers": [],
                "anycubic_task": None,
            })
            card.update(mesh_fields(printer["host"]))
@@ -988,20 +1294,23 @@ def camera_image(host):
    return CAMERA_CACHE[host][2]


+def open_camera_stream(host):
+    """Öffnet den MJPEG-Stream am Drucker. Aufrufer schließt die Response."""
+    url = "http://%s/webcam/?action=stream" % host
+    request = urllib.request.Request(url)
+    return urllib.request.urlopen(request, timeout=30)
+
+
 def _camera_fields(host, quoted_host):
    """Kamera-URL nur, wenn nicht als tot bekannt (Cache-Miss = erst versuchen)."""
+    snap = "/api/v1/kamera?host=%s" % quoted_host
+    stream = "/api/v1/kamera/stream?host=%s" % quoted_host
    cached = CAMERA_CACHE.get(host)
    if cached is not None and cached[2] is None:
-        return {"camera": "", "has_camera": False}
+        return {"camera": "", "camera_stream": "", "has_camera": False}
    if cached is not None and cached[2] is not None:
-        return {
-            "camera": "/api/v1/kamera?host=%s" % quoted_host,
-            "has_camera": True,
-        }
-    return {
-        "camera": "/api/v1/kamera?host=%s" % quoted_host,
-        "has_camera": None,
-    }
+        return {"camera": snap, "camera_stream": stream, "has_camera": True}
+    return {"camera": snap, "camera_stream": stream, "has_camera": None}


 def embedded_bytes(host, name):
@@ -1,8 +1,9 @@
-"""Telegram-Benachrichtigungen (Bot API)."""
+"""Telegram- und ntfy-Benachrichtigungen."""

 from __future__ import annotations

 import json
+import threading
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -33,7 +34,12 @@ def send_telegram(cfg, text):
        return False


-ALERT_GROUP = {"abbruch": "fehler"}
+ALERT_GROUP = {
+    "abbruch": "fehler",
+    "bedarf": "queue",
+    "wartung": "queue",
+    "auftrag": "queue",
+}
 DEFAULT_OFF = {"ablauf", "start"}


@@ -43,11 +49,52 @@ def alert_enabled(cfg, kind):
    return bool(alerts.get(key, key not in DEFAULT_OFF))


-def record(conn, cfg, host, printer, kind, message, filename="", dedupe_s=60):
-    """Ereignis immer speichern; Telegram nur einmal pro Art und Drucker im Zeitfenster."""
+def ntfy_configured(cfg):
+    ntfy = (cfg or {}).get("ntfy") or {}
+    return bool(ntfy.get("enabled") and ntfy.get("topic"))
+
+
+def send_ntfy(cfg, text):
+    if not ntfy_configured(cfg):
+        return False
+    ntfy = cfg["ntfy"]
+    server = str(ntfy.get("server") or "https://ntfy.sh").rstrip("/")
+    topic = str(ntfy.get("topic") or "").strip()
+    if not topic:
+        return False
+    url = "%s/%s" % (server, urllib.parse.quote(topic, safe=""))
+    headers = {"Title": "Grotti", "Priority": "default"}
+    token = str(ntfy.get("token") or "").strip()
+    if token:
+        headers["Authorization"] = "Bearer %s" % token
+    request = urllib.request.Request(
+        url,
+        data=text[:4000].encode("utf-8"),
+        method="POST",
+        headers=headers,
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=12) as response:
+            return 200 <= response.status < 300
+    except (urllib.error.URLError, TimeoutError, OSError):
+        return False
+
+
+def _push_alerts(cfg, message):
+    send_telegram(cfg, message)
+    send_ntfy(cfg, message)
+
+
+def record(conn, cfg, host, printer, kind, message, filename="", dedupe_s=60, run_id=None):
+    """Ereignis immer speichern; Telegram/ntfy nur einmal pro Art und Drucker im Zeitfenster."""
    from grotti import store

    recent = store.recent_event_kind(conn, host, kind, within_s=dedupe_s)
-    store.add_event(conn, host, printer, kind, message, filename or "")
+    store.add_event(conn, host, printer, kind, message, filename or "", run_id=run_id)
    if not recent and alert_enabled(cfg, kind):
-        send_telegram(cfg, message)
+        threading.Thread(
+            target=_push_alerts,
+            args=(cfg, message),
+            name="grotti-notify",
+            daemon=True,
+        ).start()
@@ -0,0 +1,460 @@
+"""Aufträge, Kunden und Positionen."""
+
+from __future__ import annotations
+
+from datetime import date
+
+from psycopg.types.json import Json
+
+from grotti import store
+
+ORDER_STATUSES = frozenset({
+    "idee",
+    "angebot",
+    "bestaetigt",
+    "druckt",
+    "fertig",
+    "geliefert",
+    "bezahlt",
+})
+
+PROJECT_TO_ORDER = {
+    "idee": "idee",
+    "bereit": "angebot",
+    "druckt": "druckt",
+    "fertig": "fertig",
+}
+
+IDEA_TO_ORDER = {
+    "offen": "idee",
+    "spaeter": "idee",
+    "erledigt": "fertig",
+}
+
+
+def normalize_status(value):
+    s = (value or "idee").strip().lower()
+    if s not in ORDER_STATUSES:
+        raise ValueError("Unbekannter Auftragsstatus.")
+    return s
+
+
+def customer_out(row):
+    return {
+        "id": row["id"],
+        "name": row["name"],
+        "email": row.get("email") or "",
+        "notes": row.get("notes") or "",
+        "created_at": store.iso(row["created_at"]),
+    }
+
+
+def order_item_out(row, file_name=None):
+    return {
+        "id": row["id"],
+        "order_id": row["order_id"],
+        "file_id": row.get("file_id"),
+        "file_name": file_name or "",
+        "qty": int(row.get("qty") or 1),
+        "unit_price": float(row.get("unit_price") or 0),
+        "material_type": row.get("material_type") or "",
+        "color": row.get("color") or "",
+        "done_ok": int(row.get("done_ok") or 0),
+        "done_bad": int(row.get("done_bad") or 0),
+        "note": row.get("note") or "",
+    }
+
+
+def order_out(row, customer=None, items=None, progress=None):
+    data = {
+        "id": row["id"],
+        "customer_id": row.get("customer_id"),
+        "title": row["title"],
+        "status": row["status"],
+        "due_at": row["due_at"].isoformat() if row.get("due_at") else None,
+        "notes": row.get("notes") or "",
+        "quote": row.get("quote") or {},
+        "created_at": store.iso(row["created_at"]),
+        "updated_at": store.iso(row.get("updated_at") or row["created_at"]),
+    }
+    if customer is not None:
+        data["customer"] = customer
+    if items is not None:
+        data["items"] = items
+    if progress is not None:
+        data["progress"] = progress
+    return data
+
+
+def order_progress(conn, order_id):
+    row = conn.execute(
+        """
+        SELECT
+            COALESCE(SUM(qty), 0) AS target,
+            COALESCE(SUM(LEAST(done_ok, qty)), 0) AS done_ok,
+            COALESCE(SUM(done_bad), 0) AS done_bad
+        FROM order_items
+        WHERE order_id = %s
+        """,
+        (order_id,),
+    ).fetchone()
+    target = int(row["target"] or 0)
+    done = int(row["done_ok"] or 0)
+    return {
+        "target": target,
+        "done": done,
+        "done_bad": int(row["done_bad"] or 0),
+        "label": "%d von %d" % (done, target) if target else "0 von 0",
+    }
+
+
+def list_customers(conn):
+    rows = conn.execute(
+        "SELECT * FROM customers ORDER BY name, id"
+    ).fetchall()
+    return [customer_out(r) for r in rows]
+
+
+def get_customer(conn, customer_id):
+    row = conn.execute("SELECT * FROM customers WHERE id = %s", (customer_id,)).fetchone()
+    return customer_out(row) if row else None
+
+
+def create_customer(conn, name, email="", notes=""):
+    row = conn.execute(
+        """
+        INSERT INTO customers (name, email, notes)
+        VALUES (%s, %s, %s)
+        RETURNING *
+        """,
+        (name.strip(), (email or "").strip(), (notes or "").strip()),
+    ).fetchone()
+    return customer_out(row)
+
+
+def update_customer(conn, customer_id, fields):
+    sets = []
+    values = []
+    for key in ("name", "email", "notes"):
+        if key in fields:
+            sets.append("%s = %%s" % key)
+            values.append(fields[key])
+    if not sets:
+        return get_customer(conn, customer_id)
+    values.append(customer_id)
+    row = conn.execute(
+        "UPDATE customers SET %s WHERE id = %%s RETURNING *" % ", ".join(sets),
+        values,
+    ).fetchone()
+    return customer_out(row) if row else None
+
+
+def delete_customer(conn, customer_id):
+    row = conn.execute(
+        "DELETE FROM customers WHERE id = %s RETURNING id",
+        (customer_id,),
+    ).fetchone()
+    return bool(row)
+
+
+def list_orders(conn, status=None):
+    where = ""
+    params = []
+    if status:
+        where = "WHERE o.status = %s"
+        params.append(status)
+    rows = conn.execute(
+        """
+        SELECT o.*, c.name AS customer_name
+        FROM orders o
+        LEFT JOIN customers c ON c.id = o.customer_id
+        %s
+        ORDER BY o.updated_at DESC, o.id DESC
+        """ % where,
+        params,
+    ).fetchall()
+    out = []
+    for row in rows:
+        prog = order_progress(conn, row["id"])
+        customer = None
+        if row.get("customer_id"):
+            customer = {"id": row["customer_id"], "name": row.get("customer_name") or ""}
+        out.append(order_out(row, customer=customer, progress=prog))
+    return out
+
+
+def get_order(conn, order_id):
+    row = conn.execute(
+        """
+        SELECT o.*, c.name AS customer_name, c.email AS customer_email
+        FROM orders o
+        LEFT JOIN customers c ON c.id = o.customer_id
+        WHERE o.id = %s
+        """,
+        (order_id,),
+    ).fetchone()
+    if not row:
+        return None
+    items_rows = conn.execute(
+        """
+        SELECT oi.*, f.name AS file_name
+        FROM order_items oi
+        LEFT JOIN files f ON f.id = oi.file_id
+        WHERE oi.order_id = %s
+        ORDER BY oi.id
+        """,
+        (order_id,),
+    ).fetchall()
+    items = [order_item_out(r, r.get("file_name")) for r in items_rows]
+    customer = None
+    if row.get("customer_id"):
+        customer = {
+            "id": row["customer_id"],
+            "name": row.get("customer_name") or "",
+            "email": row.get("customer_email") or "",
+        }
+    return order_out(
+        row,
+        customer=customer,
+        items=items,
+        progress=order_progress(conn, order_id),
+    )
+
+
+def create_order(conn, title, status="idee", customer_id=None, due_at=None, notes="", quote=None):
+    status = normalize_status(status)
+    due = None
+    if due_at:
+        if isinstance(due_at, date):
+            due = due_at
+        else:
+            due = date.fromisoformat(str(due_at)[:10])
+    row = conn.execute(
+        """
+        INSERT INTO orders (customer_id, title, status, due_at, notes, quote)
+        VALUES (%s, %s, %s, %s, %s, %s)
+        RETURNING *
+        """,
+        (
+            customer_id,
+            title.strip(),
+            status,
+            due,
+            (notes or "").strip(),
+            Json(quote if isinstance(quote, dict) else {}),
+        ),
+    ).fetchone()
+    return get_order(conn, row["id"])
+
+
+def update_order(conn, order_id, fields):
+    sets = ["updated_at = now()"]
+    values = []
+    if "title" in fields:
+        sets.append("title = %s")
+        values.append(fields["title"])
+    if "status" in fields:
+        sets.append("status = %s")
+        values.append(normalize_status(fields["status"]))
+    if "customer_id" in fields:
+        sets.append("customer_id = %s")
+        values.append(fields["customer_id"])
+    if "due_at" in fields:
+        sets.append("due_at = %s")
+        due = fields["due_at"]
+        if due in ("", None):
+            values.append(None)
+        elif isinstance(due, date):
+            values.append(due)
+        else:
+            values.append(date.fromisoformat(str(due)[:10]))
+    if "notes" in fields:
+        sets.append("notes = %s")
+        values.append(fields["notes"] or "")
+    if "quote" in fields:
+        sets.append("quote = %s")
+        values.append(Json(fields["quote"] if isinstance(fields["quote"], dict) else {}))
+    if len(sets) <= 1:
+        return get_order(conn, order_id)
+    values.append(order_id)
+    row = conn.execute(
+        "UPDATE orders SET %s WHERE id = %%s RETURNING id" % ", ".join(sets),
+        values,
+    ).fetchone()
+    return get_order(conn, row["id"]) if row else None
+
+
+def delete_order(conn, order_id):
+    row = conn.execute("DELETE FROM orders WHERE id = %s RETURNING id", (order_id,)).fetchone()
+    return bool(row)
+
+
+def create_order_item(conn, order_id, file_id=None, qty=1, unit_price=0, material_type="", color="", note=""):
+    if not conn.execute("SELECT 1 FROM orders WHERE id = %s", (order_id,)).fetchone():
+        return None
+    try:
+        qty_n = max(1, int(qty))
+    except (TypeError, ValueError):
+        qty_n = 1
+    row = conn.execute(
+        """
+        INSERT INTO order_items (
+            order_id, file_id, qty, unit_price, material_type, color, note
+        )
+        VALUES (%s, %s, %s, %s, %s, %s, %s)
+        RETURNING *
+        """,
+        (
+            order_id,
+            file_id,
+            qty_n,
+            float(unit_price or 0),
+            (material_type or "").strip(),
+            (color or "").strip(),
+            (note or "").strip(),
+        ),
+    ).fetchone()
+    conn.execute("UPDATE orders SET updated_at = now() WHERE id = %s", (order_id,))
+    file_name = ""
+    if file_id:
+        f = store.get_file_row(conn, file_id)
+        file_name = (f or {}).get("name") or ""
+    return order_item_out(row, file_name)
+
+
+def get_order_item(conn, item_id):
+    row = conn.execute(
+        """
+        SELECT oi.*, f.name AS file_name
+        FROM order_items oi
+        LEFT JOIN files f ON f.id = oi.file_id
+        WHERE oi.id = %s
+        """,
+        (item_id,),
+    ).fetchone()
+    return order_item_out(row, row.get("file_name")) if row else None
+
+
+def update_order_item(conn, item_id, fields):
+    sets = []
+    values = []
+    for key in ("file_id", "material_type", "color", "note"):
+        if key in fields:
+            sets.append("%s = %%s" % key)
+            values.append(fields[key])
+    if "qty" in fields:
+        try:
+            qty_n = max(1, int(fields["qty"]))
+        except (TypeError, ValueError):
+            qty_n = 1
+        sets.append("qty = %s")
+        values.append(qty_n)
+    if "unit_price" in fields:
+        sets.append("unit_price = %s")
+        values.append(float(fields["unit_price"] or 0))
+    if not sets:
+        return get_order_item(conn, item_id)
+    values.append(item_id)
+    row = conn.execute(
+        """
+        UPDATE order_items SET %s
+        WHERE id = %%s
+        RETURNING order_id
+        """ % ", ".join(sets),
+        values,
+    ).fetchone()
+    if not row:
+        return None
+    conn.execute("UPDATE orders SET updated_at = now() WHERE id = %s", (row["order_id"],))
+    return get_order_item(conn, item_id)
+
+
+def delete_order_item(conn, item_id):
+    row = conn.execute(
+        "DELETE FROM order_items WHERE id = %s RETURNING order_id",
+        (item_id,),
+    ).fetchone()
+    if row:
+        conn.execute("UPDATE orders SET updated_at = now() WHERE id = %s", (row["order_id"],))
+    return bool(row)
+
+
+def apply_verdict_delta(conn, order_item_id, old_ok, old_bad, new_ok, new_bad):
+    """Erhöht done_ok/done_bad an der Position — nur Delta zum vorherigen Lauf-Stand."""
+    if not order_item_id:
+        return
+    d_ok = int(new_ok or 0) - int(old_ok or 0)
+    d_bad = int(new_bad or 0) - int(old_bad or 0)
+    if d_ok == 0 and d_bad == 0:
+        return
+    conn.execute(
+        """
+        UPDATE order_items
+        SET done_ok = done_ok + %s, done_bad = done_bad + %s
+        WHERE id = %s
+        """,
+        (d_ok, d_bad, order_item_id),
+    )
+    item = conn.execute(
+        "SELECT order_id FROM order_items WHERE id = %s",
+        (order_item_id,),
+    ).fetchone()
+    if item:
+        conn.execute("UPDATE orders SET updated_at = now() WHERE id = %s", (item["order_id"],))
+
+
+def enqueue_order_item(
+    conn,
+    order_id,
+    item_id,
+    host="",
+    family="",
+    priority=100,
+    spool_id=None,
+    ace_map=None,
+    bed_leveling=False,
+    override=False,
+):
+    item = conn.execute(
+        "SELECT * FROM order_items WHERE id = %s AND order_id = %s",
+        (item_id, order_id),
+    ).fetchone()
+    if not item:
+        raise ValueError("Position fehlt.")
+    file_id = item.get("file_id")
+    if not file_id:
+        raise ValueError("Position ohne Datei.")
+    if not store.get_file_row(conn, file_id):
+        raise ValueError("Datei fehlt.")
+    row = store.enqueue_print(
+        conn,
+        file_id,
+        host or "",
+        family or "",
+        priority,
+        spool_id,
+        ace_map if isinstance(ace_map, list) else [],
+        bool(bed_leveling),
+        bool(override),
+        order_item_id=item["id"],
+    )
+    conn.execute("UPDATE orders SET updated_at = now(), status = CASE WHEN status IN ('idee', 'angebot', 'bestaetigt') THEN 'druckt' ELSE status END WHERE id = %s", (order_id,))
+    return row
+
+
+def attach_order_item_to_live_run(conn, host, filename, order_item_id):
+    """Verknüpft gestarteten Lauf mit Auftragsposition."""
+    if not order_item_id or not host:
+        return
+    base = (filename or "").replace("\\", "/").rsplit("/", 1)[-1]
+    conn.execute(
+        """
+        UPDATE runs
+        SET order_item_id = COALESCE(order_item_id, %s)
+        WHERE printer_host = %s
+          AND (filename = %s OR filename LIKE %s)
+          AND state IN ('printing', 'paused', 'in_progress', 'completed')
+          AND ended_at IS NULL
+        """,
+        (order_item_id, host, base, "%/" + base),
+    )
@@ -17,6 +17,8 @@ TRAILER_RE = re.compile(rb";\s*referenced_tools\s*=", re.I)
 RINKHALS_FINGERPRINT = b"; processed by MmuAcePatcher"
 _SLICER_RE = re.compile(rb"^;.*generated by ([A-Za-z]*) .*$|^; (BambuStudio) .*$", re.I)
 _TOOL_RE = re.compile(rb"^(?:MMU_CHANGE_TOOL(?:_STANDALONE)? .*?TOOL=|T)(\d{1,2})", re.I)
+# Orca `; filament_colour_type` — gklib parsed wie `filament_colour` und panickt (10111).
+_COLOUR_TYPE_LINE_RE = re.compile(rb"(?m)^;\s*filament_colour_type\b[^\n]*\n?")
 _AUTHORIZED_SLICERS = {
    "prusaslicer",
    "superslicer",
@@ -91,40 +93,111 @@ def color_hex(channels):
    return "#%02x%02x%02x" % tuple(rgb)


+def profile_name(raw):
+    """Orca-Profil → Katalogname: `Sunlu PLA Meta @Kobra 3` → `Sunlu PLA Meta`."""
+    text = (raw or "").strip().strip('"').strip("'").strip()
+    if " @" in text:
+        text = text.rsplit(" @", 1)[0].strip()
+    return text
+
+
+def filament_profiles(comments):
+    """Profilnamen aus `; filament_settings_id`, Index = Slicer-Slot / paint_index."""
+    raw = (comments or {}).get("filament_settings_id") or ""
+    if not raw.strip():
+        fallback = profile_name((comments or {}).get("default_filament_profile") or "")
+        return [fallback] if fallback else []
+    return [profile_name(part) for part in raw.split(";") if profile_name(part)]
+
+
+def attach_profiles(filaments, comments):
+    """Hängt `profile` (Sorte) an Filament-Einträge anhand des paint_index."""
+    profiles = filament_profiles(comments)
+    if not filaments:
+        return filaments
+    if not profiles:
+        return filaments
+    for index, row in enumerate(filaments):
+        if not isinstance(row, dict):
+            continue
+        try:
+            paint = int(row.get("paint_index"))
+        except (TypeError, ValueError):
+            paint = index
+        name = ""
+        if 0 <= paint < len(profiles):
+            name = profiles[paint]
+        elif len(filaments) == 1 and len(profiles) == 1:
+            name = profiles[0]
+        if name:
+            row["profile"] = name
+    return filaments
+
+
 def filaments_from_paint_info(raw):
+    """Farben aus `; paint_info` — inkl. originalem `paint_index` (T-Nummer).
+
+    Bambu/Anycubic nutzen oft Lücken (T1 + T10 bei 16 Slots). Die Liste bleibt
+    kompakt (nur belegte Farben), aber jeder Eintrag trägt den Slicer-Index,
+    damit `.acm` und ACE-Map denselben Wert wie `Tn` im G-code schreiben.
+    """
    try:
        items = json.loads(raw or "")
    except (TypeError, json.JSONDecodeError):
        return []
    if not isinstance(items, list):
        return []
-    found = []
+    found = {}
+    next_fallback = 0
    for item in items:
        if not isinstance(item, dict):
            continue
        try:
            index = int(item.get("paint_index"))
        except (TypeError, ValueError):
-            index = len(found)
-        while len(found) <= index:
-            found.append({"type": "", "color": ""})
-        found[index] = {
+            index = next_fallback
+        if index < 0:
+            continue
+        next_fallback = max(next_fallback, index + 1)
+        row = {
            "type": str(item.get("material_type") or "").strip(),
            "color": color_hex(item.get("paint_color")),
+            "paint_index": index,
        }
-    return [row for row in found if row["type"] or row["color"]]
+        if row["type"] or row["color"]:
+            found[index] = row
+    return [found[key] for key in sorted(found)]


 def filaments_of(comments):
    painted = filaments_from_paint_info(comments.get("paint_info"))
    if painted:
-        return painted
+        return attach_profiles(painted, comments)
    types = [part.strip() for part in (comments.get("filament_type") or "").split(";") if part.strip()]
    colors = [part.strip() for part in (comments.get("filament_colour") or comments.get("filament_color") or "").split(";")]
-    return [
-        {"type": kind, "color": colors[index] if index < len(colors) else ""}
+    rows = [
+        {
+            "type": kind,
+            "color": colors[index] if index < len(colors) else "",
+            "paint_index": index,
+        }
        for index, kind in enumerate(types)
    ]
+    return attach_profiles(rows, comments)
+
+
+def tools_used_in_gcode(content):
+    """T-/MMU-Werkzeuge aus dem G-code (wie Rinkhals mmu_ace_metadata)."""
+    if not content:
+        return set()
+    if isinstance(content, str):
+        content = content.encode("utf-8", "replace")
+    found = set()
+    for line in _gcode_lines(content):
+        match = _TOOL_RE.match(line)
+        if match:
+            found.add(int(match.group(1)))
+    return found


 def _gcode_lines(content):
@@ -173,6 +246,36 @@ def _paint_tool_indexes(content):
    return found


+def gcode_is_multicolor(content, tools=None):
+    """Mehr als ein Slicer-/ACE-Tool → Multicolor (Header nicht antasten)."""
+    if not content or content[:2] == b"PK":
+        return False
+    indexes = set()
+    for value in tools or []:
+        try:
+            indexes.add(int(value))
+        except (TypeError, ValueError):
+            continue
+    for line in _gcode_lines(content):
+        match = _TOOL_RE.match(line)
+        if match:
+            indexes.add(int(match.group(1)))
+    indexes |= _paint_tool_indexes(content)
+    return len(indexes) > 1
+
+
+def strip_filament_colour_type(content, tools=None):
+    """`; filament_colour_type` nur bei Einfarbig entfernen (gklib 10111).
+
+    Multicolor unverändert — ACE/paint_index und `; filament_colour` bleiben.
+    """
+    if not content or content[:2] == b"PK":
+        return content
+    if gcode_is_multicolor(content, tools=tools):
+        return content
+    return _COLOUR_TYPE_LINE_RE.sub(b"", content)
+
+
 def prepare_rinkhals_gcode(content, tools=None):
    """Kopfzeile für Rinkhals plus `; referenced_tools`, wenn sie fehlt.

@@ -182,6 +285,7 @@ def prepare_rinkhals_gcode(content, tools=None):
    """
    if not content or content[:2] == b"PK":
        return content
+    content = strip_filament_colour_type(content, tools=tools)
    first_end = content.find(b"\n")
    first = content if first_end < 0 else content[:first_end]
    if first.endswith(b"\r"):
@@ -10,9 +10,19 @@ import threading
 import time
 from datetime import datetime, timezone

-from grotti import eject, jobs, moonraker, notify, store
+from grotti import acm, eject, jobs, logutil, moonraker, notify, store
 from grotti.db import connect
 from grotti.errors import GrottiError
+from grotti import time_window
+
+WINDOW_WAIT_MSG = "Wartet auf Zeitfenster…"
+from grotti.events_bus import publish as publish_live
+
+log = logutil.get("grotti.queue")
+
+
+def _notify_queue():
+    publish_live("queue", {})

 FREE = {"standby", "complete", "cancelled"}
 BUSY = {"printing", "paused", "heating", "error"}
@@ -20,6 +30,13 @@ BUSY = {"printing", "paused", "heating", "error"}
 KEEPALIVE_S = 120
 # Nach Start ohne print_active: Upload/MQTT/LeviQ brauchen Zeit, aber nicht ewig
 PRINT_START_TIMEOUT_S = 600
+# Upload-Worker weg (typisch Grotti-Neustart mitten im Hochladen).
+# Nach erfolgreichem Senden ist die Phase await_print — dort gilt das nicht,
+# sonst wird ein noch anlaufender Druck als „Neustart“ neu eingereiht.
+SIMPLE_START_STUCK_S = 45
+# Anycubic meldet kurz cancelled/standby bei LeviQ und Filament-Resume.
+TERMINAL_CONFIRM_HITS = 3
+AWAIT_CANCEL_HITS = 3


 def _ablauf_needs_motors(item):
@@ -101,7 +118,7 @@ class PrintQueueDispatcher:
            try:
                self.tick()
            except Exception as exc:
-                print("Druck-Queue: %s" % exc, flush=True)
+                log.warning("Druck-Queue: %s", exc)
            self._stop.wait(self.interval)

    def _live_map(self, printers):
@@ -120,6 +137,100 @@ class PrintQueueDispatcher:
            thread = self._workers.get(item_id)
            return bool(thread and thread.is_alive())

+    def _item_phase_age_s(self, item):
+        """Alter von phase_started_at, sonst updated_at (für hängende Starts nach Neustart)."""
+        started = item.get("phase_started_at")
+        if started:
+            if getattr(started, "tzinfo", None) is None:
+                started = started.replace(tzinfo=timezone.utc)
+            return (datetime.now(timezone.utc) - started).total_seconds()
+        updated = item.get("updated_at")
+        if updated:
+            if getattr(updated, "tzinfo", None) is None:
+                updated = updated.replace(tzinfo=timezone.utc)
+            return (datetime.now(timezone.utc) - updated).total_seconds()
+        return 0
+
+    def _auto_retry_enabled(self):
+        return bool((self.cfg or {}).get("auto_retry", True))
+
+    def _retryable_message(self, message):
+        text = (message or "").lower()
+        if "abgebrochen" in text:
+            return False
+        if "druck abgebrochen" in text:
+            return False
+        return True
+
+    def _try_auto_retry(self, conn, item, message):
+        """Ein automatischer Neuversuch; sonst False. Nicht nach Abbruch."""
+        if not self._auto_retry_enabled():
+            return False
+        if not self._retryable_message(message):
+            return False
+        retries = int(item.get("retry_count") or 0)
+        if retries >= 1:
+            return False
+        store.update_print_queue(
+            conn,
+            item["id"],
+            {
+                "status": "waiting",
+                "message": "Nochmal (%s)" % (message or "Fehler"),
+                "retry_count": retries + 1,
+                "phase": "",
+                "phase_started_at": None,
+                "host": item.get("host") or "",
+            },
+        )
+        return True
+
+    def _terminal_hits(self, item_id, kind="end"):
+        key = "%s:%s" % (item_id, kind)
+        if not hasattr(self, "_term_hits"):
+            self._term_hits = {}
+        self._term_hits[key] = self._term_hits.get(key, 0) + 1
+        return self._term_hits[key]
+
+    def _clear_terminal_hits(self, item_id, kind=None):
+        if not hasattr(self, "_term_hits"):
+            return
+        if kind:
+            self._term_hits.pop("%s:%s" % (item_id, kind), None)
+            return
+        for key in list(self._term_hits):
+            if key.startswith("%s:" % item_id):
+                self._term_hits.pop(key, None)
+
+    def _fail_stuck_simple_start(self, conn, item, printer):
+        host = printer["host"]
+        msg = "Start abgebrochen (Neustart)"
+        if self._try_auto_retry(conn, item, msg):
+            self._event(
+                conn, host, printer["name"], "queue",
+                "%s: Nochmal — %s" % (printer["name"], msg),
+                item.get("filename") or "",
+            )
+            return
+        store.update_print_queue(
+            conn,
+            item["id"],
+            {
+                "status": "error",
+                "message": msg,
+                "phase": "",
+                "phase_started_at": None,
+            },
+        )
+        self._event(
+            conn,
+            host,
+            printer["name"],
+            "queue",
+            "%s: Start abgebrochen (Neustart)" % printer["name"],
+            item.get("filename") or "",
+        )
+
    def _spawn_worker(self, item_id, target, *args):
        with self._worker_lock:
            existing = self._workers.get(item_id)
@@ -129,7 +240,10 @@ class PrintQueueDispatcher:
            def run():
                try:
                    target(*args)
+                except Exception as exc:
+                    log.warning("Queue-Worker %s: %s", item_id, exc)
                finally:
+                    _notify_queue()
                    with self._worker_lock:
                        self._workers.pop(item_id, None)

@@ -143,6 +257,12 @@ class PrintQueueDispatcher:
            return True

    def tick(self):
+        try:
+            self._tick_once()
+        finally:
+            _notify_queue()
+
+    def _tick_once(self):
        with connect(self.database_url) as conn:
            printers = store.list_printers(conn)
            if not printers:
@@ -187,16 +307,53 @@ class PrintQueueDispatcher:
                    lives[host] = live
                    state = (live.get("state") or "").lower()
                if state in BUSY:
+                    # Laufenden Einfach-Druck mitziehen. Sonst bleibt await_print
+                    # stehen, bis der Drucker frei ist — und der Start gilt als Timeout,
+                    # obwohl er längst druckt.
+                    running = store.running_print_on_host(conn, host)
+                    if running and not _has_ablauf(running):
+                        self._advance_simple(conn, running, printer, live)
+                        conn.commit()
                    continue
                if state not in FREE:
                    continue
-                if store.running_print_on_host(conn, host):
+                running = store.running_print_on_host(conn, host)
+                if running:
+                    if not _has_ablauf(running):
+                        if (
+                            (running.get("phase") or "").lower() == "starting"
+                            and not self._worker_busy(running["id"])
+                            and self._item_phase_age_s(running) > SIMPLE_START_STUCK_S
+                        ):
+                            self._fail_stuck_simple_start(conn, running, printer)
+                        else:
+                            self._advance_simple(conn, running, printer, live)
+                        conn.commit()
                    continue
                if store.bed_needs_clear(conn, host):
                    continue
                waiting = store.next_waiting_print(conn, host=host, family=printer.get("family") or "")
                if not waiting:
                    continue
+                sw = printer.get("start_window") or {}
+                if sw and not time_window.allowed_now(sw):
+                    if (waiting.get("message") or "") != WINDOW_WAIT_MSG:
+                        store.update_print_queue(conn, waiting["id"], {"message": WINDOW_WAIT_MSG})
+                    continue
+                est_s = 0
+                if waiting.get("file_id"):
+                    file_row = store.get_file_row(conn, waiting["file_id"])
+                    if file_row:
+                        est_s = float(file_row.get("estimated_s") or 0)
+                if sw and not time_window.job_fits_overnight(sw, est_s):
+                    if (waiting.get("message") or "") != WINDOW_WAIT_MSG:
+                        store.update_print_queue(conn, waiting["id"], {"message": WINDOW_WAIT_MSG})
+                    continue
+                # Nächster passender / leere Map: ACE aus Spulen bauen oder warten
+                if not _has_ablauf(waiting):
+                    waiting = self._ensure_ace_map(conn, waiting, host, live)
+                    if not waiting:
+                        continue
                claimed = store.claim_print_queue(conn, waiting["id"], host)
                if not claimed:
                    continue
@@ -208,6 +365,49 @@ class PrintQueueDispatcher:
                    self._start_simple(conn, claimed, printer)
                conn.commit()

+    def _ensure_ace_map(self, conn, waiting, host, live):
+        """Bei ACE-Drucker und leerer Map: aus Spulen zuordnen oder Wartegrund setzen."""
+        slots = (live or {}).get("slots") or []
+        if not slots:
+            return waiting
+        ace = waiting.get("ace_map") or []
+        if isinstance(ace, str):
+            import json
+
+            try:
+                ace = json.loads(ace)
+            except json.JSONDecodeError:
+                ace = []
+        if acm.normalize_mapping(ace if isinstance(ace, list) else []):
+            return waiting
+        file_id = waiting.get("file_id")
+        if not file_id:
+            return waiting
+        mapping, reason = store.auto_ace_map(conn, host, file_id)
+        if reason:
+            if (waiting.get("wait_reason") or "") != reason or (waiting.get("message") or "") != reason:
+                store.update_print_queue(
+                    conn,
+                    waiting["id"],
+                    {"wait_reason": reason, "message": reason},
+                )
+            return None
+        if not mapping:
+            # ACE am Drucker, aber keine ACE-Spulen in Grotti → nicht raten
+            reason = "ACE-Zuordnung fehlt (keine passende Spule)"
+            if (waiting.get("wait_reason") or "") != reason:
+                store.update_print_queue(
+                    conn,
+                    waiting["id"],
+                    {"wait_reason": reason, "message": reason},
+                )
+            return None
+        store.update_print_queue(conn, waiting["id"], {"ace_map": mapping, "wait_reason": "", "message": ""})
+        waiting = dict(waiting)
+        waiting["ace_map"] = mapping
+        waiting["wait_reason"] = ""
+        return waiting
+
    def _start_simple(self, conn, item, printer):
        """Upload/Start im Worker — mehrere freie Drucker parallel."""
        host = printer["host"]
@@ -255,17 +455,31 @@ class PrintQueueDispatcher:
                        bed_leveling=bed_leveling,
                    )
                    name = (result or {}).get("filename") or ""
-                    store.update_print_queue(
-                        wconn,
-                        item_id,
-                        {
-                            "status": "done",
-                            "message": "Gestartet auf %s: %s" % (printer_copy["name"], name),
-                            "host": host,
-                            "phase": "",
-                            "phase_started_at": None,
-                        },
-                    )
+                    # Abbruch während Upload: Status nicht überschreiben, Druck stoppen.
+                    current = store.get_print_queue_row(wconn, item_id)
+                    if current and (current.get("status") or "") in ("cancelled", "dismissed"):
+                        try:
+                            moonraker.command(host, "cancel")
+                        except Exception:
+                            pass
+                        return
+                    oid = item.get("order_item_id")
+                    if oid:
+                        from grotti import orders
+
+                        orders.attach_order_item_to_live_run(wconn, host, name, oid)
+                    live_run = store.find_active_run(wconn, host, name)
+                    fields = {
+                        "status": "running",
+                        "message": "Datei ist auf %s. Druckstart kann etwa eine Minute dauern."
+                        % printer_copy["name"],
+                        "host": host,
+                        "phase": "await_print",
+                        "phase_started_at": "now",
+                    }
+                    if live_run:
+                        fields["run_id"] = live_run["id"]
+                    store.update_print_queue(wconn, item_id, fields)
                    self._event(
                        wconn,
                        host,
@@ -276,6 +490,7 @@ class PrintQueueDispatcher:
                    )
                    wconn.commit()
                except GrottiError as exc:
+                    wconn.rollback()
                    store.update_print_queue(
                        wconn,
                        item_id,
@@ -291,6 +506,7 @@ class PrintQueueDispatcher:
                    )
                    wconn.commit()
                except Exception as exc:
+                    wconn.rollback()
                    store.update_print_queue(
                        wconn,
                        item_id,
@@ -313,6 +529,147 @@ class PrintQueueDispatcher:

        self._spawn_worker(item_id, work)

+    def _advance_simple(self, conn, item, printer, live):
+        """Einfach-Druck: running bleiben bis Moonraker fertig/abgebrochen."""
+        phase = (item.get("phase") or "").lower()
+        state = (live.get("state") or "").lower()
+        if phase in ("starting", "await_print"):
+            if state in ("printing", "paused", "heating") or live.get("print_active"):
+                self._clear_terminal_hits(item["id"])
+                store.update_print_queue(
+                    conn,
+                    item["id"],
+                    {
+                        "phase": "print_active",
+                        "phase_started_at": "now",
+                        "message": "Druckt…",
+                    },
+                )
+                return
+            if phase == "await_print" and state == "cancelled":
+                hits = self._terminal_hits(item["id"], "await_cancel")
+                if hits >= AWAIT_CANCEL_HITS:
+                    self._clear_terminal_hits(item["id"])
+                    store.update_print_queue(
+                        conn,
+                        item["id"],
+                        {
+                            "status": "error",
+                            "message": "Druck abgebrochen.",
+                            "phase": "",
+                            "phase_started_at": None,
+                        },
+                    )
+                return
+            if phase == "await_print" and self._print_start_timed_out(item):
+                store.update_print_queue(
+                    conn,
+                    item["id"],
+                    {
+                        "status": "error",
+                        "message": "Druckstart-Timeout: Drucker hat nach %d min nicht angefangen."
+                        % (PRINT_START_TIMEOUT_S // 60),
+                        "phase": "",
+                        "phase_started_at": None,
+                    },
+                )
+                return
+            # complete/standby vom vorherigen Auftrag: noch warten, nicht „Fertig.“
+            return
+        if phase != "print_active":
+            return
+        if state in ("printing", "paused", "heating"):
+            self._clear_terminal_hits(item["id"])
+            return
+        if state == "error":
+            store.update_print_queue(
+                conn,
+                item["id"],
+                {
+                    "status": "error",
+                    "message": (live.get("message") or "Druckerfehler").strip()[:200],
+                    "phase": "",
+                    "phase_started_at": None,
+                },
+            )
+            return
+        # Nur complete = fertig. cancelled/standby erst nach Entprellen.
+        if state == "complete":
+            self._clear_terminal_hits(item["id"])
+            store.update_print_queue(
+                conn,
+                item["id"],
+                {
+                    "status": "done",
+                    "message": "Fertig.",
+                    "phase": "",
+                    "phase_started_at": None,
+                },
+            )
+            self._event(
+                conn,
+                printer["host"],
+                printer["name"],
+                "fertig",
+                "%s fertig: %s" % (printer["name"], item.get("filename") or "Druck"),
+                item.get("filename") or "",
+            )
+            return
+        if state in ("cancelled", "standby"):
+            hits = self._terminal_hits(item["id"], "end")
+            if hits < TERMINAL_CONFIRM_HITS:
+                return
+            live2 = live
+            try:
+                live2 = moonraker.query(printer["host"])
+            except Exception:
+                pass
+            state2 = (live2.get("state") or "").lower()
+            if state2 in ("printing", "paused", "heating") or live2.get("print_active"):
+                self._clear_terminal_hits(item["id"])
+                return
+            self._clear_terminal_hits(item["id"])
+            if state2 == "complete":
+                store.update_print_queue(
+                    conn,
+                    item["id"],
+                    {
+                        "status": "done",
+                        "message": "Fertig.",
+                        "phase": "",
+                        "phase_started_at": None,
+                    },
+                )
+                self._event(
+                    conn,
+                    printer["host"],
+                    printer["name"],
+                    "fertig",
+                    "%s fertig: %s" % (printer["name"], item.get("filename") or "Druck"),
+                    item.get("filename") or "",
+                )
+                return
+            # Echter Abbruch — nicht „Fertig.“ und kein Auto-Retry.
+            store.update_print_queue(
+                conn,
+                item["id"],
+                {
+                    "status": "cancelled",
+                    "message": "Druck abgebrochen.",
+                    "phase": "",
+                    "phase_started_at": None,
+                },
+            )
+            self._event(
+                conn,
+                printer["host"],
+                printer["name"],
+                "abbruch",
+                "%s: Druck abgebrochen (%s)"
+                % (printer["name"], item.get("filename") or "ohne Datei"),
+                item.get("filename") or "",
+            )
+
    def _begin_ablauf(self, conn, item, printer, live):
        try:
            eject.require_kobra_3(printer)
@@ -549,9 +906,31 @@ class PrintQueueDispatcher:
                    live.get("message") or "Druckerfehler während des Drucks.",
                )
                return
-            # Erst weiter, wenn der Job wirklich gelaufen ist — sonst Race
-            # (noch standby/complete vom vorherigen Auftrag).
-            if phase == "print_active" and state in ("complete", "standby"):
+            # Nur complete = Druckende. standby/cancelled entprellen (Filament-Resume).
+            if phase == "print_active" and state == "complete":
+                self._clear_terminal_hits(item["id"])
+                self._next_step(conn, item, printer, live)
+                return
+            if phase == "print_active" and state in ("cancelled", "standby"):
+                hits = self._terminal_hits(item["id"], "ablauf_end")
+                if hits < TERMINAL_CONFIRM_HITS:
+                    return
+                try:
+                    live = moonraker.query(printer["host"])
+                    state = (live.get("state") or "").lower()
+                except Exception:
+                    pass
+                if state in ("printing", "paused", "heating") or live.get("print_active"):
+                    self._clear_terminal_hits(item["id"])
+                    return
+                self._clear_terminal_hits(item["id"])
+                if state == "complete":
+                    self._next_step(conn, item, printer, live)
+                    return
+                if state == "cancelled":
+                    self._fail_ablauf(conn, item, printer, "Druck abgebrochen.")
+                    return
+                # standby nach Entprellen: Job wirklich zu Ende
                self._next_step(conn, item, printer, live)
                return
            # Idle schon während des Drucks verlängern — sonst greift M84/Default zu früh.
@@ -671,23 +1050,31 @@ class PrintQueueDispatcher:
                    )
                    name = (result or {}).get("filename") or ""
                    row = store.get_print_queue_row(wconn, item_id) or item
-                    store.update_print_queue(
-                        wconn,
-                        item_id,
-                        {
-                            "phase": "printing",
-                            "phase_started_at": "now",
-                            "file_id": step_copy["file_id"],
-                            "message": self._ablauf_message(row, "druckt %s" % name),
-                        },
-                    )
+                    if (row.get("status") or "") in ("cancelled", "dismissed"):
+                        try:
+                            moonraker.command(printer_copy["host"], "cancel")
+                        except Exception:
+                            pass
+                        return
+                    fields = {
+                        "phase": "printing",
+                        "phase_started_at": "now",
+                        "file_id": step_copy["file_id"],
+                        "message": self._ablauf_message(row, "druckt %s" % name),
+                    }
+                    live_run = store.find_active_run(wconn, printer_copy["host"], name)
+                    if live_run:
+                        fields["run_id"] = live_run["id"]
+                    store.update_print_queue(wconn, item_id, fields)
                    self._step_event(wconn, row, printer_copy, "druckt %s" % name)
                    wconn.commit()
                except GrottiError as exc:
+                    wconn.rollback()
                    row = store.get_print_queue_row(wconn, item_id) or item
                    self._fail_ablauf(wconn, row, printer_copy, exc.message)
                    wconn.commit()
                except Exception as exc:
+                    wconn.rollback()
                    row = store.get_print_queue_row(wconn, item_id) or item
                    self._fail_ablauf(wconn, row, printer_copy, str(exc) or "Druckstart fehlgeschlagen.")
                    wconn.commit()
@@ -742,42 +1129,64 @@ class PrintQueueDispatcher:
        return state

    def _start_cool_step(self, conn, item, printer, step):
+        # Park (bis 60 s G-code) läuft im Worker, damit tick() nicht blockiert.
        host = printer["host"]
        cool = eject.normalize_cool(step)
-        try:
-            moonraker.gcode_script(host, eject.cool_script(cool), timeout=30)
-            # Idle zuerst verlängern, dann Park (sonst Stepper aus → must home).
-            try:
-                moonraker.gcode_script(host, eject.idle_timeout_script(cool), timeout=15)
-            except Exception:
-                pass
-            park = self._try_cool_park(host, item["id"], force=True)
-            self._keepalive[item["id"]] = time.monotonic()
-            park_note = ""
-            if not park["ok"] and park["error"]:
-                park_note = " — Mitte fehlgeschlagen: %s" % park["error"]
-            elif park["ok"]:
-                park_note = " · Düse Mitte"
-            store.update_print_queue(
-                conn,
-                item["id"],
-                {
-                    "phase": "cooling",
-                    "phase_started_at": "now",
-                    "message": self._ablauf_message(
-                        item,
-                        "kühlt ab (Bett ≤ %.0f °C, Düse ≤ %.0f °C)%s"
-                        % (cool["bed_max"], cool["nozzle_max"], park_note),
-                    ),
-                },
-            )
-            self._step_event(
-                conn, item, printer,
-                "kühlt ab bis Bett ≤ %.0f °C, Düse ≤ %.0f °C%s"
-                % (cool["bed_max"], cool["nozzle_max"], park_note),
-            )
-        except Exception as exc:
-            self._fail_ablauf(conn, item, printer, "Abkühlen: %s" % exc)
+        item_id = item["id"]
+        printer_copy = dict(printer)
+        item_copy = dict(item)
+
+        def work():
+            with connect(self.database_url) as wconn:
+                try:
+                    moonraker.gcode_script(host, eject.cool_script(cool), timeout=30)
+                    try:
+                        moonraker.gcode_script(host, eject.idle_timeout_script(cool), timeout=15)
+                    except Exception:
+                        pass
+                    park = self._try_cool_park(host, item_id, force=True)
+                    self._keepalive[item_id] = time.monotonic()
+                    park_note = ""
+                    if not park["ok"] and park["error"]:
+                        park_note = " — Mitte fehlgeschlagen: %s" % park["error"]
+                    elif park["ok"]:
+                        park_note = " · Düse Mitte"
+                    row = store.get_print_queue_row(wconn, item_id) or item_copy
+                    store.update_print_queue(
+                        wconn,
+                        item_id,
+                        {
+                            "message": self._ablauf_message(row, "kühlt%s" % park_note),
+                            "phase": "cooling",
+                            "phase_started_at": datetime.now(timezone.utc),
+                        },
+                    )
+                    wconn.commit()
+                except GrottiError as exc:
+                    self._fail_ablauf(wconn, item_copy, printer_copy, "Abkühlen: %s" % exc.message)
+                    wconn.commit()
+                except Exception as exc:
+                    self._fail_ablauf(wconn, item_copy, printer_copy, "Abkühlen: %s" % exc)
+                    wconn.commit()
+
+        store.update_print_queue(
+            conn,
+            item_id,
+            {
+                "message": self._ablauf_message(
+                    item,
+                    "kühlt ab (Bett ≤ %.0f °C, Düse ≤ %.0f °C)"
+                    % (cool["bed_max"], cool["nozzle_max"]),
+                ),
+                "phase": "cooling",
+                "phase_started_at": datetime.now(timezone.utc),
+            },
+        )
+        self._step_event(
+            conn, item, printer,
+            "kühlt ab bis Bett ≤ %.0f °C, Düse ≤ %.0f °C" % (cool["bed_max"], cool["nozzle_max"]),
+        )
+        self._spawn_worker(item_id, work)

    def _poll_cool(self, conn, item, printer, live, step):
        cool = eject.normalize_cool(step)
@@ -908,14 +1317,17 @@ class PrintQueueDispatcher:
                    self._next_step(wconn, row, printer_copy, {"state": "standby", "ok": True})
                    wconn.commit()
                except GrottiError as exc:
+                    wconn.rollback()
                    row = store.get_print_queue_row(wconn, item_id) or item
                    self._fail_ablauf(wconn, row, printer_copy, exc.message)
                    wconn.commit()
                except moonraker.PrinterError as exc:
+                    wconn.rollback()
                    row = store.get_print_queue_row(wconn, item_id) or item
                    self._fail_ablauf(wconn, row, printer_copy, eject.explain_printer_error(exc.message))
                    wconn.commit()
                except Exception as exc:
+                    wconn.rollback()
                    row = store.get_print_queue_row(wconn, item_id) or item
                    self._fail_ablauf(wconn, row, printer_copy, "Schieben: %s" % exc)
                    wconn.commit()
@@ -1013,14 +1425,17 @@ class PrintQueueDispatcher:
                    self._next_step(wconn, row, printer_copy, {"state": "standby", "ok": True})
                    wconn.commit()
                except GrottiError as exc:
+                    wconn.rollback()
                    row = store.get_print_queue_row(wconn, item_id) or item
                    self._fail_ablauf(wconn, row, printer_copy, exc.message)
                    wconn.commit()
                except moonraker.PrinterError as exc:
+                    wconn.rollback()
                    row = store.get_print_queue_row(wconn, item_id) or item
                    self._fail_ablauf(wconn, row, printer_copy, eject.explain_printer_error(exc.message))
                    wconn.commit()
                except Exception as exc:
+                    wconn.rollback()
                    row = store.get_print_queue_row(wconn, item_id) or item
                    self._fail_ablauf(wconn, row, printer_copy, "Tasten: %s" % exc)
                    wconn.commit()
@@ -1121,6 +1536,16 @@ class PrintQueueDispatcher:
            self._fail_ablauf(conn, item, printer, "Unbekannter Schritt: %s" % kind)

    def _fail_ablauf(self, conn, item, printer, message):
+        if self._try_auto_retry(conn, item, message):
+            self._event(
+                conn,
+                printer["host"],
+                printer["name"],
+                "queue",
+                "%s Nochmal — %s" % (printer["name"], message),
+                item.get("filename") or "",
+            )
+            return
        store.update_print_queue(
            conn,
            item["id"],
@@ -1,7 +1,5 @@
 """Die Drucker: Familie aus dem Namen, die Liste selbst liegt in PostgreSQL."""

-import json
-
 FAMILY_LABELS = {"kobra_s1": "Kobra S1", "kobra_3": "Kobra 3"}


@@ -21,24 +19,3 @@ def family_from_text(text):
    if "kobra 3" in low or "kobra3" in low:
        return "kobra_3"
    return ""
-
-
-def load_printers(path):
-    rows = json.loads(path.read_text(encoding="utf-8"))
-    printers = []
-    for row in rows:
-        family = row.get("family") or family_from_name(row["name"])
-        printers.append({
-            "name": row["name"],
-            "host": row["host"],
-            "family": family,
-            "family_label": FAMILY_LABELS.get(family, family),
-        })
-    return printers
-
-
-def printer_by_host(path, host):
-    for printer in load_printers(path):
-        if printer["host"] == host:
-            return printer
-    return None
@@ -1,12 +1,18 @@
+-- Referenz-Schema. Laufende Migrationen liegen in grotti/migrations/*.sql
+-- (001_base.sql entspricht diesem Stand, danach nummerierte Änderungen).
+
 CREATE TABLE IF NOT EXISTS projects (
    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    name text NOT NULL,
    notes text NOT NULL DEFAULT '',
    status text NOT NULL DEFAULT 'idee',
    quote jsonb NOT NULL DEFAULT '{}'::jsonb,
+    folder text NOT NULL DEFAULT '',
    created_at timestamptz NOT NULL DEFAULT now()
 );

+ALTER TABLE projects ADD COLUMN IF NOT EXISTS folder text NOT NULL DEFAULT '';
+
 CREATE TABLE IF NOT EXISTS spools (
    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    name text NOT NULL,
@@ -120,6 +126,7 @@ ALTER TABLE spools ADD COLUMN IF NOT EXISTS material_id bigint REFERENCES materi
 ALTER TABLE spools ADD COLUMN IF NOT EXISTS chargen_nr text;
 ALTER TABLE spools ADD COLUMN IF NOT EXISTS hersteller_charge text NOT NULL DEFAULT '';
 ALTER TABLE spools ADD COLUMN IF NOT EXISTS code text;
+ALTER TABLE spools ADD COLUMN IF NOT EXISTS archived_at timestamptz;

 CREATE UNIQUE INDEX IF NOT EXISTS spools_chargen_nr ON spools (chargen_nr) WHERE chargen_nr IS NOT NULL AND chargen_nr <> '';
 CREATE UNIQUE INDEX IF NOT EXISTS spools_code ON spools (code) WHERE code IS NOT NULL AND code <> '';
@@ -169,6 +176,8 @@ ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS repeat_total integer NOT NULL D
 ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS repeat_done integer NOT NULL DEFAULT 0;
 ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS phase text NOT NULL DEFAULT '';
 ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS phase_started_at timestamptz;
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS retry_count integer NOT NULL DEFAULT 0;
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS wait_reason text NOT NULL DEFAULT '';

 CREATE INDEX IF NOT EXISTS print_queue_waiting ON print_queue (status, priority, id);
 CREATE INDEX IF NOT EXISTS print_queue_running_host ON print_queue (host, status) WHERE status = 'running';
@@ -215,3 +224,155 @@ CREATE TABLE IF NOT EXISTS oauth_identities (
    created_at timestamptz NOT NULL DEFAULT now(),
    UNIQUE (provider, subject)
 );
+
+-- Druckbericht: Soll/Ist, Charge, Live-Fortschritt
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS weight_planned_g double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS weight_used_g double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS weight_source text NOT NULL DEFAULT '';
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS filament_used_mm double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS filament_total_mm double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS progress_last double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS estimated_s double precision NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS chargen_nr text;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS message text NOT NULL DEFAULT '';
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS objects jsonb NOT NULL DEFAULT '[]'::jsonb;
+
+CREATE UNIQUE INDEX IF NOT EXISTS runs_chargen_nr
+    ON runs (chargen_nr) WHERE chargen_nr IS NOT NULL AND chargen_nr <> '';
+
+ALTER TABLE events ADD COLUMN IF NOT EXISTS run_id bigint REFERENCES runs (id) ON DELETE SET NULL;
+CREATE INDEX IF NOT EXISTS events_run ON events (run_id) WHERE run_id IS NOT NULL;
+
+-- Abzug je Spule (Messwert oder Schätzwert)
+CREATE TABLE IF NOT EXISTS run_spools (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    run_id bigint NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    spool_id bigint NOT NULL REFERENCES spools (id) ON DELETE RESTRICT,
+    ace_slot smallint,
+    weight_g double precision NOT NULL DEFAULT 0,
+    weight_planned_g double precision NOT NULL DEFAULT 0,
+    cost double precision NOT NULL DEFAULT 0,
+    is_estimate boolean NOT NULL DEFAULT false,
+    UNIQUE (run_id, spool_id, ace_slot)
+);
+
+CREATE INDEX IF NOT EXISTS run_spools_spool ON run_spools (spool_id);
+CREATE INDEX IF NOT EXISTS run_spools_run ON run_spools (run_id);
+
+-- Abschnitte bei Rollenwechsel mitten im Druck
+CREATE TABLE IF NOT EXISTS run_segments (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    run_id bigint NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    spool_id bigint NOT NULL REFERENCES spools (id) ON DELETE RESTRICT,
+    ace_slot smallint,
+    mm_start double precision NOT NULL DEFAULT 0,
+    mm_end double precision,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    closed_at timestamptz
+);
+
+CREATE INDEX IF NOT EXISTS run_segments_run ON run_segments (run_id);
+CREATE INDEX IF NOT EXISTS run_segments_open
+    ON run_segments (run_id) WHERE mm_end IS NULL;
+
+-- Temperatur / Fortschritt während des Drucks
+CREATE TABLE IF NOT EXISTS run_samples (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    run_id bigint NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    sampled_at timestamptz NOT NULL DEFAULT now(),
+    nozzle double precision,
+    nozzle_target double precision,
+    bed double precision,
+    bed_target double precision,
+    chamber double precision,
+    fan double precision,
+    speed_factor double precision,
+    extrude_factor double precision,
+    layer integer,
+    progress double precision,
+    filament_used_mm double precision,
+    mmu_tool smallint,
+    nozzle_power double precision,
+    bed_power double precision
+);
+
+CREATE INDEX IF NOT EXISTS run_samples_run_time ON run_samples (run_id, sampled_at);
+
+ALTER TABLE run_samples ADD COLUMN IF NOT EXISTS nozzle_power double precision;
+ALTER TABLE run_samples ADD COLUMN IF NOT EXISTS bed_power double precision;
+
+-- Objekt-Chargen für Etiketten
+CREATE TABLE IF NOT EXISTS run_labels (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    run_id bigint NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    object_name text NOT NULL DEFAULT '',
+    chargen_nr text NOT NULL,
+    excluded boolean NOT NULL DEFAULT false,
+    UNIQUE (run_id, object_name)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS run_labels_chargen ON run_labels (chargen_nr);
+
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS verdict_reason text NOT NULL DEFAULT '';
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS pieces_ok int NOT NULL DEFAULT 0;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS pieces_bad int NOT NULL DEFAULT 0;
+
+CREATE TABLE IF NOT EXISTS maintenance_parts (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    printer_host text NOT NULL,
+    part_key text NOT NULL,
+    label text NOT NULL DEFAULT '',
+    installed_at timestamptz NOT NULL DEFAULT now(),
+    life_hours double precision NOT NULL DEFAULT 0,
+    life_meters double precision NOT NULL DEFAULT 0,
+    note text NOT NULL DEFAULT ''
+);
+
+CREATE TABLE IF NOT EXISTS maintenance_log (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    printer_host text NOT NULL,
+    part_key text NOT NULL,
+    event text NOT NULL DEFAULT '',
+    hours_at double precision NOT NULL DEFAULT 0,
+    meters_at double precision NOT NULL DEFAULT 0,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    note text NOT NULL DEFAULT ''
+);
+
+ALTER TABLE printers ADD COLUMN IF NOT EXISTS start_window jsonb NOT NULL DEFAULT '{}'::jsonb;
+
+CREATE TABLE IF NOT EXISTS customers (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    name text NOT NULL,
+    email text NOT NULL DEFAULT '',
+    notes text NOT NULL DEFAULT '',
+    created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS orders (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    customer_id bigint REFERENCES customers (id) ON DELETE SET NULL,
+    title text NOT NULL,
+    status text NOT NULL DEFAULT 'idee',
+    due_at date,
+    notes text NOT NULL DEFAULT '',
+    quote jsonb NOT NULL DEFAULT '{}'::jsonb,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS order_items (
+    id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    order_id bigint NOT NULL REFERENCES orders (id) ON DELETE CASCADE,
+    file_id bigint REFERENCES files (id) ON DELETE SET NULL,
+    qty int NOT NULL DEFAULT 1,
+    unit_price double precision NOT NULL DEFAULT 0,
+    material_type text NOT NULL DEFAULT '',
+    color text NOT NULL DEFAULT '',
+    done_ok int NOT NULL DEFAULT 0,
+    done_bad int NOT NULL DEFAULT 0,
+    note text NOT NULL DEFAULT ''
+);
+
+ALTER TABLE print_queue ADD COLUMN IF NOT EXISTS order_item_id bigint REFERENCES order_items (id) ON DELETE SET NULL;
+ALTER TABLE runs ADD COLUMN IF NOT EXISTS order_item_id bigint REFERENCES order_items (id) ON DELETE SET NULL;
@@ -11,18 +11,26 @@ from queue import Empty, Queue
 from grotti import jobs
 from grotti.db import connect
 from grotti.errors import GrottiError
+from grotti.events_bus import publish as publish_live


 class SendQueue:
    def __init__(self, database_url, cfg, workers=4):
        self.database_url = database_url
        self.cfg = cfg
+        self._workers_n = max(1, int(workers))
        self._lock = threading.Lock()
        self._pending = Queue()
        self._jobs = {}
        self._order = deque(maxlen=60)
        self._threads = []
-        for index in range(max(1, int(workers))):
+        self._stop = threading.Event()
+
+    def start(self):
+        if self._threads:
+            return
+        self._stop.clear()
+        for index in range(self._workers_n):
            thread = threading.Thread(
                target=self._worker,
                name="grotti-send-queue-%s" % (index + 1),
@@ -31,6 +39,14 @@ class SendQueue:
            thread.start()
            self._threads.append(thread)

+    def stop(self):
+        self._stop.set()
+        for _ in self._threads:
+            try:
+                self._pending.put_nowait(None)
+            except Exception:
+                pass
+
    def enqueue(
        self,
        conn,
@@ -82,9 +98,14 @@ class SendQueue:
        want_level = bool(bed_leveling)
        created = []
        for host in unique:
-            printer, row, chosen = jobs.prepare_send(conn, file_id, host, True, override, spool_id)
+            # Mapping zuerst, damit Materialprüfung die ACE-Spulen sieht.
+            mapping = ace_maps.get(host) or []
+            printer, row, chosen = jobs.prepare_send(
+                conn, file_id, host, True, override, spool_id, ace_map=mapping
+            )
+            if not mapping:
+                mapping = ace_maps.get(printer["name"]) or []
            job_id = uuid.uuid4().hex[:12]
-            mapping = ace_maps.get(host) or ace_maps.get(printer["name"]) or []
            job = {
                "id": job_id,
                "status": "pending",
@@ -141,13 +162,16 @@ class SendQueue:
                return
            job.update(fields)
            job["updated_at"] = time.time()
+        publish_live("senden", {})

    def _worker(self):
-        while True:
+        while not self._stop.is_set():
            try:
                item = self._pending.get(timeout=1)
            except Empty:
                continue
+            if item is None:
+                break
            self._run(item)

    def _run(self, item):
@@ -0,0 +1,72 @@
+"""Start-Zeitfenster pro Drucker (Nachtdruck)."""
+
+from __future__ import annotations
+
+from datetime import datetime, time, timedelta
+
+
+def _parse_hm(text):
+    text = str(text or "").strip()
+    if not text or ":" not in text:
+        return None
+    parts = text.split(":", 1)
+    try:
+        h, m = int(parts[0]), int(parts[1])
+    except (TypeError, ValueError):
+        return None
+    if not (0 <= h <= 23 and 0 <= m <= 59):
+        return None
+    return time(h, m)
+
+
+def _in_segment(now_t, start_t, end_t):
+    if start_t <= end_t:
+        return start_t <= now_t <= end_t
+    return now_t >= start_t or now_t <= end_t
+
+
+def allowed_now(start_window, now=None):
+    """True wenn kein Fenster gesetzt oder die aktuelle Uhrzeit erlaubt ist."""
+    window = start_window or {}
+    if not isinstance(window, dict):
+        return True
+    allowed = window.get("allowed")
+    if not allowed:
+        return True
+    if not isinstance(allowed, list):
+        return True
+    now_dt = now if isinstance(now, datetime) else datetime.now().astimezone()
+    now_t = now_dt.timetz().replace(tzinfo=None)
+    for entry in allowed:
+        if not isinstance(entry, dict):
+            continue
+        start_t = _parse_hm(entry.get("from"))
+        end_t = _parse_hm(entry.get("to"))
+        if start_t is None or end_t is None:
+            continue
+        if _in_segment(now_t, start_t, end_t):
+            return True
+    return False
+
+
+def overnight_max_hours(start_window):
+    window = start_window or {}
+    if not isinstance(window, dict):
+        return None
+    try:
+        val = float(window.get("max_hours_overnight") or 0)
+    except (TypeError, ValueError):
+        return None
+    return val if val > 0 else None
+
+
+def job_fits_overnight(start_window, estimated_s, now=None):
+    """Optional: Job darf max_hours_overnight nicht überschreiten (nur wenn gesetzt)."""
+    max_h = overnight_max_hours(start_window)
+    if max_h is None:
+        return True
+    if not estimated_s or float(estimated_s) <= 0:
+        return True
+    if allowed_now(start_window, now=now):
+        return float(estimated_s) <= max_h * 3600
+    return True
@@ -8,8 +8,8 @@ MOVE = re.compile(r"^(?:G0|G00|G1|G01)\b(.*)$", re.IGNORECASE)
 # Auch E.39 / Z.6 ohne führende Null (Anycubic/Prusa-Stil)
 AXIS = re.compile(r"([XYZE])\s*(-?\d*\.?\d+)", re.IGNORECASE)

-# Cache-/Viewer-Version: Segment-IDs, kein Sehnen-Thinning
-TOOLPATH_VERSION = 5
+# Cache-/Viewer-Version: ganze Z-Höhen dicht behalten (keine gesprenkelten Stichproben)
+TOOLPATH_VERSION = 8


 def _gcode_text(path: Path) -> str:
@@ -28,48 +28,89 @@ def _gcode_text(path: Path) -> str:
    return path.read_text(encoding="utf-8", errors="replace")


+def _z_key(z):
+    return round(float(z), 2)
+
+
 def _thin_points(points, layer_breaks, max_points):
-    """Extrusions-Segmente stichprobenartig behalten — nie Endpunkte einer Bahn
-    weglassen und die Nachbarn verbinden (sonst Sehnen statt Infill)."""
+    """Pfad kürzen, ohne Wände zu sprenkeln.
+
+    Strategie: ganze Z-Höhen (Druckschichten) vollständig behalten und nur
+    ganze Höhen weglassen. Stichproben entlang der Bahn erzeugen Lücken.
+    """
    if len(points) <= max_points:
        return points, layer_breaks

-    extrude_ends = [i for i in range(1, len(points)) if points[i][3]]
-    keep = {0, len(points) - 1}
-    for break_i in layer_breaks:
-        keep.add(max(0, min(len(points) - 1, break_i)))
-        if break_i > 0:
-            keep.add(break_i - 1)
+    # Nur Z-Höhen mit Extrusion — Z-Hops allein zählen nicht
+    z_order = []
+    seen = set()
+    for point in points:
+        if not point[3]:
+            continue
+        key = _z_key(point[2])
+        if key not in seen:
+            seen.add(key)
+            z_order.append(key)
+    if not z_order:
+        return points[:max_points], [0]

-    # Budget für Segment-Endpunkte (jedes Segment braucht 2 Indizes, viele teilen sich)
-    target_segs = max(2000, max_points // 2)
-    step = max(1, (len(extrude_ends) + target_segs - 1) // target_segs)
-    for j, end_i in enumerate(extrude_ends):
-        if j % step == 0:
+    def keep_for_zs(keep_zs):
+        keep = {0, len(points) - 1}
+        for i, point in enumerate(points):
+            if _z_key(point[2]) in keep_zs:
+                keep.add(i)
+                if i > 0:
+                    keep.add(i - 1)
+        return sorted(keep)
+
+    # So viele Höhen wie ins Budget passen (Schätzung über mittlere Punkte/Höhe)
+    per_z = max(1, len(points) // max(1, len(z_order)))
+    max_zs = max(2, min(len(z_order), max_points // per_z))
+    stride = max(1, (len(z_order) + max_zs - 1) // max_zs)
+
+    def pick_zs(step):
+        chosen = {z_order[0], z_order[-1]}
+        for i in range(0, len(z_order), step):
+            chosen.add(z_order[i])
+        return chosen
+
+    step = stride
+    ordered = keep_for_zs(pick_zs(step))
+    while len(ordered) > max_points and step < len(z_order):
+        step += 1
+        ordered = keep_for_zs(pick_zs(step))
+
+    # Immer noch zu groß: innerhalb behaltener Höhen jedes n-te Extrusionssegment
+    if len(ordered) > max_points:
+        keep_zs = pick_zs(step)
+        segs = [
+            i
+            for i in range(1, len(points))
+            if points[i][3] and _z_key(points[i][2]) in keep_zs
+        ]
+        budget = max(1, (max_points - 4) // 2)
+        seg_step = max(1, (len(segs) + budget - 1) // budget)
+        keep = {0, len(points) - 1}
+        for end_i in segs[::seg_step]:
            keep.add(end_i - 1)
            keep.add(end_i)
-
-    ordered = sorted(keep)
-    # Falls immer noch zu groß: Segmente grober
-    if len(ordered) > max_points:
-        step2 = max(1, (len(ordered) + max_points - 1) // max_points)
-        ordered = ordered[::step2]
-        if ordered[-1] != len(points) - 1:
-            ordered.append(len(points) - 1)
+        ordered = sorted(keep)

    index_map = {old: new for new, old in enumerate(ordered)}
    kept = [points[i] for i in ordered]
-    new_breaks = sorted({
-        index_map[b]
-        for b in layer_breaks
-        if b in index_map
-    })
+    new_breaks = []
+    last_z = None
+    for new_i, point in enumerate(kept):
+        z = _z_key(point[2])
+        if last_z is None or abs(z - last_z) > 0.01:
+            new_breaks.append(new_i)
+            last_z = z
    if not new_breaks:
        new_breaks = [0]
    return kept, new_breaks


-def build_toolpath(path: Path, max_points=120000):
+def build_toolpath(path: Path, max_points=220000):
    text = _gcode_text(path)
    if not text:
        return {
@@ -0,0 +1,172 @@
+"""Ist-Gramm aus Moonraker-Filamentzählern und Spulenanteilen."""
+
+from __future__ import annotations
+
+
+def as_float(value, default=0.0):
+    if value is None or value is False:
+        return float(default)
+    if isinstance(value, bool):
+        return float(default)
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        try:
+            return float(value.replace(",", ".").strip())
+        except ValueError:
+            return float(default)
+    if isinstance(value, list):
+        return sum(as_float(item) for item in value)
+    return float(default)
+
+
+def weight_list(metadata):
+    """Gramm je Farbe aus filament_weight_total (Zahl oder Liste)."""
+    raw = (metadata or {}).get("filament_weight_total")
+    if isinstance(raw, list):
+        return [as_float(item) for item in raw]
+    total = as_float(raw)
+    return [total] if total > 0 else []
+
+
+def weight_sum(metadata):
+    return sum(weight_list(metadata))
+
+
+def filament_total_mm(metadata, job=None):
+    raw = (metadata or {}).get("filament_total")
+    if raw in (None, "", [], 0, 0.0) and isinstance(job, dict):
+        raw = job.get("filament_total")
+    if isinstance(raw, list):
+        return sum(as_float(item) for item in raw)
+    return as_float(raw)
+
+
+def filament_used_mm(job):
+    if not isinstance(job, dict):
+        return 0.0
+    return as_float(job.get("filament_used"))
+
+
+def planned_shares(metadata, ace_map, target_count):
+    """Geplante Gramm je Ziel-Spule. Index entspricht targets-Reihenfolge."""
+    weights = weight_list(metadata)
+    mapping = ace_map if isinstance(ace_map, list) else []
+    if weights and mapping and len(weights) >= len(mapping) and target_count == len(mapping):
+        paints = []
+        for item in mapping:
+            try:
+                paints.append(int(item.get("paint_index")))
+            except (TypeError, ValueError):
+                paints.append(-1)
+        # Nur bei dichter 0…n−1-Map paint_index = Gewichtsindex; sonst Map-Reihenfolge
+        # (Bambu/Anycubic oft T1+T10 bei zwei kompakten Gewichten).
+        dense = sorted(paints) == list(range(len(paints))) and all(
+            0 <= paint < len(weights) for paint in paints
+        )
+        shares = []
+        for order, paint in enumerate(paints):
+            if dense:
+                shares.append(weights[paint])
+            elif order < len(weights):
+                shares.append(weights[order])
+            else:
+                shares.append(0.0)
+        if sum(shares) > 0:
+            return shares
+    if weights and target_count == len(weights):
+        return list(weights)
+    total = sum(weights) if weights else 0.0
+    if target_count <= 0:
+        return []
+    if total <= 0:
+        return [0.0] * target_count
+    each = total / target_count
+    return [each] * target_count
+
+
+def resolve_used_grams(planned_g, used_mm, total_mm, progress, state, duration_s):
+    """
+    Ist-Gramm und Herkunft.
+    measured = filament_used, estimate = Fortschritt oder Soll, none = nichts.
+    """
+    planned = max(0.0, as_float(planned_g))
+    used = max(0.0, as_float(used_mm))
+    total = max(0.0, as_float(total_mm))
+    prog = max(0.0, min(1.0, as_float(progress)))
+    duration = max(0.0, as_float(duration_s))
+    terminal_abort = state in ("cancelled", "error", "interrupted")
+
+    if used > 0.5 and total > 0:
+        grams = planned * (used / total) if planned > 0 else 0.0
+        if grams <= 0 and used > 0.5:
+            # Länge ohne Gewicht: grob 1.24 g/cm³ · 1.75 mm → ~3 g/m
+            grams = used * 0.003
+        return max(0.0, grams), "measured"
+
+    if used > 0.5 and planned > 0 and total <= 0:
+        # Millimeter da, Gesamtlänge fehlt — Fortschritt oder Dauer helfen nicht
+        return used * 0.003, "estimate"
+
+    if terminal_abort and used <= 0.5:
+        if prog > 0.005 and planned > 0:
+            return planned * prog, "estimate"
+        return 0.0, "none"
+
+    if planned > 0:
+        if prog > 0.005 and prog < 0.995 and state != "completed":
+            return planned * prog, "estimate"
+        return planned, "estimate" if state == "completed" else "none"
+
+    return 0.0, "none"
+
+
+def split_used(used_g, planned_shares_list, multi):
+    """
+    Ist-Gramm auf Spulen verteilen.
+    multi=True → Anteile sind Schätzwerte, Summe bleibt used_g.
+    """
+    used = max(0.0, as_float(used_g))
+    shares = [max(0.0, as_float(s)) for s in (planned_shares_list or [])]
+    if not shares:
+        return [], False
+    total_plan = sum(shares)
+    if total_plan <= 0:
+        each = used / len(shares)
+        parts = [each] * len(shares)
+    else:
+        parts = [used * (share / total_plan) for share in shares]
+    is_estimate = bool(multi) and len(shares) > 1
+    return parts, is_estimate
+
+
+def segment_deltas(segments, final_mm):
+    """
+    Abschnitte mit mm_start/mm_end → Delta-mm je (spool_id, ace_slot).
+    Offene Abschnitte schließen auf final_mm.
+    """
+    end = max(0.0, as_float(final_mm))
+    totals = {}
+    order = []
+    for seg in segments or []:
+        start = max(0.0, as_float(seg.get("mm_start")))
+        raw_end = seg.get("mm_end")
+        stop = end if raw_end is None else max(0.0, as_float(raw_end))
+        delta = max(0.0, stop - start)
+        key = (seg.get("spool_id"), seg.get("ace_slot"))
+        if key not in totals:
+            totals[key] = 0.0
+            order.append(key)
+        totals[key] += delta
+    return [(key[0], key[1], totals[key]) for key in order]
+
+
+def grams_from_mm(delta_mm, total_mm, planned_g):
+    delta = max(0.0, as_float(delta_mm))
+    total = max(0.0, as_float(total_mm))
+    planned = max(0.0, as_float(planned_g))
+    if delta <= 0:
+        return 0.0
+    if total > 0 and planned > 0:
+        return planned * (delta / total)
+    return delta * 0.003
@@ -0,0 +1,33 @@
+"""Urteil und Ausschuss-Gründe beim Abräumen."""
+
+VERDICT_REASONS = frozenset({
+    "haftung",
+    "warping",
+    "spaghetti",
+    "layer_shift",
+    "verstopfung",
+    "farbe",
+    "sonstiges",
+})
+
+
+def normalize_abraeumen_verdict(verdict, verdict_reason, pieces_ok, pieces_bad):
+    v = (verdict or "").strip().lower()
+    if not v:
+        v = "gut"
+    if v not in ("gut", "ausschuss"):
+        raise ValueError("Urteil muss gut oder ausschuss sein.")
+    reason = (verdict_reason or "").strip().lower()
+    if v == "gut":
+        reason = ""
+        pieces_bad = 0
+    elif reason and reason not in VERDICT_REASONS:
+        raise ValueError("Unbekannter Ausschuss-Grund.")
+    try:
+        ok_n = max(0, int(pieces_ok or 0))
+        bad_n = max(0, int(pieces_bad or 0))
+    except (TypeError, ValueError) as exc:
+        raise ValueError("Stückzahlen müssen ganze Zahlen sein.") from exc
+    if v == "ausschuss" and bad_n <= 0 and ok_n <= 0:
+        bad_n = 1
+    return v, reason, ok_n, bad_n
@@ -1,3 +1,3 @@
 """Version von Grotti (SemVer). Bei jeder Änderung CHANGELOG.md mitführen."""

-__version__ = "2.2.0"
+__version__ = "3.6.0"
@@ -4,10 +4,32 @@ from __future__ import annotations

 import threading
 import time
+from datetime import datetime, timezone

-from grotti import moonraker, notify, store
+from grotti import jobs, logutil, moonraker, notify, store, usage
+from grotti.events_bus import publish as publish_live
 from grotti.db import connect

+log = logutil.get("grotti.watcher")
+
+SAMPLE_EVERY_S = 30
+SAMPLE_HEAT_S = 10
+
+
+def contact_gap_keeps_run(prev_filename, next_filename, next_state):
+    """Nach einem Kontaktverlust bleibt der Lauf, solange kein anderer Auftrag läuft.
+
+    Ein Timeout ist kein Druckende. Ohne Dateiname gibt es keinen Beweis
+    für einen Wechsel, der offene Lauf bleibt.
+    """
+    if next_state not in ("printing", "paused"):
+        return False
+    prev_filename = prev_filename or ""
+    next_filename = next_filename or ""
+    if not prev_filename or not next_filename:
+        return True
+    return prev_filename == next_filename
+

 class StateWatcher:
    def __init__(self, database_url, cfg, interval=10):
@@ -16,11 +38,13 @@ class StateWatcher:
        self.interval = max(5, int(interval))
        self._prev = {}
        self._offline_hits = {}
+        self._cancel_hits = {}
        self.latest = []
        self._lock = threading.Lock()
        self._updated_at = 0.0
        self._stop = threading.Event()
        self._thread = None
+        self._last_sample = {}

    def start(self):
        if self._thread and self._thread.is_alive():
@@ -53,22 +77,25 @@ class StateWatcher:
            try:
                self.tick()
            except Exception as exc:
-                print("Watcher: %s" % exc, flush=True)
+                log.warning("Watcher: %s", exc)
            self._stop.wait(self.interval)

    def tick(self):
-        with connect(self.database_url) as conn:
-            printers = store.list_printers(conn)
-            if not printers:
+        try:
+            with connect(self.database_url) as conn:
+                printers = store.list_printers(conn)
+                if not printers:
+                    conn.commit()
+                    return
+                lives = moonraker.snapshot(printers)
+                with self._lock:
+                    self.latest = lives
+                    self._updated_at = time.monotonic()
+                for live in lives:
+                    self._one(conn, live)
                conn.commit()
-                return
-            lives = moonraker.snapshot(printers)
-            with self._lock:
-                self.latest = lives
-                self._updated_at = time.monotonic()
-            for live in lives:
-                self._one(conn, live)
-            conn.commit()
+        finally:
+            publish_live("drucker", {"at": datetime.now(timezone.utc).isoformat()})

    def _one(self, conn, live):
        host = live.get("host") or ""
@@ -79,24 +106,109 @@ class StateWatcher:
        prev = self._prev.get(host) or {}
        prev_state = (prev.get("state") or "").lower()
        prev_offline = bool(prev.get("offline"))
+        run_id = None

        if offline:
            hits = self._offline_hits.get(host, 0) + 1
            self._offline_hits[host] = hits
-            if hits >= 2 and not prev_offline:
+            # Ein Aussetzer ist noch kein Offline. Erst der zweite Poll.
+            if hits < 2:
+                return
+            if not prev_offline:
                self._emit(conn, host, name, "offline", "%s ist offline." % name, filename)
-            self._prev[host] = {"state": "offline", "offline": True, "filename": filename}
+            # Kontakt weg ist kein Druckende. Der letzte echte Zustand bleibt
+            # gemerkt, damit fertig/Abbruch/Fehler beim nächsten Poll greifen.
+            remembered = prev_state if prev_state and prev_state != "offline" else ""
+            self._prev[host] = {
+                "state": remembered,
+                "offline": True,
+                "heating": bool(prev.get("heating")),
+                "filename": prev.get("filename") or filename or "",
+                "spool_warn": bool(prev.get("spool_warn")) if remembered == "printing" else False,
+                "run_id": prev.get("run_id"),
+            }
            return

        self._offline_hits[host] = 0
+        file_changed = False
+        if prev_offline and state in ("printing", "paused"):
+            file_changed = self._release_replaced_run(conn, host, name, filename)
+        starting = (
+            (
+                bool(prev_state)
+                and prev_state not in ("printing", "paused")
+                and state == "printing"
+            )
+            or (file_changed and state == "printing")
+        )
+        if starting:
+            # Aufheiz-Proben behalten: Live-Lauf gleicher Datei nicht verwerfen
+            keep = None
+            existing = store.find_live_run(conn, host)
+            if existing:
+                same = (
+                    not filename
+                    or not existing.get("filename")
+                    or existing.get("filename") == filename
+                )
+                if same:
+                    keep = existing["id"]
+                    if filename and existing.get("filename") != filename:
+                        conn.execute(
+                            "UPDATE runs SET filename = %s WHERE id = %s",
+                            (filename, keep),
+                        )
+            store.abandon_live_runs(conn, host, keep_id=keep)
+        sample_now = self._should_sample(conn, host, live, state)
+        heating = sample_now and state not in ("printing", "paused")
+        if sample_now:
+            force = starting or (heating and not prev.get("heating"))
+            run = self._track_print(conn, host, name, filename, live, state, force_sample=force)
+            run_id = run["id"] if run else None
+            if run_id:
+                store.set_printer_active_run(conn, host, run_id)
+
+        if state not in ("cancelled", "standby"):
+            self._cancel_hits[host] = 0
+
        if prev_offline:
-            self._emit(conn, host, name, "offline", "%s ist wieder erreichbar." % name, filename)
-        elif prev_state and prev_state not in ("printing", "paused") and state == "printing":
-            self._emit(conn, host, name, "start", "%s druckt %s" % (name, filename or "einen Auftrag"), filename)
+            self._emit(conn, host, name, "offline", "%s ist wieder erreichbar." % name, filename, run_id)
+        if file_changed and state == "printing":
+            self._emit(
+                conn, host, name, "start",
+                "%s druckt %s" % (name, filename or "einen Auftrag"),
+                filename, run_id,
+            )
+            self._ensure_start_segment(conn, host, filename, live, run_id)
+        elif starting:
+            self._emit(
+                conn, host, name, "start",
+                "%s druckt %s" % (name, filename or "einen Auftrag"),
+                filename, run_id,
+            )
+            self._ensure_start_segment(conn, host, filename, live, run_id)
        elif prev_state == "printing" and state == "paused":
-            self._emit(conn, host, name, "start", "%s pausiert." % name, filename)
+            reason = (live.get("pause_reason") or "").strip()
+            if live.get("filament_empty") or reason:
+                detail = reason or "Filament leer oder gerissen"
+                self._emit(
+                    conn, host, name, "spule",
+                    "%s pausiert — Material nachlegen (%s)." % (name, detail),
+                    filename, run_id,
+                )
+            else:
+                self._emit(conn, host, name, "start", "%s pausiert." % name, filename, run_id)
        elif prev_state == "paused" and state == "printing":
-            self._emit(conn, host, name, "start", "%s druckt weiter." % name, filename)
+            self._emit(conn, host, name, "start", "%s druckt weiter." % name, filename, run_id)
+            try:
+                jobs.sync_history(conn, self.cfg, host=host, watcher_resume=True)
+            except Exception as exc:
+                log.warning("Watcher Abgleich Resume %s: %s", host, exc)
+            # Nach Fold: aktiven History-Lauf weiter tracken.
+            open_run = store.find_active_run(conn, host, filename)
+            if open_run:
+                run_id = open_run["id"]
+                store.set_printer_active_run(conn, host, run_id)
        elif prev_state == "printing" and state == "complete":
            store.set_bed_needs_clear(conn, host, True, filename or "fertig")
            self._emit(
@@ -106,27 +218,75 @@ class StateWatcher:
                "fertig",
                "%s fertig: %s" % (name, filename or "Druck"),
                filename,
+                run_id or (prev.get("run_id")),
            )
-            # Protokoll und Spulenabzug nicht erst nach manuellem Knopf
            try:
-                from grotti import jobs
-
-                jobs.sync_history(conn, self.cfg)
+                jobs.sync_history(conn, self.cfg, host=host)
            except Exception as exc:
-                print("Watcher Abgleich %s: %s" % (host, exc), flush=True)
-        elif prev_state in ("printing", "paused") and state in ("cancelled", "standby"):
-            store.set_bed_needs_clear(conn, host, True, filename or state)
-            self._emit(
-                conn,
-                host,
-                name,
-                "abbruch",
-                "%s: Druck abgebrochen (%s)" % (name, filename or "ohne Datei"),
-                filename,
-            )
+                log.warning("Watcher Abgleich %s: %s", host, exc)
+            # Live schließen ohne Abzug — History bucht; Fallback nach Frist.
+            dangling = store.find_live_run(conn, host)
+            if dangling:
+                store.complete_open_run(conn, dangling["id"], state="completed")
+            store.set_printer_active_run(conn, host, None)
+        elif state in ("cancelled", "standby"):
+            dangling = store.find_live_run(conn, host)
+            from_active = prev_state in ("printing", "paused")
+            recover = bool(dangling) and (prev_offline or not prev_state)
+            hits = self._cancel_hits.get(host, 0) + 1
+            self._cancel_hits[host] = hits
+            # Anycubic flackert kurz cancelled/standby während Pause/Resume —
+            # erst nach 3 Polls aufgeben. Nach Offline-Lücke sofort.
+            need_hits = 1 if recover else 3
+            if (from_active or recover) and hits >= need_hits:
+                file_label = filename or (dangling or {}).get("filename") or state
+                try:
+                    jobs.sync_history(conn, self.cfg, host=host)
+                except Exception as exc:
+                    log.warning("Watcher Abgleich %s: %s", host, exc)
+                # Nach Sync evtl. schon Fortsetzung — dann nicht aufgeben.
+                still = store.find_live_run(conn, host) or store.find_open_history_run(
+                    conn, host, filename or (dangling or {}).get("filename") or ""
+                )
+                if still and (still.get("state") or "") in ("in_progress", "printing", "paused"):
+                    self._cancel_hits[host] = 0
+                    run_id = still["id"]
+                    store.set_printer_active_run(conn, host, run_id)
+                else:
+                    store.set_bed_needs_clear(conn, host, True, file_label)
+                    store.abandon_live_runs(conn, host)
+                    store.set_printer_active_run(conn, host, None)
+                    self._emit(
+                        conn,
+                        host,
+                        name,
+                        "abbruch",
+                        "%s: Druck abgebrochen (%s)" % (
+                            name, file_label if file_label != state else "ohne Datei",
+                        ),
+                        file_label if file_label != state else "",
+                        run_id or prev.get("run_id") or (dangling or {}).get("id"),
+                    )
+            # prev-Zustand behalten, bis die Hits reichen.
+            if hits < 3 and from_active:
+                self._prev[host] = {
+                    "state": prev_state,
+                    "offline": False,
+                    "heating": heating,
+                    "filename": prev.get("filename") or filename,
+                    "spool_warn": bool(prev.get("spool_warn")),
+                    "run_id": run_id or prev.get("run_id"),
+                }
+                return
        elif state == "error" and prev_state != "error":
            if prev_state == "printing" or prev_state == "paused":
                store.set_bed_needs_clear(conn, host, True, filename or "Fehler")
+                try:
+                    jobs.sync_history(conn, self.cfg, host=host)
+                except Exception as exc:
+                    log.warning("Watcher Abgleich %s: %s", host, exc)
+                store.abandon_live_runs(conn, host)
+                store.set_printer_active_run(conn, host, None)
            msg = (live.get("message") or "").strip()
            if not msg or msg.lower() in ("error", "fehler"):
                msg = "Ursache unbekannt — in Mainsail prüfen"
@@ -138,18 +298,33 @@ class StateWatcher:
                "fehler",
                "%s: %s · Heizung aus" % (name, msg),
                filename,
+                run_id or prev.get("run_id"),
            )
        elif state == "error":
-            # Schon im Fehler, Heizer laufen noch → aus
            if (live.get("nozzle_target") or 0) > 0 or (live.get("bed_target") or 0) > 0:
                self._cool_heaters(host)
-        elif state == "complete":
-            known = conn.execute(
-                "SELECT 1 FROM bed_status WHERE host = %s", (host,)
+        elif state == "complete" and (not prev_state or prev_offline):
+            ended = conn.execute(
+                """
+                SELECT ended_at FROM runs
+                WHERE printer_host = %s
+                  AND state IN ('completed', 'cancelled', 'error', 'interrupted')
+                  AND ended_at IS NOT NULL
+                ORDER BY ended_at DESC
+                LIMIT 1
+                """,
+                (host,),
            ).fetchone()
-            if not known:
-                # Erster Stand nach Deploy: fertiger Druck ohne Quittierung
-                store.set_bed_needs_clear(conn, host, True, filename or "fertig")
+            store.ensure_bed_after_print(
+                conn,
+                host,
+                ended_at=ended["ended_at"] if ended else None,
+                message=filename or "fertig",
+            )
+            try:
+                jobs.sync_history(conn, self.cfg, host=host)
+            except Exception as exc:
+                log.warning("Watcher Abgleich %s: %s", host, exc)

        spool_warn = bool(prev.get("spool_warn"))
        if state == "printing" and not spool_warn:
@@ -158,40 +333,227 @@ class StateWatcher:
        self._prev[host] = {
            "state": state,
            "offline": False,
+            "heating": heating,
            "filename": filename,
            "spool_warn": spool_warn if state == "printing" else False,
+            "run_id": run_id or (prev.get("run_id") if state in ("printing", "paused") or heating else None),
        }

+    def _release_replaced_run(self, conn, host, name, filename):
+        """Anderer Auftrag nach der Lücke: den offenen Lauf loslassen.
+
+        History zuerst, damit Proben am echten Job hängen. Bleibt der alte
+        Live-Lauf, wird er beendet ohne Abzug — der History-Abgleich bucht
+        das Filament, sobald der Job da ist.
+        """
+        existing = store.find_live_run(conn, host)
+        if not existing:
+            return False
+        if contact_gap_keeps_run(existing.get("filename") or "", filename, "printing"):
+            return False
+        try:
+            jobs.sync_history(conn, self.cfg)
+        except Exception as exc:
+            log.warning("Watcher Abgleich nach Offline %s: %s", host, exc)
+        existing = store.find_live_run(conn, host)
+        if not existing:
+            return True
+        if contact_gap_keeps_run(existing.get("filename") or "", filename, "printing"):
+            return False
+        label = existing.get("filename") or "ohne Datei"
+        store.abandon_live_runs(conn, host)
+        self._emit(
+            conn,
+            host,
+            name,
+            "abbruch",
+            "%s: Druck unterbrochen (%s)" % (name, label),
+            label,
+            existing["id"],
+        )
+        return True
+
+    def _should_sample(self, conn, host, live, state):
+        """Proben bei Druck/Pause und beim Aufheizen mit Bezug zu einem Auftrag."""
+        if state in ("printing", "paused"):
+            return True
+        if state in ("error", "offline", ""):
+            return False
+        nozzle_t = usage.as_float(live.get("nozzle_target"))
+        bed_t = usage.as_float(live.get("bed_target"))
+        if nozzle_t <= 40 and bed_t <= 30:
+            return False
+        if live.get("filename"):
+            return True
+        if store.running_print_on_host(conn, host):
+            return True
+        return bool(store.find_live_run(conn, host))
+
+    def _track_print(self, conn, host, name, filename, live, state, force_sample=False):
+        if not filename:
+            running = store.running_print_on_host(conn, host)
+            if running:
+                filename = running.get("filename") or ""
+            if not filename:
+                existing = store.find_live_run(conn, host)
+                if existing:
+                    filename = existing.get("filename") or ""
+        if not filename and state not in ("printing", "paused"):
+            return None
+        sent = store.latest_send(conn, host, filename) if filename else None
+        spool_id = (sent or {}).get("spool_id")
+        # Send kann nach Rollenwechsel veraltet sein — aktuelle Rolle am Host bevorzugt
+        spool_id = jobs.resolve_tracking_spool(conn, host, spool_id, ace_map=(sent or {}).get("ace_map"))
+        run = store.ensure_live_run(conn, host, name, filename, spool_id=spool_id)
+        objects = self._merge_objects(run.get("objects"), live.get("exclude"))
+        planned = usage.as_float(live.get("weight"))
+        total_mm = usage.as_float(live.get("filament_total"))
+        used_mm = usage.as_float(live.get("filament_used"))
+        progress = usage.as_float(live.get("progress"))
+        estimated = usage.as_float(live.get("estimated"))
+        store.update_run_progress(conn, run["id"], {
+            "state": "paused" if state == "paused" else "in_progress",
+            "progress_last": progress,
+            "filament_used_mm": used_mm,
+            "filament_total_mm": total_mm,
+            "weight_planned_g": planned,
+            "estimated_s": estimated,
+            "message": (live.get("message") or "") if state == "error" else "",
+            "objects": objects,
+            "duration_s": usage.as_float(live.get("elapsed")),
+        })
+        store.ensure_run_chargen(conn, run["id"])
+        self._maybe_sample(conn, run["id"], live, used_mm, force=force_sample)
+        return store.get_run_row(conn, run["id"])
+
+    def _merge_objects(self, current, exclude):
+        known = {}
+        if isinstance(current, str):
+            try:
+                import json
+                current = json.loads(current)
+            except Exception:
+                current = []
+        for item in current or []:
+            if isinstance(item, dict) and item.get("name"):
+                known[item["name"]] = {
+                    "name": item["name"],
+                    "excluded": bool(item.get("excluded")),
+                }
+        exclude = exclude or {}
+        excluded = set(exclude.get("excluded") or [])
+        for item in exclude.get("objects") or []:
+            name = (item.get("name") if isinstance(item, dict) else str(item)).strip()
+            if not name:
+                continue
+            known[name] = {"name": name, "excluded": name in excluded}
+        for name in excluded:
+            if name not in known:
+                known[name] = {"name": name, "excluded": True}
+        return list(known.values())
+
+    def _heat_gap(self, live):
+        """Abstand Ist↔Soll — während Aufheizen dichter samplen."""
+        gaps = []
+        for key, tkey in (("nozzle", "nozzle_target"), ("bed", "bed_target")):
+            target = usage.as_float(live.get(tkey))
+            if target <= 0:
+                continue
+            gaps.append(abs(usage.as_float(live.get(key)) - target))
+        return max(gaps) if gaps else 0
+
+    def _maybe_sample(self, conn, run_id, live, used_mm, force=False):
+        now = time.monotonic()
+        last = self._last_sample.get(run_id, 0)
+        interval = SAMPLE_HEAT_S if self._heat_gap(live) > 3 else SAMPLE_EVERY_S
+        if not force and now - last < interval:
+            return
+        self._last_sample[run_id] = now
+        store.add_run_sample(conn, run_id, {
+            "sampled_at": datetime.now(timezone.utc),
+            "nozzle": live.get("nozzle"),
+            "nozzle_target": live.get("nozzle_target"),
+            "bed": live.get("bed"),
+            "bed_target": live.get("bed_target"),
+            "chamber": live.get("chamber"),
+            "fan": live.get("fan"),
+            "speed_factor": live.get("speed_factor"),
+            "extrude_factor": live.get("extrude_factor"),
+            "layer": live.get("layer") or 0,
+            "progress": live.get("progress"),
+            "filament_used_mm": used_mm,
+            "mmu_tool": live.get("mmu_tool"),
+            "nozzle_power": live.get("nozzle_power"),
+            "bed_power": live.get("bed_power"),
+        })
+
+    def _ensure_start_segment(self, conn, host, filename, live, run_id):
+        """Nur externe Einzelspule: ein Abschnitt. ACE-Farben ohne Wechsel → Anteil-Split."""
+        if not run_id:
+            return
+        existing = store.list_run_segments(conn, run_id)
+        if existing:
+            return
+        sent = store.latest_send(conn, host, filename) if filename else None
+        ace = (sent or {}).get("ace_map") or []
+        from grotti import acm
+
+        mapping = acm.normalize_mapping(ace) if ace else []
+        if mapping:
+            return
+        used_mm = usage.as_float(live.get("filament_used"))
+        rows = conn.execute(
+            """
+            SELECT id FROM spools
+            WHERE printer_host = %s AND ace_slot IS NULL
+            ORDER BY id LIMIT 1
+            """,
+            (host,),
+        ).fetchone()
+        if rows:
+            store.open_segment(conn, run_id, rows["id"], None, used_mm)
+
    def _cool_heaters(self, host):
        try:
            moonraker.heaters_off(host)
        except Exception as exc:
-            print("Watcher Heizung aus %s: %s" % (host, exc), flush=True)
+            log.warning("Watcher Heizung aus %s: %s", host, exc)

    def _check_spool(self, conn, host, name, filename, live):
        need = float(live.get("weight") or 0)
        if need <= 0 or not filename:
            return False
        sent = store.latest_send(conn, host, filename)
-        spool_id = (sent or {}).get("spool_id")
-        if not spool_id:
+        ace = (sent or {}).get("ace_map") or []
+        from grotti import jobs as grotti_jobs
+
+        at_host = grotti_jobs.resolve_spools_at_host(conn, host, ace)
+        if not at_host:
+            spool_id = (sent or {}).get("spool_id")
+            if spool_id:
+                row = store.get_spool_row(conn, spool_id)
+                if row:
+                    at_host = [row]
+        if not at_host:
            return False
-        spool = store.get_spool_row(conn, spool_id)
-        if not spool:
-            return False
-        left = float(spool["remaining_g"] or 0)
+        left = sum(float(s.get("remaining_g") or 0) for s in at_host)
        if left + 0.5 >= need:
            return False
+        label = " / ".join(s.get("name") or "?" for s in at_host[:3])
        self._emit(
            conn,
            host,
            name,
            "spule",
-            "%s: Spule „%s“ hat nur %.0f g, Druck braucht %.0f g."
-            % (name, spool["name"], left, need),
+            "%s: %s hat nur %.0f g, Druck braucht %.0f g."
+            % (name, label, left, need),
            filename,
        )
        return True

-    def _emit(self, conn, host, printer, kind, message, filename):
-        notify.record(conn, self.cfg, host, printer, kind, message, filename, dedupe_s=60)
+    def _emit(self, conn, host, printer, kind, message, filename, run_id=None):
+        notify.record(
+            conn, self.cfg, host, printer, kind, message, filename,
+            dedupe_s=60, run_id=run_id,
+        )
+        publish_live("ereignis", {})
@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# Baut grotti_<version>_<arch>.deb (auf dem Zielsystem oder arm64-Container).
+# Aufruf aus dem Repo-Root:  bash packaging/build-deb.sh
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT"
+
+if ! command -v dpkg-deb >/dev/null 2>&1; then
+  echo "dpkg-deb fehlt — bitte auf Debian/Raspberry Pi OS bauen." >&2
+  exit 1
+fi
+
+VERSION="$(python3 -c "from grotti.version import __version__; print(__version__)")"
+ARCH="$(dpkg --print-architecture)"
+PKG="grotti_${VERSION}_${ARCH}"
+DIST="$ROOT/packaging/dist"
+STAGE="$DIST/$PKG"
+
+rm -rf "$STAGE"
+mkdir -p "$STAGE/DEBIAN" \
+  "$STAGE/usr/lib/grotti" \
+  "$STAGE/usr/bin" \
+  "$STAGE/etc/grotti" \
+  "$STAGE/lib/systemd/system" \
+  "$STAGE/usr/share/grotti" \
+  "$STAGE/usr/share/doc/grotti" \
+  "$STAGE/var/lib/grotti/data/eingang" \
+  "$STAGE/var/lib/grotti/slice"
+
+rsync -a --delete \
+  --exclude '__pycache__' --exclude '*.pyc' --exclude '.pytest_cache' \
+  "$ROOT/grotti/" "$STAGE/usr/lib/grotti/grotti/"
+rsync -a --delete \
+  --exclude '__pycache__' --exclude '*.pyc' \
+  "$ROOT/web/" "$STAGE/usr/lib/grotti/web/"
+cp "$ROOT/server.py" "$STAGE/usr/lib/grotti/server.py"
+cp "$ROOT/requirements.txt" "$STAGE/usr/lib/grotti/requirements.txt"
+cp "$ROOT/config.example.json" "$STAGE/usr/lib/grotti/config.example.json"
+mkdir -p "$STAGE/usr/lib/grotti/scripts"
+cp "$ROOT/scripts/pfade_umziehen.py" "$STAGE/usr/lib/grotti/scripts/pfade_umziehen.py"
+# Symlink-Pfad für die Anleitung
+mkdir -p "$STAGE/opt/grotti"
+ln -sfn /usr/lib/grotti/scripts "$STAGE/opt/grotti/scripts"
+ln -sfn /usr/lib/grotti/venv "$STAGE/opt/grotti/venv"
+echo '[]' > "$STAGE/usr/lib/grotti/drucker.json"
+cp "$ROOT/packaging/config.pi.json" "$STAGE/usr/share/grotti/config.pi.json"
+cp "$ROOT/packaging/config.pi.json" "$STAGE/etc/grotti/config.json"
+cp "$ROOT/packaging/grotti.service" "$STAGE/lib/systemd/system/grotti.service"
+cp "$ROOT/docs/Anleitung-Installation-Pi.md" "$STAGE/usr/share/doc/grotti/"
+cp "$ROOT/CHANGELOG.md" "$STAGE/usr/share/doc/grotti/changelog"
+gzip -9 -f "$STAGE/usr/share/doc/grotti/changelog"
+
+cat > "$STAGE/usr/bin/grotti" <<'EOF'
+#!/bin/sh
+export GROTTI_CONFIG="${GROTTI_CONFIG:-/etc/grotti/config.json}"
+exec /usr/lib/grotti/venv/bin/python /usr/lib/grotti/server.py "$@"
+EOF
+chmod 755 "$STAGE/usr/bin/grotti"
+
+python3 -m venv "$STAGE/usr/lib/grotti/venv"
+"$STAGE/usr/lib/grotti/venv/bin/pip" install --upgrade pip wheel
+"$STAGE/usr/lib/grotti/venv/bin/pip" install -r "$ROOT/requirements.txt"
+
+SIZE_KB="$(du -sk "$STAGE" | awk '{print $1}')"
+cat > "$STAGE/DEBIAN/control" <<EOF
+Package: grotti
+Version: ${VERSION}
+Section: web
+Priority: optional
+Architecture: ${ARCH}
+Maintainer: Dominic Gundel <[email protected]>
+Depends: python3 (>= 3.11), python3-venv, postgresql, adduser
+Installed-Size: ${SIZE_KB}
+Homepage: https://git.gundel.dev/dg/grotti
+Description: Farm-Manager für Moonraker-Drucker (Kobra 3 / S1)
+ Grotti steuert eine 3D-Drucker-Farm über Moonraker: Wand, Warteschlange,
+ Material, Abläufe und Protokoll. PostgreSQL wird lokal mit eingerichtet.
+EOF
+
+cp "$ROOT/packaging/debian/conffiles" "$STAGE/DEBIAN/conffiles"
+for script in postinst prerm postrm; do
+  cp "$ROOT/packaging/debian/$script" "$STAGE/DEBIAN/$script"
+  chmod 755 "$STAGE/DEBIAN/$script"
+done
+
+dpkg-deb --root-owner-group --build "$STAGE" "$DIST/${PKG}.deb"
+echo "Gebaut: $DIST/${PKG}.deb"
+echo "Install: sudo apt install ./packaging/dist/${PKG}.deb"
+echo "Logs:    journalctl -u grotti -f"
@@ -0,0 +1,56 @@
+{
+  "host": "0.0.0.0",
+  "port": 8770,
+  "data_dir": "/var/lib/grotti/data",
+  "watch_dir": "/var/lib/grotti/slice",
+  "database_url": "postgresql:///grotti?host=/var/run/postgresql",
+  "token": "",
+  "secret_key": "",
+  "fqdn": "",
+  "log_level": "INFO",
+  "auto_queue": true,
+  "auto_retry": true,
+  "oauth": {
+    "enabled": false,
+    "issuer": "",
+    "client_id": "",
+    "client_secret": "",
+    "redirect_uri": ""
+  },
+  "energy": {
+    "watts": 40,
+    "nozzle_watts": 60,
+    "bed_watts": 220,
+    "euro_per_kwh": 0.35,
+    "dryer_watts": 0,
+    "dry_hours": 0,
+    "waste_percent": 0,
+    "utilization": 50,
+    "tariff": {
+      "ht_euro": 0.35,
+      "nt_euro": 0.22,
+      "nt_from": "22:00",
+      "nt_to": "06:00"
+    }
+  },
+  "telegram": {
+    "enabled": false,
+    "bot_token": "",
+    "chat_id": ""
+  },
+  "ntfy": {
+    "enabled": false,
+    "server": "https://ntfy.sh",
+    "topic": "",
+    "token": ""
+  },
+  "alerts": {
+    "fertig": true,
+    "fehler": true,
+    "offline": true,
+    "queue": true,
+    "spule": true,
+    "ablauf": false,
+    "start": false
+  }
+}
@@ -0,0 +1 @@
+/etc/grotti/config.json
@@ -0,0 +1,45 @@
+#!/bin/sh
+set -e
+
+_pg() {
+  if command -v runuser >/dev/null 2>&1; then
+    runuser -u postgres -- "$@"
+  else
+    su -s /bin/sh postgres -c "$*"
+  fi
+}
+
+case "$1" in
+configure)
+  if ! getent passwd grotti >/dev/null; then
+    adduser --system --group --home /var/lib/grotti --no-create-home \
+      --gecos "Grotti farm manager" grotti
+  fi
+
+  mkdir -p /var/lib/grotti/data/eingang /var/lib/grotti/slice /etc/grotti
+  chown -R grotti:grotti /var/lib/grotti
+  chmod 750 /var/lib/grotti
+
+  if [ ! -f /etc/grotti/config.json ]; then
+    cp /usr/share/grotti/config.pi.json /etc/grotti/config.json
+  fi
+  chmod 640 /etc/grotti/config.json
+  chown root:grotti /etc/grotti/config.json
+
+  if getent passwd postgres >/dev/null 2>&1; then
+    _pg psql -tAc "SELECT 1 FROM pg_roles WHERE rolname='grotti'" | grep -q 1 \
+      || _pg createuser -D -R -S grotti || true
+    _pg psql -tAc "SELECT 1 FROM pg_database WHERE datname='grotti'" | grep -q 1 \
+      || _pg createdb -O grotti grotti || true
+    _pg psql -c "GRANT ALL PRIVILEGES ON DATABASE grotti TO grotti;" >/dev/null 2>&1 || true
+  fi
+
+  if command -v systemctl >/dev/null 2>&1; then
+    systemctl daemon-reload || true
+    systemctl enable grotti.service || true
+    systemctl restart grotti.service || true
+  fi
+  ;;
+esac
+
+exit 0
@@ -0,0 +1,19 @@
+#!/bin/sh
+set -e
+
+case "$1" in
+purge)
+  rm -f /etc/grotti/config.json
+  rmdir /etc/grotti 2>/dev/null || true
+  # Daten und DB bleiben absichtlich (Backup). Manuell:
+  #   sudo rm -rf /var/lib/grotti
+  #   sudo -u postgres dropdb grotti; sudo -u postgres dropuser grotti
+  ;;
+remove)
+  if command -v systemctl >/dev/null 2>&1; then
+    systemctl daemon-reload || true
+  fi
+  ;;
+esac
+
+exit 0
@@ -0,0 +1,13 @@
+#!/bin/sh
+set -e
+
+case "$1" in
+remove|upgrade|deconfigure)
+  if command -v systemctl >/dev/null 2>&1; then
+    systemctl stop grotti.service 2>/dev/null || true
+    systemctl disable grotti.service 2>/dev/null || true
+  fi
+  ;;
+esac
+
+exit 0
@@ -0,0 +1,24 @@
+[Unit]
+Description=Grotti Farm-Manager
+Documentation=file:///usr/share/doc/grotti/Anleitung-Installation-Pi.md
+After=network-online.target postgresql.service
+Wants=network-online.target
+Requires=postgresql.service
+
+[Service]
+Type=simple
+User=grotti
+Group=grotti
+WorkingDirectory=/usr/lib/grotti
+Environment=GROTTI_CONFIG=/etc/grotti/config.json
+Environment=PYTHONUNBUFFERED=1
+ExecStart=/usr/lib/grotti/venv/bin/python /usr/lib/grotti/server.py
+Restart=on-failure
+RestartSec=5
+# Logs → journald (journalctl -u grotti -f)
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=grotti
+
+[Install]
+WantedBy=multi-user.target
@@ -0,0 +1,2 @@
+-r requirements.txt
+pytest==9.1.1
Author	SHA1	Message	Date
Dominic Gundel	2b1e36634a	Grotti 3.6.0: Lauf-Identität nach Filament-Pause, robustere Queue, Projekte/Aufträge list-first und API-Polish.	2026-10-25 08:24:24 +01:00
Dominic Gundel	d1eb87ba25	Grotti 3.5.2: Zu wenig Rest blockiert den Start nicht mehr, und ein anlaufender Druck wird nicht als Neustart neu eingereiht.	2026-10-21 21:04:28 +02:00
Dominic Gundel	5166ed6530	Grotti 3.5.1: MCP-Anweisung für Clients, Queue-Strip nur bei Ablauf, Start wartet auf printing.	2026-10-20 21:39:22 +02:00
Dominic Gundel	f034c5e626	Wand: Queue-Strip nur bei Ablauf; Start wartet auf printing statt Falsch-Fertig.	2026-10-19 11:35:59 +02:00
Dominic Gundel	f1f79c2ce2	Grotti 3.5.0: Pagination, Logging, Deb-Paket, Makro-Doku, PLA-Match-Fix.	2026-10-19 11:14:24 +02:00
Dominic Gundel	4ffe1dcfc6	README: Banner, Badges und Community-Screenshots oben.	2026-10-18 22:06:56 +02:00
Dominic Gundel	dd0e7ebc6b	Grotti 3.4.0: Dateien umbenennen, Bedarf/PLA-Match, Pause- und gklib-Fixes.	2026-10-18 21:36:12 +02:00
Dominic Gundel	67a89d1794	Grotti 3.3.0: Projekte mit Ordner, Datei-Löschen/Verschieben, Material-Archiv, UI-Polish.	2026-10-18 20:10:32 +02:00
Dominic Gundel	4ddffbbeb1	Grotti 3.2.0: Jetzt-Liste, Filament-Pause, Strom-Torte, UI-Polish. Jetzt/Topbar und Material-Routing, Pause bei Filament-Ende, Druckbericht mit Stromanteilen, Design- und Kamera-Stream-Polish; Bedarf-Alert-Spam und Platte-belegt-Bugs behoben.	2026-10-18 14:58:32 +02:00
Dominic Gundel	6e59df22e5	Grotti 3.1.0: Bedarf-UI, Zeitfenster, HT/NT, Theme, Chrome-Fixes. Bedarf in Sidebar/Material, Drucker-Zeitfenster und Tarif in Einstellungen, helles Theme; Legacy-Token und /api/drucker entfernt; SSE/SW-Fixes gegen hängende Navigation in Chrome.	2026-10-18 02:20:12 +02:00
Dominic Gundel	8e88efc094	Grotti 3.0.0: Aufträge, Wartung, SSE, Ausschuss-Dialog, UI-Umbau. Migrationen 003–009, Kundaufträge mit Lieferschein, Abräumen mit Urteil, ntfy/Backup/Zeitfenster, Live-Stream und Mobile-Mehr-Menü.	2026-10-18 00:54:51 +02:00
Dominic Gundel	0236278929	Grotti 3.0 Phase 1: Migrationen, Pool, Queue- und Abzug-Fixes. Nummerierte SQL-Migrationen, psycopg-Pool, waitress, hängende Queue-Jobs, sichere History-Abzüge, Chargen-Locks, Upload-/Host-Validierung, ProxyFix.	2026-10-18 00:47:23 +02:00
Dominic Gundel	9e22cebb81	Grotti 2.10.0: Orca-Senden, Slice-Ordner, ED-Strom, Hygiene. Slice-Watch mit Ordnern/Filtern, Orca-Nachbearbeitung, Cockpit-Verlauf mit ED, Zeitzone im Browser. Tasten-Grenze und README-API angeglichen, toter Code entfernt, Requirements gepinnt.	2026-10-18 00:41:15 +02:00
Dominic Gundel	efd0801cd1	Grotti 2.5.1: Druckbericht, Statistik, Spulenakte und Protokoll-Fixes.	2026-10-17 15:32:51 +02:00
Dominic Gundel	b277ca48aa	Grotti 2.2.6: Wand-Vorschau, dichterer 3D-Pfad, ASCII-Dateinamen. Kacheln zeigen Moonraker-Thumbnails; Toolpath-Thinning behält ganze Schichten; Nicht-ASCII-Namen vermeiden 10115 beim Senden.	2026-10-17 11:22:43 +02:00
Dominic Gundel	7da895bbcd	Grotti 2.2.1: Anleitungen mit relativen Pfaden für Git-Vorschau.	2026-10-15 10:54:45 +02:00
				`@@ -0,0 +1 @@`
				`ALTER TABLE printers ADD COLUMN IF NOT EXISTS start_window jsonb NOT NULL DEFAULT '{}'::jsonb;`