specrails-desktop 2.64.1 → 2.65.0

package/docs/guide/de/getting-started/{4-the-dashboard-tour.md → 5-the-dashboard-tour.md}

@@ -37,11 +37,15 @@ Ein schmaler Streifen verläuft ganz unten am Fenster. Klein, aber praktisch:
 - **Gesamtausgaben** (rechts) – eine laufende Summe dessen, was du ausgegeben hast, sodass die Kosten immer nur einen Blick entfernt sind.
 - **Terminal-Umschalter** (ganz rechts) – öffnet das integrierte Terminal-Panel. Drücke **Cmd+J** (macOS) oder **Ctrl+J** (Windows/Linux), um es jederzeit ein- oder auszublenden. Es ist eine vollwertige Shell, direkt in deinem Projektordner geöffnet.
 
-## Ein paar praktische Tastenkürzel
+## Ein paar praktische Tastenkürzel {#shortcuts}
 
-- **Cmd/Ctrl+B** – Seitenleisten anpinnen oder einklappen.
+- **Cmd/Ctrl+B** – linke Seitenleiste anpinnen oder einklappen; **Option+Cmd+B** (**Ctrl+Alt+B**) macht dasselbe mit der rechten.
 - **Cmd/Ctrl+J** – Terminal-Panel ein-/ausblenden.
-- **Cmd/Ctrl+K** – Suche öffnen.
+- **Cmd/Ctrl+K** – die Befehlspalette: Missionen, Projekte und Jobs suchen und **Aktionen ausführen**. Tippen Sie ein Verb („neu“, „starten“, „verschieben“, „wechseln“) oder beginnen Sie mit **>**, um Aktionen aufzulisten: Neue Spec (auch im Erkunden-Modus), Spec starten oder verschieben, ihr Review öffnen, einen Flow übergeben oder pausieren, Neue Mission, Theme wechseln, zwischen Mission- und Board-Modus wechseln, App- oder Projekteinstellungen in einem Bereich öffnen, einen Loop ausführen, Seitenleisten umschalten, Zurück oder Vorwärts, die letzte Änderung rückgängig machen und Kürzlich gelöscht. Aktionen, die eine Auswahl brauchen (Rail, Status, Theme, Bereich), öffnen eine zweite Seite; **Rücktaste** bei leerer Suche geht zurück. Jede Aktion zeigt ihr Tastenkürzel, die Palette bringt Ihnen also die Tasten bei. Sie bietet nur an, was dort funktioniert, wo Sie sind, und befolgt dieselben Regeln wie die Schaltflächen (eine nicht startbare Spec wird nicht angeboten). Bei leerer Suche listet sie Ihre **zuletzt verwendeten Aktionen** und **zuletzt besuchten Orte**.
+- **Cmd+[ / Cmd+]** (**Alt+← / Alt+→** unter Windows/Linux), die Schaltflächen **←  →** in der Titelleiste oder die Zurück-/Vor-Tasten der Maus – gehen durch die besuchten Orte: Specs, Missionen, Jobs, Projekte und Vollbild-Panels. Rechtsklick (oder langes Drücken) auf eine Schaltfläche zeigt die letzten Orte.
+- **Cmd+Umschalt+I** (**Strg+Alt+I** unter Windows und Linux) oder die Schaltfläche **Offen** in der Titelleiste — die Liste **Offen**: alles, was in all deinen Projekten auf dich wartet, in einer Liste nach Projekt gruppiert. Er sammelt Reviews, die entschieden werden können, Fragen, auf die ein Agent wartet, fehlgeschlagene oder blockierte Läufe, am Tagesbudget pausierte Läufe und Jira-Updates, die sich nicht synchronisieren ließen. Jede Zeile hat ihre Hauptaktion direkt dabei (**Review öffnen**, **Antworten**, **Fortsetzen**, **Wiederholen**) sowie **Zurückstellen** (1 Stunde oder bis morgen) und **Erledigt**. Ein zurückgestellter oder erledigter Eintrag kommt von selbst wieder, wenn sich sein Zustand ändert. Die Schaltfläche zeigt, wie viele Einträge warten, und eine Anbieter-Limit-Benachrichtigung öffnet die Liste. Die Liste ist außerdem ein Link (`?inbox=1`) und eine Aktion der Befehlspalette.
+- **M** — öffnet bei einer fokussierten Spec-Karte im Board eine Auswahl, um sie in einen Status oder eine Rail zu verschieben, das Tastaturäquivalent zu Drag and Drop. Es funktioniert auch bei einer Mehrfachauswahl, und die Palette bietet es als **Fokussierte Spec verschieben…** an.
+- **?** — die Übersicht der Tastaturkürzel. Tippe in ihr Suchfeld, um die Kürzel zu filtern und passende Seiten und Abschnitte dieser Anleitung zu finden; sie öffnen sich in der Anleitung, ohne dass du deinen Bildschirm verlässt. Die kleinen **ⓘ**-Symbole und **Mehr erfahren**-Links neben Einstellungen, Rails, Flow, dem Kontext-Schieberegler und Budgets öffnen die Anleitung auf dieselbe Weise im passenden Abschnitt.
 
 ## Wie es weitergeht
 

package/docs/guide/de/getting-started/6-universal-search.md

@@ -0,0 +1,34 @@
+# Universelle Suche (⌘K)
+
+Drücke **⌘K** (**Strg+K** unter Windows und Linux), um fast alles in Specrails an einer Stelle zu durchsuchen: Missionen, Specs, Job-Protokolle, Dateien, Einstellungen und diese Anleitung. Gib eine normale Suchanfrage ein, um wie bisher Missionen, Projekte, Specs und aktuelle Jobs zu durchsuchen, oder beginne mit einem **Präfix**, um nur eine Quelle zu durchsuchen.
+
+## Präfixe
+
+| Eingabe | Durchsucht | Enter öffnet |
+| --- | --- | --- |
+| `#` | Specs: Titel, Zusammenfassung, Beschreibung, Labels, Notizen zum Ausschluss, Nachträge und Kommentare. `#12` findet Spec 12. | Die Spec |
+| `@` | Missionen: Titel und Gesprächsinhalt. | Die Mission |
+| `/` | Einstellungen (Desktop und Projekt) nach Name oder nach dem, wie du sie nennen würdest. | Das Einstellungsfenster an diesem Block, sichtbar und fokussiert |
+| `f:` | Dateien des Projekts nach Name oder Pfad. | Die Datei im Code-Explorer |
+| `log:` | Job-Protokolle: Befehle, Loop-Namen, Phasentitel und Fehlerdiagnosen. | Der Job |
+| `?` | Diese Anleitung: Seitentitel und Überschriften. | Die Anleitung an dieser Überschrift |
+
+Ein getipptes Präfix wird zu einem **Chip** im Suchfeld, und das Feld behält nur deine Anfrage. Drücke **Rücktaste** bei leerem Feld (oder klicke auf das × des Chips), um den Bereich zu entfernen. Bei leerem Feld listet die Palette die Präfixe unter dem Feld auf; klicke eines an, um zu starten. `>` listet weiterhin Aktionen auf.
+
+## Hervorhebung
+
+Treffer zeigen einen kurzen Ausschnitt um die erste Übereinstimmung, mit hervorgehobenem Text. Die Suche ignoriert Groß- und Kleinschreibung sowie Akzente, `revision` findet also „Révision“.
+
+## Einstellungen
+
+`/` kennt die wichtigsten Einstellungsblöcke in deiner Sprache: Design, Sprache, Editor, Budgets, Benachrichtigungen, Webhooks, Updates, Branch, Umgebung, Telemetrie, Regeln und mehr. Projekteinstellungen werden angeboten, wenn ein Projekt geöffnet ist. Wähle eine aus, und das richtige Fenster öffnet sich an diesem Block. Ohne Präfix fügt ein starker Treffer (ab drei Zeichen) den normalen Ergebnissen bis zu drei Einstellungen hinzu. `/budget` findet auch das Budget-Panel (Limits, Prognose, Was-wäre-wenn), in dem das Wochen- und das Monatslimit liegen. Ein Slash-Befehl wie `/implement` steht unter den Einstellungen in einer eigenen Gruppe, das Präfix `/` blendet ihn also nie aus.
+
+## Job-Protokolle
+
+`log:` durchsucht einen kompakten Index, nicht die Rohausgabe eines Laufs: den Befehl, den Loop-Namen, die Phasentitel und die kurze Diagnose eines fehlgeschlagenen, blockierten oder hängenden Laufs. Token-Streams und Tool-Ausgaben werden nie gespeichert, daher bleibt er klein und schnell. Er wird pro Projekt geführt und enthält die neuesten Läufe.
+
+## Gut zu wissen
+
+- `#`, `f:` und `log:` durchsuchen das aktive Projekt; öffne zuerst ein Projekt.
+- Der Datei-Bereich beachtet die Ausschlussregeln des Code-Explorers.
+- Jede Gruppe zeigt nur ihre besten Treffer; verfeinere die Anfrage, um einzugrenzen.

