cx-viewer 1.0.0

package/concepts/de/Tool-TaskUpdate.md

@@ -0,0 +1,123 @@
+# TaskUpdate
+
+## Definition
+
+Aktualisiert den Status, Inhalt oder die Abhängigkeiten einer Aufgabe in der Aufgabenliste.
+
+## Parameter
+
+| Parameter | Typ | Erforderlich | Beschreibung |
+|-----------|-----|--------------|--------------|
+| `taskId` | string | Ja | Die zu aktualisierende Aufgaben-ID |
+| `status` | enum | Nein | Neuer Status: `pending` / `in_progress` / `completed` / `deleted` |
+| `subject` | string | Nein | Neuer Titel |
+| `description` | string | Nein | Neue Beschreibung |
+| `activeForm` | string | Nein | Text in Verlaufsform, der während der Bearbeitung angezeigt wird |
+| `owner` | string | Nein | Neuer Aufgabenverantwortlicher (Agent-Name) |
+| `metadata` | object | Nein | Zu mergende Metadaten (auf null setzen zum Löschen eines Schlüssels) |
+| `addBlocks` | string[] | Nein | Liste der Aufgaben-IDs, die von dieser Aufgabe blockiert werden |
+| `addBlockedBy` | string[] | Nein | Liste der Voraussetzungsaufgaben-IDs, die diese Aufgabe blockieren |
+
+## Status-Workflow
+
+```
+pending → in_progress → completed
+```
+
+`deleted` kann von jedem Status aus gesetzt werden und entfernt die Aufgabe dauerhaft.
+
+## Anwendungsfälle
+
+**Geeignet für:**
+- Aufgabe bei Arbeitsbeginn als `in_progress` markieren
+- Aufgabe nach Abschluss als `completed` markieren
+- Abhängigkeiten zwischen Aufgaben festlegen
+- Aufgabeninhalt bei Anforderungsänderungen aktualisieren
+
+**Wichtige Regeln:**
+- Nur als `completed` markieren, wenn die Aufgabe vollständig abgeschlossen ist
+- Bei Fehlern oder Blockaden den Status `in_progress` beibehalten
+- Nicht als `completed` markieren bei: fehlgeschlagenen Tests, unvollständiger Implementierung, ungelösten Fehlern
+
+## Hinweise
+
+- Vor der Aktualisierung den aktuellen Status über TaskGet abrufen, um veraltete Daten zu vermeiden
+- Nach Abschluss einer Aufgabe TaskList aufrufen, um die nächste verfügbare Aufgabe zu finden
+
+## Originaltext
+
+<textarea readonly>Use this tool to update a task in the task list.
+
+## When to Use This Tool
+
+**Mark tasks as resolved:**
+- When you have completed the work described in a task
+- When a task is no longer needed or has been superseded
+- IMPORTANT: Always mark your assigned tasks as resolved when you finish them
+- After resolving, call TaskList to find your next task
+
+- ONLY mark a task as completed when you have FULLY accomplished it
+- If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+- When blocked, create a new task describing what needs to be resolved
+- Never mark a task as completed if:
+  - Tests are failing
+  - Implementation is partial
+  - You encountered unresolved errors
+  - You couldn't find necessary files or dependencies
+
+**Delete tasks:**
+- When a task is no longer relevant or was created in error
+- Setting status to `deleted` permanently removes the task
+
+**Update task details:**
+- When requirements change or become clearer
+- When establishing dependencies between tasks
+
+## Fields You Can Update
+
+- **status**: The task status (see Status Workflow below)
+- **subject**: Change the task title (imperative form, e.g., "Run tests")
+- **description**: Change the task description
+- **activeForm**: Present continuous form shown in spinner when in_progress (e.g., "Running tests")
+- **owner**: Change the task owner (agent name)
+- **metadata**: Merge metadata keys into the task (set a key to null to delete it)
+- **addBlocks**: Mark tasks that cannot start until this one completes
+- **addBlockedBy**: Mark tasks that must complete before this one can start
+
+## Status Workflow
+
+Status progresses: `pending` → `in_progress` → `completed`
+
+Use `deleted` to permanently remove a task.
+
+## Staleness
+
+Make sure to read a task's latest state using `TaskGet` before updating it.
+
+## Examples
+
+Mark task as in progress when starting work:
+```json
+{"taskId": "1", "status": "in_progress"}
+```
+
+Mark task as completed after finishing work:
+```json
+{"taskId": "1", "status": "completed"}
+```
+
+Delete a task:
+```json
+{"taskId": "1", "status": "deleted"}
+```
+
+Claim a task by setting owner:
+```json
+{"taskId": "1", "owner": "my-name"}
+```
+
+Set up task dependencies:
+```json
+{"taskId": "2", "addBlockedBy": ["1"]}
+```
+</textarea>

