cc-viewer 1.6.182 → 1.6.183

package/concepts/no/Tool-Read.md

@@ -1,56 +1,41 @@
 # Read
 
-## Definisjon
+Laster innholdet i én enkelt fil fra det lokale filsystemet. Støtter ren tekst, kildekode, bilder, PDF-er og Jupyter-notebooks, og returnerer resultater med 1-baserte linjenumre i `cat -n`-stil.
 
-Leser filinnhold fra det lokale filsystemet. Støtter tekstfiler, bilder, PDF og Jupyter notebook.
+## Når skal den brukes
+
+- Lese en kildefil på en kjent sti før redigering eller analyse
+- Inspisere konfigurasjonsfiler, lockfiler, logger eller genererte artefakter
+- Se på skjermbilder eller diagrammer brukeren har limt inn i samtalen
+- Hente ut et spesifikt sideområde fra en lang PDF-manual
+- Åpne en `.ipynb`-notebook for å gjennomgå kodeceller, markdown og celleutdata sammen
 
 ## Parametere
 
-| Parameter | Type | Påkrevd | Beskrivelse |
-|-----------|------|---------|-------------|
-| `file_path` | string | Ja | Absolutt sti til filen |
-| `offset` | number | Nei | Startlinjenummer (for segmentert lesing av store filer) |
-| `limit` | number | Nei | Antall linjer å lese (for segmentert lesing av store filer) |
-| `pages` | string | Nei | PDF-sideområde (f.eks. "1-5", "3", "10-20"), gjelder kun for PDF |
-
-## Bruksscenarioer
-
-**Egnet for bruk:**
-- Lese kodefiler, konfigurasjonsfiler og andre tekstfiler
-- Vise bildefiler (Claude er en multimodal modell)
-- Lese PDF-dokumenter
-- Lese Jupyter notebook (returnerer alle celler med utdata)
-- Lese flere filer parallelt for å få kontekst
-
-**Ikke egnet for bruk:**
-- Lese kataloger — bruk `ls`-kommandoen i Bash
-- Åpen kodebaseutforskning — bruk Task (Explore-type)
-
-## Merknader
-
-- Stien må være absolutt, ikke relativ
-- Leser som standard de første 2000 linjene i filen
-- Linjer over 2000 tegn blir avkortet
-- Utdata bruker `cat -n`-format, linjenumre starter fra 1
-- Store PDF-er (over 10 sider) må spesifisere `pages`-parameteren, maks 20 sider per gang
-- Lesing av en ikke-eksisterende fil returnerer feil (krasjer ikke)
-- Kan kalle flere Read parallelt i en enkelt melding
-
-## Originaltekst
-
-<textarea readonly>Reads a file from the local filesystem. You can access any file directly by using this tool.
-Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
-
-Usage:
-- The file_path parameter must be an absolute path, not a relative path
-- By default, it reads up to 2000 lines starting from the beginning of the file
-- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
-- Any lines longer than 2000 characters will be truncated
-- Results are returned using cat -n format, with line numbers starting at 1
-- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.
-- This tool can read PDF files (.pdf). For large PDFs (more than 10 pages), you MUST provide the pages parameter to read specific page ranges (e.g., pages: "1-5"). Reading a large PDF without the pages parameter will fail. Maximum 20 pages per request.
-- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
-- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
-- You can call multiple tools in a single response. It is always better to speculatively read multiple potentially useful files in parallel.
-- You will regularly be asked to read screenshots. If the user provides a path to a screenshot, ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths.
-- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.</textarea>
+- `file_path` (string, påkrevd): Absolutt sti til målfilen. Relative stier avvises.
+- `offset` (integer, valgfri): 1-basert linjenummer å starte lesingen fra. Nyttig for store filer når den kombineres med `limit`.
+- `limit` (integer, valgfri): Maksimalt antall linjer å returnere fra og med `offset`. Standard er 2000 linjer fra toppen av filen når den utelates.
+- `pages` (string, valgfri): Sideområde for PDF-filer, for eksempel `"1-5"`, `"3"` eller `"10-20"`. Påkrevd for PDF-er lengre enn 10 sider; maksimalt 20 sider per forespørsel.
+
+## Eksempler
+
+### Eksempel 1: Les en hel liten fil
+Kall `Read` med kun `file_path` satt til `/Users/me/project/src/index.ts`. Opptil 2000 linjer returneres med linjenumre, som vanligvis er tilstrekkelig for redigeringskontekst.
+
+### Eksempel 2: Bla gjennom en lang logg
+Bruk `offset: 5001` og `limit: 500` på en logg på flere tusen linjer for å hente ut et smalt vindu uten å sløse med kontekstokens.
+
+### Eksempel 3: Hent ut spesifikke PDF-sider
+For en 120-siders PDF på `/tmp/spec.pdf`, sett `pages: "8-15"` for å trekke ut kun kapittelet du trenger. Å utelate `pages` på en stor PDF gir en feil.
+
+### Eksempel 4: Vis et bilde
+Send den absolutte stien til et PNG- eller JPG-skjermbilde. Bildet rendres visuelt slik at Claude Code kan resonnere over det direkte.
+
+## Notater
+
+- Foretrekk alltid absolutte stier. Hvis brukeren oppgir en, stol på den som den er.
+- Linjer lengre enn 2000 tegn trunkeres; behandle det returnerte innholdet som potensielt avklippet for ekstremt brede data.
+- Leser du flere uavhengige filer? Send flere `Read`-kall i samme svar slik at de kjører parallelt.
+- `Read` kan ikke liste kataloger. Bruk et `Bash` `ls`-kall eller `Glob`-verktøyet i stedet.
+- Å lese en eksisterende, men tom fil returnerer en systempåminnelse i stedet for filbytes, så håndter det signalet eksplisitt.
+- En vellykket `Read` er påkrevd før du kan bruke `Edit` på samme fil i gjeldende sesjon.

