@agent-native/core 0.76.5 → 0.76.6

package/docs/content/locales/de-DE/cloneable-saas.md

@@ -0,0 +1,114 @@
+---
+title: "Vorlagen"
+description: "Forken Sie ein funktionierendes SaaS-Produkt und machen Sie es zu Ihrem – Agent inklusive."
+---
+
+# Vorlagen
+
+Möchten Sie Ihr eigenes KI-gestütztes Analysetool liefern? Mail-Client? Formularersteller? Wählen Sie eine Vorlage und Sie haben in wenigen Minuten ein funktionierendes SaaS – Agent, Datenbank, Authentifizierung und Bereitstellungspipeline sind bereits verkabelt.
+
+Die meisten „Vorlagen“ geben Ihnen ein leeres Gerüst und eine lange TODO-Liste. Agent-Native macht das anders. Bei jedem einzelnen handelt es sich um ein **komplettes Produkt auf SaaS-Niveau** – bereits am ersten Tag lauffähig, bereits lieferbar und ganz Ihnen überlassen, individuell anzupassen, zu branden und bereitzustellen. Betrachten Sie sie als klonbare SaaS, nicht als Starter-Kits: Sie forken ein fertiges Produkt und starren nicht auf die Standardversion.
+
+## Vorlagen verfügbar {#catalog}
+
+Jede davon ist eine echte App, die Sie heute verwenden können, und die Startrampe für Ihre eigene Version davon.
+
+| Vorlage                                   | Was es ist                                                                                                                                                 |
+| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [**Chat**](/docs/template-chat)           | Minimale Chat-First-App mit dauerhaften Threads, actions, Authentifizierung und einem sauberen Pfad zum benutzerdefinierten UI oder Ihrem eigenen Backend. |
+| [**Mail**](/docs/template-mail)           | Ein aus Agenten stammender Übermensch. Posteingang, Beschriftungen, KI-Selektion, Tastatureingabe, Entwürfe und Versendungen über den Agenten.             |
+| [**Calendar**](/docs/template-calendar)   | Ein agentennativer Google Calendar. Ereignisse, Synchronisierung, öffentliche Buchungslinks, agentengesteuerte Planung.                                    |
+| [**Content**](/docs/template-content)     | Open-Source-Obsidian für MDX. Lokaler Markdown/MDX, Tiptap-Editor, Notion-Synchronisierung, Zusammenarbeit mit mehreren Benutzern in Echtzeit.             |
+| [**Brain**](/docs/template-brain)         | Sauberer Unternehmenschat, gestützt durch zitiertes institutionelles Gedächtnis, genehmigte Quellen, Überprüfungstore und Zitate.                          |
+| [**Assets**](/docs/template-assets)       | Digital Asset Manager für Markenbibliotheken, Uploads, Referenzen und die Erstellung von markenbezogenen Bildern/Videos.                                   |
+| [**Slides**](/docs/template-slides)       | Eine agentennative Google Slides. React-basierte Decks, die der Agent direkt generiert und bearbeitet.                                                     |
+| [**Video**](/docs/template-videos)        | Programmatische Bewegungsgrafiken und Produktdemovideos zu Remotion.                                                                                       |
+| [**Analytics**](/docs/template-analytics) | Ein agentennatives Amplitude/Mixpanel. Datenquellen verbinden, Diagramme anfordern, an Dashboards anpinnen.                                                |
+| [**Clips**](/docs/template-clips)         | Asynchrone Bildschirm- und Kameraaufzeichnung mit Transkription, Kapiteln und KI-Zusammenfassungen.                                                        |
+| [**Design**](/docs/template-design)       | Agent-natives HTML-Prototyping-Studio für interaktive Alpine/Tailwind-Designs.                                                                             |
+| [**Forms**](/docs/template-forms)         | Ein agentennatives Typformular. Erstellen, teilen, sammeln und leiten Sie Einsendungen an Slack, Sheets, webhooks oder Discord weiter.                     |
+| [**Plan**](/docs/template-plan)           | Visuelle Pläne und PR-Zusammenfassungen mit Diagrammen, Wireframes und Anmerkungen.                                                                        |
+| [**Dispatch**](/docs/template-dispatch)   | Die Workspace-Steuerungsebene: gemeinsame Geheimnisse, wiederverwendbare Integrationen, Slack/Telegram, geplante Jobs.                                     |
+
+Sie möchten keine Domain-Vorlage? Verwenden Sie [Chat](/docs/template-chat), wenn Sie eine einfache App wünschen, mit der Benutzer sofort sprechen können, oder beginnen Sie mit [Pure-Agent Apps](/docs/pure-agent-apps) zuerst mit der Aktion.
+
+Sehen Sie sich den vollständigen Katalog unter [Templates](/templates) an oder springen Sie direkt zu einem – [Dispatch](/docs/template-dispatch) ist beispielsweise ein großartiger Ausgangspunkt, wenn Sie eine App im Workspace-Stil wünschen.
+
+## Was Sie im Lieferumfang enthalten {#what-you-get}
+
+Jede Vorlage wird mit den Teilen geliefert, deren Erstellung normalerweise Monate dauert:
+
+- **Ein funktionierender Agent** – bereits mit der App verbunden, bereits in der Lage, actions auf Ihre Daten zu übertragen, bereits kontextbewusst darüber, was Sie gerade sehen. Informationen zur Funktionsweise finden Sie unter [Messaging the agent](/docs/messaging).
+- **Auth** – Anmeldung, Sitzungen, Organisationen, mandantenfähige Isolation. Bereits erledigt.
+- **Eine Datenbank** – für jede Vorlage stehen Schema, Abfragen und Migrationen bereit. Bringen Sie Ihre eigene SQL-Datenbank (Postgres, SQLite, Turso, D1) mit – das Framework passt sich an.
+- **Ein Echtzeit-UI** – der Bildschirm bleibt mit den Aktionen des Agenten synchronisiert. Klicken Sie im Chat auf „E-Mail entwerfen“. Der Entwurf erscheint sofort in Ihrem Posteingang.
+- **Bereitstellungsbereit** – Push an Netlify, Vercel, Cloudflare, AWS oder an einen anderen Ort, an dem Node ausgeführt wird. Keine Lieferantenbindung.
+- **Branding-Hooks** – Name, Farben, Logo und Text können einfach geändert werden.
+
+Dies ist keine theoretische Behauptung. Der Autor des Frameworks führt seinen tatsächlichen Posteingang auf der Mail-Vorlage, seinen tatsächlichen Kalender auf der Kalendervorlage und seine tatsächlichen Analysen auf der Analytics-Vorlage aus. Vorlagen sind tägliche Treibersoftware.
+
+## Was Sie tun {#what-you-do}
+
+Der Weg von „Ich möchte mein eigenes SaaS“ zu „Ich habe mein eigenes SaaS“ ist kurz:
+
+```an-diagram title="Fork and customize" summary="Pick a finished product, brand it, evolve it in plain English, and ship it to your own domain."
+{
+  "html": "<div class=\"diagram-fork\"><div class=\"diagram-card\"><span class=\"diagram-pill\">1</span><strong>Pick</strong><small class=\"diagram-muted\">a complete template</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-card\"><span class=\"diagram-pill\">2</span><strong>Brand</strong><small class=\"diagram-muted\">name, colors, logo, copy</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-card\"><span class=\"diagram-pill accent\">3</span><strong>Customize</strong><small class=\"diagram-muted\">ask the agent &#8635;</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-card\"><span class=\"diagram-pill ok\">4</span><strong>Ship</strong><small class=\"diagram-muted\">your own domain</small></div></div>",
+  "css": ".diagram-fork{display:flex;align-items:center;gap:10px;flex-wrap:wrap}.diagram-fork .diagram-card{display:flex;flex-direction:column;gap:6px;padding:14px 16px;min-width:130px}.diagram-fork .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+1. **Wählen Sie eine Vorlage.** Verwenden Sie die CLI-Auswahl oder durchsuchen Sie die Dokumente und wählen Sie eine aus, mit der Sie beginnen möchten.
+2. **Marken Sie es.** Ändern Sie den Namen, die Farben, das Logo und den Text. Die meisten Vorlagen stellen dies in einer einzigen Konfigurationsdatei bereit.
+3. **Passen Sie es an.** Bitten Sie den Agenten, die benötigte Spalte hinzuzufügen, die Posteingangsgruppen zu ändern, eine Verbindung zu Ihrem internen API herzustellen und eine neue Ansicht hinzuzufügen. Der Agent bearbeitet den Code; Sie überprüfen den Unterschied.
+4. **Versenden Sie es.** Führen Sie den Bereitstellungsbefehl aus. Sie haben jetzt Ihr eigenes Produktions-SaaS in Ihrer eigenen Domain.
+
+Die Schritte 2–4 dauern normalerweise Tage, nicht Monate. Schritt 3 ist ergebnisoffen – Ihr geforktes SaaS entwickelt sich im Laufe der Zeit, im Klartext, durch Gespräche mit dem Agenten.
+
+## Warum das praktisch ist {#why}
+
+Ein traditionelles Fork-the-Codebase-Modell bricht im großen Maßstab zusammen: Jeder Benutzer, der seinen eigenen Posteingang verwaltet, klingt wie ein Wartungsalbtraum. Zwei Rahmenentscheidungen machen es möglich:
+
+1. **Der Agent übernimmt die Wartung.** Sie schreiben keinen Code, um eine Spalte hinzuzufügen oder eine neue Integration zu verbinden – Sie fragen den Agenten. „Ihr eigener gespaltener Posteingang“ ist also eine Funktion und keine Belastung.
+2. **Anpassung pro Benutzer ohne Code pro Benutzer.** Skills, Speicher, Anweisungen, verbundene MCP-Server und Subagenten befinden sich alle in SQL. Jeder Benutzer erhält seine eigene Anpassungsebene; Die gemeinsame Codebasis hostet sie alle gleichzeitig.
+
+Das Ergebnis: Flexibilität auf Claude-Codeebene für jeden Benutzer, mit normaler SaaS-Bereitstellungsökonomie.
+
+```an-diagram title="Why per-user forks scale" summary="Two ideas keep the fork-and-customize model practical: the agent does the maintenance, and per-user customization lives in SQL — not in per-user code."
+{
+  "html": "<div class=\"diagram-why\"><div class=\"diagram-panel\" data-rough><strong>Shared codebase</strong><small class=\"diagram-muted\">one app, deployed once</small><div class=\"diagram-pill accent\">agent does the maintenance</div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&harr;</div><div class=\"diagram-panel\" data-rough><strong>Per-user layer in SQL</strong><small class=\"diagram-muted\">skills · memory · instructions · MCP · sub-agents</small><div class=\"diagram-pill ok\">no per-user code</div></div></div>",
+  "css": ".diagram-why{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-why .diagram-panel{display:flex;flex-direction:column;gap:8px;padding:14px 18px;min-width:240px;flex:1}.diagram-why .diagram-arrow{font-size:24px;line-height:1}"
+}
+```
+
+## Möchten Sie nicht forken? {#hosted}
+
+Das musst du nicht. Jede Vorlage ist auch als gehostete App auf `agent-native.com` – `mail.agent-native.com`, `calendar.agent-native.com` usw. verfügbar. Nutzen Sie die gehostete Version kostenlos oder kostenpflichtig; Fork nur, wenn Sie etwas ändern möchten, das die gehostete Version nicht offenlegt.
+
+## Probieren Sie es mit einer Fertigkeit aus {#try-with-a-skill}
+
+Nicht bereit für den Gerüstbau? Sie können einem Codierungsagenten, den Sie bereits verwenden, agentennative Superkräfte mit einem einzigen Befehl hinzufügen – keine App erforderlich. Siehe [Skills Guide](/docs/skills-guide#app-backed-skills).
+
+## Darauf aufbauen
+
+- [**Getting Started**](/docs/getting-started) – Erstellen Sie eine minimale Chat-App oder einen Headless-Agenten
+- [**Messaging the agent**](/docs/messaging) – wie Benutzer (und Sie) mit dem Agenten kommunizieren, der mit jeder Vorlage geliefert wird
+- [**Multi-App Workspace**](/docs/multi-app-workspace) – Bündeln Sie mehrere Vorlagen in einem Arbeitsbereich, der Authentifizierung, Marke und Agent teilt
+- [**Dispatch**](/docs/template-dispatch) – die Vorlage für die Steuerungsebene des Arbeitsbereichs
+- [**Creating Templates**](/docs/creating-templates) – Erstellen und veröffentlichen Sie Ihre eigene Vorlage
+
+### Für Entwickler {#dev-details}
+
+Wenn Sie jetzt ein Gerüst erstellen, lautet der CLI-Befehl:
+
+```bash
+npx @agent-native/core@latest create my-platform
+```
+
+Sie erhalten eine Mehrfachauswahl-Auswahl. Wählen Sie eine App (eigenständig) oder mehrere (Arbeitsbereich – Apps teilen sich Authentifizierung, Marke, Agentenkonfiguration und Datenbank). Jede ausgewählte Vorlage wird mit jeder benötigten Datei in `apps/<name>/` eingebunden. Für eine reine Aktions-App anstelle einer Vorlage UI verwenden Sie `npx @agent-native/core@latest create my-agent --headless`.
+
+Geben Sie `.env` (hauptsächlich `ANTHROPIC_API_KEY` und `DATABASE_URL`), `pnpm install`, `pnpm dev` ein und es funktioniert. Kein „TODO: Login implementieren“, keine Platzhalterrouten.
+
+Ziele bereitstellen: jeder Nitro-kompatible Host (Node, Cloudflare, Netlify, Vercel, Deno, Lambda, Bun) und jede Drizzle-kompatible SQL-Datenbank (SQLite, Postgres, Turso, D1, Supabase, Neon). Für Arbeitsbereiche erstellt `npx @agent-native/core@latest deploy` jede App auf einmal und versendet sie hinter einem einzigen Ursprung. Siehe [Deployment](/docs/deployment).
+
+Informationen zum Erstellen und Veröffentlichen Ihrer eigenen Vorlage finden Sie unter [Creating Templates](/docs/creating-templates).

package/docs/content/locales/de-DE/code-agents-ui.md

@@ -0,0 +1,436 @@
+---
+title: "Agent-Native Code UI"
+description: "Erstellen und passen Sie Agent-Native-Codeoberflächen mit dem gemeinsam genutzten UI-Paket, der Desktop-Host-Bridge und dem CLI-Run-Store an."
+---
+
+# Agent-Native Code UI
+
+> **Für wen ist das gedacht:** Host-Autoren, die einen Coding-Workspace erstellen oder anpassen
+> -Oberfläche (CLI, Desktop oder eine Browservorlage) auf dem freigegebenen Code-UI-Paket.
+
+## Welches Codierungsdokument möchte ich? {#which-doc}
+
+| Sie möchten…                                                                       | Verwenden                              |
+| ---------------------------------------------------------------------------------- | -------------------------------------- |
+| Rendern Sie einen **Codierungsarbeitsbereich UI** im Claude-Code/Codex-Stil        | **Agent-Native Code UI** (diese Seite) |
+| Führen Sie Claude Code / Codex / Pi **als Agent** mit eigener Schleife + Tools aus | [Harness Agents](/docs/harness-agents) |
+| Tausch das Backend, das das **`run-code`-Tool** des Agenten ausführt               | [Adapters](/docs/sandbox-adapters)     |
+| Verpacken Sie ein CLI-Tool (`gh`, `ffmpeg`), damit der Agent anrufen kann          | [Adapters](/docs/sandbox-adapters)     |
+
+Agent-Native Code ist die Agent-Native-Codierungsoberfläche: ein lokaler Arbeitsbereich im Claude Code/Codex-Stil für Codierungssitzungen, Slash-Befehle, Migrationen, Audits, Transkripte, Laufkontrollen und Nachverfolgungen. Ein einfacher `npx @agent-native/core@latest`-Befehl öffnet diesen Arbeitsbereich; `npx @agent-native/core@latest code` ist der explizite Unterbefehl für dasselbe Erlebnis.
+
+Es gibt drei Ebenen:
+
+- **CLI**: `npx @agent-native/core@latest` und `npx @agent-native/core@latest code` starten, fortsetzen, prüfen und stoppen Läufe.
+- **Desktop**: Die Registerkarte „Code“ in der linken Seitenleiste fügt nativen Terminalstart, App-Webansichten und Desktop-Deep-Links hinzu, während dasselbe Ausführungsmodell verwendet wird.
+- **Shared UI**: `@agent-native/code-agents-ui` rendert die wiederverwendbare React-Oberfläche.
+
+```an-diagram title="Three layers over one run store" summary="CLI, Desktop, and the shared UI are different surfaces over the same file-backed run store and executor; hosts adapt it via the CodeAgentsHost contract."
+{
+  "html": "<div class=\"diagram-layers\"><div class=\"diagram-row\"><div class=\"diagram-card\" data-rough><span class=\"diagram-pill\">CLI</span><small class=\"diagram-muted\">start · resume · status · stop</small></div><div class=\"diagram-card\" data-rough><span class=\"diagram-pill\">Desktop</span><small class=\"diagram-muted\">native terminal · webviews · deep links</small></div><div class=\"diagram-card\" data-rough><span class=\"diagram-pill accent\">Shared UI</span><small class=\"diagram-muted\">@agent-native/code-agents-ui</small></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-panel center\" data-rough><span class=\"diagram-pill\">CodeAgentsHost</span><small class=\"diagram-muted\">host contract</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-box\" data-rough>File-backed run store + executor<br><small class=\"diagram-muted\">@agent-native/core/code-agents</small></div></div>",
+  "css": ".diagram-layers{display:flex;flex-direction:column;gap:10px;align-items:center}.diagram-layers .diagram-row{display:flex;gap:12px;flex-wrap:wrap;justify-content:center}.diagram-layers .diagram-card{display:flex;flex-direction:column;gap:4px;padding:12px 16px}.diagram-layers .diagram-arrow{font-size:22px;line-height:1}.diagram-layers .center{display:flex;flex-direction:column;align-items:center;gap:4px}"
+}
+```
+
+Die aktuelle Aufteilung ist absichtlich konvergierend: Die Standard-Agenten-Seitenleiste und die Agenten-Teams werden im zentralen `run-manager`-Lebenszyklus ausgeführt, während Agent-Native-Code lokale, lang laufende Sitzungen verwendet, die durch den dateibasierten Code-Ausführungsspeicher und das gemeinsame Controller-Vokabular für die Hintergrundausführung unterstützt werden.
+
+Das gemeinsam genutzte UI ist hostgesteuert. Es weiß nicht, ob es in Electron, einer Browservorlage oder einer künftig gehosteten Shell ausgeführt wird. Hosts stellen eine `CodeAgentsHost`-Implementierung bereit.
+
+```ts
+import { CodeAgentsApp, type CodeAgentsHost } from "@agent-native/code-agents-ui";
+import "@agent-native/code-agents-ui/styles.css";
+
+const host: CodeAgentsHost = {
+  listRuns: (goalId) => listRunsSomehow(goalId),
+  listCodePacks: () => listCodePacksSomehow(),
+  createRun: (request) => createRunSomehow(request),
+  subscribeTranscript: (request, callback) =>
+    subscribeToTranscriptSomehow(request, callback),
+  readTranscript: (request) => readTranscriptSomehow(request),
+  appendFollowUp: (request) => appendFollowUpSomehow(request),
+  updateRun: (request) => updateRunSomehow(request),
+  retryRun: (request) => retryRunSomehow(request),
+  rerunRun: (request) => rerunRunSomehow(request),
+  controlRun: (goalId, runId, command, permissionMode) =>
+    controlRunSomehow({ goalId, runId, command, permissionMode }),
+};
+
+export function CodeSurface() {
+  return <CodeAgentsApp apps={[]} host={host} />;
+}
+```
+
+Hosts können Ausführungsquellen in derselben Liste mischen. Lokale Agent-Native-Codesitzungen
+kann neben Agent Teams oder anderen im Hintergrund ausgeführten Adaptern angezeigt werden, solange jeder
+normalisiert sich zu `CodeAgentRun`. Wenn ein Host `sourceLabel` bereitstellt,
+`source` oder `kind`, der Hub rendert eine kleine Quellbezeichnung wie „Lokaler Code“
+oder „Agent Teams“ in der Ausführungsliste und im Header der ausgewählten Sitzung. Lassen Sie diese Felder weg
+für eine Single-Source-Oberfläche; Der leere Zustand und das Basislayout bleiben unverändert.
+
+## Desktop-Host
+
+Desktop verwendet das freigegebene UI, behält aber die privilegierten Funktionen in Electron:
+
+- Öffnen eines nativen Terminals
+- Rendering optionaler App-gestützter Oberflächen mit `AppWebview`
+- Verarbeitung von `agentnative://open?...`-Links
+- Lokale Ausführungsprozesse verfolgen
+- Aufzeichnung der Lenkung im Vergleich zu in der Warteschlange stehenden Folgeaktionen für aktive Läufe
+- Native Code-Sitzungen wiederholen und ausführen, einschließlich `/migrate` und `/audit`
+- einen von ihm gestarteten Prozess stoppen
+
+Diese Trennung ist wichtig. Der UI kann von Vorlagen wiederverwendet werden, die native Prozesssteuerung sollte jedoch in Desktop oder CLI verbleiben.
+
+## Codex CLI Auth {#codex-cli-auth}
+
+Agent-Native-Code kann ein lokales Codex CLI-Login anstelle eines OpenAI API-Schlüssels verwenden.
+Installieren Sie Codex CLI auf Ihrem `PATH`, melden Sie sich einmal an und starten Sie dann Desktop oder
+Code UI, wenn es bereits geöffnet war:
+
+```bash
+npm install -g @openai/codex@latest
+codex login
+codex login status
+```
+
+Desktop und CLI lesen `codex login status` und führen `codex exec` aus, also
+Verwenden Sie das von Ihnen installierte ChatGPT-Abonnement oder die API-Schlüsselauthentifizierung wieder.
+berichte. Dies ist unabhängig vom `@ai-sdk/harness-codex`-Paket, das von
+[Harness Agents](/docs/harness-agents); Der Kabelbaumadapter kann lokal kopieren
+Codex CLI authentifiziert sich nur dann in einer vertrauenswürdigen Sandbox, wenn `codexCliAuth: true` aktiviert ist
+explizit aktiviert.
+
+## Browser-Host
+
+Die alte versteckte `code`-Vorlage wurde entfernt. Um eine vom Browser gehostete Codeoberfläche zu erstellen, erstellen Sie eine normale App und mounten das freigegebene UI-Paket mit einer Host-Implementierung:
+
+```bash
+npx @agent-native/core@latest create my-code-ui --template chat
+cd my-code-ui
+pnpm add @agent-native/code-agents-ui
+pnpm install
+pnpm dev
+```
+
+Ihr Host kann den lokalen Ausführungsspeicher über normales actions umschließen. Dies sind
+hosteigene actions, die Sie selbst definieren würden – sie sind kein ausgeliefertes Framework
+actions – Zuordnung jeder `CodeAgentsHost`-Methode zum Laufspeicher, zum Beispiel:
+
+- eine Aktion „Liste führt aus“, die `listRuns` unterstützt
+- eine Aktion „Codepakete auflisten“, die `listCodePacks` unterstützt
+- eine Aktion „Lauf erstellen“, die `createRun` unterstützt
+- eine Aktion „Transkript lesen“, die `readTranscript` unterstützt
+- eine Aktion „Folge anhängen“, die `appendFollowUp` unterstützt
+- eine „Aktualisierungslauf“-Aktion, die `updateRun` unterstützt
+- eine „Kontrolllauf“-Aktion, die `controlRun` unterstützt
+
+Jeder ruft `@agent-native/core/code-agents` auf, wodurch dasselbe verfügbar gemacht wird
+dateigestützter Ausführungsspeicher und Executor, der vom CLI verwendet wird.
+
+## CLI Laufkontrollen
+
+Der CLI der obersten Ebene verhält sich wie der Claude-Code oder der Codex:
+
+```bash
+npx @agent-native/core@latest
+npx @agent-native/core@latest "fix the failing auth tests"
+npx @agent-native/core@latest code
+```
+
+Verwenden Sie `npx @agent-native/core@latest code`, wenn Sie den expliziten Namespace wünschen. Eingebauter Schrägstrich
+Ziele und Projektbefehle können im interaktiven Arbeitsbereich oder direkt ausgeführt werden
+aus der Shell:
+
+```bash
+npx @agent-native/core@latest code /migrate ./legacy-app --emit ./migration-dossier
+npx @agent-native/core@latest code /audit --url https://example.com
+npx @agent-native/core@latest code /release-check
+```
+
+Hier sind `/migrate` und `/audit` integrierte Ziele (die integrierten Ziele sind
+`task`, `migrate` und `audit`). `/release-check` wird als Beispiel für ein
+Projektbefehl – definiert in `.agents/commands/`, kein integriertes Ziel. Projekt
+Befehle kommen von `.agents/commands/*.md`; Projekt skills stammen von
+`.agents/skills/*/SKILL.md`. Die Steuerbefehle werden im selben Lauf ausgeführt
+zeichnet auf, dass auf der Registerkarte „Desktop-Code“ und der freigegebenen UI Folgendes angezeigt wird:
+
+```bash
+npx @agent-native/core@latest code list
+npx @agent-native/core@latest code status --last
+npx @agent-native/core@latest code attach --last
+npx @agent-native/core@latest code logs --last
+npx @agent-native/core@latest code resume --last
+npx @agent-native/core@latest code stop --last
+npx @agent-native/core@latest code ui
+```
+
+`resume` hängt Kontext an und setzt einen Lauf fort, `status` meldet den letzten Lauf
+Zustand, `stop` fordert den aktiven Controller auf, die Arbeit anzuhalten, und `ui` öffnet den lokalen
+Codeoberfläche. Dabei handelt es sich um Ausführungskontrollen, nicht um einen separaten Implementierungspfad. Wenn ein
+Befehl mit hohem Risiko wartet auf Genehmigung, `approve --last` führt diesen noch aus
+Befehl und weist Sie dann zurück, um die Sitzung fortzusetzen.
+
+Ausführungsmodi machen die Bearbeitungsrichtlinie pro Sitzung explizit:
+
+| Modus                   | CLI-Flag | Verhalten                                                                                                                                                |
+| ----------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Planmodus**           | `--plan` | Inspizieren, planen und erklären, ohne Dateien zu schreiben oder Mutationen auszuführen.                                                                 |
+| **Automatischer Modus** | `--auto` | Bearbeiten Sie Dateien, führen Sie Prüfungen durch und pausieren Sie nur bei wirklich destruktiven Datei-, Git-, Veröffentlichungs- oder Datenvorgängen. |
+
+Der automatische Modus ist die Standardeinstellung für lokale Agent-Native Code-Sitzungen. Verwenden Sie den Planmodus für
+Bewertung, Architektur, Überprüfung oder jede Aufgabe, bei der Sie vorher einen Vorschlag wünschen
+Änderungen.
+
+Für oberflächenübergreifende Listen, Dashboards oder Überwachungsbereiche bevorzugen Sie die gemeinsame Nutzung
+Im Hintergrund ausgeführte Exporte von `@agent-native/core/code-agents` über das Lesen von Code
+Dateien direkt ausführen. Sie normalisieren lokale Codesitzungen im gleichen Vokabular
+wird von gehosteten Hintergrundarbeiten verwendet: Lauf-ID, Status, CWD, Bedarfseingabe,
+Genehmigung erforderlich, Transkriptereignisse und Artefaktstamm.
+
+Gehostete Agententeams werden auch über die Agenten-Chat-Route für den Browser angezeigt
+Hosts, die eine Code-Hub-kompatible Liste ohne direkte Serverimporte benötigen:
+`GET /_agent-native/agent-chat/runs/list?goalId=agent-team` gibt zurück
+`{ status: "ok", goalId, runs }`, wobei jeder Lauf `kind` enthält,
+`source`, `sourceLabel`, `status`, `title`, Zeitstempel und Aufgabenmetadaten.
+`GET /_agent-native/agent-chat/runs/:id/background-events` gibt den
+Gemeinsame Hintergrundtranskriptereignisse für einen Agent Teams-Lauf.
+
+Adaptergestützte Hosts können auch Quellmetadaten anhängen:
+
+```ts
+{
+  id: run.id,
+  goalId: "task",
+  title: run.title,
+  source: "agent-teams",
+  sourceLabel: "Agent Teams",
+  kind: "background-run",
+  status: run.status,
+  createdAt: run.createdAt,
+  updatedAt: run.updatedAt,
+}
+```
+
+## Store ausführen
+
+Lokale Agent-Native-Codeausführungen werden gespeichert unter:
+
+```text
+~/.agent-native/code-agents
+```
+
+Legen Sie `AGENT_NATIVE_CODE_AGENTS_HOME` fest, um einen Vorlagen- oder Testlaufspeicher zu isolieren.
+
+```bash
+AGENT_NATIVE_CODE_AGENTS_HOME=./data/code-agents pnpm dev
+```
+
+## Host-Vertrag
+
+`CodeAgentsHost` ist absichtlich klein:
+
+| Methode                                               | Zweck                                                                                                           |
+| ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `listRuns(goalId?)`                                   | Sitzungen für das ausgewählte Ziel auflisten                                                                    |
+| `listCodePacks?()`                                    | `.agents/commands` und `.agents/skills` auflisten                                                               |
+| `createRun(request)`                                  | Neuen Lauf starten                                                                                              |
+| `subscribeTranscript?(request, callback)`             | Übertragen Sie Transkriptaktualisierungen an die geteilte Konversation                                          |
+| `readTranscript(request)`                             | Transkriptereignisse als Kompatibilitäts-Fallback abfragen                                                      |
+| `appendFollowUp(request)`                             | Fügen Sie eine Nachverfolgung hinzu, die entweder aktive Arbeit steuert oder sich in der Warteschlange befindet |
+| `updateRun(request)`                                  | Aktualisierungsmodus oder Metadaten ausführen                                                                   |
+| `retryRun?(request)`                                  | Wiederholen Sie die ausgewählte Ausführung direkt                                                               |
+| `rerunRun?(request)`                                  | Starten Sie einen neuen Lauf von einer vorherigen Eingabeaufforderung aus                                       |
+| `controlRun(goalId, runId, command, permissionMode?)` | Fortsetzen, genehmigen, aktualisieren oder stoppen                                                              |
+| `openTerminal?(request)`                              | Optionaler nativer Terminal-Hook                                                                                |
+
+Browser-Hosts sollten einen ordnungsgemäßen `openTerminal`-Fehler zurückgeben, anstatt zu versuchen, den nativen Terminalstart zu emulieren.
+
+## Gemeinsamer Komponist
+
+Agent-Native-Code verwendet dasselbe `AgentComposerFrame` + `PromptComposer` /
+`TiptapComposer`-Stack wurde aus `@agent-native/core/client/composer` als
+Framework-Agent-Seitenleiste. Verzweigen Sie kein separates
+Textbereich, Codierungstool-Auswahl, Upload-Auswahl, Sprachschaltfläche, Modellauswahl oder Enter-to-Submit
+Implementierung für Code-ähnliche Oberflächen. Wenn ein Host ein zusätzliches Steuerelement benötigt, übergeben Sie
+es über die freigegebenen Composer-Erweiterungspunkte, also die Seitenleiste, Code UI und
+Brain-Chat behält das gleiche Interaktionsmodell und Gesichtsfeld bei.
+
+Die Ask-Route von Brain verwendet `AgentChatSurface`, das bereits von
+Standard-Sidebar-Composer. Der Code verwendet `PromptComposer` direkt, weil der Host
+ist für die Lauferstellung, die Transkripte und die Nachbereitung verantwortlich.
+
+## Gemeinsame Codierungstools
+
+Der Sidebar-Entwicklungsagent und der Agent-Native-Code verwenden beide dasselbe Minimum
+Coding-Tool-Profil: `bash`, `read`, `edit` und `write`. `bash` ist die Standardeinstellung
+zum Auflisten/Durchsuchen von Dateien, Ausführen von Tests und Aufrufen von Projekt-CLIs; `read`
+zeigt zeilennummerierte Dateiabschnitte; `edit` wendet exakte Textersetzungen an; und
+`write` ist für neue Dateien oder absichtliche vollständige Neuschreibungen reserviert. Ältere Aliase
+wie `shell`, `read-file`, `write-file`, `list-files` und `search-files`
+sind nur kompatibel und nicht Teil der standardmäßig beworbenen Oberfläche.
+
+Codespezifisches UI gehört in die Nähe des Komponisten, nicht in ein abgezweigtes Chatfeld. Die
+gemeinsamer Code UI kann Slots hinzufügen für:
+
+- Steuerung des Auto-/Planmodus.
+- Die ausgewählten CWD-, Projektauswahl- und Ausführungsmetadaten.
+- Angebote, die nur für Gastgeber gelten, z. B. das Öffnen eines Terminals.
+
+Alles andere bleibt im gemeinsamen Composer: Anhänge, Referenzen, Schrägstriche und
+Fertigkeit Einfügen, Umgang mit eingefügtem Text, Sprachdiktat, Entwürfe, Tastatur
+Verknüpfungen und Übermittlungssemantik.
+
+Das benutzerorientierte Transkript sollte gesprächig bleiben. Code-Hosts normalisieren Raw
+Transkript-/Status-/Tool-Ereignisse in den Renderer für gemeinsame Konversationen: Assistent
+Text fügt sich in einer Runde zusammen, das Rauschen des Lebenszyklus mit geringem Signal bleibt aus dem Hauptteil
+Oberfläche und Werkzeugaktivität werden als kompakte Inline-Zusammenfassungen mit Details gerendert
+bei Bedarf verfügbar.
+
+## Slash-Befehle
+
+Agent-Native Code behandelt Migration als eine Funktion, nicht als separate App-Kategorie. `/migrate` kann ein integriertes Ziel, ein Projektbefehl oder ein benutzerdefiniertes Anweisungspaket auf demselben Hostvertrag sein.
+
+### Migration zu Agent-Native mit `/migrate` {#migrate}
+
+`/migrate` ist das integrierte Ziel für die Verschiebung einer vorhandenen App, URL, oder eines beschriebenen Produkts nach Agent-Native. Es handelt sich um ein Slash-Ziel im Code-Arbeitsbereich – keine separate Vorlage zum Gerüstbauen und kein einmaliges Produkt – es nutzt also den gleichen Sitzungsspeicher, die gleiche Transkription, die gleichen Ausführungssteuerungen und den gleichen Desktop-Hub wie jede andere Code-Sitzung, und Sie können sie auf die gleiche Weise fortsetzen, anhängen, prüfen und stoppen.
+
+```bash
+npx @agent-native/core@latest code /migrate ./my-next-app --out ../migrated-app
+npx @agent-native/core@latest code /migrate https://example.com --describe "marketing site plus dashboard"
+npx @agent-native/core@latest code /migrate --describe "A Rails admin app with reports and CSV imports" --emit
+npx @agent-native/core@latest migrate ./my-next-app --out ../migrated-app   # shortcut into the same goal
+```
+
+Lokale Quellpfade sind schreibgeschützt; Die generierte Ausgabe muss außerhalb des Quellbaums liegen. Verwenden Sie `--emit <dir>`, um ein tragbares Migrationsdossier zu schreiben (`AGENTS.md`, `MIGRATION_PLAYBOOK.md`, Bewertung und ein `ir.json`-Inventar, sofern verfügbar) und übergeben Sie es an einen anderen Codierungsagenten, anstatt die interne Ausführungsoberfläche zu öffnen. `/migrate` verwendet das normale Anmeldeinformationssystem des Frameworks wieder – es gibt keinen migrationsspezifischen Schlüsselspeicher. Das `@agent-native/migrate`-Paket stellt eine wiederverwendbare Engine (`createMigrationRun`, `discoverMigration`, `planMigration`, Quell-/Zieladapter) für benutzerdefinierte Workflows bereit.
+
+Projektspezifische Befehle leben in:
+
+```text
+.agents/commands/*.md
+```
+
+Verwenden Sie diese für Team-Workflows wie Release-Prüfungen, Migrationsvarianten, Framework-Upgrades oder Audits.
+
+Projekt skills live in:
+
+```text
+.agents/skills/*/SKILL.md
+```
+
+Wenn der Host `listCodePacks` implementiert, zeigt der gemeinsam genutzte UI Projektbefehle und skills in der Schiene an. Befehlszeilen fügen `/<command>` ein, und Fertigkeitszeilen fügen eine fokussierte Eingabeaufforderung „Verwenden Sie die Fertigkeit <skill>…“ ein, damit die Schiene umsetzbar bleibt. Die integrierten Slash-Ziele `/migrate` und `/audit` bleiben für die globalen Agent-Native-Codesteuerelemente reserviert, ebenso wie Run-Control-Namen wie `status` und `resume` – das sind Unterbefehle, die ohne Schrägstrich aufgerufen werden (`npx @agent-native/core@latest code status`, `npx @agent-native/core@latest code resume`), keine Slash-Ziele.
+
+Erstellen Sie keine separate Slash-Befehls-Registrierung für einen neuen Code-Host. Projekt
+Befehle und skills werden von `.agents/commands/*.md` und
+`.agents/skills/*/SKILL.md`; Der UI sollte diese Pakete rendern und Eingabeaufforderungen einfügen
+über den Shared Composer.
+
+## Background Agent Run-Manager
+
+Die Hintergrundarbeit des Coding-Agents sollte die gleiche Run-Manager-Grundlage wie die
+Rest von Agent-Native:
+
+- Verwenden Sie den Code Run Store/Executor für lokale Codesitzungen.
+- Verwenden Sie den gemeinsam genutzten Hintergrundlaufadapter/die gemeinsame Grundlage, wenn eine Oberfläche aufgelistet werden muss
+  Inspizieren oder überbrücken Sie lokale Codesitzungen mit anderen Hintergrundarbeiten.
+- Verwenden Sie den Kern `run-manager` für gehostete Agentenausführungen, also Streams, Abbrüche, Heartbeats usw.
+  Wiederaufnahmefähigkeit, weiche Zeitüberschreitungen und Bereinigung bei hängengebliebener Ausführung verhalten sich konsistent.
+- Verwenden Sie `agent-teams` / `spawnTask()`, wenn der UI Arbeit an a delegiert
+  Hintergrund-Subagent aus einem normalen App-Chat.
+
+Fügen Sie keinen parallelen Hintergrundagenten-Läufer hinzu, nur weil eine neue Oberfläche einen benötigt
+anderes Layout. Bauen Sie einen Host-Adapter oder einen UI-Steckplatz auf dem gemeinsam genutzten
+Run-Manager Foundation stattdessen.
+
+## Follow-ups
+
+Follow-ups zu aktiven Läufen unterstützen zwei Bereitstellungsmodi:
+
+- Durch Drücken der Eingabetaste oder Klicken auf „Senden“ wird eine sofortige Steuerungsaufforderung aufgezeichnet, die
+  aktiver Läufer wendet sich am nächsten sicheren Fortsetzungspunkt an.
+- Durch Drücken von Cmd+Enter unter macOS oder Strg+Enter an anderer Stelle wird die Eingabeaufforderung zur Ausführung in die Warteschlange gestellt
+  nachdem die aktuelle Runde beendet ist.
+
+Inaktive Läufe behalten das kompatible Verhalten bei: Das Follow-up wird angehängt und der Lauf wird sofort fortgesetzt.
+
+Dadurch erhält Code die gleiche benutzerorientierte bidirektionale Nachrichtenform wie Agent Teams:
+Der Benutzer kann weiterhin mit der aktiven Arbeit kommunizieren, aber die Ausführung verbraucht nur diese
+Nachricht an einem sicheren Fortsetzungspunkt. Wenn ein Läufer nicht sofort steuern kann, dann
+Die Nachverfolgung muss als Arbeit in der Warteschlange bestehen bleiben, anstatt sie zu verwerfen oder zu beschleunigen.
+
+## Fernversand
+
+Desktop kann den lokalen Code-Agent-Läufer einem bereitgestellten Dispatch-Relay zur Verfügung stellen
+Telefon- oder Telegram-Chat kann währenddessen Sitzungen starten, überwachen und fortsetzen
+Computer ist wach.
+
+Die Verbindung ist nur ausgehend vom Desktop:
+
+1. Desktop koppelt sich mit Dispatch und speichert ein Geräte-Token lokal.
+2. Desktop-Langumfragen `/_agent-native/integrations/remote/poll`.
+3. Mobile Sessions und Telegram `/code` reihen Befehle in die Relay-Datenbank ein.
+4. Desktop beansprucht Befehle, steuert den lokalen Ausführungsspeicher und veröffentlicht Ergebnisse und
+   Ereignisse zurück an Dispatch übertragen.
+5. Mobile liest `hosts`, `runs` und `transcript` aus Dispatch; es redet nie
+   direkt auf den Desktop.
+
+```an-diagram title="Remote Dispatch is outbound-only" summary="Mobile never talks to the desktop directly. Desktop long-polls Dispatch, claims commands, drives the local run store, and mirrors results back."
+{
+  "html": "<div class=\"diagram-remote\"><div class=\"diagram-node\" data-rough>Mobile / Telegram<br><small class=\"diagram-muted\">/code · sessions</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\" data-rough>Dispatch relay<br><small class=\"diagram-muted\">hosts · runs · transcript</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&larr;</div><div class=\"diagram-node\" data-rough>Desktop<br><small class=\"diagram-muted\">long-polls · claims · drives run store</small></div></div>",
+  "css": ".diagram-remote{display:flex;align-items:center;gap:12px;flex-wrap:wrap}.diagram-remote .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+Die kanonischen Remote-Relay-Endpunkte sind:
+
+```an-api title="Desktop claims queued work"
+{
+  "method": "POST",
+  "path": "/_agent-native/integrations/remote/poll",
+  "summary": "Desktop long-polls the relay to claim enqueued commands",
+  "description": "Outbound-only from a paired Desktop host. Desktop authenticates with its device token and claims work that mobile or Telegram enqueued.",
+  "auth": "Desktop device token",
+  "responses": [
+    { "status": "200", "description": "Claimed commands for this host (may be empty after the long-poll window)." }
+  ]
+}
+```
+
+| Methode    | Route                                                    | Anrufer         | Zweck                                                                |
+| ---------- | -------------------------------------------------------- | --------------- | -------------------------------------------------------------------- |
+| `POST`     | `/_agent-native/integrations/remote/register`            | Desktop-Sitzung | Koppeln Sie einen Desktop-Host und geben Sie einmal ein Token zurück |
+| `GET`      | `/_agent-native/integrations/remote/hosts`               | Mobil/Sitzung   | Gepaarte Hosts auflisten                                             |
+| `DELETE`   | `/_agent-native/integrations/remote/devices/:id`         | Mobil/Sitzung   | Einen gepaarten Host widerrufen                                      |
+| `POST`     | `/_agent-native/integrations/remote/devices/:id/revoke`  | Mobil/Sitzung   | Einen gepaarten Host widerrufen                                      |
+| `POST/GET` | `/_agent-native/integrations/remote/poll`                | Desktop-Token   | Beanspruchen Sie Arbeit                                              |
+| `POST`     | `/_agent-native/integrations/remote/result`              | Desktop-Token   | Arbeit abschließen oder fehlschlagen                                 |
+| `POST`     | `/_agent-native/integrations/remote/run-events`          | Desktop-Token   | Transkriptereignisse spiegeln                                        |
+| `GET`      | `/_agent-native/integrations/remote/runs`                | Mobil/Sitzung   | Sitzungen auflisten                                                  |
+| `GET`      | `/_agent-native/integrations/remote/runs/:id`            | Mobil/Sitzung   | Sitzungszusammenfassung lesen                                        |
+| `GET`      | `/_agent-native/integrations/remote/runs/:id/transcript` | Mobil/Sitzung   | Gespiegeltes Transkript lesen                                        |
+| `POST`     | `/_agent-native/integrations/remote/push/register`       | Mobil/Sitzung   | Expo/Mobile-Push-Token registrieren                                  |
+
+Telegram verwendet das gleiche Relay über Dispatch. Unterstützte Befehle sind:
+
+```text
+/code <prompt>
+/code list
+/code status <run>
+/code continue <run> <text>
+/code approve <id>
+/code deny <id>
+/code stop <run>
+```
+
+## Styling
+
+Paket-Stylesheet importieren:
+
+```ts
+import "@agent-native/code-agents-ui/styles.css";
+```
+
+Das Stylesheet verwendet dieselben benutzerdefinierten HSL-Eigenschaften im Shadcn-Stil wie die Vorlagen und die Desktop-Shell. Ändern Sie lieber Token oder kleine Klassenüberschreibungen in der Host-App, bevor Sie das gemeinsam genutzte UI forken.
+
+## Begrenzungen
+
+Die Browservorlage ist lokal zuerst. Es kann Ausführungen starten und fortsetzen, während sein lokaler Knotenserver aktiv ist. Für native Prozesslebenszyklen, Terminalstarts und App-Webansichten verwenden Sie Desktop.