package/concepts/de/Tool-TeamCreate.md

@@ -0,0 +1,38 @@
+# TeamCreate
+
+## Definition
+
+Erstellt ein neues Team zur Koordination mehrerer Agenten, die an einem Projekt arbeiten. Teams ermöglichen parallele Aufgabenausführung über eine gemeinsame Aufgabenliste und agentenübergreifende Kommunikation.
+
+## Parameter
+
+| Parameter | Typ | Erforderlich | Beschreibung |
+|-----------|-----|--------------|--------------|
+| `team_name` | string | Ja | Name des neuen Teams |
+| `description` | string | Nein | Team-Beschreibung / Zweck |
+| `agent_type` | string | Nein | Typ / Rolle des Team-Leiters |
+
+## Was erstellt wird
+
+- **Team-Konfigurationsdatei**: `~/.claude/teams/{team-name}/config.json` — speichert Mitgliederliste und Metadaten
+- **Aufgabenlisten-Verzeichnis**: `~/.claude/tasks/{team-name}/` — gemeinsame Aufgabenliste für alle Teammitglieder
+
+Teams stehen in einem 1:1-Verhältnis zu Aufgabenlisten.
+
+## Team-Workflow
+
+1. **TeamCreate** — Team und zugehörige Aufgabenliste erstellen
+2. **TaskCreate** — Aufgaben für das Team definieren
+3. **Agent** (mit `team_name` + `name`) — Teammitglieder starten, die dem Team beitreten
+4. **TaskUpdate** — Aufgaben über `owner` an Teammitglieder zuweisen
+5. Teammitglieder bearbeiten Aufgaben und kommunizieren über **SendMessage**
+6. Teammitglieder beenden, dann **TeamDelete** zur Bereinigung
+
+## Verwandte Tools
+
+| Tool | Zweck |
+|------|-------|
+| `TeamDelete` | Team und Aufgabenverzeichnisse entfernen |
+| `SendMessage` | Kommunikation zwischen Agenten innerhalb des Teams |
+| `TaskCreate` / `TaskUpdate` / `TaskList` / `TaskGet` | Gemeinsame Aufgabenliste verwalten |
+| `Agent` | Teammitglieder starten, die dem Team beitreten |

package/concepts/de/Tool-TeamDelete.md

@@ -0,0 +1,30 @@
+# TeamDelete
+
+## Definition
+
+Entfernt ein Team und die zugehörigen Aufgabenverzeichnisse, wenn die Multi-Agent-Kollaborationsarbeit abgeschlossen ist. Dies ist das Bereinigungs-Gegenstück zu TeamCreate.
+
+## Verhalten
+
+- Entfernt das Team-Verzeichnis: `~/.claude/teams/{team-name}/`
+- Entfernt das Aufgabenverzeichnis: `~/.claude/tasks/{team-name}/`
+- Löscht den Team-Kontext aus der aktuellen Sitzung
+
+**Wichtig**: TeamDelete schlägt fehl, wenn das Team noch aktive Mitglieder hat. Teammitglieder müssen zuvor über SendMessage-Shutdown-Anfragen ordnungsgemäß beendet werden.
+
+## Typische Verwendung
+
+TeamDelete wird am Ende eines Team-Workflows aufgerufen:
+
+1. Alle Aufgaben sind abgeschlossen
+2. Teammitglieder werden über `SendMessage` mit `shutdown_request` beendet
+3. **TeamDelete** entfernt Team- und Aufgabenverzeichnisse
+
+## Verwandte Tools
+
+| Tool | Zweck |
+|------|-------|
+| `TeamCreate` | Neues Team und zugehörige Aufgabenliste erstellen |
+| `SendMessage` | Kommunikation mit Teammitgliedern / Shutdown-Anfragen senden |
+| `TaskCreate` / `TaskUpdate` / `TaskList` / `TaskGet` | Gemeinsame Aufgabenliste verwalten |
+| `Agent` | Teammitglieder starten, die dem Team beitreten |

package/concepts/de/Tool-WebFetch.md