package/concepts/no/Tool-RemoteTrigger.md

@@ -0,0 +1,73 @@
+# RemoteTrigger
+
+Kaller claude.ai's fjernutløser-API for å administrere planlagte oppgaver og on-demand utløsereksekveringer. OAuth-tokenet håndteres internt av verktøyet og eksponeres aldri for modellen eller skallet.
+
+## Når skal den brukes
+
+- Administrasjon av fjernagenter (utløsere) på claude.ai, inkludert oppføring, inspeksjon og oppdatering av eksisterende utløsere
+- Oppretting av en ny cron-basert automatisert oppgave som kjører en Claude-agent etter en tilbakevendende plan
+- Kjøring av en eksisterende utløser on-demand uten å vente på neste planlagte kjøring
+- Visning eller revisjon av alle gjeldende utløsere for å gjennomgå konfigurasjon og status
+- Oppdatering av utløserinnstillinger som plan, nyttelast eller beskrivelse uten å måtte gjenskape utløseren
+
+## Parametere
+
+- `action` (string, påkrevd): operasjonen som skal utføres — en av `list`, `get`, `create`, `update` eller `run`
+- `trigger_id` (string, påkrevd for `get`, `update` og `run`): identifikatoren til utløseren det skal opereres på; må samsvare med mønsteret `^[\w-]+$` (bare ordtegn og bindestreker)
+- `body` (object, påkrevd for `create` og `update`; valgfri for `run`): forespørselsnyttelast sendt til API-en
+
+## Eksempler
+
+### Eksempel 1: vis alle utløsere
+
+```json
+{
+  "action": "list"
+}
+```
+
+Kaller `GET /v1/code/triggers` og returnerer en JSON-matrise med alle utløsere knyttet til den autentiserte kontoen.
+
+### Eksempel 2: opprett en ny utløser som kjører hver hverdagsmorgen
+
+```json
+{
+  "action": "create",
+  "body": {
+    "name": "weekday-morning-report",
+    "schedule": "0 8 * * 1-5",
+    "description": "Generer et daglig sammendrag hver hverdag kl. 08:00 UTC"
+  }
+}
+```
+
+Kaller `POST /v1/code/triggers` med den angitte kroppen og returnerer det nyopprettede utløserobjektet, inkludert den tildelte `trigger_id`.
+
+### Eksempel 3: kjør en utløser on-demand
+
+```json
+{
+  "action": "run",
+  "trigger_id": "my-report-trigger"
+}
+```
+
+Kaller umiddelbart `POST /v1/code/triggers/my-report-trigger/run` og omgår det planlagte tidspunktet.
+
+### Eksempel 4: hent en enkelt utløser
+
+```json
+{
+  "action": "get",
+  "trigger_id": "my-report-trigger"
+}
+```
+
+Kaller `GET /v1/code/triggers/my-report-trigger` og returnerer den fullstendige utløserkonfigurasjonen.
+
+## Notater
+
+- OAuth-tokenet injiseres in-process av verktøyet — kopier, lim inn eller logg aldri tokens manuelt; dette skaper en sikkerhetsrisiko og er unødvendig når dette verktøyet brukes.
+- Foretrekk dette verktøyet fremfor rå `curl` eller andre HTTP-klienter for alle utløser-API-kall; direkte bruk av HTTP omgår sikker tokeninjeksjon og kan eksponere legitimasjon.
+- Verktøyet returnerer det rå JSON-svaret fra API-en; kalleren er ansvarlig for å analysere svaret og håndtere feilstatuskoder.
+- Verdien av `trigger_id` må samsvare med mønsteret `^[\w-]+$` — bare alfanumeriske tegn, understreker og bindestreker er tillatt; mellomrom eller spesialtegn vil få forespørselen til å mislykkes.

