cx-viewer 1.0.0

package/concepts/da/Tool-TaskUpdate.md

@@ -0,0 +1,123 @@
+# TaskUpdate
+
+## Definition
+
+Opdaterer status, indhold eller afhængigheder for en opgave i opgavelisten.
+
+## Parametre
+
+| Parameter | Type | Påkrævet | Beskrivelse |
+|------|------|------|------|
+| `taskId` | string | Ja | ID på opgaven der skal opdateres |
+| `status` | enum | Nej | Ny status: `pending` / `in_progress` / `completed` / `deleted` |
+| `subject` | string | Nej | Ny titel |
+| `description` | string | Nej | Ny beskrivelse |
+| `activeForm` | string | Nej | Tekst i nutids-tillægsform vist under udførelse |
+| `owner` | string | Nej | Ny opgaveansvarlig (agent-navn) |
+| `metadata` | object | Nej | Metadata der skal flettes (sæt til null for at slette en nøgle) |
+| `addBlocks` | string[] | Nej | Liste over ID'er for opgaver blokeret af denne opgave |
+| `addBlockedBy` | string[] | Nej | Liste over ID'er for forudgående opgaver der blokerer denne opgave |
+
+## Statusflow
+
+```
+pending → in_progress → completed
+```
+
+`deleted` kan nås fra enhver status og fjerner opgaven permanent.
+
+## Brugsscenarier
+
+**Egnet til:**
+- Markere en opgave som `in_progress` når arbejdet påbegyndes
+- Markere en opgave som `completed` når arbejdet er afsluttet
+- Sætte afhængigheder mellem opgaver
+- Opdatere opgaveindhold når kravene ændres
+
+**Vigtige regler:**
+- Markér kun som `completed` når opgaven er fuldstændigt afsluttet
+- Ved fejl eller blokeringer, behold `in_progress`
+- Markér ikke som `completed` ved fejlende tests, ufuldstændig implementering eller uløste fejl
+
+## Bemærkninger
+
+- Før opdatering bør man hente opgavens seneste status via TaskGet for at undgå forældede data
+- Efter fuldførelse af en opgave, kald TaskList for at finde den næste tilgængelige opgave
+
+## Originaltekst
+
+<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/da/Tool-TeamCreate.md

@@ -0,0 +1,38 @@
+# TeamCreate
+
+## Definition
+
+Opretter et nyt team til at koordinere flere agenter, der arbejder på et projekt. Teams muliggør parallel opgaveudførelse via en delt opgaveliste og kommunikation mellem agenter.
+
+## Parametre
+
+| Parameter | Type | Påkrævet | Beskrivelse |
+|-----------|------|----------|-------------|
+| `team_name` | string | Ja | Navn til det nye team |
+| `description` | string | Nej | Teambeskrivelse / formål |
+| `agent_type` | string | Nej | Type / rolle for teamlederen |
+
+## Hvad der oprettes
+
+- **Team-konfigurationsfil**: `~/.claude/teams/{team-name}/config.json` — gemmer medlemsliste og metadata
+- **Opgavelistemappe**: `~/.claude/tasks/{team-name}/` — delt opgaveliste for alle teammedlemmer
+
+Teams har et 1:1-forhold til opgavelister.
+
+## Team-arbejdsgang
+
+1. **TeamCreate** — opret teamet og dets opgaveliste
+2. **TaskCreate** — definer opgaver for teamet
+3. **Agent** (med `team_name` + `name`) — start teammedlemmer der tilslutter sig teamet
+4. **TaskUpdate** — tildel opgaver til teammedlemmer via `owner`
+5. Teammedlemmer arbejder på opgaver og kommunikerer via **SendMessage**
+6. Luk teammedlemmer ned når det er færdigt, derefter **TeamDelete** for at rydde op
+
+## Relaterede værktøjer
+
+| Værktøj | Formål |
+|---------|--------|
+| `TeamDelete` | Fjern team og opgavemapper |
+| `SendMessage` | Kommunikation mellem agenter inden for teamet |
+| `TaskCreate` / `TaskUpdate` / `TaskList` / `TaskGet` | Administrer den delte opgaveliste |
+| `Agent` | Start teammedlemmer der tilslutter sig teamet |

package/concepts/da/Tool-TeamDelete.md