@@ -0,0 +1,55 @@
+# WebFetch
+
+## Definition
+
+Ruft den Inhalt einer angegebenen URL ab, konvertiert HTML in Markdown und verarbeitet den Inhalt mit einem KI-Modell basierend auf dem Prompt.
+
+## Parameter
+
+| Parameter | Typ | Erforderlich | Beschreibung |
+|-----------|-----|--------------|--------------|
+| `url` | string (URI) | Ja | Die vollständige abzurufende URL |
+| `prompt` | string | Ja | Beschreibt, welche Informationen von der Seite extrahiert werden sollen |
+
+## Anwendungsfälle
+
+**Geeignet für:**
+- Inhalte öffentlicher Webseiten abrufen
+- Online-Dokumentation nachschlagen
+- Bestimmte Informationen aus Webseiten extrahieren
+
+**Nicht geeignet für:**
+- URLs, die Authentifizierung erfordern (Google Docs, Confluence, Jira, GitHub usw.) – zuerst nach einem dedizierten MCP-Tool suchen
+- GitHub-URLs – bevorzugt `gh` CLI verwenden
+
+## Hinweise
+
+- Die URL muss eine vollständige gültige URL sein
+- HTTP wird automatisch auf HTTPS hochgestuft
+- Bei sehr großen Inhalten können die Ergebnisse zusammengefasst werden
+- Enthält einen sich selbst bereinigenden 15-Minuten-Cache
+- Wenn die URL zu einem anderen Host weiterleitet, gibt das Tool die Weiterleitungs-URL zurück; eine erneute Anfrage mit der neuen URL ist erforderlich
+- Wenn ein MCP-bereitgestelltes Web-Fetch-Tool verfügbar ist, dieses bevorzugt verwenden
+
+## Originaltext
+
+<textarea readonly>IMPORTANT: WebFetch WILL FAIL for authenticated or private URLs. Before using this tool, check if the URL points to an authenticated service (e.g. Google Docs, Confluence, Jira, GitHub). If so, you MUST use ToolSearch first to find a specialized tool that provides authenticated access.
+
+- Fetches content from a specified URL and processes it using an AI model
+- Takes a URL and a prompt as input
+- Fetches the URL content, converts HTML to markdown
+- Processes the content with the prompt using a small, fast model
+- Returns the model's response about the content
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+  - IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions.
+  - The URL must be a fully-formed valid URL
+  - HTTP URLs will be automatically upgraded to HTTPS
+  - The prompt should describe what information you want to extract from the page
+  - This tool is read-only and does not modify any files
+  - Results may be summarized if the content is very large
+  - Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL
+  - When a URL redirects to a different host, the tool will inform you and provide the redirect URL in a special format. You should then make a new WebFetch request with the redirect URL to fetch the content.
+  - For GitHub URLs, prefer using the gh CLI via Bash instead (e.g., gh pr view, gh issue view, gh api).
+</textarea>

package/concepts/de/Tool-WebSearch.md