package/concepts/no/Tool-ScheduleWakeup.md

@@ -0,0 +1,56 @@
+# ScheduleWakeup
+
+Planlegger når arbeidet skal gjenopptas i `/loop` dynamisk modus. Verktøyet lar Claude selvstyre tempoet i oppgaveiterationer ved å sove i det valgte intervallet, deretter utløse igjen med den samme løkke-prompten.
+
+## Når skal den brukes
+
+- For å selvstyre tempoet i en `/loop` dynamisk oppgave der iterasjonsintervallet avhenger av arbeidstilstand snarere enn en fast klokke
+- For å vente på at en lang bygging, distribusjon eller testkjøring er ferdig før resultater sjekkes
+- For å sette inn tomgangs-ticks mellom iterasjoner når det ikke er et spesifikt signal å overvåke akkurat nå
+- For å kjøre en autonom løkke uten brukerprompt — send den bokstavelige sentinel `<<autonomous-loop-dynamic>>` som `prompt`
+- For å polle en prosess hvis tilstand er i ferd med å endre seg snart (bruk kort forsinkelse for å holde cachen varm)
+
+## Parametere
+
+- `delaySeconds` (tall, påkrevd): Sekunder til gjenopptagelse. Kjøretiden begrenser automatisk verdien til `[60, 3600]`, så manuell begrensning er ikke nødvendig.
+- `reason` (streng, påkrevd): En kort setning som forklarer den valgte forsinkelsen. Vises til brukeren og registreres i telemetri. Vær spesifikk — "sjekker lang bun-bygging" er mer nyttig enn "venter."
+- `prompt` (streng, påkrevd): `/loop`-input som utløses ved oppvåkning. Send den samme strengen hver tur slik at neste utløsning gjentar oppgaven. For en autonom løkke uten brukerprompt sendes den bokstavelige sentinel `<<autonomous-loop-dynamic>>`.
+
+## Eksempler
+
+### Eksempel 1: kort forsinkelse for å sjekke et raskt skiftende signal på nytt (hold cachen varm)
+
+En bygging ble nettopp startet og tar vanligvis to til tre minutter.
+
+```json
+{
+  "delaySeconds": 120,
+  "reason": "sjekker bun-bygging forventet ferdig om ~2 min",
+  "prompt": "sjekk byggstatus og rapporter eventuelle feil"
+}
+```
+
+120 sekunder holder samtalekonteksten i Anthropic prompt-cachen (TTL 5 min), så neste oppvåkning er raskere og billigere.
+
+### Eksempel 2: lang tomgangs-tick (aksepter cache-miss, amortiser over lengre ventetid)
+
+En databasemigrering kjører og tar vanligvis 20–40 minutter.
+
+```json
+{
+  "delaySeconds": 1200,
+  "reason": "migrering tar vanligvis 20–40 min; sjekker igjen om 20 min",
+  "prompt": "sjekk migrasjonsstatus og fortsett hvis ferdig"
+}
+```
+
+Cachen vil være kald ved oppvåkning, men 20-minutters ventetiden amortiserer mer enn tilstrekkelig den enkle cache-missen. Å polle hvert 5. minutt ville betale den samme miss-prisen 4 ganger uten fordel.
+
+## Notater
+
+- **5-minutters cache-TTL**: Anthropic prompt-cachen utløper etter 300 sekunder. Forsinkelser under 300 s holder konteksten varm; forsinkelser over 300 s medfører en cache-miss ved neste oppvåkning.
+- **Unngå nøyaktig 300 s**: Det er det verste fra begge verdener — man betaler cache-missen uten å få en meningsfull lengre ventetid. Enten drop til 270 s (hold cachen varm) eller forplikter til 1200 s eller mer (én miss kjøper en mye lengre ventetid).
+- **Standard for tomgangs-ticks**: Når det ikke er et spesifikt signal å overvåke, bruk **1200–1800 s** (20–30 min). Dette lar løkken sjekke periodisk uten å brenne cachen 12 ganger i timen for ingenting.
+- **Automatisk begrensning**: Kjøretiden begrenser `delaySeconds` til `[60, 3600]`. Verdier under 60 blir til 60; verdier over 3600 blir til 3600. Det er ikke nødvendig å håndtere disse grensene selv.
+- **Utelat kallet for å avslutte løkken**: Hvis iterasjoner skal stoppes, skal ikke ScheduleWakeup kalles. Å bare utelate kallet avslutter løkken.
+- **Send den samme `prompt` hver tur**: `prompt`-feltet må bære den originale `/loop`-instruksjonen ved hver invokasjon slik at neste oppvåkning vet hvilken oppgave som skal gjenopptas.