@@ -0,0 +1,30 @@
+# TeamDelete
+
+## Definition
+
+Fjerner et team og dets tilknyttede opgavemapper når multi-agent-samarbejdsarbejdet er afsluttet. Dette er oprydningsmodstykket til TeamCreate.
+
+## Adfærd
+
+- Fjerner team-mappen: `~/.claude/teams/{team-name}/`
+- Fjerner opgavelistemappen: `~/.claude/tasks/{team-name}/`
+- Rydder team-konteksten fra den aktuelle session
+
+**Vigtigt**: TeamDelete fejler hvis teamet stadig har aktive medlemmer. Teammedlemmer skal først lukkes ned korrekt via SendMessage shutdown-anmodninger.
+
+## Typisk anvendelse
+
+TeamDelete kaldes i slutningen af en team-arbejdsgang:
+
+1. Alle opgaver er fuldført
+2. Teammedlemmer lukkes ned via `SendMessage` med `shutdown_request`
+3. **TeamDelete** fjerner team- og opgavemapper
+
+## Relaterede værktøjer
+
+| Værktøj | Formål |
+|---------|--------|
+| `TeamCreate` | Opret et nyt team og dets opgaveliste |
+| `SendMessage` | Kommuniker med teammedlemmer / send shutdown-anmodninger |
+| `TaskCreate` / `TaskUpdate` / `TaskList` / `TaskGet` | Administrer den delte opgaveliste |
+| `Agent` | Start teammedlemmer der tilslutter sig teamet |

package/concepts/da/Tool-WebFetch.md

@@ -0,0 +1,55 @@
+# WebFetch
+
+## Definition
+
+Henter indholdet af en webside fra den angivne URL, konverterer HTML til markdown og behandler indholdet med en AI-model baseret på prompten.
+
+## Parametre
+
+| Parameter | Type | Påkrævet | Beskrivelse |
+|------|------|------|------|
+| `url` | string (URI) | Ja | Komplet URL der skal hentes |
+| `prompt` | string | Ja | Beskriver hvilken information der skal udtrækkes fra siden |
+
+## Brugsscenarier
+
+**Egnet til:**
+- Hente indhold fra offentlige websider
+- Slå op i onlinedokumentation
+- Udtrække specifik information fra en webside
+
+**Ikke egnet til:**
+- URL'er der kræver autentificering (Google Docs, Confluence, Jira, GitHub osv.) — søg først efter et dedikeret MCP-værktøj
+- GitHub-URL'er — foretræk brug af `gh` CLI
+
+## Bemærkninger
+
+- URL'en skal være en komplet gyldig URL
+- HTTP opgraderes automatisk til HTTPS
+- Resultater kan blive opsummeret, hvis indholdet er for stort
+- Inkluderer en selvrensende 15-minutters cache
+- Når URL'en omdirigerer til en anden vært, returnerer værktøjet omdirigerings-URL'en, og der skal foretages en ny anmodning med den nye URL
+- Hvis et MCP-leveret web fetch-værktøj er tilgængeligt, foretræk det
+
+## Originaltekst
+
+<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/da/Tool-WebSearch.md

@@ -0,0 +1,58 @@
+# WebSearch
+
+## Definition
+
+Udfører en søgemaskineforespørgsel og returnerer søgeresultater til at hente aktuel information.
+
+## Parametre
+
+| Parameter | Type | Påkrævet | Beskrivelse |
+|------|------|------|------|
+| `query` | string | Ja | Søgeforespørgsel (mindst 2 tegn) |
+| `allowed_domains` | string[] | Nej | Inkluder kun resultater fra disse domæner |
+| `blocked_domains` | string[] | Nej | Ekskluder resultater fra disse domæner |
+
+## Brugsscenarier
+
+**Egnet til:**
+- Hente aktuel information ud over modellens videns-cutoff-dato
+- Søge efter aktuelle begivenheder og nyeste data
+- Søge efter den nyeste tekniske dokumentation
+
+## Bemærkninger
+
+- Søgeresultater returneres i markdown-hyperlinkformat
+- Efter brug skal der tilføjes en "Sources:"-sektion i slutningen af svaret med relevante URL'er
+- Understøtter domænefiltrering (inklusion/eksklusion)
+- Brug det aktuelle år i søgeforespørgsler
+- Kun tilgængelig i USA
+
+## Originaltekst
+
+<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/da/Tool-Write.md

