@agent-native/core 0.76.5 → 0.76.6

package/corpus/core/docs/content/locales/de-DE/workspace.md

@@ -0,0 +1,323 @@
+---
+title: "Arbeitsbereich"
+description: "Claude-Anpassung auf Codeebene pro Benutzer – skills, Speicher, Anweisungen, benutzerdefinierte Agenten, geplante Jobs, MCP-Server – unterstützt durch SQL, kein Dateisystem."
+---
+
+# Arbeitsbereich
+
+> **Welches Arbeitsbereichsdokument?** Diese Seite behandelt die **Anpassungsebene** – was ein Arbeitsbereich _ist_. Informationen zur Bereitstellungsform (ein Monorepo, viele Apps) finden Sie unter [Multi-App Workspaces](/docs/multi-app-workspace); Informationen zur Governance (wer überprüft, genehmigt und besitzt was) finden Sie unter [Workspace Governance](/docs/workspace-management).
+
+Jede agentennative App wird mit einem **Arbeitsbereich** ausgeliefert: der Anpassungsebene, die den Agenten zu Ihrem macht. Es enthält Teamanweisungen (`AGENTS.md`), gemeinsame Erkenntnisse (`LEARNINGS.md`), persönliches strukturiertes Gedächtnis (`memory/MEMORY.md`), skills, das der Agent bei Bedarf einholt, benutzerdefinierte Subagenten, geplante Jobs und verbundene MCP-Server – alles, was Sie von einem Claude-Code-/Codex-Setup erwarten.
+
+Der Clou: **Es sind SQL-Zeilen, keine Dateisystemdateien.** Jeder Benutzer erhält seinen eigenen Arbeitsbereich, der in der Datenbank gespeichert wird. Es muss keine Entwicklungsbox gestartet werden, kein Container pro Benutzer, keine Dateien müssen gemountet werden. Ein mandantenfähiges SaaS kann jedem Benutzer praktisch kostenlos einen vollständig anpassbaren Agenten zur Verfügung stellen, da alles aus Zeilen besteht – persönlicher Speicher, persönliche MCP-Server, persönliche skills, persönliche Subagenten – und die gemeinsame Codebasis sie alle gleichzeitig hostet.
+
+```an-diagram title="A Claude-Code workspace, but stored in SQL" summary="The same customization layer — instructions, skills, memory, agents, jobs, MCP — except every file is a row in a shared multi-tenant database."
+{
+  "html": "<div class=\"ws-map\"><div class=\"diagram-card cc\"><span class=\"diagram-pill warn\">Claude Code / Codex</span><small class=\"diagram-muted\">~/.claude/ on a local disk</small><div class=\"ws-files\"><span class=\"diagram-box\">CLAUDE.md</span><span class=\"diagram-box\">skills/</span><span class=\"diagram-box\">memory</span><span class=\"diagram-box\">mcp.json</span></div><small class=\"diagram-muted\">one codebase per developer</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-card an\"><span class=\"diagram-pill accent\">Agent-native workspace</span><small class=\"diagram-muted\">rows in one SQL database</small><div class=\"ws-rows\"><span class=\"diagram-pill\">AGENTS.md</span><span class=\"diagram-pill\">skills/&hellip;</span><span class=\"diagram-pill\">memory/&hellip;</span><span class=\"diagram-pill\">mcp-servers/&hellip;</span></div><small class=\"diagram-muted\">one codebase, many users, scoped <code>u:&lt;email&gt;:&hellip;</code></small></div></div>",
+  "css": ".ws-map{display:flex;align-items:center;gap:16px;flex-wrap:wrap}.ws-map .diagram-card{display:flex;flex-direction:column;gap:8px;padding:16px 18px;flex:1;min-width:220px}.ws-map .ws-files,.ws-map .ws-rows{display:flex;flex-wrap:wrap;gap:6px;margin:4px 0}.ws-map .diagram-arrow{font-size:24px}"
+}
+```
+
+| Claude-Code / Codex                                | Agent-nativer Arbeitsbereich                                       |
+| -------------------------------------------------- | ------------------------------------------------------------------ |
+| Dateien auf Ihrer lokalen Festplatte               | Zeilen in einer gemeinsam genutzten SQL-Datenbank                  |
+| Eine Codebasis pro Entwickler                      | Eine Codebasis, viele Benutzer                                     |
+| Benötigt eine Entwicklungsbox oder einen Container | Läuft auf jedem serverlosen/Edge-Host                              |
+| Anpassung bei `~/.claude/`                         | Anpassung pro Benutzer, mit Gültigkeitsbereich `u:<email>:…`       |
+| Pro Projekt `CLAUDE.md` / skills                   | `AGENTS.md` pro App + Arbeitsspeicherressourcen                    |
+| MCP-Konfiguration in einer JSON-Datei              | MCP-Konfiguration in JSON _oder_ die Einstellungen UI, pro Bereich |
+
+Gleiche Funktionen. Andere Wirtschaftswissenschaften. Warum dies für SaaS wichtig ist, erfahren Sie unter [Templates](/docs/cloneable-saas).
+
+## Übersicht {#overview}
+
+Ressourcen haben drei Laufzeitbereiche:
+
+- **Persönlich** – auf einen einzelnen Benutzer (seine E-Mail-Adresse) beschränkt. Gut für Einstellungen, Notizen und den Kontext pro Benutzer.
+- **Freigegeben / Organisation** – sichtbar für alle Benutzer in der App oder Organisation. Gut für App-/Teamanweisungen, skills und gemeinsame Konfiguration.
+- **Workspace** – geerbte globale Standardeinstellungen, verwaltet von Dispatch Resources. Gut für Unternehmensfakten, Positionierung, Markenrichtlinien, globale Leitplanken, arbeitsbereichsweites skills und gemeinsam genutzte MCP-Server. Apps lesen diese zur Laufzeit; Sie werden nicht in jede App kopiert.
+
+Das In-App-Arbeitsbereich-Bedienfeld zeigt alle drei Bereiche. Persönliche und freigegebene/Organisationsressourcen können dort bearbeitet werden. Arbeitsbereichsbezogene Ressourcen sind in App-Panels schreibgeschützt und werden zentral von Dispatch aus bearbeitet, sodass jede App ohne einen Synchronisierungsschritt dieselben kanonischen Dateien sieht.
+
+Die kanonischen Pfade, die steuern, wie der Agent jede Ressource nutzt:
+
+| Laufzeitressource                 | Pfad                                      | Wie Agenten es verwenden                                    |
+| --------------------------------- | ----------------------------------------- | ----------------------------------------------------------- |
+| Leitplankenanweisungen            | `AGENTS.md` oder `instructions/<slug>.md` | Wird in jeder Runde in jeder App geladen, die es empfängt   |
+| Global skills                     | `skills/<slug>/SKILL.md`                  | Als Arbeitsbereich skills aufgeführt und bei Bedarf gelesen |
+| Marken-/Unternehmensressourcen    | `context/<slug>.md`                       | Bei jedem Schritt indiziert, bei Bedarf gelesen             |
+| Benutzerdefinierte Agentenprofile | `agents/<slug>.md`                        | Verfügbar als wiederverwendbare lokale Agentenprofile       |
+| Freigegebene HTTP MCP-Server      | `mcp-servers/<slug>.json`                 | In die Tool-Registrierung MCP gewährter Apps geladen        |
+
+Diese Pfade gelten für alle drei Bereiche – Arbeitsbereich, Organisation/App und Persönlich. Der spätere Bereich gewinnt, wenn derselbe Pfad auf mehreren Ebenen vorhanden ist.
+
+```an-diagram title="Three scopes, one effective file" summary="The runtime resolves the same path across workspace, app, and personal scopes on read — the most specific scope wins."
+{
+  "html": "<div class=\"ws-stack\"><div class=\"diagram-card\"><span class=\"diagram-pill\">Workspace</span><small class=\"diagram-muted\">company-wide defaults from Dispatch</small><code>context/brand.md</code></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-card\"><span class=\"diagram-pill\">Organization / app</span><small class=\"diagram-muted\">team override for one app</small><code>context/brand.md</code></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-card\"><span class=\"diagram-pill accent\">Personal</span><small class=\"diagram-muted\">per-user override &mdash; wins</small><code>context/brand.md</code></div><div class=\"diagram-arrow diagram-accent\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box ok\">Effective <code>context/brand.md</code></div></div>",
+  "css": ".ws-stack{display:flex;flex-direction:column;align-items:flex-start;gap:8px}.ws-stack .diagram-card{display:flex;flex-direction:column;gap:4px;padding:12px 16px;min-width:280px}.ws-stack .diagram-arrow{font-size:20px;align-self:center}.ws-stack code{font-size:.85em}.ws-stack .diagram-box{align-self:center;margin-top:4px}"
+}
+```
+
+## Erste Schritte: eine 1-minütige Komplettlösung {#getting-started}
+
+Ändern Sie das Verhalten des Agenten in 60 Sekunden.
+
+1. Öffnen Sie die Registerkarte **Arbeitsbereich** → **Freigegeben** → `AGENTS.md` (erstellen Sie sie mit `+` → **Datei**, falls fehlend).
+2. Fügen Sie eine Regel hinzu, z. B.:
+
+   ```Markdown
+   ## Ton
+
+   Seien Sie prägnant. Geben Sie die Antwort.
+   ```
+
+3. Speichern, zum **Chat** wechseln, alles fragen – der Agent folgt sofort der neuen Regel.
+
+```an-callout
+{ "tone": "info", "body": "No restart, no redeploy. `AGENTS.md` is read at the start of every turn, so an edit you save now changes the agent's behavior on the very next message." }
+```
+
+**Nächste Schritte, wann immer Sie möchten:**
+
+- **Skills** (`+` → **Skill**) – fokussierte Anleitungsdateien, die im Chat mit `/skill-name` aufgerufen werden.
+- **Agents** (`+` → **Agent**) – wiederverwendbare Subagenten-Personas, aufgerufen mit `@agent-name`.
+- **Geplante Aufgaben** (`+` → **Geplante Aufgabe**) – Eingabeaufforderungen, die auf einem Cron ausgeführt werden. Zeitpläne und Auslöser finden Sie unter [Recurring Jobs](/docs/recurring-jobs).
+- **Speicher** – gemeinsam genutztes `LEARNINGS.md` und persönliches `memory/MEMORY.md` sorgen dafür, dass dauerhafter Kontext über Gespräche hinweg verfügbar bleibt.
+
+## Globale Ressourcen und kanonische Pfade {#global-resources}
+
+Ressourcen im Workspace-Bereich werden über die Dispatch-Seite **Ressourcen** verwaltet und von Apps zur Laufzeit geerbt – kein Kopier- oder Synchronisierungsschritt. Dispatch unterstützt zwei Gewährungsbereiche:
+
+- **Alle Apps** – globale Ressourcen, die jede App im Arbeitsbereich erbt. Die meisten Unternehmens-, Marken-, Persona-, Positionierungs-, Nachrichten- und Leitplankenkontexte sollten **Alle Apps** sein.
+- **Ausgewählte Apps** – Ressourcen, die bestimmten Apps für app-spezifischen Kontext oder Tools gewährt werden. Gehen Sie sparsam damit um.
+
+Der Pfad bestimmt, wie der Agent eine Ressource nutzt (siehe Tabelle in [Overview](#overview) oben). Dies ist das richtige Zuhause für Kernpersönlichkeiten, Positionierung, Nachrichten, Unternehmensfakten, Markenrichtlinien, Supportrichtlinien, gemeinsame skills- oder gemeinsame HTTP MCP-Tools, von denen viele Apps profitieren sollten.
+
+Ein nützliches Starterpaket für einen neuen Arbeitsbereich:
+
+```text
+context/company.md              # what the company does, ICP, products, links
+context/brand.md                # voice, visual identity, spelling, forbidden usage
+context/messaging.md            # positioning, value props, proof points, objections
+instructions/guardrails.md      # compliance, escalation, and approval rules
+skills/company-voice/SKILL.md   # on-demand guidance for customer-facing writing
+agents/<slug>.md                # reusable custom agent profiles
+```
+
+Halten Sie `context/`-Dateien sachlich und leicht zu überfliegen. Legen Sie in `instructions/guardrails.md` Regeln fest, die in jeder Runde gelten müssen. Verwenden Sie `skills/company-voice/SKILL.md`, wenn der Agent die Kopie im Namen des Unternehmens absichtlich umwandeln oder überprüfen soll.
+
+Um einen globalen Standard für eine App oder ein Team zu überschreiben, erstellen Sie in dieser App eine freigegebene/Organisationsressource mit demselben Pfad. Um es für eine Person zu überschreiben, erstellen Sie eine persönliche Ressource mit demselben Pfad. Kopieren Sie die Arbeitsbereichsdatei nicht in jede App; Die Laufzeit löst den Stapel beim Lesen auf:
+
+```text
+workspace context/brand.md
+-> shared/app context/brand.md
+-> personal context/brand.md
+```
+
+Halten Sie `context/`-Dateien kurz und sachlich – ein paar Punkte, die der Agent überfliegen kann:
+
+```text
+<!-- context/brand.md -->
+
+# Brand
+
+- Voice: direct, warm, concrete
+- Use: "workspace", "agent", "team"
+- Avoid: unsupported superlatives and vague AI claims
+```
+
+## Arbeitsbereichsbereich {#workspace-panel}
+
+Das Agentenfenster enthält neben Chat und CLI auch die Registerkarte **Arbeitsbereich**. Es zeigt eine in Ordnern organisierte Baumstruktur aller Ressourcen, einen Inline-Editor für jede Textdatei (Markdown, JSON, YAML, einfacher Text) und die typisierten Erstellungsabläufe des `+`-Menüs (Dateien, Skills, Agenten, geplante Aufgaben). Benutzer können übernommene Standardeinstellungen für Arbeitsbereiche durchsuchen und persönliche oder Organisationsressourcen erstellen/bearbeiten/löschen.
+
+Wenn Sie eine Ressource öffnen, zeigt der Editor einen **Effektiven Kontext**-Streifen mit dem `workspace default -> organization/app override -> personal override`-Stack an, sodass Sie sehen können, was geerbt wurde und warum eine Überschreibung aktiv ist. Dispatch zeigt das gleiche Modell von der Seite der Steuerungsebene: Verwenden Sie auf der Seite **Ressourcen** **Gültig in der App** oder erweitern Sie **Stack** in einer Ressourcenzeile im **Kontext**-Dialogfeld einer App-Karte.
+
+Wenn die Dispatch-Genehmigungsrichtlinie aktiviert ist, wird beim Erstellen, Aktualisieren oder Löschen einer **Alle Apps**-Ressource eine Genehmigungsanforderung in die Warteschlange gestellt, anstatt sie sofort anzuwenden. Die Dialogfelder zum Erstellen/Bearbeiten/Löschen zeigen vor dem Speichern eine Vorschau der Auswirkungen an.
+
+Klicken Sie auf das `?`-Symbol in der Arbeitsbereichssymbolleiste, um jederzeit zu diesen Dokumenten zurückzukehren.
+
+## Wie der Agent Ressourcen nutzt {#how-the-agent-uses-resources}
+
+Der integrierte App-Agent verwaltet Ressourcen mit dem einheitlichen `resources`-Tool: Verwenden Sie `action: "list"`, `"read"`, `"effective"`, `"write"`, `"promote"` oder `"delete"`. Externe CLI/Code-Agenten können die entsprechenden `pnpm action resource-*`-Befehle verwenden.
+
+Zu Beginn jedes Gesprächs liest der Agent automatisch:
+
+### AGENTS.md und Anweisungen {#agents-md}
+
+`AGENTS.md` ist eine Anweisungsressource, die standardmäßig erstellt und in jeder Runde aus den Bereichen Arbeitsbereich, Gemeinsam/Organisation und Persönlich in dieser Reihenfolge geladen wird – Arbeitsbereich für unternehmensweite Standardeinstellungen, Gemeinsam/App für Teamregeln, Persönlich für benutzerspezifische Einstellungen. Dateien unter `instructions/` sind separate Leitdokumente, die ebenfalls in jeder Hinsicht gelten (Compliance-Regeln, Eskalationsrichtlinie, Markenstimme) und der gleichen Priorität folgen. Sowohl normale Chat- als auch durch die Integration ausgelöste Ausführungen laden sie, bevor sie antworten.
+
+```text
+AGENTS.md
+instructions/customer-support-guardrails.md
+instructions/legal-review-policy.md
+```
+
+### Referenzressourcen {#reference-resources}
+
+Wiederverwendbarer Unternehmenskontext steht unter `context/` (Personas, Positionierung, Produktfakten, Markenrichtlinien, Wettbewerbsnotizen). Der Agent sieht einen Index davon und liest die entsprechende Datei mit dem `resources`-Tool (`action: "read"`), wenn eine Aufgabe davon abhängen könnte; Verwenden Sie `action: "effective"`, um zu sehen, ob ein Arbeitsbereichsstandard für eine App oder einen Benutzer überschrieben wird.
+
+### Speicher {#memory}
+
+Der Arbeitsbereich verfügt über zwei aktuelle Speicheroberflächen:
+
+- `LEARNINGS.md` im **gemeinsamen** Bereich für projektweite Konventionen, Korrekturen und dauerhaftes Teamwissen.
+- `memory/MEMORY.md` im **Persönlichen** Bereich für strukturierten Speicher über den aktuellen Benutzer.
+
+Das Ressourcensystem setzt auch einen persönlichen `LEARNINGS.md` für die Kompatibilität mit älteren Arbeitsbereichen, aber der Chat-Preload-Pfad ist gemeinsam genutzter `LEARNINGS.md` plus persönlicher `memory/MEMORY.md`.
+
+**Was gespeichert wird.** Wenn Sie den Agenten korrigieren („Verwenden Sie immer Projektweite Erkenntnisse werden gemeinsam genutzt `LEARNINGS.md`; Der benutzerspezifische Speicher fällt unter `memory/`. Die `capture-learnings`-Fertigkeit gibt an, wann und wie.
+
+**Wo es passt.**
+
+| Oberfläche         | Geltungsbereich              | Geschrieben von                                | Wann lesen                                      |
+| ------------------ | ---------------------------- | ---------------------------------------------- | ----------------------------------------------- |
+| `AGENTS.md`        | Geteilt                      | Menschen / Agent auf Anfrage                   | Jede Runde                                      |
+| `LEARNINGS.md`     | Geteilt                      | Menschen / Agent auf Anfrage                   | Jede Runde (nur geteilte Kopie)                 |
+| `memory/MEMORY.md` | Persönlich                   | Agent / Menschen                               | Jede Runde                                      |
+| `instructions/…`   | Geteilt                      | Menschen / Agent auf Anfrage                   | Jede Runde                                      |
+| `skills/…`         | Geteilt                      | Menschen / Agent auf Anfrage                   | Auf Anfrage (`/slash`-Befehl)                   |
+| `context/…`        | Geteilt                      | Menschen / Agent auf Anfrage                   | Bei jedem Schritt indiziert, bei Bedarf gelesen |
+| `mcp-servers/…`    | Arbeitsbereich / freigegeben | Menschen über Dispatch oder App-Arbeitsbereich | MCP-Konfigurationsaktualisierung                |
+
+Benutzer können diese Speicherdateien direkt auf der Registerkarte „Arbeitsbereich“ bearbeiten – es handelt sich um reguläre Ressourcen. Löschen Sie Zeilen, die der Agent falsch verstanden hat, behalten Sie persönliche Präferenzen in `memory/MEMORY.md` bei oder übertragen Sie teamweite Regeln in `AGENTS.md`.
+
+Jede dieser Oberflächen – `AGENTS.md`, skills, Speicher, benutzerdefinierte Agenten, MCP-Server – hat die gleiche zugrunde liegende Ressourcenform: ein `path` + `scope` + `content`, die auf die gleiche Weise angesprochen und aufgelöst wird.
+
+```an-schema title="The workspace resource model" summary="One resource shape backs every workspace file. The runtime keys it by path and scope and resolves the effective value on read."
+{
+  "entities": [
+    {
+      "id": "resource",
+      "name": "workspace resource",
+      "note": "A single file in a user's workspace — instructions, skill, memory, agent, MCP config, or job.",
+      "fields": [
+        { "name": "path", "type": "string", "note": "Canonical path, e.g. AGENTS.md, skills/<slug>/SKILL.md" },
+        { "name": "scope", "type": "workspace | shared | personal", "note": "Which level this row lives at" },
+        { "name": "owner", "type": "string", "nullable": true, "note": "u:<email> for personal scope" },
+        { "name": "content", "type": "text", "note": "Markdown / JSON / YAML body" }
+      ]
+    }
+  ]
+}
+```
+
+## Skills {#skills}
+
+Skills sind Markdown-Ressourcendateien unter dem `skills/`-Pfad (vorzugsweise `skills/<name>/SKILL.md`), die dem Agenten On-Demand-Domänenwissen vermitteln, das im Chat mit `/skill-name` aufgerufen wird. Fügen Sie sie über die Registerkarte „Arbeitsbereich“ oder im Codemodus über `.agents/skills/` hinzu.
+
+Sehen Sie sich [Skills Guide](/docs/skills-guide) an – die einzige Quelle für Kompetenzformat, -umfang, -erkennung und -erstellung.
+
+## Benutzerdefinierte Agents {#custom-agents}
+
+Benutzerdefinierte Agenten sind wiederverwendbare lokale Subagentenprofile, die als Markdown-Ressourcen unter `agents/*.md` gespeichert sind. Dies ist die kanonische Heimat für das Custom-Agent-Format.
+
+Verwenden Sie sie, wenn Sie einen fokussierten Delegaten mit eigenem Namen, eigener Beschreibung, eigener Modellpräferenz und eigenem Befehlssatz wünschen. Im Gegensatz zu skills sind benutzerdefinierte Agenten keine passive Führung – es handelt sich um operative Personas, die der Hauptagent durch `@`-Erwähnungen oder durch Auswahl beim Spawnen von Unteragenten aufrufen kann.
+
+### Agent-Format {#agent-format}
+
+Benutzerdefinierte Agenten verwenden YAML-Frontmatter und Markdown-Anweisungen:
+
+```an-annotated-code title="A custom agent profile"
+{
+  "filename": "agents/design.md",
+  "language": "markdown",
+  "code": "---\nname: Design\ndescription: >-\n  Reviews layouts, interaction patterns, and product UX decisions.\nmodel: inherit\ntools: inherit\ndelegate-default: false\n---\n\n# Role\n\nYou are a focused design agent.\n\n## Responsibilities\n\n- Review layouts and interaction flows\n- Suggest stronger visual direction\n- Be concise and opinionated",
+  "annotations": [
+    { "lines": "2", "label": "@mention handle", "note": "`name` is what appears in the `@`-dropdown and what the main agent delegates to." },
+    { "lines": "3-4", "label": "When to delegate", "note": "The `description` is what the orchestrator reads to decide this profile fits a task." },
+    { "lines": "5", "label": "Model", "note": "`inherit` reuses the main agent's model. Override only when the profile clearly needs a different one." },
+    { "lines": "6", "note": "`tools: inherit` for now — the field is reserved for future per-agent tool policies." }
+  ]
+}
+```
+
+Empfohlene Konventionen:
+
+- Benutzerdefinierte Agents unter `agents/<slug>.md` speichern
+- Verwenden Sie `model: inherit`, es sei denn, das Profil erfordert eindeutig ein anderes Modell
+- `tools: inherit` vorerst behalten; Das Feld ist für zukünftige Tool-Richtlinien reserviert
+
+### Remote-Agenten im Vergleich zu benutzerdefinierten Agenten {#remote-vs-custom-agents}
+
+Es gibt zwei Agententypen in Workspace:
+
+- **Benutzerdefinierte Agenten** – lokale Profile in `agents/*.md`, ausgeführt innerhalb der aktuellen App/Laufzeit
+- **Verbundene Agenten** – entfernte A2A-Peers, die durch Manifeste in `remote-agents/*.json` beschrieben werden (ältere `agents/*.json`-Manifeste werden weiterhin erkannt)
+
+Verwenden Sie benutzerdefinierte Agenten für die Delegation innerhalb einer App. Verwenden Sie verbundene Agenten, wenn Sie eine andere App über A2A anrufen müssen.
+
+## @ Tagging {#at-tagging}
+
+Geben Sie `@` in die Chat-Eingabe ein, um auf Arbeitsbereichselemente zu verweisen. Am Cursor erscheint ein Dropdown-Menü mit passenden Agenten und Dateien. Verwenden Sie die Pfeiltasten zum Navigieren und die Eingabetaste zum Auswählen. Das ausgewählte Element erscheint als Inline-Chip in der Eingabe.
+
+Wenn Sie eine Nachricht senden, werden **Dateien/Ressourcen** als Referenzen übergeben, die der Agent lesen kann, **benutzerdefinierte Agenten** werden lokal mit ihren Profilanweisungen ausgeführt und **verbundene Agenten** werden über A2A aufgerufen.
+
+## / Slash-Befehle {#slash-commands}
+
+Geben Sie `/` am Anfang einer Zeile ein, um einen Skill aufzurufen. Ein Dropdown-Menü zeigt die verfügbaren skills mit ihren Namen und Beschreibungen; Wenn Sie einen davon auswählen, wird ein Inline-Chip hinzugefügt und dessen Inhalt als Kontext beim Senden der Nachricht einbezogen. Wenn keine skills konfiguriert sind, werden im Dropdown-Menü Links zu diesen Dokumenten angezeigt.
+
+## Code vs. App-Modus {#dev-vs-prod}
+
+Das Ressourcensystem funktioniert in beiden Modi identisch. Der Unterschied besteht in den zusätzlichen Quellen, die für `@`-Tagging und `/`-Befehle verfügbar sind:
+
+| Funktion               | Codemodus                                                                                      | App-Modus                                                                   |
+| ---------------------- | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| @-Tagging              | Codebasisdateien + Arbeitsbereichsressourcen + benutzerdefinierte Agenten + verbundene Agenten | Arbeitsbereichsressourcen + benutzerdefinierte Agenten + verbundene Agenten |
+| / Slash-Befehle        | .agents/skills/ + Ressource skills                                                             | Nur Ressource skills                                                        |
+| Agent-Dateizugriff     | Dateisystem + Ressourcen                                                                       | Nur Ressourcen                                                              |
+| Arbeitsbereichsbereich | Vollzugriff                                                                                    | Vollzugriff                                                                 |
+| AGENTS.md / Speicher   | Verfügbar                                                                                      | Verfügbar                                                                   |
+
+## Workspace-Verbindungen {#workspace-connections}
+
+Workspace Connections ermöglichen Apps die gemeinsame Nutzung desselben Anbieterkontos (Slack, GitHub, HubSpot usw.), ohne dass Anmeldeinformationen dupliziert werden müssen. Eine Verbindung zeichnet Anbieteridentität, Kontobezeichnungen, Status, Bereiche, App-Zuweisungen und Anmeldeinformationsreferenzen in SQL auf. Geheimnisse bleiben im Zugangsdatenspeicher; Verbindungen verweisen nur auf Anmeldeinformationsschlüsselnamen wie `SLACK_BOT_TOKEN`.
+
+Siehe [Workspace Connections](/docs/workspace-connections) für den Schnellstart, Connection/Grant/CredentialRef API und konkrete Slack-, HubSpot- und GitHub-Beispiele.
+
+---
+
+# Referenz
+
+## Ressource API {#resource-api}
+
+Ressourcen können über den Servercode actions oder REST API verwaltet werden.
+
+### Server API {#server-api}
+
+REST Endpunkte automatisch gemountet:
+
+| Methode  | Endpunkt                                      | Beschreibung                                  |
+| -------- | --------------------------------------------- | --------------------------------------------- |
+| `GET`    | `/_agent-native/resources?scope=all`          | Ressourcen auflisten                          |
+| `GET`    | `/_agent-native/resources?scope=workspace`    | Geerbte Arbeitsbereichsressourcen auflisten   |
+| `GET`    | `/_agent-native/resources/tree?scope=all`     | Ordnerbaum abrufen                            |
+| `GET`    | `/_agent-native/resources/effective?path=...` | Zeigen Sie den effektiven Vererbungsstapel an |
+| `POST`   | `/_agent-native/resources`                    | Erstellen Sie eine Ressource                  |
+| `GET`    | `/_agent-native/resources/:id`                | Ressource mit Inhalt abrufen                  |
+| `PUT`    | `/_agent-native/resources/:id`                | Eine Ressource aktualisieren                  |
+| `DELETE` | `/_agent-native/resources/:id`                | Eine Ressource löschen                        |
+| `POST`   | `/_agent-native/resources/upload`             | Eine Datei als Ressource hochladen            |
+
+### Aktion API {#script-api}
+
+Der Agent verwendet diese integrierten actions. Sie können sie auch von Ihrem eigenen actions:
+
+```bash
+# List all resources
+pnpm action resource-list --scope all
+
+# Read a resource
+pnpm action resource-read --path "skills/my-skill/SKILL.md"
+
+# Read inherited workspace context managed by Dispatch
+pnpm action resource-read --scope workspace --path "context/brand.md"
+
+# Show workspace -> organization/app -> personal precedence for a path
+pnpm action resource-effective --path "context/brand.md"
+
+# Write a resource
+pnpm action resource-write --path "notes/meeting.md" --content "# Meeting Notes..."
+
+# Delete a resource
+pnpm action resource-delete --path "notes/old.md"
+```

package/corpus/core/docs/content/locales/de-DE/writing-agent-instructions.md

@@ -0,0 +1,173 @@
+---
+title: "Anweisungen für Schreibagenten & Skills"
+description: "So schreiben Sie großartige Agentenanweisungen für eine agentennative App oder Vorlage: AGENTS.md, skills und Toolbeschreibungen."
+---
+
+# Anweisungen für Schreibagenten & Skills
+
+Das Verhalten des Agenten in einer agentennativen App ist nur so gut wie die Anweisungen, die Sie ihm geben. Drei Oberflächen tragen diese Anleitung: `AGENTS.md` (die Karte), skills (die tiefen Tauchgänge) und Aktions-/Werkzeugbeschreibungen (wie der Agent das richtige Werkzeug auswählt). Schreiben Sie jedes einzelne zum schnellen Auffinden, nicht für Prosa.
+
+```an-diagram title="Three authored surfaces + one runtime surface" summary="AGENTS.md and tool descriptions load every turn; skills load on demand; application_state is written live by your UI."
+{
+  "html": "<div class=\"diagram-surfaces\"><div class=\"diagram-card always\" data-rough><span class=\"diagram-pill accent\">Every turn</span><strong>AGENTS.md</strong><small class=\"diagram-muted\">the map: purpose, core rules, state keys, action + skills index</small></div><div class=\"diagram-card always\" data-rough><span class=\"diagram-pill accent\">Every turn</span><strong>Tool descriptions</strong><small class=\"diagram-muted\">drive tool selection — one precise sentence each</small></div><div class=\"diagram-card ondemand\" data-rough><span class=\"diagram-pill\">On demand</span><strong>Skills</strong><small class=\"diagram-muted\">deep how-to, loaded when the description fires</small></div><div class=\"diagram-card runtime\" data-rough><span class=\"diagram-pill ok\">Live</span><strong>application_state</strong><small class=\"diagram-muted\">written by your UI: navigation, selection, focus</small></div></div>",
+  "css": ".diagram-surfaces{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}.diagram-surfaces .diagram-card{display:flex;flex-direction:column;gap:6px;padding:14px 16px}"
+}
+```
+
+## Halten Sie AGENTS.md klein und überstreichbar {#small-agents-md}
+
+`AGENTS.md` geladen. Es sollte die kleinste Sache sein, die es dem Agenten ermöglicht, richtig zu handeln, wobei alles tief in skills verankert sein sollte. Streben Sie diese Abschnitte und wenig anderes an:
+
+- **Zweckzeile** – ein Satz darüber, was die App ist und der primäre Arbeitsablauf.
+- **Kernregeln** – die Handvoll Invarianten, die immer gelten müssen (Daten in SQL, Operationen durchlaufen actions, KI geht durch den Agenten-Chat, Schemaänderungen sind additiv). Kurze, zwingende Aufzählungszeichen.
+- **Anwendungsstatusschlüssel** – die `navigation`/Auswahl-/Fokusschlüssel, die der Agent liest, um anhand ihrer Form zu erfahren, was der Benutzer sieht.
+- **Aktionstabelle** – eine kompakte Tabelle mit Aktionsnamen und Zweck.
+- **Skills-Index** – eine Liste der vorhandenen skills und wann sie jeweils gelesen werden sollen.
+
+Wenn ein Abschnitt über einen Bildschirm hinauswächst, gehört er zu einer Fertigkeit. `AGENTS.md` antwortet mit „Was ist diese App und was kann ich tun“, nicht mit „Wie genau mache ich das Schwierige?“.
+
+```markdown
+# Projects App
+
+One workspace for projects, tasks, and notes. Agent and UI share the same SQL
+data and the same actions.
+
+## Core Rules
+
+- Data lives in SQL via Drizzle. Use actions for all writes.
+- All AI work goes through the agent chat; never call an LLM inline.
+- Schema changes are additive only.
+
+## Application State
+
+- `navigation.view`: `home` | `project`
+- `navigation.projectId`: selected project on a project page
+
+## Actions
+
+| Action           | Purpose                     |
+| ---------------- | --------------------------- |
+| `list-projects`  | List accessible projects    |
+| `create-project` | Create a project            |
+| `update-project` | Rename or archive a project |
+
+## Skills
+
+- `project-imports` — read before importing legacy CSV exports.
+- `sharing` — read before exposing a project to other users.
+```
+
+## Einzelquelle AGENTS.md {#single-source}
+
+Behalten Sie eine Datei mit kanonischen Anweisungen: `AGENTS.md`. Wenn ein Client `CLAUDE.md` erwartet, erstellen Sie einen symbolischen Link zu `AGENTS.md` und nicht eine zweite Kopie. Zwei handverwaltete Dateien geraten ins Wanken und der Agent erhält widersprüchliche Regeln. Eine Quelle der Wahrheit, verlinkt, wo nötig.
+
+## SKILL.md frontmatter muss sagen, was AND wann {#skill-frontmatter}
+
+`description` ist das Einzige, was der Agent sieht, wenn er entscheidet, ob er einen Skill lesen möchte. Es muss zwei Fragen beantworten: Was deckt die Fertigkeit ab und wann soll sie ausgelöst werden? Eine Beschreibung, die nur das Thema beschreibt, wird nicht ausgelöst.
+
+```markdown
+---
+name: project-imports
+description: >-
+  How to import projects from the legacy CSV export. Use when the user uploads
+  a project CSV or asks to migrate projects from the old system.
+---
+```
+
+- Führen Sie die Funktion aus und fügen Sie dann eine explizite **"Use when…"**-Klausel hinzu.
+- Seien Sie etwas aufdringlich – zu viel Auslösen ist besser als eine Fertigkeit, die nie geladen wird.
+- Halten Sie es unter ca. 40 Wörtern; Es wird bei jedem Gespräch in den Kontext geladen.
+
+## Progressive Offenlegung {#progressive-disclosure}
+
+Schreiben Sie `SKILL.md` als die schlanke, unverzichtbare Ebene: die Regel, die Vorgehensweise, die Do/Don't-Liste und Hinweise. Übertragen Sie lange Beispiele, ausführliche Feldverweise, API-Macken und Edge-Case-Tabellen in `references/`-Dateien, die der Agent nur dann liest, wenn er sie benötigt.
+
+```text
+.agents/skills/project-imports/
+├── SKILL.md            # rule + happy path + do/don't
+└── references/
+    └── csv-format.md   # full column spec, encodings, edge cases
+```
+
+Dadurch bleibt die stets geladene Oberfläche klein und die Tiefe lässt sich skalieren, ohne den Kontext aufzublähen. Das vollständige Skill-Format finden Sie im [Skills Guide](/docs/skills-guide).
+
+## Aktionsorientierte Tabellen schreiben {#action-tables}
+
+Der Agent scannt Tabellen schneller als Prosa. Bevorzugen Sie eine Tabelle mit Namen und Zweck gegenüber Absätzen, in denen die einzelnen Vorgänge beschrieben werden. Dasselbe gilt für Zustandsschlüssel, Feldtypen und alle aufzählbaren Mengen. Tabellen können überflogen, unterschieden und einfach synchronisiert werden, wenn Sie eine Aktion hinzufügen.
+
+## Schreiben Sie klare Werkzeugbeschreibungen {#tool-descriptions}
+
+Aktionsbeschreibungen sind Werkzeugbeschreibungen – sie steuern die Werkzeugauswahl. Machen Sie aus jedem einen präzisen Satz mit einem einzigen Zweck:
+
+- Sagen Sie, was es tut und was es zurückgibt, nicht wie es implementiert ist.
+- Beschreiben Sie jeden Parameter in seinem `.describe()`, damit der Agent ihn korrekt ausfüllt.
+- Eine Verantwortung pro Aktion. Wenn eine Beschreibung „und auch…“ benötigt, teilen Sie sie auf.
+- Markieren Sie actions (`readOnly: true` oder `http: { method: "GET" }`) als schreibgeschützt, damit der Agent weiß, dass er sicher frei anrufen kann.
+
+```ts
+defineAction({
+  description: "Create a project. Returns the new project id and title.",
+  schema: z.object({
+    title: z.string().min(1).describe("Project title shown in the sidebar"),
+  }),
+  // ...
+});
+```
+
+## Skills vs. actions {#skills-vs-actions}
+
+Skills und actions ergänzen sich. Eine Fertigkeit ist eine Anleitung, die der Agent liest; ein
+Aktion ist Code, den der Agent ausführen kann.
+
+| Bedarf                                                                                         | Verwenden                                  |
+| ---------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| Der Agent muss einen Arbeitsablauf, eine Richtlinie, eine Checkliste oder eine Rubrik befolgen | **Fähigkeit**                              |
+| Der Agent benötigt Beispiele, Referenzmaterial oder domänenspezifische Regeln                  | **Fähigkeit**                              |
+| Der Agent muss App-Daten lesen oder schreiben                                                  | **Aktion**                                 |
+| Der Agent muss einen externen API anrufen oder eine Genehmigung durchführen                    | **Aktion**                                 |
+| Der Agent ruft den richtigen Vorgang auf, aber auf die falsche Weise                           | Verbessere die **Fähigkeit**               |
+| Der Agent kann den Vorgang nicht zuverlässig aufrufen                                          | Verbessern Sie die **Aktion**              |
+| Der Agent wählt das falsche Tool                                                               | Verbessern Sie die **Aktionsbeschreibung** |
+
+Die meisten echten Funktionen nutzen beides: Der Skill erklärt, wie man die Aufgabe angeht, und
+Die Aktion stellt die typisierte Operation bereit. Zum Beispiel ein `invoice-review`-Skill
+kann die Überprüfungsrichtlinien und Eskalationsregeln erläutern, während `list-invoices`,
+`flag-invoice` und `approve-invoice` actions führen die eigentlichen Lese- und Schreibvorgänge durch.
+
+## Anti-Herstellung einbacken und vor dem Fertigstellen überprüfen {#anti-fabrication}
+
+App-Anweisungen sollten Ehrlichkeit und Überprüfung zum Standardverhalten machen:
+
+- **Niemals fabrizieren.** Wenn Daten nicht gefunden werden oder eine Aktion fehlschlägt, sagen Sie es und erholen Sie sich – erfinden Sie keine Ergebnisse und behaupten Sie nicht, Erfolg zu haben. Lesen Sie den tatsächlichen Wert über eine Aktion oder Abfrage, bevor Sie ihn melden.
+- **Überprüfen Sie, bevor Sie es für erledigt erklären.** Bestätigen Sie nach einer Änderung diese mit einem Rücklesen (fragen Sie die Zeile erneut ab, lesen Sie den Bildschirm erneut über `view-screen`), anstatt davon auszugehen, dass der Schreibvorgang funktioniert hat.
+- **Wiederherstellen, nicht aufgeben.** Bei einem behebbaren Fehler (einer fehlgeschlagenen Abfrage, einem vorübergehenden Abruf) versuchen Sie es erneut oder korrigieren Sie die Eingabe, anstatt die Aufgabe abzubrechen. Halten Sie dies getrennt von der Anti-Fabrication-Regel – verwechseln Sie „nichts erfinden“ nicht mit „beim ersten Fehler aufhören“.
+
+Fügen Sie diese als Grundregeln in `AGENTS.md` ein, damit sie in jeder Runde gelten.
+
+## Die vier Oberflächen, die der Agent sieht {#four-surfaces}
+
+Jede Anleitung, die Sie verfassen, landet auf einer von vier Oberflächen. Wenn Sie wissen, welche Oberfläche verwendet werden soll, vermeiden Sie Duplikate und falsch platzierte Details:
+
+| Oberfläche                    | Wer schreibt es            | Wenn es geladen ist                                                      | Was dorthin gehört                                                       |
+| ----------------------------- | -------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------ |
+| `AGENTS.md`-Anweisungen       | Sie (Entwickler)           | Jede Runde als Orientierung                                              | Zweck, Kernregeln, Statusschlüssel, Aktionsindex, skills-Index           |
+| Skills (`SKILL.md`)           | Sie (Entwickler)           | Auf Anfrage, wenn der Agent entscheidet, dass die Fähigkeit relevant ist | Schritt-für-Schritt-Anleitung für ein bestimmtes Muster, Do/Don't-Listen |
+| Aktionsbeschreibungen (Tools) | Sie (Entwickler)           | Jede Runde, wie die Werkzeugliste                                        | Was die Aktion bewirkt, was sie zurückgibt, Parametersemantik            |
+| `application_state`-Kontext   | Ihr UI-Code (zur Laufzeit) | Jede Runde, als Live-App-Status                                          | Aktuelle Navigation, Auswahl, fokussiertes Objekt, URL                   |
+
+**Schnelldiagnose:**
+
+- „Der Agent fragt ständig, auf welchen Datensatz er reagieren soll, auch wenn einer geöffnet ist“ → Fix: Schreiben Sie die aktuelle Element-ID von Ihrem UI in `application_state` (`navigation`-Schlüssel). Das ist eine `application_state`-Lücke, keine Qualifikationslücke.
+- „Der Agent ruft die falsche Aktion auf oder missbraucht einen Parameter“ → Fix: `description` und `.describe()` der Aktion für den Parameter verbessern. Dabei handelt es sich um eine Korrektur der Toolbeschreibung, nicht um eine Fertigkeit.
+
+## Was gehört wohin {#what-goes-where}
+
+- **AGENTS.md** – gilt für die gesamte App, in jeder Runde: Zweck, Kernregeln, Statusschlüssel, Aktionsindex, skills-Index.
+- **Skills** – wiederverwendbare Anleitung für ein bestimmtes Muster, die bei Bedarf geladen wird. Gilt für alle, die in der App arbeiten.
+- **Speicher (`memory/MEMORY.md`)** – Präferenzen und Korrekturen pro Benutzer, keine verfasste Anleitung.
+
+## Was kommt als nächstes? {#whats-next}
+
+- [Skills Guide](/docs/skills-guide) – das Skill-Dateiformat, das Framework skills und das App-gestützte skills.
+- [Creating Templates](/docs/creating-templates) – wie `AGENTS.md` und skills in eine versandfähige Vorlage passen.
+- [The four-area checklist](/docs/key-concepts#four-area-checklist) – das Vier-Bereichs-Modell, das jedes Merkmal erfüllen muss.