package/concepts/no/Tool-SendMessage.md

@@ -1,41 +1,68 @@
 # SendMessage
 
-## Definisjon
+Leverer en melding fra ett teammedlem til et annet i et aktivt team, eller kringkaster til hver lagkamerat samtidig. Dette er den eneste kanalen lagkamerater kan høre — alt som skrives til normal tekstutdata er usynlig for dem.
 
-Sender meldinger mellom agenter i et team. Brukes til direkte kommunikasjon, kringkasting og protokollmeldinger (shutdown-forespørsler/-svar, plangodkjenning).
+## Når skal den brukes
+
+- Tildele en oppgave eller overlevere et delproblem til en navngitt lagkamerat under teamsamarbeid.
+- Be om status, mellomliggende funn eller en kodegjennomgang fra en annen agent.
+- Kringkaste en beslutning, delt begrensning eller nedstengningsmelding til hele teamet via `*`.
+- Svare på en protokollforespørsel som en shutdown-forespørsel eller en plangodkjenningsforespørsel fra teamlederen.
+- Lukke sløyfen på slutten av en delegert oppgave slik at lederen kan markere punktet som fullført.
 
 ## Parametere
 
-| Parameter | Type | Påkrevd | Beskrivelse |
-|-----------|------|---------|-------------|
-| `to` | string | Ja | Mottaker: teammedlemmets navn, eller `"*"` for kringkasting til alle |
-| `message` | string / object | Ja | Ren tekstmelding eller strukturert protokollobjekt |
-| `summary` | string | Nei | En forhåndsvisning på 5-10 ord vist i brukergrensesnittet |
+- `to` (string, påkrevd): Målleagkameratens `name` som registrert i teamet, eller `*` for å kringkaste til alle lagkamerater samtidig.
+- `message` (string eller objekt, påkrevd): Ren tekst for normal kommunikasjon, eller et strukturert objekt for protokollsvar som `shutdown_response` og `plan_approval_response`.
+- `summary` (string, valgfri): En 5–10-ords forhåndsvisning vist i teamaktivitetsloggen for tekstmeldinger. Påkrevd for lange strengmeldinger; ignoreres når `message` er et protokollobjekt.
+
+## Eksempler
+
+### Eksempel 1: Direkte oppgaveoverlevering
+
+```
+SendMessage(
+  to="db-lead",
+  message="Please audit prisma/schema.prisma and list any model missing createdAt/updatedAt timestamps. Reply when done.",
+  summary="Audit schema for missing timestamps"
+)
+```
 
-## Meldingstyper
+### Eksempel 2: Kringkast en felles begrensning
 
-### Ren tekst
-Direktemeldinger mellom teammedlemmer for koordinering, statusoppdateringer og oppgavediskusjoner.
+```
+SendMessage(
+  to="*",
+  message="Reminder: do not touch files under legacy/ — that subtree is frozen until the migration PR lands.",
+  summary="Freeze legacy/ during migration"
+)
+```
 
-### Shutdown-forespørsel
-Ber et teammedlem om å avslutte på en ryddig måte: `{ type: "shutdown_request", reason: "..." }`
+### Eksempel 3: Protokollsvar
 
-### Shutdown-svar
-Teammedlem godkjenner eller avslår shutdown: `{ type: "shutdown_response", approve: true/false }`
+Svar på en shutdown-forespørsel fra lederen med en strukturert melding:
 
-### Plangodkjenningssvar
-Godkjenner eller avslår et teammedlems plan: `{ type: "plan_approval_response", approve: true/false }`
+```
+SendMessage(
+  to="leader",
+  message={ "type": "shutdown_response", "ready": true, "final_report": "All assigned diff chunks committed on branch refactor-crew/db-lead." }
+)
+```
 
-## Kringkasting vs. direkte
+### Eksempel 4: Plangodkjenningssvar
 
-- **Direkte** (`to: "teammedlem-navn"`): Send til et bestemt teammedlem — foretrukket for de fleste kommunikasjoner
-- **Kringkasting** (`to: "*"`): Send til alle teammedlemmer — bruk sparsomt, kun for kritiske teamomfattende kunngjøringer
+```
+SendMessage(
+  to="leader",
+  message={ "type": "plan_approval_response", "approved": true, "notes": "LGTM, but please split step 4 into migration + backfill." }
+)
+```
 
-## Relaterte verktøy
+## Notater
 