@@ -0,0 +1,39 @@
+# Write
+
+## Definition
+
+Skriver indhold til det lokale filsystem. Hvis filen allerede eksisterer, overskrives den.
+
+## Parametre
+
+| Parameter | Type | Påkrævet | Beskrivelse |
+|------|------|------|------|
+| `file_path` | string | Ja | Absolut sti til filen (skal være absolut) |
+| `content` | string | Ja | Indhold der skal skrives |
+
+## Brugsscenarier
+
+**Egnet til:**
+- Oprette nye filer
+- Når filindholdet skal omskrives fuldstændigt
+
+**Ikke egnet til:**
+- Ændre delvist indhold i en fil — brug Edit
+- Opret ikke proaktivt dokumentationsfiler (*.md) eller README, medmindre brugeren udtrykkeligt beder om det
+
+## Bemærkninger
+
+- Hvis målfilen allerede eksisterer, skal den først læses via Read, ellers fejler operationen
+- Overskriver alt eksisterende filindhold
+- Foretræk Edit til redigering af eksisterende filer, Write er kun til oprettelse af nye filer eller fuldstændig omskrivning
+
+## Originaltekst
+
+<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/da/Tool-executeCode.md

@@ -0,0 +1,41 @@
+# executeCode (mcp__ide__executeCode)
+
+## Definition
+
+Udfører Python-kode i Jupyter-kernen for den aktuelle notebook-fil.
+
+## Parametre
+
+| Parameter | Type | Påkrævet | Beskrivelse |
+|------|------|------|------|
+| `code` | string | Ja | Python-kode der skal udføres |
+
+## Brugsscenarier
+
+**Egnet til:**
+- Udføre kode i et Jupyter notebook-miljø
+- Teste kodestykker
+- Dataanalyse og beregninger
+
+**Ikke egnet til:**
+- Kodeudførelse i ikke-Jupyter-miljøer — brug Bash
+- Ændre filer — brug Edit eller Write
+
+## Bemærkninger
+
+- Dette er et MCP-værktøj (Model Context Protocol), leveret af IDE-integrationen
+- Kode udføres i den aktuelle Jupyter-kerne, tilstanden bevares mellem kald
+- Medmindre brugeren udtrykkeligt beder om det, undgå at deklarere variabler eller ændre kernens tilstand
+- Tilstanden går tabt efter genstart af kernen
+
+## Originaltekst
+
+<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/da/Tool-getDiagnostics.md

@@ -0,0 +1,32 @@
+# getDiagnostics (mcp__ide__getDiagnostics)
+
+## Definition
+
+Henter sprogdiagnostikinformation fra VS Code, herunder syntaksfejl, typefejl, lint-advarsler osv.
+
+## Parametre
+
+| Parameter | Type | Påkrævet | Beskrivelse |
+|------|------|------|------|
+| `uri` | string | Nej | Fil-URI. Hvis ikke angivet, hentes diagnostikinformation for alle filer |
+
+## Brugsscenarier
+
+**Egnet til:**
+- Kontrollere kodens semantiske problemer som syntaks, typer, lint
+- Verificere om der er introduceret nye fejl efter koderediger
+- Erstatte Bash-kommandoer til kontrol af kodekvalitet
+
+**Ikke egnet til:**
+- Køre tests — brug Bash
+- Kontrollere runtime-fejl — brug Bash til at udføre koden
+
+## Bemærkninger
+
+- Dette er et MCP-værktøj (Model Context Protocol), leveret af IDE-integrationen
+- Kun tilgængeligt i VS Code / IDE-miljøer
+- Foretræk dette værktøj frem for Bash-kommandoer til kontrol af kodeproblemer
+
+## Originaltekst
+
+<textarea readonly>Get language diagnostics from VS Code</textarea>

package/concepts/da/Tools.md