@@ -0,0 +1,58 @@
+# WebSearch
+
+## Definition
+
+Führt eine Suchmaschinenabfrage durch und gibt Suchergebnisse zurück, um aktuelle Informationen zu erhalten.
+
+## Parameter
+
+| Parameter | Typ | Erforderlich | Beschreibung |
+|-----------|-----|--------------|--------------|
+| `query` | string | Ja | Suchanfrage (mindestens 2 Zeichen) |
+| `allowed_domains` | string[] | Nein | Nur Ergebnisse von diesen Domains einschließen |
+| `blocked_domains` | string[] | Nein | Ergebnisse von diesen Domains ausschließen |
+
+## Anwendungsfälle
+
+**Geeignet für:**
+- Aktuelle Informationen abrufen, die über den Wissensstand des Modells hinausgehen
+- Aktuelle Ereignisse und neueste Daten finden
+- Neueste technische Dokumentation suchen
+
+## Hinweise
+
+- Suchergebnisse werden im Markdown-Hyperlink-Format zurückgegeben
+- Nach der Verwendung muss am Ende der Antwort ein "Sources:"-Abschnitt mit den relevanten URLs angefügt werden
+- Unterstützt Domain-Filterung (einschließen/ausschließen)
+- In Suchanfragen sollte das aktuelle Jahr verwendet werden
+- Nur in den USA verfügbar
+
+## Originaltext
+
+<textarea readonly>
+- Allows Claude to search the web and use the results to inform responses
+- Provides up-to-date information for current events and recent data
+- Returns search result information formatted as search result blocks, including links as markdown hyperlinks
+- Use this tool for accessing information beyond Claude's knowledge cutoff
+- Searches are performed automatically within a single API call
+
+CRITICAL REQUIREMENT - You MUST follow this:
+  - After answering the user's question, you MUST include a "Sources:" section at the end of your response
+  - In the Sources section, list all relevant URLs from the search results as markdown hyperlinks: [Title](URL)
+  - This is MANDATORY - never skip including sources in your response
+  - Example format:
+
+    [Your answer here]
+
+    Sources:
+    - [Source Title 1](https://example.com/1)
+    - [Source Title 2](https://example.com/2)
+
+Usage notes:
+  - Domain filtering is supported to include or block specific websites
+  - Web search is only available in the US
+
+IMPORTANT - Use the correct year in search queries:
+  - The current month is March 2026. You MUST use this year when searching for recent information, documentation, or current events.
+  - Example: If the user asks for "latest React docs", search for "React documentation" with the current year, NOT last year
+</textarea>

package/concepts/de/Tool-Write.md

@@ -0,0 +1,39 @@
+# Write
+
+## Definition
+
+Schreibt Inhalte in das lokale Dateisystem. Überschreibt die Datei, falls sie bereits existiert.
+
+## Parameter
+
+| Parameter | Typ | Erforderlich | Beschreibung |
+|-----------|-----|--------------|--------------|
+| `file_path` | string | Ja | Absoluter Pfad der Datei (muss ein absoluter Pfad sein) |
+| `content` | string | Ja | Der zu schreibende Inhalt |
+
+## Anwendungsfälle
+
+**Geeignet für:**
+- Neue Dateien erstellen
+- Wenn der Dateiinhalt vollständig neu geschrieben werden muss
+
+**Nicht geeignet für:**
+- Teilinhalte einer Datei ändern – dafür Edit verwenden
+- Nicht proaktiv Dokumentationsdateien (*.md) oder READMEs erstellen, es sei denn, der Benutzer fordert es ausdrücklich an
+
+## Hinweise
+
+- Wenn die Zieldatei bereits existiert, muss sie zuerst über Read gelesen werden, sonst schlägt der Vorgang fehl
+- Überschreibt den gesamten Inhalt einer vorhandenen Datei
+- Edit zum Bearbeiten vorhandener Dateien bevorzugen; Write nur für neue Dateien oder vollständige Neuschreibungen verwenden
+
+## Originaltext
+
+<textarea readonly>Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- Prefer the Edit tool for modifying existing files — it only sends the diff. Only use this tool to create new files or for complete rewrites.
+- NEVER create documentation files (*.md) or README files unless explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.</textarea>

package/concepts/de/Tool-executeCode.md

@@ -0,0 +1,41 @@
+# executeCode (mcp__ide__executeCode)
+
+## Definition
+
+Führt Python-Code im Jupyter-Kernel der aktuellen Notebook-Datei aus.
+
+## Parameter
+
+| Parameter | Typ | Erforderlich | Beschreibung |
+|-----------|-----|--------------|--------------|
+| `code` | string | Ja | Der auszuführende Python-Code |
+
+## Anwendungsfälle
+
+**Geeignet für:**
+- Code in einer Jupyter-Notebook-Umgebung ausführen
+- Code-Snippets testen
+- Datenanalyse und Berechnungen
+
+**Nicht geeignet für:**
+- Codeausführung außerhalb von Jupyter – dafür Bash verwenden
+- Dateien ändern – dafür Edit oder Write verwenden
+
+## Hinweise
+
+- Dies ist ein MCP-Tool (Model Context Protocol), bereitgestellt durch die IDE-Integration
+- Code wird im aktuellen Jupyter-Kernel ausgeführt, der Zustand bleibt zwischen Aufrufen bestehen
+- Sofern der Benutzer es nicht ausdrücklich anfordert, sollte das Deklarieren von Variablen oder Ändern des Kernel-Zustands vermieden werden
+- Nach einem Kernel-Neustart geht der Zustand verloren
+
+## Originaltext
+
+<textarea readonly>Execute python code in the Jupyter kernel for the current notebook file.
+    
+    All code will be executed in the current Jupyter kernel.
+    
+    Avoid declaring variables or modifying the state of the kernel unless the user
+    explicitly asks for it.
+    
+    Any code executed will persist across calls to this tool, unless the kernel
+    has been restarted.</textarea>

package/concepts/de/Tool-getDiagnostics.md

@@ -0,0 +1,32 @@
+# getDiagnostics (mcp__ide__getDiagnostics)
+
+## Definition
+
+Ruft Sprachdiagnoseinformationen von VS Code ab, einschließlich Syntaxfehler, Typfehler, Lint-Warnungen usw.
+
+## Parameter
+
+| Parameter | Typ | Erforderlich | Beschreibung |
+|-----------|-----|--------------|--------------|
+| `uri` | string | Nein | Datei-URI. Wenn nicht angegeben, werden Diagnoseinformationen aller Dateien abgerufen |
+
+## Anwendungsfälle
+
+**Geeignet für:**
+- Syntax-, Typ-, Lint- und andere semantische Probleme im Code prüfen
+- Nach Codebearbeitung überprüfen, ob neue Fehler eingeführt wurden
+- Als Alternative zu Bash-Befehlen zur Codequalitätsprüfung
+
+**Nicht geeignet für:**
+- Tests ausführen – dafür Bash verwenden
+- Laufzeitfehler prüfen – dafür Code über Bash ausführen
+
+## Hinweise
+
+- Dies ist ein MCP-Tool (Model Context Protocol), bereitgestellt durch die IDE-Integration
+- Nur in VS Code / IDE-Umgebungen verfügbar
+- Dieses Tool gegenüber Bash-Befehlen zur Codeprüfung bevorzugen
+
+## Originaltext
+
+<textarea readonly>Get language diagnostics from VS Code</textarea>

package/concepts/de/Tools.md

@@ -0,0 +1,67 @@
+# Claude Code Tool-Übersicht
+
+Claude Code stellt dem Modell über den tool_use-Mechanismus der Anthropic API eine Reihe integrierter Tools zur Verfügung. Das `tools`-Array jeder MainAgent-Anfrage enthält die vollständigen JSON-Schema-Definitionen dieser Tools, und das Modell ruft sie in der Antwort über `tool_use` Content Blocks auf.
+
+Im Folgenden finden Sie den kategorisierten Index aller Tools.
+
+## Agent-System
+
+| Tool | Zweck |
+|------|-------|
+| [Task](Tool-Task.md) | Startet einen Sub-Agent (SubAgent) für komplexe mehrstufige Aufgaben |
+| [TaskOutput](Tool-TaskOutput.md) | Ruft die Ausgabe von Hintergrundaufgaben ab |
+| [TaskStop](Tool-TaskStop.md) | Stoppt eine laufende Hintergrundaufgabe |
+| [TaskCreate](Tool-TaskCreate.md) | Erstellt einen strukturierten Aufgabenlisteneintrag |
+| [TaskGet](Tool-TaskGet.md) | Ruft Aufgabendetails ab |
+| [TaskUpdate](Tool-TaskUpdate.md) | Aktualisiert Aufgabenstatus, Abhängigkeiten usw. |
+| [TaskList](Tool-TaskList.md) | Listet alle Aufgaben auf |
+
+## Dateioperationen
+
+| Tool | Zweck |
+|------|-------|
+| [Read](Tool-Read.md) | Liest Dateiinhalte (unterstützt Text, Bilder, PDF, Jupyter Notebook) |
+| [Edit](Tool-Edit.md) | Bearbeitet Dateien durch exakte Zeichenkettenersetzung |
+| [Write](Tool-Write.md) | Schreibt oder überschreibt Dateien |
+| [NotebookEdit](Tool-NotebookEdit.md) | Bearbeitet Jupyter-Notebook-Zellen |
+
+## Suche
+
+| Tool | Zweck |
+|------|-------|
+| [Glob](Tool-Glob.md) | Sucht Dateien nach Dateinamenmustern |
+| [Grep](Tool-Grep.md) | Dateiinhaltssuche basierend auf ripgrep |
+
+## Terminal
+
+| Tool | Zweck |
+|------|-------|
+| [Bash](Tool-Bash.md) | Führt Shell-Befehle aus |
+
+## Web
+
+| Tool | Zweck |
+|------|-------|
+| [WebFetch](Tool-WebFetch.md) | Ruft Webinhalte ab und verarbeitet sie mit KI |
+| [WebSearch](Tool-WebSearch.md) | Suchmaschinenabfrage |
+
+## Planung und Interaktion
+
+| Tool | Zweck |
+|------|-------|
+| [EnterPlanMode](Tool-EnterPlanMode.md) | Wechselt in den Planungsmodus zur Entwurfsplanung |
+| [ExitPlanMode](Tool-ExitPlanMode.md) | Verlässt den Planungsmodus und reicht den Plan zur Benutzerfreigabe ein |
+| [AskUserQuestion](Tool-AskUserQuestion.md) | Stellt dem Benutzer Fragen zur Klärung oder Entscheidungsfindung |
+
+## Erweiterungen
+
+| Tool | Zweck |
+|------|-------|
+| [Skill](Tool-Skill.md) | Führt einen Skill (Slash Command) aus |
+
+## IDE-Integration
+
+| Tool | Zweck |
+|------|-------|
+| [getDiagnostics](Tool-getDiagnostics.md) | Ruft VS Code Sprachdiagnoseinformationen ab |
+| [executeCode](Tool-executeCode.md) | Führt Code im Jupyter-Kernel aus |

package/concepts/de/ToolsFirst.md

@@ -0,0 +1,77 @@
+# Warum werden Tools zuerst aufgelistet?
+
+Im Context-Panel von cc-viewer **erscheinen Tools vor System Prompt und Messages**. Diese Reihenfolge spiegelt exakt die **KV-Cache-Präfix-Sequenz der Anthropic API** wider.
+
+## KV-Cache-Präfix-Sequenz
+
+Wenn die Anthropic API den KV-Cache aufbaut, verkettet sie den Kontext in dieser **festen Reihenfolge** zu einem Präfix:
+
+```
+┌─────────────────────────────────────────────────┐
+│ 1. Tools (JSON Schema definitions)               │  ← Start of cache prefix
+│ 2. System Prompt                                 │
+│ 3. Messages (conversation history + current turn)│  ← End of cache prefix
+└─────────────────────────────────────────────────┘
+```
+
+Das bedeutet: **Tools befinden sich vor dem System Prompt, ganz am Anfang des Cache-Präfixes**.
+
+## Warum haben Tools ein höheres Cache-Gewicht als System?
+
+Beim KV-Cache-Präfix-Matching ist **früher Inhalt entscheidender** — jede Änderung macht alles Folgende ungültig:
+
+1. **Präfix-Matching beginnt am Anfang**: Der KV-Cache vergleicht die aktuelle Anfrage token-für-token vom Anfang mit dem gecachten Präfix. Sobald eine Abweichung gefunden wird, wird der gesamte nachfolgende Inhalt invalidiert.
+
+2. **Änderung der Tools = gesamter Cache invalidiert**: Da Tools an erster Stelle stehen, **bricht jede Änderung an Tool-Definitionen (auch das Hinzufügen oder Entfernen eines einzelnen MCP-Tools) das Präfix vom ersten Moment an**, wodurch alle gecachten System Prompt- und Messages-Inhalte invalidiert werden.
+
+3. **Änderung von System = Messages-Cache invalidiert**: Der System Prompt befindet sich in der Mitte, sodass seine Änderungen nur den nachfolgenden Messages-Teil invalidieren.
+
+4. **Änderung von Messages = nur das Ende betroffen**: Messages stehen am Ende, sodass das Anhängen neuer Messages nur ein kleines abschließendes Segment invalidiert — Tools- und System-Cache bleiben intakt.
+
+## Praktische Auswirkungen
+
+| Änderungstyp | Cache-Auswirkung | Typisches Szenario |
+|-------------|-------------|-----------------|
+| Tool hinzugefügt/entfernt | **Vollständige Invalidierung** | MCP-Server verbinden/trennen, IDE-Plugin ein-/ausschalten |
+| System Prompt-Änderung | Messages-Cache verloren | CLAUDE.md bearbeiten, system reminder einfügen |
+| Neue Message angehängt | Nur Tail-Inkrement | Normaler Gesprächsfluss (am häufigsten, am günstigsten) |
+
+Deshalb ist `tools_change` in [CacheRebuild](CacheRebuild.md) oft der teuerste Rebuild-Grund — es bricht die Präfix-Kette ganz am Anfang.
+
+## Warum werden Tool-Definitionen vor dem „Gehirn" platziert?
+
+Aus Caching-Perspektive ist die Platzierung der Tools an erster Stelle eine technische Tatsache. Doch auch aus Sicht des kognitiven Designs ist diese Reihenfolge logisch — **Tools sind die Hände und Füße, System Prompt ist das Gehirn**.
+
+Bevor ein Mensch handelt, muss er wahrnehmen, welche Gliedmaßen und Werkzeuge ihm zur Verfügung stehen. Ein Säugling versteht nicht zuerst die Regeln der Welt (System) und lernt dann zu greifen — er nimmt zuerst wahr, dass er Hände und Füße hat, und versteht dann durch Interaktion mit der Umwelt allmählich die Regeln. Ebenso muss ein LLM wissen, welche Tools es aufrufen kann (Dateien lesen, Code schreiben, suchen, Befehle ausführen), bevor es Aufgabenanweisungen (System Prompt) erhält, damit es bei der Verarbeitung der Anweisungen genau einschätzen kann: „Was kann ich tun?" und „Wie soll ich vorgehen?"
+
+Wenn es umgekehrt wäre — dem Modell zuerst sagen „Deine Aufgabe ist es, dieses Modul umzubauen", dann „Du hast Read, Edit, Bash-Tools" — würde dem Modell beim Verständnis der Aufgabe kritische Information über seine Fähigkeitsgrenzen fehlen, was zu unrealistischen Plänen oder dem Übersehen verfügbarer Ansätze führen könnte.
+
+**Erst wissen, welche Karten man hat, dann entscheiden, wie man spielt.** Das ist die kognitive Logik dahinter, dass Tools vor System stehen.
+
+## Warum sind MCP-Tools ebenfalls an dieser Position?
+
+MCP-Tools (Model Context Protocol) werden wie eingebaute Tools ganz vorne im Tools-Bereich platziert. Das Verständnis der Position von MCP im Kontext hilft, die tatsächlichen Vorteile und Kosten zu bewerten.
+
+### Vorteile von MCP
+
+- **Fähigkeitserweiterung**: MCP ermöglicht Modellen den Zugriff auf externe Dienste (Datenbankabfragen, API-Aufrufe, IDE-Operationen, Browser-Steuerung usw.) und überwindet die Grenzen eingebauter Tools
+- **Offenes Ökosystem**: Jeder kann einen MCP-Server implementieren; das Modell erhält neue Fähigkeiten ohne Neutraining
+- **Laden bei Bedarf**: MCP-Server können je nach Aufgabenszenario selektiv verbunden/getrennt werden, was flexible Tool-Zusammenstellungen ermöglicht
+
+### Kosten von MCP
+
+- **Cache-Killer**: Die JSON-Schema-Definition jedes MCP-Tools wird ganz an den Anfang des KV-Cache-Präfix angehängt. Ein MCP-Tool hinzufügen/entfernen = **gesamter Cache von Anfang an ungültig**. Häufiges Verbinden/Trennen von MCP-Servern reduziert die Cache-Trefferquote drastisch
+- **Präfix-Aufblähung**: MCP-Tool-Schemas sind typischerweise größer als eingebaute Tools (detaillierte Parameterbeschreibungen, Enumerationswerte usw.). Viele MCP-Tools erhöhen die Token-Anzahl im Tools-Bereich erheblich und verringern den für Messages verfügbaren Kontext-Raum
+- **Latenz-Overhead**: MCP-Tool-Aufrufe erfordern prozessübergreifende Kommunikation (JSON-RPC über stdio/SSE), eine Größenordnung langsamer als eingebaute Funktionsaufrufe
+- **Stabilitätsrisiko**: MCP-Server sind externe Prozesse, die abstürzen, Timeouts verursachen oder unerwartete Formate zurückgeben können und zusätzliche Fehlerbehandlung erfordern
+
+### Praktische Empfehlungen
+
+| Szenario | Empfehlung |
+|----------|-----------|
+| Lange Gespräche, häufige Interaktion | MCP-Tool-Anzahl minimieren, um Cache-Präfix-Stabilität zu schützen |
+| Kurze Aufgaben, einmalige Operationen | MCP-Tools frei verwenden; Cache-Auswirkung ist begrenzt |
+| Häufiges Hinzufügen/Entfernen von MCP-Servern | Jede Änderung löst vollständigen Cache-Neuaufbau aus; feste Tool-Zusammenstellung erwägen |
+| Überdimensionierte Tool-Schemas | Beschreibungen und Enums kürzen, um Token-Verbrauch im Präfix zu reduzieren |
+
+Im Context-Panel von cc-viewer werden MCP-Tools neben eingebauten Tools im Tools-Bereich angezeigt, sodass Sie die Schema-Größe jedes Tools und seinen Beitrag zum Cache-Präfix direkt sehen können.

package/concepts/de/TranslateContextPollution.md

@@ -0,0 +1,46 @@
+# Kontextverschmutzung der Übersetzungs-API
+
+## Hintergrund
+
+CC-Viewer enthält eine integrierte Übersetzungsfunktion (`POST /api/translate`), die von der Anthropic Messages API angetrieben wird. In der frühen Implementierung verwendeten Übersetzungsanfragen die zwischengespeicherten Authentifizierungsdaten der Claude Code-Sitzung wieder — einschließlich der Header `x-api-key` und `authorization`. Dies verursachte ein subtiles, aber schwerwiegendes Problem: Übersetzungsergebnisse lieferten häufig irrelevante Inhalte zurück.
+
+## Ursache
+
+### Grundlegender Unterschied zwischen zwei Authentifizierungsmethoden
+
+Die Anthropic API unterstützt zwei Authentifizierungsmethoden:
+
+| Methode | Header | Typische Quelle | Eigenschaften |
+|---------|--------|-----------------|---------------|
+| API-Schlüssel | `x-api-key: sk-ant-...` | Umgebungsvariable / Console | Zustandslos, jede Anfrage ist unabhängig |
+| OAuth-Token | `authorization: Bearer sessionToken` | Claude Code-Abonnement-Login | Sitzungsgebunden, Server pflegt Kontextzuordnung |
+
+Der entscheidende Unterschied: **API-Schlüssel sind zustandslos** — jede Anfrage ist vollständig unabhängig; während **OAuth-Sitzungstoken zustandsbehaftet sind** — der Anthropic-Server ordnet Anfragen mit demselben Token demselben Sitzungskontext zu.
+
+### Verschmutzungskette
+
+Wenn Claude Code die OAuth-Anmeldung über ein Abonnement verwendet, sieht der Authentifizierungsfluss folgendermaßen aus:
+
+```
+Claude Code Hauptkonversation ──(authorization: Bearer sessionToken)──→ Anthropic API
+                                                                          ↑
+CC-Viewer Übersetzungsanfrage ──(authorization: Bearer sessionToken)──→ Anthropic API
+```
+
+Da Übersetzungsanfragen dasselbe Sitzungstoken wiederverwendeten, konnte der Anthropic-Server Übersetzungsanfragen mit dem Hauptkonversationskontext von Claude Code verknüpfen. Dies führt zu:
+
+1. **Übersetzungsergebnisse werden vom Hauptkonversationskontext beeinflusst**: Der Systemprompt der Übersetzungsanfrage lautet „Du bist ein Übersetzer", aber der Serverkontext enthält weiterhin den Gesprächsverlauf von Claude Code, was das Modell beeinträchtigen kann
+2. **Hauptkonversation wird durch Übersetzungsanfragen gestört**: Inhalte der Übersetzungsanfrage (UI-Textfragmente) können in den Hauptkonversationskontext injiziert werden, wodurch die Antworten von Claude Code abweichen
+3. **Unvorhersehbares Verhalten**: Da die Kontextverschmutzung serverseitiges Verhalten ist, kann der Client sie weder erkennen noch kontrollieren
+
+## Erkenntnisse
+
+- **OAuth-Sitzungstoken sind nicht „einfach ein weiterer API-Schlüssel"** — sie tragen serverseitigen Zustand, ihre Wiederverwendung bedeutet gemeinsame Nutzung des Kontexts
+- **Interne Dienstaufrufe sollten eine unabhängige, zustandslose Authentifizierung verwenden**, um eine Verknüpfung mit Benutzersitzungen zu vermeiden
+
+## Referenzen
+
+- [Anthropic API Authentication Docs](https://docs.anthropic.com/en/api/getting-started)
+- [Claude Code Authentication](https://support.claude.com/en/articles/12304248-managing-api-key-environment-variables-in-claude-code)
+- [Anthropic Bans Subscription OAuth in Third-Party Apps](https://winbuzzer.com/2026/02/19/anthropic-bans-claude-subscription-oauth-in-third-party-apps-xcxwbn/)
+- [Claude Code Authentication: API Keys, Subscriptions, and SSO](https://developertoolkit.ai/en/claude-code/quick-start/authentication/)