-| Verktøy | Formål |
-|---------|--------|
-| `TeamCreate` | Opprett et nytt team |
-| `TeamDelete` | Fjern team når ferdig |
-| `Agent` | Start teammedlemmer som slutter seg til teamet |
-| `TaskCreate` / `TaskUpdate` / `TaskList` | Administrer den delte oppgavelisten |
+- Din vanlige assistenttekst-utdata overføres IKKE til lagkamerater. Hvis du vil at en annen agent skal se noe, må det gå gjennom `SendMessage`. Dette er den vanligste feilen i team-arbeidsflyter.
+- Kringkasting (`to: "*"`) er kostbart — det vekker hver lagkamerat og bruker deres kontekst. Reserver det for kunngjøringer som faktisk påvirker alle. Foretrekk målrettede sendinger.
+- Hold meldinger konsise og handlingsrettede. Inkluder filbanene, begrensningene og forventet svarformat mottakeren trenger; husk at de ikke har noe delt minne med deg.
+- Protokollmeldingsobjekter (`shutdown_response`, `plan_approval_response`) har faste former. Ikke bland protokollfelter inn i tekstmeldinger eller omvendt.
+- Meldinger er asynkrone. Mottakeren får din på sin neste tur; ikke anta at de har lest eller handlet på den før de svarer.
+- En godt skrevet `summary` gjør teamaktivitetsloggen lettlest for lederen — behandle den som en commit-overskriftslinje.

package/concepts/no/Tool-Skill.md

@@ -1,56 +1,47 @@
 # Skill
 
-## Definisjon
+Påkaller en navngitt skill i gjeldende samtale. Skills er forhåndspakkede kapabilitetspakker — domenekunnskap, arbeidsflyter og noen ganger verktøytilgang — som rammeverket eksponerer til assistenten gjennom systempåminnelser.
 
-Kjører en ferdighet (skill) i hovedsamtalen. Ferdigheter er spesialiserte evner som brukeren kan kalle via slash-kommandoer (f.eks. `/commit`, `/review-pr`).
+## Når skal den brukes
 
-## Parametere
-
-| Parameter | Type | Påkrevd | Beskrivelse |
-|-----------|------|---------|-------------|
-| `skill` | string | Ja | Ferdighetsnavn (f.eks. "commit", "review-pr", "pdf") |
-| `args` | string | Nei | Ferdighetsparametere |
+- Brukeren skriver en slash-kommando som `/review` eller `/init` — slash-kommandoer er skills og må kjøres gjennom dette verktøyet.
+- Brukeren beskriver en oppgave som matcher en annonsert skills utløserbetingelser (for eksempel å be om å skanne transkripsjoner for gjentatte tillatelsesspørsmål matcher `fewer-permission-prompts`).
+- En skills uttalte formål er et direkte treff for gjeldende fil, forespørsel eller samtalekontekst.
+- Spesialiserte, gjentakbare arbeidsflyter er tilgjengelige som skills og den kanoniske prosedyren er å foretrekke fremfor en ad hoc-tilnærming.
+- Brukeren spør "hvilke skills er tilgjengelige" — list de annonserte navnene, og påkall kun når de bekrefter.
 
-## Bruksscenarioer
+## Parametere
 
-**Egnet for bruk:**
-- Brukeren har skrevet en slash-kommando i formatet `/<skill-name>`
-- Brukerens forespørsel matcher funksjonaliteten til en registrert ferdighet
+- `skill` (string, påkrevd): Det eksakte navnet på en skill som er listet i gjeldende available-skills-systempåminnelse. For plugin-navneromsformede skills, bruk den fullt kvalifiserte `plugin:skill`-formen (for eksempel `skill-creator:skill-creator`). Ikke inkluder ledende skråstrek.
+- `args` (string, valgfri): Fritekstargumenter som sendes til skillen. Format og semantikk er definert av hver skills egen dokumentasjon.
 
-**Ikke egnet for bruk:**
-- Innebygde CLI-kommandoer (f.eks. `/help`, `/clear`)
-- En ferdighet som allerede kjører
-- Et ferdighetsnavn som ikke finnes i listen over tilgjengelige ferdigheter
+## Eksempler
 
-## Merknader
+### Eksempel 1: Kjør en review-skill på gjeldende branch
 
-- Etter at ferdigheten er kalt, utvides den til et fullstendig prompt
-- Støtter fullt kvalifiserte navn (f.eks. `ms-office-suite:pdf`)
-- Listen over tilgjengelige ferdigheter gis i system-reminder-meldinger
-- Når du ser en `<command-name>`-tag betyr det at ferdigheten allerede er lastet, og du bør kjøre den direkte i stedet for å kalle dette verktøyet igjen
-- Ikke nevn en ferdighet uten å faktisk kalle verktøyet
+```
+Skill(skill="review")
+```
 
-## Originaltekst
+`review`-skillen pakker trinnene for å gjennomgå en pull request mot gjeldende base-branch. Å påkalle den laster den rammeverks-definerte gjennomgangsprosedyren inn i turen.
 