@@ -0,0 +1,67 @@
+# Oversigt over Claude Code-værktøjer
+
+Claude Code giver modellen et sæt indbyggede værktøjer via Anthropic API'ens tool_use-mekanisme. `tools`-arrayet i hver MainAgent-request indeholder de komplette JSON Schema-definitioner for disse værktøjer, og modellen kalder dem via `tool_use` content blocks i svaret.
+
+Nedenfor er det kategoriserede indeks over alle værktøjer.
+
+## Agent-system
+
+| Værktøj | Formål |
+|------|------|
+| [Task](Tool-Task.md) | Start en sub-agent (SubAgent) til at håndtere komplekse flertrinsopgaver |
+| [TaskOutput](Tool-TaskOutput.md) | Hent output fra en baggrundsopgave |
+| [TaskStop](Tool-TaskStop.md) | Stop en kørende baggrundsopgave |
+| [TaskCreate](Tool-TaskCreate.md) | Opret en struktureret opgavelistepost |
+| [TaskGet](Tool-TaskGet.md) | Hent opgavedetaljer |
+| [TaskUpdate](Tool-TaskUpdate.md) | Opdater opgavestatus, afhængigheder osv. |
+| [TaskList](Tool-TaskList.md) | List alle opgaver |
+
+## Filoperationer
+
+| Værktøj | Formål |
+|------|------|
+| [Read](Tool-Read.md) | Læs filindhold (understøtter tekst, billeder, PDF, Jupyter notebook) |
+| [Edit](Tool-Edit.md) | Rediger fil via præcis strengerstatning |
+| [Write](Tool-Write.md) | Skriv eller overskriv en fil |
+| [NotebookEdit](Tool-NotebookEdit.md) | Rediger Jupyter notebook-celler |
+
+## Søgning
+
+| Værktøj | Formål |
+|------|------|
+| [Glob](Tool-Glob.md) | Søg filer efter filnavnsmønster |
+| [Grep](Tool-Grep.md) | Søg i filindhold baseret på ripgrep |
+
+## Terminal
+
+| Værktøj | Formål |
+|------|------|
+| [Bash](Tool-Bash.md) | Udfør shell-kommandoer |
+
+## Web
+
+| Værktøj | Formål |
+|------|------|
+| [WebFetch](Tool-WebFetch.md) | Hent webindhold og behandl det med AI |
+| [WebSearch](Tool-WebSearch.md) | Søgemaskineforespørgsel |
+
+## Planlægning og interaktion
+
+| Værktøj | Formål |
+|------|------|
+| [EnterPlanMode](Tool-EnterPlanMode.md) | Gå ind i planlægningstilstand for at designe en implementeringsplan |
+| [ExitPlanMode](Tool-ExitPlanMode.md) | Forlad planlægningstilstand og indsend planen til brugerens godkendelse |
+| [AskUserQuestion](Tool-AskUserQuestion.md) | Stil spørgsmål til brugeren for at få afklaring eller beslutninger |
+
+## Udvidelser
+
+| Værktøj | Formål |
+|------|------|
+| [Skill](Tool-Skill.md) | Udfør en skill (slash command) |
+
+## IDE-integration
+
+| Værktøj | Formål |
+|------|------|
+| [getDiagnostics](Tool-getDiagnostics.md) | Hent sprogdiagnostik fra VS Code |
+| [executeCode](Tool-executeCode.md) | Udfør kode i Jupyter-kernen |

package/concepts/da/ToolsFirst.md

