@agent-native/core 0.76.5 → 0.76.6

package/docs/content/locales/de-DE/dispatch.md

@@ -0,0 +1,146 @@
+---
+title: "Versand"
+description: "Die Steuerungsebene des Arbeitsbereichs: Geheimspeicher, Integrations-Hub, App-übergreifender Delegat und zentraler Posteingang für Slack, E-Mail, Telegram, WhatsApp."
+---
+
+# Versand
+
+Dispatch ist die zentrale App, die sich vor jeder anderen App in Ihrem Arbeitsbereich befindet und Geheimnisse, Integrationen, Nachrichten und app-übergreifende Delegierung verwaltet. Es handelt sich um die **Kontrollebene des Arbeitsbereichs** – der einzelne Agent, mit dem Ihr Team kommuniziert, die zentralen Anmeldeinformationen live und der einzelne Router, der entscheidet, welche Spezial-App eine bestimmte Anfrage bearbeiten soll.
+
+> **Versenden Sie die Vorlage vs. `@agent-native/dispatch` das Paket.** Diese Seite behandelt das Konzept der Dispatch-App/-Vorlage – was sie tut und warum Sie sie benötigen. Das `@agent-native/dispatch` npm-Paket ist die separat veröffentlichte Laufzeit, die die Serverlogik der Dispatch-Vorlage (Tresor, Integrationen, Ziele, geplante Jobs und app-übergreifende Delegierung) als Drop-In-Paket für Arbeitsbereiche bündelt, die sie erweitern. Informationen zur Gerüst-App selbst (Routen, Bildschirme, Agentenführer) finden Sie im [Dispatch template](/docs/template-dispatch).
+
+Ohne Dispatch implementiert jede App in einem Multi-App-Arbeitsbereich letztendlich die gleichen Installationen neu: ihren eigenen Slack-Bot, ihren eigenen Geheimspeicher, ihre eigenen geplanten Jobs, ihre eigene Kopie der Anweisungen des Arbeitsbereichs. Das Drehen eines API-Schlüssels führt zu zehn Neubereitstellungen. Das Hinzufügen einer neuen Richtlinie erfordert zehn Kopier- und Einfügevorgänge. Dispatch zentralisiert all das in einer App, sodass sich die anderen auf ihre Domain konzentrieren können.
+
+```an-diagram title="Dispatch as the workspace control plane" summary="One inbox, one vault, one MCP gateway, and shared resources sit in front of the domain apps, which Dispatch reaches as A2A peers."
+{
+  "html": "<div class=\"dsp-hub\"><div class=\"diagram-node\">Users &amp; external agents<br><small class=\"diagram-muted\">Slack · email · Telegram · WhatsApp · MCP</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-panel dsp-control\" data-rough><span class=\"diagram-pill accent\">Dispatch &mdash; control plane</span><div class=\"dsp-caps\"><span class=\"diagram-pill\">Central inbox</span><span class=\"diagram-pill\">Secret vault</span><span class=\"diagram-pill\">Cross-app delegation</span><span class=\"diagram-pill\">MCP gateway</span><span class=\"diagram-pill\">Workspace resources</span></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"dsp-peers\"><div class=\"diagram-box\" data-rough>Mail</div><div class=\"diagram-box\" data-rough>Calendar</div><div class=\"diagram-box\" data-rough>Analytics</div></div><small class=\"diagram-muted\">domain apps &mdash; A2A peers</small></div>",
+  "css": ".dsp-hub{display:flex;flex-direction:column;align-items:center;gap:10px}.dsp-hub .dsp-control{display:flex;flex-direction:column;align-items:center;gap:10px;width:100%}.dsp-hub .dsp-caps{display:flex;gap:8px;flex-wrap:wrap;justify-content:center}.dsp-hub .dsp-peers{display:flex;gap:10px;flex-wrap:wrap;justify-content:center}"
+}
+```
+
+## Wenn Sie den Versand wünschen {#when}
+
+Reach for Dispatch, wenn einer dieser Punkte zutrifft:
+
+- Sie führen einen [multi-app workspace](/docs/multi-app-workspace) aus – E-Mail, Kalender, Analysen, Inhalte – und möchten nicht einen Slack-Bot pro App.
+- Sie möchten **einen Posteingang für „den Agenten“**, damit Benutzer einem einzelnen Bot eine DM schicken und die richtige Spezial-App die Arbeit hinter den Kulissen übernimmt.
+- Sie verfügen über **arbeitsbereichsweite Geheimnisse** (Stripe-Schlüssel, OpenAI-Schlüssel, API-Token von Drittanbietern), die mehrere Apps benötigen, und Sie möchten einen einzigen Tresor, anstatt Werte in jeden `.env` zu kopieren.
+- Sie möchten einen **Laufzeitgenehmigungsfluss** vor sensiblen Änderungen (gespeicherte Ziele, Richtlinienänderungen), damit Nicht-Administratoren Anfragen stellen und Administratoren ohne Code-Bereitstellung abmelden können.
+- Sie möchten **gemeinsame skills, Anweisungen, Agentenprofile und MCP-Server**, die Apps im Arbeitsbereich erben – einmal ändern, alle erreichen.
+
+Wenn Sie eine einzelne Vorlage eigenständig ausführen, benötigen Sie Dispatch nicht – jede Vorlage kann ihre eigenen Messaging-Integrationen direkt verbinden. Siehe [Messaging](/docs/messaging) für das Standalone-Setup.
+
+## Was Dispatch tut {#what-it-does}
+
+Sieben Funktionen, die alle auf derselben Workspace-Datenbank basieren, die auch die anderen Apps verwenden:
+
+| Fähigkeit                         | Was es Ihnen bietet                                                                                      | Einrichten                                                     |
+| --------------------------------- | -------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
+| **Zentraler Posteingang**         | Slack, E-Mail, Telegram, WhatsApp erreichen alle einen Agenten mit gemeinsamem Speicher + Tools          | **Einstellungen → Nachrichten** ([Messaging](/docs/messaging)) |
+| **Geheimer Tresor**               | Speichern Sie jeden Berechtigungsnachweis einmal. rotieren an einer Stelle in jeder App                  | **Vault** + Zugriffsmodus (alle Apps oder manuell)             |
+| **App-übergreifende Delegierung** | Leitet eine Anfrage über A2A an die richtige Fach-App weiter und antwortet im Thread                     | Automatisch ([A2A](/docs/a2a-protocol))                        |
+| **Einheitliches MCP-Gateway**     | Ein MCP-Connector für externe Agenten erreicht jede gewährte Workspace-App                               | [External Agents](/docs/external-agents)                       |
+| **Arbeitsbereichsressourcen**     | Autor skills/instructions/profiles einmal; Apps erben sie zur Laufzeit                                   | **Ressourcen** ([Workspace](/docs/workspace#global-resources)) |
+| **Träume**                        | Überprüft vergangene Läufe/Feedback und schlägt dauerhafte Verbesserungen vor, die Sie genehmigen können | Registerkarte „Träume\*\*“                                     |
+| **Genehmigungsablauf**            | Gate-sensitive Laufzeitänderungen hinter der Inline-Administratorüberprüfung                             | **Versandgenehmigungsrichtlinie**                              |
+
+Jedes wird unten detailliert beschrieben.
+
+### Zentraler Posteingang
+
+Slack, E-Mail, Telegram und WhatsApp fließen alle in die Agentenschleife von Dispatch ein. Verbinden Sie jede Plattform einmal unter **Einstellungen → Nachrichten** und jeder Kanal erreicht denselben Agenten mit demselben Speicher und denselben Tools. Eine Slack-DM und eine E-Mail an `agent@yourcompany.com` enden als zwei Oberflächen in einem Gesprächsverlauf und nicht als zwei getrennte Bots. Siehe [Messaging](/docs/messaging) für die Anmeldeinformationen und Webhooks URLs.
+
+### Geheimer Tresor
+
+Speichern Sie die Anmeldeinformationen einmal im Tresor von Dispatch. Standardmäßig ist der Tresorzugriff **alle Apps**: Jeder gespeicherte Schlüssel ist für jede Workspace-App verfügbar, und `sync-vault-to-app` verschiebt den gesamten Tresor an die Ziel-App. Arbeitsbereiche, die eine strengere Trennung benötigen, können den Tresor in den **manuellen** Modus umschalten, in dem vor der Synchronisierung explizite Genehmigungen pro App erforderlich sind. Nicht-Administratoren können ein Geheimnis für eine App **anfordern**; Administratoren **genehmigen**, wodurch das Geheimnis und in manuellen Workflows die Gewährung erstellt wird. Alle Lese-, Gewährungs-, Synchronisierungs- und Rotationsvorgänge werden in einem Prüfprotokoll erfasst. Dies macht das Drehen der OpenAI-Taste zu einem Ein-Klick-Vorgang über zehn Apps statt zehn PRs.
+
+### App-übergreifende Delegierung
+
+Dispatch erkennt die anderen Apps in Ihrem Arbeitsbereich automatisch als A2A-Peers – keine manuelle Registrierung, keine Konfiguration pro App. Wenn ein Benutzer in Slack nach „Anmeldungen der letzten Woche zusammenfassen“ fragt, erkennt Dispatch dies als Analyseanfrage und ruft die Analyse-App über [A2A](/docs/a2a-protocol) auf. Wenn sie fragen „Entwerfen Sie eine Antwort an Alice“, wird die Nachricht an die Mail-App weitergeleitet. Dispatch veröffentlicht die endgültige Antwort zurück im ursprünglichen Thread. Die Verhaltensregel lebt in den Anweisungen des Disponenten: Domänenarbeit gehört zur Domänen-App. Dispatch ist der Orchestrator, nicht der Spezialist.
+
+### Einheitliches MCP-Gateway
+
+Dispatch kann der einzelne MCP-Connector für externe Agenten sein: Fügen Sie `https://dispatch.agent-native.com/_agent-native/mcp` einmal in Claude, ChatGPT, Codex oder Cursor hinzu, und eine Autorisierung erreicht jede gewährte Workspace-App anstelle eines Connectors pro App. Den vollständigen Verbindungsablauf, App-Zuschüsse, OAuth und Inline-MCP-App-Vorschauen finden Sie unter [External Agents](/docs/external-agents).
+
+```an-api
+{
+  "method": "POST",
+  "path": "/_agent-native/mcp",
+  "summary": "Unified MCP gateway endpoint",
+  "description": "The single MCP connector URL external agents add (e.g. `https://dispatch.agent-native.com/_agent-native/mcp`). One authorization here reaches every **granted** workspace app instead of wiring one connector per app. App grants, OAuth, and inline MCP App previews are covered in [External Agents](/docs/external-agents).",
+  "auth": "Standard remote MCP OAuth, handled by the framework. The granted-app set scopes which workspace apps the connector can reach.",
+  "responses": [
+    { "status": "200", "description": "MCP JSON-RPC response — tools, resources, and MCP App UI resources aggregated across granted workspace apps." }
+  ]
+}
+```
+
+### Arbeitsbereichsressourcen
+
+Skills, Leitplankenanweisungen, Agentenprofile und Referenzressourcen können einmal in Dispatch erstellt und vom Rest des Arbeitsbereichs übernommen werden. Ressourcen mit dem Geltungsbereich **Alle Apps** sind global: Dispatch speichert sie einmal im Arbeitsbereichsbereich und jeder App-Agent liest sie zur Laufzeit. Sie werden nicht in jede App kopiert und es gibt keinen manuellen Synchronisierungsschritt zwischen Arbeitsbereich und Ressourcen. Von der App freigegebene Ressourcen und persönliche Ressourcen können die Standardeinstellungen des Arbeitsbereichs lokal überschreiben oder einschränken.
+
+Siehe [Workspace — Global resources](/docs/workspace#global-resources) für die kanonische Pfadtabelle, das Starterpaket und das Override-Modell.
+
+MCP-Serverressourcen verwenden JSON und sind absichtlich nur HTTP. Speichern Sie Token in
+Versenden Sie Vault, gewähren oder synchronisieren Sie diese Schlüssel mit den Ziel-Apps und verweisen Sie darauf
+aus Headern mit `${keys.NAME}`, sodass die Rohanmeldeinformationen niemals im
+Ressourcenkörper.
+
+Auf der Seite **Ressourcen** wird das empfohlene Starterpaket hervorgehoben, sodass Administratoren schnell erkennen können, welche Dateien vorhanden sind, fehlende Starterdateien wiederherstellen, ohne vorhandene zu überschreiben, und deren Inhalte bearbeiten können. Erweitern Sie eine beliebige Ressource, um eine Vorschau ihres effektiven Laufzeitstapels für eine ausgewählte App/einen ausgewählten Benutzer anzuzeigen. Jede App-Karte verfügt außerdem über eine **Kontextansicht**, die genau zeigt, was diese App empfängt.
+
+### Träume
+
+Dispatch Dreams überprüft frühere Agentenläufe, Feedback, Bewertungen und wiederholte Fehler, um dauerhafte Verbesserungen vorzuschlagen. Ein Traumbericht ist eine Überprüfungsoberfläche, kein stilles Umschreiben: Er kann persönliche Speicheraktualisierungen, die Bereinigung veralteter Speicher, gemeinsame `LEARNINGS.md`-Änderungen, Arbeitsbereichsanweisungen/Fähigkeiten/Wissen/Agentenressourcen oder wiederkehrende Jobs vorschlagen, und jeder Vorschlag verweist auf die Ausführungen, die ihn rechtfertigen. Gemeinsame Anweisungen und teamweite Ressourcen müssen vor ihrer Anwendung überprüft werden, insbesondere wenn die Beweise aus eingehenden Slack-, E-Mail-, Telegram-, WhatsApp- oder Webinhalten stammen.
+
+Bevor Dreams einen Schreibvorgang vorschlägt, vergleicht Dreams die Beweise mit dem persönlichen Speicherindex, vorhandenen `memory/*.md`-Notizen und freigegebenen `LEARNINGS.md`. Wenn eine Lektion bereits erfasst ist, wird im Bericht vermerkt, dass sie übersprungen wurde. Wenn eine zugehörige persönliche Erinnerung veraltet erscheint, zielt der Vorschlag auf diese vorhandene Notiz ab, anstatt ein Duplikat zu erstellen.
+
+Beginnen Sie mit der Registerkarte **Träume** in Dispatch. Führen Sie zunächst einen manuellen Durchgang durch, öffnen Sie ein Vorschlagsüberprüfungsblatt, um das aktuelle Ziel mit dem vorgeschlagenen Inhalt und den Quellennachweisen zu vergleichen, und übernehmen Sie dann nur die Änderungen, die Sie behalten möchten. Sobald die Berichte durchgängig nützlich sind, kann Dispatch einen wiederkehrenden Traumjob erstellen, der weiterhin Vorschläge erstellt, ohne dass gemeinsame Änderungen oder Änderungen auf Anweisungsebene automatisch angewendet werden.
+
+### Genehmigungsablauf
+
+Dispatch kann sensible Laufzeitänderungen hinter der Überprüfung durch den Administrator verbergen. Heute umfasst dies **gespeicherte Ziele** (die Slack-Kanäle und E-Mail-Adressen, an die der Agent proaktiv senden kann), geteilte/Team-**Traumvorschläge**, das Erstellen/Aktualisieren/Löschen von All-App-**Arbeitsbereichsressourcen** und die **Versandgenehmigungsrichtlinie** selbst. Wenn die Richtlinie aktiviert ist, wird die Änderung in die Warteschlange gestellt und der Agent zeigt direkt im Chat eine Inline-Genehmigungsvorschau an – Administratoren genehmigen oder lehnen ab, ohne die Konversation zu verlassen.
+
+## Wie eine Slack-Nachricht durch Dispatch fließt {#flow}
+
+Gehen Sie ein Beispiel Ende-zu-Ende durch. Ein Benutzer schickt dem Bot eine DM: _"Zusammenfassen der Anmeldungen der letzten Woche."_
+
+1. **Slack → Webhook.** Slack `POST`s bis `/_agent-native/integrations/slack/webhook` in der Dispatch-App. Der Handler überprüft die Signatur und **fügt eine Zeile in `integration_pending_tasks` ein**, löst dann einen selbstgesteuerten `POST` auf seinem eigenen Prozessor aus und gibt `200` sofort zurück, sodass Slack keinen erneuten Versuch unternimmt.
+2. **Neue Prozessorausführung.** Der Prozessorendpunkt wird in einer brandneuen Funktionsausführung mit seinem eigenen vollständigen Timeout ausgeführt. Es beansprucht die Aufgabe atomar und startet die Agentenschleife.
+3. **Der Dispatcher-Agent entscheidet.** Der Agent liest die Nachricht, erkennt „Anmeldungen“ als Analyseabsicht und ruft `call-agent` für [A2A endpoint](/docs/a2a-protocol) der Analyse-App auf. Dort läuft die eigentliche SQL-Arbeit.
+4. **Antwort im Thread gepostet.** Der Analyseagent gibt ein Ergebnis zurück. Dispatch formatiert es und sendet es zurück in denselben Slack-Thread, in den der Benutzer geschrieben hat, und verwendet dabei die verknüpfte Identität, falls vorhanden (der Agent handelt also mit den Berechtigungen des Anforderers, nicht mit denen des Arbeitsbereichsbesitzers).
+5. **Wiederherstellung, wenn etwas ausfällt.** Wenn der Prozessor mitten im Flug abstürzt – A2A-Timeout, Downstream-Agent-Fehler, Funktionseinfrierung – durchsucht ein Wiederholungsjob alle 60 Sekunden festsitzende Aufgaben und startet den Prozessor erneut. Bis zu drei Versuche, bevor die Aufgabe mit `failed` markiert wird.
+
+```an-diagram title="A Slack message through Dispatch" summary="Slack enqueues into SQL, a fresh execution drains it, the Dispatch agent delegates the domain work over A2A, and the reply lands back in the originating thread. A 60s retry job recovers anything that dies mid-flight."
+{
+  "html": "<div class=\"dsp-flow\"><div class=\"dsp-row\"><div class=\"diagram-node\">Slack DM<br><small class=\"diagram-muted\">\"summarize last week's signups\"</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\" data-rough><strong>/slack/webhook</strong><br><small class=\"diagram-muted\">verify + INSERT pending task</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-pill ok\">200</div></div><div class=\"dsp-row\"><div class=\"diagram-box\" data-rough><strong>fresh processor</strong><br><small class=\"diagram-muted\">claim task · start agent loop</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel center\" data-rough><span class=\"diagram-pill accent\">Dispatch agent decides</span><small class=\"diagram-muted\">analytics intent &rarr; call-agent</small></div></div><div class=\"dsp-row\"><div class=\"diagram-box\" data-rough>Analytics app<br><small class=\"diagram-muted\">A2A peer · runs the SQL work</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-pill ok\">reply posted in thread</div></div><div class=\"diagram-panel dsp-retry\" data-rough><span class=\"diagram-pill warn\">recovery</span> <span class=\"diagram-muted\">if the processor crashes &mdash; A2A timeout, downstream error, freeze &mdash; the 60s retry job re-fires it (&le;3 attempts) so the Slack reply still arrives</span> <span class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&#8635;</span></div></div>",
+  "css": ".dsp-flow{display:flex;flex-direction:column;gap:12px}.dsp-flow .dsp-row{display:flex;align-items:center;gap:10px;flex-wrap:wrap}.dsp-flow .center{display:flex;flex-direction:column;align-items:center;gap:4px}.dsp-flow .dsp-retry{display:flex;align-items:center;gap:8px;flex-wrap:wrap}"
+}
+```
+
+Der gleiche Ablauf gilt für E-Mail, Telegram und WhatsApp – nur der Adapter ändert sich.
+
+## Zuverlässigkeitsgeschichte {#reliability}
+
+Die gesamte Pipeline ist so konzipiert, dass sie auf jedem serverlosen Host (Netlify, Vercel, Cloudflare Workers) funktioniert, ohne auf plattformspezifische APIs für die Hintergrundausführung angewiesen zu sein.
+
+- **Webhook → SQL-Warteschlange → Fresh-Execution-Prozessor.** Die Agentenschleife wird niemals innerhalb des Webhook-Handlers ausgeführt. Die einzige Aufgabe des Handlers besteht darin, 200 zu überprüfen, in die Warteschlange zu stellen und zurückzugeben. Eine separate neue Ausführung entleert die Warteschlange, sodass eine langsame Agentenausführung niemals den eingehenden Webhook blockieren oder dazu führen kann, dass die Plattform es erneut versucht.
+- **A2A Fortsetzungsabfrage.** Wenn Dispatch an eine andere App delegiert, fragt es die Downstream-Aufgabe mit einem begrenzten Timeout ab. Wenn der Downstream-Agent zu lange braucht oder abstürzt, zeichnet Dispatch die Fortsetzung auf und der Wiederholungsjob übernimmt sie – die Slack-Antwort des Benutzers kommt trotzdem an.
+- **Automatisch signiertes, appübergreifendes A2A.** Gehostete Multi-App-Arbeitsbereiche generieren zum Zeitpunkt der Bereitstellung automatisch A2A-Anmeldeinformationen pro App, sodass Apps im selben Arbeitsbereich einander aufrufen können, ohne dass Sie jemals ein JWT-Geheimnis einfügen müssen. Die Agent-Discovery-Ebene von Dispatch liest diese Creds aus der Workspace-Datenbank, sodass neu hinzugefügte Apps automatisch als aufrufbare Peers angezeigt werden.
+
+## Einrichtung {#setup}
+
+Drei kurze Schritte:
+
+1. **Bauen Sie ein Gerüst für einen Arbeitsbereich auf, der Dispatch enthält.** Führen Sie `npx @agent-native/core@latest create my-company-platform` aus und wählen Sie `dispatch` neben den gewünschten Domänenvorlagen aus. Dispatch befindet sich bei `apps/dispatch` und die restlichen Apps befinden sich daneben. Siehe [Multi-App Workspace](/docs/multi-app-workspace).
+2. **Messaging verbinden.** Öffnen Sie **Einstellungen → Messaging** in Dispatch und klicken Sie auf Verbinden für Slack, E-Mail, Telegram oder WhatsApp. Die Formularfelder stimmen mit den Umgebungsvariablen im Dokument [Messaging](/docs/messaging) überein – siehe dort, was die einzelnen Plattformen benötigen.
+3. **Andere Apps hinzufügen.** Führen Sie `npx @agent-native/core@latest add-app` vom Arbeitsbereichsstammverzeichnis für jede Domänen-App aus. Sie erscheinen automatisch als A2A-Peers in `list-workspace-apps` von Dispatch – keine manuelle Registrierung, keine Bearbeitung der Agentenkarte. Dispatch beginnt mit der Delegierung an sie, sobald ihre Agentenkarten erreichbar sind.
+
+Fügen Sie dann Anmeldeinformationen zum Tresor hinzu und erstellen Sie (optional) globale Arbeitsbereichsressourcen unter **Ressourcen**. Tresorschlüssel können je nach Zugriffsmodus weiterhin synchronisiert oder gewährt werden; Alle App-Arbeitsbereichsressourcen werden automatisch geerbt. Wenn Sie eine Geheimisolierung pro App benötigen, stellen Sie die Tresorzugriffseinstellung auf „Manuell“ um, bevor Sie einzelne Apps gewähren.
+
+## Siehe auch {#see-also}
+
+- [Dispatch template](/docs/template-dispatch) – die eigentliche Gerüst-App mit vollständigem Aktionskatalog und Agentenleitfaden
+- [Messaging](/docs/messaging) – Verbindung von Slack, E-Mail, Telegram, WhatsApp
+- [A2A Protocol](/docs/a2a-protocol) – wie die app-übergreifende Delegierung unter der Haube funktioniert
+- [Multi-App Workspace](/docs/multi-app-workspace) – die Bereitstellungsform, für die Dispatch erstellt wurde
+- [Workspace Governance](/docs/workspace-management) – git/GitHub-Governance, die mit der Laufzeit-Governance von Dispatch gekoppelt ist

package/docs/content/locales/de-DE/drop-in-agent.md

@@ -0,0 +1,260 @@
+---
+title: "Drop-in-Agent"
+description: "Mounten Sie den Agenten-Chat + Arbeitsbereich mit <AgentPanel>, <AgentSidebar> und sendToAgentChat() in jede React-App."
+---
+
+# Drop-in-Agent
+
+> **Entwicklerseite.** Diese Seite richtet sich an Entwickler, die den Agent in eine React-App einbetten. Informationen zur Endbenutzererfahrung bei der Arbeit mit dem Agenten finden Sie unter [Using Your Agent](/docs/using-your-agent).
+
+Sie müssen den Agent-nativen Ansatz nicht von Grund auf neu erstellen. Der Agenten-Chat, die Registerkarte „Arbeitsbereich“, das CLI-Terminal, die Spracheingabe und die gesamte zugehörige Infrastruktur werden als eine Handvoll React-Komponenten geliefert, die Sie in jede App einfügen können.
+
+> **Voraussetzung:** Auf dem Server muss `agent-chat-plugin` ausgeführt werden (es wird in jeder Vorlage automatisch gemountet). Wenn Sie bei Null anfangen, lesen Sie [Server](/docs/server).
+>
+> Benötigen Sie die öffentliche API-Karte anstelle eines Tutorials? Siehe [Component API](/docs/components).
+
+## Die Komponenten im Überblick {#components}
+
+| Komponente            | Was es ist                                                                                                              | Verwenden Sie es, wenn                                                                 |
+| --------------------- | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
+| `<AgentSidebar>`      | Umschließt Ihr Root-App-Layout und fügt einen umschaltbaren Seitenbereich hinzu, der den vollständigen Agenten enthält. | Sie möchten, dass der Agent neben Ihrer App auf jedem Bildschirm verfügbar ist         |
+| `<AgentToggleButton>` | Öffnet/schließt `<AgentSidebar>` (fügen Sie es in Ihren Header ein)                                                     | Mit `<AgentSidebar>` koppeln                                                           |
+| `<AgentPanel>`        | Das Rohpanel selbst – Chat + CLI + Arbeitsbereichsregisterkarten                                                        | Sie möchten die volle Kontrolle über das Layout oder eine dedizierte Agentenseite      |
+| `<AgentChatSurface>`  | Eine vorverkabelte Panel-/Seiten-Chat-Oberfläche                                                                        | Sie möchten ohne den Seitenleisten-Wrapper chatten                                     |
+| `<AssistantChat>`     | Chat-Renderer auf niedrigerer Ebene mit Komponisten-/Verlaufs-Hooks                                                     | Sie benötigen benutzerdefiniertes Chrom rund um die Standardkonversation UI            |
+| `sendToAgentChat()`   | Programmgesteuert eine Nachricht an den Chat senden                                                                     | Eine Schaltfläche, die die Arbeit dem Agenten übergibt, anstatt sie inline auszuführen |
+| `useActionMutation()` | Typsicherer Frontend-Wrapper um eine Aktion                                                                             | UI muss den gleichen Vorgang ausführen, den ein Agent-Tool ausführen würde             |
+
+Alle diese werden aus `@agent-native/core/client` exportiert.
+
+```an-diagram title="The mount model" summary="<AgentSidebar> wraps your existing layout. Your routes render in the main area; the agent panel mounts beside them. <AgentPanel> is the same panel without the wrapper."
+{
+  "html": "<div class=\"diagram-mount\"><div class=\"diagram-box sidebar\" data-rough><span class=\"diagram-pill accent\">&lt;AgentSidebar&gt;</span><div class=\"inner\"><div class=\"diagram-node main\">Your app<br><small class=\"diagram-muted\">children: header + &lt;Outlet/&gt;</small></div><div class=\"diagram-node panel\">Agent panel<br><small class=\"diagram-muted\">chat &middot; CLI &middot; workspace</small></div></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&harr;</div><div class=\"diagram-card alt\"><span class=\"diagram-pill\">&lt;AgentPanel&gt;</span><small class=\"diagram-muted\">same panel, no wrapper &mdash; you own the layout</small></div></div>",
+  "css": ".diagram-mount{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-mount .sidebar{display:flex;flex-direction:column;gap:8px;padding:14px}.diagram-mount .inner{display:flex;gap:10px}.diagram-mount .main{flex:2}.diagram-mount .panel{flex:1}.diagram-mount .alt{display:flex;flex-direction:column;gap:6px;padding:14px}.diagram-mount .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+## Der 80 %-Fall: `<AgentSidebar>` {#sidebar}
+
+Das häufigste Setup ist eine Seitenleiste, die auf jedem Bildschirm von rechts geöffnet wird.
+Umschließen Sie Ihr vorhandenes Root-Layout mit `<AgentSidebar>`; als was auch immer Sie übergeben
+Kinder bleiben im Haupt-App-Bereich. Der Agenten-Chat ist der Seitenbereich.
+
+```an-annotated-code title="Wrapping the root layout with <AgentSidebar>"
+{
+  "filename": "app/root.tsx",
+  "language": "tsx",
+  "code": "import { Outlet } from \"react-router\";\nimport { AgentSidebar, AgentToggleButton } from \"@agent-native/core/client\";\n\nexport default function Root() {\n  return (\n    <AgentSidebar\n      emptyStateText=\"How can I help?\"\n      suggestions={[\n        \"Summarize my inbox\",\n        \"Draft a reply to the latest email\",\n        \"Show me yesterday's signup numbers\",\n      ]}\n      dynamicSuggestions\n      defaultSidebarWidth={420}\n      position=\"right\"\n    >\n      <header>\n        <AgentToggleButton />\n      </header>\n\n      <main>\n        <Outlet />\n      </main>\n    </AgentSidebar>\n  );\n}",
+  "annotations": [
+    { "lines": "6", "label": "Wrapper", "note": "`<AgentSidebar>` wraps your whole layout. It adds the toggleable side panel; everything you pass as children stays in the main app area." },
+    { "lines": "8-12", "label": "Starter prompts", "note": "`suggestions` render as clickable chips on the empty chat." },
+    { "lines": "13", "label": "Context-aware chips", "note": "`dynamicSuggestions` merges screen-aware prompts (e.g. \"Summarize this selection\") with your static ones. On by default." },
+    { "lines": "18-20", "label": "Toggle button", "note": "Put `<AgentToggleButton />` anywhere in your header to open and close the panel." },
+    { "lines": "22-24", "label": "Your app", "note": "`<Outlet/>` (your routes) renders in the main area, untouched." }
+  ]
+}
+```
+
+Das ist es. Der Benutzer hat jetzt auf jeder Seite einen umschaltbaren Agenten – mit Chat-Verlauf, Arbeitsbereich-Tab, CLI-Terminal, Spracheingabe und einem Vollbildmodus. Der Status bleibt über Neuladevorgänge über `localStorage` hinweg bestehen.
+
+### Requisiten
+
+- **`children`** – das normale Layout und die Routen Ihrer App. Im Hauptbereich gerendert; Das Agentenfeld wird auf dem Desktop daneben und auf Mobilgeräten/im Vollbildmodus darüber angezeigt.
+- **`emptyStateText`** – Begrüßung, die angezeigt wird, wenn der Chat keine Nachrichten enthält. Standard: `"How can I help you?"`.
+- **`suggestions`** – Starter-Eingabeaufforderungen werden als anklickbare Chips gerendert, wenn sie leer sind.
+- **`dynamicSuggestions`** – kontextsensitive Eingabeaufforderungs-Chips, zusammengeführt mit `suggestions`. Standardmäßig aktiviert; Übergeben Sie `false`, um nur statische Vorschläge anzuzeigen, oder `{ max, includeStatic, getSuggestions }`, um es anzupassen.
+- **`defaultSidebarWidth`** – anfängliche Pixelbreite (nur Mount; Größenänderung durch Benutzer und Überschreiben gespeicherter Werte). Standard: `380`.
+- **`position`** – `"left"` oder `"right"`. Standard: `"right"`.
+- **`defaultOpen`** – ob die Seitenleiste geöffnet startet (nur Desktop). Standard: `false`.
+
+## Die anderen 20 %: `<AgentPanel>` {#panel}
+
+Wenn Sie die volle Kontrolle über das Layout benötigen – eine dedizierte `/chat`-Route, ein eingebettetes Panel in einer von Ihnen verwalteten Seitenspalte oder ein Popup – rendern Sie `<AgentPanel>` direkt:
+
+```tsx
+// app/routes/agent.tsx
+import { AgentPanel } from "@agent-native/core/client";
+
+export default function AgentRoute() {
+  return (
+    <div className="h-screen">
+      <AgentPanel defaultMode="chat" className="h-full" />
+    </div>
+  );
+}
+```
+
+`<AgentPanel>` bietet Ihnen die Rohregisterkarten (Chat / CLI / Arbeitsbereich) ohne den Seitenleisten-Wrapper, die Schaltfläche zum Reduzieren oder jegliche Statuspersistenz. Platzieren Sie es, wo immer Sie wollen; Sie kümmern sich um das Layout.
+
+### Ausgewählte Requisiten
+
+- **`defaultMode`** – `"chat"` oder `"cli"`. Standard: `"chat"`.
+- **`className`** – CSS-Klasse für den äußeren Container.
+- **`onCollapse`** – sofern vorhanden, erscheint in der Kopfzeile eine Schaltfläche zum Ausblenden.
+- **`isFullscreen`** / **`onToggleFullscreen`** – verknüpfen Sie den externen Vollbildstatus, wenn Sie eine zentrierte Spalte im Claude-Stil wünschen.
+- **`storageKey`** – Namespace für `localStorage`-Schlüssel. Nützlich, wenn Sie mehrere Panels (verschiedene App-Instanzen oder Arbeitsbereiche) auf derselben Seite rendern.
+
+Vollständige Requisiten: `AgentPanelProps` in `@agent-native/core/client`.
+
+## Programmatische Nachrichten: `sendToAgentChat()` {#send}
+
+Eine Schaltfläche, die die Arbeit an den Agenten übergibt (anstatt einen Inline-`llm()`-Aufruf auszuführen – das Anti-Pattern von [ladder](/docs/what-is-agent-native#the-ladder)):
+
+```tsx
+import { sendToAgentChat } from "@agent-native/core/client";
+
+<Button
+  onClick={() =>
+    sendToAgentChat({
+      message: "Generate a chart showing signups by source",
+      context: `Dashboard ID: ${dashboardId}, date range: last 30 days`,
+      submit: true,
+    })
+  }
+>
+  Generate chart
+</Button>;
+```
+
+### Optionen
+
+- **`message`** – die sichtbare Eingabeaufforderung, die im Chat angezeigt wird.
+- **`context`** – versteckter Kontext, der an die Eingabeaufforderung angehängt wird (ausgewählter Text, Cursorposition, aktuelle Entitäts-ID – alles, was der Agent wissen sollte, der Benutzer aber nicht zweimal sehen sollte).
+- **`submit`** – `true` für automatische Ausführung, `false` für Vorabfüllung, aber warten. Lassen Sie es weg, um den Projektstandard zu verwenden.
+- **`newTab`** – Erstellen Sie einen separaten Chat-Thread für diese Eingabeaufforderung.
+- **`background`** – mit `newTab` ausführen, ohne den neuen Thread zu fokussieren. Der versteckte Lauf wird in `RunsTray` verfolgt.
+- **`openSidebar`** – für Hintergrund-/stille Sendungen auf `false` eingestellt. Standardmäßig wird die Seitenleiste geöffnet, sodass der Benutzer die Antwort sieht.
+- **`type`** – `"content"` (Standard) behält die Arbeit im eingebetteten App-Agent. `"code"` leitet zum Codebearbeitungsrahmen weiter (für vom Agenten geschriebene Codeänderungen siehe [Frames](/docs/frames)).
+
+`sendToAgentChat` gibt ein stabiles `tabId` zurück, mit dem Sie den Chat-Lauf verfolgen können.
+
+Für geräuschloses Arbeiten koppeln Sie `newTab`, `background` und `openSidebar: false`:
+
+```ts
+sendToAgentChat({
+  message: "Summarize the selected thread and save the summary",
+  context: `Thread id: ${threadId}`,
+  submit: true,
+  newTab: true,
+  background: true,
+  openSidebar: false,
+});
+```
+
+Dies ist immer noch eine vollständige Agentenausführung mit Tools, actions, Thread-Status und Ausführung
+Verfolgung. Es stiehlt einfach nicht den Fokus vom aktuellen Seitenleistenstatus des Benutzers.
+
+Wenn dieselbe Route als MCP-App eingebettet ist, wird sie übermittelt
+`sendToAgentChat()`-Anrufe werden an den Host-Chat weitergeleitet, sofern dies unterstützt wird; siehe
+[Client](/docs/client#sendtoagentchat) für das MCP-App-Bridge-Verhalten.
+
+Wenn Sie einen Ladezustand wünschen, verwenden Sie den Hook `useSendToAgentChat()` – er gibt sowohl `send` als auch `isGenerating` zurück:
+
+```ts
+import { useSendToAgentChat } from "@agent-native/core/client";
+
+const { send, isGenerating } = useSendToAgentChat();
+```
+
+## Wenn die Standard-Seitenleiste nicht passt {#custom-chat-ui}
+
+`<AgentSidebar>` und `<AgentPanel>` decken die meisten Apps ab. Wenn Sie das
+Layout rund um den Agenten, oder Sie möchten die Konversation mit einem Agenten vorantreiben
+Sie haben an anderer Stelle erstellt, lassen Sie eine Ebene fallen – aber lassen Sie das Framework weiterhin besitzen
+Laufzeit, actions und SQL-gestützter Status:
+
+- **Besitzen Sie Chrome rund um die Standardlaufzeit.** Verwenden Sie `<AgentChatSurface>` für
+  eine dedizierte Chat-Route oder `<AssistantChat>`, wenn Sie benutzerdefinierte Header wünschen
+  Tabs und leere Zustände rund um die Standardkonversation. Die vollständige Ebenenkarte –
+  jede Komponente, jeder Hook, jeder Composer und jeder Adapter mit Importpfaden – lebt in
+  [Component API](/docs/components#agent-chat-ui).
+- **Bringen Sie Ihre eigene Agent-Laufzeit mit.** Wenn ein Agent, den Sie anderswo erstellt haben, dies tun sollte
+  treiben Sie die Konversation voran, während Agent-Native den Komponisten, das Transkript und das Tool behält
+  Karten, Genehmigungen und native Widgets übergeben ein `AgentChatRuntime` an
+  `<AssistantChat runtime={...} />`. Die Anschlüsse
+  (`createHttpAgentChatRuntime()` und OpenAI / Claude / Vercel AI / AG-UI
+  Helfer) und der Veranstaltungsvertrag sind in
+  [Native Chat UI — BYO agent runtimes](/docs/native-chat-ui#byo-agent-runtimes).
+
+Welche Ebene Sie auch wählen, behalten Sie den von actions und SQL unterstützten App-Status als Vertrag bei.
+und vermeiden Sie es, vom Produkt UI aus direkt auf `/_agent-native/agent-chat` zu posten. Wenn ein
+Der benannte Helfer fehlt für eine echte benutzerdefinierte Oberfläche. Fügen Sie daher zuerst diesen Helfer hinzu.
+Client-Code lernt keinen zweiten Ad-hoc-Transport.
+
+## Typsicheres actions vom UI: `useActionMutation()` {#use-action-mutation}
+
+Wenn der UI den gleichen Vorgang ausführen muss, den ein Agent-Tool ausführen würde – Strompfad 3 des [ladder](/docs/what-is-agent-native#rung-three) – verwenden Sie `useActionMutation`:
+
+```tsx
+import { useActionMutation } from "@agent-native/core/client";
+
+const { mutate, isPending } = useActionMutation("reply-to-email");
+
+<Button onClick={() => mutate({ emailId, body: "Thanks!" })}>
+  Send Reply
+</Button>;
+```
+
+Typsichere Argumente stammen aus dem Zod-Schema in Ihrem `defineAction()`. Das vollständige Aktionssystem finden Sie unter [Actions](/docs/actions).
+
+```an-callout
+{
+  "tone": "decision",
+  "body": "**`useActionMutation` vs `sendToAgentChat`.** Run the operation directly with `useActionMutation` when the user clicked a deterministic button (\"Send reply\"). Hand it to `sendToAgentChat` when the work needs the agent's reasoning, tools, or multi-step planning. Never call an inline `llm()` from UI — that is rung 1 of the [ladder](/docs/what-is-agent-native#the-ladder)."
+}
+```
+
+## Auswahl + Cursorerkennung {#selection}
+
+Der Agent kann über die Tasten `navigation` und `selection` im Anwendungsstatus sehen, was der Benutzer ausgewählt hat – Text, Zellen, Folien, Kontakte. Der leere Chat verwendet diese Tasten auch, um dynamische Vorschläge wie „Diese Auswahl zusammenfassen“ oder „Diese Folie verbessern“ anzubieten, wenn der aktuelle Bildschirm sie relevant macht. Wenn Sie möchten, dass Cmd-I (oder ähnlich) einen ausgewählten Bereich als Kontext in den Chat sendet, siehe [Context Awareness](/docs/context-awareness).
+
+## Alles zusammenfügen {#putting-it-together}
+
+Ein typisches Drop-in-Setup:
+
+```tsx
+// app/root.tsx
+import {
+  AgentSidebar,
+  AgentToggleButton,
+  sendToAgentChat,
+} from "@agent-native/core/client";
+
+export default function Root() {
+  return (
+    <AgentSidebar suggestions={["Draft a reply", "Summarize selection"]}>
+      <Header>
+        <AgentToggleButton />
+      </Header>
+
+      <Main>
+        <YourRoutes />
+      </Main>
+    </AgentSidebar>
+  );
+}
+```
+
+```tsx
+// Anywhere else in the app
+<Button
+  onClick={() =>
+    sendToAgentChat({
+      message: "Summarize this thread",
+      context: `Thread id: ${threadId}`,
+      submit: true,
+    })
+  }
+>
+  Summarize
+</Button>
+```
+
+Der Benutzer sieht in der Kopfzeile eine Chat-Schaltfläche, kann diese öffnen und mit dem Agenten sprechen. Ihre Tasten übergeben die Arbeit an denselben Agenten, anstatt einmalige LLM-Anrufe auszuführen.
+
+## Was kommt als nächstes?
+
+- [**Actions**](/docs/actions) – `defineAction()` und `useActionMutation()`
+- [**Context Awareness**](/docs/context-awareness) – Auswahl, Navigation, Ansichtsbildschirm
+- [**Workspace**](/docs/workspace) – was die Registerkarte „Arbeitsbereich“ enthält (skills, Speicher, MCP-Server, geplante Jobs)
+- [**Voice Input**](/docs/voice-input) – das Mikrofon im Chat Composer

package/docs/content/locales/de-DE/durable-resume.md

@@ -0,0 +1,65 @@
+---
+title: "Dauerhafter Lebenslauf"
+description: "Wenn die Ausführung eines gehosteten Agenten unterbrochen und fortgesetzt wird, werden abgeschlossene Tool-Aufrufe mit Nebeneffekten nicht erneut ausgeführt – ein aus dem dauerhaften Hauptbuch abgeleitetes Tool-Call-Journal blockiert doppelte Versendungen, Gebühren und Tickets."
+---
+
+# Dauerhafter Lebenslauf
+
+> **Für wen ist das gedacht:** Jeder, der verstehen möchte, wie das Framework funktioniert
+> -Wiederherstellung vermeidet doppelte Nebenwirkungen. Dies ist ein eingebautes Verhalten – es gibt
+> nichts zu verkabeln.
+
+Gehostete Agentenausführungen werden unterbrochen: Eine serverlose Funktion erreicht mitten im Stream ihr hartes Timeout, ein Gateway trennt die Verbindung nach 45 Sekunden, ein Socket hängt sich auf, die Plattform startet einen Kaltstart. Das Framework stellt diese bereits wieder her, indem es das Konversationspräfix speichert und den LLM-Aufruf erneut ausführt („Weiter an der Stelle, an der Sie aufgehört haben“). Aber die Wiederherstellung allein hat einen scharfen Vorteil: Wenn der unterbrochene Versuch **bereits eine E-Mail gesendet oder ein Ticket erstellt hat**, könnte ein naiver Lebenslauf es noch einmal tun.
+
+Dauerhafter Lebenslauf schließt diese Lücke. Beim Fortsetzen weiß das Framework, welche Toolaufrufe mit Nebeneffekten bereits abgeschlossen sind, und weigert sich, sie erneut auszuführen – und zwar auf zwei Ebenen.
+
+```an-diagram title="Two layers block duplicate side effects on resume" summary="The journal reads the durable ledger and classifies prior calls; layer 1 tells the model, layer 2 hard-blocks a re-dispatched write that matches a completed entry."
+{
+  "html": "<div class=\"diagram-durable\"><div class=\"diagram-box\" data-rough>Run-event ledger<br><small class=\"diagram-muted\">tool_start / tool_done</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel center\" data-rough><strong>Tool-call journal</strong><small class=\"diagram-ok\">completed = start+done</small><small class=\"diagram-warn\">interrupted = start, no done</small></div><div class=\"diagram-col\"><div class=\"diagram-pill\">Layer 1 · prompt note &rarr; model</div><div class=\"diagram-pill accent\">Layer 2 · hard-block re-dispatched write</div></div></div>",
+  "css": ".diagram-durable{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-durable .diagram-col{display:flex;flex-direction:column;gap:8px}.diagram-durable .diagram-arrow{font-size:22px;line-height:1}.diagram-durable .center{display:flex;flex-direction:column;align-items:center;gap:4px}"
+}
+```
+
+## Das Tool-Call-Journal {#journal}
+
+Das Journal ist ein **reiner Lesevorgang über das dauerhafte Run-Event-Ledger** – es gibt keinen neuen Aufzeichnungs-Hook im Hot-Pfad. Es klassifiziert die bereits für die aktuelle Runde aufgezeichneten Werkzeugaufrufe:
+
+- **Abgeschlossen** – ein `tool_start` mit einem passenden `tool_done`. Der Anruf wurde ausgeführt, die Nebenwirkung trat auf und das Ergebnis wurde aufgezeichnet. **Nicht erneut ausführen.**
+- **Unterbrochen** – ein `tool_start` mit **kein** passendem `tool_done`. Der Anruf begann, sein Nebeneffekt ist möglicherweise aufgetreten oder auch nicht, und die Unterbrechung hat das Ergebnis verschlungen. Ergebnis unbekannt.
+
+Matching spiegelt wider, wie dauerhafte Drehungen an anderer Stelle wiederhergestellt werden: Ein `tool_done` paart sich mit dem ältesten noch offenen `tool_start` für denselben Werkzeugnamen (FIFO pro Werkzeug). Ein `clear`-Ereignis (verworfene Teilausgabe) setzt die Zählung pro Runde zurück, sodass aufgegebene Teilausgaben keine offenen Phantomaufrufe hinterlassen.
+
+## Ebene 1: Journalnotiz auf Eingabeaufforderungsebene {#prompt-note}
+
+Wenn eine Ausführung fortgesetzt wird (Soft-Timeout, Gateway-Timeout oder irgendein wiederaufnehmbarer Transportfehler), hängt das Framework eine **strukturierte Journalnotiz** an die Wiederaufnahme-Eingabeaufforderung an, direkt nach dem Anstoß „Weiter an der Stelle, an der Sie aufgehört haben“. Die Notiz teilt dem Modell im Klartext mit:
+
+- welches Tool **bereits abgeschlossen** aufruft (mit kurzen Ergebnissen), sodass es sie wiederverwendet und **nicht** erneut ausführt, und
+- welche Toolaufrufe **mit unbekanntem Ergebnis unterbrochen** wurden, sodass der Status überprüft wird, bevor von Erfolg oder Misserfolg ausgegangen wird.
+
+Wenn das Journal leer ist (eine Wende ohne Werkzeugaktivität oder eine saubere Fortsetzung), wird nichts Zusätzliches angehängt und das Wiederaufnahmeverhalten ist Byte für Byte das gleiche wie zuvor. Der Hinweis gilt nach bestem Wissen und Gewissen: Ein fehlgeschlagener Ledger-Lesevorgang blockiert niemals eine ansonsten erfolgreiche Wiederherstellung.
+
+## Schicht 2: Werkzeugschicht-Hardblock {#hard-block}
+
+Der Aufforderungshinweis hat beratenden Charakter – ein braves Model beachtet ihn, aber ein Model ist keine Garantie. Die Schleife erzwingt es also auch auf der Werkzeugebene.
+
+Bevor die Schleife in einem wiederaufgenommenen Block ausgeführt wird, erstellt sie einmal einen Snapshot des Journals (wobei nur **vorherige** Blöcke dieser logischen Runde erfasst werden). Wenn das Modell ein **Schreibwerkzeug** erneut sendet, dessen Werkzeugname **und Eingabe** mit einem abgeschlossenen Journaleintrag übereinstimmen, wird die Schleife kurzgeschlossen: Sie gibt das aufgezeichnete Ergebnis zurück, anstatt die Aktion auszuführen, mit dem Hinweis, dass der Aufruf bereits in einem früheren unterbrochenen Versuch abgeschlossen wurde und nicht erneut ausgeführt wurde, um einen doppelten Nebeneffekt zu vermeiden.
+
+Schlüsseleigenschaften:
+
+- **Nur Schreibwerkzeuge.** Schreibgeschützt (`readOnly` / GET) actions werden niemals blockiert – erneutes Lesen ist sicher und idempotent.
+- **Content-addressed.** Die Übereinstimmung bezieht sich auf den Namen des Werkzeugs + die Eingabesignatur, sodass ein fortgesetzter Aufruf, der sich an einer anderen Position in der Runde befindet, immer noch übereinstimmt. Ein _anderer_ Aufruf (unterschiedliche Argumente) wird als neu behandelt und normal ausgeführt.
+- **Einmal verbrauchen.** Jeder abgeschlossene Eintrag wird beansprucht, wenn er übereinstimmt, sodass zwei wirklich unterschiedliche, identische neue Aufrufe in derselben Runde nicht beide bei einem protokollierten Abschluss kurzgeschlossen werden.
+- **Neue Anrufe bleiben unberührt.** Bei einem ersten Anruf wird ein leeres Journal angezeigt. Bei normalen Läufen ändert sich nichts.
+
+```an-callout
+{
+  "tone": "success",
+  "body": "Together the two layers mean an interrupted run that already had a real side effect resumes **without repeating it** — no duplicate emails, charges, or tickets — while genuinely new work still runs. Read-only actions are never blocked; re-reading is always safe."
+}
+```
+
+## Verwandt
+
+- [**Real-Time Sync**](/docs/real-time-collaboration) – wie das dauerhafte Laufbuch zum Client streamt und bei erneuter Verbindung wiedergibt.
+- [**Actions**](/docs/actions) – `readOnly` markiert Lesevorgänge als sicher für die erneute Ausführung; alles andere wird als Nebenwirkung behandelt.
+- [**In-Loop Processors**](/docs/processors) – eine weitere schleifeninterne Verhärtungsnaht.