-<textarea readonly>Execute a skill within the main conversation
+### Eksempel 2: Påkall en plugin-navneromsformet skill med argumenter
 
-When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.
+```
+Skill(
+  skill="skill-creator:skill-creator",
+  args="create a skill that summarizes git log for a given date range"
+)
+```
 
-When users reference a "slash command" or "/<something>" (e.g., "/commit", "/review-pr"), they are referring to a skill. Use this tool to invoke it.
+Ruter forespørselen gjennom `skill-creator`-pluginens inngangspunkt slik at forfatterarbeidsflyten starter.
 
-How to invoke:
-- Use this tool with the skill name and optional arguments
-- Examples:
-  - `skill: "pdf"` - invoke the pdf skill
-  - `skill: "commit", args: "-m 'Fix bug'"` - invoke with arguments
-  - `skill: "review-pr", args: "123"` - invoke with arguments
-  - `skill: "ms-office-suite:pdf"` - invoke using fully qualified name
+## Notater
 
-Important:
-- Available skills are listed in system-reminder messages in the conversation
-- When a skill matches the user's request, this is a BLOCKING REQUIREMENT: invoke the relevant Skill tool BEFORE generating any other response about the task
-- NEVER mention a skill without actually calling this tool
-- Do not invoke a skill that is already running
-- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
-- If you see a <command-name> tag in the current conversation turn, the skill has ALREADY been loaded - follow the instructions directly instead of calling this tool again
-</textarea>
+- Påkall kun skills hvis navn vises ordrett i available-skills-systempåminnelsen, eller skills brukeren skrev direkte som `/name` i meldingen sin. Gjett aldri på eller finn opp skill-navn fra minne eller treningsdata — hvis skillen ikke er annonsert, ikke kall dette verktøyet.
+- Når en brukers forespørsel matcher en annonsert skill, er det å kalle `Skill` en blokkerende forutsetning: påkall den før du genererer noe annet svar om oppgaven. Ikke beskriv hva skillen ville gjort — kjør den.
+- Nevn aldri en skill ved navn uten faktisk å påkalle den. Å kunngjøre en skill uten å kalle verktøyet er villedende.
+- Ikke bruk `Skill` for innebygde CLI-kommandoer som `/help`, `/clear`, `/model` eller `/exit`. Disse håndteres av rammeverket direkte.
+- Ikke kall på nytt en skill som allerede kjører i gjeldende tur. Hvis du ser en `<command-name>`-tag i gjeldende tur, har skillen allerede blitt lastet — følg instruksjonene i stedet for å kalle verktøyet på nytt.
+- Hvis flere skills kan gjelde, velg den mest spesifikke. For konfigurasjonsendringer som å legge til tillatelser eller hooks, foretrekk `update-config` fremfor en generisk settings-tilnærming.
+- Skill-kjøring kan introdusere nye systempåminnelser, verktøy eller begrensninger for resten av turen. Les gjennom samtaletilstanden på nytt etter at en skill fullføres før du fortsetter.

package/concepts/no/Tool-TaskCreate.md

@@ -1,78 +1,56 @@
 # TaskCreate
 
-## Definisjon
+Oppretter en ny oppgave i gjeldende teams oppgaveliste (eller sesjonens oppgaveliste når ingen team er aktivt). Bruk det for å fange opp arbeidsposter som skal spores, delegeres eller vurderes på nytt senere.
 
-Oppretter strukturerte oppgavelisteelementer for å spore fremdrift, organisere komplekse oppgaver og vise arbeidsfremdrift til brukeren.
+## Når skal den brukes
 
-## Parametere
-
-| Parameter | Type | Påkrevd | Beskrivelse |
-|-----------|------|---------|-------------|
-| `subject` | string | Ja | Kort oppgavetittel i imperativform (f.eks. "Fix authentication bug") |
-| `description` | string | Ja | Detaljert beskrivelse med kontekst og akseptansekriterier |
-| `activeForm` | string | Nei | Tekst i presens partisipp som vises under utførelse (f.eks. "Fixing authentication bug") |
-| `metadata` | object | Nei | Vilkårlig metadata knyttet til oppgaven |
-
-## Bruksscenarioer
-
-**Egnet for bruk:**
-- Komplekse flerstegsoppgaver (mer enn 3 steg)
-- Brukeren har gitt flere gjøremål
-- Spore arbeid i planleggingsmodus
-- Brukeren ber eksplisitt om å bruke oppgaveliste
+- Brukeren beskriver et flertrinnsarbeid som tjener på eksplisitt sporing.
+- Du deler en stor forespørsel inn i mindre, separat fullførbare enheter.
+- En oppfølging oppdages midt i en oppgave og bør ikke glemmes.
+- Du trenger en varig registrering av intensjon før du leverer arbeid til en lagkamerat eller underagent.
+- Du opererer i planmodus og vil at hvert planlegg-trinn skal representeres som en konkret oppgave.
 