@@ -0,0 +1,77 @@
+# Hvorfor vises Tools først?
+
+I cc-viewers kontekstpanel vises **Tools før System Prompt og Messages**. Denne rækkefølge afspejler præcist **Anthropic API's KV-Cache-præfikssekvens**.
+
+## KV-Cache-præfikssekvens
+
+Når Anthropic's API opbygger KV-Cache, sammensætter den konteksten til et præfiks i denne **faste rækkefølge**:
+
+```
+┌─────────────────────────────────────────────────┐
+│ 1. Tools (JSON Schema definitions)               │  ← Start of cache prefix
+│ 2. System Prompt                                 │
+│ 3. Messages (conversation history + current turn)│  ← End of cache prefix
+└─────────────────────────────────────────────────┘
+```
+
+Det betyder, at **Tools befinder sig før System Prompt helt i begyndelsen af cache-præfikset**.
+
+## Hvorfor har Tools større cache-vægt end System?
+
+Ved KV-Cache-præfiksmatchning er **tidligt indhold mere kritisk** — enhver ændring ugyldiggør alt efterfølgende indhold:
+
+1. **Præfiksmatchning starter fra begyndelsen**: KV-Cache sammenligner den aktuelle anmodning med det cachede præfiks token for token fra starten. I det øjeblik en uoverensstemmelse opdages, ugyldiggøres alt efterfølgende indhold.
+
+2. **Tools ændres = hele cache ugyldiggøres**: Da Tools kommer først, vil enhver ændring i værktøjsdefinitioner (selv tilføjelse eller fjernelse af et enkelt MCP-tool) **bryde præfikset helt fra starten** og ugyldiggøre al cachet System Prompt og Messages.
+
+3. **System ændres = Messages-cache ugyldiggøres**: System Prompt befinder sig i midten, så dens ændringer ugyldiggør kun den efterfølgende Messages-del.
+
+4. **Messages ændres = kun halen påvirkes**: Messages er i slutningen, så tilføjelse af nye beskeder ugyldiggør kun et lille afsluttende segment — Tools- og System-cache forbliver intakt.
+
+## Praktisk betydning
+
+| Ændringstype | Cache-påvirkning | Typisk scenarie |
+|--------------|-----------------|-----------------|
+| Tool tilføjet/fjernet | **Fuld ugyldiggørelse** | MCP server tilslut/frakobl, IDE-plugin til/fra |
+| System Prompt ændring | Messages-cache tabt | CLAUDE.md redigering, system reminder-injektion |
+| Ny besked tilføjet | Kun hale-tilvækst | Normal samtalegång (mest almindelig, billigst) |
+
+Det er derfor `tools_change` i [CacheRebuild](CacheRebuild.md) typisk er den dyreste genopbygningsårsag — det bryder præfikskæden helt forrest.
+
+## Hvorfor placeres værktøjsdefinitioner før "hjernen"?
+
+Fra et caching-perspektiv er det en teknisk kendsgerning, at Tools kommer først. Men fra et kognitivt designperspektiv er denne rækkefølge lige så logisk — **Tools er hænder og fødder, System Prompt er hjernen**.
+
+Før man handler, skal man opfatte, hvilke lemmer og værktøjer man har til rådighed. Et spædbarn forstår ikke først verdens regler (System) og lærer derefter at gribe — det opfatter først, at det har hænder og fødder, og forstår gradvist reglerne gennem interaktion med omgivelserne. På samme måde skal en LLM vide, hvilke værktøjer den kan kalde (læse filer, skrive kode, søge, udføre kommandoer) før den modtager opgaveinstruktioner (System Prompt), så den præcist kan vurdere "hvad kan jeg gøre" og "hvordan skal jeg gøre det" ved behandling af instruktionerne.
+
+Hvis det var omvendt — først fortælle modellen "din opgave er at refaktorere dette modul", derefter "du har Read, Edit, Bash-værktøjer" — ville modellen mangle kritisk information om sine kapabilitetsgræenser ved forståelse af opgaven, hvilket potentielt kunne føre til urealistiske planer eller overseelse af tilgængelige tilgange.
+
+**Kend dine kort før du beslutter, hvordan du spiller.** Dette er den kognitive logik bag at Tools placeres før System.
+
+## Hvorfor er MCP-værktøjer også på denne position?
+
+MCP-værktøjer (Model Context Protocol) placeres ligesom indbyggede værktøjer helt i starten af Tools-området. At forstå MCPs position i konteksten hjælper med at vurdere de reelle fordele og omkostninger.
+
+### MCP-fordele
+
+- **Kapabilitetsudvidelse**: MCP lader modeller tilgå eksterne tjenester (databaseforespørgsler, API-kald, IDE-operationer, browserstyring osv.), og overgår grænserne for indbyggede værktøjer
+- **Åbent økosystem**: Enhver kan implementere en MCP-server; modellen opnår nye kapabiliteter uden gentræning
+- **On-demand-indlæsning**: MCP-servere kan selektivt tilsluttes/frakobles efter opgavescenario, med fleksibel sammensætning af værktøjssæt
+
+### MCP-omkostninger
+
+- **Cache-dræber**: Hvert MCP-værktøjs JSON Schema-definition sammenkædes i starten af KV-Cache-præfikset. Tilføjelse eller fjernelse af ét MCP-værktøj = **hele cachen invalideret fra starten**. Hyppig tilslutning/frakobling af MCP-servere reducerer cache-hitraten drastisk
+- **Præfiks-oppustning**: MCP-værktøjers Schemas er typisk større end indbyggede værktøjer (detaljerede parameterbeskrivelser, enum-værdier osv.). Mange MCP-værktøjer øger token-antallet i Tools-området markant og indskrænker kontekstrummet til Messages
+- **Latens-overhead**: MCP-værktøjskald kræver inter-proces-kommunikation (JSON-RPC over stdio/SSE), en størrelsesorden langsommere end indbyggede funktionskald
+- **Stabilitetsrisiko**: MCP-servere er eksterne processer, der kan crashe, timeout'e eller returnere uventede formater, og kræver ekstra fejlhåndtering
+
+### Praktiske anbefalinger
+
+| Scenarie | Anbefaling |
+|----------|-----------|
+| Lange samtaler, hyppig interaktion | Minimér antallet af MCP-værktøjer for at beskytte cache-præfiks-stabiliteten |
+| Korte opgaver, engangsoperationer | Brug MCP-værktøjer frit; cache-påvirkningen er begrænset |
+| Hyppig tilføjelse/fjernelse af MCP-servere | Hver ændring udløser fuld cache-genopbygning; overvej at fastlåse værktøjssættet |
+| Overdimensionerede Tool Schemas | Beskær beskrivelser og enums for at reducere præfiks-tokenforbrug |
+
+I cc-viewers Context-panel vises MCP-værktøjer sammen med indbyggede værktøjer i Tools-området, hvilket giver et klart overblik over hvert værktøjs Schema-størrelse og bidrag til cache-præfikset.

