refactor(swift): update references from Medical Scribe to Swift Assistent

- Updated comments and documentation to reflect the new branding of the chat API and related components. - Renamed functions and variables to align with the Swift Assistent terminology. - Enhanced UI components with animations using Framer Motion for a smoother user experience. - Removed outdated architecture documentation related to the Medical Scribe system. This change is part of the transition to the Swift Assistent branding, ensuring consistency across the application.
2025-12-29 22:40:34 +01:00
parent 94aab93f1c
commit c8aaba657e
25 changed files with 6230 additions and 1054 deletions
--- a/docs/intent/architecture-intent-scalability.md
+++ b/docs/intent/architecture-intent-scalability.md
--- a/docs/intent/architecture-swift-cortex-v2.md
+++ b/docs/intent/architecture-swift-cortex-v2.md
--- a/docs/intent/fo-swift-intent-system-v2.md
+++ b/docs/intent/fo-swift-intent-system-v2.md
@@ -0,0 +1,167 @@
+# 🧩 Functioneel Ontwerp (FO) – Swift Intent System V2
+
+**Projectnaam:** Swift Intent Architecture V2
+**Versie:** v2.0 (Draft)
+**Datum:** 29-12-2025
+**Auteur:** Colin Lit (Antigravity AI)
+
+---
+
+## 1. Doel en relatie met het PRD
+🎯 **Doel van dit document:**
+Dit FO beschrijft de functionele werking van de "Next Gen" Swift Intent Architectuur. Waar V1 focuste op snelheid en basiscommando's ("Reactive"), focust V2 op contextbegrip, meervoudige intenties en proactieve ondersteuning ("Agentic").
+
+📘 **Relatie tot vorige documentatie:**
+Dit document vervangt de architectuur uit `architecture-intent-scalability.md` (Strategie 1: Strict Hierarchy) en kiest voor de **Hybride Route** (Strategie 5 + Agentic extensions) zoals besproken in de UX Evaluatie.
+
+---
+
+## 2. Overzicht van de belangrijkste onderdelen
+🎯 **Architectuurmodel:** "The Swift Cortex"
+Het systeem bestaat uit drie samenwerkende lagen die elk een andere rol spelen in de interactie:
+
+1.  **Layer 1: The Reflex Arc (De Snelle Reflex)**
+    *   *Rol:* Directe uitvoering van simpele, veelvoorkomende commando's.
+    *   *Voorbeeld:* "Afspraken vandaag", "Navigeer dossier".
+
+2.  **Layer 2: The Intent Orchestrator (Het Brein)**
+    *   *Rol:* AI-gedreven analyse voor complexe zinnen, context-disambiguatie en **Multi-Intents**.
+    *   *Voorbeeld:* "Zeg Jan af **en** maak een notitie."
+
+3.  **Layer 3: The Safety Net & Suggestion Engine (De Partner)**
+    *   *Rol:* Proactieve business logic die *na* een actie meedenkt.
+    *   *Voorbeeld:* Na "Wondzorg registratie" → Suggestie: "Wondcontrole inplannen?"
+
+---
+
+## 3. Userstories
+
+**User Story Template:**
+> Als [rol] wil ik [actie] zodat [waarde].
+
+| ID | Rol | Doel / Actie | Context / Voorbeeld | Prioriteit |
+|----|------|---------------|-------------------|-------------|
+| **US-V2-01** | Vpk | **Multi-Intent** commando's geven | "Meld Jan af voor vandaag **en** bel zijn huisarts." | Hoog |
+| **US-V2-02** | Vpk | **Context-aware** begrepen worden | "Plan wondzorg **morgen**" (Snap dat 'morgen' refereert aan *mijn* agenda). | Hoog |
+| **US-V2-03** | Regie | **Proactieve checks** op veiligheid | Bij voorschrijven lithium: "Check laatste nierfunctie?" | Middel |
+| **US-V2-04** | Psych | **Impliciete intenties** verwerkt zien | "Patiënt was suïcidaal" → Systeem oppert crisisprotocol start. | Hoog |
+| **US-V2-05** | Vpk | Geen "Computer says no" ervaring | Bij twijfel: vraag verduidelijking i.p.v. "Ik begrijp het niet". | Hoog |
+
+---
+
+## 4. Functionele werking per onderdeel
+
+### 4.1 Layer 1: The Reflex Arc (Local First)
+*   **Trigger:** Elke gebruikersinput (spraak/tekst).
+*   **Werking:** Checkt razendsnel (<20ms) of de input matcht met een `Local Pattern` (Regex).
+*   **Conditie:** Alleen bij **Confidence > 0.9** (vrijwel zeker) voert hij direct uit.
+*   **Fallback:** Bij twijfel (<0.9) of geen match → *Direct doorsturen naar Layer 2*.
+
+### 4.2 Layer 2: The Intent Orchestrator (AI Router)
+*   **Trigger:** Input die te complex of dubbelzinnig is voor Layer 1.
+*   **Input Context:** Ontvangt niet alleen de zin, maar ook: `ActivePatient`, `CurrentView`, `Time`.
+*   **Werking:**
+    1.  Analyseert intentie(s).
+    2.  Splits samengestelde zinnen ("En", "Daarna") in een **Action Chain**.
+    3.  Extraheert entities (Wie, Wanneer, Wat).
+*   **Output:** Een lijst van uit te voeren acties: `[ActionA, ActionB]`.
+
+### 4.3 Layer 3: The Safety Net (Post-Action Logic)
+*   **Trigger:** Succesvolle afronding van een intent (bijv. `CreateAppointment` klaar).
+*   **Werking:** Draait `Domain Rules` op de uitgevoerde actie.
+*   **UI:** Toont een **Suggestion Toast** of **Card** ("Wil je ook...?").
+*   **Voorbeeld:**
+    *   *Actie:* Medicatie gestart.
+    *   *Rule:* "Nieuwe medicatie vereist evaluatie na 2 weken."
+    *   *Suggestie:* "Evaluatie afspraak inplannen over 14 dagen?"
+
+---
+
+## 5. UI-overzicht (Flow)
+
+De UI past zich aan op basis van de complexiteit van de intentie.
+
+```text
+┌─────────────────────────────────────────────────────────────┐
+│ 1. Input: "Zeg Jan af en maak notitie: grieperig"           │
+└─────────────────────────────────────────────────────────────┘
+          │
+          ▼
+┌─────────────────────────────────────────────────────────────┐
+│ 2. Processing (Cortex): "1 moment, ik verwerk 2 acties..."  │
+└─────────────────────────────────────────────────────────────┘
+          │
+          ▼
+┌─────────────────────────────────────────────────────────────┐
+│ 3. Execution UI (Stacked Cards)                             │
+│ ┌──────────────────────────────────────┐                    │
+│ │ ✅ Afspraak Jan (14:00) Geannuleerd  │                    │
+│ └──────────────────────────────────────┘                    │
+│ ┌──────────────────────────────────────┐                    │
+│ │ 📝 Concept Notitie: "grieperig"      │ [Bevestigen]       │
+│ └──────────────────────────────────────┘                    │
+└─────────────────────────────────────────────────────────────┘
+          │
+          ▼
+┌─────────────────────────────────────────────────────────────┐
+│ 4. Safety Net (Proactive Toast)                             │
+│ 💡 "Wil je de griep-poli waarschuwen?"   [Ja, doe maar] [X] │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 6. Interacties met AI (Specificaties)
+
+| Component | Trigger | AI Model | Prompt Strategie | Output Structuur |
+|-----------|---------|----------|------------------|------------------|
+| **Reflex** | User Input | *Geen (Regex)* | N.v.t. | `SingleIntent` |
+| **Cortex** | Complex Input | Claude 3.5 Haiku | "You are an Orchestrator. Output a JSON list of intents." | `Array<IntentAction>` |
+| **Safety** | Action Done | Regelset / Small AI | "Based on this action, what is the protocol?" | `Suggestion | null` |
+
+### 6.1 Multi-Intent Data Model
+Het systeem moet worden omgebouwd van `Single Intent` naar `Intent Chain`:
+
+**Oud:**
+```typescript
+interface Result { intent: SwiftIntent }
+```
+
+**Nieuw:**
+```typescript
+interface IntentChain {
+  originalInput: string;
+  actions: IntentAction[];
+}
+
+interface IntentAction {
+  intent: SwiftIntent;
+  entities: ExtractedEntities;
+  status: 'pending' | 'success' | 'failed';
+  requiresConfirmation: boolean;
+}
+```
+
+---
+
+## 7. Migratie & Roadmap
+
+### Fase 1: Hybrid Foundation (Week 1-2)
+*   Implementatie van de **Reflex/Cortex switch**.
+*   Zorgen dat *alle* twijfelgevallen naar de AI gaan (geen "Unknown" errors meer).
+*   Context object (`ActivePatient`) meegeven aan AI.
+
+### Fase 2: Orchestration (Week 3-4)
+*   Refactor frontend om `IntentChain` (lijstjes) te ondersteunen.
+*   Prompt engineering voor multi-intent herkenning ("En", "Daarna").
+
+### Fase 3: Proactivity (Maand 2)
+*   Bouwen van de `Safety Net` listeners.
+*   Protocollen toevoegen voor Medicatie en Wondzorg.
+
+---
+
+## 8. Bijlagen & Referenties
+*   **PRD/Vision:** `docs/swift/ux-simulation-intent-next-level.md`
+*   **Technical Base:** `lib/swift/intent-classifier-ai.ts`
+*   **Legacy Docs:** `docs/swift/intent-architecture-v2-proposal.md`
--- a/docs/intent/haalbaarheidsanalyse-swift-cortex-v2.md
+++ b/docs/intent/haalbaarheidsanalyse-swift-cortex-v2.md
@@ -0,0 +1,356 @@
+# Haalbaarheidsanalyse: Swift Cortex V2
+
+**Datum:** 29-12-2025
+**Auteur:** Claude Code (Opus 4.5)
+**Status:** Analyse compleet
+
+---
+
+## Executive Summary
+
+**Conclusie: HAALBAAR met gefaseerde aanpak**
+
+De Swift Cortex V2 architectuur is **goed haalbaar** binnen de bestaande codebase. De huidige implementatie biedt een solide fundament met ~70% van de benodigde infrastructuur al aanwezig. De voorgestelde V2 architectuur sluit naadloos aan op bestaande patterns.
+
+| Aspect | Score | Toelichting |
+|--------|-------|-------------|
+| **Technische haalbaarheid** | 🟢 Hoog | Bestaande architectuur is compatibel |
+| **Complexiteit** | 🟡 Middel | Multi-intent en Safety Net zijn nieuwe concepten |
+| **Risico** | 🟢 Laag | Incrementeel te bouwen, backward compatible |
+| **MVP Scope** | 🟢 Realistisch | 6 user stories, goed afgebakend |
+
+---
+
+## 1. Vergelijking: Huidige Staat vs V2 Visie
+
+### 1.1 Architectuur Mapping
+
+| V2 Concept | Huidige Implementatie | Gap |
+|------------|----------------------|-----|
+| **Layer 1: Reflex Arc** | ✅ `intent-classifier.ts` (60 patterns) | Minimaal - voeg complexity detection toe |
+| **Layer 2: Orchestrator** | ✅ `intent-classifier-ai.ts` (Haiku) | Middel - upgrade prompt voor multi-intent |
+| **Layer 3: Safety Net** | ❌ Niet aanwezig | Nieuw te bouwen |
+| **Context Injection** | 🟡 Basis aanwezig (`activePatient`, `shift`) | Uitbreiden met `agendaToday`, `recentIntents` |
+| **Multi-Intent Chains** | ❌ Single intent model | Data model refactor nodig |
+| **Entity Extraction** | ✅ `entity-extractor.ts` | Minimaal - voeg `patientResolution` toe |
+| **Date/Time Parsing** | ✅ `date-time-parser.ts` | Geen gap |
+
+### 1.2 Bestaande Bestanden (Assets)
+
+```
+lib/swift/
+├── types.ts                 ✅ Basis types, uitbreiden met IntentChain
+├── intent-classifier.ts     ✅ Layer 1 basis, voeg signals detection toe
+├── intent-classifier-ai.ts  ✅ Layer 2 basis, upgrade prompt
+├── entity-extractor.ts      ✅ Compleet, kleine uitbreiding
+├── date-time-parser.ts      ✅ Compleet, geen wijzigingen
+├── action-parser.ts         ✅ Refactor voor chains
+├── chat-api.ts              ✅ Behouden
+├── error-handler.ts         ✅ Recent toegevoegd
+└── [NIEUW] reflex-classifier.ts   → Upgrade van intent-classifier
+└── [NIEUW] orchestrator.ts        → Upgrade van intent-classifier-ai
+└── [NIEUW] safety-net.ts          → Nieuw te bouwen
+
+stores/
+└── swift-store.ts           ✅ Uitbreiden met chain state + suggestions
+
+components/swift/
+├── chat/                    ✅ Bestaand, voeg ActionChainCard toe
+├── artifacts/               ✅ Bestaand, geen wijzigingen
+├── command-center/          ✅ Bestaand, voeg SuggestionToast toe
+└── [NIEUW] suggestion-toast.tsx
+└── [NIEUW] chat/action-chain-card.tsx
+└── [NIEUW] chat/clarification-card.tsx
+```
+
+---
+
+## 2. Gap Analyse per V2 Feature
+
+### 2.1 Multi-Intent Support (US-MVP-01)
+
+**Huidige situatie:**
+```typescript
+// Huidige single-intent response
+interface ClassificationResult {
+  intent: SwiftIntent;
+  confidence: number;
+}
+```
+
+**V2 vereist:**
+```typescript
+// Multi-intent chain
+interface IntentChain {
+  actions: IntentAction[];  // Array i.p.v. single
+  status: 'pending' | 'executing' | 'completed';
+}
+```
+
+**Impact:**
+- `types.ts`: Nieuwe interfaces toevoegen (~50 regels)
+- `orchestrator.ts`: Nieuwe AI prompt met multi-intent instructies (~150 regels)
+- `swift-store.ts`: Chain state toevoegen (~30 regels)
+- `action-chain-card.tsx`: Nieuwe UI component (~150 regels)
+
+**Effort: M (Medium)**
+
+---
+
+### 2.2 Context Awareness (US-MVP-02, US-MVP-03)
+
+**Huidige situatie:**
+```typescript
+// In chat API - basic context
+context: {
+  activePatient?: { id, first_name, last_name },
+  shift?: ShiftType
+}
+```
+
+**V2 vereist:**
+```typescript
+interface SwiftContext {
+  activePatient: { id, name, recentNotes?, upcomingAppointments? };
+  currentView: string;
+  shift: ShiftType;
+  currentTime: Date;
+  agendaToday: Appointment[];
+  recentIntents: RecentIntent[];
+}
+```
+
+**Impact:**
+- Nieuwe `GET /api/swift/context` endpoint (~80 regels)
+- Context builder utility (~50 regels)
+- Store uitbreiding voor context sync (~20 regels)
+
+**Effort: S (Small)**
+
+---
+
+### 2.3 Hybrid Reflex/Cortex Switch (US-MVP-04, US-MVP-05)
+
+**Huidige situatie:**
+- `intent-classifier.ts` heeft al confidence threshold (0.8)
+- AI fallback via `intent-classifier-ai.ts` werkt al
+
+**V2 verschil:**
+- Expliciete "complexity signals" detectie (multi-intent woorden: "en", "daarna")
+- Context-afhankelijke woorden detectie ("hij", "haar", "deze")
+
+**Impact:**
+- Upgrade `intent-classifier.ts` → `reflex-classifier.ts` (~100 regels diff)
+- Voeg `MULTI_INTENT_SIGNALS` en `CONTEXT_SIGNALS` regex arrays toe
+
+**Effort: S (Small)** - Grootste deel al gebouwd
+
+---
+
+### 2.4 Safety Net / Proactive Suggestions (US-MVP-06)
+
+**Huidige situatie:**
+- Niet aanwezig
+
+**V2 vereist:**
+- Protocol Rules database
+- `evaluateSafetyNet()` functie
+- `SuggestionToast` component
+- Store state voor suggestions
+
+**Impact:**
+- `safety-net.ts`: Nieuwe module (~200 regels)
+- `suggestion-toast.tsx`: Nieuw component (~100 regels)
+- Store uitbreiding (~40 regels)
+- Integratie in action execution flow
+
+**Effort: L (Large)** - Volledig nieuw concept
+
+---
+
+## 3. Risico Analyse
+
+### 3.1 Technische Risico's
+
+| Risico | Impact | Kans | Mitigatie |
+|--------|--------|------|-----------|
+| AI Prompt instabiliteit | Multi-intent parsing faalt | Laag | Uitgebreide test dataset, fallback naar single |
+| Performance degradatie | Latency >2s | Laag | Haiku is snel, cache context |
+| State complexity | Race conditions | Middel | Zustand immer middleware, clear action flow |
+| Backward compatibility | V1 features breken | Laag | Feature flags, adapter pattern |
+
+### 3.2 Scope Risico's
+
+| Risico | Impact | Mitigatie |
+|--------|--------|-----------|
+| Feature creep | MVP te groot | Strikte scope (6 stories) |
+| Protocol complexity | Safety Net te ambitieus | Begin met 1 hardcoded regel |
+| Over-engineering | Te veel abstractie | "Working software" first |
+
+---
+
+## 4. Implementatie Strategie
+
+### 4.1 Aanbevolen Fasering
+
+```
+Fase 1: Foundation (Week 1)
+├── SwiftContext type definitie
+├── GET /api/swift/context endpoint
+├── Reflex complexity detection upgrade
+├── Feature flag: SWIFT_V2_ENABLED
+└── Deliverable: Context beschikbaar, backward compatible
+
+Fase 2: Multi-Intent (Week 2)
+├── IntentChain types
+├── Orchestrator AI prompt upgrade
+├── ActionChainCard component
+├── Store chain state
+└── Deliverable: "Zeg af en maak notitie" werkt
+
+Fase 3: Safety Net MVP (Week 3)
+├── 1 hardcoded protocol regel (wondzorg)
+├── SuggestionToast component
+├── Trigger na dagnotitie
+└── Deliverable: Proactieve suggestie demo
+
+Fase 4: Polish (Week 4)
+├── ClarificationCard component
+├── Error handling
+├── UI animaties
+└── Deliverable: Demo-ready prototype
+```
+
+### 4.2 Backward Compatibility
+
+De V2 architectuur kan naast V1 draaien:
+
+```typescript
+// lib/swift/classifier-adapter.ts
+export async function classifyIntent(input: string, context?: SwiftContext) {
+  if (!FEATURE_FLAGS.SWIFT_V2_ENABLED) {
+    return classifyV1(input);  // Bestaande flow
+  }
+
+  const reflex = classifyWithReflex(input);
+  if (!reflex.shouldEscalateToAI) {
+    return buildLocalResult(input, reflex);
+  }
+  return classifyWithOrchestrator(input, context);
+}
+```
+
+---
+
+## 5. Effort Schatting
+
+### 5.1 Per Component
+
+| Component | Nieuw | Wijziging | Effort |
+|-----------|-------|-----------|--------|
+| `types.ts` | 150 regels | - | S |
+| `reflex-classifier.ts` | 200 regels | upgrade | M |
+| `orchestrator.ts` | 250 regels | upgrade | M |
+| `safety-net.ts` | 200 regels | nieuw | M |
+| `swift-store.ts` | - | +100 regels | S |
+| `action-chain-card.tsx` | 180 regels | nieuw | M |
+| `suggestion-toast.tsx` | 100 regels | nieuw | S |
+| `clarification-card.tsx` | 60 regels | nieuw | S |
+| `/api/swift/context` | 80 regels | nieuw | S |
+| `/api/intent/classify` | 150 regels | nieuw | M |
+| Tests | 300 regels | nieuw | M |
+
+**Totaal: ~1770 nieuwe regels code**
+
+### 5.2 Tijdsinschatting
+
+| Fase | Effort | Complexiteit |
+|------|--------|--------------|
+| Fase 1: Foundation | 2-3 dagen | Laag |
+| Fase 2: Multi-Intent | 3-4 dagen | Middel |
+| Fase 3: Safety Net | 2-3 dagen | Middel |
+| Fase 4: Polish | 2-3 dagen | Laag |
+
+**Totaal: 9-13 werkdagen voor MVP**
+
+---
+
+## 6. Aanbevelingen
+
+### 6.1 DO's
+
+1. **Start met Foundation** - Context injection is low-risk, high-value
+2. **Gebruik feature flags** - Mogelijkheid om V2 uit te schakelen
+3. **Test sentences dataset** - Bouw corpus van 50+ test zinnen voordat je multi-intent bouwt
+4. **Behoud V1 patterns** - De 60 bestaande regex patterns zijn waardevol
+
+### 6.2 DON'T's
+
+1. **Niet alle protocollen tegelijk** - Begin met 1 Safety Net regel
+2. **Geen over-engineering** - De `ProtocolRule` interface is voor later
+3. **Niet de store herschrijven** - Extend, niet replace
+4. **Geen rollout strategie nodig** - Dit is een prototype
+
+### 6.3 Quick Wins
+
+1. **Context endpoint** - Direct te bouwen, verbetert AI kwaliteit
+2. **Complexity detection** - 10 regels code, grote impact
+3. **Processing indicator** - Al aanwezig (`isStreaming`), polish
+
+---
+
+## 7. Conclusie
+
+### Haalbaarheid: ✅ JA
+
+De Swift Cortex V2 architectuur is **volledig haalbaar** binnen de bestaande codebase:
+
+1. **70% infrastructuur bestaat al** - Classifier, entity extraction, store, chat API
+2. **Incrementeel te bouwen** - Elke fase levert werkende software
+3. **Backward compatible** - Geen breaking changes voor bestaande features
+4. **Realistische scope** - 6 user stories, ~1770 regels code
+5. **Risico's beheersbaar** - Feature flags, fallbacks, tests
+
+### Kritieke Succesfactoren
+
+1. **Test dataset eerst** - Bouw 50+ test zinnen voordat je multi-intent implementeert
+2. **Feature flags** - Zorg dat V2 uitschakelbaar is
+3. **Iteratief bouwen** - Elke fase moet demo-baar zijn
+4. **Scope discipline** - Niet alle protocollen, alleen wondzorg voor MVP
+
+### Volgende Stap
+
+Start met **Fase 1: Foundation** - de SwiftContext API endpoint. Dit is:
+- Low risk
+- Onafhankelijk van andere features
+- Direct waarde toevoegend aan bestaande AI classificatie
+- In 1-2 dagen te bouwen
+
+---
+
+## Bijlagen
+
+### A. Bestaande Code Referenties
+
+| Bestand | Regels | Functie |
+|---------|--------|---------|
+| `lib/swift/types.ts` | ~180 | Type definities |
+| `lib/swift/intent-classifier.ts` | ~200 | Layer 1 classifier |
+| `lib/swift/intent-classifier-ai.ts` | ~100 | Layer 2 AI fallback |
+| `lib/swift/entity-extractor.ts` | ~250 | Entity extraction |
+| `lib/swift/date-time-parser.ts` | ~200 | Datum/tijd parsing |
+| `lib/swift/action-parser.ts` | ~150 | Action routing |
+| `stores/swift-store.ts` | ~200 | Zustand state |
+
+### B. V2 Documentatie Verwijzingen
+
+- `architecture-swift-cortex-v2.md` - Uitgebreid technisch plan
+- `fo-swift-intent-system-v2.md` - Functioneel ontwerp
+- `intent-architecture-v2-proposal.md` - Architectuur voorstel
+- `mvp-userstories-intent-system.md` - MVP scope
+
+### C. Versie Historie
+
+| Versie | Datum | Auteur | Wijzigingen |
+|--------|-------|--------|-------------|
+| 1.0 | 29-12-2025 | Claude Code | Initiële analyse |
--- a/docs/intent/intent-architecture-v2-proposal.md
+++ b/docs/intent/intent-architecture-v2-proposal.md
@@ -0,0 +1,86 @@
+# Architecture Proposal: Swift Intent System V2
+
+**Status:** Draft
+**Based on:**
+- `ux-evaluation-intent-scalability.md` (The "Don't make me think" rule)
+- `ux-simulation-intent-next-level.md` (The "Be my partner" wish)
+
+---
+
+## 1. The Triad Consensus (PO, UX, Dev)
+
+De PO, UX en Lead Developer hebben de bevindingen geanalyseerd. Dit is de gezamenlijke conclusie:
+
+> **"We stoppen met optimaliseren voor milliseconden (Pre-optimization) en starten met optimaliseren voor intelligentie (Agentic UI)."**
+
+*   **PO:** "Akkoord met hogere 'cost per interaction' (AI tokens) als dit directe tijdwinst oplevert voor de zorgverlener (minder administratie)."
+*   **UX:** "De interface moet 'Invisible' worden. Geen commando's leren, maar intenties uitspreken."
+*   **Dev:** "De huidige 'Strict Hierarchy' (Strategie 1) is te rigide. We gaan voor een **Hybrid Leader/Follower architectuur**: Lokale snelheid waar kan, AI intelligentie waar moet."
+
+---
+
+## 2. Core Architecture: "The Swift Cortex"
+
+We vervangen de simpele `Classifier` door een slimmere `Cortex`.
+
+### Layer 1: The Reflex Arc (Lokaal, <20ms)
+*   **Wat:** Regex & Keyword matching (zoals nu).
+*   **Doel:** Directe actie voor "High Confidence, Low Risk" commando's.
+*   **Scope:** Navigatie, simpele queries ("Agenda vandaag"), start commando's.
+
+### Layer 2: The Intent Orchestrator (AI, ~400ms)
+*   **Wat:** Een kleine LLM (Haiku/Gemini Flash) die fungeert als "Router".
+*   **Nieuwe capability: Multi-Intent Parsing.**
+    *   *Input:* "Zeg Jan af en zet in zijn dossier dat hij griep heeft."
+    *   *Output:* `[CancelAppointment(Jan), CreateNote(Jan, "Griep")]`
+*   **Nieuwe capability: Entity Disambiguation.**
+    *   Snap dat "Jan" verwijst naar de patiënt die ik *vandaaag* in mijn agenda heb.
+
+### Layer 3: The Safety Net (Contextual Logic)
+*   **Wat:** Een business logic laag die *na* de intent draait.
+*   **Functie:** Proactive Suggestions.
+    *   *Trigger:* Intent `CreateWoundCareNote` 'completed'.
+    *   *Logic:* Check `Protocol(Wondzorg)`.
+    *   *Action:* Suggest `ScheduleFollowUp`.
+
+---
+
+## 3. Implementation Roadmap
+
+### Phase 1: Hybrid Foundation (Week 1-2)
+*   [ ] Behoud huidige lokale patterns voor snelheid.
+*   [ ] Bouw de **AI Fallback Router** in. Als lokaal faalt (<60% confidence), stuur *direct* volledige context naar AI.
+*   [ ] **UX Win:** Geen "Ik begrijp het niet" meer. Altijd een poging tot begrip.
+
+### Phase 2: Chains & Context (Week 3-4)
+*   [ ] **Context Injectie:** Stuur `ActivePatient`, `RecentIntents`, en `AgendaToday` mee in de AI prompt.
+*   [ ] **Multi-Intent Support:** Pas de frontend aan om een *lijst* van acties te verwerken in plaats van één.
+
+### Phase 3: Agentic Proactivity (Maand 2)
+*   [ ] **Suggestion Engine:** UI element (Toaster/Card) dat vraagt: *"Wil je ook X doen?"*
+*   [ ] **Medical Knowledge Base:** Koppel protocollen aan intents.
+
+---
+
+## 4. Technisch Ontwerp Schets (Dev)
+
+```mermaid
+graph TD
+    User["User Speech"] --> Reflex["Layer 1: Reflex (Regex)"]
+    Reflex -->|Match > 90%| Action["Execute Action"]
+    Reflex -->|No Match / Low Conf| Cortex["Layer 2: AI Cortex"]
+    
+    subgraph Context
+        Store["Active Patient"]
+        Agenda["Today's Schedule"]
+    end
+    
+    Context --> Cortex
+    
+    Cortex -->|Multi-Intent Detected| Plan["Execution Plan"]
+    Plan --> Action1["Action A"]
+    Plan --> Action2["Action B"]
+    
+    Action1 --> Safety["Layer 3: Safety Net"]
+    Safety -->|Trigger Found| Suggestion["Suggest Follow-up"]
+```
--- a/docs/intent/mvp-userstories-intent-system.md
+++ b/docs/intent/mvp-userstories-intent-system.md
@@ -0,0 +1,69 @@
+# 🚀 MVP Userstories & Scope: Swift Cortex (Public Prototype)
+
+**Betreft:** Scope voor de "Build in Public" fase van het Swift Intent System V2.
+**Doel:** Een werkend, indrukwekkend prototype neerzetten dat de kernwaarde van "Agency" (Multi-intent & Context) demonstreert, zonder te verzanden in productie-complexiteit.
+
+---
+
+## 1. Scope Definitie
+
+We splitsen de ontwikkeling in **MVP** (Wat we nu bouwen voor de publieke demo) en **Post-MVP** (Wat nodig is voor een veilig medisch productiesysteem).
+
+### ✅ In Scope (MVP - "The Prototype")
+*Focus: Wow-factor, core mechanics, demonstratie van intelligentie.*
+
+1.  **Hybrid Architecture:** De naadloze switch tussen Layer 1 (Reflex) en Layer 2 (AI).
+2.  **Multi-Intent:** Het kunnen verwerken van samengestelde zinnen ("Zeg af en maak notitie").
+3.  **Context Awareness:** Het correct interpreteren van "hij", "deze", "morgen" o.b.v. de huidige schermstatus.
+4.  **UI Feedback:** Visualisatie van het "denkproces" en gestapelde resultaten (Stacked Cards).
+5.  **Basic Safety Net:** Eén hardcoded voorbeeld van proactiviteit (bijv. "Wondcontrole suggestie") om het concept te tonen.
+
+### ❌ Out of Scope (Post-MVP - "The Product")
+*Focus: Veiligheid, robuustheid, edge-cases.*
+
+1.  **Complete Medische Protocollen:** Geen volledige rule-engine voor alle ziektebeelden.
+2.  **Complex Rollback:** Geen "Undo" knop voor database mutaties (wel confirmaties vooraf).
+3.  **Offline Mode:** Het prototype gaat uit van internetverbinding.
+4.  **Advanced Error Handling:** Geen automatische retry-mechanismes of fallbacks als de LLM down is.
+5.  **Analytics & Learning:** Geen telemetry opslag voor model-training.
+
+---
+
+## 2. MVP User Stories
+
+Deze stories zijn leidend voor de aankomende bouwfase.
+
+### Thema 1: De Slimme Assistent (Core Intelligence)
+
+| ID | Story | Acceptatie Criteria |
+|----|-------|---------------------|
+| **US-MVP-01** | Als gebruiker wil ik **twee acties in één zin** kunnen geven ("Zeg Jan af en mail de huisarts"), zodat ik niet hoef te wachten. | - Systeem herkent "en/daarna" signalen.<br>- UI toont twee losse acties in progressie.<br>- Beide acties worden uitgevoerd. |
+| **US-MVP-02** | Als gebruiker wil ik naar **"deze patiënt"** of **"hij"** kunnen verwijzen, zodat ik natuurlijk kan spreken. | - Systeem gebruikt de `ActivePatient` uit de store om "hij" te invullen.<br>- Als er geen patiënt open staat, vraagt het systeem "Wie bedoel je?". |
+| **US-MVP-03** | Als gebruiker wil ik **impliciete tijd** ("morgen", "volgende week") kunnen gebruiken, zodat ik geen datums hoef te noemen. | - "Morgen" wordt correct vertaald naar de datum van morgen.<br>- Context (huidige tijd) wordt meegestuurd naar de AI. |
+
+### Thema 2: Hybride Snelheid (Architecture)
+
+| ID | Story | Acceptatie Criteria |
+|----|-------|---------------------|
+| **US-MVP-04** | Als gebruiker wil ik dat simpele commando's (**"Agenda", "Zoek Jan"**) direct werken (<20ms), zodat het systeem niet traag voelt. | - Reflex Arc (Regex) vangt deze af.<br>- Geen AI spinner zichtbaar, directe actie. |
+| **US-MVP-05** | Als gebruiker wil ik zien **dat het systeem nadenkt** bij complexe vragen, zodat ik weet dat ik moet wachten. | - Bij trage/AI acties (Layer 2) toont de UI direct een "Processing..." indicator.<br>- Geen "bevroren" scherm. |
+
+### Thema 3: De Partner (Proactivity - Concept)
+
+| ID | Story | Acceptatie Criteria |
+|----|-------|---------------------|
+| **US-MVP-06** | Als gebruiker wil ik een **proactieve suggestie** zien na een specifieke actie (bijv. wondzorg), zodat ik snap dat het systeem meedenkt. | - *Demo Case:* Na invoeren "Wondverzorging" toont systeem kaartje: "Afspraak wondcontrole inplannen?".<br>- Klikken op "Ja" opent direct het planningsscherm. |
+
+---
+
+## 3. Technische Randvoorwaarden (MVP)
+
+*   **Model:** Claude 3.5 Haiku (via Anthropic API).
+*   **Latency Target:** Reflex < 50ms, AI < 1.5s (acceptabel voor prototype).
+*   **Data:** We gebruiken mock-data voor patiënten en agenda, geen echte EPD koppeling.
+
+## 4. 'Build in Public' roadmap
+
+1.  **Week 1:** De "Reflex" werkend krijgen (De basis).
+2.  **Week 2:** De "Cortex" aansluiten (Multi-intent parsing demo).
+3.  **Week 3:** De UI polijsten (Stacked Cards & Animaties) & Share video.
--- a/docs/intent/review-swift-cortex-v2.md
+++ b/docs/intent/review-swift-cortex-v2.md
@@ -0,0 +1,116 @@
+# Review Rapport: Swift Cortex & Intent System V2
+
+**Datum:** 29-12-2025  
+**Betreft:** Review van `architecture-swift-cortex-v2.md` en `fo-swift-intent-system-v2.md`  
+**Reviewers (Simulatie):** Architect, Backend Dev, Frontend Dev, UX Designer, QA Engineer
+
+---
+
+## 1. Algemene Conclusie
+Het voorgestelde **Hyper-Hybrid model (Swift Cortex)** is een sterke, volwassen architectuur die de grootste pijnpunten van V1 (traagheid bij simpele taken, domheid bij complexe taken) effectief oplost. De opsplitsing in drie lagen (Reflex, Orchestrator, Safety Net) is logisch en schaalbaar.
+
+**Oordeel:** ✅ **Go for launch**, mits onderstaande punten in acht worden genomen.
+
+---
+
+## 2. Feedback per Rol
+
+### 🏗️ Software Architect / Lead
+**Perspectief:** Systeemsamenhang, onderhoudbaarheid, risico's.
+
+*   **Pros:**
+    *   **Separation of Concerns:** De scheiding tussen deterministische regex (L1) en probabilistische AI (L2) beschermt de performance van basisfuncties.
+    *   **Schaalbaarheid:** L2 is losgekoppeld; we kunnen het model (Claude Haiku) later vervangen door GPT-4o of een local model zonder L1 te breken.
+    *   **Type Safety:** De definities voor `IntentChain` en `SwiftContext` zijn robuust.
+*   **Cons / Risico's:**
+    *   **State Complexity:** Het beheren van een `IntentChain` (met statussen als `pending`, `executing`, `failed`) introduceert complexe state management logica. Wat als stap 1 slaagt maar stap 2 faalt? Rollback support (genoemd in L2 architecture overview) is complex om generiek te bouwen.
+    *   **Drift:** Risico dat L1 (Regex) en L2 (AI) uit elkaar groeien. Als de AI "agenda" anders interpreteert dan de Regex.
+*   **Advies:** Begin L2 zonder volledige rollback support (fail-forward of handmatige cleanup) om complexiteit te beperken.
+
+### ⚙️ Backend Developer
+**Perspectief:** Integratie, LLM API's, performance.
+
+*   **Pros:**
+    *   **Duidelijke API's:** De inputs en outputs voor de Orchestrator zijn helder gedefinieerd.
+    *   **Model Keuze:** Claude 3.5 Haiku is inderdaad de sweet spot voor snelheid/kosten.
+*   **Cons:**
+    *   **Latency:** Zelfs met Haiku is ~400ms+ merkbaar. De UI "wachtstand" is cruciaal.
+    *   **Error Handling:** Wat als de API 500't of timeout? De fallback strategie ontbreekt in de docs (terugvallen naar L1 of "Probeer later"?).
+*   **Haalbaarheid:** Goed haalbaar. De prompts (`ORCHESTRATOR_SYSTEM_PROMPT`) zien er solide uit.
+
+### 🎨 Frontend Developer
+**Perspectief:** UI implementatie, feedback loops, React state.
+
+*   **Pros:**
+    *   **Store Integration:** Uitbreiding van `SwiftStore` is logisch.
+    *   **Reflex Snelheid:** Client-side regex betekent instant feedback (<20ms), wat de UX enorm verbetert.
+*   **Cons:**
+    *   **UI Complexiteit:** Het visualiseren van "Stacked Cards" voor multi-intents is nieuw. Hoe tonen we de voortgang van "Actie 1 klaar, Actie 2 bezig"?
+    *   **Optimistic UI:** Bij L1 kunnen we optimistisch updaten. Bij L2 moeten we wachten. Deze hybride UX (soms direct, soms laden) kan inconsistent voelen als de transities niet soepel zijn.
+*   **Vraag:** Moeten we de "Reflex" logica niet in een Web Worker draaien om de main thread vrij te houden, of is de regex simpel genoeg? (Waarschijnlijk simpel genoeg).
+
+### 🧘 UX Designer / Product Owner
+**Perspectief:** Gebruikerswaarde, duidelijkheid, "Magic" factor.
+
+*   **Pros:**
+    *   **Killer Feature:** Multi-intent ("Zeg af en email") is een enorme meerwaarde die de gebruiker tijd bespaart.
+    *   **Proactivity:** De Safety Net suggesties ("Wondcontrole inplannen?") transformeren het systeem van typemachine naar partner.
+    *   **No Dead Ends:** Het doel "Nooit 'ik snap het niet' zeggen" is perfect.
+*   **Cons / Risico's:**
+    *   **Uncanny Valley:** Als L1 "dom" voelt en L2 "slim", snapt de gebruiker dan wanneer hij tegen wie praat?
+    *   **Over-proactive:** Te veel Safety Net suggesties worden irritant (Clippy effect). "Wil je dit opslaan?" "Wil je dat doen?".
+*   **Advies:** Start Safety Net met zeer conservatieve regels. Alleen medisch kritieke suggesties, geen administratieve "nagging".
+
+### 🧪 QA Engineer / Tester
+**Perspectief:** Testbaarheid, betrouwbaarheid.
+
+*   **Pros:**
+    *   **L1 is testbaar:** Regex is 100% voorspelbaar -> Unit tests zijn makkelijk.
+*   **Cons:**
+    *   **L2 is non-deterministisch:** AI output kan variëren. Hoe schrijven we E2E tests voor "Slimme interpretatie"?
+    *   **Context Matrix:** De hoeveelheid combinaties van Context * Input is enorm.
+*   **Advies:** We hebben een "Golden Dataset" nodig van 50+ complexe zinnen die we periodiek tegen de Orchestrator draaien om regressie (dommer worden) te meten.
+
+---
+
+## 3. Wat ontbreekt er / Moet erbij?
+
+1.  **Rate Limiting & Cost Guard:** Er is geen mechanisme beschreven om misbruik of "runaway loops" (AI blijft zichzelf aanroepen) te voorkomen.
+    *   *Actie:* Toevoegen aan architectuur (o.a. max requests per minuut per user).
+2.  **Telemetry & Feedback Loop:** Hoe weten we of de AI fout zit?
+    *   *Actie:* Voeg een simpele "Thumbs up/down" of "Undo" event tracking toe aan de IntentChain. Dit is cruciaal om de prompts te verbeteren.
+3.  **Offline Mode:** Wat doet L2 (Orchestrator) als er geen internet is?
+    *   *Actie:* Expliciete fallback: "Je bent offline. Alleen basiscommando's (L1) werken nu."
+
+## 4. Wat kan er (voor nu) af?
+
+1.  **"Severity" Sentiment Analysis** in `ExtractedEntities`:
+    *   *Waarom:* Leuk, maar niet essentieel voor MVP. Maakt de prompt complexer en duurder. Eerst focussen op feit-extractie.
+2.  **Complex Rollback Support:**
+    *   *Waarom:* Het engineeren van een "Undo" voor een database-write of email-send is erg complex.
+    *   *Alternatief:* Vraag gewoon bevestiging vooraf bij destructieve acties (zoals ook beschreven), dat is genoeg voor V2.
+
+## 5. Eindoordeel Haalbaarheid
+
+| Onderdeel | Haalbaarheid | Complexiteit |
+|-----------|--------------|--------------|
+| Layer 1 (Reflex) | ⭐⭐⭐⭐⭐ (Hoog) | Laag |
+| Layer 2 (Orchestrator) | ⭐⭐⭐⭐ (Goed) | Middel |
+| Layer 3 (Safety Net) | ⭐⭐⭐⭐ (Goed) | Laag (als we simpel beginnen) |
+| Multi-Intent Frontend | ⭐⭐⭐ (Uitdagend) | Hoog (UI flows) |
+
+**Advies:** Start direct met **Fase 1 (Reflex + Basic Orchestrator)**. Schuif Layer 3 (Safety Net) naar de volgende sprint om focus te houden op de core flow.
+
+## 6. Concretie Actiepunten
+
+Op basis van de bovenstaande analyse zijn dit de direct uit te voeren acties voor het team:
+
+| Prio | Domein | Actie | Eigenaar |
+|------|--------|-------|----------|
+| 🔴 **Prio 1** | **Architectuur** | **Rate Limiting toevoegen**: Bescherm tegen LLM-kosten explosies (max req/min). | Architect / Backend |
+| 🔴 **Prio 1** | **Backend** | **Error Fallback Strategie**: Wat gebeurt er als Claude 500't? (Fallback naar L1 of error msg). | Backend |
+| 🟡 **Prio 2** | **QA** | **Golden Dataset**: Stel een lijst samen van 50 test-zinnen voor regressietests. | QA / PO |
+| 🟡 **Prio 2** | **Frontend** | **Feedback Loop**: Voeg simpele 👍/👎 toe bij AI-acties voor latere analyse. | Frontend |
+| 🟢 **Prio 3** | **Frontend** | **Offline Mode**: Detecteer connection loss en forceer L1-only modus. | Frontend |
+| 🟢 **Prio 3** | **Scope** | **Schrappen**: Verwijder 'Severity Analysis' uit de prompt (te complex voor nu). | Backend / PO |
+| 🟢 **Prio 3** | **Scope** | **Schrappen**: Verwijder complexe 'Rollback' logica, vertrouw op confirmatie-dialogen. | Architect |
--- a/docs/intent/ux-evaluation-intent-scalability.md
+++ b/docs/intent/ux-evaluation-intent-scalability.md
@@ -0,0 +1,69 @@
+# UX Evaluatie: Intent System Schaalbaarheid
+
+**Betreft:** Evaluatie van `architecture-intent-scalability.md` vanuit gebruikersperspectief.  
+**Deelnemers:** Product Owner (PO), UX Designer (UX), Klantvertegenwoordiger (Klant).
+
+---
+
+## 1. Simulatie Gesprek
+
+**PO:** "Bedankt dat jullie er zijn. Tech heeft een plan gemaakt voor de schaalbaarheid van ons 'Intent System'. Kort gezegd: we gaan van 7 naar 35+ intents. Om dit snel te houden, adviseren de developers **Strategie 1: Een strikte hiërarchie**. Eerst bepalen we de categorie (bijv. 'Agenda' of 'Medicatie'), en dan pas de specifieke actie. Ze zeggen dat dit de performance met factor 5 verbetert. Klinkt goed, toch?"
+
+**UX:** "Ho even. 'Performance' met factor 5... waar hebben we het over? Milliseconden?"
+
+**PO:** "Eh, ja. Ze zeggen dat het teruggaat van 50ms naar 10ms."
+
+**UX:** *Zucht.* "Voor een gebruiker is 50ms al 'direct'. Het menselijk brein neemt alles onder de 100ms waar als instant. Gaan we hier een complex hiërarchisch systeem bouwen om 40ms te winnen die niemand voelt? Mijn zorg is de rigiditeit. Wat als een gebruiker zegt: *'Plan wondzorg in voor morgen'*?"
+
+**Klant:** "Precies. Dat is een dagelijkse zin. Is dat 'Planning' (agenda) of 'Zorg' (wondzorg)?"
+
+**PO:** "In het technisch voorstel zou dat waarschijnlijk onder 'Planning' vallen, omdat het woord 'plan' erin zit. Maar als het systeem denkt dat het 'Zorg' is, vindt hij nooit de intent 'afspraak maken'."
+
+**Klant:** "Als dat gebeurt, haken mijn mensen af. Ze gaan niet leren praten zoals de computer. Als ze twee keer 'Ik begrijp het niet' krijgen, typen ze het wel met de hand. En dan is de hele winst van dit spraaksysteem weg."
+
+**UX:** "Dat is mijn punt. Een hiërarchie introduceert een **extra faalpunt**: de categorie-detectie. Als die fout is, is alles fout. Ik keek naar dat document en zag **Strategie 4: Compositional Intents** staan. Dat gaat over 'Actie' + 'Onderwerp'. Dat klinkt veel meer zoals mensen praten."
+
+**PO:** "Klopt, maar tech zegt dat Strategie 4 'refactoring' vereist en complexer is om te bouwen."
+
+**UX:** "Mag ik heel eerlijk zijn? We bouwen een 'Next Gen' EPD. Als we kiezen voor de makkelijkste technische oplossing die resulteert in een domme bot, falen we. Ik heb liever dat het 200ms duurt (nog steeds snel) en dat hij *alles* snapt, dan dat hij in 10ms de verkeerde categorie kiest."
+
+**Klant:** "Eens. Wat staat er nog meer in? Iets met AI?"
+
+**PO:** "Ja, **Strategie 5: Hybrid AI**. Daar gebruiken we een klein AI-model om de categorie te bepalen, en dan lokale logica voor de details. Dat duurt wel iets langer, ongeveer 100ms."
+
+**UX:** "Kijk, dat wordt interessant! 100ms is nog steeds perfect binnen de UX-grenzen van 'responsief'. Maar een AI is veel slimmer in context begrijpen dan een lijstje trefwoorden. Als iemand zegt: *'Ik moet even kwijt dat Jan vandaag erg onrustig was tijdens het wassen'*, snapt een AI dat dit 'Rapportage' is, terwijl een zoekwoord-systeem misschien struikelt over 'wassen' en denkt dat het een taak is."
+
+**Klant:** "Wat kost dat? Die AI tokens?"
+
+**PO:** "Dat is een puntje. Lokale regex is gratis. AI kost geld per bericht. Maar we hebben het over kleine modelletjes (Haiku), dus de kosten vallen mee."
+
+**Klant:** "Luister, een verpleegkundige kost 40 euro per uur. Als ze per dag 10 minuten besparen door vlekkeloze spraaksturing, mag dat systeem van mij best een paar cent per dag kosten. Betrouwbaarheid boven alles."
+
+**UX:** "Conclusie voor mij: Die 'Strategie 1' (Hiërarchie op regex basis) voelt als *premature optimization*. Ze optimaliseren voor processortijd, niet voor gebruikerservaring. Ik stel voor dat we inzetten op flexibiliteit."
+
+**PO:** "Dus jullie zeggen: focus niet op de pure snelheidswinst van Strategie 1, maar op de 'begrijpelijkheid' van Strategie 4 of 5?"
+
+**UX:** "Ja. En ik wil een 'Fail-safe' garantie. Als het hiërarchische systeem twijfelt, mag het niet zeggen 'snap ik niet'. Dan moet het doorschakelen naar die bredere AI. De gebruiker mag *nooit* last hebben van onze database-structuur."
+
+---
+
+## 2. Synthese & Advies
+
+Op basis van de evaluatie is dit de aanbevolen `User-Centric Architecture` koers:
+
+### 1. Verwerp mic-optimalisatie ten koste van UX
+Het verschil tussen 12ms en 50ms is irrelevant voor de eindgebruiker, maar een foutieve classificatie is fataal voor het vertrouwen. De "Recommended" status van **Strategie 1 (Strict Hierarchical)** wordt afgewezen als stand-alone oplossing.
+
+### 2. Kies voor de Hybride Route (Strategie 5 + 1)
+We adviseren een gelaagd model dat betrouwbaarheid voorop stelt:
+*   **Layer 1 (Lokaal/Snel):** Gebruik high-confidence regex patrons voor overduidelijke commando's (b.v. "Maak afspraak" = Agenda). Dit vangt 80% af met 0ms latency.
+*   **Layer 2 (AI Router):** Bij twijfel (conflicterende patterns) of complexe zinnen (b.v. "Plan wondzorg"), schakel direct door naar de AI Router (Strategie 5). De 100ms latency is acceptabel.
+
+### 3. Lange Termijn: Compositional Thinking (Strategie 4)
+De backend moet idealiter toe naar **Strategie 4 (Actie + Onderwerp)**.
+*   Gebruikers denken in `Actie` (plannen, stoppen, starten) op een `Subject` (medicatie, afspraak).
+*   Dit is robuuster dan rigide categorieën.
+
+### 4. Actiepunten
+1.  **UX Validatie Set:** Maak een lijst van 50 "dubbelzinnige" zinnen die categorieën kruisen (zoals "Plan wondzorg"). Test het systeem hiertegen.
+2.  **Safety Net:** Implementeer de regel: *"Bij twijfel onder de 0.8 confidence -> Altijd AI Fallback gebruiken"*. Beter iets trager en goed, dan snel en fout.
--- a/docs/intent/ux-simulation-intent-next-level.md
+++ b/docs/intent/ux-simulation-intent-next-level.md
@@ -0,0 +1,83 @@
+# UX Simulatie: Intent System "Next Level"
+
+**Betreft:** Brainstormsessie voor de volgende fase van de Swift Intent Architectuur.
+**Doel:** Het systeem transformeren van "Command-Response" naar "Proactive Assistant".
+**Deelnemers:**
+*   **PO (Product Owner):** Focus op waarde, haalbaarheid en roadmap.
+*   **UX (UX Specialist):** Focus op interactie, vertrouwen en de "Invisible Interface".
+*   **Vpk (Verpleegkundige):** Focus op snelheid, handen-vrij werken, administratieve lastenverlichting.
+*   **Psych (Psycholoog):** Focus op nuance, cliënt-context, emotionele lading en rapportage.
+*   **Regie (Psychiater/Regiebehandelaar):** Focus op veiligheid, medicatie, complexiteit en het grote plaatje.
+
+---
+
+## 1. De Huidige Stand van Zaken
+
+**PO:** "Welkom allen. Even een recap: ons huidige systeem is *snel*. We snappen commando's als 'Maak afspraak' en 'Schrijf dagnotitie' binnen 100ms. De basis staat. Maar Colin en ik willen weten: wat is het *volgende niveau*? Waar lopen jullie in de praktijk nog tegenaan?"
+
+**Vpk:** "Het is snel, ja. Maar het voelt nog wel als een *computer*. Ik moet commando's geven. Als ik een cliënt heb gewassen en een wond heb verzorgd, moet ik zeggen: *'Maak notitie: wond verzorgd'* én daarna *'Plan wondcontrole over 3 dagen'*. Waarom snapt hij niet dat bij een 'vochtige wond' er *altijd* een controle hoort?"
+
+**UX:** "Interessant. Je wilt toe naar **impliciete intents**. Het systeem moet snappen dat Actie A vaak Actie B impliceert."
+
+## 2. Diepgang & Context (De Psycholoog)
+
+**Psych:** "Mij gaat het om de inhoud. Ik spreek cliënten die suïcidaal kunnen zijn. Als ik dicteer: *'Cliënt oogt somber, spreekt over uitzichtloosheid'*, dan wil ik niet dat Swift alleen maar zegt: 'Notitie opgeslagen'. Ik wil dat hij met me meedenkt. 'Moet ik het signaleringsplan updaten?' of 'Wil je de crisisdienst bellen?'."
+
+**PO:** "Oef, dat is spannend. Dan gaan we van 'uitvoeren' naar 'adviseren'. Durven we dat aan qua liability?"
+
+**Regie:** "We *moeten* dat aandurven, als 'Safety Net'. Kijk, ik schrijf medicatie voor. Als ik zeg: *'Start Lithium 400mg'*, dan verwacht ik dat Swift direct checkt: 'Hé, de laatste nierfunctie is van 6 maanden geleden. Lab aanvragen?'. Nu is het systeem passief. Ik wil een **actieve partner**."
+
+## 3. Complexe Flows & Agentic Behavior
+
+**UX:** "We hebben het hier over een fundamentele shift.
+*   Niveau 1 (Nu): **Reactive**. Jij vraagt, wij draaien.
+*   Niveau 2 (Wens): **Agentic**. Het systeem *begrijpt* processen en *stelt voor*."
+
+**Vpk:** "En mag het ook minder 'gescheiden' zijn? Nu zit ik in 'Agenda modus' of 'Dossier modus'. Soms wil ik zeggen: *'Jan voelt zich niet lekker, ik meld hem af voor therapie en bel zijn huisarts'*. Dat zijn drie dingen: Notitie, Agenda wijziging, Taak aanmaken. Nu struikelt Swift daarover."
+
+**PO:** "Multi-intent support. Dat staat op de backlog, maar is technisch pittig."
+
+**UX:** "Voor de gebruiker bestaat er geen backlog. Voor de gebruiker is het één handeling: 'Reageer op situatie Jan'. Als wij ze dwingen dat op te knippen in drie spraakopdrachten, zijn we een obstakel."
+
+**Regie:** "Precies. 'Ontlasten' betekent dat ik mijn *intentie* uitspreek, niet mijn *administratie*. Mijn intentie is 'Zorg voor Jan regelen'. De administratie (agenda, brief, notitie) is jullie probleem."
+
+## 4. Nuance & "Smart Patterns"
+
+**Psych:** "Nog iets kleins: toon. Als ik een notitie maak over een agressie-incident, is mijn stemgebruik anders. Kan Swift dat niet markeren? 'Let op: emotionele lading hoog'. En dat hij dat bij de overdracht aan de avonddienst highlight?"
+
+**UX:** "Sentiment analysis als metadata bij intents. Heel vet. Dan wordt de intent 'Maak notitie' verrijkt met `severity: high`."
+
+**Vpk:** "En alsjeblieft, stop met die eindeloze bevestigingsvragen voor dingen die ik elke dag doe. Als ik zeg 'Rapportage ADL ok', hoef ik niet te horen 'Wil je een rapportage maken met tekst ADL ok?'. Ja, natuurlijk. *Just do it*."
+
+**PO:** "Klinkt als 'Adaptive Confidence'. Als je iets vaak doet, hoeft het systeem minder te vragen."
+
+---
+
+## 5. Synthese: Het Nieuwe "Level"
+
+Op basis van dit gesprek identificeren we drie pijlers voor de optimalisatie:
+
+### Pijler 1: Chain of Thought & Multi-Intents
+De gebruiker denkt niet in silo's.
+*   **Use Case:** "Zeg afspraak af en maak notitie dat hij ziek is."
+*   **Oplossing:** Een "Orchestrator" die de zin opsplitst en meerdere intents parallel of sequentieel afvuurt.
+
+### Pijler 2: Context-Aware Proactivity (The Safety Net)
+Swift moet "weten" wat medisch logisch is.
+*   **Use Case:** "Start medicatie X" -> Systeem checkt lab/interacties. "Wond verzorgd" -> Systeem suggereert vervolgafspraak.
+*   **Oplossing:** `Intent Triggers`. Een intent kan een *andere* intent triggeren als suggestie (een "Follow-up Action").
+
+### Pijler 3: Adaptive & Invisible Interface
+Minder frictie voor power users.
+*   **Use Case:** Geen bevestiging voor routine-taken, wel voor afwijkende zaken.
+*   **Oplossing:** User-specific confidence thresholds. Het systeem leert wat *jij* normaal vindt.
+
+---
+
+## 6. Advies aan Tech (Colin)
+
+1.  **Bouw een 'Intent Chainer':** Support voor `[Intent A] AND [Intent B]` in één uiting.
+2.  **Implementeer 'Follow-up Suggestions':** Na succesvolle afronding van Intent A, kan de UI (of spraak) direct vragen: "Wil je ook Intent B doen?" (o.b.v. regels of AI).
+3.  **Context Injectie:** De intent-classifier moet niet alleen de *zin* krijgen, maar ook de *huidige cliënt-status* (bijv. "Laatste labwaardes", "Openstaande agenda"). Dit maakt de AI slimmer zonder trager te worden.
+
+**UX Conclusie:** "We stoppen met het bouwen van een 'Spraakgestuurd Toetsenbord'. We gaan bouwen aan een **AI Collega**."