package/docs/guide/de/insights/1-analytics-and-cost-tracking.md

@@ -6,15 +6,17 @@ Du öffnest ihn über die rechte Seitenleiste (Beschriftung **Analytics**). Alle
 
 ## Was als Ausgabe zählt
 
-Specrails verfolgt fünf Arten von KI-Aktivität, sogenannte *Surfaces*. Jede ist in allen Diagrammen einheitlich farblich gekennzeichnet, damit du sie auf einen Blick erkennst:
+Specrails versieht jeden KI-Lauf mit einer *Surface*: dem Teil der App, der die Ausgabe verursacht hat. Die wichtigsten Surfaces haben jeweils eine feste Farbe und einen eigenen Filter-Chip, sodass du sie auf einen Blick erkennst:
 
-- **Job** – ein Pipeline-Rail, das Architect → Developer → Reviewer → Ship durchläuft.
-- **Quick-Spec** – eine Spec, die über den schnellen „Spec hinzufügen“-Weg erstellt wurde.
-- **Explore-Spec** – eine Explore-Unterhaltung, in der du eine Spec im Gespräch ausarbeitest.
+- **Job** – ein in der Queue eingereihter Pipeline-Job (Architect → Developer → Reviewer → Ship), einschließlich Freestyle-Läufen.
+- **Loop** – jeder KI-Schritt eines Loop-Laufs. Rails laufen standardmäßig als Loops, daher landet der Großteil der Rail-Ausgaben hier.
+- **Quick-Spec** – eine Spec, die über den schnellen „Spec hinzufügen“-Weg erzeugt wurde.
+- **Explore-Spec** – eine Explore-Unterhaltung, in der du eine Spec im Gespräch formst.
 - **KI-Bearbeitung** – eine KI-gestützte Verfeinerung an einem Agenten oder einer Datei.
-- **Dateizusammenfassung** – die verständlichen Zusammenfassungen, die den Code-Explorer speisen.
+- **SMASH** – das Aufteilen einer Epic-Spec in kleinere Specs.
+- **Dateizusammenfassung** – die verständlichen Zusammenfassungen und Datei-Geschichten, die den Code-Explorer speisen.
 
-Ein paar Dinge werden bewusst *nicht* verfolgt: Sowohl die Chat-Seitenleiste als auch der Einrichtungsassistent starten KI-CLIs, tauchen aber nie in deinen Ausgaben auf. So spiegelt das Dashboard echte, wiederholbare Arbeit wider statt beiläufigem Geplauder.
+Kleinere Surfaces werden ebenfalls erfasst, nur ohne eigenen Chip: die Chat-Seitenleiste, der OpenSpec-Spec-Launcher, Spec-Vorschläge, Agent Studio und der ältere Einrichtungs-Chat. Auch an das Projekt angeheftete Missionen zählen zu seinen Ausgaben. Nichts, was eine KI-CLI ausführt, bleibt außen vor – die Summen spiegeln also die gesamte KI-Aktivität des Projekts wider.
 
 ## Das Dashboard lesen
 
@@ -76,3 +78,15 @@ Exporte berücksichtigen die aktuell angewendeten Zeitraum- und Surface-Filter,
 ## Immer live
 
 Du musst nicht neu laden. Sobald irgendwo im Projekt ein neuer Aufruf erfasst wird, lädt sich das geöffnete Dashboard kurz darauf still neu, sodass der Burn-Meter mit der Arbeit Schritt hält, während sie fertig wird.
+
+## Tagesbudgets {#daily-budget}
+
+Mit einem Tagesbudget begrenzt du, was ein Tag kosten darf. Alle Limits (täglich, wöchentlich, monatlich und pro Lauf) bearbeitest du an einer Stelle: **Analysen → Budget**. **Einstellungen → Erweitert** und **Projekteinstellungen → Budget** zeigen nur das aktuelle Tageslimit, mit einer Schaltfläche **Budget öffnen**, die dorthin führt.
+
+Erreichen die erfassten Tagesausgaben ein Budget, pausiert die Warteschlange sich selbst, Rails und Loop-Läufe starten nicht mehr und melden *Tagesbudget erreicht*, und ein laufender Loop-Lauf hält zwischen zwei Schritten an, pausiert durch das Budget. Erhöhe oder entferne das Budget oder warte auf das tägliche Zurücksetzen und setze dann fort.
+
+Das Projektbudget zählt deinen lokalen Tag, das app-weite Budget den UTC-Tag. Die Kostenwarnung pro Job ist eine eigene Einstellung.
+
+**Wochen-, Monats- und Lauf-Limits.** Längere Limits funktionieren genauso. Unter **Analysen → Budget** legst du ein **Wochen-** und ein **Monatslimit** fest, pro Projekt und für die ganze App, sowie ein **weiches Limit pro Lauf** (*pausieren und nachfragen bei X $*). Wochen beginnen am Montag und Monate am 1., in deiner Ortszeit. Ein Wochen- oder Monatslimit pausiert Warteschlangen, lehnt Starts ab und hält laufende Loops an – genau wie das Tagesbudget; erhöhe oder entferne es dort oder warte auf das Zurücksetzen. Erreichen die gemeldeten Kosten eines Laufs das Limit pro Lauf, pausiert er, und **Fortsetzen** fragt, ob er ohne das Limit weiterlaufen oder das Limit erhöht werden soll. Jedes erreichte Limit legt außerdem einen Eintrag **Limit erhöhen** im Posteingang an.
+
+Das Budget-Panel zeigt heute, diese Woche und diesen Monat gegenüber jedem Limit. Die **Prognose** zum Monatsende ist eine Schätzung (der Schnitt der letzten 14 vollständigen Tage mal die verbleibenden Tage plus das bisher Ausgegebene) und wird nie zu abgerechneten Ausgaben addiert. **Was wäre, wenn** berechnet die erfassten Token der letzten 30 Tage mit einem anderen Modell neu, anhand der Preisliste der App, und meldet *Kein Preis* für ein Modell ohne Preis. Bei einem Abo gibt es keine Dollarkosten pro Nutzung; das Panel zeigt dann Turns und Abo-Limits statt Dollar.

package/docs/guide/de/insights/2-the-integrated-terminal.md

@@ -1,4 +1,4 @@
-# Das integrierte Terminal
+# Das integrierte Terminal {#integrated-terminal}
 
 Specrails hat ein echtes Terminal direkt eingebaut – das Panel, das vom unteren Rand des Fensters nach oben fährt, genau wie in VS Code oder Cursor. Es führt deine tatsächliche Shell in deinem tatsächlichen Projektverzeichnis aus, sodass du `git`, `npm`, Tests oder alles andere ausführen kannst, ohne die App zu verlassen.
 

package/docs/guide/de/insights/3-code-explorer.md

@@ -1,4 +1,4 @@
-# Code-Explorer
+# Code-Explorer {#code-explorer}
 
 Der Bereich **Code** bietet dir ein freundliches, schreibgeschütztes Fenster in dein Repository – besonders gedacht für alle, die verstehen möchten, was die KI gebaut hat, ohne ständig in einem Editor zu leben. Links siehst du einen Dateibaum, rechts einen Code-Viewer und über dem Code eine verständliche Zusammenfassung dessen, was jede Datei tatsächlich tut.
 

package/docs/guide/de/integrations/1-ai-providers.md

@@ -1,4 +1,4 @@
-# KI-Anbieter (Claude, Codex)
+# KI-Anbieter (Claude, Codex) {#ai-providers}
 
 ## Die zwei Anbieter
 

package/docs/guide/de/integrations/2-plugins.md

@@ -1,4 +1,4 @@
-# Plugins (Integrationen)
+# Plugins (Integrationen) {#plugins}
 
 Der Bereich **Integrationen** ist ein projektbezogener Marktplatz für optionale Erweiterungen, die den Funktionsumfang der KI ausbauen. Jedes Projekt entscheidet eigenständig, welche Plugins es haben möchte — ein Plugin in einem Projekt zu installieren, berührt nie ein anderes.
 

package/docs/guide/de/integrations/3-jira-integration.md

@@ -15,7 +15,7 @@ Alle Rückschreibungen laufen über eine dauerhafte, absturzsichere Outbox, soda
 
 ## Ein Board verbinden
 
-Du verbindest dich über die **Einstellungen**-Seite eines Projekts (am Ende des „Projekt hinzufügen“-Assistenten gibt es zusätzlich einen optionalen Schritt „Jira konfigurieren“). Der Verbindungsassistent führt dich durch:
+Du verbindest dich über die Seite **Plugins** in der linken Seitenleiste: Klicke auf der Jira-Karte auf **Installieren** und wähle das Projekt. Der Verbindungsassistent führt dich durch:
 
 1. **Testen** — gib deine Jira-URL und deine Zugangsdaten ein, und Specrails überprüft die Verbindung.
 2. **Projekt wählen** — wähle aus, mit welchem Jira-Projekt synchronisiert werden soll.
@@ -52,7 +52,7 @@ So kannst du frei experimentieren — anschalten, ein paar Rails laufen lassen,
 
 ## Im Alltag
 