package/concepts/da/TranslateContextPollution.md

@@ -0,0 +1,46 @@
+# Kontekstforurening i Translate API
+
+## Baggrund
+
+CC-Viewer inkluderer en indbygget oversættelsesfunktion (`POST /api/translate`) drevet af Anthropic Messages API. I den tidlige implementering genbrugte oversættelsesanmodninger cachede autentificeringsoplysninger fra Claude Code-sessionen — herunder både `x-api-key` og `authorization` headers. Dette forårsagede et subtilt men alvorligt problem: oversættelsesresultater returnerede ofte irrelevant indhold.
+
+## Grundårsag
+
+### Fundamental forskel mellem to autentificeringsmetoder
+
+Anthropic API understøtter to autentificeringsmetoder:
+
+| Metode | Header | Typisk kilde | Karakteristika |
+|--------|--------|--------------|----------------|
+| API-nøgle | `x-api-key: sk-ant-...` | Miljøvariabel / Console | Tilstandsløs, hver anmodning er uafhængig |
+| OAuth-token | `authorization: Bearer sessionToken` | Claude Code abonnementslogin | Sessionsbundet, serveren opretholder konteksttilknytning |
+
+Den afgørende forskel: **API-nøgler er tilstandsløse** — hver anmodning er fuldstændig uafhængig; mens **OAuth-sessionstokens er tilstandsbaserede** — Anthropic-serveren tilknytter anmodninger med samme token til den samme sessionskontekst.
+
+### Forureningskæde
+
+Når Claude Code bruger OAuth-abonnementslogin, ser autentificeringsflowet sådan ud:
+
+```
+Claude Code hovedsamtale ──(authorization: Bearer sessionToken)──→ Anthropic API
+                                                                      ↑
+CC-Viewer oversættelsesanmodning ──(authorization: Bearer sessionToken)──→ Anthropic API
+```
+
+Da oversættelsesanmodninger genbrugte det samme sessionstoken, kan Anthropic-serveren tilknytte oversættelsesanmodninger til Claude Codes hovedsamtalekontekst. Dette medfører:
+
+1. **Oversættelsesresultater påvirket af hovedsamtalens kontekst**: Oversættelsesanmodningens systemprompt er "du er en oversætter", men serverkonteksten indeholder stadig Claude Codes samtalehistorik, som potentielt kan forstyrre modellen
+2. **Hovedsamtalen forstyrret af oversættelsesanmodninger**: Indhold fra oversættelsesanmodninger (UI-tekstfragmenter) kan blive injiceret i hovedsamtalens kontekst, hvilket får Claude Codes svar til at afvige
+3. **Uforudsigelig adfærd**: Da kontekstforurening er serverside-adfærd, kan klienten ikke opdage eller kontrollere det
+
+## Erfaringer
+
+- **OAuth-sessionstokens er ikke "bare en anden API-nøgle"** — de bærer serverside-tilstand, og genbrug af dem betyder deling af kontekst
+- **Interne servicekald bør bruge uafhængig, tilstandsløs autentificering** for at undgå tilknytning til brugersessioner
+
+## Referencer
+
+- [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/)