-**Ikke egnet for bruk:**
-- Enkelt, enkel oppgave
-- Enkle operasjoner med 3 steg eller færre
-- Ren samtale eller informasjonsforespørsel
+Hopp over `TaskCreate` for trivielle engangshandlinger, ren samtale eller noe som kan fullføres i to eller tre direkte verktøykall.
 
-## Merknader
-
-- Alle nye oppgaver starter med status `pending`
-- `subject` bruker imperativform ("Run tests"), `activeForm` bruker presens partisipp ("Running tests")
-- Etter opprettelse kan avhengigheter (blocks/blockedBy) settes via TaskUpdate
-- Før opprettelse bør TaskList kalles for å sjekke om det finnes duplikater
-
-## Originaltekst
-
-<textarea readonly>Use this tool to create a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
-It also helps the user understand the progress of the task and overall progress of their requests.
+## Parametere
 
-## When to Use This Tool
+- `subject` (string, påkrevd): Kort imperativ tittel, f.eks. `Fix login redirect on Safari`. Hold den under omtrent åtti tegn.
+- `description` (string, påkrevd): Detaljert kontekst — problemet, begrensningene, akseptkriteriene og eventuelle filer eller lenker en fremtidig leser trenger. Skriv som om en lagkamerat skal ta dette uten forkunnskap.
+- `activeForm` (string, valgfri): Spinner-tekst i presens partisipp vist mens oppgaven er `in_progress`, f.eks. `Fixing login redirect on Safari`. Speil `subject` men i -ing-form.
+- `metadata` (objekt, valgfri): Vilkårlige strukturerte data knyttet til oppgaven. Vanlige bruksområder: etiketter, prioritetshint, eksterne ticket-ID-er eller agent-spesifikk konfigurasjon.
 
-Use this tool proactively in these scenarios:
+Nyopprettede oppgaver starter alltid med status `pending` og ingen eier. Avhengigheter (`blocks`, `blockedBy`) settes ikke ved opprettelse — anvend dem etterpå med `TaskUpdate`.
 
-- Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-- Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-- Plan mode - When using plan mode, create a task list to track the work
-- User explicitly requests todo list - When the user directly asks you to use the todo list
-- User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-- After receiving new instructions - Immediately capture user requirements as tasks
-- When you start working on a task - Mark it as in_progress BEFORE beginning work
-- After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+## Eksempler
 
-## When NOT to Use This Tool
+### Eksempel 1
 
-Skip using this tool when:
-- There is only a single, straightforward task
-- The task is trivial and tracking it provides no organizational benefit
-- The task can be completed in less than 3 trivial steps
-- The task is purely conversational or informational
+Fang opp en feilrapport brukeren nettopp leverte.
 
-NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+```
+TaskCreate(
+  subject: "Repair broken PDF export on Windows",
+  description: "Users on Windows 11 report the export button produces a 0-byte file. Reproduce with sample doc in test/fixtures/export/, then fix the code path in src/export/pdf.ts. Acceptance: export writes a valid PDF and the existing export test suite passes.",
+  activeForm: "Repairing broken PDF export on Windows"
+)
+```
 
-## Task Fields
+### Eksempel 2
 
-- **subject**: A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")
-- **description**: Detailed description of what needs to be done, including context and acceptance criteria
-- **activeForm**: Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.
+Del en epic inn i sporede enheter ved starten av en sesjon.
 
-**IMPORTANT**: Always provide activeForm when creating tasks. The subject should be imperative ("Run tests") while activeForm should be present continuous ("Running tests"). All tasks are created with status `pending`.
+```
+TaskCreate(
+  subject: "Draft migration plan for auth service",
+  description: "Produce a written plan covering rollout stages, rollback strategy, and monitoring. Output: docs/auth-migration.md.",
+  activeForm: "Drafting migration plan for auth service",
+  metadata: { "priority": "P1", "linearId": "AUTH-214" }
+)
+```
 
-## Tips
+## Notater
 
-- Create tasks with clear, specific subjects that describe the outcome
-- Include enough detail in the description for another agent to understand and complete the task
-- After creating tasks, use TaskUpdate to set up dependencies (blocks/blockedBy) if needed
-- Check TaskList first to avoid creating duplicate tasks
-</textarea>
+- Skriv `subject` i imperativ og `activeForm` i presens partisipp slik at UI-et leses naturlig når oppgaven overgår til `in_progress`.
+- Kall `TaskList` før opprettelse for å unngå duplikater — teamlisten er delt med lagkamerater og underagenter.
+- Ikke inkluder hemmeligheter eller påloggingsinformasjon i `description` eller `metadata`; oppgaveposter er synlige for alle med tilgang til teamet.
+- Etter opprettelse, flytt oppgaven gjennom livssyklusen med `TaskUpdate`. Ikke la arbeid forlates i stillhet i `in_progress`.

