claudient 0.1.0

package/guides/nl/agent-orchestration.md

@@ -0,0 +1,174 @@
+# Handleiding voor agentorkestratie
+
+Hoe u werk delegeert, paralleliseert en specialiseert met het sub-agentsysteem van Claude Code.
+
+---
+
+## Wat sub-agents zijn
+
+Een sub-agent is een aparte Claude-instantie die door de oudersessie wordt gestart om een specifieke, afgebakende taak af te handelen. Het krijgt:
+- Een vers contextvenster (geen sessiegeschiedenis)
+- Een specifieke tool-subset (indien geconfigureerd)
+- Een modelselectie (kan afwijken van de ouder)
+- Een prompt die u expliciet schrijft
+
+Sub-agents zijn geen magie — het zijn specifieke tools voor specifieke problemen.
+
+---
+
+## Wanneer een sub-agent gebruiken
+
+Gebruik een sub-agent wanneer de taak **duidelijke invoer** en **duidelijke uitvoer** heeft en **onafhankelijk is van de huidige sessiestatus**.
+
+**Goede kandidaten:**
+- 10 bestanden controleren op beveiligingsproblemen
+- Een specifieke zoekopdracht uitvoeren in de codebase
+- Boilerplate genereren voor een nieuwe module op basis van een spec
+- Een logbestand analyseren en een samenvatting teruggeven
+
+**Slechte kandidaten:**
+- Taken die de volledige sessiecontext vereisen
+- Taken die heen-en-weer vereisen — sub-agents zijn eenmalig
+- Taken waarbij de opstartoverhead het werk overtreft
+
+---
+
+## 1. Delegatiepatroon
+
+De oudersessie identificeert een afgebakende taak en geeft deze door.
+
+**Sleutelregel:** De sub-agent prompt moet op zichzelf staan. Het heeft geen toegang tot wat de oudersessie heeft gedaan. Brief het als een collega die net de kamer is binnengekomen.
+
+**Wat op te nemen in de sub-agent prompt:**
+- Wat u probeert te bereiken en waarom
+- De specifieke bestanden of mappen
+- Het gewenste resultaatformaat
+- Al genomen beslissingen
+
+---
+
+## 2. Parallelisatiepatroon
+
+Meerdere sub-agents die gelijktijdig aan onafhankelijke taken werken.
+
+**Wanneer te paralleliseren:**
+- Dezelfde bewerking moet op veel bestanden/modules worden toegepast
+- Twee echt onafhankelijke taken moeten beide worden voltooid
+- Onderzoekstaken die verschillende gebieden bestrijken
+
+**Git worktrees gebruiken voor parallelle codewijzigingen:**
+```bash
+git worktree add ../feature-branch-a feature-a
+git worktree add ../feature-branch-b feature-b
+```
+
+**Parallelisatie anti-patronen:**
+- Taken paralleliseren die staat delen (schrijfconflicten)
+- Parallelle taken waarbij de ene afhangt van de uitvoer van de andere
+
+---
+
+## 3. Specialisatiepatroon (cavecrew)
+
+Pas het model en de tools van de sub-agent aan op de aard van de taak. Geïnspireerd door het **cavecrew**-patroon (bron: [JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman)) — bespaart ~60% tokens vergeleken met het gebruik van Opus voor elke sub-agent.
+
+| Rol | Model | Tools | Gebruik wanneer |
+|---|---|---|---|
+| Onderzoeker | Haiku 4.5 | Read, Bash (alleen grep/find) | Dingen lokaliseren in de codebase — alleen-lezen, snel |
+| Bouwer | Sonnet 4.6 | Read, Edit, Write, Bash | Chirurgische 1–2 bestandswijzigingen |
+| Reviewer | Haiku 4.5 | Read | Een diff of set bestanden beoordelen |
+| Orkestrator | Opus 4.7 | Alle | Complexe meerstaps coördinatie, architectuurbeslissingen |
+
+---
+
+## 4. Context overdrachtspatroon
+
+Wanneer een sessie significante context heeft opgebouwd en u werk moet overdragen aan een nieuwe agent.
+
+**Structuur van de overdracht prompt:**
+```
+## Context
+[Wat dit project doet, kort]
+[Waar we aan werkten]
+[Beslissingen genomen tijdens deze sessie]
+
+## Files modified
+[Lijst met korte reden voor elke wijziging]
+
+## Current state
+[Wat klaar, wat niet, wat blokkeert]
+
+## Your task
+[Specifieke, afgebakende taak voor de nieuwe agent]
+
+## Constraints
+[Genomen beslissingen die niet opnieuw besproken moeten worden]
+```
+
+---
+
+## 5. Harde vs. zachte afhankelijkheden
+
+**Harde afhankelijkheid:** De stroomafwaartse taak faalt expliciet zonder de stroomopwaartse setup.
+- Signaleer dit expliciet: "Deze skill vereist setup — voer eerst `/setup` uit."
+
+**Zachte afhankelijkheid:** De taak werkt maar produceert lagere kwaliteit uitvoer zonder setup.
+- Niet stoppen. Graceful degraderen en de kloof noteren.
+
+---
+
+## 6. Scopecontrole voor sub-agents
+
+Elke sub-agent moet een expliciete scopelimiet hebben.
+
+**Op te nemen in elke sub-agent prompt:**
+```
+## Scope
+- Read: yes
+- Write/Edit: [alleen specifieke bestanden OF nee]
+- Shell commands: [specifieke toegestane commando's OF geen]
+- Network: [ja/nee]
+
+## Do not
+- Do not modify files outside [directory]
+- Do not make git commits
+- Do not install packages
+```
+
+---
+
+## 7. Resultaten teruggeven van sub-agents
+
+**Bestanden prefereren voor:**
+- Resultatenlijsten waar de ouder over zal itereren
+- Gegenereerde code die de ouder zal beoordelen
+- Rapporten die meerdere keren worden gerefereerd
+
+**Terugkeerberichten prefereren voor:**
+- Eenvoudige ja/nee-antwoorden
+- Korte gestructureerde gegevens
+- Statusrapporten
+
+---
+
+## Snelle referentie
+
+| Doel | Patroon |
+|---|---|
+| Afgebakende, op zichzelf staande taak | Delegatie |
+| Zelfde taak op veel bestanden | Parallelisatie |
+| Alleen-lezen zoeken/lokaliseren | Onderzoeker (Haiku) |
+| Chirurgische codewijziging | Bouwer (Sonnet) |
+| Diff/bestand review | Reviewer (Haiku) |
+| Complexe meerstaps coördinatie | Orkestrator (Opus) |
+| Sessieoverdracht | Context overdrachtspatroon |
+| Grote sub-agent uitvoer | Naar bestand schrijven, ouder leest |
+| Kort gestructureerd resultaat | Terurkerbericht |
+
+---
+
+## Werk met ons samen
+
+Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten met ontwikkelaarsgemeenschappen en leveren B2B AI-oplossingen. Als u multi-agent systemen, autonome workflows of productie-kwaliteit Claude Code orkestratie ontwerpt — we hebben dit in productie gebouwd en kunnen u helpen.
+
+**[uitbreiden.com](https://uitbreiden.com/)**

package/guides/nl/getting-started.md

@@ -0,0 +1,164 @@
+# Aan de slag met Claudient
+
+Deze gids brengt u in minder dan 10 minuten van nul naar een werkende Claude Code-omgeving met uw eerste skill, agent en hook.
+
+---
+
+## Vereisten
+
+- [Claude Code](https://claude.ai/code) geïnstalleerd en geverifieerd
+- Een projectmap waaraan u actief werkt
+
+---
+
+## Stap 1 — Claudient klonen
+
+```bash
+git clone https://github.com/Claudient/Claudient.git ~/Claudient
+```
+
+U heeft nu de volledige bibliotheek lokaal. Er wordt niets automatisch uitgevoerd — u kiest wat u nodig heeft.
+
+---
+
+## Stap 2 — De `.claude/`-map van uw project instellen
+
+Claude Code zoekt naar configuratie in `.claude/` in de root van uw project.
+
+```bash
+mkdir -p your-project/.claude/skills
+mkdir -p your-project/.claude/hooks
+```
+
+Uw projectstructuur zou er als volgt uit moeten zien:
+
+```
+your-project/
+├── .claude/
+│   ├── skills/        ← skills komen hier (huidige standaard)
+│   ├── hooks/         ← hook-scripts komen hier
+│   └── settings.json  ← hook-configuratie komt hier
+├── CLAUDE.md          ← regels komen hier
+└── src/
+```
+
+---
+
+## Stap 3 — Uw eerste skill toevoegen
+
+Skills zijn slash-commando's. Kopieer een `.md`-bestand uit `skills/` naar `.claude/skills/`:
+
+```bash
+# Voorbeeld: de FastAPI-skill toevoegen
+cp ~/Claudient/skills/backend/python/fastapi.md your-project/.claude/skills/
+```
+
+Open nu Claude Code in uw project en typ `/fastapi` — de skill wordt geactiveerd.
+
+> **Opmerking:** `.claude/commands/` werkt nog steeds (verouderd pad), maar `.claude/skills/` is de huidige standaard. Als beide bestaan, hebben skills voorrang.
+
+**Hoe een skill kiezen:**
+- Blader door `skills/` per categorie
+- Lees de sectie "When to activate" bovenaan elk bestand
+- Als het overeenkomt met uw huidige taak, kopieer het dan
+
+---
+
+## Stap 4 — Een regel toevoegen
+
+Regels staan in `CLAUDE.md` in de root van uw project. Claude leest dit bestand aan het begin van elke sessie.
+
+```bash
+# Een gemeenschappelijke regelset kopiëren naar de CLAUDE.md van uw project
+cat ~/Claudient/rules/common/coding-style.md >> your-project/CLAUDE.md
+```
+
+Of open `rules/common/` en kopieer handmatig de secties die relevant zijn voor uw project.
+
+---
+
+## Stap 5 — Uw eerste hook toevoegen
+
+Hooks worden automatisch uitgevoerd bij Claude Code-gebeurtenissen. Ze staan in `.claude/settings.json`.
+
+Maak of open `.claude/settings.json` in uw project:
+
+```json
+{
+  "hooks": {}
+}
+```
+
+Kopieer een hook uit `hooks/` — elk hook-bestand bevat de exacte JSON om in te plakken. Bijvoorbeeld de kosten-tracking hook:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/cost-tracker.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Kopieer dan het bijbehorende script:
+
+```bash
+cp ~/Claudient/hooks/lifecycle/cost-tracker.sh your-project/.claude/hooks/
+chmod +x your-project/.claude/hooks/cost-tracker.sh
+```
+
+---
+
+## Stap 6 — (Optioneel) Een agent toevoegen
+
+Agents zijn sub-agent definities die u in uw Claude-sessies verwijst. Ze vereisen geen bestandskopie — u roept ze aan via `subagent_type` in een Agent-tool aanroep.
+
+Blader door `agents/` om te begrijpen wat beschikbaar is. Wanneer u wilt dat Claude een taak delegeert aan een specialist (bijv. een beveiligingsreviewer, een databasespecialist), raadpleeg dan de agentdefinitie om te begrijpen wat die verwacht en wat die teruggeeft.
+
+---
+
+## Wat nu te doen
+
+| Doel | Waar te zoeken |
+|---|---|
+| Uw eigen skill schrijven | [guides/skill-authoring.md](skill-authoring.md) |
+| Token-kosten verlagen | [guides/token-optimization.md](token-optimization.md) |
+| Geheugen en sessiestatus begrijpen | [guides/memory-management.md](memory-management.md) |
+| Uw Claude Code-setup beveiligen | [guides/security.md](security.md) |
+| Meerstaps geautomatiseerde workflows bouwen | [guides/agent-orchestration.md](agent-orchestration.md) |
+| Kwaliteit automatiseren met hooks | [guides/hooks-cookbook.md](hooks-cookbook.md) |
+
+---
+
+## Problemen oplossen
+
+**Skill verschijnt niet als slash-commando**
+— Controleer of het bestand in `.claude/skills/` staat (of `.claude/commands/` voor het oude pad)
+— Controleer of de bestandsextensie `.md` is
+— Start Claude Code opnieuw op
+
+**Hook wordt niet geactiveerd**
+— Controleer of de naam van de gebeurtenis exact overeenkomt: `PreToolUse`, `PostToolUse`, `PreCompact`, `Notification`
+— Controleer of het scriptpad relatief is aan de projectroot
+— Controleer of het script uitvoerbaar is (`chmod +x`)
+
+**CLAUDE.md wordt niet gelezen**
+— Het moet in de projectroot staan (op hetzelfde niveau als `src/`, `package.json`, etc.)
+— Start de Claude Code-sessie opnieuw na het bewerken
+
+---
+
+## Werk met ons samen
+
+Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten met ontwikkelaarsgemeenschappen en leveren B2B AI-oplossingen. Als u iets serieus bouwt met Claude Code en deskundige hulp, een technische partner, of gewoon deel wilt uitmaken van de gemeenschap — kom ons vinden.
+
+**[uitbreiden.com](https://uitbreiden.com/)**

package/guides/nl/hooks-cookbook.md

@@ -0,0 +1,160 @@
+# Hooks Kookboek
+
+Echte, gebruiksklare hook-patronen voor het automatiseren van kwaliteit, veiligheid en waarneembaarheid in Claude Code.
+
+---
+
+## Hook-fundamenten
+
+Hooks zijn shell-scripts of commando's die Claude Code automatisch uitvoert als reactie op gebeurtenissen. Ze draaien buiten Claudes context — het zijn echte shell-processen, geen Claude-instructies.
+
+**Hook-gebeurtenissen:**
+| Gebeurtenis | Wanneer het activeert |
+|---|---|
+| `SessionStart` | Wanneer een Claude Code-sessie begint |
+| `PreToolUse` | Voordat een tool-aanroep wordt uitgevoerd |
+| `PostToolUse` | Nadat een tool-aanroep is voltooid |
+| `PreCompact` | Voordat context-compactie activeert |
+| `PostCompact` | Na context-compactie |
+| `Stop` | Wanneer Claude klaar is met antwoorden |
+| `Notification` | Wanneer Claude een bureaubladmelding stuurt |
+
+**Afsluitcodes:** `0` = toestaan, `1` = waarschuwen (Claude ziet de uitvoer maar gaat door), `2` = blokkeren (tool-aanroep wordt geannuleerd).
+
+---
+
+## Recept 1 — Prettier auto-opmaak bij schrijven
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [{ "type": "command", "command": "npx prettier --write ${tool_input.file_path}", "async": true }]
+      }
+    ]
+  }
+}
+```
+
+---
+
+## Recept 2 — Gevaarlijke shell-opdrachten blokkeren
+
+**.claude/hooks/block-dangerous.sh:**
+```bash
+#!/usr/bin/env bash
+INPUT=$(cat)
+COMMAND=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('command',''))")
+BLOCKED_PATTERNS=("rm -rf" "sudo " "| bash" "| sh" "git push --force" "git reset --hard")
+for pattern in "${BLOCKED_PATTERNS[@]}"; do
+  if echo "$COMMAND" | grep -qi "$pattern"; then
+    echo "GEBLOKKEERD: opdracht komt overeen met gevaarlijk patroon '$pattern'" >&2
+    exit 2
+  fi
+done
+exit 0
+```
+
+---
+
+## Recept 3 — Auditlog voor elke tool-aanroep
+
+**.claude/hooks/audit-log.sh:**
+```bash
+#!/usr/bin/env bash
+INPUT=$(cat)
+TOOL_NAME=$(echo "$INPUT" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('tool_name','unknown'))" 2>/dev/null)
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+LOG_FILE="${CLAUDE_PROJECT_DIR}/.claude/logs/audit.log"
+mkdir -p "$(dirname "$LOG_FILE")"
+echo "${TIMESTAMP} | ${TOOL_NAME}" >> "$LOG_FILE"
+```
+
+---
+
+## Recept 4 — Sessieopslag voor compactie
+
+Combineer met een CLAUDE.md instructie: "Wanneer PreCompact activeert, vat samen: huidige taak, gewijzigde bestanden, open beslissingen, volgende stappen — voeg toe aan `.claude/memory/session-state.md`."
+
+---
+
+## Recept 5 — Kostentracker
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      { "matcher": "", "hooks": [{ "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/cost-tracker.sh", "async": true }] }
+    ]
+  }
+}
+```
+
+---
+
+## Recept 6 — TypeScript typecontrole bij bewerken
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [{ "type": "command", "command": "bash -c 'echo \"${tool_input.file_path}\" | grep -q \"\\.tsx\\?$\" && npx tsc --noEmit 2>&1 | head -20 || true'", "async": false, "timeout": 30 }]
+      }
+    ]
+  }
+}
+```
+
+---
+
+## Recept 7 — Git push herinnering
+
+```bash
+#!/usr/bin/env bash
+INPUT=$(cat)
+COMMAND=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('command',''))" 2>/dev/null)
+if echo "$COMMAND" | grep -q "git push"; then
+  echo "⚠️  Op het punt naar remote te pushen. Bevestig dat dit intentioneel is." >&2
+  exit 1
+fi
+exit 0
+```
+
+---
+
+## Recept 8 — Context-lader bij sessiestart
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      { "matcher": "", "hooks": [{ "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/session-start.sh" }] }
+    ]
+  }
+}
+```
+
+---
+
+## Problemen oplossen met hooks
+
+**Hook activeert niet:**
+- Controleer of de gebeurtenisnaam exact is: `PreToolUse`, `PostToolUse`, `SessionStart`, `PreCompact`
+- Controleer of het script uitvoerbaar is: `chmod +x .claude/hooks/uw-script.sh`
+
+**Hook handmatig testen:**
+```bash
+echo '{"tool_name":"Bash","tool_input":{"command":"ls"}}' | bash .claude/hooks/uw-script.sh
+```
+
+---
+
+## Werk met ons samen
+
+Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten met ontwikkelaarsgemeenschappen en leveren B2B AI-oplossingen. Als u aangepaste hook-systemen, geautomatiseerde kwaliteitspoorten of productie-kwaliteit Claude Code-automatisering voor uw team nodig heeft — we bouwen dit voor klanten.
+
+**[uitbreiden.com](https://uitbreiden.com/)**

package/guides/nl/memory-management.md

@@ -0,0 +1,153 @@
+# Handleiding voor geheugenbeheer
+
+Hoe u context bewaart tussen sessies, compactie overleeft en Claudes werkgeheugen scherp houdt.
+
+---
+
+## Het geheugenprobleem
+
+Claude Code heeft standaard geen persistent geheugen tussen sessies. Elke nieuwe sessie begint opnieuw. Binnen een sessie groeit de context totdat compactie wordt geactiveerd — op dat moment wordt de gespreksgeschiedenis gecomprimeerd en gaan details verloren.
+
+Geheugenbeheer is de praktijk van het expliciet controleren van wat Claude weet, wanneer het dat weet, en hoe die kennis sessiegrenzen overleeft.
+
+---
+
+## De vier geheugenlagen
+
+| Laag | Waar | Persistent tussen sessies | Overleeft compactie |
+|---|---|---|---|
+| **CLAUDE.md** | Projectroot | Ja | Ja |
+| **Sessiebestanden** | `.claude/memory/` of `.tmp/` | Ja (indien opgeslagen) | Ja (indien voor compact opgeslagen) |
+| **Contextvenster** | Alleen binnen sessie | Nee | Nee (gecomprimeerd) |
+| **Sub-agent context** | Per sub-agent | Nee | Nee |
+
+---
+
+## 1. CLAUDE.md als permanent geheugen
+
+`CLAUDE.md` wordt aan het begin van elke sessie gelezen. Het is de meest betrouwbare geheugenlaag.
+
+**Wat in CLAUDE.md hoort:**
+- Projectarchitectuuroverzicht (één alinea, niet uitputtend)
+- Conventies die Claude zonder begeleiding fout zou doen
+- Al genomen beslissingen die niet opnieuw besproken moeten worden
+- Wat Claude nooit mag doen in dit project
+
+**Wat NIET in CLAUDE.md hoort:**
+- Lopend werk of taakstatus (verandert te snel, wordt verouderd)
+- Lange uitleg over hoe technologieën werken
+- Alles — CLAUDE.md boven 500 regels kost meer dan het oplevert
+
+---
+
+## 2. Sessiebestanden voor werkgeheugen
+
+Voor lopende context die niet permanent in CLAUDE.md hoort, gebruik sessiebestanden.
+
+**Patroon:**
+```
+.claude/
+└── memory/
+    ├── current-task.md       ← waar u nu aan werkt
+    ├── decisions.md          ← beslissingen genomen deze week
+    └── context-dump.md       ← achtergrond voor een lange taak
+```
+
+**Sessiebestanden comprimeren:** Gebruik het caveman-compress patroon — sessiegeheugenbestanden herschrijven bespaart ~46% op input-tokens die elke sessie worden gelezen.
+
+---
+
+## 3. Pre-compact hook voor overleving
+
+Wanneer compactie automatisch wordt geactiveerd, gaat elke werkcontext in de sessie die niet in een bestand is opgeslagen verloren. Een `PreCompact`-hook wordt uitgevoerd voor compactie.
+
+```json
+{
+  "hooks": {
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/pre-compact-save.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+**Wat `pre-compact-save.sh` moet doen:**
+1. Claude vragen samen te vatten: huidige taakstatus, openstaande beslissingen, gewijzigde bestanden, volgende stappen
+2. Die samenvatting met tijdstempel schrijven naar `.claude/memory/session-state.md`
+
+---
+
+## 4. Sub-agent geheugen-isolatie
+
+Sub-agents krijgen een schoon contextvenster — ze hebben standaard geen geheugen van de oudersessie.
+
+**Geheugen doorgeven aan sub-agents:**
+- Relevante CLAUDE.md-secties expliciet opnemen in de sub-agent prompt
+- Specifieke bestandspaden en beslissingen doorgeven die de sub-agent nodig heeft
+
+**Geheugen terugkrijgen van sub-agents:**
+- Laat de sub-agent zijn bevindingen naar een bestand schrijven
+- Lees dat bestand terug in de oudersessie
+
+---
+
+## 5. CONTEXT.md voor domeintaal
+
+Complexe projecten profiteren van een `CONTEXT.md` — een woordenlijst van domeinspecifieke termen.
+
+**Structuur:**
+```markdown
+# Projectcontext
+
+## Language
+**Order**: Aankoopintentie van een klant voor een of meer Producten.
+**Cart**: Tijdelijke pre-bestelling status. Verschilt van Order — niet verwarren.
+
+## Relationships
+- Een Order bevat een of meer OrderLines
+- Een Cart behoort tot precies één User
+
+## Decisions
+- "Basket" werd gebruikt in vroege code — opgelost: gebruik altijd "Cart"
+```
+
+---
+
+## 6. Compactiestrategie
+
+**Proactieve compactie wint van reactieve compactie.**
+
+**Wanneer handmatig comprimeren (`/compact`):**
+- Voor het starten van een nieuwe grote taak in dezelfde sessie
+- Na een lange debugsessie
+- Wanneer Claude vragen begint te herhalen of beslissingen kwijtraakt
+
+---
+
+## Snelle referentie
+
+| Situatie | Actie |
+|---|---|
+| Onveranderlijke beslissingen | In CLAUDE.md zetten |
+| Huidige taakstatus | `.claude/memory/current-task.md` |
+| Domeinterminologie | `CONTEXT.md` in projectroot |
+| Compactie overleven | `PreCompact`-hook → session-state.md |
+| Nieuwe grote taak beginnen | Eerst `/compact`, dan beginnen |
+| Context doorgeven aan sub-agent | Expliciet opnemen in de prompt |
+| Claude stelt al beantwoorde vragen | Antwoord toevoegen aan CLAUDE.md |
+
+---
+
+## Werk met ons samen
+
+Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten met ontwikkelaarsgemeenschappen en leveren B2B AI-oplossingen. Als u langlopende AI-workflows, autonome agents bouwt, of hulp nodig heeft bij het ontwerpen van geheugenarchitecturen voor productie Claude Code-implementaties — wij kunnen helpen.
+
+**[uitbreiden.com](https://uitbreiden.com/)**