package/concepts/da/UltraPlan.md

@@ -0,0 +1,55 @@
+# UltraPlan — Den Ultimative Onskemaskine
+
+## Hvad er UltraPlan
+
+UltraPlan er cc-viewers **lokaliserede implementering** af Claude Codes native `/ultraplan`-kommando. Det giver dig mulighed for at bruge de fulde funktioner i `/ultraplan` i dit lokale miljo **uden at skulle starte Claudes officielle fjerntjeneste**, og guider Claude Code til at udfoere komplekse planlaegnings- og implementeringsopgaver ved hjaelp af **multi-agent-samarbejde**.
+
+Sammenlignet med den almindelige Plan-tilstand eller Agent Team kan UltraPlan:
+- Automatisk vurdere opgavekompleksitet og vaelge den optimale planlaegningsstrategi
+- Indsaette flere parallelle agenter til at udforske kodebasen fra forskellige dimensioner
+- Inkorporere ekstern research (webSearch) for branchens bedste praksisser
+- Automatisk sammensaette et Code Review Team efter planens udfoerelse til kodegennemgang
+- Danne en komplet **Plan → Execute → Review → Fix** lukket kredsloeb
+
+---
+
+## Vigtige Bemerkninger
+
+### 1. UltraPlan Er Ikke Almaegtigt
+UltraPlan er en mere kraftfuld onskemaskine, men det betyder ikke, at ethvert oenske kan opfyldes. Den er mere kraftfuld end Plan og Agent Team, men kan ikke direkte "tjene penge til dig". Overvej en rimelig opgavegranularitet — opdel store maal i udfoebare mellemstore opgaver i stedet for at proeve at opnaa alt paa en gang.
+
+### 2. Aktuelt Mest Effektiv til Programmeringsprojekter
+UltraPlans skabeloner og workflows er dybt optimeret til programmeringsprojekter. Andre scenarier (dokumentation, dataanalyse osv.) kan forsoges, men det kan vaere vaerd at vente paa tilpasninger i fremtidige versioner.
+
+### 3. Koerselstid og Krav til Kontekstvindue
+- En vellykket UltraPlan-koerelse tager typisk **30 minutter eller mere**
+- Kraever at MainAgent har et stort kontekstvindue (1M context Opus-modellen anbefales)
+- Hvis du kun har en 200K-model, **soerg for at `/clear` konteksten foer koerelse**
+- Claude Codes `/compact` fungerer daarligt, naar kontekstvinduet er utilstraekkeligt — undgaa at loebe toer for plads
+- At opretholde tilstraekkelig kontekstplads er en afgoerende forudsaetning for vellykket UltraPlan-udfoerelse
+
+Hvis du har spoergsmaal eller forslag til den lokaliserede UltraPlan, er du velkommen til at aabne [Issues paa GitHub](https://github.com/anthropics/claude-code/issues) for at diskutere og samarbejde.
+
+---
+
+## Saadan Fungerer Det
+
+UltraPlan tilbyder to driftstilstande:
+
+### Automatisk Tilstand
+Analyserer automatisk opgavekompleksiteten (score 4-12) og dirigerer til forskellige strategier:
+
+| Rute | Score | Strategi |
+|------|-------|----------|
+| Rute A | 4-6 | Let planlaegning med direkte kodeudforskning |
+| Rute B | 7-9 | Planlaegning med strukturdiagrammer (Mermaid / ASCII) |
+| Rute C | 10-12 | Multi-agent-udforskning + gennemgangs-kredsloeb |
+
+### Tvungen Tilstand
+Aktiverer direkte det fulde Rute C multi-agent-workflow:
+1. Indsaet op til 5 parallelle agenter til at udforske kodebasen samtidigt (arkitektur, filidentifikation, risikovurdering osv.)
+2. Valgfrit indsaette en research-agent til at undersoege brancheloesninger via webSearch
+3. Syntetisere alle agenternes fund til en detaljeret implementeringsplan
+4. Indsaette en gennemgangsagent til at granske planen fra flere perspektiver
+5. Udfoere planen efter godkendelse
+6. Automatisk sammensaette et Code Review Team for at validere kodekvaliteten efter implementering