package/concepts/no/Tool-TaskGet.md

@@ -1,56 +1,47 @@
 # TaskGet
 
-## Definisjon
+Henter hele posten for en enkelt oppgave med ID, inkludert beskrivelse, gjeldende status, eier, metadata og avhengighetskanter. Bruk det når sammendraget returnert av `TaskList` ikke er nok til å handle på oppgaven.
 
-Henter fullstendige detaljer for en oppgave via oppgave-ID.
+## Når skal den brukes
 
-## Parametere
-
-| Parameter | Type | Påkrevd | Beskrivelse |
-|-----------|------|---------|-------------|
-| `taskId` | string | Ja | ID-en til oppgaven som skal hentes |
+- Du plukket opp en oppgave fra `TaskList` og trenger den fulle beskrivelsen før du begynner arbeidet.
+- Du er i ferd med å markere en oppgave `completed` og vil dobbeltsjekke akseptkriteriene.
+- Du må inspisere hvilke oppgaver denne `blocks` eller er `blockedBy` for å avgjøre neste trekk.
+- Du undersøker historikk — hvem eier den, hvilken metadata ble knyttet, når endret den tilstand.
+- En lagkamerat eller tidligere sesjon refererte til en oppgave-ID og du trenger konteksten.
 
-## Returnert innhold
+Foretrekk `TaskList` når du bare trenger en oversikt på høyt nivå; reserver `TaskGet` for den spesifikke posten du har tenkt å lese nøye eller endre.
 
-- `subject` — Oppgavetittel
-- `description` — Detaljerte krav og kontekst
-- `status` — Status: `pending`, `in_progress` eller `completed`
-- `blocks` — Liste over oppgaver blokkert av denne oppgaven
-- `blockedBy` — Liste over forutgående oppgaver som blokkerer denne oppgaven
-
-## Bruksscenarioer
+## Parametere
 
-**Egnet for bruk:**
-- Hente fullstendig beskrivelse og kontekst før arbeidet starter
-- Forstå oppgavens avhengighetsforhold
-- Hente fullstendige krav etter å ha blitt tildelt en oppgave
+- `taskId` (string, påkrevd): Oppgaveidentifikatoren returnert av `TaskCreate` eller `TaskList`. ID-er er stabile gjennom oppgavens levetid.
 
-## Merknader
+## Eksempler
 
-- Etter å ha hentet oppgaven bør du sjekke at `blockedBy`-listen er tom før du starter arbeidet
-- Bruk TaskList for å se sammendragsinformasjon for alle oppgaver
+### Eksempel 1
 
-## Originaltekst
+Slå opp en oppgave du nettopp så i listen.
 
-<textarea readonly>Use this tool to retrieve a task by its ID from the task list.
+```
+TaskGet(taskId: "t_01HXYZ...")
+```
 
-## When to Use This Tool
+Typiske svarfelter: `id`, `subject`, `description`, `activeForm`, `status`, `owner`, `blocks`, `blockedBy`, `metadata`, `createdAt`, `updatedAt`.
 
-- When you need the full description and context before starting work on a task
-- To understand task dependencies (what it blocks, what blocks it)
-- After being assigned a task, to get complete requirements
+### Eksempel 2
 
-## Output
+Løs avhengigheter før du starter.
 
-Returns full task details:
-- **subject**: Task title
-- **description**: Detailed requirements and context
-- **status**: 'pending', 'in_progress', or 'completed'
-- **blocks**: Tasks waiting on this one to complete
-- **blockedBy**: Tasks that must complete before this one can start
+```
+TaskGet(taskId: "t_01HXYZ...")
+# Inspect blockedBy — if any referenced task is still pending
+# or in_progress, work on the blocker first.
+```
 
-## Tips
+## Notater
 
-- After fetching a task, verify its blockedBy list is empty before beginning work.
-- Use TaskList to see all tasks in summary form.
-</textarea>
+- `TaskGet` er skrivebeskyttet og trygt å kalle gjentatte ganger; det endrer ikke status eller eierskap.
+- Hvis `blockedBy` er ikke-tom og inneholder oppgaver som ikke er `completed`, ikke start denne oppgaven — løs blokkerne først (eller koordiner med eieren deres).
+- `description`-feltet kan være langt. Les det fullt ut før du handler; å skumlese fører til missede akseptkriterier.
+- En ukjent eller slettet `taskId` returnerer en feil. Kjør `TaskList` på nytt for å plukke en gjeldende ID.
+- Hvis du er i ferd med å redigere en oppgave, kall `TaskGet` først for å unngå å overskrive felter en lagkamerat nettopp endret.