-Nach dem Verbinden zeigt die Einstellungen-Seite des Projekts eine **Verbunden-Karte**, auf der du:
+Nach dem Verbinden zeigt die Jira-Karte auf der Seite **Plugins** **Verwalten**. Wähle dort das Projekt, um seine **Verbunden-Karte** zu öffnen, auf der du:
 
 - **Jetzt synchronisieren** — ein sofortiges Pollen erzwingen, statt auf den Timer zu warten.
 - **Dead-Letter erneut versuchen** — alle hängengebliebenen Rückschreibungen erneut ausführen.
@@ -69,4 +69,4 @@ Specs, die mit Jira hinterlegt sind, zeigen ein **Jira-Schlüssel-Badge** (etwa
 
 ## Ausschalten
 
-Wenn du jemals vollständig aussteigen möchtest, **trenne** einfach in den Einstellungen. Deine Specs kehren zum reinen Lokal-Verhalten zurück, und die Jira-Metadaten liegen einfach ungenutzt herum — es wird nichts zerstört.
+Wenn du jemals vollständig aussteigen möchtest, **trenne** einfach über die Verbunden-Karte. Deine Specs kehren zum reinen Lokal-Verhalten zurück, und die Jira-Metadaten liegen einfach ungenutzt herum — es wird nichts zerstört.

package/docs/guide/de/integrations/4-mobile-companion.md

@@ -1,4 +1,4 @@
-# Der mobile Companion
+# Der mobile Companion {#mobile-companion}
 
 Specrails hat eine Companion-App fürs Smartphone, mit der du deine Rails im Blick behältst, während du nicht am Schreibtisch sitzt — Jobs laufen sehen, ihren Abschluss verfolgen und auf dem Laufenden bleiben, ohne vor dem Dashboard zu sitzen.
 

package/docs/guide/de/integrations/5-mcp-server.md

@@ -1,4 +1,4 @@
-# Specrails von jeder KI aus steuern (MCP-Server)
+# Specrails von jeder KI aus steuern (MCP-Server) {#mcp-server}
 
 > **For agents (English):** use the [current connection runbook](../../../agents/mcp.md) for Claude and Codex. It includes verified bridge discovery, registration and read-only checks.
 

package/docs/guide/de/integrations/6-agent-chat.md

@@ -33,6 +33,8 @@ Der Agent kann die ganze App anfassen, also entscheidest du, wie viel Freiheit e
 
 Beginne bei **Beobachten** und erhöhe die Stufe erst, wenn der Agent handeln soll. Versucht er etwas oberhalb der aktuellen Stufe, hält er an und sagt dir genau, welche Stufe du einschalten musst — er umgeht die Grenze nie. Das ist getrennt von den Einstellungen ▸ MCP-Stufen, die *externe* Assistenten regeln; die Stufe hier gilt nur für diesen app-internen Agenten.
 
+Die Stufe **auf Autonom** zu erhöhen passiert nie mit einem bloßen Tastendruck: Shift+Tab von Ausführen aus zeigt einen Hinweis mit **Zu Autonom wechseln**, und ein weiteres Shift+Tab springt stattdessen zurück zu Beobachten. Senken geht immer sofort.
+
 ## Ein paar Dinge, die du fragen kannst
 
 Sobald du auf **Ausführen** bist, probier:
@@ -47,16 +49,21 @@ Sobald du auf **Ausführen** bist, probier:
 
 Antworten strömen flüssig herein und landen bereits formatiert (Überschriften, Tabellen, Listen), jede mit einem kleinen **Kopieren**-Button. Ein Status-Chip unten zeigt, was der Agent gerade tut — *Denkt nach…*, *MCP · jobs*, *Terminal* — sodass du seinen Zustand immer kennst.
 
+Codeblöcke zeigen ihre Sprache und haben einen eigenen **Kopieren**-Button. Scrollst du nach oben, während der Agent noch schreibt, erscheint über dem Feld die Pille **Neue Nachrichten** – ein Klick bringt dich zur neuesten Antwort zurück.
+
 ## Praktische Feinheiten
 
 - **Super-Specs aus einem Gespräch.** Bitte den Agenten, eine Spec mit dir zu *formen*, statt sie in einem Schuss zu erzeugen: Er liest zuerst den echten Code, stellt dir kurz Fragen und zeigt den wachsenden Entwurf als Live-Karte direkt im Gespräch. Auf dein Ja erstellt er die Spec und reichert sie — standardmäßig — im Hintergrund mit einem **Contract Layer** an (exakte Dateipfade, Datenformen, Invarianten), damit die implementierenden Agenten nicht improvisieren. Sage „ohne Contract Layer“, um die Anreicherung zu überspringen.
 - **Klicke an, was er erwähnt.** In einer an ein Projekt gepinnten Mission sind Spec-Nummern (`#12`) und Job-/Run-Ids in den Antworten des Agenten klickbare Chips — eine Spec öffnet das Detail-Modal des Boards, eine Job-Id die Live-Job-Ansicht. Existiert die Referenz nicht mehr, erscheint ein dezenter „nicht gefunden“-Hinweis.
-- **Die Implementierungskarte bleibt im Blick.** Wenn der Agent Specs implementiert, verfolgt eine Live-Karte die Arbeit — und solange sie etwas von dir braucht (PR erstellen, veröffentlichen, erneut versuchen, verwerfen), bleibt sie **direkt über dem Eingabefeld angeheftet**, egal wie weit die Unterhaltung scrollt; an ihrer Stelle im Verlauf erscheint stattdessen ein dezenter „oben angeheftet“-Marker. Mehrere aktive Karten stapeln sich als kleine Chips (ein Klick holt eine nach vorn), und ein Chevron minimiert die Karte zu einer schmalen Leiste. Sobald die PR veröffentlicht ist — oder die Arbeit gemergt oder verworfen wurde — kehrt die Karte an ihren Platz im Gesprächsverlauf zurück.
+- **Ein Streifen für deine Läufe.** Startet der Agent Arbeit, verfolgt sie ein einziger Streifen direkt über dem Eingabefeld: was der Lauf gerade tut, in klaren Worten („Spec wird aus deinen Änderungen geschrieben“), wie viele Läufe fertig sind, die Zeit und die bisher echten Kosten (`—`, bis der Anbieter abrechnet). Braucht ein Lauf dich (PR erstellen, erneut versuchen, zurück zum Flow), sagt der Streifen das mit Symbol und Worten und bietet genau diese eine Aktion an; ein Klick auf den Streifen öffnet die vollständige Karte des Laufs direkt darüber (Esc schließt sie). Bei mehreren Läufen zeigt der Streifen zuerst den, der dich braucht, und einen kleinen Umschalter („Rail 1 · Rail 2 · +1“). Die Unterhaltung behält nur, was passiert ist („Auf Rail 1 gestartet“, „Rail 1 fehlgeschlagen: …“, „Ausgeliefert: PR #812“), und jede Zeile öffnet ihren Lauf. Missionen, die auf deine Entscheidung warten, zeigen in der Missionsliste einen Punkt. Aktionen, die einen neuen kostenpflichtigen Lauf starten (**Neu starten**, **Wiederherstellen und erneut versuchen**) oder die andere sehen (PR erstellen, Veröffentlichen), löst der Streifen nie selbst aus: Er öffnet die Karte mit dem Fokus auf diesem Knopf, damit du dort bestätigen kannst.
+- **Der Streifen per Tastatur.** **⌥R** (**Alt+R** unter Windows/Linux) springt vom Nachrichtenfeld zum Streifen der Mission, in der du bist; erneut gedrückt blendet es die Details des Laufs ein oder aus, und **Esc** bringt dich dorthin zurück, wo du warst. Außerhalb eines Textfelds wechseln **⌥[** und **⌥]** zwischen den Läufen. Solange der Streifen den Fokus hat, pausiert oder setzt **P** einen Flow fort und **H** übergibt ihn; anderswo bewirken diese Buchstaben nichts. Drücke **?** für die vollständige Liste.
 - **Prompt-Verlauf.** Ist das Feld leer, drücke **↑**/**↓**, um durch deine früheren Fragen zu blättern (beim Scrollen abgedunkelt dargestellt); tippe los, um sie zu bearbeiten, oder drücke Enter zum Senden.
 - **Warteschlange bearbeiten.** Mehr geschickt, während der Agent beschäftigt war? Solange Nachrichten eingereiht sind, blättert **↑**/**↓** durch *diese*: Das Feld zeigt die ausgewählte, du bearbeitest sie an Ort und Stelle, und **Enter speichert sie zurück in die Warteschlange** (Esc bricht ab; dein ungesendeter Entwurf kommt unverändert zurück).
+- **Antworte per Taste.** Bietet der Agent Optionen an, trägt jeder Chip eine Zahl: Drücke bei leerem Feld **⌥1**…**⌥9** (**Alt+1**…**Alt+9** unter Windows/Linux), um eine zu wählen.
+- **Gelöschte Nachricht in der Warteschlange zurückholen.** Nach dem Löschen erscheint ein paar Sekunden lang **Rückgängig**; damit kommt die Nachricht zurück in die Warteschlange.
 - **Minimieren, nicht verlieren.** Klicke auf das ✕, um das Panel zurück in die Blase abzulegen — die Unterhaltung läuft weiter. Öffne es wieder und du landest bei der neuesten Nachricht; nichts muss neu getippt werden.
 - **Neue Unterhaltung.** Der **+**-Button startet einen sauberen Thread; der Verlauf lebt app-weit, oberhalb jedes einzelnen Projekts.
-- **Missionen wechseln.** Der Missions-Selektor neben dem Projekt-Selektor listet deine Unterhaltungen von neu nach alt — ein pulsierender Punkt markiert die, an denen der Agent noch arbeitet, und ein kleines Badge zählt die Nachrichten in der Warteschlange. Die Suche erscheint, sobald die Liste mehr als acht Einträge hat, und das Papierkorb-Symbol jeder Zeile löscht eine Mission nach einer kurzen Inline-Bestätigung — auch eine laufende (es warnt zuerst und stoppt dann den Agenten).
+- **Missionen wechseln.** Der Missions-Selektor neben dem Projekt-Selektor listet deine Unterhaltungen von neu nach alt — ein pulsierender Punkt markiert die, an denen der Agent noch arbeitet, und ein kleines Badge zählt die Nachrichten in der Warteschlange. Die Suche erscheint, sobald die Liste mehr als acht Einträge hat, und das Papierkorb-Symbol jeder Zeile löscht eine Mission sofort und zeigt einige Sekunden lang **Rückgängig** (oder drücke **⌘Z**); danach wartet die Mission 30 Tage unter **Zuletzt gelöscht** in den Projekteinstellungen. Bei einer Mission, an der der Agent noch arbeitet, wird zuerst gefragt, weil das Stoppen des Agenten nicht rückgängig zu machen ist.
 - **Eine Mission von überall finden.** Drücke **⌘K** (oder den **Suchen**-Button in der Seitenleiste im Agent-Modus) und tippe irgendein Fragment, an das du dich erinnerst — ein Wort aus dem Titel *oder* aus dem, was darin gesagt wurde. Missionen treffen sofort per Titel aus dem Speicher, einen Herzschlag später kommen die Inhaltstreffer mit hervorgehobener Passage dazu, plus angepinntes Projekt und letzte Aktivität. Im Agent-Modus sind Missionen die erste Gruppe; auf dem Board stehen sie direkt nach den Projekten. Enter öffnet die Mission.
 
 ## Launch-Karten und Run-Karten
@@ -69,10 +76,10 @@ Antworten strömen flüssig herein und landen bereits formatiert (Überschriften
 
 ## Sub-Agenten
 
-Manche Anbieter können Teile einer Aufgabe an **Sub-Agenten** abgeben – Helfer, die parallel arbeiten und weitermachen, nachdem der Agent geantwortet hat. Sub-Agenten sind **standardmäßig aus**, weil sie die Kosten einer Anfrage vervielfachen.
+Manche Anbieter können Teile einer Aufgabe an **Sub-Agenten** abgeben – Helfer, die parallel arbeiten und weitermachen, nachdem der Agent geantwortet hat. Sub-Agenten sind **standardmäßig an**; schalte sie pro Projekt aus, wenn du die Kosten niedrig halten willst, denn sie vervielfachen die Kosten einer Anfrage.
 
-- **Pro Projekt einschalten.** Öffne in den Projekteinstellungen den Bereich **Sub-Agenten** und aktiviere **Sub-Agenten in diesem Projekt erlauben**. Das gilt für Missionen, Explore und Verfeinerungen dieses Projekts; Implement-Pipelines sind nie betroffen. Missionen ohne Projekt folgen **App-Einstellungen → KI-Anbieter → Sub-Agenten in Missionen ohne Projekt erlauben**.
-- **Wählen Sie, wer sie ausführt.** Unter **Sub-Agenten ausführen mit** lässt die Standardoption **Wie der Missions-Agent** das CLI der Mission sie nativ starten: am schnellsten, und sie teilen dessen Prompt-Cache. Wählen Sie stattdessen Anbieter, Modell und Aufwand, um Anbieter zu kombinieren – etwa eine Codex-Mission mit Claude-Sub-Agenten. Missionen, die bereits diesen Anbieter nutzen, bleiben mit diesem Modell nativ; bei einem anderen Anbieter startet Specrails jeden Sub-Agenten selbst, was kälter startet und mehr kosten kann, Ihnen aber mehr Kontrolle gibt und die echten Kosten jedes einzelnen zeigt. Specrails fragt vor dem Wechsel nach einer Bestätigung, und diese Sub-Agenten tragen in der Mission ein Anbieter-Badge.
+- **Pro Projekt ausschalten.** Öffne in den Projekteinstellungen den Bereich **Sub-Agenten** und deaktiviere **Sub-Agenten in diesem Projekt erlauben**. Das gilt für Missionen, Explore und Verfeinerungen dieses Projekts; Implement-Pipelines sind nie betroffen. Missionen ohne Projekt folgen **App-Einstellungen → KI-Anbieter → Sub-Agenten in Missionen ohne Projekt erlauben**.
+- **Wähle, wer sie ausführt.** Unter **Sub-Agenten ausführen mit** lässt die Standardoption **Wie der Missions-Agent** das CLI der Mission sie nativ starten: am schnellsten, und sie teilen dessen Prompt-Cache. Wähle stattdessen Anbieter, Modell und Aufwand, um Anbieter zu kombinieren – etwa eine Codex-Mission mit Claude-Sub-Agenten. Missionen, die bereits diesen Anbieter nutzen, bleiben mit diesem Modell nativ; bei einem anderen Anbieter startet Specrails jeden Sub-Agenten selbst, was kälter startet und mehr kosten kann, dir aber mehr Kontrolle gibt und die echten Kosten jedes einzelnen zeigt. Specrails fragt vor dem Wechsel nach einer Bestätigung, und diese Sub-Agenten tragen in der Mission ein Anbieter-Badge.
 - **Bei der Arbeit zusehen.** Die von einer Antwort gestarteten Agenten erscheinen als eine kompakte Zeile unter dieser Antwort. Sie bleibt offen, solange sie arbeiten, und klappt sich zu einer Zusammenfassung mit Gesamtzeit und Tokens zusammen, sobald alle fertig sind. Klappe eine Zeile auf, um Ergebnis und Kosten zu lesen oder die Aktivität live zu verfolgen. Jeder Start bleibt an seiner Stelle im Gespräch, spätere Starts vermischen sich also nie mit früheren. Stoppe einen laufenden Agenten in seiner Zeile oder alle über die Zeile.
 - **Der Agent macht selbst weiter.** Wenn Hintergrund-Agenten fertig sind, setzt der Agent fort und berichtet, was sie gefunden haben – markiert mit *Nach Hintergrund-Agenten fortgesetzt*.
 - **Die Einstellung zu ändern ist sicher.** Eine Mission mit laufenden Agenten übernimmt die Änderung, sobald diese fertig sind; sie sagt es dir und bietet **Agenten stoppen und jetzt übernehmen** an.

package/docs/guide/de/integrations/8-flow-mode.md

@@ -0,0 +1,69 @@
+# Flow: erst bauen, dann die Spec {#flow-mode}
+
+Flow ist eine Art, mit einem Agenten zu bauen, wenn du noch nicht genau weißt, was du willst. Du sprichst in deiner Mission mit dem Agenten, er schreibt und startet echten Code auf seinem eigenen Flow-Branch (einer separaten Kopie deines Projekts), und wenn das Ergebnis stimmt, drückst du **Übergeben**: Ein Rail übernimmt deine Änderungen, leitet die Spec ab und führt die übliche Prüfung, Review und Auslieferung aus.
+
+Implement ist zum Delegieren von Arbeit, die du schon beschreiben kannst. Flow ist zum Entdecken.
+
+## So beginnt ein Flow
+
+Du musst Flow nie beim Namen nennen. Wenn du etwas Exploratives oder Visuelles beschreibst („Ich will ausprobieren…“, „Ich weiß nicht, wie es aussehen soll“), zeigt die Mission eine Karte mit zwei Wegen:
+
+- **Flow**: jetzt gemeinsam bauen; die Spec kommt am Ende.
+- **Spec + Implement**: erst eine Spec vereinbaren, dann an einen Rail delegieren.
+
+Beide Wege haben dasselbe Gewicht und erscheinen immer in derselben Reihenfolge: Keiner wird empfohlen, du entscheidest. Unter **Warum der Agent fragt** sagt der Agent in einem Satz, warum er fragt, und er drängt nicht, egal welchen Weg du wählst oder ob du **Nicht jetzt** drückst.
+
+Wählst du Flow, öffnet sich eine Bestätigung: Specrails legt eine separate Kopie des Projekts auf einem eigenen Flow-Branch an, in der der Agent Code schreiben kann, und dein Hauptbranch bleibt unberührt. Drücke **Flow starten**. Auf dem Board erscheint eine Platzhalter-Spec mit dem Label **Im Flow** (ein Klick führt zurück zur Mission).
+
+Kann dein Specrails Core Flow noch nicht ausführen, ist Starten deaktiviert und die Karte nennt, was fehlt. Meist hilft ein Update von Specrails Core.
+
+## Einen Flow aus einer vorhandenen Spec starten
+
+Jede Spec lässt sich in Flow bauen, nicht nur eine neue Idee. Flow und Implement bleiben zwei gleichwertige Wege, daran zu arbeiten:
+
+- auf dem Board: Rechtsklick auf eine Spec und **In Flow starten** (neben dem Ziehen auf eine Rail); in der Spec-Detailansicht steht **In Flow starten** neben **Auf Rail verschieben**;
+- in einer Mission: Wenn du eine Spec umsetzen lassen willst, ohne eine Rail zu nennen, zeigt der Agent dieselbe Karte mit zwei Wegen für diese Spec: **Flow** arbeitet mit dir daran, **Spec + Implement** startet sie auf einer Rail;
+- eine Rail-Startkarte für eine einzelne Spec bietet ebenfalls **In Flow starten** neben ihrem Start an.
+
+Die Spec selbst ist dann **In Flow**: Es entsteht keine Platzhalter-Spec, und der erste Zug des Agenten erhält die Spec (Akzeptanzkriterien, Contract Layer, Nicht-Ziele und offene Addenda). Vom Board aus gestartet, öffnet sich der Flow in der Mission der Spec oder in einer neuen Mission mit dem Namen der Spec. In einem Projekt mit mehreren Git-Repositorys fragt ein kleiner Dialog zuerst, wo der Flow läuft, wenn die Spec nicht genau eines davon nennt: Es werden nur die Git-Repositorys angezeigt, das Repository der Spec (sonst das primäre) ist vorausgewählt, und die Pfeiltasten ändern die Auswahl. **In Flow starten** ist deaktiviert, mit dem Grund im Tooltip, wenn die Spec schon in Flow ist, erledigt oder abgebrochen ist, auf einer Rail liegt oder Flow nicht verfügbar ist.
+
+**Verwerfen** gibt die Spec genau so zurück, wie sie war, mit ihrem vorherigen Status: Deine Spec wird nie gelöscht. Wird der Flow geliefert, wird die Spec aus dem Gebauten neu geschrieben; vorher bleibt ihr ursprünglicher Text als Kommentar **Original spec before Flow** erhalten, damit nichts verloren geht. Eine bereits mit Jira verknüpfte Spec aktualisiert genau dieses Issue und verschiebt es in den für Review zugeordneten Status; es entsteht kein zweites Issue.
+
+## Während des Flows
+
+Der Flow-Modus wird dort benannt, wo du hinschaust, in seiner eigenen Flow-Farbe: Der Composer zeigt einen **Flow**-Chip neben dem Autonomie-Chip und den Hinweis *Sag dem Agenten, was er in diesem Flow ändern soll…*; der Missionstitel zeigt **Im Flow**, ebenso ihre Zeile in der Missionsliste. Das Gespräch markiert, wo du Flow betreten und verlassen hast, und die im Flow geschriebenen Antworten des Agenten tragen neben ihrer Uhrzeit eine kleine **Flow**-Marke.
+
+Die Leiste direkt über dem Composer zeigt den Flow in einer kurzen Zeile: seinen Status, **Flow · 7 Dateien**, **Flow pausieren** und die Hauptaktion **Übergeben**. Ist eine Aktion nicht verfügbar (der Flow speichert noch, eine andere Aktion läuft), sagt der Hover-Text warum. Öffne die Zeile mit ihrem Pfeil, wie jeden anderen Lauf, um den Rest zu sehen:
+
+- den **Branch** (Klick kopiert den Namen), die **Änderungen** mit hinzugefügten und entfernten Zeilen (Klick listet jede geänderte Datei mit Status und +/−) und die **Kosten bisher**, wie vom Anbieter abgerechnet. Bis ein Zug gemeldete Kosten hat, steht dort `—`, nie eine Schätzung; ein `*` markiert eine Summe ohne unbepreiste Züge, mit einem Hinweis, wie viele es sind;
+- **Vorschau**, solange die App des Flows läuft (siehe unten);
+- **Verwerfen**, abgesetzt, löscht die Änderungen des Flows, seinen Branch und die Platzhalter-Spec. Die Bestätigung listet, was verloren geht: die geänderten Dateien mit ihren +/−, den Branch und die Spec.
+
+**Flow pausieren** stoppt den Agenten und behält deine Änderungen und die Spec. Die Zeile zeigt dann **Flow fortsetzen**.
+
+Du kannst schreiben, während der Agent arbeitet: Im Flow **unterbricht** deine Nachricht den aktuellen Schritt (der Senden-Knopf wird zum Blitz), und der Agent macht sofort mit deinen neuen Informationen weiter. Solange der Flow offen ist, tritt die Git-Leiste unter dem Composer zur Seite: Das Panel des Flows zeigt seinen Branch bereits.
+
+## Die App ausprobieren
+
+Der Flow-Agent führt Typecheck und Tests selbst aus, um seine Arbeit zu prüfen. Gibt es etwas auszuprobieren, fragt er mit drei Optionen: **Start the app**, **Start and expose on the local network** oder **Not now**. Freigeben erlaubt dir, die App von einem Handy im selben WLAN oder VPN zu öffnen, und jeder in diesem Netz kann sie erreichen.
+
+Sobald die App lauscht, gibt dir der Agent ihre Adressen als Links, und das Panel des Flows zeigt **Vorschau** mit einem grünen Punkt: Sie öffnet die App in deinem Browser. Ihr Menü hat die Netzwerkadresse und **App beenden**. Die App läuft aus der Kopie des Flows, nie aus deinem Haupt-Checkout, und Specrails beendet sie, wenn du den Flow pausierst, verwirfst oder übergibst.
+
+## Übergeben {#flow-hand-off}
+
+Wenn dir das Ergebnis gefällt, drücke **Übergeben**. Die Zeile zeigt **Bereit, ein PR zu werden** und öffnet darüber eine einzige Zeile: *Rail 2 macht aus deinen 7 geänderten Dateien einen geprüften PR. Wenn etwas schiefgeht, bleibt deine Arbeit erhalten.* Drücke **Starten** oder **Noch nicht**, um zum Flow zurückzukehren; **Esc** ist dasselbe wie **Noch nicht**; ein Klick daneben klappt die Zeile nur ein, und die Zeile bleibt bei **Bereit, ein PR zu werden** mit **Starten**. Kann die Engine deines Gesprächs die Übergabe auf diesem Rechner nicht ausführen, sagt das ein Hinweis direkt unter der Zeile, und die Standard-Engine des Rails wird verwendet.
+
+Rail, Engine, Modell und Aufwand sind schon für dich gewählt (ein freier Rail und die Engine deines Gesprächs). Um sie zu ändern, öffne **Vorgehen ändern**; dort siehst du auch, was sich geändert hat. Die Kosten bisher stehen in der Hauptzeile. Deine Auswahl bleibt erhalten, wenn du **Noch nicht** drückst und später erneut übergibst. Während die Übergabe startet, zeigt die Leiste den Start ohne Lücke und folgt dann dem Lauf Schritt für Schritt. Ist das Review-Limit oder ein Budget erreicht, sagt die Zeile das, und nichts startet. Zeigt sich der Lauf nach 45 Sekunden noch nicht, hört die Leiste auf zu drehen und zeigt **Wird noch an Rail 2 übergeben…** mit **Aktualisieren**, das erneut nachsieht und weiter wartet, bis der Lauf erscheint.
+
+Der Rail leitet aus dem Gebauten die Spec und ihre Spec-Änderung ab, prüft und reviewt sie, und die Auslieferungskarte erscheint in der Mission wie bei jedem Lauf.
+
+Scheitert der Lauf aus technischem Grund, kommt die Arbeit von selbst unversehrt in diesen Flow zurück: Die Karte sagt in einfachen Worten, was fehlschlug (die Codes bleiben unter **Technische Details**), und der Agent erhält den Fehler und erklärt ihn. Verlangt die Review Änderungen, bietet die Karte **Zurück zum Flow** oder **Neu starten**. Ist die Auslieferung abgeschlossen, schließt die Mission den Flow mit einer Zusammenfassung: der Pull Request, die aus dem Gebauten neu geschriebene Spec, die archivierte Spec-Änderung und der Jira-Vorgang, falls vorhanden.
+
+## Gut zu wissen
+
+- Flow schreibt nur auf seinem eigenen Branch. Außerhalb von Flow bleiben Missionen schreibgeschützt.
+- Ein Flow pro Mission zur gleichen Zeit. Eine Pause übersteht einen Neustart der App.
+- Verschwindet die Projektkopie des Flows, wird der Flow als **muss geprüft werden** markiert (zur Info, nichts zu entscheiden), und nichts wird gelöscht.
+- Die Leiste wechselt nie den Lauf, den du gerade ansiehst. Braucht dich inzwischen ein anderer Lauf, sagt sein Name im Umschalter der Leiste **braucht dich**.
+- Jira erhält nichts, solange du im Flow bist oder wenn du ihn verwirfst.
+- Flow-Kosten erscheinen in der Analyse als eigene Oberfläche, **Flow**, und im Block der Agenten-Missionen.

package/docs/guide/de/pipeline/1-rails-and-jobs.md

@@ -37,13 +37,14 @@ Das war's. Die rail startet einen KI-CLI-Prozess im richtigen Ausführungskontex
 | **Loop-Auswahl** | Der Loop, den diese rail ausführt — ein eingebauter (`Implement` / `Freestyle` / `SDD Quick (OpenSpec)`) oder ein eigener Loop. Siehe Tabelle unten. Pro rail gespeichert. |
 | **▶ Play / ■ Stop** | Starten oder abbrechen. |
 
-### Was eine rail ausführt: Loops
+### Was eine rail ausführt: Loops {#rail-loops}
 
 Eine rail führt einen **Loop** aus — das Rezept für die Arbeit. Zwei Loops sind **eingebaut** und decken die gängigen Fälle ab:
 
 | Eingebauter Loop | Befehl | Was er macht |
 |------|---------|--------------|
 | **Implement** | `/specrails:implement` | Ein Job für alle Specs auf der rail. Durchläuft die komplette Pipeline Architect → Developer → Reviewer → Ship. Der Alltagsstandard. |
+| **Freestyle** | Freestyle | Der Provider der rail setzt jede Spec selbstständig um und **umgeht** die Pipeline; danach verfeinern Verifikation und Loop Decider das Ergebnis, bis alles grün ist. Ein unabhängiger Lauf pro Spec. Funktioniert mit Claude, Codex, Gemini, Kimi und lokalen Engines; der interaktive Chat im Job gibt es nur mit Claude. |
 
 Für mehrere Specs legst du zusammengehörige (bis zu 3) auf eine rail — `Implement` führt sie als einen gemeinsamen Job aus — oder verteilst unabhängige Specs auf mehrere rails: Jede git-gestützte rail läuft parallel in ihrem eigenen isolierten Worktree.
 
@@ -85,6 +86,25 @@ Wenn etwas nicht stimmt:
 - **Auto-Pause beim Budget** — setze ein Tagesbudget, und die Queue pausiert sich selbst, sobald die Ausgaben des Tages das Limit erreichen.
 - **Alles** — beende die Desktop-App oder führe `specrails-desktop stop` aus.
 
+## Lokal integrieren mit nicht committeten Änderungen
+
+**Lokal integrieren** führt eine freigegebene Lieferung auf diesem Rechner ohne PR in deinen Integrationsbranch (zum Beispiel `main`) zusammen. Ein sauberer Checkout ist nicht nötig:
+
+- Nicht committete Änderungen, die die gelieferten Dateien nicht berühren, bleiben einfach, wo sie sind.
+- Berühren deine Änderungen dieselben Dateien, sichert Specrails sie als git stash namens `specrails: before integrating #N (…)`, integriert und spielt sie zurück. Die Meldung lautet sinngemäß: Änderungen gesichert, #N integriert, wiederhergestellt.
+- Führt das Zurückspielen zu Konflikten mit dem integrierten Code, lässt Specrails den Branch genau wie integriert und **behält den Stash** — nichts geht verloren. Die Karte zeigt *Deine lokalen Änderungen sind als Stash gesichert* mit den Konfliktdateien, **Meine Änderungen wiederherstellen** (erneuter Versuch, etwa nachdem du den Code geändert hast) und den Stash-Namen zum Kopieren. Anschließend stellt Specrails sie selbst auf einem neuen Branch `specrails/restore-local-<id>` in einem separaten Worktree wieder her: Lassen sie sich dort konfliktfrei anwenden, committet es sie; andernfalls arbeitet ein KI-Konfliktlöser nur in diesem Worktree, bewahrt deine Absicht und den integrierten Code, und Specrails committet das Ergebnis. Die Karte listet die wiederhergestellten Dateien; **Nach <Branch> zurückholen** bringt sie auf deinen Branch (erst dann wird der Stash verworfen) und **Wiederhergestellten Branch verwerfen** entfernt den Branch und behält den Stash. Eine Mission wird nur informiert; sie muss nie etwas ausführen. Von Specrails generierte OpenSpec-Skills und -Befehle (etwa `.claude/skills/openspec-*/SKILL.md`) gelten nicht als deine Änderungen: Bei einem Konflikt behalten sie die integrierte Version.
+- Ignorierte Dateien werden nie gestasht: kollidiert eine davon mit der Lieferung, bittet Specrails dich, sie vorher zu verschieben.
+- Stoppt die App zwischen Sichern und Wiederherstellen, stellt sie deine Änderungen beim nächsten Öffnen des Projekts wieder her (nur wenn derselbe Branch ausgecheckt ist).
+
+## Zeit- und Kostenprognose {#launch-forecast}
+
+Bevor du auf Starten drückst, kann ein Rail zeigen, wie lange vergleichbare Läufe üblicherweise dauern und, wo es sinnvoll ist, was sie üblicherweise kosten, zum Beispiel *Üblicherweise 6–9 Min. · 2–4 $ für solche Läufe*.
+
+Die Spanne ist die mittlere Hälfte deines eigenen Verlaufs: das 25. bis 75. Perzentil abgeschlossener Läufe in diesem Projekt mit demselben Loop oder Befehl und derselben Engine. Es braucht mindestens 5 vergleichbare Läufe. Bis dahin steht in der Zeile *Noch nicht genug Verlauf* statt einer Vermutung. Es zählen nur vom Anbieter gemeldete Kosten; geschätzte Kosten bleiben außen vor. Es ist eine Schätzung, nie eine Rechnung.
+
+Der Dollarbetrag erscheint nur, wenn bekannt ist, dass die Engine nach Verbrauch abrechnet (zum Beispiel mit einem API-Schlüssel). Bei einem Abo-Tarif oder solange die Abrechnungsart noch nicht bekannt ist, wird nur die Zeit angezeigt. Enthält die Rail mehrere Specs, gilt die Spanne für eine Spec und sagt das mit *(pro Spec)*. Könnten die heutigen Ausgaben plus das obere Ende der Spanne dein Tagesbudget erreichen, ergänzt die Zeile *Könnte am Budget pausieren* mit einem Link zu den Budgeteinstellungen. Ist das heutige Budget bereits aufgebraucht, bittet Starten zuerst um Bestätigung, weil der Lauf bis zum Zurücksetzen pausieren würde.
+
+
 ## Wie es weitergeht
 
 - [Der Loop Builder](the-loop-builder) — was eine rail ausführt und wie du deine eigenen Loops baust.

package/docs/guide/de/pipeline/2-the-job-detail-view.md

@@ -107,6 +107,18 @@ Wenn [Telemetrie](../settings/customizing) für den Job aktiviert war, erscheint
 
 Praktisch, um einen Lauf mit einem Teammitglied zu teilen oder einen präzisen Fehlerbericht einzureichen.
 
+## Wenn ein Lauf fehlschlägt
+
+Wenn ein Job fehlschlägt, stoppt oder blockiert ist, beginnt der Endzustand mit einer **Diagnosekarte**, die in klaren Worten sagt, was passiert ist, zum Beispiel *Tests sind in der Phase Reviewer nach 4 Korrekturrunden fehlgeschlagen*, und warum, wenn die App es weiß:
+
+- **Tests fehlgeschlagen**: Die Prüfungen schlagen nach den Korrekturrunden weiter fehl.
+- **Anbieterlimit**: Das Nutzungslimit des KI-Anbieters ist erreicht. Die Karte nennt den Zeitpunkt des Zurücksetzens in den Worten des Anbieters.
+- **Umgebung**: Der Rechner kann die Prüfungen nicht ausführen (Zugangsdaten, fehlendes Werkzeug, fehlschlagender Setup-Befehl). *Umgebung reparieren* zeigt genau, was auszuführen oder zu ändern ist.
+- **Blockiert**, **Zeit überschritten**, **stumm geblieben** und **unerwartet gestoppt** nennen das Limit oder den Prozess, der den Lauf angehalten hat.
+- **Unbekannte Ursache**: Die App rät nicht. Sie zeigt das Ende des Protokolls, damit du es selbst lesen kannst.
+
+Unter der Diagnose stehen bis zu drei gereihte Abhilfen, und nur solche, die hier funktionieren können: **Fortsetzen ab** der angehaltenen Phase, **Erneut ausführen**, **Spec bearbeiten und neu starten** (die Nachträge der Spec tragen deine Änderung in den nächsten Lauf), **Umgebung reparieren** und **Protokoll am Fehler öffnen**. Dieselbe Ursache erscheint als einzeilige Bezeichnung im [Liste „Offen“](../getting-started/the-dashboard-tour), und die Lauf-Karte der Mission zeigt dieselbe Karte.
+
 ## Wie es weitergeht
 
 - [Rails & Jobs](rails-and-jobs) — Starten und Einreihen in die Queue.

package/docs/guide/de/pipeline/3-reviewing-a-delivery.md

@@ -0,0 +1,43 @@
+<!-- guide-revision: mission-first-v1 -->
+
+# Eine Lieferung in der App prüfen {#review-a-delivery}
+
+Eine prüfbereite Lieferung hat zwei Ansichten: **Übersicht** (das Urteil, die Belege und die Entscheidungsschaltflächen) und **Änderungen** (was die Lieferung tatsächlich geändert hat). Öffne die Prüfung über die Schaltfläche **Prüfen** der Lieferung und wähle dann **Änderungen**.
+
+## Die Änderungen lesen
+
+Die Dateiliste links zeigt jede geänderte Datei mit Status (hinzugefügt, geändert, gelöscht, umbenannt), ihren `+`- und `−`-Zeilenzahlen und einem Haken, sobald du sie als angesehen markierst. Der Diff rechts lädt jeweils eine Datei, daher bleibt auch eine große Änderung flüssig. Wechsle zwischen den Darstellungen **Vereint** und **Geteilt**; Specrails merkt sich deine Wahl. Eine sehr große Datei zeigt ihre ersten Zeilen mit **Vollständigen Datei-Diff laden**; eine Binärdatei wird als binär aufgeführt.
+
+Die Änderungen werden ab dem Punkt gemessen, an dem die Lieferung von ihrem Basis-Branch abzweigte, daher erscheint nichts, was danach in die Basis kam. Hat eine Lieferung noch keinen kombinierten Branch, kannst du wählen, den Branch welcher Spec du lesen willst.
+
+## Anmerkungen des Reviewers am Code
+
+Die Befunde des Reviewers, die markierten Risiken und die Review-Kommentare, die der Lauf lösen sollte, erscheinen unter der Zeile, um die es geht. Anmerkungen ohne Datei oder Zeile stehen über der Dateiliste, es wird also nichts verborgen. Ältere Lieferungen und Reviewer, die keinen Ort nannten, zeigen ihre Befunde in dieser Liste.
+
+## Den Agenten um eine Änderung bitten
+
+Wähle Zeilen per Klick auf ihre Nummern (Umschalt-Klick erweitert den Bereich), wähle **Änderung beim Agenten anfragen** und beschreibe die Änderung. Specrails speichert sie als Review-Feedback an der Spec, mit Datei, Zeilenbereich und dem ausgewählten Code, und zeigt eine Meldung mit einem Link zur Spec. Der nächste Lauf zu dieser Spec erhält es. Um ihn sofort zu starten, nutze **Änderungen anfordern** in der Übersicht. Hier gibt es keine Kommentarthreads zwischen Personen; besprich dich mit deinem Team auf GitHub.
+
+## In deinem Editor öffnen
+
+**Im Editor öffnen** öffnet die Datei an der ausgewählten Zeile in VS Code, Cursor oder einer JetBrains-IDE. Den Editor wählst du unter **Einstellungen → Code → Editor**. Die Datei öffnet sich aus deinem eigenen Checkout des Projekts, in dem der Review-Branch möglicherweise nicht ausgecheckt ist.
+
+## Entscheiden, was mit einer Lieferung geschieht {#pr-decision}
+
+Ein abgeschlossener Lauf fragt dich nur eines: Was soll mit dem Ergebnis passieren? Die Karte zeigt eine Hauptschaltfläche für den nächsten Schritt (PR erstellen, veröffentlichen oder prüfen) und daneben **Prüfen**, das das verständliche Review-Paket öffnet. Alles andere liegt hinter **Weitere Aktionen**:
+
+- **Branch auschecken** legt den Branch in deinem Projektordner ab, damit du ihn ausprobieren kannst.
+- **Lokal integrieren** führt das Ergebnis auf diesem Computer in deinen Basis-Branch zusammen. GitHub ist nicht nötig, und du bestätigst vorher.
+- **Verwerfen** entfernt das Ergebnis und seinen Branch. Du bestätigst vorher.
+
+Schlägt eine Aktion fehl, nennt die Meldung, was nicht geklappt hat, und bietet **Wiederholen** an.
+
+## Tastatur
+
+| Taste | Aktion |
+| --- | --- |
+| `j` / `k` | Nächste / vorherige geänderte Datei |
+| `n` / `p` | Nächste / vorherige Anmerkung des Reviewers |
+| `v` | Datei als angesehen markieren |
+
+Die Tasten werden ignoriert, während du in ein Feld tippst. „Angesehen“ ist nur für dich sichtbar; ändert sich die Datei in einer späteren Revision, zeigt sie **Seit dem Ansehen geändert** und gilt wieder als nicht angesehen.

package/docs/guide/de/pipeline/4-picking-an-engine-per-rail.md

@@ -1,4 +1,4 @@
-# Engine pro Rail wählen
+# Engine pro Rail wählen {#provider-capabilities}
 
 ## Wann die Auswahl erscheint
 
@@ -19,7 +19,7 @@ Alle vier führen **Implement** aus:
 | Engine | Greif dazu, wenn… | Hinweise |
 |--------|--------------------|-------|
 | **Claude** | Du native Kosten, persistente Interaktion oder strikte Tool-Policies brauchst. | Profile, Freestyle und strukturierte Transforms. |
-| **Codex** | Du die OpenAI Codex CLI bevorzugst oder Implementierungen über verschiedene Provider hinweg vergleichen willst. | `codex` ≥ 0.128.0. Keine native Kostenmeldung — die App ergänzt die Kosten aus ihrer Preistabelle. Profile gelten nicht. |
+| **Codex** | Du die OpenAI Codex CLI bevorzugst oder Implementierungen über verschiedene Provider hinweg vergleichen willst. | `codex` ≥ 0.128.0. Keine native Kostenmeldung — die App ergänzt die Kosten aus ihrer Preistabelle. Profile gelten nicht. Freestyle läuft ohne interaktiven Chat. |
 
 ## Ein praktischer Workflow
 

package/docs/guide/de/pipeline/5-the-loop-builder.md

@@ -1,4 +1,4 @@
-# Der Loop Builder
+# Der Loop Builder {#loop-builder}
 
 ## Core-Workflows
 

package/docs/guide/de/settings/1-themes.md

@@ -1,4 +1,4 @@
-# Themes
+# Themes {#themes}
 
 Gestalte Specrails so, wie es dir gefällt. Die App bringt fünf sorgfältig abgestimmte Themes mit, zwischen denen du jederzeit blitzschnell wechseln kannst – ohne Neustart, ohne Neukompilieren, ganz ohne Konfiguration.
 

package/docs/guide/de/settings/3-pipeline-telemetry-and-diagnostics.md

@@ -1,4 +1,4 @@
-# Pipeline-Telemetrie & Diagnose
+# Pipeline-Telemetrie & Diagnose {#telemetry}
 
 Die Telemetrie zeichnet Pipeline-Diagnosen lokal auf. Sie ist für Projekte ohne gespeicherte Einstellung **standardmäßig aktiviert**. Du kannst sie pro Projekt deaktivieren; ausdrücklich gespeicherte Einstellungen bleiben erhalten.
 
@@ -20,7 +20,7 @@ Ab diesem Moment zeichnen Pipeline-Jobs in diesem Projekt Telemetrie auf. Andere
 
 ### Was abgedeckt ist
 
-Die Telemetrie gilt für **Pipeline-Jobs** (die in der Queue eingereihten Architect → Developer → Reviewer → Ship-Rail-Läufe). Interaktive Sitzungen wie der Chat und der Einrichtungsassistent sind bewusst ausgenommen – die Telemetrie ist für die wiederholbaren, untersuchbaren Pipeline-Läufe gedacht, nicht für einmalige Unterhaltungen.
+Die Telemetrie gilt für Jobs, die über die **Job-Queue** des Projekts laufen: CLI-Pipeline-Läufe (Rails, wenn Loops deaktiviert sind, und `implement`-Befehle aus der `specrails-desktop`-CLI). Loop-Läufe – die Standardart, wie Rails laufen – sowie interaktive Sitzungen wie Chat, Explore und Missionen werden nicht instrumentiert.
 
 ## Wo die Daten liegen
 

package/docs/guide/de/settings/5-project-environment.md

@@ -1,4 +1,4 @@
-# Projektumgebung
+# Projektumgebung {#project-environment}
 
 Manche Projekte brauchen zur Laufzeit ein Zugangsdatum, etwa `NODE_AUTH_TOKEN` für private npm-Pakete. Füge unter **Projekteinstellungen → Umgebung** die **Namen** der Variablen hinzu, die deine Rails und Loops brauchen. Specrails speichert nur die Namen, nie die Werte.
 

package/docs/guide/de/settings/6-updates.md

@@ -0,0 +1,24 @@
+# Updates {#updates}
+
+Specrails hält zwei Dinge aktuell: die App **Specrails Desktop** selbst und das Framework **specrails-core**, das deine Projekte verwenden. Beides findest du unter **Einstellungen ▸ Updates**.
+
+## Update-Kanal
+
+Wähle, wie schnell du neue Versionen erhältst:
+
+- **Neueste** (Standard): jede Version sofort nach der Veröffentlichung. Neue Funktionen und Korrekturen bekommst du zuerst.
+- **Stabil**: nur Versionen, die mindestens eine Woche mit grüner CI auf Neueste liefen und danach von den Maintainern freigegeben wurden. Sinnvoll, wenn dein Team weniger, gut getestete Updates bevorzugt.
+
+Der Kanal gilt für die App und für specrails-core. Hat specrails-core noch keine stabile Version, folgt Core vorerst Neueste, und die Core-Karte weist darauf hin.
+
+Wurde auf Stabil noch keine Version freigegeben, meldet **Nach Updates suchen** das, statt eine Version von Neueste anzubieten.
+
+## Wie Updates ankommen
+
+- **Specrails Desktop** prüft beim Start und alle 6 Stunden. Ist ein Update verfügbar, erscheint eine Karte zum Herunterladen, Installieren und Neustarten. Du kannst auch auf **Nach Updates suchen** klicken.
+- **specrails-core** aktualisiert sich nie von selbst. Klicke auf der Core-Karte auf **Nach Updates suchen** und dann auf **Aktualisieren**. Deine Projekte wechseln ohne Neustart der App zum neuen Framework.
+
+## Gut zu wissen
+
+- Ein Wechsel von Neueste zu Stabil stuft dich nie herab. Du bleibst auf deiner Version, bis Stabil aufholt.
+- Jedes Update wird auf beiden Kanälen vor der Installation signiert und geprüft.

package/docs/guide/de/settings/7-existing-projects.md

@@ -0,0 +1,33 @@
+# In einem bestehenden Projekt arbeiten {#existing-projects}
+
+Diese Funktionen helfen Läufen, ein bestehendes Projekt zu respektieren: was eine Spec ausklammert, welche Fragen der Architekt vor der Planung hat, welche Anforderungen ein Test wirklich nachweist, wie alter Code vor einer Änderung beschrieben wird und welche Regeln dein Team bereits aufgeschrieben hat. Jede braucht eine specrails-core-Version, die sie unterstützt; bis dahin ist ihr Schalter ausgegraut, mit einem Hinweis, Core zu aktualisieren.
+
+## Nicht im Umfang
+
+Jede Spec kann auflisten, was sie bewusst **nicht** ändert. Quick und Explore füllen das für dich aus; im Spec-Fenster erscheint es als **Nicht im Umfang** unter der Beschreibung, ein Eintrag pro Zeile, und lässt sich wie jedes andere Feld bearbeiten. Die Agenten erhalten es bei jedem Start mit der Spec.
+
+## Fragen des Architekten in Jira
+
+Aktiviere unter **Einstellungen ▸ Verankerung in bestehenden Projekten** die Option **Klärungsfragen des Architekten in Jira posten**. Wenn ein Lauf anhält, weil der Architekt eine Antwort braucht, oder mit Annahmen fortfährt, postet Specrails sie als einen Kommentar im verknüpften Jira-Vorgang. Antworte in Jira auf diesen Kommentar: Die Antwort wird der Spec als Klärung hinzugefügt und der nächste Lauf der Spec liest sie. Einen pausierten Lauf kannst du weiterhin in der App beantworten.
+
+## Nachgewiesene Anforderungen
+
+Wenn ein Test die Anforderung nennt, die er nachweist (`[spec:<capability>/<anforderung>]` im Titel), zeigt die Review-Seite **Nachgewiesene Anforderungen X/Y**: welche Anforderungen ein erfolgreicher Test nachweist, welche noch keinen haben und welche die Änderung selbst berührt hat. Die Analysen zeigen dasselbe pro Loop. Damit CI fehlschlägt, wenn eine geänderte Anforderung keinen Test hat, füge nach deinen Tests `specrails-core pipeline trace --check --tests-passed` hinzu.
+
+Die Loop-Bibliothek bietet außerdem **Drift-Prüfung**, einen nur lesenden Loop, der vergleicht, was jede Spec sagt und was der Code tut, und jeden Widerspruch auflistet. Er ändert nichts.
+
+## Baseline bei Berührung
+
+Aktiviere **Baseline bei Berührung**, damit eine Änderung, die Code ohne beschreibende Spec erreicht, ihn zuerst beschreibt: Tests des heutigen Verhaltens, am unveränderten Code bestätigt, und eine kurze Spec des Bestehenden. Die Review-Seite zeigt **Spec für den Code erstellt, den die Arbeit berührt hat** mit Modul, Anforderungen und Tests; die Kosten werden getrennt ausgewiesen. Schlagen diese Tests am unveränderten Code fehl, stoppt der Lauf vor jeder Änderung am Modul und sagt das.
+
+## Projektregeln {#project-rules}
+
+**Einstellungen ▸ Projektregeln** listet die Prüfungen, die dein Projekt bereits ausführt (Lint, Typen, Tests, CI), und jede Regel aus Dateien wie `CLAUDE.md` oder `AGENTS.md`, eingeteilt in:
+
+- **Durchgesetzt**: Eine Prüfung garantiert sie bereits.
+- **Automatisierbar**: Eine Prüfung könnte es. **Spec erstellen** macht daraus mit einem Klick eine Spec.
+- **Nur manuell**: Jemand muss hinsehen. Diese Regeln erscheinen auf jeder Review-Seite unter **Menschliche Prüfung nötig**.
+
+Regeln, die Core noch nicht einstufen konnte (etwa direkt nach dem Hinzufügen des Projekts, wenn die Inventur offline läuft), erscheinen als **Nicht eingestuft**; **Inventur erneut ausführen** mit konfiguriertem Anbieter stuft sie ein.
+
+**Inventur erneut ausführen** aktualisiert die Liste. Hat ein Projekt noch keine Verifikationsbefehle, bieten die Agent-Runtime-Einstellungen zuerst diese Prüfungen an.

package/docs/guide/de/settings/8-accessibility.md

@@ -0,0 +1,23 @@
+# Barrierefreiheit und Anpassung {#accessibility}
+
+Specrails passt sich an deine Arbeitsweise an. Alles steht unter **Einstellungen ▸ Darstellung**, gilt sofort und wird auf diesem Computer gespeichert.
+
+## Dichte {#density}
+
+**Komfortabel** hält Karten und Zeilen großzügig. **Kompakt** zeigt mehr auf einmal: Das Spec-Board startet als kompakte Zeilen, die Job-Liste nutzt engere Zeilen und die Job-Story verdichtet ihre Zeitleiste. Eine gespeicherte Board-Ansicht behält ihr eigenes Layout; eine als Haftnotizen gespeicherte Ansicht öffnet sich also weiterhin als Haftnotizen. Hat das Board dieses Projekts bereits ein eigenes Layout, lässt **Auch für das Board verwenden** unter der Auswahl es wieder der Dichte folgen.
+
+## Bewegung reduzieren {#reduce-motion}
+
+**System folgen** respektiert dein Betriebssystem. **Reduzieren** schaltet Animationen und Übergänge in Specrails aus, was auch das System sagt: Die Rail-Pille bleibt an ihrer Position, Live-Punkte pulsieren nicht mehr und der Builder-Halo sowie die Theme-Effekte stehen still. **Volle Bewegung** animiert auch dann, wenn das System weniger verlangt.
+
+## Eine Spec per Tastatur verschieben {#keyboard-moves}
+
+Fokussiere eine Spec-Karte im Board (Tab oder Pfeiltasten) und drücke **M**. Eine kleine Auswahl listet die Status und die Rails; wähle mit den Pfeiltasten und **Enter**. Das entspricht dem Ziehen der Karte dorthin, auch bei Jira-gebundenen Specs, die über deinen Jira-Workflow verschoben werden. Gehört die Karte zu einer Mehrfachauswahl (**X** wählt die fokussierte Karte aus), gilt die Verschiebung für alle ausgewählten Specs. Die Befehlspalette bietet dasselbe als **Fokussierte Spec verschieben…**. **M** tut nichts, solange du in ein Feld tippst.
+
+## Run-Meldungen für Screenreader {#live-status}
+
+Specrails meldet Änderungen an Runs über einen höflichen Live-Bereich für das Projekt, das du gerade ansiehst: ein Run gestartet, pausiert, braucht dich, fehlgeschlagen, abgeschlossen oder mit bereitem Review. Schübe werden zusammengefasst und Wiederholungen verworfen, damit eine geschäftige Rail den Screenreader nie überflutet. Rückgängig-Hinweise melden sich bereits selbst.
+
+## Tastaturfokus {#focus}
+
+Jede Schaltfläche, jeder Link, jedes Menüelement, jede Karte und jede Baumzeile zeigt einen sichtbaren Fokusring, wenn du sie per Tastatur erreichst. Informationen, die früher nur in einem Tooltip standen, etwa die Spec-Referenz auf einem Rail-Streifen, stehen auch Tastatur- und Screenreader-Nutzern zur Verfügung.