From c0a4fa24f252c1b84656fcf62e6a6153dd941ccf Mon Sep 17 00:00:00 2001 From: colinislit Date: Thu, 9 Jul 2026 23:16:28 +0200 Subject: [PATCH] docs: architectuurdocs, styleguides en release notes intake/behandelplan Co-Authored-By: Claude Fable 5 --- .../enterprise-componenten-uitbreiding.md | 1734 +++++++++++++++++ .../enterprise-epd-architectuur.md | 1619 +++++++++++++++ .../intent-system-architecture.md | 1073 ++++++++++ .../intent-system-architectuur-nl.md | 1101 +++++++++++ docs/architecture/overzicht-po-pm.html | 287 +++ docs/architecture/overzicht-po-pm.md | 170 ++ .../platform-connectiviteit-selfhosted.md | 1175 +++++++++++ docs/architecture/tech-stack-onderzoek.md | 494 +++++ .../technische-invulling-componenten.md | 1461 ++++++++++++++ .../usecases-technische-componenten.md | 864 ++++++++ .../RELEASE_INTAKE_BEHANDELPLAN.md | 129 ++ .../Release_Intake_Behandelplan.docx | Bin 0 -> 675600 bytes docs/styleguide-ux.md | 433 ++++ docs/swift/cortex-architectuur-analyse.md | 1514 ++++++++++++++ docs/visuele-styleguide.md | 89 + 15 files changed, 12143 insertions(+) create mode 100644 docs/architecture/enterprise-componenten-uitbreiding.md create mode 100644 docs/architecture/enterprise-epd-architectuur.md create mode 100644 docs/architecture/intent-system-architecture.md create mode 100644 docs/architecture/intent-system-architectuur-nl.md create mode 100644 docs/architecture/overzicht-po-pm.html create mode 100644 docs/architecture/overzicht-po-pm.md create mode 100644 docs/architecture/platform-connectiviteit-selfhosted.md create mode 100644 docs/architecture/tech-stack-onderzoek.md create mode 100644 docs/architecture/technische-invulling-componenten.md create mode 100644 docs/architecture/usecases-technische-componenten.md create mode 100644 docs/releasenotes/RELEASE_INTAKE_BEHANDELPLAN.md create mode 100644 docs/releasenotes/Release_Intake_Behandelplan.docx create mode 100644 docs/styleguide-ux.md create mode 100644 docs/swift/cortex-architectuur-analyse.md create mode 100644 docs/visuele-styleguide.md diff --git a/docs/architecture/enterprise-componenten-uitbreiding.md b/docs/architecture/enterprise-componenten-uitbreiding.md new file mode 100644 index 0000000..f75741a --- /dev/null +++ b/docs/architecture/enterprise-componenten-uitbreiding.md @@ -0,0 +1,1734 @@ +# Enterprise Componenten Uitbreiding — Voorbereiding & Interfaces + +> **Type**: Architectuur Specificatiedocument +> **Versie**: 1.0 +> **Datum**: 2026-02-14 +> **Doelgroep**: LLM-agents, developers, architecten +> **Taal**: Nederlands (tekst), Engels (technische termen en code) +> **Relatie**: Uitbreiding op `usecases-technische-componenten.md` — voegt 10 nieuwe componenten toe (C34–C43) +> **Status**: Voorbereiding — interfaces en integratiepunten gedefinieerd, nog niet gebouwd + +--- + +## Leeswijzer + +Dit document beschrijft 10 aanvullende technische componenten die nodig zijn voor een enterprise-ready EPD. Ze zijn nog **niet gebouwd**, maar de architectuur is zo voorbereid dat ze naadloos ingepast kunnen worden: + +- **Interface definities** — TypeScript interfaces die de contracten vastleggen +- **Database schema** — Tabellen die aangemaakt kunnen worden wanneer nodig +- **Integratiepunten** — Hoe elk component aansluit op bestaande componenten (C01–C33) +- **Technologiekeuzes** — Welke libraries/tools en waarom +- **Fasering** — Wanneer bouwen in relatie tot het bouwplan + +De componenten volgen de nummering uit `usecases-technische-componenten.md` (C34+). + +--- + +## Component Overzicht + +``` +LAAG 6: PLATFORM SERVICES (nieuw) +├── C34 Notificatie Service (in-app + email + escalatie) +├── C35 Workflow Engine (state machine voor klinische workflows) +├── C36 Full-Text Search Service (klinische notities doorzoeken) +├── C37 Caching Layer (AI responses, API responses, sessiedata) +├── C38 Scheduled Jobs Service (BullMQ repeatable jobs) +└── C39 Webhook System (outbound event webhooks) + +LAAG 7: EXTERNE INTEGRATIES (nieuw) +├── C40 ZPM Facturatie Service (Zorgprestatiemodel) +├── C41 Vecozo Connector (voorbereiding) +└── C42 Zorgdomein Connector (voorbereiding) + +LAAG 8: ANALYTICS (nieuw) +└── C43 BI Module (materialized views, data-export) +``` + +### Prioriteit & fasering + +| Component | Prioriteit | Bouwfase | Reden | +|-----------|-----------|----------|-------| +| C34 Notificatie | Must-have | Fase 2 (EPD core) | Overdracht, shifts, escalaties | +| C35 Workflow Engine | Must-have | Fase 2 | Intake, behandelplan, Wvggz | +| C36 Full-Text Search | Should-have | Fase 3 | Zoeken in rapportage, overdracht | +| C37 Caching | Should-have | Fase 2 | Performance, AI cost reductie | +| C38 Scheduled Jobs | Must-have | Fase 1 (fundament) | Audit cleanup, protocol sync, facturatie | +| C39 Webhook System | Should-have | Fase 4 (connectiviteit) | Connector events, externe integraties | +| C40 ZPM Facturatie | Must-have | Fase 3 | Inkomsten, wettelijk verplicht | +| C41 Vecozo | Later | Fase 4+ | Pas als EPD core stabiel is | +| C42 Zorgdomein | Later | Fase 4+ | Pas als EPD core stabiel is | +| C43 BI Module | Should-have | Fase 5 | Management rapportages | + +--- + +## C34 — Notificatie Service + +### Doel + +Centraal systeem voor alle notificaties: in-app meldingen, email, en escalatieketens. Elke service in het systeem stuurt notificaties via dit component — geen directe email of push vanuit business logic. + +### Waarom nodig + +- Overdracht: melden dat AI-samenvatting klaar is +- Shifts: herinnering aan overdracht, ongelezen rapportages +- Incidenten: escalatie naar teamleider als MIC-melding niet afgehandeld +- Wvggz: wettelijke termijnen die aflopen (dwangmaatregel verlenging) +- Medicatie: herinneringen aan medicatie-evaluaties +- Protocol Engine: nudges die niet in-app getoond konden worden + +### Interface + +```typescript +// lib/notifications/types.ts + +type NotificationChannel = 'in_app' | 'email' | 'both'; +type NotificationPriority = 'low' | 'normal' | 'high' | 'urgent'; +type NotificationCategory = + | 'overdracht' + | 'shift' + | 'incident' + | 'wvggz_termijn' + | 'medicatie' + | 'behandelplan' + | 'protocol_nudge' + | 'systeem' + | 'taak'; + +interface NotificationPayload { + recipientUserId: string; + tenantId: string; + category: NotificationCategory; + priority: NotificationPriority; + channel: NotificationChannel; + title: string; // NL, max 120 chars + body: string; // NL, max 500 chars + actionUrl?: string; // Deep link naar EPD pagina + relatedPatientId?: string; // Voor audit trail koppeling + relatedEntityType?: string; // 'report' | 'appointment' | 'treatment_plan' + relatedEntityId?: string; + metadata?: Record; + expiresAt?: Date; // Automatisch opruimen +} + +interface NotificationPreferences { + userId: string; + tenantId: string; + channelDefaults: Record; + quietHours?: { start: string; end: string }; // "22:00" - "07:00" + emailDigest: 'immediate' | 'hourly' | 'daily' | 'off'; +} + +interface EscalationRule { + id: string; + tenantId: string; + category: NotificationCategory; + triggerCondition: string; // bv. "unread_after_minutes > 60" + escalateToRole: string; // bv. "teamleider" + escalateChannel: NotificationChannel; + maxEscalations: number; +} + +// Service interface +interface NotificationService { + send(payload: NotificationPayload): Promise<{ notificationId: string }>; + sendBulk(payloads: NotificationPayload[]): Promise<{ sent: number; failed: number }>; + markAsRead(notificationId: string, userId: string): Promise; + markAllAsRead(userId: string, category?: NotificationCategory): Promise; + getUnread(userId: string, limit?: number): Promise; + getUnreadCount(userId: string): Promise>; + updatePreferences(prefs: NotificationPreferences): Promise; + registerEscalationRule(rule: EscalationRule): Promise; +} +``` + +### Database schema + +```sql +-- Notificaties tabel +CREATE TABLE notifications ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + recipient_id UUID NOT NULL REFERENCES users(id), + category TEXT NOT NULL, + priority TEXT NOT NULL DEFAULT 'normal', + channel TEXT NOT NULL DEFAULT 'in_app', + title TEXT NOT NULL, + body TEXT NOT NULL, + action_url TEXT, + related_patient_id UUID REFERENCES patients(id), + related_entity_type TEXT, + related_entity_id UUID, + metadata JSONB DEFAULT '{}', + read_at TIMESTAMPTZ, + sent_at TIMESTAMPTZ DEFAULT NOW(), + expires_at TIMESTAMPTZ, + created_at TIMESTAMPTZ DEFAULT NOW() +); + +-- Indexes voor snelle queries +CREATE INDEX idx_notifications_recipient_unread + ON notifications (recipient_id, read_at) + WHERE read_at IS NULL; + +CREATE INDEX idx_notifications_tenant_category + ON notifications (tenant_id, category, created_at DESC); + +-- RLS: gebruiker ziet alleen eigen notificaties +ALTER TABLE notifications ENABLE ROW LEVEL SECURITY; + +CREATE POLICY notifications_own ON notifications + FOR ALL USING ( + tenant_id = current_setting('app.current_tenant_id')::UUID + AND recipient_id = current_setting('app.current_user_id')::UUID + ); + +-- Voorkeuren per gebruiker +CREATE TABLE notification_preferences ( + user_id UUID NOT NULL REFERENCES users(id), + tenant_id UUID NOT NULL REFERENCES tenants(id), + channel_defaults JSONB NOT NULL DEFAULT '{}', + quiet_hours_start TIME, + quiet_hours_end TIME, + email_digest TEXT NOT NULL DEFAULT 'immediate', + updated_at TIMESTAMPTZ DEFAULT NOW(), + PRIMARY KEY (user_id, tenant_id) +); + +-- Escalatie regels per tenant +CREATE TABLE escalation_rules ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + category TEXT NOT NULL, + trigger_condition TEXT NOT NULL, + escalate_to_role TEXT NOT NULL, + escalate_channel TEXT NOT NULL DEFAULT 'both', + max_escalations INT NOT NULL DEFAULT 3, + active BOOLEAN DEFAULT TRUE, + created_at TIMESTAMPTZ DEFAULT NOW() +); +``` + +### Integratiepunten + +| Bestaand component | Integratie | +|-------------------|------------| +| C10 Protocol Engine | Nudges die niet in-app getoond worden → notificatie | +| C15 Rapportage Service | Nieuwe rapportage voor overdracht → notificatie aan team | +| C16 Overdracht Service | AI-samenvatting gereed → notificatie | +| C17 Agenda Service | Afspraakherinnering → notificatie | +| C22 Toestemming Service | Wvggz termijn nadert → escalatie notificatie | +| C25 RBAC + ABAC | Escalatie naar rol, niet naar specifieke persoon | +| C38 Scheduled Jobs | Periodieke digest emails, escalatie checks | + +### Technologiekeuze + +- **In-app**: Server-Sent Events (SSE) vanuit Next.js API route — simpeler dan WebSockets, voldoende voor notificaties +- **Email**: Postal (self-hosted, D19) via BullMQ job queue +- **Escalatie**: BullMQ delayed jobs — check na X minuten of notificatie gelezen is + +### Trade-offs + +| Keuze | Alternatief | Rationale | +|-------|------------|-----------| +| SSE voor real-time | WebSockets | Eenvoudiger, minder infra, unidirectioneel is voldoende | +| Escalatie via BullMQ | Aparte escalatie service | Hergebruik bestaande infra (C38), KISS | +| Notificatie in PostgreSQL | Aparte message store (Redis) | Eén bron van waarheid, auditbaar, RLS | + +--- + +## C35 — Workflow Engine (State Machine) + +### Doel + +Generieke state machine die klinische workflows bestuurt: intake-trajecten, behandelplannen, Wvggz-procedures, MIC-meldingen. Dwingt af dat stappen in de juiste volgorde gebeuren, door de juiste rollen, binnen wettelijke termijnen. + +### Waarom nodig + +- **Intake**: Aanmelding → Triage → Diagnostiek → Behandelplan → Start behandeling +- **Wvggz**: Verzoekschrift → Beoordeling → Machtiging → Uitvoering → Evaluatie (wettelijke termijnen!) +- **MIC-melding**: Registratie → Analyse → Maatregelen → Evaluatie → Afsluiting +- **Behandelplan**: Concept → Review → Akkoord patiënt → Actief → Evaluatie +- **Ontslag**: Voorbereiding → Nazorgplan → Overdracht → Ontslag + +### Interface + +```typescript +// lib/workflow/types.ts + +interface WorkflowDefinition { + id: string; + name: string; // bv. "intake_ggz" + version: number; + tenantId: string | null; // null = systeembreed + states: WorkflowState[]; + transitions: WorkflowTransition[]; + initialState: string; + terminalStates: string[]; +} + +interface WorkflowState { + name: string; // bv. "triage", "diagnostiek" + label: string; // NL label: "Triage" + requiredRole?: string; // Welke rol mag in deze state werken + maxDurationDays?: number; // Wettelijke of interne deadline + onEnter?: WorkflowAction[]; // Acties bij betreden state + onExit?: WorkflowAction[]; // Acties bij verlaten state + requiredFields?: string[]; // Welke velden ingevuld moeten zijn +} + +interface WorkflowTransition { + from: string; + to: string; + trigger: string; // bv. "approve", "reject", "timeout" + requiredRole?: string; // Wie mag deze transitie uitvoeren + guard?: string; // Conditie (bv. "all_required_fields_filled") + actions?: WorkflowAction[]; // Acties bij transitie +} + +interface WorkflowAction { + type: 'notify' | 'create_task' | 'update_field' | 'escalate' | 'audit_log'; + config: Record; +} + +interface WorkflowInstance { + id: string; + workflowDefinitionId: string; + tenantId: string; + entityType: string; // 'intake' | 'behandelplan' | 'wvggz' | 'mic_melding' + entityId: string; // ID van het gerelateerde object + currentState: string; + stateHistory: StateTransitionRecord[]; + createdAt: Date; + updatedAt: Date; + completedAt: Date | null; +} + +interface StateTransitionRecord { + fromState: string; + toState: string; + trigger: string; + userId: string; + timestamp: Date; + comment?: string; + metadata?: Record; +} + +// Service interface +interface WorkflowService { + // Definitie beheer + registerDefinition(def: WorkflowDefinition): Promise; + getDefinition(name: string, version?: number): Promise; + + // Instance beheer + startWorkflow(params: { + definitionName: string; + entityType: string; + entityId: string; + tenantId: string; + initiatorUserId: string; + }): Promise; + + transition(params: { + instanceId: string; + trigger: string; + userId: string; + comment?: string; + }): Promise; + + getCurrentState(instanceId: string): Promise; + getAvailableTransitions(instanceId: string, userId: string): Promise; + getInstancesByEntity(entityType: string, entityId: string): Promise; + + // Deadline monitoring + getOverdueInstances(tenantId: string): Promise; +} +``` + +### Database schema + +```sql +-- Workflow definities (versioned) +CREATE TABLE workflow_definitions ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + name TEXT NOT NULL, + version INT NOT NULL DEFAULT 1, + tenant_id UUID REFERENCES tenants(id), -- NULL = systeembreed + definition JSONB NOT NULL, -- Volledige WorkflowDefinition + active BOOLEAN DEFAULT TRUE, + created_at TIMESTAMPTZ DEFAULT NOW(), + UNIQUE(name, version, tenant_id) +); + +-- Workflow instances +CREATE TABLE workflow_instances ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + workflow_def_id UUID NOT NULL REFERENCES workflow_definitions(id), + tenant_id UUID NOT NULL REFERENCES tenants(id), + entity_type TEXT NOT NULL, + entity_id UUID NOT NULL, + current_state TEXT NOT NULL, + completed_at TIMESTAMPTZ, + created_at TIMESTAMPTZ DEFAULT NOW(), + updated_at TIMESTAMPTZ DEFAULT NOW() +); + +CREATE INDEX idx_workflow_instances_entity + ON workflow_instances (entity_type, entity_id); + +CREATE INDEX idx_workflow_instances_state + ON workflow_instances (tenant_id, current_state) + WHERE completed_at IS NULL; + +-- State transitie historie (immutable) +CREATE TABLE workflow_transitions_log ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + instance_id UUID NOT NULL REFERENCES workflow_instances(id), + from_state TEXT NOT NULL, + to_state TEXT NOT NULL, + trigger TEXT NOT NULL, + user_id UUID NOT NULL REFERENCES users(id), + comment TEXT, + metadata JSONB DEFAULT '{}', + created_at TIMESTAMPTZ DEFAULT NOW() +); + +-- Immutable: geen UPDATE of DELETE +CREATE RULE workflow_transitions_no_update AS + ON UPDATE TO workflow_transitions_log DO INSTEAD NOTHING; +CREATE RULE workflow_transitions_no_delete AS + ON DELETE TO workflow_transitions_log DO INSTEAD NOTHING; + +-- RLS +ALTER TABLE workflow_instances ENABLE ROW LEVEL SECURITY; +ALTER TABLE workflow_transitions_log ENABLE ROW LEVEL SECURITY; + +CREATE POLICY workflow_instances_tenant ON workflow_instances + FOR ALL USING (tenant_id = current_setting('app.current_tenant_id')::UUID); + +CREATE POLICY workflow_transitions_tenant ON workflow_transitions_log + FOR ALL USING ( + instance_id IN ( + SELECT id FROM workflow_instances + WHERE tenant_id = current_setting('app.current_tenant_id')::UUID + ) + ); +``` + +### Voorgedefinieerde workflows + +```typescript +// lib/workflow/definitions/intake-ggz.ts +const intakeGGZ: WorkflowDefinition = { + id: 'wf-intake-ggz', + name: 'intake_ggz', + version: 1, + tenantId: null, + initialState: 'aangemeld', + terminalStates: ['gestart', 'afgewezen'], + states: [ + { name: 'aangemeld', label: 'Aangemeld', maxDurationDays: 5, + onEnter: [{ type: 'notify', config: { category: 'taak', role: 'triagist' } }] }, + { name: 'triage', label: 'Triage', requiredRole: 'triagist', maxDurationDays: 3 }, + { name: 'diagnostiek', label: 'Diagnostiek', requiredRole: 'behandelaar', maxDurationDays: 14 }, + { name: 'behandelplan', label: 'Behandelplan opstellen', requiredRole: 'behandelaar', maxDurationDays: 7, + requiredFields: ['diagnose', 'behandeldoelen'] }, + { name: 'akkoord_patient', label: 'Akkoord patiënt', maxDurationDays: 5 }, + { name: 'gestart', label: 'Behandeling gestart' }, + { name: 'afgewezen', label: 'Afgewezen (doorverwijzing)' }, + ], + transitions: [ + { from: 'aangemeld', to: 'triage', trigger: 'start_triage', requiredRole: 'triagist' }, + { from: 'triage', to: 'diagnostiek', trigger: 'accept', requiredRole: 'triagist' }, + { from: 'triage', to: 'afgewezen', trigger: 'reject', requiredRole: 'triagist', + actions: [{ type: 'notify', config: { category: 'taak', message: 'Doorverwijsbrief opstellen' } }] }, + { from: 'diagnostiek', to: 'behandelplan', trigger: 'diagnose_complete', requiredRole: 'behandelaar' }, + { from: 'behandelplan', to: 'akkoord_patient', trigger: 'submit_plan', guard: 'all_required_fields_filled' }, + { from: 'akkoord_patient', to: 'gestart', trigger: 'patient_agrees' }, + { from: 'akkoord_patient', to: 'behandelplan', trigger: 'patient_disagrees' }, + ], +}; +``` + +### Integratiepunten + +| Bestaand component | Integratie | +|-------------------|------------| +| C10 Protocol Engine | Nudge kan workflow transitie suggereren | +| C15 Rapportage Service | MIC-melding start `mic_workflow` instance | +| C18 Behandelplan Service | Behandelplan lifecycle via workflow | +| C20 Intake Service | Intake trajectory via workflow | +| C22 Toestemming Service | Wvggz-procedure als workflow met wettelijke deadlines | +| C25 RBAC + ABAC | `requiredRole` in transitions → RBAC check | +| C26 Audit Trail | Elke transitie → audit log entry | +| C34 Notificatie | `onEnter`, `onExit`, transitie acties → notificaties | +| C38 Scheduled Jobs | Deadline monitoring: check dagelijks op `maxDurationDays` overschrijding | + +### Technologiekeuze + +- **Geen externe library**: State machine logica is ~200 regels TypeScript. XState is overkill voor server-side workflow. +- **Definities in code + database**: Systeem-workflows in code (version controlled), tenant-specifieke aanpassingen in database. +- **Transitie log immutable**: Net als audit trail — compliance vereist onveranderbare historie. + +--- + +## C36 — Full-Text Search Service + +### Doel + +Zoeken door klinische notities, rapportages en patiëntgegevens op basis van vrije tekst. Ondersteunt het intent "zoeken" (C06/C07) en de traditionele EPD zoekbalk. + +### Waarom nodig + +- Zorgverlener zoekt: "alle rapportages over agressie bij Jan Janssen afgelopen maand" +- Compliance officer zoekt: "alle incidenten met fixatie in 2025" +- Intent systeem: `zoeken` intent moet rapportages kunnen doorzoeken + +### Interface + +```typescript +// lib/search/types.ts + +interface SearchQuery { + tenantId: string; + query: string; // Vrije tekst, NL + filters?: { + entityTypes?: ('report' | 'patient' | 'appointment' | 'treatment_plan')[]; + patientId?: string; + dateRange?: { from: Date; to: Date }; + reportCategories?: string[]; + authorId?: string; + departmentId?: string; + }; + pagination?: { offset: number; limit: number }; + highlight?: boolean; // Markeer matches in resultaat +} + +interface SearchResult { + entityType: string; + entityId: string; + score: number; + title: string; + snippet: string; // Fragment met context + highlights?: string[]; // Gemarkeerde matches + metadata: { + patientName?: string; + authorName?: string; + createdAt: Date; + category?: string; + }; +} + +interface SearchResponse { + results: SearchResult[]; + total: number; + took: number; // milliseconds + query: string; +} + +// Service interface +interface SearchService { + search(query: SearchQuery): Promise; + indexDocument(params: { + entityType: string; + entityId: string; + tenantId: string; + content: string; + metadata: Record; + }): Promise; + removeDocument(entityType: string, entityId: string): Promise; + reindexAll(tenantId: string): Promise<{ indexed: number }>; +} +``` + +### Database schema + +```sql +-- Full-text search configuratie voor Nederlands +CREATE TEXT SEARCH CONFIGURATION dutch_medical (COPY = dutch); + +-- Medische synoniemen dictionary (uitbreidbaar) +-- In productie: custom dictionary file met medische termen +-- ALTER TEXT SEARCH CONFIGURATION dutch_medical +-- ALTER MAPPING FOR asciiword WITH dutch_medical_syn, dutch_stem; + +-- Search index op reports +ALTER TABLE reports ADD COLUMN IF NOT EXISTS + search_vector TSVECTOR + GENERATED ALWAYS AS ( + setweight(to_tsvector('dutch', coalesce(title, '')), 'A') || + setweight(to_tsvector('dutch', coalesce(content, '')), 'B') || + setweight(to_tsvector('dutch', coalesce( + structured_data->>'category', '' + )), 'C') + ) STORED; + +CREATE INDEX idx_reports_search ON reports USING GIN (search_vector); + +-- Search index op patients +ALTER TABLE patients ADD COLUMN IF NOT EXISTS + search_vector TSVECTOR + GENERATED ALWAYS AS ( + setweight(to_tsvector('dutch', coalesce(first_name, '')), 'A') || + setweight(to_tsvector('dutch', coalesce(last_name, '')), 'A') || + setweight(to_tsvector('dutch', coalesce(bsn, '')), 'A') + ) STORED; + +CREATE INDEX idx_patients_search ON patients USING GIN (search_vector); + +-- Zoekquery met ranking +-- Voorbeeld: zoek "agressie medicatie" in rapportages van een patiënt +-- SELECT id, title, +-- ts_rank_cd(search_vector, query) AS rank, +-- ts_headline('dutch', content, query, 'MaxWords=35, MinWords=15') AS snippet +-- FROM reports, +-- plainto_tsquery('dutch', 'agressie medicatie') query +-- WHERE search_vector @@ query +-- AND patient_id = $1 +-- AND tenant_id = current_setting('app.current_tenant_id')::UUID +-- AND deleted_at IS NULL +-- ORDER BY rank DESC +-- LIMIT 20; +``` + +### Integratiepunten + +| Bestaand component | Integratie | +|-------------------|------------| +| C06 Reflex / C07 Orchestrator | `zoeken` intent → SearchService.search() | +| C09 Action System | Search resultaten als block in canvas | +| C15 Rapportage Service | Bij create/update → automatisch geïndexeerd (GENERATED column) | +| C21 Patiënt Service | Patiënt zoeken → search_vector op patients | +| C24 Multi-tenancy | RLS op search queries: tenant_id filter | + +### Technologiekeuze + +- **PostgreSQL tsvector** (geen Elasticsearch): Eenvoudiger stack, geen extra service, voldoende voor GGZ-schaal (~100k-1M documenten) +- **GENERATED ALWAYS AS STORED**: Automatische index-update bij write, geen aparte indexer nodig +- **Nederlandse stemmer**: Ingebouwd in PostgreSQL, uitbreidbaar met medische synoniemen dictionary + +### Trade-offs + +| Keuze | Alternatief | Rationale | +|-------|------------|-----------| +| PostgreSQL tsvector | Elasticsearch, Meilisearch, Typesense | Geen extra service, voldoende voor verwacht volume | +| GENERATED column | Trigger-based indexing | Eenvoudiger, altijd in sync, geen race conditions | +| `ts_rank_cd` | Custom scoring | Standaard PostgreSQL, goed genoeg voor eerste iteratie | + +### Schaalgrens + +PostgreSQL full-text search werkt goed tot ~5M documenten. Als het systeem voorbij die grens groeit, kan Meilisearch (self-hosted, Rust, <100MB RAM) als drop-in replacement dienen zonder interface-wijzigingen. + +--- + +## C37 — Caching Layer + +### Doel + +Caching van dure operaties: AI-responses, API-responses, sessiedata, en veelgevraagde queries. Vermindert latency, kosten (minder AI API calls), en database load. + +### Waarom nodig + +- **AI kosten**: Dezelfde overdracht-samenvatting wordt meerdere keren bekeken → cache +- **Performance**: Patient zoekresultaten, dashboard aggregaties, agenda views +- **Protocol Engine**: RAG results cachen zodat dezelfde protocol-query niet steeds opnieuw draait +- **Sessiedata**: Active patient context, recente navigatie + +### Interface + +```typescript +// lib/cache/types.ts + +type CacheNamespace = + | 'ai:summary' // Overdracht AI samenvattingen + | 'ai:classification' // Intent classificatie resultaten + | 'ai:rag' // RAG pipeline resultaten + | 'api:patients' // Patient zoekresultaten + | 'api:agenda' // Agenda views + | 'api:dashboard' // Dashboard aggregaties + | 'session:context' // Active patient, recente acties + | 'config:protocols'; // Protocol definities + +interface CacheOptions { + ttl: number; // Seconds + namespace: CacheNamespace; + tags?: string[]; // Voor gerichte invalidatie +} + +interface CacheService { + get(key: string, namespace: CacheNamespace): Promise; + set(key: string, value: T, options: CacheOptions): Promise; + delete(key: string, namespace: CacheNamespace): Promise; + invalidateByTag(tag: string): Promise; // Returns count + invalidateNamespace(namespace: CacheNamespace): Promise; + + // Convenience: get-or-set pattern + getOrSet( + key: string, + factory: () => Promise, + options: CacheOptions + ): Promise; + + // Stats + getStats(): Promise<{ + hitRate: number; + memoryUsage: number; + keyCount: number; + }>; +} +``` + +### TTL strategie + +| Namespace | TTL | Invalidatie | +|-----------|-----|-------------| +| `ai:summary` | 30 min | Bij nieuwe rapportage voor die patiënt | +| `ai:classification` | 5 min | Zelden — zelfde input = zelfde output | +| `ai:rag` | 60 min | Bij protocol update | +| `api:patients` | 10 min | Bij patient update | +| `api:agenda` | 5 min | Bij appointment create/update/delete | +| `api:dashboard` | 15 min | Periodiek (C38 scheduled job) | +| `session:context` | 60 min | Bij navigatie-actie | +| `config:protocols` | 24 uur | Bij protocol wijziging | + +### Implementatie + +```typescript +// lib/cache/redis-cache.ts + +import Redis from 'ioredis'; + +const NAMESPACE_PREFIX: Record = { + 'ai:summary': 'ai:sum:', + 'ai:classification': 'ai:cls:', + 'ai:rag': 'ai:rag:', + 'api:patients': 'api:pat:', + 'api:agenda': 'api:agd:', + 'api:dashboard': 'api:dsh:', + 'session:context': 'ses:ctx:', + 'config:protocols': 'cfg:prt:', +}; + +// Cache key inclusief tenant voor isolatie +function buildKey(namespace: CacheNamespace, tenantId: string, key: string): string { + return `${NAMESPACE_PREFIX[namespace]}${tenantId}:${key}`; +} + +// Tag-based invalidatie via Redis Sets +// Set "tag:{tagName}" bevat alle keys met die tag +// Bij invalidateByTag: SMEMBERS + DEL pipeline +``` + +### Integratiepunten + +| Bestaand component | Integratie | +|-------------------|------------| +| C07 Orchestrator | Cache classificatie resultaten (zelfde input → zelfde output) | +| C12 RAG Pipeline | Cache vector search resultaten per query hash | +| C16 Overdracht Service | Cache AI-samenvattingen per patiënt + shift | +| C24 Multi-tenancy | Cache keys bevatten tenant_id — volledige isolatie | +| C31 Circuit Breaker | Bij AI service down → serve from cache (stale-while-revalidate) | + +### Technologiekeuze + +- **Redis** (al in stack voor BullMQ, D18): Hergebruik bestaande Redis instance +- **ioredis**: Standaard Node.js Redis client, pipeline support, cluster-ready + +### Geen gevoelige data in cache + +BSN, diagnoses en andere PII worden **nooit** direct gecached. Alleen: +- Hashed keys met verwijzing naar encrypted database records +- AI-gegenereerde samenvattingen (geen ruwe patiëntdata) +- Aggregaties en counts + +--- + +## C38 — Scheduled Jobs Service + +### Doel + +Betrouwbare uitvoering van periodieke en geplande taken: audit trail cleanup, protocol synchronisatie, facturatie batches, deadline monitoring, email digests. + +### Waarom nodig + +- **Audit trail**: Partities aanmaken, oude partities archiveren +- **Workflow deadlines**: Dagelijks checken of workflows hun `maxDurationDays` overschrijden +- **Notificatie digests**: Dagelijkse email samenvattingen +- **ZPM facturatie**: Maandelijkse facturatie batch +- **Protocol sync**: Periodiek nieuwe protocollen ophalen/indexeren +- **Caching**: Periodiek dashboard aggregaties vernieuwen + +### Interface + +```typescript +// lib/jobs/types.ts + +interface JobDefinition { + name: string; // Unieke naam: "audit.partition.create" + handler: (payload: unknown) => Promise; + schedule?: string; // Cron syntax: "0 2 * * *" (02:00 dagelijks) + retries?: number; // Default: 3 + backoff?: { type: 'exponential' | 'fixed'; delay: number }; + timeout?: number; // Milliseconds + concurrency?: number; // Max parallel workers +} + +interface ScheduledJobsService { + register(definition: JobDefinition): void; + enqueue(jobName: string, payload?: unknown, options?: { + delay?: number; // Milliseconds + priority?: number; // 1 (highest) - 10 (lowest) + tenantId?: string; + }): Promise; // Returns job ID + + getStatus(jobId: string): Promise; + getFailedJobs(limit?: number): Promise; + retryFailed(jobId: string): Promise; + getMetrics(): Promise; +} + +interface JobMetrics { + active: number; + waiting: number; + completed: number; + failed: number; + delayed: number; +} +``` + +### Geplande jobs + +```typescript +// lib/jobs/definitions.ts + +const scheduledJobs: JobDefinition[] = [ + { + name: 'audit.partition.create', + schedule: '0 0 25 * *', // 25e van de maand, partitie voor volgende maand + handler: createNextAuditPartition, + retries: 3, + }, + { + name: 'workflow.deadline.check', + schedule: '0 8 * * *', // Dagelijks 08:00 + handler: checkWorkflowDeadlines, // Overschrijdingen → escalatie notificatie + retries: 2, + }, + { + name: 'notifications.digest', + schedule: '0 7 * * *', // Dagelijks 07:00 + handler: sendDailyDigests, // Email digest aan users met die voorkeur + retries: 2, + }, + { + name: 'zpm.facturatie.batch', + schedule: '0 2 1 * *', // 1e van de maand, 02:00 + handler: runZPMFacturatieBatch, // Maandelijkse facturatie + retries: 3, + timeout: 600_000, // 10 minuten + }, + { + name: 'protocol.sync', + schedule: '0 3 * * 0', // Zondag 03:00 + handler: syncProtocolDocuments, // RAG pipeline re-index + retries: 2, + timeout: 300_000, + }, + { + name: 'cache.dashboard.refresh', + schedule: '*/15 * * * *', // Elke 15 minuten + handler: refreshDashboardCache, + retries: 1, + }, + { + name: 'notifications.escalation.check', + schedule: '*/5 * * * *', // Elke 5 minuten + handler: checkEscalations, // Ongelezen urgente notificaties → escaleer + retries: 1, + }, +]; +``` + +### Integratiepunten + +| Bestaand component | Integratie | +|-------------------|------------| +| C26 Audit Trail | Partitie management, archivering | +| C34 Notificatie | Digest emails, escalatie checks | +| C35 Workflow Engine | Deadline monitoring | +| C37 Caching | Dashboard cache verversing | +| C40 ZPM Facturatie | Maandelijkse batch | +| C12 RAG Pipeline | Protocol re-indexering | + +### Technologiekeuze + +- **BullMQ** (al gekozen, D18): Betrouwbare job queue met Redis backing, cron support, retry logic, dashboard (Bull Board) +- **Bull Board**: Web UI voor job monitoring — beschikbaar voor admin users + +--- + +## C39 — Webhook System + +### Doel + +Outbound webhooks voor externe integraties: externe systemen kunnen zich abonneren op events in het EPD platform. Essentieel voor de connector-architectuur (D17) en toekomstige integraties. + +### Waarom nodig + +- **Connector API**: Extern EPD wil weten wanneer er een nieuw rapport is aangemaakt +- **Externe systemen**: Facturatiesysteem, CRM, onderzoeksplatform willen events ontvangen +- **Toekomstige integraties**: Vecozo, Zorgdomein, BI-tools + +### Interface + +```typescript +// lib/webhooks/types.ts + +type WebhookEvent = + | 'report.created' + | 'report.updated' + | 'report.deleted' + | 'patient.admitted' + | 'patient.discharged' + | 'appointment.created' + | 'appointment.updated' + | 'appointment.cancelled' + | 'treatment_plan.activated' + | 'treatment_plan.updated' + | 'workflow.state_changed' + | 'incident.reported' + | 'wvggz.status_changed'; + +interface WebhookRegistration { + id: string; + tenantId: string; + url: string; // HTTPS endpoint + events: WebhookEvent[]; // Welke events + secret: string; // HMAC-SHA256 signing secret + active: boolean; + description?: string; + createdBy: string; + headers?: Record; // Extra headers (auth tokens etc.) + retryPolicy?: { + maxRetries: number; // Default: 5 + backoffMs: number; // Default: 1000, exponential + }; +} + +interface WebhookPayload { + id: string; // Unique event ID + event: WebhookEvent; + tenantId: string; + timestamp: string; // ISO 8601 + data: Record; // Event-specifieke data + // NOOIT PII in webhook payload — alleen IDs en metadata +} + +interface WebhookDeliveryLog { + id: string; + webhookId: string; + event: WebhookEvent; + payload: WebhookPayload; + responseStatus: number | null; + responseBody?: string; + attempt: number; + deliveredAt: Date | null; + nextRetryAt: Date | null; + error?: string; +} + +// Service interface +interface WebhookService { + register(registration: Omit): Promise; + update(id: string, updates: Partial): Promise; + delete(id: string): Promise; + list(tenantId: string): Promise; + + // Event dispatching (intern, aangeroepen door andere services) + dispatch(event: WebhookEvent, tenantId: string, data: Record): Promise; + + // Delivery monitoring + getDeliveryLog(webhookId: string, limit?: number): Promise; + retryDelivery(deliveryLogId: string): Promise; +} +``` + +### Database schema + +```sql +-- Webhook registraties +CREATE TABLE webhook_registrations ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + url TEXT NOT NULL, + events TEXT[] NOT NULL, + secret TEXT NOT NULL, -- HMAC signing secret (encrypted at rest) + active BOOLEAN DEFAULT TRUE, + description TEXT, + headers JSONB DEFAULT '{}', + retry_max INT DEFAULT 5, + retry_backoff INT DEFAULT 1000, + created_by UUID NOT NULL REFERENCES users(id), + created_at TIMESTAMPTZ DEFAULT NOW(), + updated_at TIMESTAMPTZ DEFAULT NOW() +); + +-- Delivery log (voor monitoring en retry) +CREATE TABLE webhook_delivery_log ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + webhook_id UUID NOT NULL REFERENCES webhook_registrations(id), + event TEXT NOT NULL, + payload JSONB NOT NULL, + response_status INT, + response_body TEXT, + attempt INT NOT NULL DEFAULT 1, + delivered_at TIMESTAMPTZ, + next_retry_at TIMESTAMPTZ, + error TEXT, + created_at TIMESTAMPTZ DEFAULT NOW() +); + +-- Partitie delivery log per maand (groeit snel) +-- CREATE TABLE webhook_delivery_log_2026_02 PARTITION OF webhook_delivery_log +-- FOR VALUES FROM ('2026-02-01') TO ('2026-03-01'); + +CREATE INDEX idx_webhook_delivery_pending + ON webhook_delivery_log (next_retry_at) + WHERE delivered_at IS NULL AND next_retry_at IS NOT NULL; + +-- RLS +ALTER TABLE webhook_registrations ENABLE ROW LEVEL SECURITY; +ALTER TABLE webhook_delivery_log ENABLE ROW LEVEL SECURITY; + +CREATE POLICY webhook_reg_tenant ON webhook_registrations + FOR ALL USING (tenant_id = current_setting('app.current_tenant_id')::UUID); +``` + +### Beveiliging + +```typescript +// Webhook signing — HMAC-SHA256 +import crypto from 'node:crypto'; + +function signPayload(payload: WebhookPayload, secret: string): string { + const body = JSON.stringify(payload); + return crypto.createHmac('sha256', secret).update(body).digest('hex'); +} + +// Headers bij elke delivery: +// X-Webhook-Id: +// X-Webhook-Event: report.created +// X-Webhook-Signature: sha256= +// X-Webhook-Timestamp: +``` + +### Integratiepunten + +| Bestaand component | Integratie | +|-------------------|------------| +| C15 Rapportage Service | report.created/updated/deleted → dispatch | +| C17 Agenda Service | appointment.* → dispatch | +| C18 Behandelplan Service | treatment_plan.* → dispatch | +| C35 Workflow Engine | workflow.state_changed → dispatch | +| C38 Scheduled Jobs | Retry queue voor gefaalde deliveries | +| C40-C42 Externe integraties | Ontvangen events via webhook registraties | + +### Belangrijk: geen PII in payloads + +Webhook payloads bevatten **alleen IDs en metadata**, nooit PII: + +```typescript +// GOED: +{ event: 'report.created', data: { reportId: 'uuid', patientId: 'uuid', type: 'observatie' } } + +// FOUT (nooit): +{ event: 'report.created', data: { patientName: 'Jan Janssen', bsn: '123456789', content: '...' } } +``` + +De ontvanger haalt volledige data op via de API met eigen authenticatie. + +--- + +## C40 — ZPM Facturatie Service + +### Doel + +Voorbereiding op Zorgprestatiemodel (ZPM) facturatie: registratie van zorgprestaties, koppeling aan DBC-trajecten, en generatie van facturatiebatches. ZPM is sinds 2022 het bekostigingssysteem voor GGZ. + +### Waarom nodig + +- **Wettelijk verplicht**: Elke GGZ-instelling moet factureren volgens ZPM +- **Zorgprestaties**: Elke behandelactiviteit (consult, groepssessie, diagnostiek) → prestatiecode +- **DBC-trajecten**: Patiënt heeft een lopend DBC (Diagnose Behandel Combinatie) traject +- **Facturatiebatch**: Maandelijks → declaratiebericht naar zorgverzekeraar (via Vecozo) + +### Interface + +```typescript +// lib/facturatie/types.ts + +// NZa prestatiecode structuur +interface ZorgPrestatie { + id: string; + tenantId: string; + patientId: string; + dbcTrajectId: string; + prestatieCode: string; // NZa code, bv. "OVP-0001" + prestatieType: 'consult' | 'groep' | 'diagnostiek' | 'verblijf' | 'crisis' | 'overig'; + beroep: string; // BIG-registratie beroep behandelaar + duur: number; // Minuten (voor directe tijd) + indirecteTijd?: number; // Minuten indirect + datum: Date; + behandelaarId: string; + appointmentId?: string; // Koppeling aan agenda + reportId?: string; // Koppeling aan rapportage + status: 'concept' | 'definitief' | 'gedeclareerd' | 'betaald' | 'afgewezen'; + metadata?: Record; +} + +interface DBCTraject { + id: string; + tenantId: string; + patientId: string; + diagnoseCode: string; // DSM-5 code + zorgtype: string; // Initieel / vervolg + startDatum: Date; + eindDatum?: Date; + status: 'open' | 'gesloten' | 'afgesloten_declaratie'; + verzekeringId: string; // Verwijzing naar verzekeringgegevens +} + +interface DeclaratieBatch { + id: string; + tenantId: string; + periode: string; // "2026-02" + prestaties: string[]; // Prestatie IDs + totaalBedrag: number; // Euro's + status: 'concept' | 'gecontroleerd' | 'verstuurd' | 'verwerkt' | 'deels_afgewezen'; + vecozo_referentie?: string; // Na verzending + gegenereerd_op: Date; + verstuurd_op?: Date; +} + +// Service interface +interface FacturatieService { + // Prestatie registratie + registreerPrestatie(prestatie: Omit): Promise; + koppelAanAfspraak(prestatieId: string, appointmentId: string): Promise; + koppelAanRapportage(prestatieId: string, reportId: string): Promise; + + // DBC beheer + openTraject(traject: Omit): Promise; + sluitTraject(trajectId: string): Promise; + + // Facturatie + genereerBatch(tenantId: string, periode: string): Promise; + controleerBatch(batchId: string): Promise; // Controle regels + markeerVerstuurd(batchId: string, vecozoRef: string): Promise; + + // Overzichten + getOpenPrestaties(tenantId: string, filters?: object): Promise; + getTrajecten(patientId: string): Promise; + getOmzetOverzicht(tenantId: string, periode: string): Promise; +} + +interface ValidationResult { + prestatieId: string; + valid: boolean; + errors: string[]; // NL foutmeldingen + warnings: string[]; +} + +interface OmzetOverzicht { + periode: string; + totaalGedeclareerd: number; + totaalBetaald: number; + totaalAfgewezen: number; + totaalOpen: number; + perBeroepsgroep: Record; + perZorgtype: Record; +} +``` + +### Database schema + +```sql +-- DBC trajecten +CREATE TABLE dbc_trajecten ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + patient_id UUID NOT NULL REFERENCES patients(id), + diagnose_code TEXT NOT NULL, + zorgtype TEXT NOT NULL DEFAULT 'initieel', + start_datum DATE NOT NULL, + eind_datum DATE, + status TEXT NOT NULL DEFAULT 'open', + verzekering_id UUID, -- Toekomstig: verzekeringsgegevens tabel + created_at TIMESTAMPTZ DEFAULT NOW(), + updated_at TIMESTAMPTZ DEFAULT NOW() +); + +-- Zorgprestaties +CREATE TABLE zorgprestaties ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + patient_id UUID NOT NULL REFERENCES patients(id), + dbc_traject_id UUID NOT NULL REFERENCES dbc_trajecten(id), + prestatie_code TEXT NOT NULL, + prestatie_type TEXT NOT NULL, + beroep TEXT NOT NULL, + duur_minuten INT NOT NULL, + indirecte_tijd INT DEFAULT 0, + datum DATE NOT NULL, + behandelaar_id UUID NOT NULL REFERENCES users(id), + appointment_id UUID REFERENCES appointments(id), + report_id UUID REFERENCES reports(id), + status TEXT NOT NULL DEFAULT 'concept', + metadata JSONB DEFAULT '{}', + created_at TIMESTAMPTZ DEFAULT NOW(), + updated_at TIMESTAMPTZ DEFAULT NOW() +); + +CREATE INDEX idx_zorgprestaties_patient ON zorgprestaties (patient_id, datum DESC); +CREATE INDEX idx_zorgprestaties_status ON zorgprestaties (tenant_id, status); +CREATE INDEX idx_zorgprestaties_traject ON zorgprestaties (dbc_traject_id); + +-- Declaratie batches +CREATE TABLE declaratie_batches ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + periode TEXT NOT NULL, -- "2026-02" + prestatie_ids UUID[] NOT NULL, + totaal_bedrag DECIMAL(10,2), + status TEXT NOT NULL DEFAULT 'concept', + vecozo_ref TEXT, + gegenereerd_op TIMESTAMPTZ DEFAULT NOW(), + verstuurd_op TIMESTAMPTZ, + metadata JSONB DEFAULT '{}' +); + +-- RLS +ALTER TABLE dbc_trajecten ENABLE ROW LEVEL SECURITY; +ALTER TABLE zorgprestaties ENABLE ROW LEVEL SECURITY; +ALTER TABLE declaratie_batches ENABLE ROW LEVEL SECURITY; + +CREATE POLICY dbc_tenant ON dbc_trajecten + FOR ALL USING (tenant_id = current_setting('app.current_tenant_id')::UUID); + +CREATE POLICY zorgprestaties_tenant ON zorgprestaties + FOR ALL USING (tenant_id = current_setting('app.current_tenant_id')::UUID); + +CREATE POLICY declaratie_tenant ON declaratie_batches + FOR ALL USING (tenant_id = current_setting('app.current_tenant_id')::UUID); +``` + +### Integratiepunten + +| Bestaand component | Integratie | +|-------------------|------------| +| C17 Agenda Service | Afspraak → automatisch zorgprestatie concept aanmaken | +| C15 Rapportage Service | Rapport met contactmoment → koppelen aan prestatie | +| C25 RBAC + ABAC | Alleen financieel medewerker mag batches genereren | +| C26 Audit Trail | Elke facturatie-actie → audit log | +| C35 Workflow Engine | Declaratie workflow: concept → controle → verzending | +| C38 Scheduled Jobs | Maandelijkse batch generatie | +| C41 Vecozo | Declaratiebatch versturen naar Vecozo (toekomstig) | + +### Controleregels + +```typescript +// lib/facturatie/validatie.ts + +// Voorbeelden van validatieregels die bij batch-controle draaien: +const validatieRegels = [ + // Geen prestatie zonder open DBC traject + 'prestatie.datum BETWEEN dbc.start_datum AND COALESCE(dbc.eind_datum, NOW())', + // Maximaal 12 uur directe tijd per dag per behandelaar + 'SUM(duur_minuten) per behandelaar per dag <= 720', + // Prestatiecode moet geldig zijn voor beroep + 'prestatie_code IN (valid_codes_for_beroep)', + // Geen dubbele prestatie (zelfde patient, dag, code, behandelaar) + 'UNIQUE(patient_id, datum, prestatie_code, behandelaar_id)', +]; +``` + +--- + +## C41 — Vecozo Connector (voorbereiding) + +### Doel + +Interface-voorbereiding voor koppeling met Vecozo: het landelijke communicatiepunt voor declaraties, COV-checks (Controle Op Verzekeringsrecht), en machtigingen in de zorg. + +### Status: alleen interface — geen implementatie + +Vecozo-koppeling vereist een formeel aansluittraject (UZI-certificaat, testomgeving, acceptatie). Dit component definieert **alleen de interfaces** zodat C40 (ZPM Facturatie) er straks naadloos op aan kan sluiten. + +### Interface + +```typescript +// lib/integrations/vecozo/types.ts + +interface VecozoConnector { + // COV-check: is patiënt verzekerd? + checkVerzekering(params: { + bsn: string; + peildatum: Date; + }): Promise; + + // Declaratie versturen + submitDeclaratie(params: { + batchId: string; + declaratieXml: string; // Vektis EI-standaard + }): Promise; + + // Declaratie status opvragen + getDeclaratieStatus(vecozoRef: string): Promise; + + // Machtiging aanvragen (voor bepaalde zorgtypen) + requestMachtiging(params: { + patientBsn: string; + zorgtype: string; + motivatie: string; + }): Promise; + + // Health check + isAvailable(): Promise; +} + +interface VerzekeringStatus { + verzekerd: boolean; + verzekeraar?: string; + uzovi?: string; // UZOVI-code verzekeraar + polisnummer?: string; + ingangsDatum?: Date; + eindDatum?: Date; +} + +interface DeclaratieResponse { + accepted: boolean; + vecozoReferentie: string; + errors?: string[]; +} + +interface DeclaratieStatusResponse { + status: 'ontvangen' | 'in_behandeling' | 'goedgekeurd' | 'deels_afgewezen' | 'afgewezen'; + details?: string; + betaalDatum?: Date; +} + +interface MachtigingResponse { + status: 'toegekend' | 'afgewezen' | 'in_behandeling'; + machtigingNummer?: string; + geldigTot?: Date; +} +``` + +### Vereisten voor aansluiting (niet nu, wel documenteren) + +1. **UZI-certificaat**: Nodig voor mTLS communicatie met Vecozo +2. **AGB-code**: Instelling moet geregistreerd zijn +3. **Testomgeving**: Vecozo biedt een acceptatieomgeving +4. **Vektis standaarden**: Declaratieberichten in EI-standaard XML formaat +5. **BSN-verificatie**: Koppeling met BRP via Vecozo + +### Placeholder implementatie + +```typescript +// lib/integrations/vecozo/mock-connector.ts + +export class MockVecozoConnector implements VecozoConnector { + async checkVerzekering(params: { bsn: string; peildatum: Date }): Promise { + console.warn('[Vecozo] Mock connector — niet verbonden met Vecozo'); + return { + verzekerd: true, + verzekeraar: 'Mock Verzekeraar', + uzovi: '0000', + }; + } + + async submitDeclaratie(): Promise { + throw new Error('[Vecozo] Declaratie versturen niet beschikbaar — Vecozo connector niet geconfigureerd'); + } + + // ... etc +} +``` + +--- + +## C42 — Zorgdomein Connector (voorbereiding) + +### Doel + +Interface-voorbereiding voor koppeling met Zorgdomein: het landelijke platform voor elektronische verwijzingen van huisarts naar GGZ. + +### Status: alleen interface — geen implementatie + +Net als Vecozo vereist Zorgdomein een formeel aansluittraject. Dit component definieert de interfaces. + +### Interface + +```typescript +// lib/integrations/zorgdomein/types.ts + +interface ZorgdomeinConnector { + // Nieuwe verwijzingen ophalen + getNewReferrals(since: Date): Promise; + + // Verwijzing accepteren/afwijzen + acceptReferral(verwijzingId: string): Promise; + rejectReferral(verwijzingId: string, reden: string): Promise; + + // Status terugkoppelen + updateReferralStatus(verwijzingId: string, status: string): Promise; + + // Health check + isAvailable(): Promise; +} + +interface ZorgdomeinVerwijzing { + id: string; + verwijzerAgbCode: string; // Huisarts AGB-code + verwijzerNaam: string; + patientBsn: string; + patientNaam: string; + verwijsDatum: Date; + urgentie: 'normaal' | 'spoed'; + klacht: string; + anamnese?: string; + diagnose?: string; + medicatie?: string; + bijlagen?: { naam: string; type: string; url: string }[]; +} +``` + +### Integratie met intake workflow + +```typescript +// Wanneer Zorgdomein actief is: +// 1. C38 (Scheduled Jobs) pollt Zorgdomein elke 15 minuten voor nieuwe verwijzingen +// 2. Nieuwe verwijzing → automatisch patient aanmaken (of matchen op BSN) +// 3. C35 (Workflow Engine) start intake_ggz workflow +// 4. C34 (Notificatie) meldt aan triagist: "Nieuwe verwijzing via Zorgdomein" +``` + +--- + +## C43 — BI Module (voorbereiding) + +### Doel + +Business Intelligence laag: materialized views, data-export en voorbereiding op dashboards voor management rapportages. Niet een volledige BI-tool, maar de datalaag die BI mogelijk maakt. + +### Waarom nodig + +- **Stuurinformatie**: Productiecijfers per behandelaar, team, afdeling +- **Wachttijden**: Gemiddelde wachttijd aanmelding → intake (Treeknormen) +- **Kwaliteitsindicatoren**: ROM-scores, uitval, no-shows +- **Financieel**: Omzet per periode, ongedeclareerde prestaties +- **Bezetting**: Bed/verblijfsbezetting, personeel/patiënt ratio + +### Interface + +```typescript +// lib/bi/types.ts + +interface BIQuery { + tenantId: string; + metric: BIMetric; + dimensions?: BIDimension[]; + dateRange: { from: Date; to: Date }; + filters?: Record; +} + +type BIMetric = + | 'productie_uren' + | 'aantal_consulten' + | 'wachttijd_intake' + | 'no_show_percentage' + | 'bezettingsgraad' + | 'omzet' + | 'ongedeclareerd' + | 'gemiddelde_behandelduur' + | 'uitval_percentage' + | 'incidenten_per_maand'; + +type BIDimension = + | 'behandelaar' + | 'team' + | 'afdeling' + | 'locatie' + | 'zorgtype' + | 'diagnose_groep' + | 'maand' + | 'week'; + +interface BIResult { + metric: BIMetric; + dimensions: Record; + value: number; + previousValue?: number; // Vorige periode voor vergelijking + trend?: 'up' | 'down' | 'stable'; +} + +interface BIService { + query(query: BIQuery): Promise; + refreshViews(tenantId: string): Promise; + exportCSV(query: BIQuery): Promise; // CSV content + getAvailableMetrics(): BIMetric[]; +} +``` + +### Materialized views + +```sql +-- Productie per behandelaar per maand +CREATE MATERIALIZED VIEW mv_productie_per_behandelaar AS +SELECT + z.tenant_id, + z.behandelaar_id, + u.display_name AS behandelaar_naam, + d.name AS afdeling, + DATE_TRUNC('month', z.datum) AS maand, + COUNT(*) AS aantal_prestaties, + SUM(z.duur_minuten) AS directe_minuten, + SUM(z.indirecte_tijd) AS indirecte_minuten, + SUM(z.duur_minuten + COALESCE(z.indirecte_tijd, 0)) AS totaal_minuten +FROM zorgprestaties z +JOIN users u ON u.id = z.behandelaar_id +LEFT JOIN departments d ON d.id = u.department_id +WHERE z.status != 'concept' +GROUP BY z.tenant_id, z.behandelaar_id, u.display_name, d.name, DATE_TRUNC('month', z.datum); + +CREATE UNIQUE INDEX idx_mv_productie + ON mv_productie_per_behandelaar (tenant_id, behandelaar_id, maand); + +-- Wachttijden (aanmelding → intake) +CREATE MATERIALIZED VIEW mv_wachttijden AS +SELECT + wi.tenant_id, + DATE_TRUNC('month', wi.created_at) AS maand, + wi.current_state, + COUNT(*) AS aantal, + AVG(EXTRACT(DAY FROM ( + CASE WHEN wtl.to_state = 'triage' + THEN wtl.created_at ELSE NULL END + ) - wi.created_at)) AS gem_dagen_tot_triage, + AVG(EXTRACT(DAY FROM ( + CASE WHEN wtl.to_state = 'gestart' + THEN wtl.created_at ELSE NULL END + ) - wi.created_at)) AS gem_dagen_tot_start +FROM workflow_instances wi +LEFT JOIN workflow_transitions_log wtl ON wtl.instance_id = wi.id +WHERE wi.entity_type = 'intake' +GROUP BY wi.tenant_id, DATE_TRUNC('month', wi.created_at), wi.current_state; + +-- No-show percentage per maand +CREATE MATERIALIZED VIEW mv_no_shows AS +SELECT + a.tenant_id, + DATE_TRUNC('month', a.start_time) AS maand, + COUNT(*) AS totaal_afspraken, + COUNT(*) FILTER (WHERE a.status = 'no_show') AS no_shows, + ROUND( + COUNT(*) FILTER (WHERE a.status = 'no_show')::DECIMAL / + NULLIF(COUNT(*), 0) * 100, 1 + ) AS no_show_percentage +FROM appointments a +WHERE a.start_time < NOW() +GROUP BY a.tenant_id, DATE_TRUNC('month', a.start_time); + +-- Refresh via scheduled job (C38) +-- REFRESH MATERIALIZED VIEW CONCURRENTLY mv_productie_per_behandelaar; +-- REFRESH MATERIALIZED VIEW CONCURRENTLY mv_wachttijden; +-- REFRESH MATERIALIZED VIEW CONCURRENTLY mv_no_shows; +``` + +### Integratiepunten + +| Bestaand component | Integratie | +|-------------------|------------| +| C17 Agenda Service | No-show data, bezettingsdata | +| C35 Workflow Engine | Wachttijden (intake doorlooptijden) | +| C37 Caching | BI resultaten cachen (namespace `api:dashboard`) | +| C38 Scheduled Jobs | `REFRESH MATERIALIZED VIEW CONCURRENTLY` elke 15-60 min | +| C40 ZPM Facturatie | Omzet en productiecijfers | +| C25 RBAC + ABAC | Alleen management/admin rollen mogen BI queries draaien | + +### Toekomstige uitbreiding + +Als BI-behoeften groeien voorbij wat materialized views aankunnen: +- **Metabase** (self-hosted, open source) als BI frontend bovenop dezelfde PostgreSQL +- **dbt** voor data transformaties als de views complexer worden +- Export naar extern data warehouse indien nodig + +--- + +## Bijgewerkt Component Overzicht (volledig) + +``` +LAAG 1: INTERFACE +├── C01 Traditionele EPD UI +├── C02 Intent Command Center +├── C03 Spraak Input +└── C04 Block/Artifact systeem + +LAAG 2: INTENT SYSTEEM +├── C05 Intent Registry +├── C06 Reflex Classifier +├── C07 Orchestrator +├── C08 Entity Extractor + Date Parser +├── C09 Action System +└── C10 Protocol Engine / Nudge + +LAAG 3: KNOWLEDGE LAYER +├── C11 Protocol Rules Store +├── C12 RAG Pipeline +├── C13 Regelvalidatie UI +└── C14 Kennisbron Connectors + +LAAG 4: DOMEIN / BUSINESS LOGIC +├── C15 Rapportage Service +├── C16 Overdracht Service +├── C17 Agenda Service +├── C18 Behandelplan Service +├── C19 Medicatie Service +├── C20 Intake Service +├── C21 Patiënt Service +└── C22 Toestemming Service + +LAAG 5: ENTERPRISE FUNDAMENT +├── C23 Auth + SSO (Keycloak) +├── C24 Multi-tenancy (RLS) +├── C25 RBAC + ABAC Engine +├── C26 Audit Trail (NEN 7513) +├── C27 Field Encryption +├── C28 FHIR Export Service +├── C29 CDS Hooks Service +├── C30 Observability +├── C31 Circuit Breaker / Resilience +├── C32 Health Check Service +└── C33 PII Filter + +LAAG 6: PLATFORM SERVICES ← NIEUW +├── C34 Notificatie Service +├── C35 Workflow Engine (State Machine) +├── C36 Full-Text Search Service +├── C37 Caching Layer +├── C38 Scheduled Jobs Service +└── C39 Webhook System + +LAAG 7: EXTERNE INTEGRATIES ← NIEUW +├── C40 ZPM Facturatie Service +├── C41 Vecozo Connector (voorbereiding) +└── C42 Zorgdomein Connector (voorbereiding) + +LAAG 8: ANALYTICS ← NIEUW +└── C43 BI Module (materialized views) + +TOTAAL: 43 componenten (33 bestaand + 10 nieuw) +``` + +--- + +## Bijgewerkt Bouwplan (fasen) + +De 10 nieuwe componenten passen als volgt in het bestaande 5-fasen bouwplan: + +``` +FASE 1: FUNDAMENT (week 1-4) — uitbreiding +├── (bestaand) PostgreSQL, Keycloak, Drizzle, Docker, Caddy +├── (bestaand) Multi-tenancy, Audit Trail, RBAC +├── C38 Scheduled Jobs ← NIEUW (fundament voor alles) +└── C37 Caching Layer ← NIEUW (Redis al aanwezig voor BullMQ) + +FASE 2: EPD CORE (week 5-10) — uitbreiding +├── (bestaand) Rapportage, Overdracht, Agenda, Behandelplan +├── (bestaand) Intent systeem, Reflex, Orchestrator +├── C34 Notificatie Service ← NIEUW +├── C35 Workflow Engine ← NIEUW +└── C40 ZPM Facturatie ← NIEUW (basisregistratie, geen Vecozo) + +FASE 3: KNOWLEDGE LAYER (week 11-14) — uitbreiding +├── (bestaand) Protocol Rules, RAG Pipeline, Nudge +├── C36 Full-Text Search ← NIEUW +└── C43 BI Module ← NIEUW (materialized views aanmaken) + +FASE 4: CONNECTIVITEIT (week 15-18) — uitbreiding +├── (bestaand) FHIR Connector, Connector admin UI +├── C39 Webhook System ← NIEUW +├── C41 Vecozo Connector ← NIEUW (interface + mock, geen live) +└── C42 Zorgdomein Connector ← NIEUW (interface + mock, geen live) + +FASE 5: COMPLIANCE & HARDENING (week 19-22) +├── (bestaand) Encryption, Wvggz, Observability, Load test, Pentest +└── Vecozo/Zorgdomein live aansluiting (indien traject loopt) +``` + +--- + +## Beslissingenlog (aanvullingen) + +| # | Beslissing | Alternatieven | Rationale | +|---|-----------|---------------|-----------| +| D20 | Notificaties via SSE (geen WebSockets) | WebSockets, polling | Eenvoudiger, minder infra, notificaties zijn unidirectioneel | +| D21 | Eigen state machine (geen XState) | XState, Temporal.io | ~200 regels code, server-side, geen dependency bloat | +| D22 | PostgreSQL tsvector (geen Elasticsearch) | Elasticsearch, Meilisearch | Geen extra service, voldoende voor GGZ-schaal | +| D23 | Materialized views voor BI (geen apart warehouse) | Metabase direct, dbt, Snowflake | Start simpel, upgrade later als nodig | +| D24 | Webhook signing met HMAC-SHA256 | JWT, API keys | Industriestandaard (GitHub, Stripe), simpel te valideren | +| D25 | Geen PII in webhook payloads | Encrypted payloads | Defense in depth, ontvanger haalt data via API | + +--- + +## Appendix: Cross-referentie nieuwe componenten × use cases + +| Use Case | C34 | C35 | C36 | C37 | C38 | C39 | C40 | C41 | C42 | C43 | +|----------|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----| +| UC-01 Dagnotitie | | | ● | ● | | ● | | | | | +| UC-05 Overdracht | ● | | ● | ● | | | | | | | +| UC-07 Zoeken | | | ● | ● | | | | | | | +| UC-10 Afspraak | ● | | | | | ● | ● | | | | +| UC-13 Intake status | ● | ● | | | | | | | ● | ● | +| UC-20 Nudge | ● | | | ● | | | | | | | +| UC-21 Behandelplan | ● | ● | | | | ● | ● | | | ● | +| UC-22 Medicatie | ● | | ● | | | | | | | | +| UC-23 Incident | ● | ● | ● | | | ● | | | | ● | +| UC-24 Wvggz | ● | ● | | | ● | | | | | | +| UC-26 Audit log | | | ● | | ● | | | | | | +| UC-30 Dashboard | | | | ● | ● | | | | | ● | +| UC-32 Groepstherapie | | | | | | | ● | | | ● | +| UC-33 Break-the-glass | ● | | | | | | | | | | + +● = component is betrokken bij deze use case + +--- + +## Appendix: Relatie tussen alle architectuurdocumenten (bijgewerkt) + +``` +docs/architecture/ +│ +├── intent-system-architectuur-nl.md +│ Beschrijft: Hoe het intent systeem intern werkt +│ Scope: 5 bouwblokken, classificatie, entity resolution, nudge +│ +├── enterprise-epd-architectuur.md +│ Beschrijft: Enterprise EPD schil (multi-tenancy, audit, security) +│ Stack: Supabase + Vercel (VERVANGEN door platform-connectiviteit-selfhosted.md) +│ Status: Functioneel nog geldig, stack is gewijzigd +│ +├── usecases-technische-componenten.md +│ Beschrijft: 33 use cases × 34 componenten validatie +│ Scope: Gap analyse, bouwvolgorde, kruistabel +│ Status: Uitgebreid met 10 nieuwe componenten (zie dit document) +│ +├── platform-connectiviteit-selfhosted.md +│ Beschrijft: Self-hosted stack, platform splitsing, connectors +│ Vervangt: Stack keuzes uit enterprise-epd-architectuur.md +│ Voegt toe: Connector API, deployment modellen, Keycloak, Drizzle +│ +└── enterprise-componenten-uitbreiding.md ← DIT DOCUMENT + Beschrijft: 10 nieuwe componenten (C34–C43) als voorbereiding + Scope: Interfaces, database schemas, integratiepunten, fasering + Status: Voorbereiding — nog niet gebouwd +``` diff --git a/docs/architecture/enterprise-epd-architectuur.md b/docs/architecture/enterprise-epd-architectuur.md new file mode 100644 index 0000000..24f6e76 --- /dev/null +++ b/docs/architecture/enterprise-epd-architectuur.md @@ -0,0 +1,1619 @@ +# Enterprise EPD Architectuur — Intent-Driven Zorgsysteem + +> **Type**: Architectuur Referentiedocument +> **Versie**: 1.0 +> **Datum**: 2026-02-14 +> **Doelgroep**: LLM-agents, developers, architecten, CTO's +> **Taal**: Nederlands (tekst), Engels (technische termen en code) +> **Relatie**: Bouwt voort op `intent-system-architectuur-nl.md` (het intent-systeem) en voegt enterprise-lagen toe + +--- + +## Leeswijzer + +Dit document beschrijft de complete architectuur van een enterprise EPD (Elektronisch Patiëntendossier) voor middelgrote tot grote GGZ-instellingen. Het combineert twee unieke componenten — een intent-driven interface en een Knowledge Layer — met de enterprise-eisen die productie in de Nederlandse zorg vereist. + +Het document is zo geschreven dat een LLM het kan lezen en er code, migraties of configuratie van kan afleiden. Elke sectie volgt: **wat** → **waarom** → **hoe** → **trade-offs**. + +Het intent-systeem zelf is beschreven in het companion-document. Dit document focust op de enterprise-schil eromheen. + +--- + +## 1. Systeemoverzicht + +### 1.1 Twee unieke componenten + enterprise fundament + +Dit systeem onderscheidt zich door twee elementen die samen een vliegwiel vormen: + +``` +┌─────────────────────────────────────────────────────────┐ +│ GEBRUIKERSINTERFACE │ +│ │ +│ ┌──────────────┐ ┌──────────────────────┐ │ +│ │ Traditionele │ │ Intent Command │ │ +│ │ EPD UI │ │ Center (⌘K) │ │ +│ │ (klikken) │ │ (typen/spreken) │ │ +│ └──────┬───────┘ └──────────┬───────────┘ │ +│ │ │ │ +│ └─────────┬─────────────────┘ │ +│ │ │ +│ Dezelfde API + data laag │ +├────────────────────┼────────────────────────────────────┤ +│ ▼ │ +│ ┌─────────────────────────────────────────────┐ │ +│ │ 1. INTENT SYSTEEM │ │ +│ │ Reflex → Orchestrator → Entity Resolution │ │ +│ │ → Action System → Protocol Engine (Nudge) │ │ +│ │ [zie: intent-system-architectuur-nl.md] │ │ +│ └──────────────────┬──────────────────────────┘ │ +│ │ voedt / wordt gevoed door │ +│ ┌──────────────────┴──────────────────────────┐ │ +│ │ 2. KNOWLEDGE LAYER │ │ +│ │ Wet- & regelgeving │ Behandelprotocollen │ │ +│ │ Kwaliteitsdocumenten │ EPD-data (eigen) │ │ +│ └──────────────────┬──────────────────────────┘ │ +│ │ │ +├─────────────────────┼────────────────────────────────────┤ +│ ▼ │ +│ ┌─────────────────────────────────────────────┐ │ +│ │ ENTERPRISE FUNDAMENT │ │ +│ │ Multi-tenancy │ Audit trail (NEN 7513) │ │ +│ │ RBAC + ABAC │ Encryptie │ FHIR export │ │ +│ │ Observability │ CI/CD │ Resilience │ │ +│ └─────────────────────────────────────────────┘ │ +└─────────────────────────────────────────────────────────┘ +``` + +**Component 1: Intent Systeem** — Vertaalt natuurlijke taal naar gestructureerde acties. Beschreven in het companion-document. Dit is de snelle route: de zorgverlener spreekt of typt, het systeem begrijpt en bereidt voor. + +**Component 2: Knowledge Layer** — Externe kennisbronnen die het intent-systeem en de Protocol Engine voeden. Wet- en regelgeving (Wlz, Wvggz, Wkkgz), behandelprotocollen (GGZ Standaarden, V&VN), kwaliteitsdocumenten (instellingsspecifiek) en de eigen EPD-data. + +**Enterprise Fundament** — Alles wat nodig is om deze componenten veilig, schaalbaar en compliant te draaien in productie. + +### 1.2 Dual Interface Principe + +Het systeem heeft altijd twee gelijkwaardige ingangen naar dezelfde data: + +| Interface | Wanneer | Sterkte | +|-----------|---------|---------| +| **Traditionele EPD UI** | Complexe workflows, overzichten, formulieren | Visueel, vertrouwd, altijd beschikbaar | +| **Intent Command Center** | Snelle acties, navigatie, rapportage | Snel, handsfree, context-aware | + +De traditionele UI is geen fallback — het is een volwaardige interface. Het intent-systeem is geen vervanging — het is een versneller. Beide lezen en schrijven via dezelfde API-laag. + +**Waarom dit ertoe doet**: Adoptie. Zorgverleners die gewend zijn aan klikken moeten op dag één productief zijn. Het intent-systeem groeit in gebruik naarmate vertrouwen groeit. + +--- + +## 2. Technologie Stack + +### 2.1 Gekozen stack en rationale + +| Laag | Technologie | Waarom | +|------|-------------|--------| +| **Frontend** | Next.js 14 (App Router) | Server Components voor snelle initial load, Server Actions voor forms, streaming voor AI responses | +| **Styling** | Tailwind CSS + shadcn/ui | Consistent design system, accessible components out of the box | +| **Database** | Supabase (PostgreSQL 15+) | RLS voor multi-tenancy, Realtime voor live updates, pgvector voor RAG, Edge Functions voor webhooks | +| **Auth** | Supabase Auth | SAML/SSO voor enterprise, MFA, session management | +| **AI** | Anthropic Claude API | Intent classificatie (Orchestrator), samenvattingen, chat | +| **Spraak** | Deepgram | Streaming speech-to-text, Nederlandse taalondersteuning | +| **State** | Zustand | Lightweight, geen boilerplate, splitbaar per domein | +| **Validatie** | Zod | Runtime type checking op API boundaries | +| **Zoeken** | Fuse.js (client) + pg_trgm (server) | Fuzzy matching patiëntnamen (client), trigram search (server) | +| **Logging** | Pino | Structured JSON logging, low overhead, PII filtering | +| **Monitoring** | OpenTelemetry → Grafana/Datadog | Traces, metrics, alerting | +| **CI/CD** | GitHub Actions | Automated testing, preview deploys, database migrations | + +### 2.2 Wat we bewust NIET gebruiken + +| Technologie | Waarom niet | +|-------------|-------------| +| **Microservices** | Operationele complexiteit te hoog voor team van 2-5 devs. Modular monolith geeft dezelfde scheiding met minder overhead | +| **GraphQL** | REST + Supabase PostgREST is voldoende. GraphQL voegt complexiteit toe zonder duidelijke winst voor dit domein | +| **Redis** | Supabase caching + PostgreSQL materialized views volstaan. Redis toevoegen = extra infra om te beheren | +| **Kubernetes** | Vercel/Supabase hosted = managed infra. K8s is overkill tot >10.000 concurrent users | +| **Full FHIR server** | We bouwen FHIR-compatible, niet FHIR-native. Een volledige FHIR server (HAPI) is te zwaar. We exporteren FHIR, we zijn geen FHIR store | + +--- + +## 3. Data Architectuur + +### 3.1 Database schema — kernmodel + +Het datamodel is FHIR-inspired maar niet FHIR-native. We gebruiken PostgreSQL-native types en relaties, met FHIR export als API-laag. + +```sql +-- Tenant (organisatie/instelling) +CREATE TABLE tenants ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + name TEXT NOT NULL, + slug TEXT UNIQUE NOT NULL, -- url-friendly identifier + settings JSONB DEFAULT '{}', -- tenant-specifieke configuratie + nen_7510_certified BOOLEAN DEFAULT false, + created_at TIMESTAMPTZ DEFAULT now() +); + +-- Locatie binnen een instelling +CREATE TABLE locations ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + name TEXT NOT NULL, -- "Locatie Centrum", "Kliniek Noord" + address JSONB, + created_at TIMESTAMPTZ DEFAULT now() +); + +-- Afdeling binnen een locatie +CREATE TABLE departments ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + location_id UUID NOT NULL REFERENCES locations(id), + tenant_id UUID NOT NULL REFERENCES tenants(id), + name TEXT NOT NULL, -- "Afdeling Volwassenen", "Jeugd GGZ" + department_type TEXT, -- 'klinisch', 'ambulant', 'dagbehandeling' + created_at TIMESTAMPTZ DEFAULT now() +); + +-- Gebruiker (zorgverlener) +CREATE TABLE users ( + id UUID PRIMARY KEY REFERENCES auth.users(id), + tenant_id UUID NOT NULL REFERENCES tenants(id), + department_id UUID REFERENCES departments(id), + full_name TEXT NOT NULL, + role TEXT NOT NULL, -- 'verpleegkundige', 'arts', 'psycholoog', 'admin', 'audit' + big_number TEXT, -- BIG-registratie (wettelijk vereist) + permissions TEXT[] DEFAULT '{}', -- RBAC basis permissions + active BOOLEAN DEFAULT true, + created_at TIMESTAMPTZ DEFAULT now() +); + +-- Patiënt +CREATE TABLE patients ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + department_id UUID REFERENCES departments(id), + bsn_encrypted BYTEA, -- BSN versleuteld opgeslagen (NEN 7510) + bsn_hash TEXT, -- Hash voor lookup zonder decryptie + full_name TEXT NOT NULL, + date_of_birth DATE, + gender TEXT, + status TEXT DEFAULT 'actief', -- 'actief', 'ontslagen', 'overdracht' + admission_date DATE, + legal_status TEXT, -- 'vrijwillig', 'wvggz_zorgmachtiging', 'wvggz_crisismaatregel' + deleted_at TIMESTAMPTZ, -- soft delete + created_at TIMESTAMPTZ DEFAULT now() +); + +-- Patiënt-zorgverlener toewijzing +CREATE TABLE patient_assignments ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + patient_id UUID NOT NULL REFERENCES patients(id), + user_id UUID NOT NULL REFERENCES users(id), + tenant_id UUID NOT NULL REFERENCES tenants(id), + role TEXT NOT NULL, -- 'hoofdbehandelaar', 'verpleegkundige', 'mentor' + active BOOLEAN DEFAULT true, + assigned_at TIMESTAMPTZ DEFAULT now(), + ended_at TIMESTAMPTZ, + UNIQUE(patient_id, user_id, role) +); + +-- Rapportages (alle types) +CREATE TABLE reports ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + patient_id UUID NOT NULL REFERENCES patients(id), + author_id UUID NOT NULL REFERENCES users(id), + report_type TEXT NOT NULL, -- 'voortgang', 'observatie', 'incident', 'medicatie', + -- 'contact', 'crisis', 'intake', 'behandeladvies', + -- 'vrije_notitie', 'verpleegkundig' + title TEXT, + content TEXT NOT NULL, + structured_data JSONB DEFAULT '{}', -- category, severity, etc. + shift_date DATE NOT NULL, -- voor 07:00 = vorige dag + version INTEGER DEFAULT 1, + previous_version_id UUID REFERENCES reports(id), + deleted_at TIMESTAMPTZ, -- soft delete, NOOIT hard delete + created_at TIMESTAMPTZ DEFAULT now(), + updated_at TIMESTAMPTZ DEFAULT now() +); + +-- Behandelplan +CREATE TABLE treatment_plans ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + patient_id UUID NOT NULL REFERENCES patients(id), + author_id UUID NOT NULL REFERENCES users(id), + status TEXT DEFAULT 'concept', -- 'concept', 'actief', 'afgerond', 'herzien' + goals JSONB DEFAULT '[]', -- behandeldoelen + interventions JSONB DEFAULT '[]', -- interventies + evaluation_date DATE, + version INTEGER DEFAULT 1, + created_at TIMESTAMPTZ DEFAULT now(), + updated_at TIMESTAMPTZ DEFAULT now() +); + +-- Afspraken / Agenda +CREATE TABLE appointments ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + patient_id UUID REFERENCES patients(id), + user_id UUID NOT NULL REFERENCES users(id), + title TEXT NOT NULL, + start_time TIMESTAMPTZ NOT NULL, + end_time TIMESTAMPTZ NOT NULL, + appointment_type TEXT, -- 'consult', 'groepstherapie', 'mdo', 'visite' + status TEXT DEFAULT 'gepland', -- 'gepland', 'bevestigd', 'geannuleerd', 'voltooid' + location TEXT, + notes TEXT, + created_at TIMESTAMPTZ DEFAULT now() +); + +-- Toestemmingen (Wvggz / AVG) +CREATE TABLE consents ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id), + patient_id UUID NOT NULL REFERENCES patients(id), + consent_type TEXT NOT NULL, -- 'behandeling', 'datadeling', 'wvggz_zorgmachtiging' + status TEXT NOT NULL, -- 'verleend', 'ingetrokken', 'verlopen' + granted_by TEXT, -- patiënt, wettelijk vertegenwoordiger, rechter + granted_at TIMESTAMPTZ, + expires_at TIMESTAMPTZ, + document_reference TEXT, -- link naar juridisch document + created_at TIMESTAMPTZ DEFAULT now() +); +``` + +### 3.2 Verpleegkundig rapportage — categorieën en shift-logica + +```typescript +// Report types die in de reports tabel worden opgeslagen +type ReportType = + | 'voortgang' // Dagelijkse voortgangsrapportage + | 'observatie' // Klinische observatie + | 'incident' // Incident of MIC-melding + | 'medicatie' // Medicatie-gerelateerd + | 'contact' // Contact met familie/instantie + | 'crisis' // Crisisinterventie + | 'intake' // Intakegesprek + | 'behandeladvies' // Advies aan behandelteam + | 'vrije_notitie' // Ongestructureerde notitie + | 'verpleegkundig'; // Verpleegkundige rapportage + +// Verpleegkundige subcategorieën (in structured_data.category) +type NursingCategory = 'medicatie' | 'adl' | 'gedrag' | 'incident' | 'observatie'; + +// Shift-logica: rapportage vóór 07:00 hoort bij de nachtdienst van de vorige dag +function calculateShiftDate(createdAt: Date): Date { + const hour = createdAt.getHours(); + if (hour < 7) { + return subDays(createdAt, 1); // date-fns + } + return createdAt; +} + +// Dagdelen voor tijdlijn-weergave +type DayPart = 'nacht' | 'ochtend' | 'middag' | 'avond'; +// nacht: 00:00 - 07:00 +// ochtend: 07:00 - 12:00 +// middag: 12:00 - 17:00 +// avond: 17:00 - 00:00 +``` + +### 3.3 Versioning en soft delete + +Rapportages worden **nooit** hard verwijderd. Dit is een wettelijke eis (Wkkgz, NEN 7513). + +```typescript +// Soft delete: zet deleted_at, origineel blijft in database +async function softDeleteReport(reportId: string, userId: string) { + await supabase + .from('reports') + .update({ deleted_at: new Date().toISOString() }) + .eq('id', reportId); + + await logAuditEvent({ + entityType: 'report', + entityId: reportId, + action: 'soft_delete', + userId, + purpose: 'user_requested_deletion', + }); +} + +// Versioning: nieuwe versie aanmaken, link naar vorige +async function updateReport(reportId: string, newContent: string, userId: string) { + const { data: original } = await supabase + .from('reports') + .select('*') + .eq('id', reportId) + .single(); + + // Maak nieuwe versie aan + const { data: newVersion } = await supabase + .from('reports') + .insert({ + ...original, + id: undefined, // nieuwe UUID + content: newContent, + version: original.version + 1, + previous_version_id: original.id, + updated_at: new Date().toISOString(), + }) + .select() + .single(); + + // Soft-delete de oude versie + await supabase + .from('reports') + .update({ deleted_at: new Date().toISOString() }) + .eq('id', reportId); + + return newVersion; +} +``` + +--- + +## 4. Multi-Tenancy + +### 4.1 Isolatiemodel: Shared Database + RLS + +We kiezen voor een shared database met Row Level Security. Dit is de pragmatische keuze voor de Supabase-stack: + +**Waarom shared database + RLS**: +- Één codebase, één database, geen per-tenant infra +- Supabase RLS is PostgreSQL-native (bewezen technologie) +- Schaalbaar tot ~100 tenants zonder schema-explosie +- Eenvoudiger te beheren dan separate databases + +**Waarom NIET separate databases (nu)**: +- Operationele complexiteit (migraties per tenant, backups per tenant) +- Supabase ondersteunt multi-database niet out of the box +- Pas relevant bij >100 tenants of bij contractuele data-isolatie eisen + +### 4.2 RLS-implementatie + +```sql +-- Elke tabel met tenant_id krijgt deze policy +ALTER TABLE patients ENABLE ROW LEVEL SECURITY; +ALTER TABLE reports ENABLE ROW LEVEL SECURITY; +ALTER TABLE appointments ENABLE ROW LEVEL SECURITY; +ALTER TABLE treatment_plans ENABLE ROW LEVEL SECURITY; +ALTER TABLE consents ENABLE ROW LEVEL SECURITY; +ALTER TABLE patient_assignments ENABLE ROW LEVEL SECURITY; + +-- Basis tenant-isolatie policy (template voor alle tabellen) +CREATE POLICY tenant_isolation ON patients + USING (tenant_id = ( + SELECT tenant_id FROM users WHERE id = auth.uid() + )) + WITH CHECK (tenant_id = ( + SELECT tenant_id FROM users WHERE id = auth.uid() + )); + +-- Verfijnde policy: alleen toegewezen patiënten (voor klinische rollen) +CREATE POLICY assigned_patients_only ON patients + FOR SELECT + USING ( + tenant_id = (SELECT tenant_id FROM users WHERE id = auth.uid()) + AND ( + -- Gebruiker is toegewezen aan patiënt + id IN ( + SELECT patient_id FROM patient_assignments + WHERE user_id = auth.uid() AND active = true + ) + -- OF gebruiker heeft 'alle_patienten' permissie (bijv. admin, dienstdoend arts) + OR EXISTS ( + SELECT 1 FROM users + WHERE id = auth.uid() + AND 'alle_patienten' = ANY(permissions) + ) + ) + ); +``` + +### 4.3 Tenant-context in de applicatie + +```typescript +// middleware.ts — Zet tenant context voor elke request +import { NextResponse } from 'next/server'; +import { createMiddlewareClient } from '@/lib/supabase/middleware'; + +export async function middleware(request: NextRequest) { + const supabase = createMiddlewareClient(request); + const { data: { user } } = await supabase.auth.getUser(); + + if (!user) { + return NextResponse.redirect(new URL('/login', request.url)); + } + + // Haal tenant op uit user metadata (gezet bij registratie/SSO) + const tenantId = user.user_metadata?.tenant_id; + + if (!tenantId) { + return NextResponse.redirect(new URL('/onboarding', request.url)); + } + + // Zet als header zodat Server Components het kunnen lezen + const response = NextResponse.next(); + response.headers.set('x-tenant-id', tenantId); + return response; +} +``` + +### 4.4 Tenant-specifieke configuratie + +```typescript +// Instellingen per tenant (opgeslagen in tenants.settings JSONB) +interface TenantSettings { + // Rapportage + reportTypes: ReportType[]; // Welke report types beschikbaar zijn + nursingCategories: NursingCategory[]; // Welke categorieën + shiftChangeHour: number; // Standaard 7, configureerbaar + + // Intent systeem + enabledIntents: CortexIntent[]; // Welke intents actief zijn + cortexLanguage: 'nl' | 'en'; // Taal voor intent classificatie + enableVoiceInput: boolean; // Deepgram aan/uit + + // Protocol Engine / Nudge + enableNudges: boolean; + protocolSources: string[]; // Welke protocollen geladen + + // Compliance + auditRetentionYears: number; // Standaard 7 + requireMFA: boolean; + sessionTimeoutMinutes: number; // Standaard 15 + + // Branding (optioneel) + logoUrl?: string; + primaryColor?: string; +} +``` + +--- + +## 5. Audit Trail (NEN 7513) + +### 5.1 Waarom dit niet-onderhandelbaar is + +NEN 7513 schrijft voor dat alle toegang tot en wijziging van patiëntgegevens gelogd moet worden. Dit is geen nice-to-have — het is wettelijk verplicht voor elke zorginstelling in Nederland. Bij een audit moet je kunnen aantonen: **wie** heeft **wat** gedaan, **wanneer**, **waar**, en **waarom**. + +### 5.2 Immutable audit log + +```sql +-- Audit log tabel — write-once, NOOIT updaten of verwijderen +CREATE TABLE audit_logs ( + id BIGSERIAL PRIMARY KEY, + event_id UUID NOT NULL UNIQUE DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL, + + -- WIE + user_id UUID NOT NULL, + user_role TEXT NOT NULL, + user_name TEXT NOT NULL, -- Gedenormaliseerd (naam kan later wijzigen) + + -- WAT + entity_type TEXT NOT NULL, -- 'patient', 'report', 'appointment', 'treatment_plan' + entity_id UUID NOT NULL, + action TEXT NOT NULL, -- 'create', 'read', 'update', 'soft_delete', 'export' + + -- WANNEER + timestamp TIMESTAMPTZ NOT NULL DEFAULT now(), + + -- WAAR + ip_address INET, + user_agent TEXT, + session_id UUID, + source TEXT NOT NULL DEFAULT 'ui', -- 'ui', 'intent_system', 'api', 'scheduled_job' + + -- WAAROM + purpose TEXT NOT NULL, -- 'klinische_zorg', 'overdracht', 'audit_review', 'onderzoek' + cortex_intent TEXT, -- Als actie via intent systeem kwam + + -- INTEGRITEIT + data_hash TEXT NOT NULL, -- SHA-256 hash van wie+wat+wanneer + previous_hash TEXT, -- Keten-hash voor integriteitsverificatie + + -- CONTEXT + metadata JSONB DEFAULT '{}' -- Aanvullende context (bijv. gewijzigde velden) +) PARTITION BY RANGE (timestamp); + +-- Maandelijkse partities (nodig bij miljoenen events per jaar) +CREATE TABLE audit_logs_2026_01 PARTITION OF audit_logs + FOR VALUES FROM ('2026-01-01') TO ('2026-02-01'); +CREATE TABLE audit_logs_2026_02 PARTITION OF audit_logs + FOR VALUES FROM ('2026-02-01') TO ('2026-03-01'); +-- etc. — automatiseer met pg_partman of een cron job + +-- IMMUTABILITEIT: triggers die UPDATE en DELETE blokkeren +CREATE OR REPLACE FUNCTION prevent_audit_mutation() +RETURNS TRIGGER AS $$ +BEGIN + RAISE EXCEPTION 'Audit logs zijn immutable — wijzigen of verwijderen is niet toegestaan'; +END; +$$ LANGUAGE plpgsql; + +CREATE TRIGGER audit_no_update + BEFORE UPDATE ON audit_logs + FOR EACH ROW EXECUTE FUNCTION prevent_audit_mutation(); + +CREATE TRIGGER audit_no_delete + BEFORE DELETE ON audit_logs + FOR EACH ROW EXECUTE FUNCTION prevent_audit_mutation(); + +-- Indexes voor forensische queries +CREATE INDEX idx_audit_tenant_time ON audit_logs(tenant_id, timestamp DESC); +CREATE INDEX idx_audit_entity ON audit_logs(entity_type, entity_id, timestamp DESC); +CREATE INDEX idx_audit_user ON audit_logs(user_id, timestamp DESC); +CREATE INDEX idx_audit_patient_access ON audit_logs(entity_id) + WHERE entity_type = 'patient'; +``` + +### 5.3 Applicatie-integratie + +```typescript +// lib/audit/logger.ts +import crypto from 'crypto'; +import { createClient } from '@/lib/auth/server'; + +interface AuditEventInput { + entityType: string; + entityId: string; + action: string; + purpose: string; + cortexIntent?: string; // Welke intent triggerde dit? + metadata?: Record; +} + +export async function logAuditEvent(input: AuditEventInput) { + const supabase = await createClient(); + const { data: { user } } = await supabase.auth.getUser(); + + if (!user) throw new Error('Audit log vereist geauthenticeerde user'); + + // Bereken hash voor integriteitsverificatie + const hashPayload = JSON.stringify({ + userId: user.id, + entityType: input.entityType, + entityId: input.entityId, + action: input.action, + timestamp: new Date().toISOString(), + }); + const dataHash = crypto.createHash('sha256').update(hashPayload).digest('hex'); + + // Haal vorige hash op voor keten-integriteit + const { data: lastEvent } = await supabase + .from('audit_logs') + .select('data_hash') + .eq('entity_type', input.entityType) + .eq('entity_id', input.entityId) + .order('timestamp', { ascending: false }) + .limit(1) + .single(); + + await supabase.from('audit_logs').insert({ + tenant_id: user.user_metadata.tenant_id, + user_id: user.id, + user_role: user.user_metadata.role, + user_name: user.user_metadata.full_name, + entity_type: input.entityType, + entity_id: input.entityId, + action: input.action, + purpose: input.purpose, + cortex_intent: input.cortexIntent, + source: input.cortexIntent ? 'intent_system' : 'ui', + data_hash: dataHash, + previous_hash: lastEvent?.data_hash ?? null, + metadata: input.metadata ?? {}, + }); +} + +// Gebruik in elke API route: +// Na rapport aanmaken: +await logAuditEvent({ + entityType: 'report', + entityId: newReport.id, + action: 'create', + purpose: 'klinische_zorg', + cortexIntent: 'dagnotitie', // Als via intent systeem + metadata: { reportType: 'verpleegkundig', category: 'observatie' }, +}); + +// Na patiëntdossier openen: +await logAuditEvent({ + entityType: 'patient', + entityId: patientId, + action: 'read', + purpose: 'klinische_zorg', +}); +``` + +### 5.4 Forensische queries + +```sql +-- "Wie heeft patiënt X bekeken in de laatste 30 dagen?" +SELECT user_name, user_role, action, timestamp, purpose, cortex_intent +FROM audit_logs +WHERE entity_type = 'patient' AND entity_id = $1 +AND timestamp > now() - interval '30 days' +ORDER BY timestamp DESC; + +-- "Alle acties van gebruiker Y vandaag" +SELECT entity_type, entity_id, action, purpose, timestamp +FROM audit_logs +WHERE user_id = $1 AND timestamp::date = CURRENT_DATE +ORDER BY timestamp DESC; + +-- "Alle wijzigingen aan rapport Z met versiegeschiedenis" +SELECT action, timestamp, user_name, metadata +FROM audit_logs +WHERE entity_type = 'report' AND entity_id = $1 +ORDER BY timestamp ASC; + +-- Anomalie detectie: "Wie heeft >50 patiëntdossiers geopend in 1 uur?" +SELECT user_id, user_name, COUNT(*) as access_count +FROM audit_logs +WHERE entity_type = 'patient' AND action = 'read' +AND timestamp > now() - interval '1 hour' +GROUP BY user_id, user_name +HAVING COUNT(*) > 50; +``` + +--- + +## 6. Toegangscontrole (RBAC + ABAC) + +### 6.1 Rollenmodel + +GGZ-instellingen hebben een complex rollenmodel. We implementeren een hybride RBAC + ABAC systeem. + +**RBAC basis** (wie mag in principe wat): + +| Rol | Patiënt lezen | Rapport schrijven | Behandelplan | Audit log | Systeem config | +|-----|--------------|-------------------|--------------|-----------|----------------| +| `verpleegkundige` | Toegewezen | Ja | Lezen | Nee | Nee | +| `arts` | Afdeling | Ja | Schrijven | Nee | Nee | +| `psycholoog` | Toegewezen | Ja | Schrijven | Nee | Nee | +| `hoofdbehandelaar` | Afdeling | Ja | Goedkeuren | Nee | Nee | +| `admin` | Alle | Nee | Nee | Lezen | Ja | +| `audit` | Alle (read-only) | Nee | Nee | Alle | Nee | + +**ABAC verfijning** (context-afhankelijke regels): + +```typescript +// lib/access-control/policies.ts + +interface AccessPolicy { + id: string; + name: string; + description: string; + conditions: PolicyCondition[]; + effect: 'allow' | 'deny'; +} + +type PolicyCondition = + | { type: 'role'; roles: string[] } + | { type: 'assignment'; required: boolean } // Moet toegewezen zijn aan patiënt + | { type: 'time_window'; start: string; end: string } // Tijdsvenster (Wvggz) + | { type: 'consent'; consentType: string } // Toestemming vereist + | { type: 'legal_status'; statuses: string[] } // Juridische status patiënt + | { type: 'data_classification'; maxLevel: string }; // Data gevoeligheidsniveau + +// Voorbeeld: Toegang tot Wvggz-patiëntdossier +const wvggzAccessPolicy: AccessPolicy = { + id: 'wvggz-patient-access', + name: 'Wvggz patiënt toegangsbeleid', + description: 'Beperkte toegang voor patiënten onder Wvggz-maatregel', + conditions: [ + { type: 'role', roles: ['arts', 'verpleegkundige', 'psycholoog'] }, + { type: 'assignment', required: true }, + { type: 'consent', consentType: 'wvggz_zorgmachtiging' }, + ], + effect: 'allow', +}; +``` + +### 6.2 Policy evaluatie + +```typescript +// lib/access-control/evaluator.ts + +export async function evaluateAccess(request: { + userId: string; + action: 'read' | 'write' | 'delete'; + resource: string; // 'patient', 'report', 'treatment_plan' + resourceId: string; + tenantId: string; +}): Promise<{ allowed: boolean; reason?: string }> { + + const user = await getUser(request.userId); + const policies = await getPoliciesForResource(request.resource, request.tenantId); + + for (const policy of policies) { + const result = await evaluatePolicy(policy, { user, ...request }); + + if (policy.effect === 'deny' && result.matched) { + // Deny altijd voorrang + return { allowed: false, reason: result.reason }; + } + + if (policy.effect === 'allow' && result.matched) { + return { allowed: true }; + } + } + + // Default deny (principle of least privilege) + return { allowed: false, reason: 'Geen toepasselijk beleid gevonden' }; +} +``` + +--- + +## 7. Encryptie & Data Bescherming + +### 7.1 Encryptie strategie + +| Laag | Methode | Wat | +|------|---------|-----| +| **In transit** | TLS 1.3 | Alle verbindingen client ↔ server ↔ database | +| **At rest (database)** | Supabase managed (AES-256) | Volledige database encryptie | +| **At rest (velden)** | Application-level AES-256-GCM | BSN, diagnose, medicatie in audit logs | +| **Backup** | Versleutelde backups | Point-in-time recovery met encrypted storage | + +### 7.2 Gevoelige velden — application-level encryptie + +```typescript +// lib/encryption/field-encryption.ts +import crypto from 'crypto'; + +const ALGORITHM = 'aes-256-gcm'; +// Key management: gebruik Supabase Vault of AWS KMS in productie +const ENCRYPTION_KEY = Buffer.from(process.env.FIELD_ENCRYPTION_KEY!, 'hex'); + +export function encryptField(plaintext: string): string { + const iv = crypto.randomBytes(16); + const cipher = crypto.createCipheriv(ALGORITHM, ENCRYPTION_KEY, iv); + + let encrypted = cipher.update(plaintext, 'utf8', 'hex'); + encrypted += cipher.final('hex'); + const authTag = cipher.getAuthTag(); + + // Format: iv:authTag:ciphertext + return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`; +} + +export function decryptField(encrypted: string): string { + const [ivHex, authTagHex, ciphertext] = encrypted.split(':'); + const decipher = crypto.createDecipheriv( + ALGORITHM, ENCRYPTION_KEY, Buffer.from(ivHex, 'hex') + ); + decipher.setAuthTag(Buffer.from(authTagHex, 'hex')); + + let decrypted = decipher.update(ciphertext, 'hex', 'utf8'); + decrypted += decipher.final('utf8'); + return decrypted; +} + +// BSN opslaan: hash voor lookup, encrypted voor weergave +export function storeBSN(bsn: string) { + return { + bsn_hash: crypto.createHash('sha256').update(bsn).digest('hex'), + bsn_encrypted: encryptField(bsn), + }; +} +``` + +### 7.3 PII in AI prompts — minimalisatie + +```typescript +// lib/cortex/pii-filter.ts +// AI prompts krijgen NOOIT direct identificeerbare patiëntgegevens + +export function sanitizeForAI(context: PatientContext): SanitizedContext { + return { + patientRef: `P-${context.patientId.slice(0, 8)}`, // Geen naam, geen BSN + age: calculateAge(context.dateOfBirth), // Leeftijd, geen geboortedatum + gender: context.gender, + activeConditions: context.conditions, // Klinisch relevant + recentReportCount: context.recentReports.length, // Alleen count + legalStatus: context.legalStatus, // Relevant voor Wvggz nudges + // NIET meesturen: naam, BSN, adres, contactgegevens + }; +} +``` + +--- + +## 8. FHIR Interoperabiliteit + +### 8.1 Strategie: FHIR-compatible, niet FHIR-native + +We slaan data op in ons eigen PostgreSQL-model (optimaal voor onze use case) en bieden FHIR R4 export endpoints aan voor interoperabiliteit met andere systemen. + +**Waarom niet FHIR-native**: +- FHIR resources zijn generiek — ons model is geoptimaliseerd voor GGZ +- Volledige FHIR server (HAPI) is Java/heavy — past niet bij onze stack +- Nederlandse EPD-markt verwacht FHIR export, niet FHIR storage + +### 8.2 FHIR export endpoints + +```typescript +// app/api/fhir/Patient/[id]/route.ts +// Vertaalt ons interne model naar FHIR R4 Patient resource + +export async function GET(req: Request, { params }: { params: { id: string } }) { + const supabase = await createClient(); + + const { data: patient } = await supabase + .from('patients') + .select('*') + .eq('id', params.id) + .single(); + + if (!patient) return Response.json({ error: 'Patient not found' }, { status: 404 }); + + // Log FHIR export in audit trail + await logAuditEvent({ + entityType: 'patient', + entityId: params.id, + action: 'export', + purpose: 'fhir_interoperability', + }); + + // Vertaal naar FHIR R4 + const fhirPatient = { + resourceType: 'Patient', + id: patient.id, + identifier: patient.bsn_hash ? [{ + system: 'http://fhir.nl/NamingSystem/bsn', + value: patient.bsn_hash, // Hash, niet de echte BSN + }] : [], + name: [{ + text: patient.full_name, + family: patient.full_name.split(' ').pop(), + given: patient.full_name.split(' ').slice(0, -1), + }], + gender: mapGender(patient.gender), + birthDate: patient.date_of_birth, + active: patient.status === 'actief', + }; + + return Response.json(fhirPatient, { + headers: { 'Content-Type': 'application/fhir+json' }, + }); +} + +// FHIR Bundle export (alle data van een patiënt) +// app/api/fhir/Patient/[id]/$everything/route.ts +export async function GET(req: Request, { params }: { params: { id: string } }) { + const patient = await getFHIRPatient(params.id); + const observations = await getFHIRObservations(params.id); + const conditions = await getFHIRConditions(params.id); + + return Response.json({ + resourceType: 'Bundle', + type: 'searchset', + total: 1 + observations.length + conditions.length, + entry: [ + { resource: patient }, + ...observations.map(o => ({ resource: o })), + ...conditions.map(c => ({ resource: c })), + ], + }); +} +``` + +### 8.3 CDS Hooks integratie + +```typescript +// app/api/cds-hooks/patient-view/route.ts +// Wordt aangeroepen wanneer een clinicus een patiëntdossier opent +// Retourneert nudge-achtige suggesties in CDS Hooks formaat + +export async function POST(req: Request) { + const body = await req.json(); + const patientId = body.context?.patientId; + + // Evalueer protocol regels (dezelfde logic als Nudge systeem) + const nudges = await evaluateProtocolRules(patientId); + + // Vertaal naar CDS Hooks cards + const cards = nudges.map(nudge => ({ + uuid: nudge.id, + summary: nudge.message, + indicator: nudge.priority === 'P1' ? 'critical' : 'info', + source: { + label: nudge.source, // 'GGZ Standaard Depressie' + url: nudge.sourceUrl, + }, + suggestions: nudge.suggestedAction ? [{ + label: nudge.suggestedAction.label, + actions: [{ + type: 'create', + description: nudge.suggestedAction.description, + resource: nudge.suggestedAction.fhirResource, + }], + }] : [], + })); + + return Response.json({ cards }); +} +``` + +--- + +## 9. Observability & Monitoring + +### 9.1 Drie pijlers + +| Pijler | Tool | Wat | +|--------|------|-----| +| **Logs** | Pino → stdout → log aggregator | Gestructureerde JSON logs, PII-gefilterd | +| **Metrics** | OpenTelemetry → Grafana/Datadog | Latency, error rate, classificatie-snelheid | +| **Traces** | OpenTelemetry | Request flow door de hele pipeline | + +### 9.2 Cortex-specifieke metrics + +```typescript +// lib/observability/cortex-metrics.ts + +// Metrics die we tracken per intent classificatie: +interface ClassificationMetrics { + totalClassifications: Counter; + reflexHits: Counter; // Opgelost door Reflex (snel) + orchestratorFallbacks: Counter; // Doorverwezen naar LLM (langzaam) + classificationLatency: Histogram; // ms per classificatie + confidenceDistribution: Histogram; // Verdeling van confidence scores + intentDistribution: Counter; // Welke intents het meest voorkomen + entityExtractionErrors: Counter; // Mislukte entity extractie + nudgeSuggestions: Counter; // Aantal nudge suggesties gegeven + nudgeAccepted: Counter; // Aantal nudges geaccepteerd door gebruiker +} + +// Dashboard alerts: +// - Reflex hit rate < 60% → patronen moeten geüpdatet worden +// - Orchestrator latency p95 > 3s → AI provider probleem +// - Entity extraction error rate > 5% → extractie regels reviewen +// - Nudge acceptance rate < 10% → nudges zijn niet relevant genoeg +``` + +### 9.3 Health checks + +```typescript +// app/api/health/route.ts +export async function GET() { + const checks = await Promise.allSettled([ + checkDatabase(), + checkAnthropicAPI(), + checkDeepgram(), + checkSupabaseAuth(), + ]); + + const status = checks.every(c => c.status === 'fulfilled') ? 'healthy' : 'degraded'; + + return Response.json({ + status, + timestamp: new Date().toISOString(), + checks: { + database: checks[0].status === 'fulfilled' ? 'up' : 'down', + ai: checks[1].status === 'fulfilled' ? 'up' : 'down', + speech: checks[2].status === 'fulfilled' ? 'up' : 'down', + auth: checks[3].status === 'fulfilled' ? 'up' : 'down', + }, + // Graceful degradation status + capabilities: { + intentClassification: checks[1].status === 'fulfilled' ? 'full' : 'reflex_only', + voiceInput: checks[2].status === 'fulfilled' ? 'available' : 'unavailable', + reporting: checks[0].status === 'fulfilled' ? 'available' : 'unavailable', + }, + }); +} +``` + +--- + +## 10. Resilience & Graceful Degradation + +### 10.1 Drie degradatieniveaus + +Het systeem moet altijd blijven functioneren, ook als externe services uitvallen. + +``` +Niveau 0: VOLLEDIG OPERATIONEEL +├── Intent systeem: Reflex + Orchestrator (LLM) +├── Spraak: Deepgram beschikbaar +├── Nudges: Protocol Engine actief +└── Alle functies beschikbaar + +Niveau 1: VERMINDERD (AI niet beschikbaar) +├── Intent systeem: Alleen Reflex (lokale patronen) +│ → ~70% van intents wordt nog herkend +│ → Complexe/ambigue input krijgt "niet begrepen" melding +├── Spraak: Deepgram beschikbaar (of ook uit → alleen tekst) +├── Nudges: Alleen statische regels (geen AI-suggesties) +└── Traditionele UI: Volledig beschikbaar ✓ + +Niveau 2: MINIMAAL (database traag/beperkt) +├── Intent systeem: Uit +├── Traditionele UI: Read-only modus +├── Nieuwe rapportages: Lokaal gebufferd, sync later +└── Banner: "Beperkte beschikbaarheid — sommige functies zijn tijdelijk niet beschikbaar" +``` + +### 10.2 Circuit breaker voor AI providers + +```typescript +// lib/resilience/circuit-breaker.ts + +interface CircuitBreakerState { + status: 'closed' | 'open' | 'half-open'; + failureCount: number; + lastFailure: Date | null; + nextAttempt: Date | null; +} + +const AI_CIRCUIT_BREAKER: CircuitBreakerState = { + status: 'closed', + failureCount: 0, + lastFailure: null, + nextAttempt: null, +}; + +const MAX_FAILURES = 3; +const RECOVERY_TIME_MS = 30_000; // 30 seconden + +export async function callWithCircuitBreaker( + fn: () => Promise, + fallback: () => T, +): Promise { + if (AI_CIRCUIT_BREAKER.status === 'open') { + if (AI_CIRCUIT_BREAKER.nextAttempt && new Date() > AI_CIRCUIT_BREAKER.nextAttempt) { + AI_CIRCUIT_BREAKER.status = 'half-open'; + } else { + return fallback(); // Gebruik fallback (Reflex-only) + } + } + + try { + const result = await fn(); + if (AI_CIRCUIT_BREAKER.status === 'half-open') { + AI_CIRCUIT_BREAKER.status = 'closed'; + AI_CIRCUIT_BREAKER.failureCount = 0; + } + return result; + } catch (error) { + AI_CIRCUIT_BREAKER.failureCount++; + AI_CIRCUIT_BREAKER.lastFailure = new Date(); + + if (AI_CIRCUIT_BREAKER.failureCount >= MAX_FAILURES) { + AI_CIRCUIT_BREAKER.status = 'open'; + AI_CIRCUIT_BREAKER.nextAttempt = new Date(Date.now() + RECOVERY_TIME_MS); + } + + return fallback(); + } +} +``` + +--- + +## 11. Nederlandse Zorgwetgeving — Compliance Matrix + +### 11.1 Relevante wetgeving en impact op architectuur + +| Wet | Wat het regelt | Impact op het systeem | +|-----|---------------|---------------------| +| **Wlz** (Wet langdurige zorg) | Recht op langdurige zorg | Moet zorgindicaties kunnen registreren en rapporteren | +| **Wvggz** (Wet verplichte GGZ) | Verplichte/onvrijwillige zorg | Legal status tracking, extra audit requirements, toestemmingsregistratie | +| **Wkkgz** (Wet kwaliteit klachten geschillen zorg) | Kwaliteit en veiligheid | Incident-rapportage (MIC), klachtenregistratie, dossierplicht | +| **Wmcz** (Wet medezeggenschap cliënten zorginstellingen) | Cliëntenparticipatie | Niet direct, maar relevant voor governance | +| **AVG/GDPR** | Persoonsgegevens bescherming | Toestemming, recht op inzage, dataportabiliteit, DPIA | +| **NEN 7510** | Informatiebeveiliging zorg | RBAC, encryptie, access control, incident management | +| **NEN 7512** | Veilige gegevensuitwisseling | TLS, authenticatie bij data-export, FHIR security | +| **NEN 7513** | Logging van zorggebeurtenissen | Immutable audit trail, 7 jaar bewaarplicht | +| **BIG-wet** | Registratie zorgverleners | BIG-nummer opslaan bij gebruikers, verifiëren | + +### 11.2 Wvggz-specifieke functionaliteit + +De Wvggz verdient extra aandacht omdat het direct impact heeft op het datamodel en de toegangscontrole: + +```typescript +// Juridische statussen die het systeem moet ondersteunen +type LegalStatus = + | 'vrijwillig' // Vrijwillige opname + | 'wvggz_zorgmachtiging' // Rechterlijke zorgmachtiging + | 'wvggz_crisismaatregel' // Burgemeester-crisismaatregel + | 'wvggz_machtiging_voortgezet' // Voortgezette crisismaatregel + | 'wzd_rechterlijke_machtiging'; // Wet zorg en dwang (andere doelgroep) + +// Impact op toegang: +// - Wvggz-patiënten: extra logging bij elke dossierinzage +// - Wvggz-patiënten: toestemmingsregistratie verplicht +// - Wvggz-patiënten: dwangmaatregelen moeten geregistreerd worden +// - Wvggz-patiënten: periodieke evaluatie door geneesheer-directeur + +// Impact op Nudge systeem: +// Protocol Engine regel voorbeeld: +// "Als patient.legalStatus = 'wvggz_zorgmachtiging' +// EN laatste evaluatie > 6 maanden geleden +// → Nudge: 'Evaluatie zorgmachtiging is verlopen, plan evaluatie in'" +``` + +--- + +## 12. Knowledge Layer — Detail + +### 12.1 Vier kennisbronnen + +De Knowledge Layer is de tweede unieke component van het systeem. Het voedt de Protocol Engine (Nudge) met actuele, verifieerbare kennis. + +``` +┌─────────────────────────────────────────────────────────────┐ +│ KNOWLEDGE LAYER │ +│ │ +│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ +│ │ 1. WETGEVING │ │ 2. PROTOCOLLEN│ │ 3. KWALITEITS│ │ +│ │ │ │ │ │ DOCUMENTEN │ │ +│ │ Wlz, Wvggz │ │ GGZ Std. │ │ │ │ +│ │ Wkkgz, NEN │ │ V&VN, FMS │ │ Instelling- │ │ +│ │ 7510/12/13 │ │ NHG, CBO │ │ specifiek │ │ +│ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │ +│ │ │ │ │ +│ └────────┬────────┴──────────────────┘ │ +│ ▼ │ +│ ┌──────────────────────────────────────────────┐ │ +│ │ PROTOCOL RULES ENGINE │ │ +│ │ Gevalideerde regels met bron-verwijzing │ │ +│ │ (completedAction, rules) → suggestions[] │ │ +│ └──────────────────┬───────────────────────────┘ │ +│ │ │ +│ ┌──────────────────┴───────────────────────────┐ │ +│ │ 4. EPD DATA (eigen data) │ │ +│ │ Patiëntgegevens, rapportages, behandelplannen│ │ +│ │ → Data-driven conditions voor nudges │ │ +│ └──────────────────────────────────────────────┘ │ +└─────────────────────────────────────────────────────────────┘ +``` + +### 12.2 Protocol Rule structuur + +```typescript +// lib/knowledge/protocol-rule.ts + +interface ProtocolRule { + id: string; + name: string; + description: string; + + // Bron + source: { + type: 'wetgeving' | 'richtlijn' | 'instelling' | 'epd_data' | 'ai_suggested'; + name: string; // "GGZ Standaard Depressie v3.0" + section?: string; // "Hoofdstuk 4.2 - Medicatiebewaking" + url?: string; // Link naar bron + version: string; + }; + + // Validatie + validatedBy: string; // userId van validator + validatedAt: Date; + status: 'concept' | 'gevalideerd' | 'actief' | 'verlopen'; + + // Trigger + trigger: { + afterIntent?: CortexIntent[]; // Na welke intents evalueren + afterAction?: string[]; // Na welke acties + schedule?: string; // Cron voor periodieke checks + }; + + // Conditie + condition: RuleCondition; + + // Actie + suggestion: { + message: string; // "Overweeg lithiumspiegel te controleren" + priority: 'P1' | 'P2' | 'P3'; + suggestedIntent?: CortexIntent; // Welke intent als vervolgactie + evidence: string; // "Volgens GGZ Standaard Bipolair §4.3" + }; +} + +// Condities kunnen statisch of data-driven zijn +type RuleCondition = + | { type: 'static'; check: (context: RuleContext) => boolean } + | { type: 'query'; table: string; filter: Record; expect: 'exists' | 'not_exists' | 'count_gt' | 'count_lt'; threshold?: number }; + +// Voorbeeld: data-driven conditie +const medicatieReviewRule: ProtocolRule = { + id: 'med-review-quarterly', + name: 'Kwartaal medicatiereview', + description: 'Herinnering voor medicatiereview elke 3 maanden', + source: { + type: 'richtlijn', + name: 'GGZ Standaard Psychose', + section: '6.3 Medicatiebewaking', + version: '2024.1', + }, + validatedBy: 'user-uuid-arts', + validatedAt: new Date('2026-01-15'), + status: 'actief', + trigger: { afterIntent: ['dagnotitie', 'overdracht'] }, + condition: { + type: 'query', + table: 'reports', + filter: { + patient_id: '$activePatient', + report_type: 'medicatie', + 'structured_data->category': 'review', + }, + expect: 'not_exists', // Geen medicatiereview gevonden + // in de laatste 90 dagen (impliciet via created_at filter) + }, + suggestion: { + message: 'Laatste medicatiereview is >3 maanden geleden. Overweeg een review in te plannen.', + priority: 'P2', + suggestedIntent: 'create_appointment', + evidence: 'GGZ Standaard Psychose §6.3: "Evalueer medicatie minimaal elke 3 maanden"', + }, +}; +``` + +### 12.3 RAG voor protocolkennis + +Voor het ontsluiten van omvangrijke protocolteksten (GGZ Standaarden zijn honderden pagina's) gebruiken we RAG (Retrieval-Augmented Generation): + +```typescript +// lib/knowledge/rag-pipeline.ts + +// Stap 1: Indexeer protocoldocumenten (eenmalig of bij update) +// Gebruik pgvector in Supabase voor vector storage + +// Tabel: +// protocol_chunks (id, source_id, chunk_text, embedding vector(1536), metadata jsonb) + +// Stap 2: Bij een nudge-evaluatie, zoek relevante chunks +async function findRelevantProtocolChunks(query: string, topK: number = 5) { + const embedding = await generateEmbedding(query); // OpenAI of Anthropic + + const { data } = await supabase.rpc('match_protocol_chunks', { + query_embedding: embedding, + match_threshold: 0.7, + match_count: topK, + }); + + return data; // Relevante protocolfragmenten +} + +// Stap 3: AI suggereert candidate rules op basis van protocol +// Mens (arts/kwaliteitsmedewerker) valideert en activeert +async function suggestRulesFromProtocol(protocolId: string) { + const chunks = await getProtocolChunks(protocolId); + + const suggestions = await anthropic.messages.create({ + model: 'claude-sonnet-4-5-20250514', + system: `Je bent een klinische informaticus. Analyseer dit protocol en stel + concrete nudge-regels voor die een EPD-systeem kan evalueren. + Elke regel moet: een trigger, een conditie en een suggestie bevatten. + Verwijs naar het exacte hoofdstuk/paragraaf.`, + messages: [{ role: 'user', content: chunks.map(c => c.text).join('\n\n') }], + }); + + // Parse suggestions → ProtocolRule[] met status 'ai_suggested' + // Toon in admin UI voor validatie door arts + return parseSuggestedRules(suggestions, { status: 'ai_suggested' }); +} +``` + +**Trade-off: Rules vs RAG**: +- **Rules** (handmatig gevalideerd): Betrouwbaar, traceerbaar, maar arbeidsintensief +- **RAG** (AI-gesuggereerd): Schaalbaar, maar vereist menselijke validatie +- **Onze keuze**: RAG voor candidate generation, mens voor validatie. Nooit automatisch actief. + +--- + +## 13. API Structuur + +### 13.1 Route-indeling + +``` +app/api/ +├── auth/ # Authenticatie (Supabase Auth wrappers) +│ ├── login/route.ts +│ ├── logout/route.ts +│ └── callback/route.ts # SSO callback +│ +├── patients/ # Patiënt CRUD +│ ├── route.ts # GET (lijst), POST (aanmaken) +│ ├── [id]/route.ts # GET, PATCH (details) +│ └── [id]/assignments/route.ts +│ +├── reports/ # Rapportage CRUD +│ ├── route.ts # GET (lijst met filters), POST +│ └── [id]/route.ts # GET, PATCH, DELETE (soft) +│ +├── treatment-plans/ # Behandelplannen +│ ├── route.ts +│ └── [id]/route.ts +│ +├── appointments/ # Agenda +│ ├── route.ts +│ └── [id]/route.ts +│ +├── cortex/ # Intent systeem +│ ├── classify/route.ts # POST: tekst → intent + entities +│ ├── chat/route.ts # POST: streaming chat (SSE) +│ ├── context/route.ts # GET: huidige context +│ └── nudge/route.ts # GET: evalueer nudges voor context +│ +├── overdracht/ # Overdracht / handover +│ ├── route.ts # GET: overzicht +│ ├── [patientId]/route.ts # GET: patient detail +│ └── generate/route.ts # POST: AI samenvatting genereren +│ +├── fhir/ # FHIR R4 export +│ ├── Patient/[id]/route.ts +│ ├── Observation/route.ts +│ └── Bundle/route.ts +│ +├── cds-hooks/ # CDS Hooks endpoints +│ └── patient-view/route.ts +│ +├── audit/ # Audit log queries (admin only) +│ ├── route.ts # GET: zoeken in logs +│ └── export/route.ts # GET: CSV/JSON export +│ +├── admin/ # Systeembeheer +│ ├── tenants/route.ts +│ ├── users/route.ts +│ └── settings/route.ts +│ +├── health/route.ts # Health check endpoint +└── deepgram/route.ts # Speech-to-text proxy +``` + +### 13.2 API route patroon + +```typescript +// Standaard patroon voor elke API route + +import { createClient } from '@/lib/auth/server'; +import { logAuditEvent } from '@/lib/audit/logger'; +import { evaluateAccess } from '@/lib/access-control/evaluator'; +import { z } from 'zod'; + +// 1. Zod schema voor validatie +const CreateReportSchema = z.object({ + patientId: z.string().uuid(), + reportType: z.enum(['voortgang', 'observatie', 'incident', /* ... */]), + content: z.string().min(1).max(10000), + structuredData: z.object({ + category: z.enum(['medicatie', 'adl', 'gedrag', 'incident', 'observatie']).optional(), + }).optional(), +}); + +export async function POST(req: Request) { + // 2. Auth check + const supabase = await createClient(); + const { data: { user } } = await supabase.auth.getUser(); + if (!user) return Response.json({ error: 'Niet geauthenticeerd' }, { status: 401 }); + + // 3. Input validatie + const body = await req.json(); + const parsed = CreateReportSchema.safeParse(body); + if (!parsed.success) { + return Response.json({ error: 'Ongeldige invoer', details: parsed.error.issues }, { status: 400 }); + } + + // 4. Toegangscontrole (RBAC + ABAC) + const access = await evaluateAccess({ + userId: user.id, + action: 'write', + resource: 'report', + resourceId: parsed.data.patientId, + tenantId: user.user_metadata.tenant_id, + }); + if (!access.allowed) { + return Response.json({ error: 'Geen toegang', reason: access.reason }, { status: 403 }); + } + + // 5. Business logic + const shiftDate = calculateShiftDate(new Date()); + const { data: report, error } = await supabase + .from('reports') + .insert({ + tenant_id: user.user_metadata.tenant_id, + patient_id: parsed.data.patientId, + author_id: user.id, + report_type: parsed.data.reportType, + content: parsed.data.content, + structured_data: parsed.data.structuredData ?? {}, + shift_date: shiftDate, + }) + .select() + .single(); + + if (error) return Response.json({ error: 'Fout bij opslaan' }, { status: 500 }); + + // 6. Audit log + await logAuditEvent({ + entityType: 'report', + entityId: report.id, + action: 'create', + purpose: 'klinische_zorg', + metadata: { reportType: parsed.data.reportType }, + }); + + // 7. Response + return Response.json(report, { status: 201 }); +} +``` + +--- + +## 14. EPD Modules + +### 14.1 Module-overzicht + +``` +app/epd/ +├── dashboard/ # Hoofddashboard + Cortex command center +├── patients/ # Patiëntenoverzicht en -beheer +│ └── [id]/ # Individueel patiëntdossier +│ ├── overzicht/ # Samenvattingsweergave +│ ├── rapportages/ # Rapportagegeschiedenis (tijdlijn) +│ ├── behandelplan/ # Behandelplan + doelen +│ ├── medicatie/ # Medicatieoverzicht +│ └── agenda/ # Patiënt-specifieke afspraken +├── rapportage/ # Rapportage-invoer workspace +│ └── nieuw/ # Nieuw rapport formulier +├── overdracht/ # Overdracht overzicht (dienstwisseling) +├── agenda/ # Team/persoonlijke agenda (FullCalendar) +├── clients/ # Cliëntbeheer (admin) +└── instellingen/ # Systeeminstellingen (admin) + ├── gebruikers/ # Gebruikersbeheer + ├── afdelingen/ # Afdelingsconfiguratie + ├── protocollen/ # Protocol/nudge regels beheer + └── audit/ # Audit log viewer +``` + +### 14.2 Intent → Module mapping + +Het intent-systeem navigeert naar of pre-fillt modules: + +| Intent | Module | Actie | +|--------|--------|-------| +| `dagnotitie` | rapportage/nieuw | Pre-fill formulier met patiënt, categorie, inhoud | +| `zoeken` | patients | Filter patiëntenlijst op zoekterm | +| `overdracht` | overdracht | Open overdracht met patiëntfocus | +| `agenda_query` | agenda | Filter op datum/patiënt | +| `create_appointment` | agenda | Open nieuw-afspraak formulier | +| `cancel_appointment` | agenda | Open annulerings-dialog | +| `reschedule_appointment` | agenda | Open verplaats-dialog | + +--- + +## 15. Bouwvolgorde + +### 15.1 Fasering + +``` +FASE 1: FUNDAMENT (maand 1-2) +├── Database schema + migraties +├── Auth + multi-tenancy (RLS) +├── Basis UI: patiëntenlijst, dossier, formulieren +├── Rapportage CRUD (het meest gebruikte scherm) +├── Audit trail (NEN 7513) — vanaf dag 1 meebouwen +└── Deliverable: werkend EPD zonder intent-systeem + +FASE 2: INTENT SYSTEEM MVP (maand 2-3) +├── Intent Registry (database-driven) +├── Reflex classifier (lokale patronen) +├── Command input overlay (⌘K) +├── 3-4 intents: dagnotitie, zoeken, overdracht, agenda_query +├── Pre-fill pattern: intent → open formulier met data +└── Deliverable: EPD + intent-laag voor routinetaken + +FASE 3: INTELLIGENCE (maand 3-4) +├── Orchestrator (LLM classificatie) +├── Entity resolution met fuzzy matching +├── Spraak-input (Deepgram) +├── Overdracht met AI-samenvatting +├── Nudge systeem v1 (statische regels) +└── Deliverable: slimme EPD met AI-assist + +FASE 4: KNOWLEDGE LAYER (maand 4-5) +├── Protocol Engine met gevalideerde regels +├── RAG pipeline voor protocoldocumenten +├── Eerste protocollen inladen (GGZ Standaarden) +├── Admin UI voor regelbeheer +└── Deliverable: evidence-based nudges + +FASE 5: COMPLIANCE & SCHAAL (maand 5-6) +├── FHIR R4 export endpoints +├── CDS Hooks integratie +├── Encryptie verfijning (field-level) +├── ABAC policies (Wvggz-specifiek) +├── Observability (Pino, OpenTelemetry) +├── Performance optimalisatie +└── Deliverable: compliance-ready systeem + +DOORLOPEND: +├── Testing (unit, integration, e2e) +├── CI/CD pipeline +├── Documentatie +└── Gebruikerstesten met zorgverleners +``` + +--- + +## 16. Beslissingenlog + +| # | Beslissing | Alternatieven overwogen | Rationale | +|---|-----------|------------------------|-----------| +| D1 | Modular monolith (geen microservices) | Microservices, serverless | Team <5 devs, operationele eenvoud, Supabase is al managed | +| D2 | Shared database + RLS (geen separate DBs) | Separate databases per tenant | Supabase-native, schaalbaar tot ~100 tenants, eenvoudiger migraties | +| D3 | FHIR-compatible export (geen FHIR-native) | Full FHIR server (HAPI) | Te zwaar voor onze stack, Nederlandse markt verwacht export niet storage | +| D4 | Hybrid RBAC + ABAC | Alleen RBAC, alleen ABAC | RBAC te simpel voor Wvggz, ABAC alleen te complex. Hybride geeft flexibiliteit | +| D5 | Application-level field encryptie | Database-level transparent encryption | Meer controle over wat versleuteld is, nodig voor BSN en diagnoses in audit logs | +| D6 | Pino voor logging (geen Winston) | Winston, Bunyan, console.log | Laagste overhead, native JSON, PII filtering pipeline | +| D7 | pgvector voor RAG (geen Pinecone) | Pinecone, Weaviate, Chroma | Supabase-native, geen extra service, voldoende voor protocol-volumes | +| D8 | Audit trail vanaf dag 1 | Later toevoegen | Retrofit is exponentieel duurder, NEN 7513 is wettelijk verplicht | +| D9 | Dual interface (traditioneel + intent) | Alleen intent, alleen traditioneel | Adoptie vereist vertrouwde UI, intent is versneller niet vervanging | +| D10 | Immutable audit logs met hash chain | Append-only zonder hash | Hash chain geeft cryptografisch bewijs van integriteit (NEN 7513) | + +--- + +## Appendix A: Relatie met het Intent Systeem Document + +Dit document beschrijft de enterprise-schil. Het intent-systeem zelf — met de vijf bouwblokken (Intent Registry, Classification Pipeline, Entity Resolution, Action System, Protocol Engine) — is volledig beschreven in `intent-system-architectuur-nl.md`. + +De twee documenten samen vormen de complete architectuur: + +``` +intent-system-architectuur-nl.md enterprise-epd-architectuur.md +┌────────────────────────────┐ ┌──────────────────────────────┐ +│ Hoe het intent systeem │ │ Hoe het enterprise EPD │ +│ intern werkt: │ │ eromheen werkt: │ +│ │ │ │ +│ • Intent Registry │◄────►│ • Multi-tenancy │ +│ • Classification Pipeline │ │ • Audit trail (NEN 7513) │ +│ • Entity Resolution │ │ • Toegangscontrole (RBAC+ABAC)│ +│ • Action System │ │ • Encryptie & data bescherming│ +│ • Protocol Engine (Nudge) │ │ • FHIR interoperabiliteit │ +│ │ │ • Knowledge Layer │ +│ │ │ • Observability │ +│ │ │ • Resilience │ +│ │ │ • Zorgwetgeving compliance │ +│ │ │ • EPD modules & UI │ +└────────────────────────────┘ └──────────────────────────────┘ +``` + +## Appendix B: Technologie Referenties + +| Technologie | Documentatie | Versie | +|-------------|-------------|--------| +| Next.js | nextjs.org/docs | 14 (App Router) | +| Supabase | supabase.com/docs | Latest | +| PostgreSQL | postgresql.org/docs | 15+ | +| Anthropic Claude | docs.anthropic.com | claude-sonnet-4-5 / claude-opus-4 | +| Deepgram | developers.deepgram.com | Nova-2 | +| Tailwind CSS | tailwindcss.com | 3.x | +| shadcn/ui | ui.shadcn.com | Latest | +| Zod | zod.dev | 3.x | +| Zustand | zustand-demo.pmnd.rs | 4.x | +| Pino | getpino.io | 8.x | +| OpenTelemetry | opentelemetry.io | 1.x | +| FHIR R4 | hl7.org/fhir/R4 | 4.0.1 | +| CDS Hooks | cds-hooks.org | 2.0 | + +## Appendix C: Standaarden Referenties + +| Standaard | Organisatie | Relevant voor | +|-----------|-------------|---------------| +| NEN 7510 | NEN | Informatiebeveiliging (→ RBAC, encryptie, access control) | +| NEN 7512 | NEN | Veilige gegevensuitwisseling (→ FHIR, TLS) | +| NEN 7513 | NEN | Logging (→ audit trail) | +| FHIR R4 | HL7 | Interoperabiliteit (→ export endpoints) | +| CDS Hooks | HL7 | Clinical decision support (→ nudge/protocol engine) | +| GGZ Standaarden | Akwa GGZ | Behandelprotocollen (→ Knowledge Layer) | +| V&VN richtlijnen | V&VN | Verpleegkundige protocollen (→ Knowledge Layer) | +| AVG/GDPR | EU | Privacy (→ encryptie, toestemming, dataportabiliteit) | diff --git a/docs/architecture/intent-system-architecture.md b/docs/architecture/intent-system-architecture.md new file mode 100644 index 0000000..cfacf19 --- /dev/null +++ b/docs/architecture/intent-system-architecture.md @@ -0,0 +1,1073 @@ +# Intent-Driven Architecture for Healthcare Applications + +> **Type**: Architecture Reference Document +> **Version**: 1.0 +> **Date**: 2026-02-14 +> **Audience**: LLM agents, developers, architects building on this system +> **Language**: English (code and architecture), Dutch (domain examples) + +--- + +## How to Read This Document + +This document describes an intent-driven architecture for healthcare applications. It is written to be consumed by both humans and LLMs. Each section follows a consistent pattern: **what** the component does, **why** it exists, **how** it works, and **what trade-offs** were made. Code examples illustrate concepts — they are not implementation specifications. + +The architecture is domain-agnostic in its core (any application that translates natural language into structured actions) but makes specific decisions for healthcare contexts where safety, auditability, and clinical relevance are non-negotiable. + +--- + +## 1. Problem Statement + +### 1.1 The Core Tension + +Healthcare workers think and communicate in **unstructured language**: "Jan refused his medication this morning." Healthcare systems require **structured input**: selecting the right form, the right category, the right patient, at the right time. + +The gap between these two modes is where productivity is lost. Every form-fill, every menu navigation, every context switch from clinical thinking to system operation is friction that takes time away from patient care. + +### 1.2 What This Architecture Solves + +This architecture provides a pattern for building a **command interface** that sits between natural language input and structured system actions. It is not a chatbot (conversation is not the goal), not a search engine (retrieval is one action among many), and not an autonomous agent (the human always decides). + +It does three things: + +1. **Understand** — Classify what the user wants (intent) and extract the relevant parameters (entities) +2. **Prepare** — Open the right form with the right data pre-filled, ready for human confirmation +3. **Suggest** — After an action completes, propose clinically relevant follow-ups based on protocols + +### 1.3 Design Constraints from Healthcare + +These constraints are non-negotiable and shape every architectural decision: + +| Constraint | Implication | +|-----------|-------------| +| **No autonomous writes** | The system never writes to the patient record without explicit human confirmation | +| **Auditability** | Every classification, every action, every suggestion must be traceable | +| **Graceful degradation** | If AI is unavailable, the system must still function (reduced capability, not failure) | +| **Speed for routine tasks** | 70%+ of interactions are routine and must resolve in milliseconds, not seconds | +| **Domain vocabulary is stable** | Medical terms, shift patterns, report categories change slowly — this favors rule-based approaches | +| **Privacy by design** | Patient data in AI prompts must be minimized; logs must be sanitized | + +--- + +## 2. Architecture Overview + +### 2.1 The Five Building Blocks + +The system consists of five components, each with a single responsibility. They are described in the order data flows through them. + +``` +User Input (text or speech) + │ + ▼ +┌─────────────────────────┐ +│ 1. INTENT REGISTRY │ Declarative definitions — the single source of truth +│ (static config) │ for all intents, patterns, entities, and metadata +└────────────┬────────────┘ + │ provides definitions to ↓ +┌─────────────────────────┐ +│ 2. CLASSIFICATION │ Two-phase pipeline: fast local matching (Reflex) +│ PIPELINE │ with LLM fallback (Orchestrator) for complex input +└────────────┬────────────┘ + │ produces classified intent + raw entities ↓ +┌─────────────────────────┐ +│ 3. ENTITY RESOLUTION │ Grounds raw entities against real data: +│ │ "Jan" → Patient #427, "morgen" → 2026-02-15 +└────────────┬────────────┘ + │ produces resolved intent ready for action ↓ +┌─────────────────────────┐ +│ 4. ACTION SYSTEM │ Maps intent → UI artifact (form, view, navigation) +│ │ Human confirms → system executes → result +└────────────┬────────────┘ + │ after successful action ↓ +┌─────────────────────────┐ +│ 5. PROTOCOL ENGINE │ Evaluates clinical rules against completed action +│ (Nudge) │ Suggests follow-ups with protocol references +└─────────────────────────┘ +``` + +### 2.2 Why This Order Matters + +The pipeline is strictly sequential for a reason. Each step produces a more refined representation: + +- **Raw input** → (Classification) → **Intent + raw entities** → (Resolution) → **Grounded intent** → (Action) → **Prepared UI** → (Human confirms) → **Executed action** → (Protocol) → **Suggested follow-up** + +No step can be skipped. Classification without resolution produces ungrounded entities ("Jan" without knowing which Jan). Resolution without classification has nothing to resolve. Actions without human confirmation violate healthcare safety requirements. Protocol evaluation without completed actions has no trigger. + +### 2.3 What Is NOT in This Architecture + +Decisions about what to exclude are as important as what to include: + +| Excluded | Reason | +|----------|--------| +| **Custom ML model for classification** | Regex + LLM fallback outperforms custom models for <50 intents in a stable domain vocabulary. No training data maintenance overhead. | +| **Event bus / pub-sub** | Overkill for single-tenant applications. Direct function calls and store subscriptions are simpler and equally effective. | +| **Autonomous agent execution** | Healthcare requires human-in-the-loop for all record modifications. The system prepares; the human decides. | +| **Ambient capture** | Passive listening during patient conversations is a fundamentally different input model. This architecture handles explicit commands (typed or spoken). Ambient capture is a future extension, not a foundation change. | +| **FHIR server** | A FHIR-inspired data model is sufficient. Building a full FHIR-compliant server is a separate project that doesn't affect the intent architecture. | +| **Knowledge graph for entity resolution** | Simple database lookups (fuzzy name search, date parsing) are sufficient for <1000 patients. Knowledge graphs add value at scale but premature complexity at MVP. | + +--- + +## 3. Building Block 1: Intent Registry + +### 3.1 Purpose + +The Intent Registry is the **single source of truth** for all intent definitions. Every other component in the system reads from the registry — nothing defines intent behavior independently. + +### 3.2 Why This Matters + +Without a registry, intent definitions drift apart. In the current prototype, an intent is defined in four separate locations: the TypeScript type union, the Reflex pattern map, the Orchestrator system prompt, and the Chat API system prompt. Adding a new intent requires synchronized changes to all four. This is the primary source of architectural debt. + +The registry eliminates this by centralizing the definition and generating derived artifacts (pattern maps, prompts, validation schemas) from a single declaration. + +### 3.3 Anatomy of an Intent Definition + +```typescript +interface IntentDefinition { + // === Identity === + id: string; // Unique identifier, e.g. "dagnotitie" + label: string; // Human-readable name (Dutch), e.g. "Dagnotitie" + description: string; // What this intent does (used in AI prompts) + priority: 'P1' | 'P2' | 'P3'; // Classification priority tier + + // === Local Classification (Reflex) === + reflexPatterns: Array<{ + pattern: RegExp; + weight: number; // 0.5 (weak signal) to 1.0 (exact match) + }>; + + // === Entity Schema === + entities: { + required: string[]; // Must be present for action execution + optional: string[]; // Enriches the action if present + extractionRules: Array<{ // Regex with named capture groups + pattern: RegExp; + mapping: Record; // capture group → entity field + }>; + }; + + // === AI Classification === + aiExamples: Array<{ + input: string; // Example user input + expectedEntities: Record; + }>; + + // === Action Binding === + artifactType: string | null; // Which UI artifact to open (null = navigation only) + requiresConfirmation: boolean; // Must user confirm before execution? + + // === Access Control (prepared, not enforced in MVP) === + allowedRoles?: string[]; // Empty = everyone + + // === Feature Management === + featureFlag?: string; // Optional flag to enable/disable + enabled: boolean; // Master switch +} +``` + +### 3.4 What the Registry Generates + +Other components do not access the registry directly for their core logic. Instead, the registry exposes generator functions: + +| Function | Consumer | What it produces | +|----------|----------|------------------| +| `getReflexPatterns()` | Classification Pipeline (Reflex phase) | Map of intent → pattern/weight pairs | +| `getExtractionRules()` | Entity Resolution | Map of intent → regex extraction rules | +| `buildClassificationPrompt()` | Classification Pipeline (Orchestrator phase) | System prompt section listing all intents with descriptions and examples | +| `buildChatPrompt()` | Chat API | System prompt section for conversational context | +| `getEntitySchema(intentId)` | Action System | Zod validation schema for entity validation | +| `getArtifactMapping()` | Action System | Map of intent → artifact type | + +### 3.5 Trade-Off: Declarative vs. Distributed + +**Alternative considered**: Each intent as a self-contained module (file per intent, co-located patterns + prompt + component). This is the "feature folder" pattern. + +**Why we chose centralized registry**: In a healthcare context, the relationships *between* intents matter. Ambiguity detection requires comparing confidence scores across intents. RBAC filtering requires iterating all intents. Prompt generation needs the full catalog. A centralized registry makes these cross-cutting concerns natural. The cost is that adding an intent touches one large file instead of creating a new file — but that one file is the only file you need to touch. + +**When to reconsider**: If the system grows beyond ~50 intents, the registry file becomes unwieldy. At that point, split into category-based sub-registries (clinical, administrative, navigation) that merge into a single runtime registry. + +--- + +## 4. Building Block 2: Classification Pipeline + +### 4.1 Purpose + +The Classification Pipeline takes raw user input and produces a classified intent with confidence score and raw entities. It is the single entry point for all classification — both direct API calls and chat interactions use the same pipeline. + +### 4.2 Two-Phase Design + +``` +Input + Context + │ + ▼ +┌──────────────────────────────────────────────────────┐ +│ Phase 1: REFLEX (local, <20ms) │ +│ │ +│ 1. Check escalation triggers │ +│ - Multi-intent signals ("en", "daarna", "dan") │ +│ - Pronouns ("hij", "zij", "hem", "haar") │ +│ - Relative time ("morgen", "volgende week") │ +│ → If triggered: skip to Phase 2 with best-guess │ +│ │ +│ 2. Pattern matching against registry patterns │ +│ - Score each intent by highest matching weight │ +│ - Track top-2 for ambiguity detection │ +│ → If confidence ≥ 0.7 AND gap > 0.1: return │ +│ → Otherwise: escalate to Phase 2 │ +│ │ +│ 3. Entity extraction via registry extraction rules │ +│ → Attach raw entities to result │ +└──────────────────────────────────────────────────────┘ + │ + │ (only if escalation needed) + ▼ +┌──────────────────────────────────────────────────────┐ +│ Phase 2: ORCHESTRATOR (AI, ~250ms-3s) │ +│ │ +│ 1. Build prompt from registry (intent descriptions │ +│ + examples + entity schemas) │ +│ 2. Include application context: │ +│ - Active patient (name, recent notes) │ +│ - Current shift (nacht/ochtend/middag/avond) │ +│ - Today's appointments │ +│ - Recent intents (for pronoun resolution) │ +│ 3. Send to LLM with structured output format │ +│ 4. Validate response with Zod schema │ +│ 5. Build IntentChain (single or multi-action) │ +│ │ +│ On failure: fall back to Reflex result, │ +│ cap confidence at 0.6 │ +└──────────────────────────────────────────────────────┘ + │ + ▼ +ClassificationResult { + intent, confidence, rawEntities, + chain (if multi-action), + source ('reflex' | 'orchestrator' | 'fallback'), + processingTimeMs +} +``` + +### 4.3 Why Two Phases Instead of One + +**Cost**: An LLM API call costs money and time. At 100 classifications per hour across an organization, pure-LLM classification becomes expensive. Reflex handles 70%+ locally at zero marginal cost. + +**Latency**: Reflex responds in <20ms. The LLM takes 250ms-3s. For routine commands ("notitie jan medicatie"), the user should not wait for AI. + +**Resilience**: If the LLM provider is down, Reflex still works. The system degrades from "intelligent" to "fast and reliable" instead of failing completely. + +**Debuggability**: Regex patterns are deterministic and inspectable. When a classification is wrong, you can trace exactly which pattern matched and why. LLM reasoning is probabilistic and harder to debug. + +### 4.4 Escalation Triggers + +The Reflex phase checks for escalation triggers *before* doing pattern matching. This is a deliberate choice: if the input contains signals that require AI reasoning (multiple actions, pronouns, relative time), there is no point in building a local hypothesis that will be incomplete. + +| Trigger | Detection | Why AI is needed | +|---------|-----------|------------------| +| Multi-intent | Conjunctions: "en", "daarna", "dan", "ook" | Reflex cannot split compound sentences | +| Pronouns | "hij", "zij", "hem", "haar", "die", "deze" | Requires context (active patient, recent actions) to resolve | +| Relative time | "morgen", "overmorgen", "volgende week", weekday names | Requires current date + calendar awareness | + +### 4.5 The Unified Pipeline Principle + +Both the **Classify API** (direct classification) and the **Chat API** (conversational interaction) use the same pipeline. The difference: + +- **Classify API**: Returns the pipeline result directly as structured data +- **Chat API**: Feeds the pipeline result as context to a conversational LLM, which generates a natural language response alongside the structured action + +This means the Chat LLM does not need to classify — it receives the classification as input and only needs to formulate a response. This eliminates the problem of maintaining two separate classification systems with divergent intent definitions. + +``` + ┌─────────────────────┐ + │ Classification │ + │ Pipeline │ + │ (single impl.) │ + └──────┬──────────────┘ + │ + ┌────────────┴────────────┐ + ▼ ▼ + ┌──────────────────┐ ┌──────────────────┐ + │ Classify API │ │ Chat API │ + │ Returns result │ │ Passes result as │ + │ as JSON │ │ context to LLM │ + └──────────────────┘ │ for conversation │ + └──────────────────┘ +``` + +### 4.6 Circuit Breaker for AI Resilience + +The Orchestrator wraps AI calls with a simple circuit breaker: + +``` +State Machine: + CLOSED (normal) ──[3 consecutive failures]──▶ OPEN (bypass AI) + OPEN ──[30 seconds elapsed]──▶ HALF-OPEN (try one request) + HALF-OPEN ──[success]──▶ CLOSED + HALF-OPEN ──[failure]──▶ OPEN +``` + +When the circuit is open, all classifications are handled by Reflex alone (with confidence capped at 0.6). This prevents cascade failures when the AI provider is experiencing issues — instead of every request waiting 5 seconds for a timeout, the system instantly falls back. + +### 4.7 Trade-Off: Regex vs. Embeddings for Phase 1 + +**Current choice**: Regex patterns with weights. + +**Alternative**: Sentence embeddings (e.g., via a local model or API) that match input against intent descriptions by semantic similarity. + +**Why regex for now**: The domain vocabulary in healthcare (especially GGZ — mental health) is stable and limited. "Notitie", "overdracht", "afspraak" are not ambiguous words. Regex captures these patterns with near-perfect accuracy and zero latency. Embeddings add infrastructure complexity (model hosting or API calls) without proportional accuracy improvement at <50 intents. + +**When to reconsider**: If the Reflex hit rate drops below 60% — meaning more than 40% of inputs require AI escalation — the patterns are no longer covering the vocabulary. At that point, an embedding-based first pass (selecting top-10 candidate intents, then LLM for final classification) becomes worthwhile. This is the architecture Voiceflow benchmarked successfully in production. + +--- + +## 5. Building Block 3: Entity Resolution + +### 5.1 Purpose + +Entity Resolution takes the raw entities from classification (strings like "jan", "morgen", "medicatie") and grounds them against real system data (Patient #427, 2026-02-15, category "medicatie"). + +### 5.2 Why This Is a Separate Step + +In the current prototype, entity extraction and resolution are conflated — some happens in the Reflex, some in the Orchestrator, some in the UI components. By making it an explicit pipeline step, we gain: + +1. **Testability**: Resolution logic can be unit-tested with mock data +2. **Reusability**: The same resolution logic serves both Classify and Chat paths +3. **Extensibility**: Swapping a name-lookup for a FHIR Patient search requires changing only this layer +4. **Separation of concerns**: Classification decides *what* the user wants; resolution grounds *who/when/what* they mean + +### 5.3 Resolution Types + +| Entity Type | Raw Value | Resolution Method | Resolved Value | +|------------|-----------|-------------------|----------------| +| Patient name | "jan" | Fuzzy search against patient database | `{ id: "427", name: "Jan de Vries" }` | +| Date/time | "morgen 14:00" | Date parsing with Dutch locale + current date | `{ date: "2026-02-15", time: "14:00" }` | +| Category | "medicatie", "med", "medicijn" | Alias mapping to canonical values | `"medicatie"` | +| Navigation target | "risico", "diagnose" | Enum matching | `"risicotaxatie"` | +| Shift | "ochtend" | Direct mapping | `"ochtend"` (07:00-12:00) | + +### 5.4 Disambiguation + +When resolution is ambiguous (multiple patients named "Jan"), the system produces a `ClarificationRequest`: + +```typescript +interface ClarificationRequest { + type: 'patient_disambiguation' | 'appointment_disambiguation' | 'time_disambiguation'; + question: string; // "Welke Jan bedoel je?" + options: Array<{ + label: string; // "Jan de Vries (kamer 12)" + value: string; // patient ID + }>; + originalIntent: string; // Preserved for retry after disambiguation + originalEntities: Record; // Preserved raw entities +} +``` + +The UI presents the options. After the user selects, the pipeline resumes with the resolved entity. The original intent and entities are preserved so the user doesn't need to repeat their command. + +### 5.5 Context-Aware Resolution + +Some entities resolve differently based on application context: + +- **"Hij"/"zij"** → resolves to `activePatient` from the context store +- **"De afspraak"** → resolves to the most recent or next appointment in context +- **"Vandaag"** → resolves to current date, but reports before 07:00 belong to previous day's shift + +This context-awareness is what makes the Orchestrator (AI) necessary for some inputs — the Reflex phase cannot resolve context-dependent references. + +### 5.6 Trade-Off: Inline vs. Explicit Resolution + +**Alternative considered**: Letting each UI component resolve entities on mount (current approach — components fetch patient data when they receive a name string). + +**Why explicit resolution**: In a multi-action chain ("notitie jan en verzet zijn afspraak"), the patient resolved in action 1 must be the same patient used in action 2. Inline resolution per component can produce inconsistencies. Explicit resolution at the pipeline level ensures a single resolution pass for the entire chain. + +--- + +## 6. Building Block 4: Action System + +### 6.1 Purpose + +The Action System maps resolved intents to UI artifacts (forms, views, navigation targets) and manages the execution lifecycle. It is the bridge between "the system understands what you want" and "the system shows you the right form." + +### 6.2 The Intent-Action Separation + +An intent is what the user *means*. An action is what the system *does*. This separation matters because: + +- One intent can map to different actions depending on context (e.g., "overdracht" opens a summary view during shift start but generates a new summary at shift end) +- One user utterance can produce multiple actions (IntentChain) +- Actions have lifecycle states that intents do not (pending → confirming → executing → success/failed) + +### 6.3 Action Types + +There are three types of actions, each with different UI behavior: + +| Type | What it does | UI Behavior | Example | +|------|-------------|-------------|---------| +| **Artifact Action** | Opens a form or data view | Opens artifact panel with pre-filled data | `dagnotitie`, `create_appointment` | +| **Query Action** | Fetches and displays data | Opens read-only artifact | `risico_query`, `diagnose_query`, `agenda_query` | +| **Navigation Action** | Redirects to a page | Client-side navigation, no artifact | `intake_navigeer` | + +### 6.4 The Confirmation Principle + +**No action that modifies patient data executes without human confirmation.** This is the foundational safety principle. + +In practice, this means: + +- **High confidence (≥0.9), non-destructive**: Open form with pre-filled data. User reviews and submits. +- **Medium confidence (0.7-0.9)**: Open form with pre-filled data + explicit confirmation banner: "Ik begrijp: dagnotitie voor Jan, categorie medicatie. Klopt dit?" +- **Low confidence (0.5-0.7)**: Ask clarification question before opening anything. +- **Very low confidence (<0.5)**: "Ik begrijp het niet. Kun je het anders zeggen?" +- **Destructive actions** (cancel, delete): Always require explicit confirmation, regardless of confidence. + +The system **pre-fills** but never **auto-submits**. The human sees what the system understood and decides whether it's correct. + +### 6.5 IntentChain: Multi-Action Execution + +When the Orchestrator detects multiple intents in one utterance ("Annuleer de afspraak van Jan en maak een notitie over zijn medicatie"), it produces an IntentChain — an ordered sequence of actions. + +```typescript +interface IntentChain { + id: string; + originalInput: string; + actions: IntentAction[]; // Ordered sequence + status: 'pending' | 'executing' | 'completed' | 'partial' | 'failed'; + meta: { + source: 'reflex' | 'orchestrator' | 'fallback'; + processingTimeMs: number; + aiReasoning?: string; // Orchestrator's explanation (for debugging) + }; +} +``` + +Execution is **strictly sequential**: action 2 starts only after action 1 completes (or the user confirms action 1). Parallel execution is intentionally not supported — the user expects a logical order, and in healthcare, action order can matter clinically (e.g., cancel before reschedule). + +### 6.6 Trade-Off: Pre-fill vs. Auto-Execute + +**Alternative considered**: For very high confidence classifications (≥0.95), skip the form and execute directly (write the note, create the appointment). + +**Why we chose pre-fill only**: In healthcare, the cost of a wrong write is high (incorrect patient record) while the cost of an extra confirmation click is low (fraction of a second). The risk-reward ratio strongly favors requiring confirmation. Additionally, displaying the pre-filled form serves as a transparency mechanism — the user sees exactly what the system understood, building trust over time. + +**Exception to consider for the future**: Read-only queries (agenda_query, risico_query) could arguably execute without confirmation since they don't modify data. This is a reasonable optimization but not a priority. + +--- + +## 7. Building Block 5: Protocol Engine (Nudge) + +### 7.1 Purpose + +The Protocol Engine evaluates clinical rules after a successful action and suggests relevant follow-up actions. It is the system's proactive intelligence — suggesting things the user didn't ask for but should consider based on clinical protocols. + +### 7.2 Why This Is the Differentiator + +Any chatbot can classify intents. Any form system can pre-fill data. What makes a healthcare command interface genuinely useful is **domain intelligence**: knowing that after wound care documentation, a follow-up wound check should be scheduled in 3 days per V&VN guidelines. This is where the system transitions from "faster data entry" to "clinical decision support." + +### 7.3 Rule Structure + +```typescript +interface ProtocolRule { + id: string; + name: string; // Human-readable rule name + + // When to trigger + trigger: { + intent: string; // Which completed intent triggers this rule + conditions: Condition[]; // ALL must match (AND logic) + }; + + // What to suggest + suggestion: { + intent: string; // The suggested follow-up intent + message: string; // User-facing suggestion text (Dutch) + prefillEntities: (completedAction: Action) => Record; + }; + + // Clinical grounding + protocol?: { + name: string; // "V&VN Richtlijn Wondzorg" + reference: string; // "§4.2 Controlebeleid" + rationale: string; // Why this suggestion matters + }; + + priority: 'low' | 'medium' | 'high'; + expiresAfterMs: number; // Suggestion disappears after this time + enabled: boolean; +} + +interface Condition { + field: string; // Entity field to check + operator: 'equals' | 'contains' | 'matches' | 'exists'; + value?: string; // Expected value (not needed for 'exists') +} +``` + +### 7.4 Engine Design: Pure Function + +The engine is a pure function: `(completedAction, rules) → suggestions[]`. It has no side effects, no state, and no knowledge of where rules come from. This makes it: + +- **Testable**: Pass mock actions and rules, assert on suggestions +- **Portable**: Rules can come from hardcoded TypeScript objects (MVP), a database table (v2), or FHIR PlanDefinitions (enterprise) +- **Predictable**: Same input always produces same output + +### 7.5 Integration Point + +The Protocol Engine runs after action completion, triggered by the Action System: + +``` +Action completes successfully + │ + ▼ +evaluateNudge(completedAction, protocolRules) + │ + ▼ +NudgeSuggestion[] (sorted by priority) + │ + ▼ +UI displays suggestion toast with: + - Message ("Wondcontrole inplannen over 3 dagen?") + - Protocol reference ("V&VN Wondzorg §4.2") + - Accept button → opens new artifact with pre-filled entities + - Dismiss button → logs dismissal for analytics +``` + +### 7.6 Example Rules (Healthcare / GGZ) + +| Rule | Trigger | Suggestion | Protocol | +|------|---------|------------|----------| +| Wound care follow-up | dagnotitie + content contains "wond" | Schedule wound check in 3 days | V&VN Wondzorg §4.2 | +| Medication change review | dagnotitie + content contains "medicatie" + "gewijzigd" | Schedule medication evaluation in 1 week | FMS Polyfarmacie §3.1 | +| Incident follow-up | dagnotitie + category = "incident" | Create incident report | IGJ Meldcode §2 | +| Risk reassessment | risico_query viewed | Schedule risk reassessment if >30 days old | GGZ Standaarden §5.4 | +| Intake completion | intake_status viewed + missing sections | Navigate to next incomplete section | Intake protocol | + +### 7.7 Trade-Off: Rules Engine vs. AI-Generated Suggestions + +**Alternative considered**: Instead of rule-based suggestions, let the LLM generate contextual suggestions based on the completed action and patient history. + +**Why we chose rules**: Clinical suggestions must be traceable to specific protocols. When a nurse sees "Schedule wound check in 3 days," she needs to know *why* — and the answer must be a protocol reference, not "the AI thought it was a good idea." Rule-based suggestions are deterministic, auditable, and clinically grounded. AI-generated suggestions are creative but unverifiable. + +**Hybrid future**: The rule engine could be augmented with an AI layer that *proposes new rules* based on patterns in action logs. These proposed rules would then be reviewed by clinical staff and added to the rule set if valid. The engine itself remains rule-based; AI contributes to rule discovery, not rule execution. + +### 7.8 Path Toward Standards: CDS Hooks + +The Protocol Engine is conceptually aligned with the [HL7 CDS Hooks](https://cds-hooks.hl7.org/) specification — a standard for Clinical Decision Support in healthcare. The mapping: + +| Cortex Concept | CDS Hooks Equivalent | +|----------------|---------------------| +| ProtocolRule | CDS Service | +| Trigger (intent + conditions) | CDS Hook (workflow trigger) | +| NudgeSuggestion | CDS Card (suggestion type) | +| Protocol metadata | Card.source | + +Migrating to CDS Hooks compatibility is not needed for MVP but is architecturally possible: express rules as FHIR PlanDefinitions, map triggers to CDS hook types, format output as CDS Cards. This enables integration with hospital CDS systems that already speak HL7. + +--- + +## 8. Cross-Cutting Concerns + +### 8.1 State Management + +The system requires state management for five distinct domains. These should be separate stores (not one monolithic store) to maintain testability and single responsibility: + +| Store | Responsibility | Key State | +|-------|---------------|-----------| +| **Context Store** | Application context | Active patient, shift, recent patients | +| **Chat Store** | Conversational state | Messages, streaming status, pending action | +| **Artifact Store** | UI artifact management | Open artifacts (max 3), active artifact | +| **Action Store** | Intent chain execution | Active chain, chain history | +| **Nudge Store** | Protocol suggestions | Active suggestions, accept/dismiss tracking | + +Stores communicate via subscriptions, not direct imports. Example: when the Action Store completes a chain, the Nudge Store's subscription triggers protocol evaluation. + +### 8.2 Observability + +Every classification produces a structured log event: + +```typescript +interface ClassificationEvent { + timestamp: string; + userId: string; + input: string; // Sanitized (PII removed or hashed) + intent: string; + confidence: number; + source: 'reflex' | 'orchestrator' | 'fallback'; + escalationReason?: string; + processingTimeMs: number; + entities: Record; // Sanitized +} +``` + +Key metrics to track: + +| Metric | Why It Matters | +|--------|---------------| +| Reflex hit rate | If <60%, patterns need expansion or embeddings should be considered | +| Orchestrator fallback rate | High rate = AI is unreliable, circuit breaker effectiveness | +| Classification latency (P95) | User experience indicator | +| Intent distribution | Reveals which features are actually used | +| Nudge acceptance rate per rule | Indicates whether suggestions are clinically useful | + +### 8.3 Audit Trail + +In healthcare, every system interaction with patient context must be auditable: + +```typescript +interface AuditEvent { + userId: string; + action: 'classify' | 'resolve' | 'execute' | 'nudge_shown' | 'nudge_accepted' | 'nudge_dismissed'; + intent?: string; + patientId?: string; // Which patient was involved + input?: string; // Sanitized + result?: string; // Summary, not full response + timestamp: string; + sessionId: string; // For correlating events within a session + durationMs?: number; +} +``` + +Storage requirements: append-only table, no UPDATE or DELETE, minimum 5 years retention (NEN 7510 compliance for Dutch healthcare). + +### 8.4 Privacy: PII in AI Prompts + +When the Orchestrator sends context to the LLM, it includes patient names and potentially clinical information. Mitigations: + +1. **Minimize context**: Send only what's needed for classification (patient name, not full medical history) +2. **Data processing agreement**: Ensure the AI provider's DPA guarantees no training on API data +3. **Log sanitization**: All log events must strip or hash patient names and identifiers before storage +4. **Pseudonymization option**: For high-security environments, replace patient names with tokens before sending to AI, resolve tokens after classification + +### 8.5 Role-Based Access (Prepared, Not Enforced) + +The Intent Registry includes an `allowedRoles` field per intent. This enables future RBAC filtering without architectural changes: + +``` +Input → Classification Pipeline → [RBAC Filter] → Action System + │ + └─ If intent not allowed for user's role: + → "Je hebt geen toegang tot deze functie" +``` + +The filter sits between classification and action: the system classifies the intent (so it knows what was attempted) but blocks execution if the user's role doesn't permit it. The blocked attempt is logged for audit purposes. + +--- + +## 9. Scaling Considerations + +### 9.1 Scaling Intents: From 11 to 50+ + +The current system has 11 intents. The architecture supports growth to 50+ with these considerations: + +| Dimension | At 11 intents | At 50 intents | Mitigation | +|-----------|--------------|---------------|------------| +| Reflex matching | ~88 regex evaluations (<20ms) | ~400 evaluations (~50ms) | Keyword pre-filter: match first word against index, evaluate only candidate intents | +| AI prompt size | ~2000 tokens | ~8000 tokens | Category-based prompt sections; only include relevant categories based on Reflex pre-classification | +| Registry file size | ~300 lines | ~1500 lines | Split into category sub-registries that merge at runtime | +| Ambiguity | Low (intents are distinct) | Higher (more overlapping patterns) | Increase pattern specificity; add disambiguation rules | + +### 9.2 Scaling Users + +| Component | Bottleneck | Mitigation | +|-----------|-----------|------------| +| Reflex | None (stateless, in-process) | Scales with application instances | +| Orchestrator | AI provider rate limits | Circuit breaker prevents cascade; consider provider load balancing | +| Rate limiting | Currently in-memory (lost on restart) | Move to database-backed (Supabase table or Redis) | +| Audit logging | Write volume | Batch writes; async logging pipeline | + +### 9.3 AI Provider Independence + +The system is currently coupled to Anthropic Claude. To reduce vendor lock-in: + +```typescript +interface LLMProvider { + classify(input: string, systemPrompt: string, context: string): Promise; + stream(messages: Message[], systemPrompt: string): AsyncIterable; +} +``` + +Two implementations (Anthropic, OpenAI) behind a single interface. Note that prompts are NOT fully portable between providers — the system prompt is optimized for Claude's behavior. Provider switching requires prompt re-tuning. This is inherent to LLM usage and cannot be fully abstracted. + +--- + +## 10. Relationship to Healthcare Standards + +### 10.1 FHIR Resource Mapping + +Extracted entities ultimately map to FHIR-inspired resources: + +| Entity | FHIR Resource | Usage | +|--------|---------------|-------| +| patientName / patientId | Patient | Patient identification | +| category + content | Observation or DocumentReference | Clinical notes | +| datetime + appointmentType | Encounter / Appointment | Scheduling | +| diagnosis / risk | Condition | Clinical data queries | + +The system does not need to be a FHIR server. It needs a clear mapping layer so that when FHIR compliance becomes required, entity resolution can produce FHIR-compliant references. + +### 10.2 NEN 7510 (Dutch Healthcare Information Security) + +| Requirement | How This Architecture Addresses It | +|-------------|-----------------------------------| +| Access control | RBAC prepared in Intent Registry; Supabase Auth + RLS on data | +| Audit logging | Append-only audit events for all interactions | +| No PII in logs | Sanitization step in logging pipeline | +| Encryption in transit | HTTPS (standard for modern web apps) | +| Encryption at rest | Database-level (Supabase managed) | +| Incident logging | Classification failures logged as potential security events | + +--- + +## 11. Migration Path from Current Prototype + +### Phase 1: Foundation (Low Risk) +**Goal**: Intent Registry as single source of truth + entity extraction in Reflex + +1. Create `intent-registry.ts` with all 11 current intents as declarative objects +2. Refactor `reflex-classifier.ts` to load patterns from registry instead of hardcoded map +3. Add entity extraction rules to registry; implement extraction in Reflex phase +4. Generate Orchestrator prompt from registry (replace hardcoded prompt) +5. Verify: all existing classifications produce the same results (regression test) + +**Risk**: Low — refactoring without behavior change (except added entity extraction). + +### Phase 2: Unification (Medium Risk) +**Goal**: Single classification pipeline serving both Classify and Chat APIs + +1. Extract `classifyInput()` as standalone pipeline function +2. Modify Chat API to use pipeline for classification (remove duplicate intent logic from chat prompt) +3. Simplify Chat system prompt to conversational role only (no classification responsibility) +4. Fix AbortController signal propagation (currently disconnected from actual fetch) +5. Add circuit breaker to Orchestrator + +**Risk**: Medium — Chat behavior may subtly change. Requires thorough testing with existing scenarios. + +### Phase 3: Activation (Low Risk) +**Goal**: Nudge system actually running; state management cleaned up + +1. Split monolithic Zustand store into 5 domain stores +2. Wire `evaluateNudge()` to fire after action completion (via store subscription) +3. Add 3-5 clinical protocol rules +4. Implement nudge tracking (shown/accepted/dismissed) + +**Risk**: Low — new functionality, no breaking changes to existing features. + +### Phase 4: Production Readiness (Low Risk) +**Goal**: Observable, auditable, resilient + +1. Structured logging (replace console.log) +2. Classification metrics tracking +3. Audit events to database +4. Database-backed rate limiting +5. PII sanitization in logs + +**Risk**: Low — cross-cutting infrastructure, no functionality changes. + +--- + +## 12. Decision Log + +This section records key architectural decisions with their rationale, for future reference. + +### D1: Three-Layer Model (Reflex → Orchestrator → Nudge) + +**Decision**: Use a tiered classification model with local fast path and AI fallback, plus protocol-driven post-action suggestions. + +**Rationale**: Optimizes for the common case (70%+ routine commands handled locally in <20ms) while preserving AI capability for complex input. Nudge layer adds domain value beyond classification. This pattern is validated by industry benchmarks (Voiceflow 2025) showing hybrid NLU+LLM outperforms pure approaches on both cost and accuracy. + +**Alternatives rejected**: Pure LLM (too slow and expensive for routine commands), pure rule-based (cannot handle multi-intent, pronouns, relative time), custom ML model (training data overhead without proportional accuracy gain in stable domain). + +### D2: Human-in-the-Loop for All Write Operations + +**Decision**: The system never writes to patient records without explicit human confirmation. Pre-fill forms, never auto-submit. + +**Rationale**: Healthcare requires accountability. The cost of a wrong write (incorrect patient record) far exceeds the cost of an extra confirmation click. This also builds user trust — the system is transparent about what it understood. + +**Alternatives rejected**: Auto-execution for high-confidence classifications (>0.95). Rejected because even at 99% accuracy, 1 wrong write per 100 interactions is unacceptable in a clinical context. + +### D3: Centralized Intent Registry over Feature Folders + +**Decision**: Single registry file over one-file-per-intent module structure. + +**Rationale**: Cross-cutting concerns (ambiguity detection, RBAC filtering, prompt generation) need the full intent catalog. A centralized registry makes these natural. The cost (one large file) is manageable at <50 intents and can be split into sub-registries later. + +### D4: Regex over Embeddings for Phase 1 Classification + +**Decision**: Use regex patterns with weights for the Reflex phase. + +**Rationale**: Domain vocabulary is stable and limited (medical terms, fixed workflows). Regex achieves near-perfect accuracy for known patterns at zero latency. Embeddings add infrastructure complexity without proportional accuracy improvement at current scale. + +**Reconsideration trigger**: Reflex hit rate drops below 60%. + +### D5: Rule-Based Protocol Engine over AI-Generated Suggestions + +**Decision**: Nudge suggestions are deterministic, based on explicitly defined protocol rules. + +**Rationale**: Clinical suggestions must be traceable to specific protocols. Rule-based suggestions are auditable and verifiable. AI-generated suggestions are creative but clinically unverifiable. + +**Future hybrid**: AI proposes candidate rules from action log patterns; clinical staff reviews and approves; engine remains rule-based. + +### D6: Sequential Multi-Intent Execution over Parallel + +**Decision**: Actions in an IntentChain execute sequentially, never in parallel. + +**Rationale**: Users expect logical ordering ("cancel appointment AND make note" implies cancel first). In healthcare, action order can matter clinically. Sequential execution is predictable and debuggable. + +--- + +## 13. Platform Model: From Intent System to Healthcare Application + +### 13.1 The Four Layers + +The complete system consists of four layers. The intent system (this document) is layer 1. Three additional layers build on top to form a healthcare application. + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ │ +│ LAYER 4: EPD APPLICATION │ +│ The application the healthcare worker sees and uses │ +│ │ +│ Reporting │ Patient Record │ Calendar │ Handover │ Intake │ +│ UI modules, block components, API routes, data model │ +│ │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ LAYER 3: CARE DOMAIN CONFIGURATION │ +│ The knowledge of the specific care type │ +│ │ +│ Intent definitions (dagnotitie, overdracht, agenda, ...) │ +│ Entity schemas (patient, category, shift, ...) │ +│ Domain vocabulary (GGZ terms, report categories) │ +│ Protocol rules (nudges specific to this care type) │ +│ │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ LAYER 2: KNOWLEDGE LAYER │ +│ External data sources that feed the Protocol Engine │ +│ │ +│ ┌───────────┐ ┌──────────────┐ ┌────────────┐ ┌───────────┐ │ +│ │ Laws & │ │ Treatment │ │ Quality │ │ EHR Data │ │ +│ │ Regula- │ │ Protocols │ │ Documents │ │ (own │ │ +│ │ tions │ │ │ │ │ │ patient │ │ +│ │ │ │ │ │ │ │ data) │ │ +│ └───────────┘ └──────────────┘ └────────────┘ └───────────┘ │ +│ │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ LAYER 1: INTENT SYSTEM (this document) │ +│ The generic engine │ +│ │ +│ Intent Registry │ Classification Pipeline │ Entity Resolution │ +│ Action System │ Protocol Engine (Nudge) │ +│ │ +└─────────────────────────────────────────────────────────────────┘ +``` + +### 13.2 Why the Knowledge Layer Matters + +The Protocol Engine (Building Block 5) generates nudges based on rules. But those rules don't come from nowhere — they are derived from external knowledge sources. The quality of nudges is directly dependent on the quality and accessibility of these sources. + +Without the Knowledge Layer, the Protocol Engine is an empty engine: the mechanics work, but there's no fuel. The Knowledge Layer is that fuel. + +### 13.3 The Four Knowledge Sources + +#### 13.3.1 Laws and Regulations + +Laws and standards that regulate healthcare practices. These determine what *must* happen. + +| Source | Example | Nudge type it produces | +|--------|---------|----------------------| +| Wlz (Long-term Care Act) | Care plan requirements, evaluation deadlines | "Care plan evaluation expires in 2 weeks" | +| Wvggz (Compulsory Mental Healthcare Act) | Reporting obligations, coercive measure deadlines | "Coercive measure expires in 3 days — renewal needed?" | +| Wkkgz (Quality, Complaints and Disputes in Healthcare Act) | Incident reporting obligations | "Incident registered — IGJ report required within 3 business days" | +| NEN 7510 / GDPR | Record retention periods, access logging | "Audit log: 3 staff members viewed this record" | + +**Characteristics**: Changes slowly (legislative amendments), high reliability, publicly available, legally binding. + +**Technical implication**: These rules are stable enough to be hardcoded protocol rules in the engine. They change perhaps 1-2 times per year. + +#### 13.3.2 Treatment Protocols + +Clinical guidelines and standards describing how care *should* be delivered. + +| Source | Example | Nudge type it produces | +|--------|---------|----------------------| +| GGZ Standards | Care Standard Depression, Psychosis, etc. | "Patient with depression — ROM measurement scheduled in 6 weeks?" | +| V&VN Guidelines | Wound care, medication management, fall prevention | "Schedule wound check in 3 days (V&VN §4.2)" | +| FMS Guidelines | Polypharmacy, pain management | "Medication evaluation in 1 week (FMS Polypharmacy §3.1)" | +| Multidisciplinary guidelines | MDO frequency, treatment plan discussions | "MDO scheduled in 2 weeks — start preparation?" | + +**Characteristics**: Changes regularly (new guideline versions), high reliability, publicly available, requires interpretation by clinical staff. + +**Technical implication**: These sources are too extensive to manually encode as rules. This is where a **RAG component** (Retrieval Augmented Generation) comes in: protocol texts are indexed, and for relevant actions the LLM is asked to formulate specific nudge suggestions based on protocol text. These suggestions are then validated by clinical staff and added as rules. + +#### 13.3.3 Quality Documents + +Internal documents of the healthcare organization describing how *this specific organization* delivers care. + +| Source | Example | Nudge type it produces | +|--------|---------|----------------------| +| Institution protocols | Medication distribution protocol | "Double check medication required (house protocol §2.3)" | +| Work agreements | Handover moments, reporting frequency | "Handover report not completed — shift ends in 1 hour" | +| Quality handbook | Audit moments, improvement plans | "Internal audit next month — update action plan" | +| Accreditation requirements | HKZ, PREZO, Planetree | "Client satisfaction survey — 3 patients not yet surveyed" | + +**Characteristics**: Organization-specific (not public), changes with policy decisions, requires internal coordination. + +**Technical implication**: Most challenging source because it differs per institution. Options: manual rule creation, semi-automatic via RAG + validation, or hybrid (standard ruleset + organization-specific additions). + +#### 13.3.4 EHR Data (Own Patient Data) + +Data already in the system — patient records, reports, appointments, treatment plans. + +| Data source | Example | Nudge type it produces | +|-------------|---------|----------------------| +| Report history | No report in 48 hours | "No daily note for Jan de Vries in 2 days" | +| Treatment plan | Evaluation date expired | "Treatment plan evaluation Jan — 1 week past deadline" | +| Medication overview | Drug interactions, changes | "New medication prescribed — interaction check needed" | +| Risk assessment | Expired risk assessment | "Risk assessment Marie — last evaluation 45 days ago" | +| Calendar | Missed appointments, no-shows | "Jan 2x no-show this month — follow up?" | +| Lab/measurements | ROM scores, vital signs | "PHQ-9 score increased from 12 to 18 — adjust treatment plan?" | + +**Characteristics**: Real-time, patient-specific, always available (it's in your own database), privacy-sensitive. + +**Technical implication**: The only source requiring no external integration — it's already in Supabase. The Protocol Engine can run direct queries against existing tables. This is the simplest and most impactful source to start with. + +### 13.4 How the Knowledge Layer Feeds the Protocol Engine + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ KNOWLEDGE LAYER │ +│ │ +│ ┌─────────────────┐ ┌─────────────────────────────────┐ │ +│ │ Static rules │ │ Dynamic rules │ │ +│ │ │ │ │ │ +│ │ Laws & │ │ EHR data queries │ │ +│ │ regulations │ │ (report gaps, expired │ │ +│ │ (hardcoded, │ │ assessments, no-shows) │ │ +│ │ rarely changes)│ │ │ │ +│ │ │ │ Treatment protocols via RAG │ │ +│ │ National │ │ (indexed guideline texts │ │ +│ │ guidelines │ │ → AI-generated candidate │ │ +│ │ (V&VN, GGZ Std) │ │ rules → human validation) │ │ +│ │ │ │ │ │ +│ │ Institution │ │ Quality documents │ │ +│ │ protocols │ │ (uploaded per institution, │ │ +│ │ (configured at │ │ indexed, AI-suggested) │ │ +│ │ onboarding) │ │ │ │ +│ └────────┬────────┘ └────────────┬─────────────────────┘ │ +│ │ │ │ +│ ▼ ▼ │ +│ ┌──────────────────────────────────────────────────────────┐ │ +│ │ PROTOCOL RULES REGISTRY │ │ +│ │ │ │ +│ │ All rules — regardless of source — in the same format: │ │ +│ │ trigger + conditions + suggestion + protocol metadata │ │ +│ │ │ │ +│ │ Each rule contains: │ │ +│ │ - source: 'legislation' | 'guideline' | 'institution' │ │ +│ │ | 'ehr_data' | 'ai_suggested' │ │ +│ │ - validatedBy: userId (who approved the rule) │ │ +│ │ - validatedAt: timestamp │ │ +│ │ - version: rule version (for audit trail) │ │ +│ └──────────────────────────┬───────────────────────────────┘ │ +│ │ │ +└──────────────────────────────┼───────────────────────────────────┘ + │ + ▼ + ┌──────────────────────┐ + │ PROTOCOL ENGINE │ + │ (Building Block 5) │ + │ │ + │ evaluateNudge() │ + └──────────────────────┘ +``` + +### 13.5 Implementation Order for the Knowledge Layer + +**Step 1: EHR data (own database)** — Start here. No external integration needed. Supabase queries on your own tables. Direct value, low complexity. + +**Step 2: Laws & national guidelines** — Hardcoded rules. Stable sources, publicly available. 20-30 rules that apply to every GGZ institution. One-time work reusable across all clients. + +**Step 3: Institution protocols** — Configurable per client. At onboarding: upload their protocols, translate to rules (manually or semi-automatically). + +**Step 4: RAG on treatment protocols** — AI-assisted. Index full text of GGZ Standards, V&VN guidelines, etc. Use RAG to retrieve protocol texts and generate candidate nudges. Clinical staff validates. + +### 13.6 Trade-Off: Rules vs. RAG + +| Aspect | Hardcoded rules | RAG-generated suggestions | +|--------|----------------|---------------------------| +| **Accuracy** | 100% (human validated) | ~80-90% (AI-generated, requires validation) | +| **Scalability** | Low (manual per rule) | High (automatic from documents) | +| **Traceability** | Perfect (rule → protocol §) | Good (RAG source + AI reasoning) | +| **Startup cost** | Low per rule, high for completeness | High for setup, low per rule after | +| **Maintenance** | Manual on guideline changes | Semi-automatic (reindex + revalidate) | + +**Recommendation**: Start with hardcoded rules (steps 1-3). Build RAG when the ruleset grows beyond what's manually manageable (~50+ rules per institution). The rule format is the same — the source changes, the engine does not. + +### 13.7 The Knowledge Layer as Product Differentiator + +This is where it becomes commercially interesting. The Knowledge Layer differentiates between: + +- **Generic intent system**: "I understand your command and open the right form" — anyone can build this. +- **Care-specific platform**: "I know that after wound care, a check is needed in 3 days per V&VN §4.2, and that the Wlz requires care plan evaluation within 6 weeks" — this requires domain knowledge. +- **Institution-specific system**: "I know that your house protocol requires dual-person medication verification, and that your next internal audit is in 3 weeks" — this requires organizational knowledge. + +Each layer adds value. The intent system (layer 1) is the engine anyone can build. The Knowledge Layer (layer 2) is the flywheel that's hard to copy. + +### 13.8 Layer Separation and Reusability + +The four layers are deliberately decoupled: + +| If you replace... | Then changes... | And stays unchanged... | +|-------------------|----------------|----------------------| +| **Layer 4** (EPD application) | UI, API routes, data model | Intent system, Knowledge Layer, Domain config | +| **Layer 3** (Care domain) | Intents, entities, vocabulary | Intent system, Knowledge Layer, EPD application | +| **Layer 2** (Knowledge Layer) | Protocol rules, data sources | Intent system, Domain config, EPD application | +| **Layer 1** (Intent system) | Classification, resolution, actions | Knowledge Layer, Domain config, EPD application | + +Concrete example: switching from GGZ to home care? +- **Layer 1** stays identical (same engine) +- **Layer 2** gets different sources (home care protocols instead of GGZ Standards) +- **Layer 3** gets different intents (care_moment_registration instead of dagnotitie, route_planning instead of agenda) +- **Layer 4** gets a different UI (home care app instead of EPD dashboard) + +--- + +## Appendix A: Glossary + +| Term | Definition | +|------|-----------| +| **Intent** | A classified user intention: what the user wants to do (e.g., `dagnotitie`, `create_appointment`) | +| **Entity** | A parameter extracted from user input (e.g., patient name, date, category) | +| **Confidence** | A score (0.0–1.0) indicating how certain the classification is | +| **Reflex** | The fast, local classification phase using regex patterns | +| **Orchestrator** | The AI-powered classification phase using an LLM | +| **IntentChain** | An ordered sequence of actions derived from a single user utterance | +| **Artifact** | A UI panel (form, data view) opened in response to an intent | +| **Block** | A React component that renders a specific artifact type | +| **Nudge** | A proactive suggestion generated by the Protocol Engine after action completion | +| **Protocol Rule** | A declarative rule that triggers a nudge based on completed action + conditions | +| **Entity Resolution** | The process of grounding raw entity strings against real system data | +| **Escalation** | The decision to send input from Reflex to Orchestrator for AI classification | +| **Circuit Breaker** | A resilience pattern that bypasses AI calls after consecutive failures | + +## Appendix B: Current Intent Catalog + +| Intent | Priority | Category | Artifact | Confirmation | +|--------|----------|----------|----------|-------------| +| `dagnotitie` | P1 | Clinical | Form (note creation) | No (pre-fill only) | +| `zoeken` | P1 | Navigation | Search results view | No | +| `overdracht` | P1 | Clinical | Handover summary | No | +| `agenda_query` | P2 | Administrative | Calendar view | No | +| `create_appointment` | P2 | Administrative | Appointment form | No (pre-fill) | +| `cancel_appointment` | P2 | Administrative | Confirmation dialog | Yes (destructive) | +| `reschedule_appointment` | P2 | Administrative | Appointment form | Yes (modifying) | +| `intake_status` | P3 | Clinical | Intake progress view | No | +| `intake_navigeer` | P3 | Navigation | Page navigation | No (no artifact) | +| `risico_query` | P3 | Clinical | Risk assessment view | No | +| `diagnose_query` | P3 | Clinical | Diagnosis list view | No | + +## Appendix C: References + +- [Voiceflow: Benchmarking Hybrid LLM Classification Systems](https://www.voiceflow.com/pathways/benchmarking-hybrid-llm-classification-systems) — Production benchmarks showing hybrid NLU+LLM outperforms pure approaches +- [HL7 CDS Hooks Specification](https://cds-hooks.hl7.org/) — Standard for Clinical Decision Support integration +- [Microsoft Dragon Copilot](https://www.microsoft.com/en-us/health-solutions/clinical-workflow/dragon-copilot) — Largest ambient AI clinical documentation system (capture → classify → act → review pattern) +- [MediGRAF: Hybrid Graph RAG for EHR](https://arxiv.org/abs/2602.00009) — Hybrid structured + unstructured querying of patient data +- [NEN 7510](https://www.nen.nl/nen-7510-1-2017-nl-245399) — Dutch standard for information security in healthcare diff --git a/docs/architecture/intent-system-architectuur-nl.md b/docs/architecture/intent-system-architectuur-nl.md new file mode 100644 index 0000000..4d31762 --- /dev/null +++ b/docs/architecture/intent-system-architectuur-nl.md @@ -0,0 +1,1101 @@ +# Intent-Driven Architectuur voor Zorgtoepassingen + +> **Type**: Architectuur Referentiedocument +> **Versie**: 1.0 +> **Datum**: 2026-02-14 +> **Doelgroep**: LLM-agents, developers, architecten die op dit systeem bouwen +> **Taal**: Nederlands (tekst), Engels (technische termen en code) + +--- + +## Leeswijzer + +Dit document beschrijft een intent-driven architectuur voor zorgtoepassingen. Het is geschreven om zowel door mensen als door LLM's geconsumeerd te worden. Elke sectie volgt een vast patroon: **wat** het onderdeel doet, **waarom** het bestaat, **hoe** het werkt, en welke **trade-offs** er zijn gemaakt. Codevoorbeelden illustreren concepten — het zijn geen implementatiespecificaties. + +De architectuur is in de kern domein-agnostisch (elke toepassing die natuurlijke taal vertaalt naar gestructureerde acties), maar maakt specifieke keuzes voor de zorgcontext waar veiligheid, traceerbaarheid en klinische relevantie niet-onderhandelbaar zijn. + +--- + +## 1. Probleemstelling + +### 1.1 De kernspanning + +Zorgverleners denken en communiceren in **ongestructureerde taal**: "Jan heeft vanochtend zijn medicatie geweigerd." Zorgsystemen vereisen **gestructureerde input**: het juiste formulier selecteren, de juiste categorie, de juiste patiënt, op het juiste moment. + +De kloof tussen deze twee modi is waar productiviteit verloren gaat. Elke formulierinvulling, elke menunavigatie, elke contextwisseling van klinisch denken naar systeembediening is frictie die tijd wegneemt van patiëntenzorg. + +### 1.2 Wat deze architectuur oplost + +Deze architectuur biedt een patroon voor het bouwen van een **command interface** die tussen natuurlijke taalinput en gestructureerde systeemacties zit. Het is geen chatbot (conversatie is niet het doel), geen zoekmachine (zoeken is één actie van vele), en geen autonoom agent (de mens beslist altijd). + +Het doet drie dingen: + +1. **Begrijpen** — Classificeer wat de gebruiker wil (intent) en extraheer de relevante parameters (entities) +2. **Voorbereiden** — Open het juiste formulier met de juiste data vooringevuld, klaar voor menselijke bevestiging +3. **Voorstellen** — Stel na afronding van een actie klinisch relevante vervolgacties voor op basis van protocollen + +### 1.3 Ontwerpbeperkingen vanuit de zorg + +Deze beperkingen zijn niet-onderhandelbaar en vormen elke architectuurbeslissing: + +| Beperking | Implicatie | +|-----------|-----------| +| **Geen autonome schrijfacties** | Het systeem schrijft nooit naar het patiëntendossier zonder expliciete menselijke bevestiging | +| **Traceerbaarheid** | Elke classificatie, elke actie, elke suggestie moet traceerbaar zijn | +| **Graceful degradation** | Als AI niet beschikbaar is, moet het systeem blijven functioneren (verminderde capaciteit, geen uitval) | +| **Snelheid voor routinetaken** | 70%+ van de interacties is routine en moet in milliseconden opgelost worden, niet seconden | +| **Domeinvocabulaire is stabiel** | Medische termen, dienstpatronen, rapportagecategorieën veranderen langzaam — dit bevoordeelt rule-based aanpakken | +| **Privacy by design** | Patiëntdata in AI-prompts moet geminimaliseerd worden; logs moeten gesanitiseerd worden | + +--- + +## 2. Architectuuroverzicht + +### 2.1 De vijf bouwblokken + +Het systeem bestaat uit vijf componenten, elk met een enkele verantwoordelijkheid. Ze worden beschreven in de volgorde waarin data erdoorheen stroomt. + +``` +Gebruikersinput (tekst of spraak) + │ + ▼ +┌─────────────────────────┐ +│ 1. INTENT REGISTRY │ Declaratieve definities — de single source of truth +│ (statische config) │ voor alle intents, patronen, entities en metadata +└────────────┬────────────┘ + │ levert definities aan ↓ +┌─────────────────────────┐ +│ 2. CLASSIFICATION │ Tweefasen-pipeline: snelle lokale matching (Reflex) +│ PIPELINE │ met LLM fallback (Orchestrator) voor complexe input +└────────────┬────────────┘ + │ produceert geclassificeerd intent + ruwe entities ↓ +┌─────────────────────────┐ +│ 3. ENTITY RESOLUTION │ Grondt ruwe entities tegen echte data: +│ │ "Jan" → Patiënt #427, "morgen" → 2026-02-15 +└────────────┬────────────┘ + │ produceert resolved intent klaar voor actie ↓ +┌─────────────────────────┐ +│ 4. ACTION SYSTEM │ Mapt intent → UI artifact (formulier, weergave, navigatie) +│ │ Mens bevestigt → systeem voert uit → resultaat +└────────────┬────────────┘ + │ na succesvolle actie ↓ +┌─────────────────────────┐ +│ 5. PROTOCOL ENGINE │ Evalueert klinische regels tegen voltooide actie +│ (Nudge) │ Stelt vervolgacties voor met protocolreferenties +└─────────────────────────┘ +``` + +### 2.2 Waarom deze volgorde ertoe doet + +De pipeline is strikt sequentieel, en daar is een reden voor. Elke stap produceert een meer verfijnde representatie: + +- **Ruwe input** → (Classification) → **Intent + ruwe entities** → (Resolution) → **Gegrond intent** → (Action) → **Voorbereide UI** → (Mens bevestigt) → **Uitgevoerde actie** → (Protocol) → **Voorgestelde vervolgactie** + +Geen stap kan worden overgeslagen. Classificatie zonder resolution produceert ongegronde entities ("Jan" zonder te weten welke Jan). Resolution zonder classificatie heeft niets om te resolven. Acties zonder menselijke bevestiging schenden zorgveiligheidseisen. Protocol-evaluatie zonder voltooide acties heeft geen trigger. + +### 2.3 Wat NIET in deze architectuur zit + +Beslissingen over wat uit te sluiten zijn net zo belangrijk als wat erin zit: + +| Uitgesloten | Reden | +|-------------|-------| +| **Custom ML-model voor classificatie** | Regex + LLM fallback presteert beter dan custom modellen voor <50 intents in een stabiel domeinvocabulaire. Geen onderhoud van trainingsdata nodig. | +| **Event bus / pub-sub** | Overkill voor single-tenant applicaties. Directe functie-aanroepen en store subscriptions zijn eenvoudiger en even effectief. | +| **Autonome agent-uitvoering** | Zorg vereist human-in-the-loop voor alle dossierwijzigingen. Het systeem bereidt voor; de mens beslist. | +| **Ambient capture** | Passief meeluisteren tijdens patiëntgesprekken is een fundamenteel ander inputmodel. Deze architectuur behandelt expliciete commando's (getypt of gesproken). Ambient capture is een toekomstige uitbreiding, geen fundamentwijziging. | +| **FHIR-server** | Een FHIR-geïnspireerd datamodel is voldoende. Een volledige FHIR-compliant server bouwen is een apart project dat de intent-architectuur niet raakt. | +| **Knowledge graph voor entity resolution** | Simpele database-lookups (fuzzy naamzoekactie, datum-parsing) zijn voldoende bij <1000 patiënten. Knowledge graphs voegen waarde toe op schaal maar zijn premature complexiteit voor MVP. | + +--- + +## 3. Bouwblok 1: Intent Registry + +### 3.1 Doel + +De Intent Registry is de **single source of truth** voor alle intent-definities. Elk ander onderdeel in het systeem leest uit de registry — niets definieert intent-gedrag onafhankelijk. + +### 3.2 Waarom dit ertoe doet + +Zonder registry drijven intent-definities uit elkaar. In het huidige prototype wordt een intent op vier aparte plekken gedefinieerd: de TypeScript type union, de Reflex pattern map, de Orchestrator system prompt, en de Chat API system prompt. Een nieuw intent toevoegen vereist gesynchroniseerde wijzigingen op alle vier. Dit is de primaire bron van architecturale schuld. + +De registry elimineert dit door de definitie te centraliseren en afgeleide artifacts (pattern maps, prompts, validatieschema's) te genereren vanuit één enkele declaratie. + +### 3.3 Anatomie van een Intent Definition + +```typescript +interface IntentDefinition { + // === Identiteit === + id: string; // Unieke identifier, bijv. "dagnotitie" + label: string; // Leesbare naam (Nederlands), bijv. "Dagnotitie" + description: string; // Wat dit intent doet (gebruikt in AI-prompts) + priority: 'P1' | 'P2' | 'P3'; // Classificatieprioriteit + + // === Lokale classificatie (Reflex) === + reflexPatterns: Array<{ + pattern: RegExp; + weight: number; // 0.5 (zwak signaal) tot 1.0 (exacte match) + }>; + + // === Entity Schema === + entities: { + required: string[]; // Moet aanwezig zijn voor actie-uitvoering + optional: string[]; // Verrijkt de actie als aanwezig + extractionRules: Array<{ // Regex met named capture groups + pattern: RegExp; + mapping: Record; // capture group → entity-veld + }>; + }; + + // === AI-classificatie === + aiExamples: Array<{ + input: string; // Voorbeeld gebruikersinput + expectedEntities: Record; + }>; + + // === Action Binding === + artifactType: string | null; // Welk UI artifact te openen (null = alleen navigatie) + requiresConfirmation: boolean; // Moet gebruiker bevestigen voor uitvoering? + + // === Toegangscontrole (voorbereid, niet afgedwongen in MVP) === + allowedRoles?: string[]; // Leeg = iedereen + + // === Feature Management === + featureFlag?: string; // Optionele vlag om aan/uit te zetten + enabled: boolean; // Hoofdschakelaar +} +``` + +### 3.4 Wat de Registry genereert + +Andere componenten benaderen de registry niet direct voor hun kernlogica. In plaats daarvan biedt de registry generatorfuncties: + +| Functie | Afnemer | Wat het produceert | +|---------|---------|-------------------| +| `getReflexPatterns()` | Classification Pipeline (Reflex-fase) | Map van intent → pattern/weight-paren | +| `getExtractionRules()` | Entity Resolution | Map van intent → regex-extractieregels | +| `buildClassificationPrompt()` | Classification Pipeline (Orchestrator-fase) | System prompt-sectie met alle intents, beschrijvingen en voorbeelden | +| `buildChatPrompt()` | Chat API | System prompt-sectie voor conversationele context | +| `getEntitySchema(intentId)` | Action System | Zod-validatieschema voor entity-validatie | +| `getArtifactMapping()` | Action System | Map van intent → artifact type | + +### 3.5 Trade-off: Declaratief vs. Gedistribueerd + +**Overwogen alternatief**: Elk intent als zelfstandige module (bestand per intent, co-located patronen + prompt + component). Dit is het "feature folder" patroon. + +**Waarom we voor gecentraliseerde registry kozen**: In een zorgcontext doen de relaties *tussen* intents ertoe. Ambiguïteitdetectie vereist het vergelijken van confidence scores over intents heen. RBAC-filtering vereist iteratie over alle intents. Promptgeneratie heeft de volledige catalogus nodig. Een gecentraliseerde registry maakt deze cross-cutting concerns natuurlijk. De kosten zijn dat het toevoegen van een intent één groot bestand raakt in plaats van een nieuw bestand aan te maken — maar dat ene bestand is het enige bestand dat je hoeft aan te raken. + +**Wanneer te heroverwegen**: Als het systeem groeit voorbij ~50 intents wordt het registry-bestand onhandelbaar. Op dat punt: opsplitsen in categorie-gebaseerde sub-registries (klinisch, administratief, navigatie) die samenvoegen tot één runtime registry. + +--- + +## 4. Bouwblok 2: Classification Pipeline + +### 4.1 Doel + +De Classification Pipeline neemt ruwe gebruikersinput en produceert een geclassificeerd intent met confidence score en ruwe entities. Het is het enkele toegangspunt voor alle classificatie — zowel directe API-calls als chatinteracties gebruiken dezelfde pipeline. + +### 4.2 Tweefasen-ontwerp + +``` +Input + Context + │ + ▼ +┌──────────────────────────────────────────────────────┐ +│ Fase 1: REFLEX (lokaal, <20ms) │ +│ │ +│ 1. Controleer escalatie-triggers │ +│ - Multi-intent signalen ("en", "daarna", "dan") │ +│ - Voornaamwoorden ("hij", "zij", "hem", "haar") │ +│ - Relatieve tijd ("morgen", "volgende week") │ +│ → Bij trigger: overslaan naar Fase 2 met gok │ +│ │ +│ 2. Patroonmatching tegen registry-patronen │ +│ - Score elk intent op hoogste matchend gewicht │ +│ - Track top-2 voor ambiguïteitdetectie │ +│ → Als confidence ≥ 0.7 EN verschil > 0.1: klaar │ +│ → Anders: escaleer naar Fase 2 │ +│ │ +│ 3. Entity-extractie via registry extractieregels │ +│ → Koppel ruwe entities aan resultaat │ +└──────────────────────────────────────────────────────┘ + │ + │ (alleen als escalatie nodig) + ▼ +┌──────────────────────────────────────────────────────┐ +│ Fase 2: ORCHESTRATOR (AI, ~250ms-3s) │ +│ │ +│ 1. Bouw prompt vanuit registry (intent-beschrij- │ +│ vingen + voorbeelden + entity schemas) │ +│ 2. Voeg applicatiecontext toe: │ +│ - Actieve patiënt (naam, recente notities) │ +│ - Huidige dienst (nacht/ochtend/middag/avond) │ +│ - Afspraken vandaag │ +│ - Recente intents (voor voornaamwoordresolutie) │ +│ 3. Stuur naar LLM met gestructureerd outputformaat │ +│ 4. Valideer response met Zod-schema │ +│ 5. Bouw IntentChain (enkele of meervoudige actie) │ +│ │ +│ Bij falen: val terug op Reflex-resultaat, │ +│ cap confidence op 0.6 │ +└──────────────────────────────────────────────────────┘ + │ + ▼ +ClassificationResult { + intent, confidence, rawEntities, + chain (bij multi-action), + source ('reflex' | 'orchestrator' | 'fallback'), + processingTimeMs +} +``` + +### 4.3 Waarom twee fasen in plaats van één + +**Kosten**: Een LLM API-call kost geld en tijd. Bij 100 classificaties per uur over een organisatie wordt pure-LLM classificatie duur. Reflex handelt 70%+ lokaal af tegen nul marginale kosten. + +**Latency**: Reflex reageert in <20ms. De LLM doet er 250ms-3s over. Voor routinecommando's ("notitie jan medicatie") hoeft de gebruiker niet op AI te wachten. + +**Veerkracht**: Als de LLM-provider plat ligt, werkt Reflex nog steeds. Het systeem degradeert van "intelligent" naar "snel en betrouwbaar" in plaats van volledig te falen. + +**Debugbaarheid**: Regex-patronen zijn deterministisch en inspecteerbaar. Als een classificatie fout is, kun je precies traceren welk patroon matchte en waarom. LLM-reasoning is probabilistisch en lastiger te debuggen. + +### 4.4 Escalatie-triggers + +De Reflex-fase controleert op escalatie-triggers *vóór* de patroonmatching. Dit is een bewuste keuze: als de input signalen bevat die AI-reasoning vereisen (meerdere acties, voornaamwoorden, relatieve tijd), heeft het geen zin een lokale hypothese te bouwen die onvolledig zal zijn. + +| Trigger | Detectie | Waarom AI nodig is | +|---------|----------|-------------------| +| Multi-intent | Voegwoorden: "en", "daarna", "dan", "ook" | Reflex kan samengestelde zinnen niet splitsen | +| Voornaamwoorden | "hij", "zij", "hem", "haar", "die", "deze" | Vereist context (actieve patiënt, recente acties) om te resolven | +| Relatieve tijd | "morgen", "overmorgen", "volgende week", dagnamen | Vereist huidige datum + agenda-awareness | + +### 4.5 Het Unified Pipeline Principe + +Zowel de **Classify API** (directe classificatie) als de **Chat API** (conversationele interactie) gebruiken dezelfde pipeline. Het verschil: + +- **Classify API**: Retourneert het pipeline-resultaat direct als gestructureerde data +- **Chat API**: Geeft het pipeline-resultaat als context aan een conversationeel LLM, dat een natuurlijke taalrespons genereert naast de gestructureerde actie + +Dit betekent dat het Chat-LLM niet hoeft te classificeren — het ontvangt de classificatie als input en hoeft alleen een antwoord te formuleren. Dit elimineert het probleem van twee aparte classificatiesystemen met divergerende intent-definities. + +``` + ┌─────────────────────┐ + │ Classification │ + │ Pipeline │ + │ (enkele impl.) │ + └──────┬──────────────┘ + │ + ┌────────────┴────────────┐ + ▼ ▼ + ┌──────────────────┐ ┌──────────────────┐ + │ Classify API │ │ Chat API │ + │ Retourneert │ │ Geeft resultaat │ + │ resultaat als │ │ als context aan │ + │ JSON │ │ LLM voor │ + └──────────────────┘ │ conversatie │ + └──────────────────┘ +``` + +### 4.6 Circuit Breaker voor AI-veerkracht + +De Orchestrator wikkelt AI-calls in een simpele circuit breaker: + +``` +State Machine: + CLOSED (normaal) ──[3 opeenvolgende fouten]──▶ OPEN (bypass AI) + OPEN ──[30 seconden verstreken]──▶ HALF-OPEN (probeer één request) + HALF-OPEN ──[succes]──▶ CLOSED + HALF-OPEN ──[fout]──▶ OPEN +``` + +Wanneer het circuit open is, worden alle classificaties alleen door Reflex afgehandeld (met confidence gecapped op 0.6). Dit voorkomt cascade-fouten wanneer de AI-provider problemen heeft — in plaats van elk request 5 seconden te laten wachten op timeout, valt het systeem direct terug. + +### 4.7 Trade-off: Regex vs. Embeddings voor Fase 1 + +**Huidige keuze**: Regex-patronen met gewichten. + +**Alternatief**: Sentence embeddings (bijv. via een lokaal model of API) die input matchen tegen intent-beschrijvingen op basis van semantische gelijkenis. + +**Waarom regex voor nu**: Het domeinvocabulaire in de zorg (met name GGZ) is stabiel en beperkt. "Notitie", "overdracht", "afspraak" zijn geen ambigue woorden. Regex vangt deze patronen met bijna perfecte nauwkeurigheid en nul latency. Embeddings voegen infrastructuurcomplexiteit toe (model hosting of API-calls) zonder proportionele nauwkeurigheidsverbetering bij <50 intents. + +**Wanneer te heroverwegen**: Als de Reflex hit rate onder de 60% zakt — wat betekent dat meer dan 40% van de input AI-escalatie vereist — dekken de patronen het vocabulaire niet meer. Op dat punt wordt een embedding-based eerste pass (top-10 kandidaat-intents selecteren, dan LLM voor definitieve classificatie) waardevol. Dit is de architectuur die Voiceflow succesvol in productie heeft gebenchmarkt. + +--- + +## 5. Bouwblok 3: Entity Resolution + +### 5.1 Doel + +Entity Resolution neemt de ruwe entities uit classificatie (strings als "jan", "morgen", "medicatie") en grondt ze tegen echte systeemdata (Patiënt #427, 2026-02-15, categorie "medicatie"). + +### 5.2 Waarom dit een aparte stap is + +In het huidige prototype zijn entity-extractie en resolution vermengd — een deel gebeurt in de Reflex, een deel in de Orchestrator, een deel in de UI-componenten. Door het een expliciete pipeline-stap te maken, winnen we: + +1. **Testbaarheid**: Resolution-logica kan unit-getest worden met mock data +2. **Herbruikbaarheid**: Dezelfde resolution-logica bedient zowel Classify als Chat paden +3. **Uitbreidbaarheid**: Een naamzoekactie vervangen door een FHIR Patient search vereist alleen aanpassing van deze laag +4. **Separation of concerns**: Classificatie bepaalt *wat* de gebruiker wil; resolution grondt *wie/wanneer/wat* ze bedoelen + +### 5.3 Resolution-typen + +| Entity-type | Ruwe waarde | Resolution-methode | Resolved waarde | +|-------------|-------------|-------------------|-----------------| +| Patiëntnaam | "jan" | Fuzzy search tegen patiëntdatabase | `{ id: "427", name: "Jan de Vries" }` | +| Datum/tijd | "morgen 14:00" | Datum-parsing met Nederlandse locale + huidige datum | `{ date: "2026-02-15", time: "14:00" }` | +| Categorie | "medicatie", "med", "medicijn" | Alias-mapping naar canonieke waarden | `"medicatie"` | +| Navigatiedoel | "risico", "diagnose" | Enum matching | `"risicotaxatie"` | +| Dienst | "ochtend" | Directe mapping | `"ochtend"` (07:00-12:00) | + +### 5.4 Disambiguatie + +Wanneer resolution ambigu is (meerdere patiënten genaamd "Jan"), produceert het systeem een `ClarificationRequest`: + +```typescript +interface ClarificationRequest { + type: 'patient_disambiguation' | 'appointment_disambiguation' | 'time_disambiguation'; + question: string; // "Welke Jan bedoel je?" + options: Array<{ + label: string; // "Jan de Vries (kamer 12)" + value: string; // patiënt-ID + }>; + originalIntent: string; // Bewaard voor retry na disambiguatie + originalEntities: Record; // Bewaarde ruwe entities +} +``` + +De UI presenteert de opties. Nadat de gebruiker selecteert, hervat de pipeline met de resolved entity. Het oorspronkelijke intent en de entities worden bewaard zodat de gebruiker zijn commando niet hoeft te herhalen. + +### 5.5 Contextbewuste resolution + +Sommige entities resolven anders afhankelijk van applicatiecontext: + +- **"Hij"/"zij"** → resolvet naar `activePatient` uit de context store +- **"De afspraak"** → resolvet naar de meest recente of volgende afspraak in context +- **"Vandaag"** → resolvet naar huidige datum, maar rapportages vóór 07:00 horen bij de dienst van de vorige dag + +Deze contextbewustheid is wat de Orchestrator (AI) noodzakelijk maakt voor sommige input — de Reflex-fase kan contextafhankelijke verwijzingen niet resolven. + +### 5.6 Trade-off: Inline vs. Expliciete Resolution + +**Overwogen alternatief**: Elke UI-component entities laten resolven bij mount (huidige aanpak — componenten halen patiëntdata op wanneer ze een naamstring ontvangen). + +**Waarom expliciete resolution**: In een multi-action chain ("notitie jan en verzet zijn afspraak") moet de patiënt die in actie 1 resolved is dezelfde patiënt zijn die in actie 2 gebruikt wordt. Inline resolution per component kan inconsistenties produceren. Expliciete resolution op pipeline-niveau garandeert één resolution-pass voor de hele chain. + +--- + +## 6. Bouwblok 4: Action System + +### 6.1 Doel + +Het Action System mapt resolved intents naar UI artifacts (formulieren, weergaven, navigatiedoelen) en beheert de execution lifecycle. Het is de brug tussen "het systeem begrijpt wat je wilt" en "het systeem toont je het juiste formulier." + +### 6.2 De scheiding Intent-Action + +Een intent is wat de gebruiker *bedoelt*. Een action is wat het systeem *doet*. Deze scheiding is belangrijk omdat: + +- Eén intent kan mappen naar verschillende acties afhankelijk van context (bijv. "overdracht" opent een samenvattingsweergave bij dienststart maar genereert een nieuwe samenvatting bij diensteinde) +- Eén gebruikersuiting kan meerdere acties produceren (IntentChain) +- Actions hebben lifecycle-states die intents niet hebben (pending → confirming → executing → success/failed) + +### 6.3 Action-typen + +Er zijn drie typen acties, elk met ander UI-gedrag: + +| Type | Wat het doet | UI-gedrag | Voorbeeld | +|------|-------------|-----------|-----------| +| **Artifact Action** | Opent een formulier of dataweergave | Opent artifact-panel met vooringevulde data | `dagnotitie`, `create_appointment` | +| **Query Action** | Haalt data op en toont deze | Opent read-only artifact | `risico_query`, `diagnose_query`, `agenda_query` | +| **Navigation Action** | Navigeert naar een pagina | Client-side navigatie, geen artifact | `intake_navigeer` | + +### 6.4 Het bevestigingsprincipe + +**Geen actie die patiëntdata wijzigt wordt uitgevoerd zonder menselijke bevestiging.** Dit is het fundamentele veiligheidsprincipe. + +In de praktijk betekent dit: + +- **Hoge confidence (≥0.9), niet-destructief**: Open formulier met vooringevulde data. Gebruiker controleert en verzendt. +- **Gemiddelde confidence (0.7-0.9)**: Open formulier met vooringevulde data + expliciete bevestigingsbanner: "Ik begrijp: dagnotitie voor Jan, categorie medicatie. Klopt dit?" +- **Lage confidence (0.5-0.7)**: Stel verduidelijkingsvraag vóór het openen van wat dan ook. +- **Zeer lage confidence (<0.5)**: "Ik begrijp het niet. Kun je het anders zeggen?" +- **Destructieve acties** (annuleren, verwijderen): Vereisen altijd expliciete bevestiging, ongeacht confidence. + +Het systeem **vult voor** maar **verzendt nooit automatisch**. De mens ziet wat het systeem begrepen heeft en beslist of het correct is. + +### 6.5 IntentChain: Multi-Action Execution + +Wanneer de Orchestrator meerdere intents detecteert in één uiting ("Annuleer de afspraak van Jan en maak een notitie over zijn medicatie"), produceert het een IntentChain — een geordende reeks acties. + +```typescript +interface IntentChain { + id: string; + originalInput: string; + actions: IntentAction[]; // Geordende reeks + status: 'pending' | 'executing' | 'completed' | 'partial' | 'failed'; + meta: { + source: 'reflex' | 'orchestrator' | 'fallback'; + processingTimeMs: number; + aiReasoning?: string; // Uitleg van de Orchestrator (voor debugging) + }; +} +``` + +Uitvoering is **strikt sequentieel**: actie 2 start pas nadat actie 1 voltooid is (of de gebruiker actie 1 bevestigd heeft). Parallelle uitvoering wordt bewust niet ondersteund — de gebruiker verwacht een logische volgorde, en in de zorg kan de volgorde van acties klinisch relevant zijn (bijv. annuleren vóór opnieuw inplannen). + +### 6.6 Trade-off: Pre-fill vs. Auto-Execute + +**Overwogen alternatief**: Bij zeer hoge confidence classificaties (≥0.95) het formulier overslaan en direct uitvoeren (de notitie wegschrijven, de afspraak aanmaken). + +**Waarom we kozen voor alleen pre-fill**: In de zorg is de kost van een foute schrijfactie hoog (onjuist patiëntendossier) terwijl de kost van een extra bevestigingsklik laag is (fractie van een seconde). De risico-rendementsverhouding bevoordeelt sterk het vereisen van bevestiging. Bovendien dient het tonen van het vooringevulde formulier als transparantiemechanisme — de gebruiker ziet precies wat het systeem begrepen heeft, wat vertrouwen opbouwt over tijd. + +**Uitzondering om te overwegen voor de toekomst**: Read-only queries (agenda_query, risico_query) zouden zonder bevestiging uitgevoerd kunnen worden omdat ze geen data wijzigen. Dit is een redelijke optimalisatie maar geen prioriteit. + +--- + +## 7. Bouwblok 5: Protocol Engine (Nudge) + +### 7.1 Doel + +De Protocol Engine evalueert klinische regels na een succesvolle actie en stelt relevante vervolgacties voor. Het is de proactieve intelligentie van het systeem — dingen voorstellen waar de gebruiker niet om gevraagd heeft maar die klinisch relevant zijn op basis van protocollen. + +### 7.2 Waarom dit de differentiator is + +Elke chatbot kan intents classificeren. Elk formuliersysteem kan data voorinvullen. Wat een zorg-command-interface daadwerkelijk nuttig maakt is **domeinintelligentie**: weten dat na wondzorgdocumentatie een vervolgwondcontrole ingepland moet worden over 3 dagen volgens V&VN-richtlijnen. Dit is waar het systeem overgaat van "snellere data-invoer" naar "clinical decision support." + +### 7.3 Regelstructuur + +```typescript +interface ProtocolRule { + id: string; + name: string; // Leesbare regelnaam + + // Wanneer te triggeren + trigger: { + intent: string; // Welk voltooid intent deze regel triggert + conditions: Condition[]; // ALLE moeten matchen (AND-logica) + }; + + // Wat voor te stellen + suggestion: { + intent: string; // Het voorgestelde vervolg-intent + message: string; // Gebruikersgerichte suggestietekst (Nederlands) + prefillEntities: (completedAction: Action) => Record; + }; + + // Klinische onderbouwing + protocol?: { + name: string; // "V&VN Richtlijn Wondzorg" + reference: string; // "§4.2 Controlebeleid" + rationale: string; // Waarom deze suggestie ertoe doet + }; + + priority: 'low' | 'medium' | 'high'; + expiresAfterMs: number; // Suggestie verdwijnt na deze tijd + enabled: boolean; +} + +interface Condition { + field: string; // Entity-veld om te controleren + operator: 'equals' | 'contains' | 'matches' | 'exists'; + value?: string; // Verwachte waarde (niet nodig voor 'exists') +} +``` + +### 7.4 Engine-ontwerp: Pure Function + +De engine is een pure function: `(completedAction, rules) → suggestions[]`. Het heeft geen side effects, geen state, en geen kennis van waar regels vandaan komen. Dit maakt het: + +- **Testbaar**: Geef mock-acties en -regels mee, assert op suggesties +- **Portable**: Regels kunnen komen uit hardcoded TypeScript-objecten (MVP), een database-tabel (v2), of FHIR PlanDefinitions (enterprise) +- **Voorspelbaar**: Dezelfde input produceert altijd dezelfde output + +### 7.5 Integratiepunt + +De Protocol Engine draait na actievoltooiing, getriggerd door het Action System: + +``` +Actie succesvol voltooid + │ + ▼ +evaluateNudge(completedAction, protocolRules) + │ + ▼ +NudgeSuggestion[] (gesorteerd op prioriteit) + │ + ▼ +UI toont suggestie-toast met: + - Bericht ("Wondcontrole inplannen over 3 dagen?") + - Protocolreferentie ("V&VN Wondzorg §4.2") + - Accepteren-knop → opent nieuw artifact met vooringevulde entities + - Afwijzen-knop → logt afwijzing voor analytics +``` + +### 7.6 Voorbeeldregels (Zorg / GGZ) + +| Regel | Trigger | Suggestie | Protocol | +|-------|---------|-----------|----------| +| Wondzorg-opvolging | dagnotitie + inhoud bevat "wond" | Wondcontrole inplannen over 3 dagen | V&VN Wondzorg §4.2 | +| Medicatiewijziging-review | dagnotitie + inhoud bevat "medicatie" + "gewijzigd" | Medicatie-evaluatie inplannen over 1 week | FMS Polyfarmacie §3.1 | +| Incident-opvolging | dagnotitie + categorie = "incident" | Incidentrapport aanmaken | IGJ Meldcode §2 | +| Risico-herbeoordeling | risico_query bekeken | Risicoherbeoordeling inplannen als >30 dagen oud | GGZ Standaarden §5.4 | +| Intake-voltooiing | intake_status bekeken + ontbrekende secties | Navigeer naar volgende onvolledige sectie | Intakeprotocol | + +### 7.7 Trade-off: Rules Engine vs. AI-gegenereerde suggesties + +**Overwogen alternatief**: In plaats van regelgebaseerde suggesties, het LLM contextuele suggesties laten genereren op basis van de voltooide actie en patiëntgeschiedenis. + +**Waarom we kozen voor regels**: Klinische suggesties moeten traceerbaar zijn naar specifieke protocollen. Wanneer een verpleegkundige ziet "Wondcontrole inplannen over 3 dagen," moet ze weten *waarom* — en het antwoord moet een protocolreferentie zijn, niet "de AI vond het een goed idee." Regelgebaseerde suggesties zijn deterministisch, auditbaar en klinisch onderbouwd. AI-gegenereerde suggesties zijn creatief maar klinisch niet verifieerbaar. + +**Hybride toekomst**: De rules engine kan aangevuld worden met een AI-laag die *nieuwe regels voorstelt* op basis van patronen in actielogs. Deze voorgestelde regels worden dan beoordeeld door klinisch personeel en toegevoegd aan de regelset als ze geldig zijn. De engine zelf blijft regelgebaseerd; AI draagt bij aan regeldiscovery, niet regeluitvoering. + +### 7.8 Pad naar standaarden: CDS Hooks + +De Protocol Engine is conceptueel aligned met de [HL7 CDS Hooks](https://cds-hooks.hl7.org/) specificatie — een standaard voor Clinical Decision Support in de zorg. De mapping: + +| Cortex-concept | CDS Hooks equivalent | +|----------------|---------------------| +| ProtocolRule | CDS Service | +| Trigger (intent + conditions) | CDS Hook (workflow trigger) | +| NudgeSuggestion | CDS Card (suggestion type) | +| Protocol metadata | Card.source | + +Migratie naar CDS Hooks-compatibiliteit is niet nodig voor MVP maar architectureel mogelijk: regels uitdrukken als FHIR PlanDefinitions, triggers mappen naar CDS hook-types, output formatteren als CDS Cards. Dit maakt integratie mogelijk met ziekenhuis-CDS-systemen die al HL7 spreken. + +--- + +## 8. Cross-Cutting Concerns + +### 8.1 State Management + +Het systeem vereist state management voor vijf aparte domeinen. Dit moeten aparte stores zijn (geen monolithische store) om testbaarheid en single responsibility te behouden: + +| Store | Verantwoordelijkheid | Belangrijkste state | +|-------|---------------------|-------------------| +| **Context Store** | Applicatiecontext | Actieve patiënt, dienst, recente patiënten | +| **Chat Store** | Conversationele state | Berichten, streaming status, pending action | +| **Artifact Store** | UI artifact-beheer | Open artifacts (max 3), actief artifact | +| **Action Store** | Intent chain-uitvoering | Actieve chain, chain-geschiedenis | +| **Nudge Store** | Protocolsuggesties | Actieve suggesties, accept/dismiss tracking | + +Stores communiceren via subscriptions, niet via directe imports. Voorbeeld: wanneer de Action Store een chain voltooit, triggert de subscription van de Nudge Store de protocol-evaluatie. + +### 8.2 Observability + +Elke classificatie produceert een gestructureerd log-event: + +```typescript +interface ClassificationEvent { + timestamp: string; + userId: string; + input: string; // Gesanitiseerd (PII verwijderd of gehasht) + intent: string; + confidence: number; + source: 'reflex' | 'orchestrator' | 'fallback'; + escalationReason?: string; + processingTimeMs: number; + entities: Record; // Gesanitiseerd +} +``` + +Belangrijke metrics om te tracken: + +| Metric | Waarom het ertoe doet | +|--------|----------------------| +| Reflex hit rate | Als <60%, moeten patronen uitgebreid worden of embeddings overwogen | +| Orchestrator fallback rate | Hoog percentage = AI is onbetrouwbaar, circuit breaker-effectiviteit | +| Classificatie-latency (P95) | Gebruikerservaring-indicator | +| Intent-distributie | Laat zien welke features daadwerkelijk gebruikt worden | +| Nudge-acceptatieratio per regel | Geeft aan of suggesties klinisch nuttig zijn | + +### 8.3 Audit Trail + +In de zorg moet elke systeeminteractie met patiëntcontext auditbaar zijn: + +```typescript +interface AuditEvent { + userId: string; + action: 'classify' | 'resolve' | 'execute' | 'nudge_shown' | 'nudge_accepted' | 'nudge_dismissed'; + intent?: string; + patientId?: string; // Welke patiënt betrokken was + input?: string; // Gesanitiseerd + result?: string; // Samenvatting, niet volledige response + timestamp: string; + sessionId: string; // Voor correlatie binnen één gebruikerssessie + durationMs?: number; +} +``` + +Opslagvereisten: append-only tabel, geen UPDATE of DELETE, minimaal 5 jaar bewaring (NEN 7510-compliance voor Nederlandse zorg). + +### 8.4 Privacy: PII in AI-prompts + +Wanneer de Orchestrator context naar het LLM stuurt, bevat dit patiëntnamen en mogelijk klinische informatie. Mitigaties: + +1. **Minimaliseer context**: Stuur alleen wat nodig is voor classificatie (patiëntnaam, niet volledige medische geschiedenis) +2. **Data processing agreement**: Zorg dat de DPA van de AI-provider garandeert dat API-data niet gebruikt wordt voor training +3. **Log-sanitisatie**: Alle log-events moeten patiëntnamen en identifiers strippen of hashen vóór opslag +4. **Pseudonimisatie-optie**: Voor hoog-beveiligde omgevingen, vervang patiëntnamen door tokens vóór verzending naar AI, resolv tokens na classificatie + +### 8.5 Role-Based Access (Voorbereid, niet afgedwongen) + +De Intent Registry bevat een `allowedRoles`-veld per intent. Dit maakt toekomstige RBAC-filtering mogelijk zonder architectuurwijzigingen: + +``` +Input → Classification Pipeline → [RBAC Filter] → Action System + │ + └─ Als intent niet toegestaan voor gebruikersrol: + → "Je hebt geen toegang tot deze functie" +``` + +Het filter zit tussen classificatie en actie: het systeem classificeert het intent (zodat het weet wat geprobeerd werd) maar blokkeert uitvoering als de rol van de gebruiker het niet toestaat. De geblokkeerde poging wordt gelogd voor auditdoeleinden. + +--- + +## 9. Schaalbaarheidsoverwegingen + +### 9.1 Intents schalen: van 11 naar 50+ + +Het huidige systeem heeft 11 intents. De architectuur ondersteunt groei naar 50+ met deze overwegingen: + +| Dimensie | Bij 11 intents | Bij 50 intents | Mitigatie | +|----------|---------------|----------------|-----------| +| Reflex matching | ~88 regex-evaluaties (<20ms) | ~400 evaluaties (~50ms) | Keyword pre-filter: match eerste woord tegen index, evalueer alleen kandidaat-intents | +| AI-prompt grootte | ~2000 tokens | ~8000 tokens | Categorie-gebaseerde prompt-secties; neem alleen relevante categorieën op basis van Reflex pre-classificatie | +| Registry-bestandsgrootte | ~300 regels | ~1500 regels | Splits in categorie-sub-registries die samenvoegen bij runtime | +| Ambiguïteit | Laag (intents zijn onderscheidend) | Hoger (meer overlappende patronen) | Vergroot patroonspecificiteit; voeg disambiguatieregels toe | + +### 9.2 Gebruikers schalen + +| Component | Bottleneck | Mitigatie | +|-----------|-----------|-----------| +| Reflex | Geen (stateless, in-process) | Schaalt met applicatie-instanties | +| Orchestrator | AI-provider rate limits | Circuit breaker voorkomt cascade; overweeg provider load balancing | +| Rate limiting | Momenteel in-memory (verloren bij herstart) | Verplaats naar database-backed (Supabase-tabel of Redis) | +| Audit logging | Schrijfvolume | Batch writes; async logging pipeline | + +### 9.3 AI Provider Independence + +Het systeem is momenteel gekoppeld aan Anthropic Claude. Om vendor lock-in te verminderen: + +```typescript +interface LLMProvider { + classify(input: string, systemPrompt: string, context: string): Promise; + stream(messages: Message[], systemPrompt: string): AsyncIterable; +} +``` + +Twee implementaties (Anthropic, OpenAI) achter één interface. Let op: prompts zijn NIET volledig portable tussen providers — de system prompt is geoptimaliseerd voor het gedrag van Claude. Provider-wisseling vereist prompt-hertuning. Dit is inherent aan LLM-gebruik en kan niet volledig geabstraheerd worden. + +--- + +## 10. Relatie met zorgstandaarden + +### 10.1 FHIR Resource Mapping + +Geëxtraheerde entities mappen uiteindelijk naar FHIR-geïnspireerde resources: + +| Entity | FHIR Resource | Gebruik | +|--------|---------------|---------| +| patientName / patientId | Patient | Patiëntidentificatie | +| category + content | Observation of DocumentReference | Klinische notities | +| datetime + appointmentType | Encounter / Appointment | Planning | +| diagnosis / risk | Condition | Klinische data-queries | + +Het systeem hoeft geen FHIR-server te zijn. Het heeft een duidelijke mapping-laag nodig zodat wanneer FHIR-compliance vereist wordt, entity resolution FHIR-compliant referenties kan produceren. + +### 10.2 NEN 7510 (Informatiebeveiliging in de zorg) + +| Eis | Hoe deze architectuur het adresseert | +|-----|--------------------------------------| +| Toegangscontrole | RBAC voorbereid in Intent Registry; Supabase Auth + RLS op data | +| Audit logging | Append-only audit events voor alle interacties | +| Geen PII in logs | Sanitisatiestap in logging pipeline | +| Encryptie in transit | HTTPS (standaard voor moderne webapps) | +| Encryptie at rest | Database-niveau (Supabase managed) | +| Incidentregistratie | Classificatiefouten gelogd als potentiële beveiligingsincidenten | + +--- + +## 11. Migratiepad vanuit huidig prototype + +### Fase 1: Fundament (Laag risico) +**Doel**: Intent Registry als single source of truth + entity-extractie in Reflex + +1. Maak `intent-registry.ts` met alle 11 huidige intents als declaratieve objecten +2. Refactor `reflex-classifier.ts` om patronen uit registry te laden in plaats van hardcoded map +3. Voeg entity-extractieregels toe aan registry; implementeer extractie in Reflex-fase +4. Genereer Orchestrator-prompt vanuit registry (vervang hardcoded prompt) +5. Verifieer: alle bestaande classificaties produceren dezelfde resultaten (regressietest) + +**Risico**: Laag — refactoring zonder gedragswijziging (behalve toegevoegde entity-extractie). + +### Fase 2: Unificatie (Gemiddeld risico) +**Doel**: Enkele classificatie-pipeline die zowel Classify als Chat API's bedient + +1. Extraheer `classifyInput()` als standalone pipeline-functie +2. Pas Chat API aan om pipeline te gebruiken voor classificatie (verwijder dubbele intent-logica uit chat-prompt) +3. Vereenvoudig Chat system prompt tot alleen conversationele rol (geen classificatieverantwoordelijkheid) +4. Fix AbortController signal propagation (momenteel losgekoppeld van daadwerkelijke fetch) +5. Voeg circuit breaker toe aan Orchestrator + +**Risico**: Gemiddeld — Chat-gedrag kan subtiel veranderen. Vereist grondig testen met bestaande scenario's. + +### Fase 3: Activatie (Laag risico) +**Doel**: Nudge-systeem daadwerkelijk actief; state management opgeschoond + +1. Splits monolithische Zustand store in 5 domein-stores +2. Koppel `evaluateNudge()` om te vuren na actievoltooiing (via store subscription) +3. Voeg 3-5 klinische protocolregels toe +4. Implementeer nudge tracking (getoond/geaccepteerd/afgewezen) + +**Risico**: Laag — nieuwe functionaliteit, geen breaking changes aan bestaande features. + +### Fase 4: Productiegereedheid (Laag risico) +**Doel**: Observeerbaar, auditbaar, veerkrachtig + +1. Gestructureerde logging (vervang console.log) +2. Classificatie-metrics tracking +3. Audit events naar database +4. Database-backed rate limiting +5. PII-sanitisatie in logs + +**Risico**: Laag — cross-cutting infrastructuur, geen functionaliteitswijzigingen. + +--- + +## 12. Decision Log + +Deze sectie documenteert de belangrijkste architectuurbeslissingen met hun rationale, voor toekomstige referentie. + +### D1: Drielagenmodel (Reflex → Orchestrator → Nudge) + +**Beslissing**: Gebruik een tiered classificatiemodel met lokaal snel pad en AI fallback, plus protocol-gedreven post-action suggesties. + +**Rationale**: Optimaliseert voor het veelvoorkomende geval (70%+ routinecommando's lokaal afgehandeld in <20ms) terwijl AI-capaciteit behouden blijft voor complexe input. Nudge-laag voegt domeinwaarde toe voorbij classificatie. Dit patroon is gevalideerd door industriebenchmarks (Voiceflow 2025) die laten zien dat hybride NLU+LLM zowel pure NLU als pure LLM overtreft op kosten én nauwkeurigheid. + +**Afgewezen alternatieven**: Pure LLM (te traag en duur voor routinecommando's), pure rule-based (kan multi-intent, voornaamwoorden, relatieve tijd niet aan), custom ML-model (trainingsdata-overhead zonder proportionele nauwkeurigheidswinst in stabiel domein). + +### D2: Human-in-the-Loop voor alle schrijfacties + +**Beslissing**: Het systeem schrijft nooit naar patiëntendossiers zonder expliciete menselijke bevestiging. Vul formulieren voor, verzend nooit automatisch. + +**Rationale**: Zorg vereist verantwoording. De kost van een foute schrijfactie (onjuist patiëntendossier) overtreft verre de kost van een extra bevestigingsklik. Dit bouwt ook gebruikersvertrouwen op — het systeem is transparant over wat het begrepen heeft. + +**Afgewezen alternatieven**: Auto-uitvoering bij hoge-confidence classificaties (>0.95). Afgewezen omdat zelfs bij 99% nauwkeurigheid, 1 foute schrijfactie per 100 interacties onacceptabel is in een klinische context. + +### D3: Gecentraliseerde Intent Registry boven Feature Folders + +**Beslissing**: Eén registry-bestand boven een bestand-per-intent modulestructuur. + +**Rationale**: Cross-cutting concerns (ambiguïteitdetectie, RBAC-filtering, promptgeneratie) hebben de volledige intent-catalogus nodig. Een gecentraliseerde registry maakt dit natuurlijk. De kosten (één groot bestand) zijn beheersbaar bij <50 intents en kunnen later opgesplitst worden in sub-registries. + +### D4: Regex boven Embeddings voor Fase 1 Classificatie + +**Beslissing**: Gebruik regex-patronen met gewichten voor de Reflex-fase. + +**Rationale**: Domeinvocabulaire is stabiel en beperkt (medische termen, vaste werkprocessen). Regex bereikt bijna perfecte nauwkeurigheid voor bekende patronen bij nul latency. Embeddings voegen infrastructuurcomplexiteit toe zonder proportionele nauwkeurigheidsverbetering bij de huidige schaal. + +**Heroverweging-trigger**: Reflex hit rate zakt onder 60%. + +### D5: Regelgebaseerde Protocol Engine boven AI-gegenereerde suggesties + +**Beslissing**: Nudge-suggesties zijn deterministisch, gebaseerd op expliciet gedefinieerde protocolregels. + +**Rationale**: Klinische suggesties moeten traceerbaar zijn naar specifieke protocollen. Regelgebaseerde suggesties zijn auditbaar en verifieerbaar. AI-gegenereerde suggesties zijn creatief maar klinisch niet verifieerbaar. + +**Toekomstige hybride**: AI stelt kandidaat-regels voor op basis van patronen in actielogs; klinisch personeel beoordeelt en keurt goed; engine blijft regelgebaseerd. + +### D6: Sequentiële Multi-Intent Execution boven Parallel + +**Beslissing**: Acties in een IntentChain worden sequentieel uitgevoerd, nooit parallel. + +**Rationale**: Gebruikers verwachten logische ordening ("annuleer afspraak EN maak notitie" impliceert eerst annuleren). In de zorg kan actievolgorde klinisch relevant zijn. Sequentiële uitvoering is voorspelbaar en debugbaar. + +--- + +## 13. Platformmodel: Van Intent-Systeem naar Zorgtoepassing + +### 13.1 De vier lagen + +Het complete systeem bestaat uit vier lagen. Het intent-systeem (dit document) is laag 1. Daarbovenop komen drie lagen die samen een zorgtoepassing vormen. + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ │ +│ LAAG 4: EPD-APPLICATIE │ +│ De toepassing die de zorgverlener ziet en gebruikt │ +│ │ +│ Rapportage │ Dossier │ Agenda │ Overdracht │ Intake │ ... │ +│ UI-modules, block-componenten, API-routes, datamodel │ +│ │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ LAAG 3: ZORGDOMEIN-CONFIGURATIE │ +│ De kennis van het specifieke zorgtype │ +│ │ +│ Intent-definities (dagnotitie, overdracht, agenda, ...) │ +│ Entity-schemas (patiënt, categorie, dienst, ...) │ +│ Domeinvocabulaire (GGZ-termen, rapportagecategorieën) │ +│ Protocol-regels (nudges specifiek voor dit zorgtype) │ +│ │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ LAAG 2: KENNISLAAG │ +│ Externe databronnen die de Protocol Engine voeden │ +│ │ +│ ┌───────────┐ ┌──────────────┐ ┌────────────┐ ┌───────────┐ │ +│ │ Wet- en │ │ Behandel- │ │ Kwaliteits-│ │ EPD-data │ │ +│ │ regel- │ │ protocollen │ │ documenten │ │ (eigen │ │ +│ │ geving │ │ │ │ │ │ patiënt- │ │ +│ │ │ │ │ │ │ │ data) │ │ +│ └───────────┘ └──────────────┘ └────────────┘ └───────────┘ │ +│ │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ LAAG 1: INTENT-SYSTEEM (dit document) │ +│ De generieke motor │ +│ │ +│ Intent Registry │ Classification Pipeline │ Entity Resolution │ +│ Action System │ Protocol Engine (Nudge) │ +│ │ +└─────────────────────────────────────────────────────────────────┘ +``` + +### 13.2 Waarom de Kennislaag ertoe doet + +De Protocol Engine (Bouwblok 5) genereert nudges op basis van regels. Maar die regels komen niet uit de lucht vallen — ze zijn afgeleid van externe kennisbronnen. De kwaliteit van de nudges is direct afhankelijk van de kwaliteit en toegankelijkheid van deze bronnen. + +Zonder de Kennislaag is de Protocol Engine een lege motor: de mechanica werkt, maar er is geen brandstof. De Kennislaag is die brandstof. + +### 13.3 De vier kennisbronnen + +#### 13.3.1 Wet- en regelgeving + +Wetten en normen die het handelen in de zorg reguleren. Deze bepalen wat er *moet* gebeuren. + +| Bron | Voorbeeld | Type nudge dat eruit voortkomt | +|------|-----------|-------------------------------| +| Wlz (Wet langdurige zorg) | Zorgplanvereisten, evaluatietermijnen | "Zorgplan evaluatie is over 2 weken verlopen" | +| Wvggz (Wet verplichte GGZ) | Meldplicht, termijnen dwangmaatregelen | "Dwangmaatregel verloopt over 3 dagen — verlenging nodig?" | +| Wkkgz (Wet kwaliteit, klachten en geschillen zorg) | Incidentmeldplicht | "Incident geregistreerd — IGJ-melding vereist binnen 3 werkdagen" | +| NEN 7510 / AVG | Dossierbewaartermijnen, toegangslogging | "Audit log: 3 medewerkers hebben dit dossier ingezien" | +| Wmcz (Wet medezeggenschap cliënten zorginstellingen) | Cliëntenraad-informatieplicht | (Niet direct nudge-relevant, maar compliance-check) | + +**Kenmerken**: Verandert langzaam (wetswijzigingen), hoge betrouwbaarheid, publiek beschikbaar, juridisch bindend. + +**Technische implicatie**: Deze regels zijn stabiel genoeg om als hardcoded protocolregels in de engine te zitten. Ze veranderen misschien 1-2x per jaar. Een database-backed regelsysteem is handig maar niet strikt noodzakelijk. + +#### 13.3.2 Behandelprotocollen + +Klinische richtlijnen en standaarden die beschrijven hoe zorg geleverd *zou moeten* worden. + +| Bron | Voorbeeld | Type nudge dat eruit voortkomt | +|------|-----------|-------------------------------| +| GGZ Standaarden | Zorgstandaard Depressie, Psychose, etc. | "Patiënt met depressie — ROM-meting gepland over 6 weken?" | +| V&VN Richtlijnen | Wondzorg, medicatiebeheer, valpreventie | "Wondcontrole inplannen over 3 dagen (V&VN §4.2)" | +| FMS Richtlijnen | Polyfarmacie, pijnbehandeling | "Medicatie-evaluatie over 1 week (FMS Polyfarmacie §3.1)" | +| Multidisciplinaire richtlijnen | MDO-frequentie, behandelplanbesprekingen | "MDO gepland over 2 weken — voorbereiding starten?" | +| NHG Standaarden | (Bij samenwerking met huisarts) | "Verwijsbrief huisarts — terugkoppeling binnen 4 weken" | +| Zorginstituut Nederland | Kwaliteitskaders langdurige zorg | "Jaarlijkse kwaliteitsmeting — deadline over 6 weken" | + +**Kenmerken**: Verandert regelmatig (nieuwe richtlijnversies), hoge betrouwbaarheid, publiek beschikbaar (ggzstandaarden.nl, V&VN), vereist interpretatie door klinisch personeel. + +**Technische implicatie**: Deze bronnen zijn te omvangrijk en te genuanceerd om handmatig als regels te coderen. Hier komt een **RAG-component** (Retrieval Augmented Generation) in beeld: de protocolteksten worden geïndexeerd, en bij relevante acties wordt de LLM gevraagd om op basis van de protocoltekst een specifieke nudge-suggestie te formuleren. Die suggestie wordt vervolgens door klinisch personeel gevalideerd en als regel opgenomen. + +Dit is het pad naar het "hybride model" beschreven in sectie 7.7: AI stelt regels voor, mensen valideren, de engine voert uit. + +#### 13.3.3 Kwaliteitsdocumenten + +Interne documenten van de zorginstelling die beschrijven hoe *deze specifieke organisatie* zorg levert. + +| Bron | Voorbeeld | Type nudge dat eruit voortkomt | +|------|-----------|-------------------------------| +| Instellingsprotocollen | Huisprotocol medicatiedistributie | "Dubbele controle medicatie vereist (huisprotocol §2.3)" | +| Werkafspraken | Overdrachtsmomenten, rapportagefrequentie | "Overdrachtsrapportage niet ingevuld — dienst eindigt over 1 uur" | +| Kwaliteitshandboek | Auditmomenten, verbeterplannen | "Interne audit volgende maand — actieplan bijwerken" | +| Accreditatie-eisen | HKZ, PREZO, Planetree | "Cliënttevredenheidsonderzoek — 3 patiënten nog niet bevraagd" | + +**Kenmerken**: Organisatie-specifiek (niet publiek), verandert bij beleidsbeslissingen, vereist interne afstemming, vaak in Word/PDF formaat. + +**Technische implicatie**: Dit is de meest uitdagende bron omdat het per instelling verschilt. Bij onboarding van een nieuwe GGZ-instelling moeten hun interne protocollen geïndexeerd worden. Opties: + +1. **Handmatig**: Klinisch personeel vertaalt hun protocollen naar nudge-regels in de admin-interface. Arbeidsintensief maar nauwkeurig. +2. **Semi-automatisch**: Upload documenten → RAG-indexering → AI genereert kandidaat-regels → klinisch personeel valideert. Sneller, maar vereist validatieworkflow. +3. **Hybride**: Standaard-regelset (op basis van landelijke richtlijnen) + organisatie-specifieke aanvullingen. + +#### 13.3.4 EPD-data (eigen patiëntdata) + +De data die al in het systeem zit — patiëntendossiers, rapportages, afspraken, behandelplannen. + +| Databron | Voorbeeld | Type nudge dat eruit voortkomt | +|----------|-----------|-------------------------------| +| Rapportagegeschiedenis | Geen rapportage in 48 uur | "Geen dagnotitie voor Jan de Vries in 2 dagen" | +| Behandelplan | Evaluatiedatum verstreken | "Behandelplanevaluatie Jan — 1 week over deadline" | +| Medicatieoverzicht | Medicatie-interacties, wijzigingen | "Nieuwe medicatie voorgeschreven — interactiecheck nodig" | +| Risicotaxatie | Verlopen risicobeoordeling | "Risicotaxatie Marie — laatste beoordeling 45 dagen geleden" | +| Agenda | Gemiste afspraken, no-shows | "Jan 2x no-show deze maand — contact opnemen?" | +| Lab/metingen | ROM-scores, vitale waarden | "PHQ-9 score gestegen van 12 naar 18 — aanpassing behandelplan?" | + +**Kenmerken**: Realtime, patiënt-specifiek, altijd beschikbaar (het zit in je eigen database), privacy-gevoelig. + +**Technische implicatie**: Dit is de enige bron die geen externe integratie vereist — het zit al in Supabase. De Protocol Engine kan direct queries draaien: + +```typescript +// Voorbeeld: check of er recente rapportage is +interface DataDrivenCondition { + type: 'query'; + table: 'reports'; + filter: { patient_id: '$activePatient', created_at: { gt: 'now() - interval 48 hours' } }; + expect: 'exists'; // Als NIET exists → trigger nudge +} +``` + +Dit is de eenvoudigste en meest impactvolle bron om mee te beginnen: je hebt de data al, de queries zijn simpel, en de nudges zijn direct relevant. + +### 13.4 Hoe de Kennislaag de Protocol Engine voedt + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ KENNISLAAG │ +│ │ +│ ┌─────────────────┐ ┌─────────────────────────────────┐ │ +│ │ Statische regels │ │ Dynamische regels │ │ +│ │ │ │ │ │ +│ │ Wet- en regel- │ │ EPD-data queries │ │ +│ │ geving │ │ (rapportage-gaps, verlopen │ │ +│ │ (hardcoded, │ │ beoordelingen, no-shows) │ │ +│ │ wijzigt zelden) │ │ │ │ +│ │ │ │ Behandelprotocollen via RAG │ │ +│ │ Landelijke │ │ (geïndexeerde richtlijnteksten │ │ +│ │ richtlijnen │ │ → AI-gegenereerde kandidaat- │ │ +│ │ (V&VN, GGZ Std) │ │ regels → menselijke validatie) │ │ +│ │ │ │ │ │ +│ │ Instellings- │ │ Kwaliteitsdocumenten │ │ +│ │ protocollen │ │ (geüpload per instelling, │ │ +│ │ (bij onboarding │ │ geïndexeerd, AI-voorgesteld) │ │ +│ │ geconfigureerd) │ │ │ │ +│ └────────┬─────────┘ └────────────┬────────────────────┘ │ +│ │ │ │ +│ ▼ ▼ │ +│ ┌──────────────────────────────────────────────────────────┐ │ +│ │ PROTOCOL RULES REGISTRY │ │ +│ │ │ │ +│ │ Alle regels — ongeacht bron — in hetzelfde formaat: │ │ +│ │ trigger + conditions + suggestion + protocol metadata │ │ +│ │ │ │ +│ │ Elke regel bevat: │ │ +│ │ - source: 'wetgeving' | 'richtlijn' | 'instelling' │ │ +│ │ | 'epd_data' | 'ai_suggested' │ │ +│ │ - validatedBy: userId (wie heeft de regel goedgekeurd) │ │ +│ │ - validatedAt: timestamp │ │ +│ │ - version: regelversie (voor audittrail) │ │ +│ └──────────────────────────┬───────────────────────────────┘ │ +│ │ │ +└──────────────────────────────┼───────────────────────────────────┘ + │ + ▼ + ┌──────────────────────┐ + │ PROTOCOL ENGINE │ + │ (Bouwblok 5) │ + │ │ + │ evaluateNudge() │ + └──────────────────────┘ +``` + +### 13.5 Implementatievolgorde voor de Kennislaag + +De vier bronnen hebben zeer verschillende implementatiecomplexiteit. De volgorde: + +**Stap 1: EPD-data (eigen database)** — Start hier. +Geen externe integratie nodig. Supabase queries op je eigen tabellen. Voorbeelden: rapportage-gaps, verlopen beoordelingen, gemiste afspraken. Directe waarde, lage complexiteit. Dit zijn "data-driven nudges" die je kunt bouwen met wat je al hebt. + +**Stap 2: Wet- en regelgeving + landelijke richtlijnen** — Hardcoded regels. +Stabiele bronnen, publiek beschikbaar. Vertaal de belangrijkste wettelijke termijnen en richtlijn-aanbevelingen naar protocolregels. 20-30 regels die voor elke GGZ-instelling gelden. Eenmalig werk dat je voor alle klanten hergebruikt. + +**Stap 3: Instellingsprotocollen** — Per klant configureerbaar. +Bij onboarding van een nieuwe instelling: hun protocollen uploaden, vertalen naar regels (handmatig of semi-automatisch). Dit is het stuk dat de toepassing organisatie-specifiek maakt. + +**Stap 4: RAG op behandelprotocollen** — AI-ondersteund. +Indexeer de volledige tekst van GGZ Standaarden, V&VN richtlijnen, etc. Gebruik RAG om bij relevante acties protocolteksten op te halen en kandidaat-nudges te genereren. Klinisch personeel valideert. Dit is het meest geavanceerde stuk — maar ook het meest schaalbare, omdat je hiermee honderden regels kunt genereren die je handmatig nooit zou uitschrijven. + +### 13.6 Trade-off: Regels vs. RAG + +| Aspect | Hardcoded regels | RAG-gegenereerde suggesties | +|--------|------------------|-----------------------------| +| **Nauwkeurigheid** | 100% (menselijk gevalideerd) | ~80-90% (AI-gegenereerd, moet gevalideerd) | +| **Schaalbaarheid** | Laag (handmatig per regel) | Hoog (automatisch uit documenten) | +| **Traceerbaarheid** | Perfect (regel → protocol §) | Goed (RAG-bron + AI-reasoning) | +| **Opstartkosten** | Laag per regel, hoog voor volledigheid | Hoog voor setup, laag per regel daarna | +| **Onderhoud** | Handmatig bij richtlijnwijzigingen | Semi-automatisch (herindexeren + hervalideren) | + +**Aanbeveling**: Begin met hardcoded regels (stap 1-3). Bouw RAG als de regelset groeit voorbij wat handmatig beheersbaar is (~50+ regels per instelling). Het regelformaat is hetzelfde — de bron verandert, de engine niet. + +### 13.7 De Kennislaag als product-differentiator + +Dit is waar het commercieel interessant wordt. De Kennislaag is wat het verschil maakt tussen: + +- **Generiek intent-systeem**: "Ik begrijp je commando en open het juiste formulier" — dat kan iedereen bouwen. +- **Zorg-specifiek platform**: "Ik weet dat na wondzorg een controle nodig is over 3 dagen volgens V&VN §4.2, en dat de Wlz vereist dat het zorgplan binnen 6 weken geëvalueerd wordt" — dat vereist domeinkennis. +- **Instelling-specifiek systeem**: "Ik weet dat jullie huisprotocol vereist dat medicatie-uitgifte met twee personen gecontroleerd wordt, en dat de volgende interne audit over 3 weken is" — dat vereist organisatiekennis. + +Elke laag voegt waarde toe. Het intent-systeem (laag 1) is de motor die iedereen kan bouwen. De Kennislaag (laag 2) is het vliegwiel dat moeilijk te kopiëren is. + +### 13.8 Laag-scheiding en herbruikbaarheid + +De vier lagen zijn bewust ontkoppeld: + +| Vervang je... | Dan verandert... | En blijft ongewijzigd... | +|---------------|-----------------|--------------------------| +| **Laag 4** (EPD-applicatie) | UI, API-routes, datamodel | Intent-systeem, Kennislaag, Domeinconfig | +| **Laag 3** (Zorgdomein) | Intents, entities, vocabulaire | Intent-systeem, Kennislaag, EPD-applicatie | +| **Laag 2** (Kennislaag) | Protocolregels, databronnen | Intent-systeem, Domeinconfig, EPD-applicatie | +| **Laag 1** (Intent-systeem) | Classificatie, resolution, actions | Kennislaag, Domeinconfig, EPD-applicatie | + +Concreet voorbeeld: wil je van GGZ naar thuiszorg? Dan: +- **Laag 1** blijft identiek (dezelfde motor) +- **Laag 2** krijgt andere bronnen (thuiszorgprotocollen i.p.v. GGZ Standaarden, Wlz i.p.v. Wvggz) +- **Laag 3** krijgt andere intents (zorgmoment_registratie i.p.v. dagnotitie, route_planning i.p.v. agenda) +- **Laag 4** krijgt een andere UI (thuiszorg-app i.p.v. EPD-dashboard) + +--- + +## Appendix A: Begrippenlijst + +| Term | Definitie | +|------|-----------| +| **Intent** | Een geclassificeerde gebruikersintentie: wat de gebruiker wil doen (bijv. `dagnotitie`, `create_appointment`) | +| **Entity** | Een parameter geëxtraheerd uit gebruikersinput (bijv. patiëntnaam, datum, categorie) | +| **Confidence** | Een score (0.0–1.0) die aangeeft hoe zeker de classificatie is | +| **Reflex** | De snelle, lokale classificatiefase met regex-patronen | +| **Orchestrator** | De AI-gestuurde classificatiefase met een LLM | +| **IntentChain** | Een geordende reeks acties afgeleid uit één gebruikersuiting | +| **Artifact** | Een UI-paneel (formulier, dataweergave) dat geopend wordt als reactie op een intent | +| **Block** | Een React-component dat een specifiek artifact-type rendert | +| **Nudge** | Een proactieve suggestie gegenereerd door de Protocol Engine na actievoltooiing | +| **Protocol Rule** | Een declaratieve regel die een nudge triggert op basis van voltooide actie + condities | +| **Entity Resolution** | Het proces van het gronden van ruwe entity-strings tegen echte systeemdata | +| **Escalation** | De beslissing om input van Reflex naar Orchestrator te sturen voor AI-classificatie | +| **Circuit Breaker** | Een veerkrachtigheidspatroon dat AI-calls omzeilt na opeenvolgende fouten | + +## Appendix B: Huidige Intent Catalogus + +| Intent | Prioriteit | Categorie | Artifact | Bevestiging | +|--------|-----------|-----------|----------|-------------| +| `dagnotitie` | P1 | Klinisch | Formulier (notitie-aanmaak) | Nee (alleen pre-fill) | +| `zoeken` | P1 | Navigatie | Zoekresultaten-weergave | Nee | +| `overdracht` | P1 | Klinisch | Overdrachtssamenvatting | Nee | +| `agenda_query` | P2 | Administratief | Kalenderweergave | Nee | +| `create_appointment` | P2 | Administratief | Afspraakformulier | Nee (pre-fill) | +| `cancel_appointment` | P2 | Administratief | Bevestigingsdialoog | Ja (destructief) | +| `reschedule_appointment` | P2 | Administratief | Afspraakformulier | Ja (wijzigend) | +| `intake_status` | P3 | Klinisch | Intake-voortgangsweergave | Nee | +| `intake_navigeer` | P3 | Navigatie | Paginanavigatie | Nee (geen artifact) | +| `risico_query` | P3 | Klinisch | Risicobeoordeling-weergave | Nee | +| `diagnose_query` | P3 | Klinisch | Diagnoselijst-weergave | Nee | + +## Appendix C: Referenties + +- [Voiceflow: Benchmarking Hybrid LLM Classification Systems](https://www.voiceflow.com/pathways/benchmarking-hybrid-llm-classification-systems) — Productiebenchmarks die laten zien dat hybride NLU+LLM pure aanpakken overtreft +- [HL7 CDS Hooks Specificatie](https://cds-hooks.hl7.org/) — Standaard voor Clinical Decision Support integratie +- [Microsoft Dragon Copilot](https://www.microsoft.com/en-us/health-solutions/clinical-workflow/dragon-copilot) — Grootste ambient AI klinisch documentatiesysteem (capture → classify → act → review patroon) +- [MediGRAF: Hybrid Graph RAG voor EPD](https://arxiv.org/abs/2602.00009) — Hybride gestructureerde + ongestructureerde bevraging van patiëntdata +- [NEN 7510](https://www.nen.nl/nen-7510-1-2017-nl-245399) — Nederlandse norm voor informatiebeveiliging in de zorg diff --git a/docs/architecture/overzicht-po-pm.html b/docs/architecture/overzicht-po-pm.html new file mode 100644 index 0000000..6d624f4 --- /dev/null +++ b/docs/architecture/overzicht-po-pm.html @@ -0,0 +1,287 @@ + + + + + +Mini-EPD — Architectuur & Datacomponenten (PO/PM) + + + +
+ +
+

Mini-EPD — Architectuur & Datacomponenten

+

Eén begrijpelijk overzicht voor Product Owners & Project Managers

+ GGZ Elektronisch Patiëntdossier · Prototype +
+ + +
+

1In het kort

+

Het Mini-EPD is een elektronisch patiëntdossier voor de GGZ. Een zorgverlener meldt patiënten aan, doet intake, maakt behandelplannen, schrijft dagrapportages en draagt diensten over. Het hart is de Cortex AI Command Center: een natuurlijke-taal-interface (typen of inspreken) waarmee je acties uitvoert in gewone zinnen — "maak een notitie voor Jan: medicatie ingenomen" of "plan een afspraak morgen om 14:00".

+
+ + +
+

2De drie lagen van het systeem

+

Van wat de gebruiker ziet tot waar de gegevens staan.

+
+
+
Laag 1 · Schermen
+
Wat de gebruiker ziet
+
Dashboard · Patiëntdossier · Intake · Behandelplan · Verpleegrapportage · Agenda · Cortex AI Command Center
+
+
▼
+
+
Laag 2 · Logica
+
De verwerking (API's)
+
Rapportage · Overdracht · Behandelplan · Intake · Cortex (intentherkenning + chat) · Spraak-naar-tekst
+
+
▼
+
+
Laag 3 · Gegevens
+
Database & externe diensten
+
Supabase database · Claude AI (Anthropic) · Deepgram (spraak)
+
+
+
+ + +
+

3De modules (wat de gebruiker ziet)

+

De schermen waarmee de zorgverlener werkt.

+
+
🏠
Dashboard
Startscherm met het Cortex AI Command Center. Hier begint elke actie.
+
📋
Patiëntdossier
Basisgegevens (incl. BSN), diagnoses, observaties en intakes per patiënt.
+
📝
Intake
Stapsgewijs: contactpersonen, risicotaxatie, anamnese, onderzoek, diagnose, advies.
+
🎯
Behandelplan
Doelen en interventies per leefgebied vastleggen en beheren.
+
🔄
Verpleegrapportage
Dagnotities in tijdlijn + overdracht met AI-samenvatting voor de volgende dienst.
+
📅
Agenda
Kalender met afspraken; inplannen, verzetten of annuleren.
+
+
+ + +
+

4Het hart: Cortex AI Command Center

+

De gebruiker typt of spreekt een opdracht. Het systeem begrijpt de bedoeling en handelt — in drie slimme lagen die snelheid én begrip combineren.

+
+
🗣
Gebruiker zegt of typt iets
"Maak een notitie voor Jan: medicatie ingenomen"
+
▼
+
1
Reflex (lokaal) — snel & gratis
Herkent veelvoorkomende opdrachten direct via patronen (<20ms). Twijfel of complex? → door naar laag 2.
+
▼
+
2
Orchestrator (AI) — voor lastige gevallen
Claude lost op: meerdere opdrachten tegelijk, "hem/haar", "morgen", onduidelijke zinnen.
+
▼
+
✓
Actie uitgevoerd
Notitie opgeslagen · afspraak gemaakt · patiënt gevonden …
+
▼
+
3
Nudge — proactieve suggestie achteraf
"Wil je hier ook een observatie bij maken?" — verhoogt de zorgkwaliteit op het juiste moment.
+
+

Waarom drie lagen? De goedkope lokale laag vangt het gros af zonder AI-kosten of vertraging. Alleen echt lastige zinnen gaan naar de betaalde AI.

+

Wat Cortex begrijpt (de "intents"):

+
+ Dagnotitie maken + Patiënt zoeken + Overdracht bekijken + Agenda opvragen + Afspraak inplannen + Afspraak annuleren + Afspraak verzetten +
+
+ + +
+

5De externe diensten (afhankelijkheden)

+

Waar het product op leunt buiten de eigen code.

+
+
+
🗄️ Supabase
+
Database + inloggen (authenticatie)
+
De plek waar alle patiëntgegevens veilig staan.
+
+
+
🤖 Claude (Anthropic)
+
Intentherkenning · chat · overdrachtssamenvatting · behandelplan
+
De "intelligentie" achter Cortex en de samenvattingen. Betaalde API → gebruik = kosten.
+
+
+
🎙️ Deepgram
+
Spraak omzetten naar tekst
+
Maakt het inspreken van notities mogelijk. Betaalde API → gebruik = kosten.
+
+
+
+ + +
+

6De gegevens (datacomponenten)

+

Het datamodel is FHIR-geïnspireerd — de internationale standaard voor zorggegevens, pragmatisch vereenvoudigd. Alles draait om de patiënt.

+ +
+
+
PATIËNT
+
naam · BSN · geboortedatum · status
+
+
+
+
Screening
aanmelding & besluit
+
Intake
+ risico, anamnese, onderzoek
+
Diagnose
DSM-5 / ICD-10
+
Observatie
metingen & scores
+
Behandelplan
doelen & interventies
+
+
+
Contactmoment → Rapportage
sessies & dagnotities
+
+ +
+

Soorten rapportage (type):

+ voortgangobservatieincidentmedicatiecontactcrisisverpleegkundigbehandeladvies +

Categorieën (verpleegkundig):

+ medicatieADLgedragincidentobservatie +
+
+ + +
+

7De patiëntreis door de data

+

Hoe een patiënt door het systeem stroomt.

+
+
Aangemeld
status: planned
›
+
Screening
geschikt?
›
+
Intake
anamnese, risico
›
+
In zorg
plan + rapportages
›
+
Overdracht
samenvatting collega
+
+
+ + +
+

8Belangrijke regels in de data

+

Goed om te weten als PO/PM.

+
+
♻️
Soft delete
Verwijderen markeert alleen; data blijft staan. Niets gaat echt verloren — belangrijk voor zorgdossiers en herstel.
+
🌙
Shift-logica
Notities vóór 07:00 horen bij de dienst van de vórige dag. Zorgt dat nachtdiensten correct in de overdracht vallen.
+
✅
Overdrachtsfilter
Alleen notities met "meenemen in overdracht" verschijnen in de samenvatting. De zorgverlener bepaalt wat relevant is.
+
🔒
Row Level Security (RLS)
De database dwingt af wie welke gegevens mag zien — fundament voor privacy/AVG. In deze fase nog ruim ingesteld.
+
🧠
AI-herkomst
Bij AI-gegenereerde inhoud worden zekerheid en redenering bewaard — transparant en controleerbaar.
+
+
+ + +
+

9Aandachtspunten & status (eerlijk beeld)

+
+
⚠️
Prototype-status
Geen productiesysteem. Beveiligingsregels (RLS) zijn nog ruim; verfijning per team/organisatie is nog niet gebouwd.
+
⚠️
Twee-sporen datamodel
Naast het nieuwe FHIR-model bestaat nog een ouder model. Het nieuwe is leidend; het oude is nog niet opgeruimd — technische schuld om te bewaken.
+
⚠️
Externe AI-kosten
Schaalbaarheid van Cortex hangt samen met de gebruikskosten van Claude en Deepgram.
+
⚠️
Nog geen echte interoperabiliteit
Het model is FHIR-geïnspireerd; volledige FHIR-uitwisseling met externe systemen is nog niet geïmplementeerd.
+
+
+ +
Bron: codebase mini-epd-prototype · modules in app/ · logica in app/api/ · Cortex in lib/cortex/ · datamodel in supabase/migrations/
+ +
+ + diff --git a/docs/architecture/overzicht-po-pm.md b/docs/architecture/overzicht-po-pm.md new file mode 100644 index 0000000..de5e6f4 --- /dev/null +++ b/docs/architecture/overzicht-po-pm.md @@ -0,0 +1,170 @@ +# Mini-EPD — Architectuur & Datacomponenten (PO/PM-overzicht) + +> Doel van dit document: één begrijpelijk overzicht van **wat het systeem doet**, **uit welke bouwblokken het bestaat** en **welke gegevens het beheert** — zonder dat je code hoeft te lezen. Bedoeld voor product owners en project managers. + +--- + +## 1. In één alinea + +Het Mini-EPD is een **elektronisch patiëntdossier voor de GGZ**. Een zorgverlener kan patiënten aanmelden, intake doen, behandelplannen maken, dagelijkse rapportages schrijven en diensten overdragen aan een collega. Het bijzondere is de **Cortex AI Command Center**: een natuurlijke-taal-interface (typen of inspreken) waarmee de zorgverlener acties uitvoert in gewone zinnen, zoals *"maak een notitie voor Jan: medicatie ingenomen"* of *"plan een afspraak morgen om 14:00"*. + +--- + +## 2. De drie lagen van het systeem + +``` +┌──────────────────────────────────────────────────────────────┐ +│ 1. WAT DE GEBRUIKER ZIET (de modules / schermen) │ +│ Dashboard · Patiëntdossier · Intake · Behandelplan · │ +│ Verpleegrapportage · Agenda · Cortex AI Command Center │ +├──────────────────────────────────────────────────────────────┤ +│ 2. DE LOGICA (de API's / verwerking) │ +│ Rapportage · Overdracht · Behandelplan · Intake · │ +│ Cortex (intentherkenning + chat) · Spraak-naar-tekst │ +├──────────────────────────────────────────────────────────────┤ +│ 3. DE GEGEVENS (de database + externe diensten) │ +│ Supabase database · Claude AI · Deepgram (spraak) │ +└──────────────────────────────────────────────────────────────┘ +``` + +--- + +## 3. De modules (wat de gebruiker ziet) + +| Module | Wat de zorgverlener ermee doet | +|---|---| +| **Dashboard** | Startscherm met het Cortex AI Command Center. Hier begint elke actie. | +| **Patiëntdossier** | Volledig dossier per patiënt: basisgegevens (incl. BSN), diagnoses, observaties, intakes. | +| **Intake** | Stapsgewijze intakeprocedure voor een nieuwe patiënt: contactpersonen, risicotaxatie, anamnese, onderzoek, diagnose, behandeladvies. | +| **Behandelplan** | Behandeldoelen en interventies per leefgebied vastleggen en beheren. | +| **Verpleegrapportage** | Dagelijkse notities in een tijdlijn (nacht/ochtend/middag/avond) + **overdracht** met AI-samenvatting voor de collega van de volgende dienst. | +| **Agenda** | Kalender met alle afspraken; afspraken inplannen, verzetten of annuleren. | + +--- + +## 4. Het hart: Cortex AI Command Center + +De zorgverlener typt of spreekt een opdracht in. Het systeem begrijpt de bedoeling ("intent") en voert de juiste actie uit. Dit gebeurt in **drie slimme lagen** die samen snelheid én begrip combineren: + +``` +Gebruiker zegt/typt iets + │ + ▼ +┌─────────────────────┐ Snel & gratis. Herkent veelvoorkomende +│ 1. REFLEX (lokaal) │ opdrachten direct via patronen (<20ms). +└─────────┬───────────┘ Twijfel of complex? → door naar laag 2. + │ + ▼ +┌─────────────────────┐ AI (Claude) lost lastige gevallen op: +│ 2. ORCHESTRATOR (AI)│ meerdere opdrachten tegelijk, "hem/haar", +└─────────┬───────────┘ "morgen", onduidelijke zinnen. + │ + ▼ + Actie wordt uitgevoerd (notitie opgeslagen, afspraak gemaakt...) + │ + ▼ +┌─────────────────────┐ Proactieve suggestie achteraf, bijv. +│ 3. NUDGE │ "Wil je hier ook een observatie bij maken?" +└─────────────────────┘ +``` + +**Waarom drie lagen?** De Reflex-laag handelt het gros af zonder AI-kosten en zonder vertraging. Alleen echt lastige zinnen gaan naar de (betaalde, iets tragere) AI. De Nudge-laag verhoogt de zorgkwaliteit door op het juiste moment iets te suggereren. + +**Wat begrijpt Cortex (de "intents"):** +- Dagnotitie maken · Patiënt zoeken · Overdracht bekijken +- Agenda opvragen · Afspraak inplannen / annuleren / verzetten + +**Chat & artifacts:** Het scherm is gesplitst — links een **chatpaneel** (gesprek met de assistent), rechts een **werkblok** ("artifact") dat past bij de opdracht: een notitieformulier, een overdrachtssamenvatting, een zoekresultaat, enzovoort. + +--- + +## 5. De externe diensten (afhankelijkheden) + +| Dienst | Waarvoor | Belang voor het product | +|---|---|---| +| **Supabase** | Database + inloggen (authenticatie) | De plek waar alle patiëntgegevens veilig staan. | +| **Claude (Anthropic)** | AI: intentherkenning, chat, overdrachtssamenvatting, behandelplan genereren | De "intelligentie" achter Cortex en de samenvattingen. | +| **Deepgram** | Spraak omzetten naar tekst | Maakt inspreken van notities mogelijk. | + +> **Aandachtspunt PO/PM:** Claude en Deepgram zijn betaalde externe API's. Gebruik = kosten. Cortex is bewust zo ontworpen dat de goedkope lokale laag het meeste afvangt. + +--- + +## 6. De gegevens (datacomponenten) + +Het datamodel is **FHIR-geïnspireerd**. FHIR is de internationale standaard voor gestructureerde zorggegevens. "Geïnspireerd" betekent: we volgen de standaard waar het helpt voor uitwisselbaarheid met andere systemen (denk ICD-10/DSM-5 diagnosecodes, BIG/AGB-nummers), maar pragmatisch vereenvoudigd waar dat sneller bouwt. + +### De kerngegevens en hoe ze samenhangen + +``` + ┌──────────────┐ + │ PATIËNT │ (naam, BSN, geboortedatum, status) + └──────┬───────┘ + ┌──────────────┬───────┼───────────┬──────────────┐ + ▼ ▼ ▼ ▼ ▼ + ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ + │SCREENING │ │ INTAKE │ │ DIAGNOSE │ │OBSERVATIE│ │BEHANDEL- │ + │(aanmeld) │ │(+ risico,│ │(condition)│ │(meting) │ │ PLAN │ + │ │ │ anamnese,│ │ │ │ │ │(doelen, │ + │ │ │ onderzoek)│ │ │ │ │ │interventies)│ + └──────────┘ └────┬─────┘ └──────────┘ └──────────┘ └──────────┘ + │ + ▼ + ┌──────────────┐ + │ CONTACTMOMENT │ (encounter: intake-gesprek, sessie) + └──────┬───────┘ + ▼ + ┌──────────────┐ + │ RAPPORTAGE │ (dagnotities: voortgang, observatie, + │ (reports) │ incident, medicatie, verpleegkundig...) + └──────────────┘ +``` + +### Wat elk gegevenstype bevat + +| Gegevenstype | Wat het is | +|---|---| +| **Patiënt** | De persoon in zorg: naam, BSN, geboortedatum, en een **status** (aangemeld → in zorg → afgerond / afgemeld). | +| **Behandelaar** | De zorgprofessional, met BIG- en AGB-nummer; gekoppeld aan het inlogaccount. | +| **Organisatie** | De GGZ-instelling. | +| **Screening** | Het aanmeldproces: hulpvraag, activiteitenlog, documenten (verwijsbrieven), en het besluit (geschikt / niet geschikt). | +| **Intake** | De intakesessie met onderliggende onderdelen: **anamnese**, **onderzoeken** en **risicotaxaties** (bv. suïcide-/agressierisico met niveau laag→zeer hoog). | +| **Diagnose** (condition) | DSM-5/ICD-10 diagnoses met status. | +| **Observatie** | Metingen en inschattingen (vitale waarden, ROM-scores, klachten). | +| **Behandelplan** | Doelen en interventies, gekoppeld aan diagnoses. | +| **Contactmoment** (encounter) | Een afspraak of sessie tussen patiënt en behandelaar (voedt ook de agenda). | +| **Rapportage** (reports) | Eén centrale tabel voor álle dagnotities, met een **type** (voortgang, observatie, incident, medicatie, contact, crisis, verpleegkundig, ...) en een **categorie** (medicatie, ADL, gedrag, incident, observatie). | + +### De patiëntreis door de data + +``` +Aangemeld → Screening → Intake → In zorg → Overdracht +(status: (besluit: (anamnese, (diagnoses, (samenvatting + planned) geschikt?) risico, behandelplan, voor volgende + onderzoek) dagrapportages) dienst) +``` + +--- + +## 7. Belangrijke regels in de data (voor PO/PM goed om te weten) + +| Regel | Wat het betekent | Waarom relevant | +|---|---|---| +| **Soft delete** | Verwijderen markeert alleen ("deleted_at"), de data blijft staan. | Niets gaat echt verloren — belangrijk voor zorgdossiers en herstel. | +| **Shift-logica** | Notities vóór 07:00 horen bij de dienst van de vórige dag. | Zorgt dat nachtdiensten correct in de overdracht vallen. | +| **Overdrachtsfilter** | Alleen notities met "meenemen in overdracht" verschijnen in de samenvatting. | De zorgverlener bepaalt wat relevant is voor de collega. | +| **Row Level Security (RLS)** | De database dwingt af wie welke gegevens mag zien. | Privacy/AVG-fundament. *Let op: in deze prototypefase nog ruim ingesteld — verfijning per team/organisatie staat nog open.* | +| **AI-herkomst** | Bij AI-gegenereerde inhoud wordt zekerheid en redenering bewaard. | Transparantie/controleerbaarheid van AI-output. | + +--- + +## 8. Aandachtspunten & status (eerlijk beeld) + +- **Prototype-status:** Dit is een prototype, geen productiesysteem. De beveiligingsregels (RLS) zijn nog ruim; verfijning per team/organisatie is nog niet gebouwd. +- **Twee-sporen datamodel:** Er bestaat nog een oudere ("clients/treatment_plans") naast de nieuwe FHIR-structuur ("patients/care_plans"). Het nieuwe spoor is leidend; het oude is nog niet volledig opgeruimd. Dit is technische schuld om in de gaten te houden. +- **Externe AI-kosten:** Schaalbaarheid van Cortex/AI hangt samen met gebruikskosten van Claude en Deepgram. +- **Geen echte interoperabiliteit (nog):** Het model is FHIR-*geïnspireerd*; volledige FHIR-uitwisseling met externe systemen is nog niet geïmplementeerd. + +--- + +*Bronnen: codebase mini-epd-prototype (modules in `app/`, logica in `app/api/`, Cortex in `lib/cortex/`, datamodel in `supabase/migrations/`).* diff --git a/docs/architecture/platform-connectiviteit-selfhosted.md b/docs/architecture/platform-connectiviteit-selfhosted.md new file mode 100644 index 0000000..d5886fd --- /dev/null +++ b/docs/architecture/platform-connectiviteit-selfhosted.md @@ -0,0 +1,1175 @@ +# Platform Architectuur — Self-Hosted, Connectiviteit & Deployment Modellen + +> **Type**: Architectuur Referentiedocument +> **Versie**: 1.0 +> **Datum**: 2026-02-14 +> **Doelgroep**: LLM-agents, developers, architecten, CTO's +> **Taal**: Nederlands (tekst), Engels (technische termen en code) +> **Relatie**: Uitbreiding op `enterprise-epd-architectuur.md` — beschrijft self-hosted stack, connectiviteitslaag en deployment modellen + +--- + +## Leeswijzer + +Dit document adresseert drie architectuurwijzigingen ten opzichte van het enterprise-EPD-document: + +1. **Self-hosted stack** — Supabase, Supabase Auth en Vercel worden vervangen door self-hosted alternatieven +2. **Connectiviteitslaag** — Het intent-systeem + Knowledge Layer worden ontkoppeld van het EPD en kunnen als onafhankelijke service draaien +3. **Deployment modellen** — Drie manieren om het systeem in te zetten: standalone, als laag bovenop bestaand EPD, of hybrid + +De kernbeslissing die dit document beschrijft: het intent-systeem en de Knowledge Layer zijn **geen onderdeel van het EPD** — ze zijn een **platform** dat met elk EPD kan communiceren via een gestandaardiseerde connectiviteitslaag. + +--- + +## 1. Architectuurwijziging: van Monoliet naar Platform + +### 1.1 Waarom dit ertoe doet + +De Nederlandse GGZ-markt heeft bestaande EPD-systemen: HiX (Chipsoft), Nexus (Nexus), User (Gerimedica), Epic, etc. Een nieuw EPD bouwen dat deze vervangt is een multi-jaar, multi-miljoen traject met enorme weerstand. + +Maar: het **intent-systeem + Knowledge Layer** kan als losse laag bovenop elk EPD draaien. Dat opent twee markten: + +- **Markt A**: Instellingen die een nieuw EPD willen → volledig platform (eigen EPD + intent + knowledge) +- **Markt B**: Instellingen die hun bestaande EPD houden → intent + knowledge als add-on laag + +Dit verandert de architectuur fundamenteel: + +``` +VOORHEEN (monoliet): +┌─────────────────────────────────┐ +│ Intent + Knowledge + EPD │ ← Eén systeem, alles gekoppeld +│ Alles in één Next.js app │ +└─────────────────────────────────┘ + +NU (platform): +┌─────────────────────────────────┐ +│ INTENT PLATFORM │ ← Onafhankelijke service +│ Intent Systeem + Knowledge Layer│ +│ Eigen API, eigen database │ +└──────────────┬──────────────────┘ + │ Connector API (gestandaardiseerd) + │ + ┌──────────┼──────────┐ + ▼ ▼ ▼ +┌────────┐ ┌────────┐ ┌────────┐ +│Eigen EPD│ │ HiX │ │ Nexus │ ← Elk EPD via connector +│(Next.js)│ │(Chipsoft)│ │ │ +└────────┘ └────────┘ └────────┘ +``` + +### 1.2 Drie deployment modellen + +| Model | Beschrijving | Doelgroep | +|-------|-------------|-----------| +| **Standalone** | Volledig platform: eigen EPD + intent + knowledge | Nieuwe instellingen, kleine GGZ | +| **Add-on** | Intent + knowledge als laag bovenop bestaand EPD | HiX/Nexus klanten | +| **Hybrid** | Eigen EPD voor specifieke modules + koppeling met bestaand EPD | Instellingen in transitie | + +--- + +## 2. Platform Architectuur + +### 2.1 Twee onafhankelijke services + +Het systeem bestaat uit twee deploybare units die onafhankelijk van elkaar kunnen draaien: + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ INTENT PLATFORM SERVICE │ +│ │ +│ ┌───────────────────────────────────────────────────────────┐ │ +│ │ Intent Engine │ │ +│ │ ├── Intent Registry (definities) │ │ +│ │ ├── Reflex Classifier (lokale patronen) │ │ +│ │ ├── Orchestrator (LLM classificatie) │ │ +│ │ ├── Entity Resolution (fuzzy matching) │ │ +│ │ └── Action Resolver (intent → actie-instructie) │ │ +│ └───────────────────────────────────────────────────────────┘ │ +│ ┌───────────────────────────────────────────────────────────┐ │ +│ │ Knowledge Layer │ │ +│ │ ├── Protocol Rules Store (gevalideerde regels) │ │ +│ │ ├── RAG Pipeline (pgvector, protocol indexering) │ │ +│ │ ├── Nudge Evaluator (protocol → suggesties) │ │ +│ │ └── Kennisbron Management (importers, validatie UI) │ │ +│ └───────────────────────────────────────────────────────────┘ │ +│ ┌───────────────────────────────────────────────────────────┐ │ +│ │ Connector API (gestandaardiseerd) │ │ +│ │ ├── EPD Adapter Interface (abstract) │ │ +│ │ ├── Patient Data Connector (lezen uit EPD) │ │ +│ │ ├── Action Dispatcher (schrijven naar EPD) │ │ +│ │ └── Event Listener (ontvangen van EPD events) │ │ +│ └───────────────────────────────────────────────────────────┘ │ +│ │ +│ Eigen database: PostgreSQL (intent logs, protocol rules, │ +│ knowledge vectors, configuratie) │ +└─────────────────────────────────────────────────────────────────┘ + │ + Connector API (REST + Webhooks) + │ +┌─────────────────────────────┼───────────────────────────────────┐ +│ EPD SERVICE (optioneel eigen EPD) │ +│ │ +│ ├── Patiënt management │ +│ ├── Rapportage (CRUD, versioning) │ +│ ├── Behandelplan │ +│ ├── Agenda │ +│ ├── Medicatie │ +│ └── Traditionele UI (formulieren, lijsten) │ +│ │ +│ Eigen database: PostgreSQL (patiëntdata, rapportages, etc.) │ +└─────────────────────────────────────────────────────────────────┘ +``` + +### 2.2 Waarom twee services, niet één? + +| Reden | Toelichting | +|-------|-------------| +| **Onafhankelijke deployment** | Intent platform kan geüpdatet worden zonder EPD downtime | +| **Meerdere EPD's bedienen** | Eén intent platform kan meerdere EPD-koppelingen hebben | +| **Verschillende eigenaren** | Intent platform = jouw product. EPD = kan van een ander zijn | +| **Schaalverschil** | Intent platform (AI, vectorDB) schaalt anders dan EPD (CRUD, rapportage) | +| **Licentiemodel** | Intent platform als SaaS/licentie, EPD als optionele module | + +### 2.3 Communicatie tussen services + +```typescript +// De Intent Platform communiceert met elk EPD via een Connector API. +// Elke EPD-koppeling implementeert dezelfde interface. + +// === CONNECTOR API INTERFACE === + +interface EPDConnector { + // --- Lezen uit EPD --- + getPatient(patientId: string): Promise; + searchPatients(query: string): Promise; + getRecentReports(patientId: string, since: Date): Promise; + getAppointments(userId: string, dateRange: DateRange): Promise; + getActiveMedication(patientId: string): Promise; + getTreatmentPlan(patientId: string): Promise; + getLegalStatus(patientId: string): Promise; + + // --- Schrijven naar EPD --- + createReport(data: CreateReportRequest): Promise; + createAppointment(data: CreateAppointmentRequest): Promise; + updateAppointment(id: string, data: UpdateAppointmentRequest): Promise; + cancelAppointment(id: string, reason: string): Promise; + + // --- Events ontvangen van EPD --- + onPatientAdmitted(callback: (event: PatientEvent) => void): void; + onReportCreated(callback: (event: ReportEvent) => void): void; + onShiftChange(callback: (event: ShiftEvent) => void): void; + + // --- Metadata --- + getCapabilities(): ConnectorCapabilities; + getVersion(): string; +} + +// Elke EPD-koppeling implementeert deze interface: +// - OwnEPDConnector: voor het eigen EPD (directe database calls) +// - HiXConnector: voor Chipsoft HiX (via HiX API/HL7) +// - NexusConnector: voor Nexus (via Nexus API) +// - FHIRConnector: voor elk FHIR-compatible systeem + +// === DATA TYPES (EPD-agnostisch) === + +interface PatientSummary { + id: string; // EPD-specifiek ID + externalId?: string; // BSN hash of ander extern ID + displayName: string; // Weergavenaam + dateOfBirth?: string; // ISO date + gender?: 'male' | 'female' | 'other' | 'unknown'; + department?: string; // Afdeling + legalStatus?: LegalStatus; // Wvggz status + activeFlags?: string[]; // 'risico_suïcide', 'valrisico', etc. +} + +interface ReportSummary { + id: string; + patientId: string; + authorName: string; + reportType: string; // 'voortgang', 'observatie', etc. + category?: string; // 'medicatie', 'adl', 'gedrag' + content: string; // Platte tekst (max 10.000 chars) + createdAt: string; // ISO datetime + shiftDate: string; // ISO date + includeInHandover: boolean; + metadata?: Record; // EPD-specifieke extra data +} + +interface ConnectorCapabilities { + canRead: string[]; // ['patient', 'report', 'appointment', 'medication'] + canWrite: string[]; // ['report', 'appointment'] + canSubscribe: string[]; // ['patient_admitted', 'report_created'] + supportsRealtime: boolean; + supportsFHIR: boolean; + maxBatchSize: number; +} +``` + +### 2.4 Connector implementaties + +```typescript +// === EIGEN EPD CONNECTOR (directe database) === +// connectors/own-epd-connector.ts + +import { db } from '@/lib/db'; +import { patients, reports, appointments } from '@/schema'; + +export class OwnEPDConnector implements EPDConnector { + constructor(private tenantId: string) {} + + async getPatient(patientId: string): Promise { + const patient = await db + .select() + .from(patients) + .where(and( + eq(patients.id, patientId), + eq(patients.tenantId, this.tenantId) + )) + .limit(1); + + return mapToPatientSummary(patient[0]); + } + + async searchPatients(query: string): Promise { + const results = await db + .select() + .from(patients) + .where(and( + eq(patients.tenantId, this.tenantId), + ilike(patients.fullName, `%${query}%`) + )) + .limit(20); + + return results.map(mapToPatientSummary); + } + + async createReport(data: CreateReportRequest): Promise { + const report = await db.insert(reports).values({ + tenantId: this.tenantId, + patientId: data.patientId, + authorId: data.authorId, + reportType: data.reportType, + content: data.content, + structuredData: data.structuredData, + shiftDate: calculateShiftDate(new Date()), + }).returning(); + + return { id: report[0].id, success: true }; + } + + // ... overige methoden +} + +// === HIX CONNECTOR (Chipsoft API) === +// connectors/hix-connector.ts + +export class HiXConnector implements EPDConnector { + constructor( + private baseUrl: string, // HiX API endpoint + private apiKey: string, // HiX API key + private organizationId: string // HiX organisatie + ) {} + + async getPatient(patientId: string): Promise { + // HiX gebruikt HL7 FHIR R4 API + const response = await fetch( + `${this.baseUrl}/fhir/Patient/${patientId}`, + { headers: { 'Authorization': `Bearer ${this.apiKey}` } } + ); + const fhirPatient = await response.json(); + return mapFHIRToPatientSummary(fhirPatient); + } + + async createReport(data: CreateReportRequest): Promise { + // HiX: create via DocumentReference FHIR resource + const fhirDoc = mapToFHIRDocumentReference(data); + const response = await fetch( + `${this.baseUrl}/fhir/DocumentReference`, + { + method: 'POST', + headers: { + 'Authorization': `Bearer ${this.apiKey}`, + 'Content-Type': 'application/fhir+json', + }, + body: JSON.stringify(fhirDoc), + } + ); + const result = await response.json(); + return { id: result.id, success: response.ok }; + } + + getCapabilities(): ConnectorCapabilities { + return { + canRead: ['patient', 'report', 'appointment', 'medication'], + canWrite: ['report'], // HiX beperkt schrijftoegang + canSubscribe: [], // HiX heeft geen realtime events + supportsRealtime: false, + supportsFHIR: true, + maxBatchSize: 100, + }; + } +} + +// === GENERIC FHIR CONNECTOR === +// connectors/fhir-connector.ts + +export class FHIRConnector implements EPDConnector { + constructor( + private fhirBaseUrl: string, + private authToken: string + ) {} + + // Werkt met elk FHIR R4 compatible systeem + // Epic, Cerner, open-source FHIR servers, etc. + + async getPatient(patientId: string): Promise { + const response = await fetch( + `${this.fhirBaseUrl}/Patient/${patientId}`, + { headers: { 'Authorization': `Bearer ${this.authToken}` } } + ); + return mapFHIRToPatientSummary(await response.json()); + } + + // ... +} +``` + +### 2.5 Intent Platform API + +Het intent platform biedt zelf een API aan die door elke frontend (eigen UI, embedded widget, of CLI) kan worden aangesproken: + +```typescript +// === INTENT PLATFORM REST API === + +// POST /api/platform/classify +// Classificeer tekst naar intent + entities +// Input: { text: string, context?: { patientId?, userId? } } +// Output: { intent, entities, confidence, suggestedAction } + +// POST /api/platform/chat +// Streaming chat met intent-aware context +// Input: { message: string, context?, history? } +// Output: SSE stream met tekst + actionBlocks + +// POST /api/platform/transcribe +// Spraak naar tekst +// Input: audio blob +// Output: { transcript, confidence } + +// GET /api/platform/nudges +// Haal actieve nudges op voor context +// Input: { patientId, lastAction? } +// Output: { nudges: NudgeSuggestion[] } + +// POST /api/platform/nudges/:id/accept +// Markeer nudge als geaccepteerd +// Input: { nudgeId } +// Output: { suggestedAction } + +// GET /api/platform/protocols +// Beheer protocol rules (admin) + +// POST /api/platform/protocols +// Voeg protocol rule toe (admin, validated) + +// GET /api/platform/health +// Health check + +// GET /api/platform/capabilities +// Wat kan dit platform? Welke intents, welke connectors? +``` + +--- + +## 3. Self-Hosted Technologie Stack + +### 3.1 Gewijzigde stack + +Componenten die wijzigen ten opzichte van het enterprise-EPD-document: + +| Was (managed) | Wordt (self-hosted) | Waarom | +|---------------|--------------------:|--------| +| **Supabase PostgreSQL** | PostgreSQL 16 (Docker) | Volledige controle, data residency NL | +| **Supabase Auth** | Keycloak | Enterprise SSO/SAML, MFA, NEN 7510 | +| **Supabase Realtime** | PostgreSQL LISTEN/NOTIFY + WebSockets | Geen externe dependency | +| **Supabase Storage** | Lokaal filesystem of Garage (S3-compatible) | Eenvoud, encryptie | +| **PostgREST (Supabase)** | Drizzle ORM | Type-safe, 2MB footprint, RLS-compatible | +| **Vercel** | Hetzner VPS + Coolify | EU data residency, €15-25/maand | +| — (nieuw) | Caddy | Reverse proxy, automatische HTTPS | +| — (nieuw) | Redis + BullMQ | Job queue voor AI taken, notificaties | +| — (nieuw) | Postal | Self-hosted email voor notificaties | + +### 3.2 Stack per service + +``` +INTENT PLATFORM SERVICE: +├── Runtime: Node.js 20 (Docker) +├── Framework: Next.js 14 of standalone Express/Fastify +├── Database: PostgreSQL 16 (pgvector, pgcrypto, pg_trgm) +├── ORM: Drizzle +├── Auth: Keycloak (OIDC) → Auth.js in Next.js +├── AI: Anthropic Claude API (extern) +├── Spraak: Deepgram API (extern) +├── Vector store: pgvector (in PostgreSQL) +├── Job queue: BullMQ + Redis +├── Logging: Pino (structured JSON) +└── Reverse proxy: Caddy (HTTPS, routing) + +EPD SERVICE (optioneel): +├── Runtime: Node.js 20 (Docker) +├── Framework: Next.js 14 (App Router) +├── Database: PostgreSQL 16 (eigen instance of shared) +├── ORM: Drizzle +├── Auth: Keycloak (gedeeld met platform) +├── UI: Tailwind + shadcn/ui +├── State: Zustand +├── Validatie: Zod +└── Icons: Lucide React +``` + +### 3.3 Waarom Keycloak voor auth + +| Requirement | Keycloak biedt | +|------------|----------------| +| SSO/SAML voor GGZ-instellingen | Native SAML 2.0 + OIDC | +| Azure AD federatie (standaard bij GGZ) | Identity Provider federation | +| MFA (NEN 7510 eis) | TOTP, WebAuthn, SMS | +| Rolbeheer | Realm roles + client roles | +| Multi-tenancy | Eén realm per instelling, of één realm met groups | +| Audit logging | Alle auth events gelogd | +| Session management | Configureerbare timeout (standaard 15 min) | +| Self-hosted | Docker image, PostgreSQL backend | + +**Integratie met Next.js:** + +```typescript +// auth.ts — Auth.js v5 met Keycloak +import NextAuth from 'next-auth'; +import KeycloakProvider from 'next-auth/providers/keycloak'; + +export const { handlers, auth, signIn, signOut } = NextAuth({ + providers: [ + KeycloakProvider({ + clientId: process.env.KEYCLOAK_CLIENT_ID!, + clientSecret: process.env.KEYCLOAK_CLIENT_SECRET!, + issuer: process.env.KEYCLOAK_ISSUER_URL!, // https://auth.jouwdomein.nl/realms/zorg + }), + ], + callbacks: { + async jwt({ token, account }) { + if (account?.access_token) { + const decoded = jwtDecode(account.access_token); + token.roles = decoded.realm_access?.roles ?? []; + token.tenantId = decoded.tenant_id; + token.organizationName = decoded.organization_name; + } + return token; + }, + async session({ session, token }) { + session.user.roles = token.roles as string[]; + session.user.tenantId = token.tenantId as string; + return session; + }, + }, +}); + +// Middleware: bescherm alle /epd/* en /api/* routes +export { auth as middleware } from './auth'; +export const config = { matcher: ['/epd/:path*', '/api/:path*'] }; +``` + +**Azure AD federatie (typisch voor GGZ-instellingen):** + +``` +Stap 1: Keycloak als Identity Broker + → Instelling A heeft Azure AD + → Configureer Azure AD als Identity Provider in Keycloak + → Keycloak federeert login naar Azure AD + → Gebruiker logt in met instellings-credentials + +Stap 2: Role mapping + → Azure AD group "Verpleegkundigen" → Keycloak role "verpleegkundige" + → Azure AD group "Artsen" → Keycloak role "arts" + → Keycloak role → PostgreSQL RLS via app.user_role setting + +Stap 3: Multi-instelling + → Instelling A: Azure AD federation in Keycloak realm "instelling-a" + → Instelling B: ADFS federation in Keycloak realm "instelling-b" + → Elke realm heeft eigen rollen en configuratie +``` + +### 3.4 Waarom Drizzle ORM (vervangt PostgREST) + +```typescript +// lib/db.ts — Database connectie met Drizzle +import { drizzle } from 'drizzle-orm/node-postgres'; +import { Pool } from 'pg'; +import * as schema from './schema'; + +const pool = new Pool({ + connectionString: process.env.DATABASE_URL, + max: 20, + idleTimeoutMillis: 30000, +}); + +export const db = drizzle(pool, { schema }); + +// RLS context instellen per request +export async function withTenantContext(tenantId: string, userId: string, fn: () => Promise) { + const client = await pool.connect(); + try { + await client.query(`SET app.current_tenant_id = '${tenantId}'`); + await client.query(`SET app.current_user_id = '${userId}'`); + return await fn(); + } finally { + // Reset settings + await client.query('RESET app.current_tenant_id'); + await client.query('RESET app.current_user_id'); + client.release(); + } +} +``` + +**Waarom Drizzle boven Prisma:** + +| Aspect | Drizzle | Prisma | +|--------|---------|--------| +| Bundle size | ~2 MB | ~15 MB | +| RLS support | Directe pg queries, RLS werkt | Prisma Client omzeilt soms RLS | +| Migraties | SQL-first, volledige controle | Schema-first, soms drift | +| Connection pooling | Eigen Pool (pg) | PgBouncer of Prisma Accelerate (managed) | +| Self-hosted | Zero dependencies | Prisma engine binary nodig | + +### 3.5 Hosting: Hetzner + Coolify + +``` +┌─────────────────────────────────────────────────────────────┐ +│ HETZNER VPS — Amsterdam (€15-25/mnd) │ +│ Ubuntu 22.04, 4 vCPU, 8GB RAM, 160GB NVMe │ +│ │ +│ ┌────────────────────────────────────────────────────────┐ │ +│ │ Coolify (deployment platform) │ │ +│ │ ├── Auto-deploy from GitHub │ │ +│ │ ├── Docker Compose orchestratie │ │ +│ │ ├── Let's Encrypt SSL automatisch │ │ +│ │ └── Health monitoring │ │ +│ └────────────────────────────────────────────────────────┘ │ +│ │ +│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ +│ │ Caddy │ │ Intent │ │ EPD │ │ Keycloak │ │ +│ │ :443 │──│ Platform │ │ Service │ │ :8080 │ │ +│ │ reverse │ │ :3001 │ │ :3000 │ │ │ │ +│ │ proxy │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ +│ └──────────┘ │ │ │ │ +│ └──────┬──────┴──────────────┘ │ +│ ▼ │ +│ ┌──────────────────────────┐ │ +│ │ PostgreSQL 16 │ │ +│ │ ├── epd_db (patiëntdata) │ │ +│ │ ├── platform_db (intents)│ │ +│ │ └── keycloak_db (auth) │ │ +│ │ :5432 │ │ +│ └──────────────────────────┘ │ +│ │ +│ ┌──────────┐ ┌──────────┐ │ +│ │ Redis │ │ Postal │ │ +│ │ :6379 │ │ email │ │ +│ │ (BullMQ) │ │ :25 │ │ +│ └──────────┘ └──────────┘ │ +│ │ +│ Storage: /data/files/ (encrypted, NFS mount of lokaal) │ +└─────────────────────────────────────────────────────────────┘ +``` + +**Docker Compose (productie):** + +```yaml +# docker-compose.yml +version: '3.8' + +services: + # Reverse proxy + caddy: + image: caddy:2-alpine + ports: + - "80:80" + - "443:443" + volumes: + - ./Caddyfile:/etc/caddy/Caddyfile + - caddy_data:/data + restart: always + + # Intent Platform + intent-platform: + build: + context: ./intent-platform + dockerfile: Dockerfile + environment: + DATABASE_URL: postgresql://platform:${DB_PASS}@postgres:5432/platform_db + KEYCLOAK_ISSUER_URL: https://auth.${DOMAIN}/realms/zorg + ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY} + DEEPGRAM_API_KEY: ${DEEPGRAM_API_KEY} + REDIS_URL: redis://redis:6379 + depends_on: + - postgres + - redis + restart: always + + # EPD Service (optioneel, alleen bij standalone deployment) + epd-service: + build: + context: ./epd-service + dockerfile: Dockerfile + environment: + DATABASE_URL: postgresql://epd:${DB_PASS}@postgres:5432/epd_db + KEYCLOAK_ISSUER_URL: https://auth.${DOMAIN}/realms/zorg + INTENT_PLATFORM_URL: http://intent-platform:3001 + depends_on: + - postgres + - intent-platform + restart: always + + # PostgreSQL + postgres: + image: postgres:16-alpine + environment: + POSTGRES_PASSWORD: ${DB_PASS} + volumes: + - postgres_data:/var/lib/postgresql/data + - ./init-db.sql:/docker-entrypoint-initdb.d/init.sql + restart: always + + # Keycloak + keycloak: + image: quay.io/keycloak/keycloak:24.0 + command: start + environment: + KC_DB: postgres + KC_DB_URL: jdbc:postgresql://postgres:5432/keycloak_db + KC_DB_USERNAME: keycloak + KC_DB_PASSWORD: ${DB_PASS} + KC_HOSTNAME: auth.${DOMAIN} + KC_PROXY_HEADERS: xforwarded + depends_on: + - postgres + restart: always + + # Redis (job queue) + redis: + image: redis:7-alpine + volumes: + - redis_data:/data + restart: always + + # Postal (email, optioneel) + postal: + image: postalserver/postal:latest + environment: + POSTAL_ADMIN_TOKEN: ${POSTAL_TOKEN} + volumes: + - postal_data:/opt/postal/app/file_store + restart: always + +volumes: + postgres_data: + redis_data: + caddy_data: + postal_data: +``` + +**Caddyfile:** + +```caddyfile +# Caddyfile +{DOMAIN} { + reverse_proxy epd-service:3000 +} + +platform.{DOMAIN} { + reverse_proxy intent-platform:3001 +} + +auth.{DOMAIN} { + reverse_proxy keycloak:8080 +} +``` + +### 3.6 Kosten vergelijking + +| Component | Managed (Supabase + Vercel) | Self-hosted (Hetzner) | +|-----------|---------------------------:|----------------------:| +| Database | €25/mnd (Supabase Pro) | €0 (in VPS) | +| Hosting | €20/mnd (Vercel Pro) | €15-25/mnd (Hetzner VPS) | +| Auth | €0 (Supabase incl.) | €0 (Keycloak) | +| Email | €10/mnd (Postmark) | €0 (Postal) | +| Job queue | €25/mnd (extern) | €0 (Redis in VPS) | +| Backup | €5/mnd | €3/mnd (Hetzner snapshots) | +| **Totaal/mnd** | **~€85** | **~€20-30** | +| **Totaal/jaar** | **~€1.020** | **~€250-360** | + +**Trade-off**: Self-hosted is goedkoper maar vereist meer DevOps kennis. Voor een team van 2-5 devs dat toch al compliance moet regelen is dit acceptabel. + +--- + +## 4. Connectiviteitslaag — Detail + +### 4.1 Connector Registry + +Het platform onderhoudt een registry van beschikbare connectors: + +```typescript +// lib/connectors/registry.ts + +interface ConnectorRegistration { + id: string; + name: string; // 'own-epd', 'hix', 'nexus', 'fhir-generic' + type: 'internal' | 'fhir' | 'hl7' | 'custom'; + status: 'active' | 'inactive' | 'error'; + config: ConnectorConfig; + capabilities: ConnectorCapabilities; + lastHealthCheck: Date; + errorCount: number; +} + +interface ConnectorConfig { + baseUrl?: string; // API endpoint van het EPD + authType: 'oauth2' | 'apikey' | 'saml' | 'internal'; + credentials: { + clientId?: string; + clientSecret?: string; // Encrypted opgeslagen + apiKey?: string; // Encrypted opgeslagen + }; + mappings?: { + patientIdField: string; // Hoe het EPD patient IDs noemt + reportTypeMapping: Record; // Onze types → EPD types + }; +} + +// Connector factory +function createConnector(registration: ConnectorRegistration): EPDConnector { + switch (registration.name) { + case 'own-epd': + return new OwnEPDConnector(registration.config); + case 'hix': + return new HiXConnector( + registration.config.baseUrl!, + registration.config.credentials.apiKey!, + registration.config.mappings! + ); + case 'fhir-generic': + return new FHIRConnector( + registration.config.baseUrl!, + registration.config.credentials.apiKey! + ); + default: + throw new Error(`Onbekende connector: ${registration.name}`); + } +} +``` + +### 4.2 Hoe het intent systeem de connector gebruikt + +```typescript +// lib/cortex/action-resolver.ts +// Het Action System gebruikt NIET direct de database, maar de connector + +export class ActionResolver { + constructor(private connector: EPDConnector) {} + + async resolveAction(intent: ClassifiedIntent): Promise { + switch (intent.type) { + case 'dagnotitie': { + // Haal patiënt op via connector (werkt met elk EPD) + const patient = intent.entities.patientName + ? (await this.connector.searchPatients(intent.entities.patientName))[0] + : null; + + return { + type: 'prefill_form', + form: 'dagnotitie', + prefillData: { + patient: patient ? { id: patient.id, name: patient.displayName } : null, + category: intent.entities.category, + content: intent.entities.content, + }, + // Na submit: connector.createReport() aanroepen + submitAction: 'connector.createReport', + }; + } + + case 'overdracht': { + // Haal rapportages op via connector + const patients = await this.connector.searchPatients(''); // Alle actieve patiënten + const summaries = await Promise.all( + patients.map(async p => ({ + patient: p, + reports: await this.connector.getRecentReports(p.id, shiftStart()), + })) + ); + + return { + type: 'render_view', + view: 'overdracht', + data: summaries, + }; + } + + case 'agenda_query': { + const appointments = await this.connector.getAppointments( + intent.context.userId, + intent.entities.dateRange + ); + + return { + type: 'render_view', + view: 'agenda', + data: appointments, + }; + } + } + } +} +``` + +### 4.3 Nudge evaluatie via connector + +```typescript +// lib/cortex/protocol-engine/evaluator.ts +// Protocol Engine haalt patiëntdata op via connector + +export class ProtocolEvaluator { + constructor( + private connector: EPDConnector, + private rulesStore: ProtocolRulesStore + ) {} + + async evaluateAfterAction( + completedAction: CompletedAction, + patientId: string + ): Promise { + + // Haal context op via connector (EPD-agnostisch) + const [patient, recentReports, medication, legalStatus] = await Promise.all([ + this.connector.getPatient(patientId), + this.connector.getRecentReports(patientId, thirtyDaysAgo()), + this.connector.getActiveMedication(patientId), + this.connector.getLegalStatus(patientId), + ]); + + const context: RuleContext = { + patient, + recentReports, + activeMedication: medication, + legalStatus, + completedAction, + }; + + // Evalueer regels tegen context + const rules = await this.rulesStore.getActiveRules({ + afterIntent: completedAction.intent, + }); + + return rules + .filter(rule => this.evaluateCondition(rule.condition, context)) + .map(rule => ({ + ruleId: rule.id, + message: rule.suggestion.message, + priority: rule.suggestion.priority, + evidence: rule.suggestion.evidence, + source: rule.source, + })); + } +} +``` + +### 4.4 Capabilities-based UI + +Omdat niet elk EPD alle functies ondersteunt, past de UI zich aan: + +```typescript +// De frontend vraagt capabilities op en toont alleen wat beschikbaar is + +async function initializeUI() { + const capabilities = await connector.getCapabilities(); + + return { + showCreateReport: capabilities.canWrite.includes('report'), + showCreateAppointment: capabilities.canWrite.includes('appointment'), + showMedication: capabilities.canRead.includes('medication'), + showLiveUpdates: capabilities.supportsRealtime, + // Intent systeem: disable intents die het EPD niet ondersteunt + disabledIntents: getUnsupportedIntents(capabilities), + }; +} + +// Voorbeeld: HiX connector zegt canWrite: ['report'] +// → Create appointment intent wordt uitgeschakeld +// → UI toont melding: "Afspraken aanmaken via HiX" +``` + +--- + +## 5. Deployment Modellen — Detail + +### 5.1 Model A: Standalone (eigen EPD + platform) + +``` +Voor: Nieuwe instellingen, kleine GGZ, pilotprojecten + +┌────────────────────────────────────┐ +│ Hetzner VPS │ +│ │ +│ ┌─────────────┐ ┌──────────────┐ │ +│ │ Intent │ │ Eigen EPD │ │ +│ │ Platform │◄│ Service │ │ +│ │ │ │ (Next.js) │ │ +│ └──────┬──────┘ └──────┬───────┘ │ +│ │ │ │ +│ ┌──────┴───────────────┴──────┐ │ +│ │ PostgreSQL (2 databases) │ │ +│ └─────────────────────────────┘ │ +│ ┌─────────────┐ ┌──────────────┐ │ +│ │ Keycloak │ │ Redis │ │ +│ └─────────────┘ └──────────────┘ │ +└────────────────────────────────────┘ + +Connector: OwnEPDConnector (directe DB calls) +Kosten: €20-30/mnd +Complexiteit: Laag (alles op één machine) +``` + +### 5.2 Model B: Add-on (platform bovenop bestaand EPD) + +``` +Voor: HiX/Nexus klanten die intent-laag willen + +┌────────────────────────┐ ┌────────────────────┐ +│ Hetzner VPS │ │ Bestaand EPD │ +│ │ │ (bijv. HiX) │ +│ ┌──────────────────┐ │ │ │ +│ │ Intent Platform │ │◄───│ FHIR R4 API │ +│ │ + Knowledge Layer │ │ │ of HL7 interface │ +│ └──────┬───────────┘ │ └────────────────────┘ +│ │ │ +│ ┌──────┴──────┐ │ Connector: HiXConnector of FHIRConnector +│ │ PostgreSQL │ │ Platform haalt data OP uit EPD +│ │ (platform DB │ │ Platform stuurt acties NAAR EPD +│ │ alleen) │ │ Platform slaat GEEN patiëntdata op +│ └─────────────┘ │ +│ ┌─────────────┐ │ +│ │ Keycloak │ │ Auth: federeert naar instelling's Azure AD +│ └─────────────┘ │ +└────────────────────────┘ + +Kosten: €15-20/mnd (minder: geen EPD database) +Complexiteit: Medium (connector configuratie) +Vereist: API-toegang tot bestaand EPD +``` + +### 5.3 Model C: Hybrid + +``` +Voor: Instellingen in transitie + +┌────────────────────────────────────────┐ +│ Hetzner VPS │ +│ │ +│ ┌──────────────────┐ │ +│ │ Intent Platform │ │ +│ │ + Knowledge Layer │ │ +│ └──────┬───────────┘ │ +│ │ │ +│ ┌────┴────┐ │ +│ ▼ ▼ │ +│ ┌──────┐ ┌──────────┐ │ +│ │Eigen │ │ HiX │ ← Via connector │ +│ │EPD │ │ Connector│ │ +│ │module │ │ │ │ +│ └──────┘ └──────────┘ │ +│ (bijv. (bestaand EPD │ +│ rapportage voor medicatie, │ +│ + overdracht) behandelplan) │ +└────────────────────────────────────────┘ + +Use case: Instelling gebruikt HiX voor medicatie en behandelplan, +maar wil betere rapportage en overdracht. +→ Eigen rapportage module + intent systeem +→ Patiëntdata komt uit HiX via connector +→ Rapportages worden opgeslagen in eigen DB +→ Overdracht combineert data uit beide bronnen +``` + +--- + +## 6. Impact op Use Cases + +### 6.1 Use case flow met connector + +Het eerder beschreven UC-01 (Dagnotitie aanmaken) werkt nu zo: + +``` +Zorgverlener → "Notitie Jan medicatie onrustige nacht" + │ + ▼ +┌──────────────────┐ +│ Intent Platform │ +│ │ +│ 1. Classify │ Reflex: "notitie" → dagnotitie +│ 2. Extract │ "Jan" → patientName, "medicatie" → category +│ 3. Resolve │ connector.searchPatients("Jan") → Patient #427 +│ 4. Action │ { type: 'prefill_form', form: 'dagnotitie', ... } +│ │ +└────────┬─────────┘ + │ ActionInstruction + ▼ +┌──────────────────┐ +│ Frontend (UI) │ +│ │ +│ Render formulier │ Patient: Jan de Vries ✓ +│ met prefill data │ Categorie: medicatie ✓ +│ │ Content: "onrustige nacht" ✓ +│ [Gebruiker klikt │ +│ "Opslaan"] │ +│ │ +└────────┬─────────┘ + │ CreateReportRequest + ▼ +┌──────────────────┐ +│ Intent Platform │ +│ │ +│ connector │ → OwnEPDConnector.createReport() +│ .createReport() │ OF HiXConnector.createReport() +│ │ OF FHIRConnector.createReport() +│ │ +│ Audit log │ Wie, wat, wanneer, via welke connector +│ │ +│ Protocol Engine │ Evalueer nudges: +│ .evaluate() │ → connector.getRecentReports(Jan) +│ │ → connector.getActiveMedication(Jan) +│ │ → "Check vitale functies?" +└──────────────────┘ +``` + +**Het maakt niet uit welk EPD erachter zit.** De flow is identiek. Alleen de connector implementatie verschilt. + +### 6.2 Welke use cases werken met welk deployment model? + +| Use Case | Standalone (A) | Add-on (B) | Hybrid (C) | +|----------|:--------------:|:----------:|:----------:| +| UC-01 Dagnotitie | ✅ | ✅ (als EPD report-write ondersteunt) | ✅ | +| UC-05 AI Overdracht | ✅ | ✅ (leest rapportages uit EPD) | ✅ | +| UC-07 Patiënt zoeken | ✅ | ✅ (via EPD API) | ✅ | +| UC-10 Afspraak maken | ✅ | ⚠️ (afhankelijk van EPD capabilities) | ✅/⚠️ | +| UC-20 Nudge suggesties | ✅ | ✅ (leest medicatie/rapportages uit EPD) | ✅ | +| UC-21 Behandelplan | ✅ | ❌ (te complex voor connector) | ⚠️ (EPD of eigen) | +| UC-24 Wvggz registratie | ✅ | ❌ (te specifiek) | ⚠️ | +| UC-26 Audit log | ✅ | ✅ (platform eigen audit) | ✅ | +| UC-33 Noodtoegang | ✅ | ⚠️ (EPD-afhankelijk) | ⚠️ | + +**Leeswijzer**: ✅ volledig ondersteund, ⚠️ afhankelijk van EPD capabilities, ❌ niet ondersteund in dit model + +--- + +## 7. Gewijzigde Bouwvolgorde + +Met de platformsplitsing verandert de volgorde: + +``` +FASE 0: INFRASTRUCTUUR (week 1-2) +├── Hetzner VPS opzetten + Coolify +├── Docker Compose met PostgreSQL, Keycloak, Redis, Caddy +├── CI/CD pipeline (GitHub Actions → Coolify) +├── Basis Keycloak configuratie (realm, rollen, test users) +└── Deliverable: draaiende infrastructuur, lege services + +FASE 1: INTENT PLATFORM CORE (week 3-6) +├── Platform database schema (intent logs, protocol rules, connector config) +├── Intent Registry (database-driven) +├── Reflex Classifier + Orchestrator (migratie uit prototype) +├── Entity Resolution (migratie uit prototype) +├── Connector API interface definitie +├── OwnEPDConnector (eerste implementatie) +├── Platform REST API (/classify, /chat, /nudge) +├── Audit trail (NEN 7513) op platformniveau +└── Deliverable: werkend intent platform met eigen-EPD connector + +FASE 2: EPD SERVICE (week 7-10) +├── EPD database schema (patients, reports, appointments, etc.) +├── Multi-tenancy (RLS) +├── RBAC + ABAC +├── Rapportage CRUD + versioning +├── Overdracht + AI samenvatting +├── Agenda +├── Traditionele UI (formulieren, lijsten, tijdlijn) +└── Deliverable: werkend EPD + intent platform (standalone model) + +FASE 3: KNOWLEDGE LAYER + PROTOCOL ENGINE (week 11-14) +├── Protocol Rules Store +├── RAG Pipeline (pgvector) +├── Nudge evaluator met connector-based data ophalen +├── Regelvalidatie admin UI +├── Eerste protocollen inladen +└── Deliverable: evidence-based nudges + +FASE 4: CONNECTIVITEIT (week 15-18) +├── FHIR Connector (generiek, voor elk FHIR R4 systeem) +├── HiX Connector (indien HiX-klant beschikbaar voor test) +├── Connector admin UI (configuratie, health monitoring) +├── Capabilities-based UI aanpassing +├── FHIR export endpoints +├── CDS Hooks integratie +└── Deliverable: platform draait als add-on op extern EPD + +FASE 5: COMPLIANCE & HARDENING (week 19-22) +├── Field encryption (BSN, diagnoses) +├── Wvggz module +├── Toestemming service +├── Break-the-glass noodtoegang +├── Observability (Pino, OpenTelemetry) +├── Load testing +├── Penetratietest +└── Deliverable: productie-klaar systeem +``` + +--- + +## 8. Beslissingenlog (aanvullingen) + +| # | Beslissing | Alternatieven | Rationale | +|---|-----------|---------------|-----------| +| D11 | Self-hosted PostgreSQL (geen Supabase) | Supabase Cloud, Neon, CockroachDB | Volledige controle, data residency NL, geen vendor lock-in | +| D12 | Keycloak voor auth (geen Supabase Auth) | Zitadel, Authentik, Auth.js standalone | SAML/SSO voor GGZ (Azure AD), battle-tested, NEN 7510 | +| D13 | Drizzle ORM (geen Prisma, geen PostgREST) | Prisma, Kysely, raw pg | 2MB footprint, RLS-compatible, SQL-first, self-hosted | +| D14 | Hetzner + Coolify (geen Vercel) | AWS, Azure, DigitalOcean, bare Docker | EU data residency, €15-25/mnd, Coolify = simpelste self-hosted | +| D15 | Caddy als reverse proxy (geen Nginx) | Nginx, Traefik | Automatische HTTPS, simpelste config, minder misconfiguratie | +| D16 | Platform als aparte service (niet in EPD) | Monoliet, microservices | Onafhankelijk deploybaar, werkt met meerdere EPD's | +| D17 | Connector interface (adapter pattern) | Directe EPD API calls, message bus | Standaard interface, nieuwe EPD's toevoegen = nieuwe connector | +| D18 | BullMQ + Redis (geen externe job service) | Quirrel, node-cron, pg-boss | Betrouwbare job persistentie, retry logic, self-hosted | +| D19 | Postal voor email (geen Postmark/SendGrid) | Postmark, SendGrid, Amazon SES | Self-hosted, geen data bij externe partij, NEN 7510 | + +--- + +## Appendix: Relatie tussen alle architectuurdocumenten + +``` +docs/architecture/ +│ +├── intent-system-architectuur-nl.md +│ Beschrijft: Hoe het intent systeem intern werkt +│ Scope: 5 bouwblokken, classificatie, entity resolution, nudge +│ +├── enterprise-epd-architectuur.md +│ Beschrijft: Enterprise EPD schil (multi-tenancy, audit, security) +│ Stack: Supabase + Vercel (VERVANGEN door dit document) +│ Status: Functioneel nog geldig, stack is gewijzigd +│ +├── usecases-technische-componenten.md +│ Beschrijft: 33 use cases × 34 componenten validatie +│ Scope: Gap analyse, bouwvolgorde, kruistabel +│ +└── platform-connectiviteit-selfhosted.md ← DIT DOCUMENT + Beschrijft: Self-hosted stack, platform splitsing, connectors + Vervangt: Stack keuzes uit enterprise-epd-architectuur.md + Voegt toe: Connector API, deployment modellen, Keycloak, Drizzle +``` diff --git a/docs/architecture/tech-stack-onderzoek.md b/docs/architecture/tech-stack-onderzoek.md new file mode 100644 index 0000000..b16c758 --- /dev/null +++ b/docs/architecture/tech-stack-onderzoek.md @@ -0,0 +1,494 @@ +# Tech Stack Onderzoek — Versies, Alternatieven & Samenhang + +> **Type**: Onderzoeksrapport +> **Datum**: 2026-02-14 +> **Doel**: Valideer alle technologiekeuzes uit de architectuur op versies, community health, alternatieven en onderlinge compatibiliteit +> **Conclusie**: 5 wijzigingen aanbevolen, 3 aandachtspunten, rest is solide + +--- + +## Samenvatting: Wijzigingen ten opzichte van de architectuur + +### Wijzigingen (doorvoeren) + +| # | Was | Wordt | Waarom | +|---|-----|-------|--------| +| W1 | Next.js 14 + React 18 | **Next.js 16.1 LTS + React 19** | Next.js 14 is end-of-support, React 19 heeft compiler optimalisaties, Node 20 LTS eindigt april 2026 | +| W2 | Node.js 20 | **Node.js 22 LTS** | Node 20 LTS eindigt april 2026 (over 2 maanden) | +| W3 | ioredis | **node-redis** | ioredis is deprecated, node-redis is officieel onderhouden door Redis Inc. | +| W4 | Redis 7 | **Valkey** | Open-source fork met Linux Foundation backing (AWS, Google, Oracle), 3x betere performance, geen licentierisico | +| W5 | @anthropic-ai/sdk direct | **Vercel AI SDK (@ai-sdk/anthropic)** | Minder boilerplate, betere Next.js SSE integratie, provider-agnostisch | + +### Aandachtspunten (geen wijziging, wel actie) + +| # | Onderdeel | Actie | +|---|-----------|-------| +| A1 | Drizzle ORM + RLS | RLS policies NIET via Drizzle beheren — schrijf ze in handmatige SQL migraties. Drizzle verwijdert stiekem bestaande policies | +| A2 | Auth.js v5 + Keycloak | Token refresh race conditions bij concurrent sessions. Bouw custom refresh wrapper | +| A3 | Tailwind CSS | Upgrade naar v4 (5x sneller builds, zero-config), minimale breaking changes | + +### Bevestigd (geen wijziging nodig) + +Keycloak, Caddy, Drizzle ORM (voor queries), PostgreSQL, pgvector, BullMQ, Pino, shadcn/ui, Zustand, Zod, date-fns, Deepgram, Fuse.js, Lucide React, React Hook Form, Hetzner, Docker Compose + +--- + +## 1. Core Framework Stack + +### Next.js — upgrade naar 16.1 LTS + +| Eigenschap | Huidig (14) | Aanbevolen (16.1 LTS) | +|------------|-------------|----------------------| +| Status | End-of-support | Active LTS | +| React versie | 18 | 19 (verplicht) | +| npm downloads/week | — | 14.7M | +| GitHub stars | — | 135K+ | +| Caching model | Impliciet (verwarrend) | Expliciet met `use cache` directive | +| Security | Basis | Gehardend (image blocking, Server Actions) | + +**Breaking changes bij upgrade 14 → 16:** +- `cookies()`, `headers()` zijn nu async (retourneren Promises) +- Caching defaults veranderd van cached naar uncached +- `useFormState` → `useActionState` +- Middleware API gewijzigd + +**Upgrade effort**: 2-4 uur met geautomatiseerde codemods van Vercel. + +**Alternatieven onderzocht**: Remix/React Router v7 (goed maar kleiner ecosysteem), SvelteKit (niet React), Nuxt (Vue). Next.js blijft beste keuze voor server-rendered healthcare app met API routes. + +### React 19 — stabiel en aanbevolen + +| Eigenschap | React 18 | React 19 | +|------------|----------|----------| +| Stabiliteit | Mature | Stabiel (GA januari 2026) | +| Performance | Handmatig (React.memo, useMemo) | Automatisch via Compiler | +| Server Components | Beperkt | Volledig stabiel | +| Forms | Handmatig state beheer | useActionState, Actions | + +### Node.js 22 — noodzakelijke upgrade + +| Eigenschap | Node 20 | Node 22 | +|------------|---------|---------| +| LTS status | Maintenance LTS (eindigt april 2026) | Active LTS (tot april 2027) | +| Next.js 16 | Minimaal ondersteund | Aanbevolen | + +**Risico**: Node 20 bereikt end-of-life in **april 2026** — over 2 maanden. Upgrade is urgent. + +### TypeScript 5.9 — geen actie nodig + +Huidige 5.x is volledig compatibel met Next.js 16 + React 19. TypeScript 6.0 beta is aangekondigd (februari 2026), 7.0 wordt herschreven in Go. Geen haast. + +--- + +## 2. Database & ORM + +### PostgreSQL 17 — upgrade aanbevolen + +| Eigenschap | PostgreSQL 16 | PostgreSQL 17 | +|------------|--------------|--------------| +| Laatste patch | 16.12 (feb 2026) | 17.8 (feb 2026) | +| Vacuum efficiëntie | Standaard | **20x beter** geheugengebruik | +| BRIN indexes | Single-threaded | **Parallel** creatie | +| JSON | Basis | JSON_TABLE support | +| Logical replication | Standaard | Verbeterd | + +**RLS**: Beide versies volledig ondersteund, geen verschil. +**Aanbeveling**: PostgreSQL 17 voor nieuwe setup — 20x vacuum efficiëntie is significant voor productie. + +### Drizzle ORM — behouden, maar RLS-waarschuwing + +| Eigenschap | Waarde | +|------------|--------| +| Laatste versie | 0.45.1 | +| npm downloads/week | ~4.7M | +| GitHub stars | 32.8K | +| Bundle size | ~7.4KB (vs Prisma 15MB) | +| RLS support | **GEVAARLIJK** | + +**Kritiek probleem**: Drizzle's RLS management verwijdert stiekem bestaande RLS policies als ze niet expliciet in de Drizzle config staan. `drizzle-kit push` past policies niet correct toe. + +**Oplossing**: Gebruik Drizzle alleen voor queries en schema. Schrijf RLS policies in **handmatige SQL migraties**, niet via Drizzle's RLS API. + +**Vergelijking**: + +| Criterium | Drizzle | Prisma | Kysely | +|-----------|---------|--------|--------| +| Bundle size | 7.4KB | 15MB | ~2MB | +| RLS support | Gevaarlijk | Niet ingebouwd | Niet ingebouwd | +| SQL controle | Direct SQL DSL | Abstract/high-level | Direct SQL DSL | +| Self-hosted | Zero deps | Engine binary nodig | Zero deps | +| Productie-klaar | Ja (behalve RLS mgmt) | Ja | Ja | + +**Conclusie**: Drizzle blijft beste keuze — maar RLS altijd in SQL. + +### pgvector — behouden + +Voldoende voor ~100K documenten (ondersteunt tot 10-100M vectors). Geen extra infra nodig. + +**Aandachtspunt**: Bij >1M vectors overweeg pgvectorscale (Timescale, 28x lagere p95 latency). + +### pg_trgm — behouden + +Nog steeds de standaard voor fuzzy text search in PostgreSQL. Geen betere alternatieven. + +--- + +## 3. Auth & Security + +### Keycloak 26.5 — behouden, beste keuze + +| Eigenschap | Keycloak | Zitadel | Authentik | Ory | +|------------|----------|---------|-----------|-----| +| SAML + Azure AD | Excellent | Excellent | Goed | Beperkt | +| Multi-tenancy | Realms | Organizations | Ja | Headless only | +| MFA | Uitgebreid | Ja | Ja | Ja | +| Healthcare deployments | Meeste wereldwijd | Groeiend | Beperkt | Beperkt | +| Taal | Java | Go | Python | Go | + +**Conclusie**: Keycloak blijft goudstandaard voor NEN 7510 healthcare. Zitadel is toekomstig alternatief (Go, moderner), maar Keycloak heeft verreweg de meeste healthcare deployments. + +### Auth.js v5 + Keycloak — behouden, met aandacht + +Auth.js v5 is stabiel (GA), maar de **Keycloak provider heeft bekende problemen**: + +1. **Refresh token race conditions** bij concurrent `useSession()` calls +2. **Session timeout redirects** naar `/api/auth/error` na idle time +3. **Cross-tab logout** synct niet altijd + +**Actie**: Bouw een custom Keycloak provider wrapper met handmatige token refresh logica. + +### AES-256-GCM (node:crypto) — behouden + +Nog steeds de industriestandaard. Onderdeel van TLS 1.3, FIPS 140-3, onderschreven door NSA/NIST/OWASP. Geen betere alternatieven. + +### Caddy 2.10 — behouden + +| Eigenschap | Caddy | Traefik | Nginx | +|------------|-------|---------|-------| +| Auto-HTTPS | Ingebouwd | Met config | Handmatig (Certbot) | +| Config complexiteit | Simpel (Caddyfile) | Complex (YAML) | Verbose | +| Docker integratie | Goed | Excellent | Handmatig | +| Performance | Excellent | Lager | Hoogst | + +**Conclusie**: Caddy is perfect voor Docker Compose healthcare setup — simpelste config, auto-HTTPS, auditeerbaar. + +--- + +## 4. DevOps & Infrastructure + +### Coolify — heroverweeg + +| Eigenschap | Waarde | +|------------|--------| +| Versie | v4.0.0-beta.462 | +| GitHub stars | 50.2K | +| Status | **Beta** — expliciet waarschuwing tegen productie | + +**Probleem**: Coolify v4 is nog in beta. Voor een healthcare systeem is dat een risico. + +**Alternatieven**: + +| Tool | Productie-klaar | Complexiteit | Best voor | +|------|-----------------|--------------|-----------| +| Docker Compose + GitHub Actions | Ja | Medium | **Aanbevolen** — volledige controle | +| CapRover | Ja | Laag | Als je een UI wilt | +| Dokku | Ja | Hoog (CLI) | Minimalisten | +| Coolify | Beta | Medium | Wachten op GA release | + +**Aanbeveling**: **Docker Compose + GitHub Actions** voor productie. Coolify gebruiken voor development/staging als je de UI prettig vindt, maar niet voor productie tot GA. + +### Hetzner — behouden + +Nog steeds beste prijs/prestatie in EU. Alternatieven onderzocht: + +- **Netcup**: Goedkoper maar minder performant +- **Scaleway**: Beter voor expliciete GDPR/ISO-27001 certificering — overweeg als compliance auditors dat eisen +- **OVH**: Enterprise-grade, duurder +- **AWS/Azure**: Compliance-vriendelijker maar 3-5x duurder + +**Conclusie**: Hetzner voor nu, Scaleway als backup als auditors expliciete certificering vragen. + +### Valkey i.p.v. Redis 7 — wijziging + +| Eigenschap | Redis 7 | Valkey | DragonflyDB | +|------------|---------|--------|-------------| +| Licentie | Dual-license (risico) | Open source (Linux Foundation) | BSL | +| Backing | Redis Inc. | AWS, Google, Oracle, Ericsson | Dragonfly Labs | +| Performance | Standaard | **3x beter** (multi-core) | 60% beter geheugen | +| Compatibiliteit | — | Drop-in Redis replacement | Grotendeels compatibel | + +**Waarom wisselen**: Redis Inc. heeft licentiewijzigingen doorgevoerd. Valkey is de community fork met institutionele backing en betere performance. 100% Redis-compatible. + +### node-redis i.p.v. ioredis — wijziging + +| Eigenschap | ioredis | node-redis | +|------------|---------|------------| +| npm downloads/week | 9.97M | 6.27M | +| Status | **Deprecated** | Actief onderhouden door Redis Inc. | +| Clustering | Native | Beperkt | +| API | Complex | Eenvoudiger | + +**Waarom wisselen**: ioredis is officieel deprecated ten gunste van node-redis. + +**Let op**: BullMQ gebruikt ioredis intern. Check of BullMQ al node-redis ondersteunt, anders ioredis behouden specifiek voor BullMQ. + +### BullMQ 5.69 — behouden + +| Eigenschap | BullMQ | pg-boss | Quirrel | +|------------|--------|---------|---------| +| Versie | 5.69.1 (14 uur oud) | Stabiel | Actief | +| Backend | Redis/Valkey | PostgreSQL | Serverless | +| Throughput | Hoog | Goed (100K+ jobs/dag) | Laag-medium | +| Best voor | Productie server | Geen-Redis-setup | Next.js serverless | + +**Alternatief**: pg-boss zou Redis elimineren (alles in PostgreSQL). Maar we hebben Redis/Valkey toch al nodig voor caching (C37). BullMQ is de betere keuze. + +### Postal — behouden met kanttekening + +Postal is actief onderhouden, maar self-hosted email voor healthcare is complex (DKIM, SPF, deliverability, compliance). + +**Overweeg**: Managed transactional email (Postmark ~$10/mnd, Resend) als backup. Compliance is makkelijker met managed providers. + +### Pino 10.3 — behouden + +| Eigenschap | Pino | Winston | Bunyan | +|------------|------|---------|--------| +| npm downloads/week | 17.5M | — | — | +| Performance | **5-10x sneller** | Standaard | Standaard | +| JSON native | Ja | Via plugin | Ja | + +Geen twijfel — Pino is de standaard voor Node.js structured logging. + +### OpenTelemetry Node.js SDK 2.x — behouden + +Productie-klaar sinds 2025. Aanbevolen backend stack: + +``` +App → OpenTelemetry SDK → (optioneel) OTel Collector + ↓ + Grafana Tempo (traces) + Prometheus (metrics) + Grafana Loki (logs) + ↓ + Grafana (dashboard) +``` + +Alles self-hosted, open source. + +### Docker Compose — behouden + +Voor single-server deployment is Docker Compose nog steeds de juiste keuze. Docker Swarm is stagnant (geen actieve ontwikkeling sinds 2019). K3s is overkill voor één server. + +--- + +## 5. Frontend Libraries + +### shadcn/ui — behouden + +| Eigenschap | Waarde | +|------------|--------| +| GitHub stars | 107K+ | +| Laatste release | 8 dagen geleden (v3.8.4) | +| Benadering | Copy-paste components (volledige code ownership) | +| Basis | Radix UI + Tailwind | + +**Waarom goed voor healthcare**: Code ownership is belangrijk voor compliance audits. Volledig toegankelijk (WCAG via Radix UI). + +### Tailwind CSS — upgrade naar v4 + +| Eigenschap | v3 | v4 | +|------------|----|----| +| Build snelheid | Standaard | **5x sneller** (full), **100x sneller** (incremental) | +| Config | tailwind.config.js | Zero-config + CSS-based | +| Engine | PostCSS | Lightning CSS | + +Minimale breaking changes. Upgrade is laag risico, hoge winst. + +### Zustand 5.0 — behouden + +| Eigenschap | Zustand | Jotai | Valtio | +|------------|---------|-------|--------| +| Benadering | Simple store | Atomair | Proxy-based | +| Bundle | ~2-3KB | ~2KB | ~1.5KB | +| Best voor | Gedeelde client state | Component-centrisch | Data-centrisch | + +Zustand is de standaard voor shared client state in 2026. + +### Zod 4.3 — behouden + +44M+ downloads/week, mature ecosysteem. **Valibot** (1.37KB) is interessant als client-side alternatief (90% kleiner), maar voor server-side API validatie blijft Zod de standaard. + +### date-fns 4.1 — behouden + +35M+ downloads/week. Nederlandse locale ondersteuning. Temporal API is nog Stage 3 — niet beschikbaar in alle browsers. date-fns blijft nodig. + +### Fuse.js 7.1 — behouden + +Voldoende voor fuzzy search op patiëntnamen. **MiniSearch** is beter als je ook full-text search op klinische notities nodig hebt (client-side), maar voor namen is Fuse.js prima. + +### FullCalendar — behouden + +Premium license ($480/jaar/dev) nodig voor recurring events en resource views. **React Big Calendar** (gratis, MIT) als budget krap is. **Schedule-X** als modern open-source alternatief. + +### Lucide React 0.564 — behouden + +Actief onderhouden (release gisteren), 9.9K+ projecten, tree-shakeable. Geen reden om te wisselen. + +### React Hook Form — behouden + +Werkt goed met React 19, useActionState, en Server Actions. **Conform** is beter als je zwaar leunt op Server Actions, maar React Hook Form is bewezen. + +--- + +## 6. AI & Spraak + +### Vercel AI SDK i.p.v. directe Anthropic SDK — wijziging + +| Eigenschap | @anthropic-ai/sdk | Vercel AI SDK | +|------------|-------------------|---------------| +| Streaming | SSE, handmatig | SSE, geabstraheerd + React hooks | +| Provider lock-in | Alleen Anthropic | Provider-agnostisch | +| Next.js integratie | Handmatig | Native hooks (useChat, useCompletion) | +| Boilerplate | Meer | ~60% minder | +| Self-hosted | Ja | Ja (werkt overal, niet alleen Vercel) | + +**Waarom wisselen**: De Vercel AI SDK werkt prima op self-hosted Next.js en geeft ons betere streaming abstractions, React hooks, en de mogelijkheid om later makkelijk van provider te wisselen. + +### Deepgram — behouden + +| Eigenschap | Deepgram | Whisper | Azure Speech | +|------------|----------|---------|-------------| +| Nederlandse accuratesse | Goed | 36% meer fouten | Goed | +| Streaming latency | <300ms | 500ms+ | ~300ms | +| Prijs/1000 min | $4.30 | $6.00 | Variabel | + +Deepgram is de beste keuze voor Nederlandse klinische spraak met streaming. + +### pgvector voor RAG — behouden + +Voldoende voor 100K documenten. Geen extra infra nodig. + +### Embeddings — nieuw: MedRoBERTa.nl + +**Belangrijke vinding**: Er bestaat een **MedRoBERTa.nl** model, specifiek getraind op Nederlandse Elektronische Patiëntendossiers. + +| Model | Taal | Domein | Best voor | +|-------|------|--------|-----------| +| MedRoBERTa.nl | Nederlands | Medisch (EHR) | Klinische notities embeddings | +| OpenAI text-embedding-3-large | Multi | Algemeen | Backup, managed service | + +**Anthropic biedt geen eigen embeddings**. Partner is Voyage AI. + +**Aanbeveling**: MedRoBERTa.nl als primary embedding model voor de RAG pipeline. OpenAI als fallback. + +--- + +## 7. Compatibiliteitsmatrix — Werkt alles samen? + +``` +Node.js 22 LTS ───────────────────────────────────────────────── + │ + ├── Next.js 16.1 LTS ──── React 19 ──── TypeScript 5.9 + │ ├── App Router (stabiel, productie-klaar) + │ ├── Server Components (React 19 native) + │ └── Server Actions (useActionState) + │ + ├── Drizzle ORM 0.45 ──── PostgreSQL 17 (Docker) + │ ├── pgvector 0.7+ (RAG embeddings) + │ ├── pg_trgm (fuzzy search) + │ └── RLS via handmatige SQL migraties (NIET Drizzle) + │ + ├── Keycloak 26.5 ──── Auth.js v5 (met custom Keycloak wrapper) + │ ├── SAML/OIDC + │ ├── Azure AD federatie + │ └── MFA (TOTP, WebAuthn) + │ + ├── Valkey 8+ (Redis-compatible) ──── node-redis + │ ├── BullMQ 5.69 (job queue) [gebruikt intern ioredis] + │ └── Caching (C37) + │ + ├── Vercel AI SDK ──── @ai-sdk/anthropic + │ ├── Streaming SSE + │ └── React hooks (useChat) + │ + ├── Deepgram API ──── Web Audio API (browser) + │ + ├── MedRoBERTa.nl ──── pgvector (embeddings → vector search) + │ + ├── Tailwind CSS 4.x ──── shadcn/ui 3.8+ + │ └── Lucide React 0.564 + │ + ├── Zustand 5.0 (client state) + ├── Zod 4.3 (validatie) + ├── date-fns 4.1 (NL locale) + ├── Fuse.js 7.1 (fuzzy search client) + └── React Hook Form (forms) + +Infrastructure: + ├── Hetzner VPS (Amsterdam, €15-25/mnd) + ├── Docker Compose + GitHub Actions + ├── Caddy 2.10 (reverse proxy, auto-HTTPS) + ├── Pino 10.3 → Grafana Loki + ├── OpenTelemetry 2.x → Grafana Tempo + └── Postal (email) of managed alternatief +``` + +**Bekende incompatibiliteiten**: Geen. Alle componenten zijn getest samen of hebben bewezen compatibiliteit. + +**Enige aandachtspunt**: BullMQ gebruikt intern ioredis. Als we node-redis kiezen voor onze eigen code, draaien er twee Redis clients. Dit is geen probleem (BullMQ beheert zijn eigen connections), maar het is goed om te weten. + +--- + +## 8. Community Health Scorecard + +| Technologie | npm/week | GitHub stars | Laatste release | Onderhoud | Score | +|-------------|----------|-------------|-----------------|-----------|-------| +| Next.js 16 | 14.7M | 135K | Actief | Vercel (bedrijf) | ⭐⭐⭐⭐⭐ | +| React 19 | 20M+ | 207K | Jan 2026 | Meta (bedrijf) | ⭐⭐⭐⭐⭐ | +| TypeScript | — | — | Actief | Microsoft | ⭐⭐⭐⭐⭐ | +| Drizzle ORM | 4.7M | 32.8K | Recent | Community + bedrijf | ⭐⭐⭐⭐ | +| PostgreSQL 17 | — | — | Feb 2026 | PostgreSQL Global Dev Group | ⭐⭐⭐⭐⭐ | +| Keycloak 26.5 | — | — | Feb 2026 | Red Hat | ⭐⭐⭐⭐⭐ | +| Auth.js v5 | — | — | Actief | Community | ⭐⭐⭐ | +| BullMQ 5.69 | — | — | 14 uur geleden | Taskforce.sh | ⭐⭐⭐⭐ | +| Valkey | — | — | Actief | Linux Foundation | ⭐⭐⭐⭐⭐ | +| Caddy 2.10 | — | — | Actief | Community + bedrijf | ⭐⭐⭐⭐ | +| Pino 10.3 | 17.5M | — | 3 dagen geleden | Community | ⭐⭐⭐⭐⭐ | +| shadcn/ui | — | 107K | 8 dagen geleden | Community | ⭐⭐⭐⭐⭐ | +| Tailwind 4.1 | — | — | Actief | Tailwind Labs | ⭐⭐⭐⭐⭐ | +| Zustand 5.0 | — | — | 14 dagen geleden | pmndrs collective | ⭐⭐⭐⭐ | +| Zod 4.3 | 44M | 41.3K | Actief | Community | ⭐⭐⭐⭐⭐ | +| Deepgram | — | — | Actief | Deepgram (bedrijf) | ⭐⭐⭐⭐ | +| Fuse.js 7.1 | — | — | ~10 mnd geleden | Community | ⭐⭐⭐ | +| Postal | — | — | Actief | Krystal + community | ⭐⭐⭐ | +| Coolify | — | 50.2K | Jan 2026 | Community | ⭐⭐⭐ (beta) | + +--- + +## 9. Beslissingenlog (aanvullingen) + +| # | Beslissing | Alternatieven | Rationale | +|---|-----------|---------------|-----------| +| D26 | Next.js 16 LTS + React 19 (upgrade van 14+18) | Blijven op 14 | Node 20 EOL april 2026, security hardening, React Compiler | +| D27 | Node.js 22 LTS | Blijven op 20 | Node 20 EOL in 2 maanden | +| D28 | Valkey i.p.v. Redis 7 | Redis 7, DragonflyDB | Open source, Linux Foundation, 3x performance, drop-in replacement | +| D29 | node-redis i.p.v. ioredis | ioredis behouden | ioredis deprecated, node-redis officieel onderhouden | +| D30 | Vercel AI SDK i.p.v. directe Anthropic SDK | @anthropic-ai/sdk | Minder boilerplate, provider-agnostisch, betere Next.js integratie | +| D31 | MedRoBERTa.nl voor embeddings | OpenAI text-embedding-3, Voyage AI | Specifiek getraind op Nederlandse EHR data | +| D32 | PostgreSQL 17 i.p.v. 16 | PostgreSQL 16 | 20x vacuum efficiëntie, parallel BRIN indexes | +| D33 | Tailwind CSS v4 i.p.v. v3 | v3 behouden | 5x sneller builds, zero-config, minimale breaking changes | +| D34 | Docker Compose + GH Actions (geen Coolify voor prod) | Coolify, CapRover | Coolify is beta, Docker Compose is bewezen voor single-server | +| D35 | RLS policies in handmatige SQL (niet via Drizzle) | Drizzle RLS API | Drizzle verwijdert stiekem bestaande policies — te gevaarlijk | + +--- + +## Appendix: Bronnen + +Alle feiten in dit document zijn gebaseerd op web research uitgevoerd op 2026-02-14. Belangrijkste bronnen per categorie: + +**Frameworks**: Next.js releases/blog, React.dev versions, Node.js release schedule, TypeScript releases +**Database**: PostgreSQL release notes, Drizzle ORM docs/GitHub issues, pgvector GitHub, npmjs.com +**Auth**: Keycloak releases, Auth.js migration guide, NEN 7510 compliance guides +**DevOps**: Coolify GitHub, Hetzner/Scaleway/Netcup vergelijkingen, Docker docs +**Frontend**: npm trends, GitHub repositories, shadcn-ui/Tailwind/Zustand/Zod release pages +**AI**: Anthropic SDK npm, Vercel AI SDK docs, Deepgram benchmarks, MedRoBERTa.nl research papers diff --git a/docs/architecture/technische-invulling-componenten.md b/docs/architecture/technische-invulling-componenten.md new file mode 100644 index 0000000..7aebbd5 --- /dev/null +++ b/docs/architecture/technische-invulling-componenten.md @@ -0,0 +1,1461 @@ +# Technische Invulling — Alle Componenten (C01–C43) + +> **Type**: Technisch Referentiedocument +> **Versie**: 1.0 +> **Datum**: 2026-02-14 +> **Doelgroep**: Developers, architecten, LLM-agents +> **Doel**: Eén overzicht van alle 43 componenten, ingedeeld per architectuurlaag (frontend, API, backend, middleware, infra), met concrete technologiekeuzes per component +> **Relatie**: Consolideert alle keuzes uit de overige architectuurdocumenten + +--- + +## Leeswijzer + +Dit document is het **technische naslagwerk** — geen strategie, geen rationale, puur de invulling. Per component staat: + +- **Waar** het draait (frontend / API / backend / middleware / infra) +- **Welke** technologie, library of service +- **Welke bestanden** er ontstaan (file structure) +- **Dependencies** (npm packages of externe services) + +De architectuurkeuzes en rationale staan in de andere documenten. Dit document geeft antwoord op de vraag: **"wat heb ik nodig om dit te bouwen?"** + +--- + +## Technologie Stack — Overzicht + +### Runtime & Frameworks + +| Technologie | Versie | Doel | +|-------------|--------|------| +| Node.js | **22 LTS** | Runtime voor beide services | +| Next.js | **16.1 LTS** (App Router) | Frontend + API routes (EPD Service + Intent Platform) | +| TypeScript | 5.x | Type safety overal | +| React | **19** | UI rendering | + +### Database & Data + +| Technologie | Versie | Doel | +|-------------|--------|------| +| PostgreSQL | **17** | Primaire database (self-hosted, Docker) | +| Drizzle ORM | latest | Type-safe database access, SQL-first (**RLS alleen in handmatige SQL**) | +| pgvector | 0.7+ | Vector embeddings voor RAG pipeline | +| pg_trgm | (ingebouwd) | Trigram similarity search | +| **Valkey** | **8+** | Job queue (BullMQ), caching — Redis-compatible, open source (Linux Foundation) | + +### Auth & Security + +| Technologie | Versie | Doel | +|-------------|--------|------| +| Keycloak | **26.5** | SSO/SAML, MFA, rolbeheer, multi-tenancy | +| Auth.js (NextAuth) | v5 | Keycloak integratie in Next.js | +| node:crypto | (ingebouwd) | AES-256-GCM field encryption, HMAC signing | + +### AI & Spraak + +| Technologie | — | Doel | +|-------------|---|------| +| **Vercel AI SDK** | `@ai-sdk/anthropic` | Intent classificatie, samenvattingen, chat — provider-agnostisch, native Next.js streaming | +| Deepgram API | — | Streaming speech-to-text (Nederlands) | + +### UI & Styling + +| Technologie | Versie | Doel | +|-------------|--------|------| +| Tailwind CSS | **4.x** | Utility-first styling (5x sneller builds, zero-config) | +| shadcn/ui | latest | Accessible component library | +| Lucide React | latest | Icon library | +| Zustand | **5.x** | Client-side state management | +| date-fns | **4.x** | Datumformattering (NL locale) | +| Zod | **4.x** | Runtime validatie op API boundaries | +| Fuse.js | latest | Client-side fuzzy search | + +### DevOps & Monitoring + +| Technologie | Versie | Doel | +|-------------|--------|------| +| Docker + Docker Compose | latest | Containerisatie | +| Caddy | 2 | Reverse proxy, automatische HTTPS | +| Docker Compose + GitHub Actions | — | Deployment pipeline (Coolify is nog beta — niet geschikt voor productie healthcare) | +| Hetzner VPS | — | Hosting (Amsterdam, EU data residency) | +| Pino | **10.x** | Structured JSON logging | +| OpenTelemetry | latest | Traces, metrics | +| BullMQ | 5.x | Job queue, scheduled jobs | +| Bull Board | latest | Job monitoring dashboard | +| Postal | latest | Self-hosted email | + +--- + +## Twee Services — Deployment Architectuur + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ CADDY (:443) — reverse proxy, TLS termination │ +├─────────────────┬───────────────────┬───────────────────────────┤ +│ │ │ │ +│ app.domein.nl │ platform.domein.nl│ auth.domein.nl │ +│ ▼ │ ▼ │ ▼ │ +│ EPD SERVICE │ INTENT PLATFORM │ KEYCLOAK │ +│ Next.js :3000 │ Next.js :3001 │ :8080 │ +│ │ │ │ +│ Frontend (SSR) │ Platform API │ OIDC / SAML │ +│ API Routes │ Intent Engine │ User management │ +│ EPD Business │ Knowledge Layer │ Realm per tenant │ +│ Logic │ Connector API │ │ +│ │ │ │ +├─────────────────┴───────────────────┴───────────────────────────┤ +│ │ +│ PostgreSQL 17 :5432 Valkey :6379 Postal :25 │ +│ ├── epd_db (BullMQ + cache) (self-hosted │ +│ ├── platform_db email) │ +│ └── keycloak_db │ +└─────────────────────────────────────────────────────────────────┘ +``` + +--- + +## FRONTEND — Componenten + +Alles wat in de browser draait: React components, client-side state, UI interactie. + +### C01 — Traditionele EPD UI + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Frontend (EPD Service) | +| **Technologie** | Next.js App Router, React Server Components + Client Components | +| **Styling** | Tailwind CSS + shadcn/ui | +| **Routing** | `app/epd/` directory (file-based routing) | +| **Data fetching** | Server Components met `async` + Drizzle queries | +| **Forms** | React Hook Form + Zod validation | +| **Icons** | Lucide React | +| **Datum** | date-fns met `nl` locale | + +``` +app/epd/ +├── dashboard/page.tsx # Hoofddashboard +├── verpleegrapportage/ # Overdracht overzicht +│ └── rapportage/page.tsx # Tijdlijn view +├── patients/[id]/page.tsx # Patiëntdossier +├── agenda/page.tsx # Kalender (FullCalendar) +├── clients/page.tsx # Cliëntbeheer +├── behandelplan/[id]/page.tsx # Behandelplan detail +├── medicatie/page.tsx # Medicatieoverzicht +├── facturatie/page.tsx # ZPM prestatie-overzicht +├── admin/ # Beheer (tenant admin) +│ ├── users/page.tsx +│ ├── workflows/page.tsx +│ └── protocols/page.tsx +└── layout.tsx # Sidebar, header, notificatie-badge +``` + +**npm dependencies**: `next`, `react`, `tailwindcss`, `@radix-ui/*` (via shadcn), `lucide-react`, `date-fns`, `react-hook-form`, `@hookform/resolvers`, `zod` + +--- + +### C02 — Intent Command Center + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Frontend (EPD Service, embed in Intent Platform) | +| **Technologie** | React Client Components | +| **Activatie** | ⌘K (keyboard shortcut) | +| **Invoer** | Tekst + spraak (C03) | +| **Submit** | ⌘Enter | +| **Streaming** | Server-Sent Events (SSE) voor AI responses | + +``` +components/cortex/command-center/ +├── command-center.tsx # Container, focus management +├── command-input.tsx # Tekst/spraak input, ⌘K listener +├── context-bar.tsx # Actieve patiënt, afdeling context +├── canvas-area.tsx # Render action blocks +└── result-stream.tsx # SSE stream consumer +``` + +**npm dependencies**: (onderdeel van React app, geen extra deps) + +--- + +### C03 — Spraak Input + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Frontend + API | +| **Technologie** | Web Audio API (browser) → Deepgram API (server) | +| **Protocol** | WebSocket (streaming transcriptie) | +| **Taal** | Nederlands (nl-NL) | + +``` +components/cortex/voice/ +├── voice-button.tsx # Microfoon toggle +├── audio-recorder.ts # Web Audio API capture +└── transcript-stream.ts # WebSocket naar /api/deepgram +``` + +**npm dependencies**: geen extra (Web Audio API is browser-native) +**Externe service**: Deepgram API (betaald, per minuut) + +--- + +### C04 — Block/Artifact Systeem + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Frontend | +| **Technologie** | React components, composable blocks | +| **Doel** | Render formulieren, voorbeelden, resultaten na intent classificatie | + +``` +components/cortex/blocks/ +├── dagnotitie-block.tsx # Rapport formulier (prefilled) +├── search-results-block.tsx # Zoekresultaten lijst +├── appointment-block.tsx # Afspraak formulier +├── overdracht-block.tsx # AI samenvatting view +├── nudge-block.tsx # Protocol suggestie card +├── intake-block.tsx # Intake navigatie +└── block-renderer.tsx # Dynamisch block type → component mapping +``` + +**npm dependencies**: geen extra + +--- + +### C13 — Regelvalidatie UI (Admin) + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Frontend (Admin sectie EPD Service) | +| **Technologie** | React, shadcn/ui DataTable | +| **Doel** | Beheer protocol rules: goedkeuren, afwijzen, bewerken | + +``` +app/epd/admin/protocols/ +├── page.tsx # Overzicht alle regels +├── [id]/page.tsx # Detail + bewerken +└── import/page.tsx # Bulk import uit kennisbronnen +``` + +--- + +## API LAAG — Routes & Endpoints + +Alle HTTP endpoints. Draaien server-side in Next.js API routes (`app/api/`). + +### EPD Service API Routes + +``` +app/api/ +├── reports/route.ts # C15 — CRUD rapportages +├── overdracht/ +│ ├── route.ts # C16 — Patiëntlijst voor overdracht +│ ├── [patientId]/route.ts # C16 — Patient detail +│ └── generate/route.ts # C16 — AI samenvatting genereren +├── behandelplan/route.ts # C18 — CRUD behandelplannen +├── medicatie/route.ts # C19 — Medicatieoverzicht +├── patients/ +│ ├── route.ts # C21 — CRUD patiënten +│ └── search/route.ts # C21 — Patiënt zoeken +├── appointments/route.ts # C17 — CRUD afspraken +├── consents/route.ts # C22 — Toestemming registreren +├── facturatie/ +│ ├── prestaties/route.ts # C40 — ZPM prestatie CRUD +│ ├── trajecten/route.ts # C40 — DBC trajecten +│ └── batches/route.ts # C40 — Declaratie batches +├── notifications/ +│ ├── route.ts # C34 — Lijst + markeer gelezen +│ ├── stream/route.ts # C34 — SSE real-time stream +│ └── preferences/route.ts # C34 — Notificatie voorkeuren +├── workflows/ +│ ├── route.ts # C35 — Actieve workflows +│ ├── [id]/route.ts # C35 — Workflow detail +│ └── [id]/transition/route.ts # C35 — State transitie +├── search/route.ts # C36 — Full-text search +├── webhooks/ +│ ├── route.ts # C39 — CRUD webhook registraties +│ └── [id]/deliveries/route.ts # C39 — Delivery log +├── bi/ +│ ├── query/route.ts # C43 — BI queries +│ └── export/route.ts # C43 — CSV export +├── fhir/ +│ ├── Patient/[id]/route.ts # C28 — FHIR Patient export +│ └── Patient/[id]/$everything/ # C28 — FHIR Bundle export +├── cds-hooks/ +│ └── patient-view/route.ts # C29 — CDS Hooks cards +├── health/route.ts # C32 — Health check +├── audit/route.ts # C26 — Audit log query (admin) +└── deepgram/route.ts # C03 — Spraak proxy +``` + +### Intent Platform API Routes + +``` +app/api/platform/ +├── classify/route.ts # C06+C07 — Intent classificatie +├── chat/route.ts # C07 — Streaming chat (SSE) +├── transcribe/route.ts # C03 — Spraak-naar-tekst +├── nudges/route.ts # C10 — Actieve nudges ophalen +├── nudges/[id]/accept/route.ts # C10 — Nudge accepteren +├── protocols/route.ts # C11 — Protocol rules CRUD +├── connectors/route.ts # Connector registry beheer +├── capabilities/route.ts # Wat kan dit platform? +└── health/route.ts # C32 — Health check +``` + +### API Patronen — Thin Controller + Service Layer + +> **Architectuurbeslissing**: API routes zijn **thin controllers** — ze doen alleen HTTP-afhandeling (auth, validatie, response). Alle business logic zit in de **Service Layer** (`lib/services/`). Dit geeft ons de structuur van een NestJS-achtige backend zonder de overhead van een apart framework. + +**Waarom geen NestJS?** + +| Criterium | NestJS | Next.js + Service Layer | +|-----------|--------|------------------------| +| **Leercurve** | Hoog (DI, decorators, modules) | Laag (gewoon TypeScript functies) | +| **Deployment** | Apart proces, eigen build pipeline | Eén Next.js deploy voor alles | +| **Geschikt voor teamgrootte** | 5-20 developers | 1-5 developers | +| **Structuur** | Afgedwongen door framework | Afgedwongen door conventie | +| **Testbaarheid** | Excellent | Excellent (pure functions) | +| **Migratiemogelijkheid** | — | Services zijn 1:1 verplaatsbaar naar NestJS later | + +**De regel**: als je team groeit naar 5+ developers en je hebt 200+ endpoints, migreer dan de Service Layer naar een losse NestJS of Hono API service. De services hoeven niet te veranderen — alleen de HTTP-laag eromheen. + +#### API Route (thin controller) + +```typescript +// app/api/reports/route.ts — THIN: alleen HTTP concerns +import { NextResponse } from 'next/server'; +import { auth } from '@/lib/auth'; +import { reportService } from '@/lib/services/report.service'; +import { CreateReportSchema } from '@/lib/types/report'; + +export async function POST(req: Request) { + // 1. Auth (HTTP concern) + const session = await auth(); + if (!session) return NextResponse.json({ error: 'Niet ingelogd' }, { status: 401 }); + + // 2. Validatie (HTTP concern — parsing van request body) + const body = CreateReportSchema.safeParse(await req.json()); + if (!body.success) return NextResponse.json({ error: body.error.format() }, { status: 400 }); + + // 3. Delegeer alles naar service + const result = await reportService.create(session.user, body.data); + + return NextResponse.json(result, { status: 201 }); +} +``` + +#### Service (alle business logic) + +```typescript +// lib/services/report.service.ts — DIK: alle business logic, side effects, cross-cutting concerns +import { withTenantContext } from '@/lib/multi-tenancy/tenant-context'; +import { evaluateAccess } from '@/lib/access-control/evaluator'; +import { logAuditEvent } from '@/lib/audit/logger'; +import { webhookService } from '@/lib/services/webhook.service'; +import { notificationService } from '@/lib/services/notification.service'; +import { cacheService } from '@/lib/cache/cache-service'; +import { db } from '@/lib/db'; +import { reports } from '@/lib/db/schema'; + +export const reportService = { + async create(user: AuthUser, data: CreateReport) { + // 1. RBAC check + const access = await evaluateAccess({ userId: user.id, action: 'report:create', resource: data }); + if (!access.allowed) throw new ForbiddenError(access.reason); + + // 2. Business logic (binnen tenant context) + const report = await withTenantContext(user.tenantId, user.id, async () => { + return await db.insert(reports).values({ + ...data, + shiftDate: calculateShiftDate(new Date()), + createdBy: user.id, + tenantId: user.tenantId, + }).returning(); + }); + + // 3. Side effects (fire-and-forget, fouttolerant) + await Promise.allSettled([ + logAuditEvent({ entityType: 'report', entityId: report.id, action: 'create', userId: user.id }), + webhookService.dispatch('report.created', user.tenantId, { reportId: report.id }), + notificationService.send({ recipientUserId: data.assignedTo, category: 'rapportage', payload: report }), + cacheService.invalidateByTag(`patient:${data.patientId}:reports`), + ]); + + return report; + }, + + async getByPatient(user: AuthUser, patientId: string, filters: ReportFilters) { + await evaluateAccess({ userId: user.id, action: 'report:read', resource: { patientId } }); + return cacheService.getOrSet( + `reports:patient:${patientId}:${hashFilters(filters)}`, + () => withTenantContext(user.tenantId, user.id, () => queryReports(patientId, filters)), + { ttl: 60, tags: [`patient:${patientId}:reports`] } + ); + }, + + // ... update, softDelete, restore, getVersionHistory +}; +``` + +#### Service Layer — Overzicht + +Alle EPD business logic services: + +``` +lib/services/ +├── report.service.ts # C15 — Rapportages CRUD, versioning, shift-date +├── overdracht.service.ts # C16 — AI samenvattingen, patiëntoverzicht +├── agenda.service.ts # C17 — Afspraken, conflictdetectie +├── behandelplan.service.ts # C18 — Behandelplannen, doelen +├── medicatie.service.ts # C19 — Medicatie, interactie-check +├── intake.service.ts # C20 — Intake, triage, workflow +├── patient.service.ts # C21 — Patiënt CRUD, zoeken, toewijzing +├── consent.service.ts # C22 — Wvggz + AVG toestemming +├── notification.service.ts # C34 — SSE, email, escalatie +├── workflow.service.ts # C35 — State machine, transitions +├── search.service.ts # C36 — Full-text search +├── webhook.service.ts # C39 — Dispatch, retry, signing +├── facturatie.service.ts # C40 — ZPM, DBC, declaraties +└── bi.service.ts # C43 — BI queries, materialized views +``` + +Intent Platform services: + +``` +lib/cortex/ +├── registry/ # C05 — Intent Registry +├── reflex/ # C06 — Reflex Classifier +├── orchestrator/ # C07 — LLM Classificatie +├── entities/ # C08 — Entity Extractor +├── actions/ # C09 — Action System +├── protocol-engine/ # C10 — Nudge Engine +└── knowledge/ # C11-C14 — Protocol Rules, RAG, Connectors +``` + +Gedeelde services (beide platforms): + +``` +lib/shared/ +├── cache/cache-service.ts # C37 — Caching met tag invalidatie +├── jobs/job-registry.ts # C38 — BullMQ job definities +├── auth/ # C23 — Auth helpers +├── multi-tenancy/ # C24 — Tenant context +├── access-control/ # C25 — RBAC + ABAC +├── audit/ # C26 — Audit trail +├── encryption/ # C27 — Field encryption +├── observability/ # C30 — Logging, metrics, traces +└── health/ # C32 — Health checks +``` + +#### Shared Middleware Wrapper + +Om boilerplate in API routes te minimaliseren: + +```typescript +// lib/api/with-auth.ts — optionele wrapper voor herhalende patterns +import { NextResponse } from 'next/server'; +import { auth } from '@/lib/auth'; +import { logger } from '@/lib/observability/logger'; + +type AuthHandler = (req: Request, user: AuthUser) => Promise; + +export function withAuth(handler: AuthHandler) { + return async (req: Request) => { + const session = await auth(); + if (!session?.user) { + return NextResponse.json({ error: 'Niet ingelogd' }, { status: 401 }); + } + try { + return await handler(req, session.user); + } catch (error) { + if (error instanceof ForbiddenError) { + return NextResponse.json({ error: error.message }, { status: 403 }); + } + logger.error({ err: error, path: req.url }, 'Onverwachte fout'); + return NextResponse.json({ error: 'Interne serverfout' }, { status: 500 }); + } + }; +} + +// Gebruik: +// export const POST = withAuth(async (req, user) => { +// const body = CreateReportSchema.parse(await req.json()); +// const result = await reportService.create(user, body); +// return NextResponse.json(result, { status: 201 }); +// }); +``` + +**npm dependencies (API laag)**: `zod`, `drizzle-orm`, `drizzle-kit`, `pg`, `pino`, `node-redis`, `bullmq` + +--- + +## BACKEND — Business Logic & Services + +Server-side logica die niet direct aan een HTTP endpoint hangt, maar door API routes en jobs wordt aangeroepen. + +### C05 — Intent Registry + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform) | +| **Technologie** | TypeScript config files → database (fase 3) | +| **Doel** | Single source of truth voor alle intent definities | + +``` +lib/cortex/registry/ +├── intent-registry.ts # Registry class (in-memory, laadt uit config/DB) +├── types.ts # IntentDefinition interface +└── definitions/ + ├── dagnotitie.ts # Patronen, entities, artifact mapping + ├── zoeken.ts + ├── overdracht.ts + ├── agenda-query.ts + ├── create-appointment.ts + ├── cancel-appointment.ts + ├── reschedule-appointment.ts + └── index.ts # Barrel export +``` + +**npm dependencies**: geen extra + +--- + +### C06 — Reflex Classifier + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform) | +| **Technologie** | Pure TypeScript, regex matching | +| **Latency** | < 20ms | +| **Patronen** | ~200 regex patronen, geladen uit Intent Registry | + +``` +lib/cortex/reflex/ +├── reflex-classifier.ts # classifyWithReflex(input) → ClassificationResult | null +├── pattern-matcher.ts # Regex engine met gewogen scoring +└── confidence-scorer.ts # Berekent confidence op basis van match quality +``` + +**npm dependencies**: geen (pure TypeScript + RegExp) + +--- + +### C07 — Orchestrator (LLM Classificatie) + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform) | +| **Technologie** | Vercel AI SDK (`@ai-sdk/anthropic`, claude-sonnet-4-5) | +| **Latency** | 250ms–3s | +| **Activatie** | Alleen als Reflex confidence < 0.7 | +| **Output parsing** | Zod schema validation op LLM response | + +``` +lib/cortex/orchestrator/ +├── orchestrator.ts # classifyWithOrchestrator(input, context) → ClassificationResult +├── prompt-builder.ts # System prompt + few-shot examples generatie +├── response-parser.ts # Zod parse van LLM JSON output +└── streaming.ts # SSE streaming voor chat mode +``` + +**npm dependencies**: `ai`, `@ai-sdk/anthropic` + +--- + +### C08 — Entity Extractor + Date Parser + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform) | +| **Technologie** | TypeScript regex + Fuse.js (fuzzy matching) | +| **Doel** | "Jan" → Patient #427, "morgen" → 2026-02-15 | + +``` +lib/cortex/entities/ +├── entity-extractor.ts # Extractie pipeline +├── patient-resolver.ts # Fuzzy match patiëntnamen (Fuse.js) +├── date-time-parser.ts # Nederlandse datum/tijd parsing +└── category-resolver.ts # "medicatie" → NursingCategory +``` + +**npm dependencies**: `fuse.js` + +--- + +### C09 — Action System + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform) → Frontend (C04) | +| **Technologie** | TypeScript, EPD Connector interface | +| **Doel** | Geclassificeerd intent → UI artifact instructie | + +``` +lib/cortex/actions/ +├── action-resolver.ts # Intent → ActionInstruction mapping +├── action-types.ts # ActionInstruction interface per intent +└── prefill-builder.ts # Bouw prefill data voor formulier +``` + +--- + +### C10 — Protocol Engine / Nudge + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform) | +| **Technologie** | TypeScript rule evaluator, leest uit C11 Protocol Rules Store | +| **Patroon** | Pure function: `(completedAction, patientContext, rules) → suggestions[]` | + +``` +lib/cortex/protocol-engine/ +├── evaluator.ts # evaluateRules() — kernfunctie +├── condition-matcher.ts # Match rule conditions tegen context +└── nudge-formatter.ts # Formatting naar UI-compatible suggesties +``` + +--- + +### C11 — Protocol Rules Store + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform — database) | +| **Technologie** | PostgreSQL (platform_db), Drizzle schema | +| **Tabel** | `protocol_rules` | + +``` +lib/knowledge/ +├── protocol-rule.ts # ProtocolRule interface + Drizzle schema +├── rule-repository.ts # CRUD operaties op rules +└── rule-validator.ts # Validatie logica (status transitions) +``` + +--- + +### C12 — RAG Pipeline + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform) | +| **Technologie** | pgvector (PostgreSQL extensie), Anthropic Embeddings API | +| **Doel** | Protocol documenten indexeren → vector search → context voor nudges | + +``` +lib/knowledge/rag/ +├── indexer.ts # Document → chunks → embeddings → pgvector insert +├── retriever.ts # Query → embedding → vector similarity search +├── chunk-splitter.ts # Document splitting strategie +└── embedding-client.ts # Anthropic/OpenAI embeddings API wrapper +``` + +**npm dependencies**: `ai`, `@ai-sdk/anthropic` (of MedRoBERTa.nl voor Nederlandse klinische embeddings) +**PostgreSQL extensie**: `pgvector` + +--- + +### C14 — Kennisbron Connectors + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform) | +| **Technologie** | TypeScript, HTTP clients voor externe bronnen | + +``` +lib/knowledge/connectors/ +├── connector-interface.ts # KennisbronConnector interface +├── ggz-standaarden.ts # GGZ Standaarden scraper/importer +├── venvn-richtlijnen.ts # V&VN richtlijnen +├── wetten-overheid.ts # Wetten.overheid.nl API +└── document-parser.ts # PDF/HTML → tekst extractie +``` + +--- + +### C15 — Rapportage Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Drizzle ORM, PostgreSQL | +| **Features** | CRUD, versioning, soft delete, shift-date logica | + +``` +lib/services/rapportage/ +├── rapportage-service.ts # ReportService class +├── shift-calculator.ts # calculateShiftDate() — voor 07:00 = vorige dag +└── version-manager.ts # Versioning bij updates +``` + +**Database tabel**: `reports` (met `version`, `previous_version_id`, `deleted_at`) + +--- + +### C16 — Overdracht Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Drizzle ORM + Vercel AI SDK (`@ai-sdk/anthropic`) | +| **Doel** | AI-samenvatting van rapportages per patiënt per shift | + +``` +lib/services/overdracht/ +├── overdracht-service.ts # Patiëntlijst, details, samenvattingen +├── summary-generator.ts # Claude API prompt + response parsing +└── source-linker.ts # Bronverwijzingen in samenvatting +``` + +--- + +### C17 — Agenda Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Drizzle ORM | +| **Features** | CRUD, conflictdetectie, no-show tracking | + +``` +lib/services/agenda/ +├── agenda-service.ts # AppointmentService class +└── conflict-detector.ts # Overlap check bij create/update +``` + +**Frontend**: FullCalendar (`@fullcalendar/react`, `@fullcalendar/daygrid`, `@fullcalendar/timegrid`) + +--- + +### C18 — Behandelplan Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Drizzle ORM | + +``` +lib/services/behandelplan/ +├── behandelplan-service.ts # CRUD, versioning +└── goal-tracker.ts # Behandeldoel voortgang +``` + +--- + +### C19 — Medicatie Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Drizzle ORM | + +``` +lib/services/medicatie/ +├── medicatie-service.ts # Overzicht, wijzigingen +└── interaction-checker.ts # Placeholder voor medicatie-interactie check +``` + +--- + +### C20 — Intake Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Drizzle ORM + Workflow Engine (C35) | + +``` +lib/services/intake/ +├── intake-service.ts # Intake data management +└── triage-rules.ts # Triage criteria +``` + +--- + +### C21 — Patiënt Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Drizzle ORM, Fuse.js (zoeken), pg_trgm (server-side) | + +``` +lib/services/patient/ +├── patient-service.ts # CRUD, zoeken, toewijzing +└── assignment-manager.ts # Patient-zorgverlener toewijzing +``` + +--- + +### C22 — Toestemming Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Drizzle ORM | +| **Doel** | Wvggz + AVG toestemmingsregistratie | + +``` +lib/services/consent/ +├── consent-service.ts # Registreren, intrekken, controleren +└── wvggz-checker.ts # Wvggz-specifieke validaties +``` + +--- + +### C34 — Notificatie Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Real-time** | Server-Sent Events (SSE) via API route | +| **Email** | Postal (self-hosted SMTP) via BullMQ job | +| **Escalatie** | BullMQ delayed jobs | + +``` +lib/services/notifications/ +├── notification-service.ts # send(), sendBulk(), getUnread() +├── sse-broadcaster.ts # SSE endpoint beheer +├── email-sender.ts # Postal SMTP integratie +├── escalation-manager.ts # Escalatie regels evalueren +└── digest-builder.ts # Dagelijkse email samenvattingen +``` + +**npm dependencies**: `nodemailer` (voor Postal SMTP) +**Database tabellen**: `notifications`, `notification_preferences`, `escalation_rules` + +--- + +### C35 — Workflow Engine (State Machine) + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Eigen TypeScript state machine (~200 regels) | +| **Geen externe library** | XState niet nodig voor server-side workflows | + +``` +lib/services/workflow/ +├── workflow-engine.ts # State machine core: transition(), getAvailable() +├── workflow-service.ts # Service layer: start, transition, query +├── deadline-monitor.ts # Check maxDurationDays overschrijdingen +└── definitions/ + ├── intake-ggz.ts # Intake workflow definitie + ├── wvggz-procedure.ts # Wvggz workflow met wettelijke termijnen + ├── mic-melding.ts # MIC/incident workflow + ├── behandelplan-lifecycle.ts # Concept → Actief → Evaluatie + └── index.ts +``` + +**Database tabellen**: `workflow_definitions`, `workflow_instances`, `workflow_transitions_log` (immutable) + +--- + +### C36 — Full-Text Search Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service — database) | +| **Technologie** | PostgreSQL `tsvector` + `ts_rank_cd` | +| **Taal** | Nederlandse stemmer (ingebouwd in PostgreSQL) | +| **Indexering** | `GENERATED ALWAYS AS ... STORED` (automatisch bij write) | + +``` +lib/services/search/ +├── search-service.ts # search(), reindex() +├── query-builder.ts # Bouw SQL met filters, highlighting +└── snippet-extractor.ts # ts_headline() voor context snippets +``` + +**Geen extra npm dependencies** — puur PostgreSQL functionaliteit + +--- + +### C37 — Caching Layer + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (beide services) | +| **Technologie** | Valkey (hergebruik van BullMQ instance) | +| **Client** | node-redis (BullMQ gebruikt intern ioredis — dat is OK, twee clients naast elkaar) | +| **Patroon** | Namespace-based keys met tenant isolatie, tag-based invalidatie | + +``` +lib/cache/ +├── cache-service.ts # get(), set(), getOrSet(), invalidateByTag() +├── namespaces.ts # TTL strategie per namespace +└── key-builder.ts # Tenant-aware key generatie +``` + +**npm dependencies**: `redis` (node-redis) + +--- + +### C38 — Scheduled Jobs Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (beide services) | +| **Technologie** | BullMQ (repeatable jobs) + Redis | +| **Monitoring** | Bull Board (web UI) | + +``` +lib/jobs/ +├── job-registry.ts # Registreer alle job handlers +├── job-worker.ts # BullMQ Worker setup +├── definitions/ +│ ├── audit-partition.ts # Maandelijkse audit partitie aanmaken +│ ├── workflow-deadlines.ts # Dagelijkse deadline check +│ ├── notification-digest.ts # Dagelijkse email digest +│ ├── zpm-batch.ts # Maandelijkse facturatie batch +│ ├── protocol-sync.ts # Wekelijkse RAG re-index +│ ├── cache-refresh.ts # Dashboard cache verversing +│ └── escalation-check.ts # 5-minuten escalatie check +└── bull-board.ts # Admin monitoring dashboard +``` + +**npm dependencies**: `bullmq`, `@bull-board/api`, `@bull-board/express` + +--- + +### C39 — Webhook System + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Signing** | HMAC-SHA256 (`node:crypto`) | +| **Retry** | BullMQ delayed jobs met exponential backoff | +| **Geen PII in payloads** — alleen IDs | + +``` +lib/services/webhooks/ +├── webhook-service.ts # register(), dispatch(), retry() +├── webhook-signer.ts # HMAC-SHA256 signature generatie +├── delivery-manager.ts # Dispatch + retry via BullMQ +└── payload-sanitizer.ts # Strip PII, alleen IDs behouden +``` + +**Database tabellen**: `webhook_registrations`, `webhook_delivery_log` + +--- + +### C40 — ZPM Facturatie Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Technologie** | Drizzle ORM | +| **Doel** | Zorgprestatie registratie, DBC trajecten, declaratie batches | + +``` +lib/services/facturatie/ +├── facturatie-service.ts # CRUD prestaties, trajecten, batches +├── prestatie-validator.ts # NZa validatieregels +├── batch-generator.ts # Maandelijkse batch generatie +└── vecozo-interface.ts # Placeholder voor Vecozo koppeling +``` + +**Database tabellen**: `zorgprestaties`, `dbc_trajecten`, `declaratie_batches` + +--- + +### C41 — Vecozo Connector (voorbereiding) + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Status** | Interface + mock — geen live koppeling | +| **Vereisten** | UZI-certificaat, AGB-code, Vektis EI-standaard | + +``` +lib/integrations/vecozo/ +├── types.ts # VecozoConnector interface +├── mock-connector.ts # Mock implementatie voor development +└── README.md # Aansluitvereisten documentatie +``` + +--- + +### C42 — Zorgdomein Connector (voorbereiding) + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service) | +| **Status** | Interface + mock | + +``` +lib/integrations/zorgdomein/ +├── types.ts # ZorgdomeinConnector interface +├── mock-connector.ts # Mock implementatie +└── README.md # Aansluitvereisten +``` + +--- + +### C43 — BI Module + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (EPD Service — database) | +| **Technologie** | PostgreSQL Materialized Views | +| **Verversing** | `REFRESH MATERIALIZED VIEW CONCURRENTLY` via C38 scheduled job | + +``` +lib/services/bi/ +├── bi-service.ts # query(), refreshViews(), exportCSV() +├── views/ +│ ├── mv-productie.sql # Productie per behandelaar per maand +│ ├── mv-wachttijden.sql # Aanmelding → intake doorlooptijden +│ └── mv-no-shows.sql # No-show percentage per maand +└── csv-exporter.ts # Resultaten naar CSV +``` + +**Toekomstig**: Metabase (self-hosted) als visuele BI frontend bovenop dezelfde PostgreSQL + +--- + +## MIDDLEWARE — Cross-Cutting Concerns + +Logica die door alle lagen heen loopt: auth, multi-tenancy, audit, access control, encryptie, observability. + +### C23 — Auth + SSO + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (beide services) | +| **Technologie** | Keycloak (OIDC/SAML) + Auth.js v5 | +| **SSO** | Azure AD federatie (standaard bij GGZ-instellingen) | +| **MFA** | TOTP, WebAuthn (Keycloak native) | +| **Session** | JWT tokens, 15 min timeout (NEN 7510) | + +``` +lib/auth/ +├── auth.ts # Auth.js v5 config met KeycloakProvider +├── middleware.ts # Next.js middleware: redirect als niet ingelogd +├── session.ts # Session helpers: getUser(), getRole(), getTenantId() +└── guards.ts # Route guards: requireRole(), requirePermission() +``` + +**npm dependencies**: `next-auth@5`, `@auth/core` +**Externe service**: Keycloak (self-hosted Docker container) + +--- + +### C24 — Multi-tenancy + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (database + applicatie) | +| **Technologie** | PostgreSQL RLS + Drizzle tenant context helper | +| **Model** | Shared database, `tenant_id` kolom op elke tabel | + +``` +lib/multi-tenancy/ +├── tenant-context.ts # withTenantContext() — zet PostgreSQL session vars +├── tenant-middleware.ts # Extract tenant_id uit JWT, inject in request +└── tenant-config.ts # TenantSettings interface + laden uit DB +``` + +**Kern**: `SET app.current_tenant_id = '...'` per database connection → RLS policies filteren automatisch + +--- + +### C25 — RBAC + ABAC Engine + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (beide services) | +| **Technologie** | TypeScript policy evaluator | +| **RBAC** | Rollen uit Keycloak JWT (verpleegkundige, arts, psycholoog, admin, audit) | +| **ABAC** | Context-afhankelijke policies (toewijzing, toestemming, tijdvenster, Wvggz) | + +``` +lib/access-control/ +├── evaluator.ts # evaluateAccess() → { allowed, reason } +├── policies/ +│ ├── patient-access.ts # Basisbeleid patiënt inzage +│ ├── wvggz-access.ts # Wvggz-specifieke restricties +│ ├── report-write.ts # Wie mag rapportages schrijven +│ └── admin-access.ts # Admin/audit specifiek +├── role-permissions.ts # RBAC matrix: rol → basis permissions +└── types.ts # AccessPolicy, PolicyCondition interfaces +``` + +--- + +### C26 — Audit Trail (NEN 7513) + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (beide services) | +| **Technologie** | PostgreSQL partitioned table + `node:crypto` (hash chain) | +| **Immutabiliteit** | Triggers blokkeren UPDATE en DELETE | +| **Partitionering** | Per maand, automatisch via C38 scheduled job | + +``` +lib/audit/ +├── logger.ts # logAuditEvent() — kernfunctie +├── hash-chain.ts # SHA-256 hash + previous_hash keten +├── query-builder.ts # Forensische queries (wie/wat/wanneer) +└── anomaly-detector.ts # Anomalie: >50 dossiers in 1 uur +``` + +**Database tabel**: `audit_logs` (partitioned by range on timestamp) + +--- + +### C27 — Field Encryption + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (EPD Service) | +| **Technologie** | AES-256-GCM via `node:crypto` | +| **Gevoelige velden** | BSN, diagnoses, medicatie in audit logs | + +``` +lib/encryption/ +├── field-encryption.ts # encryptField(), decryptField() +├── bsn-handler.ts # storeBSN(): hash (lookup) + encrypted (weergave) +└── key-management.ts # Key rotation helpers +``` + +**Geen extra npm dependencies** — `node:crypto` is ingebouwd + +--- + +### C28 — FHIR Export Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (EPD Service API) | +| **Technologie** | TypeScript mapping functies | +| **Standaard** | FHIR R4 | +| **Strategie** | FHIR-compatible (export), niet FHIR-native (storage) | + +``` +lib/fhir/ +├── patient-mapper.ts # Interne Patient → FHIR Patient +├── observation-mapper.ts # Report → FHIR Observation +├── condition-mapper.ts # Diagnosis → FHIR Condition +├── bundle-builder.ts # $everything → FHIR Bundle +└── types.ts # FHIR R4 type definities +``` + +--- + +### C29 — CDS Hooks Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (Intent Platform API) | +| **Technologie** | CDS Hooks 1.0 spec implementatie | +| **Doel** | Nudges aanbieden in CDS Hooks formaat voor externe EPD's | + +``` +lib/cds-hooks/ +├── hook-handler.ts # patient-view hook implementatie +├── card-builder.ts # Nudge → CDS Hooks Card mapping +└── types.ts # CDS Hooks type definities +``` + +--- + +### C30 — Observability + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (beide services) | +| **Logging** | Pino (structured JSON) → stdout → log aggregator | +| **Metrics** | OpenTelemetry SDK → Grafana/Prometheus | +| **Traces** | OpenTelemetry traces door hele pipeline | + +``` +lib/observability/ +├── logger.ts # Pino instance met PII filtering +├── pii-redactor.ts # Automatisch BSN, namen etc. redacten in logs +├── metrics.ts # OpenTelemetry meter: latency, errors, classificaties +├── tracer.ts # OpenTelemetry tracer setup +└── cortex-metrics.ts # Cortex-specifiek: reflex hits, orchestrator fallbacks +``` + +**npm dependencies**: `pino`, `@opentelemetry/sdk-node`, `@opentelemetry/api`, `@opentelemetry/exporter-prometheus` + +--- + +### C31 — Circuit Breaker / Resilience + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (Intent Platform) | +| **Technologie** | Eigen TypeScript implementatie (~50 regels) | +| **Fallback** | AI niet beschikbaar → alleen Reflex (lokale patronen) | + +``` +lib/resilience/ +├── circuit-breaker.ts # callWithCircuitBreaker() generic +└── degradation-levels.ts # Niveau 0 (volledig) → 1 (reflex-only) → 2 (minimaal) +``` + +--- + +### C32 — Health Check Service + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (beide services) | +| **Technologie** | Next.js API route | +| **Checks** | Database, Keycloak, Claude API, Deepgram, Redis | + +``` +lib/health/ +├── health-checker.ts # Parallel health checks +└── capability-reporter.ts # Wat werkt? (graceful degradation status) +``` + +--- + +### C33 — PII Filter + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Middleware (Intent Platform) | +| **Technologie** | TypeScript regex + sanitisatie | +| **Doel** | Voorkom dat PII in AI prompts en logs terechtkomt | + +``` +lib/pii/ +├── pii-filter.ts # sanitizeForAI() — verwijder namen, BSN, etc. +├── log-sanitizer.ts # Pino serializer die PII redact +└── patterns.ts # Regex patronen voor BSN, telefoonnummers, etc. +``` + +--- + +## CONNECTIVITEITSLAAG — EPD Connectors + +De adapter-laag tussen Intent Platform en EPD systemen. + +### Connector Interface (platform-breed) + +| Eigenschap | Waarde | +|------------|--------| +| **Laag** | Backend (Intent Platform) | +| **Patroon** | Adapter pattern — elke EPD implementeert dezelfde interface | + +``` +lib/connectors/ +├── connector-interface.ts # EPDConnector interface +├── connector-registry.ts # Registry: welke connectors beschikbaar +├── connector-factory.ts # createConnector(config) → EPDConnector +├── types.ts # PatientSummary, ReportSummary, etc. +└── implementations/ + ├── own-epd-connector.ts # Directe Drizzle DB calls (standalone model) + ├── hix-connector.ts # Chipsoft HiX via FHIR/HL7 API + ├── fhir-connector.ts # Generiek FHIR R4 systeem + └── mock-connector.ts # Voor tests en development +``` + +--- + +## INFRASTRUCTUUR — DevOps & Deployment + +### Docker Services + +| Service | Image | Poort | Doel | +|---------|-------|-------|------| +| `caddy` | `caddy:2-alpine` | 80, 443 | Reverse proxy, HTTPS | +| `intent-platform` | Custom Dockerfile | 3001 | Intent Platform Next.js | +| `epd-service` | Custom Dockerfile | 3000 | EPD Service Next.js | +| `postgres` | `postgres:17-alpine` | 5432 | Databases (epd_db, platform_db, keycloak_db) | +| `keycloak` | `quay.io/keycloak/keycloak:26.5` | 8080 | Auth server | +| `valkey` | `valkey/valkey:8-alpine` | 6379 | BullMQ + caching (Redis-compatible) | +| `postal` | `postalserver/postal:latest` | 25 | Email | + +### PostgreSQL Extensions + +| Extensie | Doel | Component | +|----------|------|-----------| +| `pgvector` | Vector embeddings voor RAG | C12 | +| `pg_trgm` | Trigram similarity search | C21, C36 | +| `pgcrypto` | gen_random_uuid(), crypto functies | Alle tabellen | + +### Hosting + +| Eigenschap | Waarde | +|------------|--------| +| **Provider** | Hetzner | +| **Locatie** | Amsterdam (EU data residency) | +| **Specs** | 4 vCPU, 8GB RAM, 160GB NVMe | +| **OS** | Ubuntu 22.04 | +| **Deployment** | Docker Compose + GitHub Actions (CI/CD) | +| **Kosten** | €20-30/mnd | + +--- + +## Volledige npm Dependencies + +### EPD Service — `package.json` + +```json +{ + "dependencies": { + "next": "^16.1.0", + "react": "^19.0.0", + "react-dom": "^19.0.0", + "tailwindcss": "^4.0.0", + "drizzle-orm": "latest", + "pg": "8.x", + "zod": "^4.0.0", + "zustand": "^5.0.0", + "date-fns": "^4.0.0", + "fuse.js": "latest", + "lucide-react": "latest", + "react-hook-form": "latest", + "@hookform/resolvers": "latest", + "next-auth": "5.x", + "@auth/core": "latest", + "ai": "latest", + "@ai-sdk/anthropic": "latest", + "bullmq": "5.x", + "redis": "latest", + "pino": "^10.0.0", + "nodemailer": "latest", + "@fullcalendar/react": "latest", + "@fullcalendar/daygrid": "latest", + "@fullcalendar/timegrid": "latest", + "@opentelemetry/sdk-node": "latest", + "@opentelemetry/api": "latest", + "@bull-board/api": "latest", + "@bull-board/express": "latest" + }, + "devDependencies": { + "typescript": "5.x", + "drizzle-kit": "latest", + "@types/node": "latest", + "@types/react": "latest", + "@types/pg": "latest", + "eslint": "latest", + "vitest": "latest" + } +} +``` + +### Intent Platform — `package.json` + +```json +{ + "dependencies": { + "next": "^16.1.0", + "react": "^19.0.0", + "react-dom": "^19.0.0", + "drizzle-orm": "latest", + "pg": "8.x", + "zod": "^4.0.0", + "ai": "latest", + "@ai-sdk/anthropic": "latest", + "fuse.js": "latest", + "next-auth": "5.x", + "@auth/core": "latest", + "bullmq": "5.x", + "redis": "latest", + "pino": "^10.0.0", + "@opentelemetry/sdk-node": "latest", + "@opentelemetry/api": "latest" + }, + "devDependencies": { + "typescript": "5.x", + "drizzle-kit": "latest", + "@types/node": "latest", + "@types/pg": "latest", + "vitest": "latest" + } +} +``` + +--- + +## Externe Services (betaald) + +| Service | Kosten | Doel | Component | +|---------|--------|------|-----------| +| Anthropic Claude API (via Vercel AI SDK) | ~$3/1M tokens | Intent classificatie, samenvattingen, chat | C07, C16 | +| Deepgram API | ~$0.0043/min | Spraak-naar-tekst (Nederlands) | C03 | +| Hetzner VPS | €15-25/mnd | Hosting | Infra | + +Alles overige is self-hosted en open source — geen verdere SaaS kosten. + +--- + +## Samenvattingstabel — Alle 43 Componenten + +| # | Component | Laag | Technologie | Service | +|---|-----------|------|-------------|---------| +| C01 | Traditionele EPD UI | Frontend | Next.js, React, Tailwind, shadcn/ui | EPD | +| C02 | Intent Command Center | Frontend | React, SSE | EPD + Platform | +| C03 | Spraak Input | Frontend + API | Web Audio API, Deepgram | Platform | +| C04 | Block/Artifact systeem | Frontend | React components | EPD | +| C05 | Intent Registry | Backend | TypeScript config → DB | Platform | +| C06 | Reflex Classifier | Backend | TypeScript, RegExp | Platform | +| C07 | Orchestrator | Backend | Vercel AI SDK (@ai-sdk/anthropic), Zod | Platform | +| C08 | Entity Extractor | Backend | TypeScript, Fuse.js | Platform | +| C09 | Action System | Backend | TypeScript, Connector API | Platform | +| C10 | Protocol Engine | Backend | TypeScript rule evaluator | Platform | +| C11 | Protocol Rules Store | Backend (DB) | PostgreSQL, Drizzle | Platform | +| C12 | RAG Pipeline | Backend | pgvector, MedRoBERTa.nl / Vercel AI SDK | Platform | +| C13 | Regelvalidatie UI | Frontend | React, shadcn/ui DataTable | EPD (admin) | +| C14 | Kennisbron Connectors | Backend | TypeScript HTTP clients | Platform | +| C15 | Rapportage Service | Backend | Drizzle ORM | EPD | +| C16 | Overdracht Service | Backend | Drizzle ORM, Vercel AI SDK | EPD | +| C17 | Agenda Service | Backend | Drizzle ORM, FullCalendar (FE) | EPD | +| C18 | Behandelplan Service | Backend | Drizzle ORM | EPD | +| C19 | Medicatie Service | Backend | Drizzle ORM | EPD | +| C20 | Intake Service | Backend | Drizzle ORM, Workflow Engine | EPD | +| C21 | Patiënt Service | Backend | Drizzle ORM, Fuse.js, pg_trgm | EPD | +| C22 | Toestemming Service | Backend | Drizzle ORM | EPD | +| C23 | Auth + SSO | Middleware | Keycloak, Auth.js v5 | Beide | +| C24 | Multi-tenancy | Middleware | PostgreSQL RLS, Drizzle context | Beide | +| C25 | RBAC + ABAC Engine | Middleware | TypeScript policy evaluator | Beide | +| C26 | Audit Trail | Middleware | PostgreSQL partitioned, crypto hash | Beide | +| C27 | Field Encryption | Middleware | AES-256-GCM (node:crypto) | EPD | +| C28 | FHIR Export | Middleware (API) | TypeScript mappers, FHIR R4 | EPD | +| C29 | CDS Hooks | Middleware (API) | CDS Hooks 1.0 spec | Platform | +| C30 | Observability | Middleware | Pino, OpenTelemetry | Beide | +| C31 | Circuit Breaker | Middleware | TypeScript (~50 regels) | Platform | +| C32 | Health Check | Middleware (API) | Next.js API route | Beide | +| C33 | PII Filter | Middleware | TypeScript regex, Pino serializer | Platform | +| C34 | Notificatie Service | Backend | SSE, BullMQ, Postal (SMTP) | EPD | +| C35 | Workflow Engine | Backend | TypeScript state machine | EPD | +| C36 | Full-Text Search | Backend (DB) | PostgreSQL tsvector (NL stemmer) | EPD | +| C37 | Caching Layer | Backend | Valkey (node-redis) | Beide | +| C38 | Scheduled Jobs | Backend | BullMQ repeatable jobs | Beide | +| C39 | Webhook System | Backend | BullMQ, HMAC-SHA256 | EPD | +| C40 | ZPM Facturatie | Backend | Drizzle ORM | EPD | +| C41 | Vecozo Connector | Backend | Interface + mock (voorbereiding) | EPD | +| C42 | Zorgdomein Connector | Backend | Interface + mock (voorbereiding) | EPD | +| C43 | BI Module | Backend (DB) | PostgreSQL Materialized Views | EPD | + +--- + +## Appendix: Relatie architectuurdocumenten + +``` +docs/architecture/ +│ +├── intent-system-architectuur-nl.md +│ → Hoe het intent systeem intern werkt (5 bouwblokken) +│ +├── enterprise-epd-architectuur.md +│ → Enterprise schil: multi-tenancy, audit, security, compliance +│ +├── usecases-technische-componenten.md +│ → 33 use cases × 43 componenten validatie + gap analyse +│ +├── platform-connectiviteit-selfhosted.md +│ → Self-hosted stack, platform splitsing, connector API +│ +├── enterprise-componenten-uitbreiding.md +│ → 10 nieuwe componenten (C34-C43): interfaces, schemas +│ +└── technische-invulling-componenten.md ← DIT DOCUMENT + → Alle 43 componenten: frontend/backend/API/middleware indeling + → Concrete technologiekeuzes, file structures, npm dependencies +``` diff --git a/docs/architecture/usecases-technische-componenten.md b/docs/architecture/usecases-technische-componenten.md new file mode 100644 index 0000000..632ef12 --- /dev/null +++ b/docs/architecture/usecases-technische-componenten.md @@ -0,0 +1,864 @@ +# Use Cases × Technische Componenten — Validatiematrix + +> **Type**: Architectuur Validatiedocument +> **Versie**: 1.0 +> **Datum**: 2026-02-14 +> **Doel**: Valideer of de enterprise architectuur alle use cases ondersteunt. Identificeer gaten. +> **Relatie**: Valideert `enterprise-epd-architectuur.md` en `intent-system-architectuur-nl.md` + +--- + +## 1. Use Case Catalogus + +Alle use cases uit de huidige codebase, uitgebreid met enterprise-scenario's die nog ontbreken. + +### 1.1 Bestaande use cases (geïmplementeerd in prototype) + +| ID | Use Case | Categorie | Intent | Status | +|----|----------|-----------|--------|--------| +| UC-01 | Dagnotitie aanmaken via spraak/tekst | Rapportage | `dagnotitie` | ✅ Volledig | +| UC-02 | Rapportage tijdlijn bekijken (per shift) | Rapportage | — (UI) | ✅ Volledig | +| UC-03 | Notitie markeren voor overdracht | Rapportage | — (UI) | ✅ Volledig | +| UC-04 | Overdracht overzicht bekijken | Overdracht | `overdracht` | ✅ Volledig | +| UC-05 | AI-samenvatting genereren voor overdracht | Overdracht | `overdracht` | ✅ Volledig | +| UC-06 | Bronverwijzing volgen vanuit AI-samenvatting | Overdracht | — (UI) | ✅ Volledig | +| UC-07 | Patiënt zoeken op naam/BSN | Zoeken | `zoeken` | ✅ Volledig | +| UC-08 | Patiëntdossier openen | Navigatie | — (UI) | ✅ Volledig | +| UC-09 | Agenda bekijken (vandaag/week) | Agenda | `agenda_query` | ✅ Volledig | +| UC-10 | Afspraak aanmaken | Agenda | `create_appointment` | ✅ Volledig | +| UC-11 | Afspraak annuleren | Agenda | `cancel_appointment` | ✅ Volledig | +| UC-12 | Afspraak verzetten | Agenda | `reschedule_appointment` | ✅ Volledig | +| UC-13 | Intake status bekijken | Intake | `intake_status` | ⚠️ MVP | +| UC-14 | Risicotaxatie bekijken | Intake | `risico_query` | ⚠️ MVP | +| UC-15 | Diagnoses bekijken | Intake | `diagnose_query` | ⚠️ MVP | +| UC-16 | Navigeren naar intake-sectie | Intake | `intake_navigeer` | ⚠️ MVP | +| UC-17 | Spraak-naar-tekst voor invoer | Invoer | — (Deepgram) | ✅ Volledig | +| UC-18 | Samengestelde opdracht (multi-intent) | Classificatie | Meerdere | ✅ Volledig | +| UC-19 | Context-afhankelijke verwijzingen ("hem", "haar") | Classificatie | — (Orchestrator) | ✅ Volledig | +| UC-20 | Nudge na actie (vervolgactie suggestie) | Protocol | — (Nudge) | ⚠️ Code bestaat, niet aangeroepen | + +### 1.2 Ontbrekende enterprise use cases + +| ID | Use Case | Categorie | Waarom nodig | +|----|----------|-----------|-------------| +| UC-21 | Behandelplan opstellen en bijwerken | Behandeling | Kernfunctie GGZ-EPD | +| UC-22 | Medicatieoverzicht bekijken/bijwerken | Medicatie | Wettelijk verplicht, hoog-risico | +| UC-23 | Incident/MIC-melding registreren | Veiligheid | Wkkgz verplichting | +| UC-24 | Wvggz-dwangmaatregel registreren | Juridisch | Wvggz verplichting | +| UC-25 | Toestemming registreren/intrekken | Juridisch | AVG + Wvggz | +| UC-26 | Audit log doorzoeken (compliance officer) | Audit | NEN 7513 verplichting | +| UC-27 | Patiëntdata exporteren (FHIR Bundle) | Interoperabiliteit | Dataportabiliteit (AVG) | +| UC-28 | Gebruikersbeheer (admin) | Beheer | Multi-tenancy | +| UC-29 | Protocolregel toevoegen/valideren | Knowledge | Protocol Engine beheer | +| UC-30 | Dashboard: team-overzicht per afdeling | Overzicht | Management informatie | +| UC-31 | Rapportage verwijderen (soft delete) + versioning | Rapportage | Wkkgz dossierplicht | +| UC-32 | Groepstherapie sessie rapporteren (meerdere patiënten) | Rapportage | GGZ-specifiek | +| UC-33 | Noodtoegang ("break the glass") | Beveiliging | NEN 7510, noodsituaties | + +--- + +## 2. Technische Componenten Register + +Alle componenten die de architectuur beschrijft, met hun verantwoordelijkheid en status. + +### 2.1 Component overzicht + +``` +LAAG 1: INTERFACE +├── C01 Traditionele EPD UI (Next.js pages + forms) +├── C02 Intent Command Center (⌘K overlay) +├── C03 Spraak Input (Deepgram integratie) +└── C04 Block/Artifact systeem (canvas + forms) + +LAAG 2: INTENT SYSTEEM +├── C05 Intent Registry (declaratieve definities) +├── C06 Reflex Classifier (lokale regex matching) +├── C07 Orchestrator (LLM classificatie) +├── C08 Entity Extractor + Date Parser +├── C09 Action System (intent → UI artifact mapping) +└── C10 Protocol Engine / Nudge + +LAAG 3: KNOWLEDGE LAYER +├── C11 Protocol Rules Store (gevalideerde regels) +├── C12 RAG Pipeline (protocol indexering + vector search) +├── C13 Regelvalidatie UI (admin) +└── C14 Kennisbron Connectors (wet/protocol/kwaliteitsdoc importers) + +LAAG 4: DOMEIN / BUSINESS LOGIC +├── C15 Rapportage Service (CRUD, versioning, soft delete) +├── C16 Overdracht Service (samenvatting generatie) +├── C17 Agenda Service (CRUD, conflictdetectie) +├── C18 Behandelplan Service +├── C19 Medicatie Service +├── C20 Intake Service +├── C21 Patiënt Service (CRUD, zoeken, toewijzing) +└── C22 Toestemming Service (Wvggz, AVG) + +LAAG 5: ENTERPRISE FUNDAMENT +├── C23 Auth + SSO (Supabase Auth, SAML) +├── C24 Multi-tenancy (RLS, tenant context) +├── C25 RBAC + ABAC Engine (policy evaluatie) +├── C26 Audit Trail (NEN 7513 immutable log) +├── C27 Field Encryption (AES-256-GCM) +├── C28 FHIR Export Service +├── C29 CDS Hooks Service +├── C30 Observability (Pino, OpenTelemetry) +├── C31 Circuit Breaker / Resilience +├── C32 Health Check Service +└── C33 PII Filter (sanitisatie voor AI prompts) + +LAAG 6: PLATFORM SERVICES (zie enterprise-componenten-uitbreiding.md) +├── C34 Notificatie Service (in-app + email + escalatie) +├── C35 Workflow Engine (state machine voor klinische workflows) +├── C36 Full-Text Search Service (klinische notities doorzoeken) +├── C37 Caching Layer (AI responses, API responses, sessiedata) +├── C38 Scheduled Jobs Service (BullMQ repeatable jobs) +└── C39 Webhook System (outbound event webhooks) + +LAAG 7: EXTERNE INTEGRATIES (zie enterprise-componenten-uitbreiding.md) +├── C40 ZPM Facturatie Service (Zorgprestatiemodel) +├── C41 Vecozo Connector (voorbereiding) +└── C42 Zorgdomein Connector (voorbereiding) + +LAAG 8: ANALYTICS (zie enterprise-componenten-uitbreiding.md) +└── C43 BI Module (materialized views, data-export) +``` + +### 2.2 Component status + +| Component | Prototype status | Enterprise gereed? | Werk nodig | +|-----------|-----------------|-------------------|------------| +| C01 EPD UI | Gedeeltelijk (rapportage, overdracht, agenda) | Nee | Uitbreiden: behandelplan, medicatie, admin | +| C02 Command Center | Volledig | Ja (refactor) | Store splitsen, Registry migratie | +| C03 Spraak Input | Volledig | Ja | Minimale wijzigingen | +| C04 Block/Artifact | Volledig | Ja | Uitbreiden met nieuwe block types | +| C05 Intent Registry | 40% (patronen verspreid over code) | Nee | **Kernwijziging**: centraliseren in config/DB | +| C06 Reflex Classifier | 85% werkend | Gedeeltelijk | Patronen naar Registry verplaatsen | +| C07 Orchestrator | 85% werkend | Gedeeltelijk | Prompt extractie, unified pipeline | +| C08 Entity Extractor | 60% werkend | Gedeeltelijk | Pattern tables externaliseren | +| C09 Action System | 70% werkend | Gedeeltelijk | Meer artifact types | +| C10 Protocol Engine | 30% (code niet aangeroepen) | Nee | **Nieuw bouwen** op basis van Knowledge Layer | +| C11 Protocol Rules Store | 0% | Nee | **Volledig nieuw** | +| C12 RAG Pipeline | 0% | Nee | **Volledig nieuw** | +| C13 Regelvalidatie UI | 0% | Nee | **Volledig nieuw** | +| C14 Kennisbron Connectors | 0% | Nee | **Volledig nieuw** | +| C15 Rapportage Service | 80% (CRUD werkt) | Nee | Versioning, multi-tenant | +| C16 Overdracht Service | 90% werkend | Gedeeltelijk | Multi-tenant, audit integratie | +| C17 Agenda Service | 80% werkend | Gedeeltelijk | Conflictdetectie, multi-tenant | +| C18 Behandelplan Service | 0% | Nee | **Volledig nieuw** | +| C19 Medicatie Service | 0% | Nee | **Volledig nieuw** | +| C20 Intake Service | 40% (MVP blocks) | Nee | Uitbreiden, multi-tenant | +| C21 Patiënt Service | 70% | Nee | Toewijzing, multi-tenant | +| C22 Toestemming Service | 0% | Nee | **Volledig nieuw** | +| C23 Auth + SSO | 60% (Supabase Auth) | Nee | SSO/SAML, MFA, session management | +| C24 Multi-tenancy | 0% | Nee | **Volledig nieuw** | +| C25 RBAC + ABAC | 10% (basis RLS) | Nee | **Grotendeels nieuw** | +| C26 Audit Trail | 0% | Nee | **Volledig nieuw** | +| C27 Field Encryption | 0% | Nee | **Volledig nieuw** | +| C28 FHIR Export | 10% (Patient endpoint) | Nee | Uitbreiden naar alle resources | +| C29 CDS Hooks | 0% | Nee | **Volledig nieuw** | +| C30 Observability | 10% (console.log) | Nee | **Grotendeels nieuw** | +| C31 Circuit Breaker | 20% (classifyWithTimeout) | Nee | Generaliseren | +| C32 Health Check | 0% | Nee | **Volledig nieuw** | +| C33 PII Filter | 40% (logger.ts sanitisatie) | Nee | Uitbreiden voor AI prompts | + +--- + +## 3. Validatiematrix — Use Case × Component + +Elke cel toont welke componenten een use case nodig heeft. **Rode cellen** zijn gaten. + +### 3.1 Rapportage use cases + +#### UC-01: Dagnotitie aanmaken via spraak/tekst + +``` +FLOW: +Zorgverlener spreekt/typt → "Notitie Jan medicatie onrustige nacht" + +┌─────────────┐ +│ C03 Spraak │ (optioneel) Audio → tekst +│ of C02 ⌘K │ Tekst invoer +└──────┬──────┘ + ▼ +┌──────────────┐ ┌──────────────┐ +│ C05 Registry │────►│ C06 Reflex │ Pattern match: "notitie" → dagnotitie +└──────────────┘ └──────┬───────┘ + │ confidence 0.9 + ▼ + ┌──────────────┐ + │ C08 Entity │ "Jan" → patient fuzzy match + │ Extractor │ "medicatie" → category + └──────┬───────┘ + ▼ + ┌──────────────┐ + │ C09 Action │ Open dagnotitie-block met prefill + │ System │ { patient: Jan, category: medicatie } + └──────┬───────┘ + ▼ + ┌──────────────┐ + │ C04 Block │ Formulier met vooringevulde data + │ (UI) │ Gebruiker bevestigt + voegt content toe + └──────┬───────┘ + │ [gebruiker klikt "Opslaan"] + ▼ + ┌──────────────┐ ┌──────────────┐ + │ C25 RBAC │────►│ C15 Rapportage│ Insert report + │ check │ │ Service │ shift_date berekend + └──────────────┘ └──────┬───────┘ + │ + ┌─────────────────────┤ + ▼ ▼ + ┌──────────────┐ ┌──────────────┐ + │ C26 Audit │ │ C10 Protocol │ Evalueer nudges + │ Trail │ │ Engine │ → "Check vitale functies?" + └──────────────┘ └──────────────┘ + +COMPONENTEN NODIG: C02/C03, C05, C06, C08, C09, C04, C25, C15, C26, C10 +GATEN: + 🔴 C05 Intent Registry bestaat niet als centraal component + 🔴 C25 RBAC check ontbreekt volledig + 🔴 C26 Audit trail ontbreekt volledig + 🔴 C10 Protocol Engine is niet aangesloten (code bestaat, niet aangeroepen) + 🟡 C15 Rapportage Service mist versioning en multi-tenant +``` + +#### UC-05: AI-samenvatting genereren voor overdracht + +``` +FLOW: +Zorgverlener → "Overdracht" of klikt in UI + +┌─────────────┐ +│ C02 ⌘K │ of C01 UI → navigatie naar overdracht pagina +└──────┬──────┘ + ▼ +┌──────────────┐ ┌──────────────┐ +│ C06 Reflex │────►│ C09 Action │ Open overdracht-block +└──────────────┘ └──────┬───────┘ + ▼ + ┌──────────────┐ + │ C16 Overdracht│ Haal patiëntenlijst op + │ Service │ Filter op afdeling/dienst + └──────┬───────┘ + │ [voor elke actieve patiënt] + ▼ + ┌──────────────┐ + │ C33 PII │ Minimaliseer patiëntdata voor AI + │ Filter │ + └──────┬───────┘ + ▼ + ┌──────────────┐ + │ C07 Claude │ Genereer samenvatting + │ API │ Aandachtspunten + actiepunten + └──────┬───────┘ + │ + ┌──────┴───────┐ + ▼ ▼ + ┌──────────────┐ ┌──────────────┐ + │ C26 Audit │ │ C04 Block │ Render samenvatting + │ Trail │ │ (UI) │ met bronverwijzingen + └──────────────┘ └──────────────┘ + +COMPONENTEN NODIG: C01/C02, C06, C09, C16, C33, C07 (Claude), C26, C04 +GATEN: + 🔴 C26 Audit trail ontbreekt — wie heeft welke samenvatting gegenereerd? + 🔴 C33 PII filter is onvolledig — welke data gaat naar Claude? + 🟡 C16 Overdracht Service mist tenant-filtering + 🟡 Geen caching — elke keer opnieuw genereren is duur +``` + +#### UC-31: Rapportage verwijderen + versioning + +``` +FLOW: +Zorgverlener wil rapport wijzigen of verwijderen + +┌─────────────┐ +│ C01 UI │ Klik op "bewerken" of "verwijderen" in tijdlijn +└──────┬──────┘ + ▼ +┌──────────────┐ +│ C25 RBAC │ Mag deze gebruiker dit rapport wijzigen? +│ + ABAC │ Check: auteur OF hoofdbehandelaar OF admin +└──────┬───────┘ + ▼ +┌──────────────┐ +│ C15 Rapportage│ WIJZIGEN: nieuwe versie aanmaken +│ Service │ → version++, previous_version_id link +│ │ VERWIJDEREN: soft delete (deleted_at) +│ │ → NOOIT hard delete (Wkkgz) +└──────┬───────┘ + ▼ +┌──────────────┐ +│ C26 Audit │ Log: wie, wat, wanneer, waarom +│ Trail │ + data_before / data_after snapshot +└──────────────┘ + +COMPONENTEN NODIG: C01, C25, C15, C26 +GATEN: + 🔴 C15 Rapportage Service heeft GEEN versioning (alleen soft delete) + 🔴 C25 Eigenaarschap-check ontbreekt + 🔴 C26 Audit trail ontbreekt — geen bewijs van wijzigingen +``` + +### 3.2 Enterprise use cases (nieuw) + +#### UC-23: Incident/MIC-melding registreren + +``` +FLOW: +Zorgverlener → "Incident melding: patiënt gevallen op kamer 3" + +┌─────────────┐ +│ C02 ⌘K │ "incident melding patiënt gevallen" +└──────┬──────┘ + ▼ +┌──────────────┐ +│ C06 Reflex │ Pattern: "incident" / "melding" / "MIC" / "gevallen" +│ │ → intent: NEW "incident_melding" (ONTBREEKT) +└──────┬───────┘ + ▼ +┌──────────────┐ +│ C08 Entity │ Extraheer: patiënt, locatie, type incident +│ Extractor │ "gevallen" → incident_type: "val" +└──────┬───────┘ + ▼ +┌──────────────┐ +│ C09 Action │ Open incident-formulier (ONTBREEKT) +│ │ Velden: patiënt, datum/tijd, locatie, beschrijving, +│ │ ernst, getuigen, maatregelen genomen +└──────┬───────┘ + │ [gebruiker bevestigt] + ▼ +┌──────────────┐ ┌──────────────┐ +│ C15 Rapportage│ │ C26 Audit │ +│ report_type:│ │ Trail │ +│ 'incident' │ └──────────────┘ +└──────┬───────┘ + ▼ +┌──────────────┐ +│ C10 Protocol │ Nudges: +│ Engine │ → "Valpreventie protocol activeren?" +│ │ → "Informeer hoofdbehandelaar" +│ │ → "Plan follow-up observatie" +└──────────────┘ + +COMPONENTEN NODIG: C02, C06, C08, C09, C04, C15, C26, C10 +NIEUWE COMPONENTEN NODIG: + 🔴 Intent 'incident_melding' toevoegen aan Registry + 🔴 Incident-formulier block (UI component) + 🔴 Protocol rules voor incidentopvolging + 🟡 Ernst-classificatie schema + 🟡 Notificatie naar hoofdbehandelaar (C-NEW: Notificatie Service) +``` + +#### UC-24: Wvggz-dwangmaatregel registreren + +``` +FLOW: +Arts → Registreer dwangmaatregel (bijv. separatie, gedwongen medicatie) + +┌─────────────┐ +│ C01 UI │ Via traditionele formulier (te complex voor intent) +│ │ OF C02 ⌘K → "dwangmaatregel registreren [patient]" +└──────┬──────┘ + ▼ +┌──────────────┐ +│ C25 RBAC │ Check: alleen arts/psychiater mag dwangmaatregel registreren +│ + ABAC │ Check: patiënt heeft Wvggz legal_status +│ │ Check: toestemming/machtiging is actief (C22) +└──────┬───────┘ + ▼ +┌──────────────┐ +│ NEW: C34 │ Dwangmaatregel formulier +│ Wvggz Service │ Velden: type maatregel, start/eind, reden, +│ │ alternatieven overwogen, proportionaliteit +│ │ Juridische grondslag (zorgmachtiging nr.) +└──────┬───────┘ + ▼ +┌──────────────┐ ┌──────────────┐ +│ C22 Toestem- │ │ C26 Audit │ EXTRA LOGGING: +│ ming Service│ │ Trail │ Wvggz-maatregel = P1 audit event +│ Verify OK │ │ │ purpose: 'wvggz_dwangmaatregel' +└──────────────┘ └──────────────┘ + ▼ +┌──────────────┐ +│ C10 Protocol │ Nudges: +│ Engine │ → "Plan evaluatie dwangmaatregel (binnen 24u)" +│ │ → "Informeer geneesheer-directeur" +│ │ → "Registreer in Wvggz-register" +└──────────────┘ + +NIEUWE COMPONENTEN NODIG: + 🔴 C34 Wvggz Service (registratie, evaluatie, rapportage) + 🔴 C22 Toestemming Service (verificatie juridische grondslag) + 🔴 Wvggz-specifieke ABAC policies + 🔴 Protocol rules voor Wvggz-termijnen + 🔴 Notificatie naar geneesheer-directeur +``` + +#### UC-26: Audit log doorzoeken + +``` +FLOW: +Compliance officer → "Wie heeft dossier patiënt X bekeken afgelopen maand?" + +┌─────────────┐ +│ C01 UI │ Admin → Audit log pagina +│ (admin) │ Zoekfilters: patiënt, gebruiker, periode, actie +└──────┬──────┘ + ▼ +┌──────────────┐ +│ C25 RBAC │ Check: rol = 'audit' of 'admin' +│ │ Audit officers hebben read-only toegang tot ALLE logs +└──────┬───────┘ + ▼ +┌──────────────┐ +│ C26 Audit │ Query: forensische zoekopdracht +│ Trail │ Filters: entity_type, entity_id, user_id, date range +│ │ Resultaat: gesorteerd op timestamp +└──────┬───────┘ + ▼ +┌──────────────┐ +│ C26 Audit │ META: het doorzoeken van de audit log +│ Trail │ wordt ZELF ook gelogd (wie zoekt wat op) +└──────────────┘ + +COMPONENTEN NODIG: C01, C25, C26 +GATEN: + 🔴 C26 Audit log UI (admin pagina) ontbreekt volledig + 🔴 Export functie (CSV/PDF voor externe auditor) + 🟡 Anomalie-detectie dashboard +``` + +#### UC-33: Noodtoegang ("break the glass") + +``` +FLOW: +Arts in noodsituatie → toegang nodig tot patiënt die niet is toegewezen + +┌─────────────┐ +│ C01 UI │ Patiëntdossier → "Geen toegang" melding +│ │ → Knop: "Noodtoegang aanvragen" +└──────┬──────┘ + ▼ +┌──────────────┐ +│ C25 RBAC │ Normale check FAALT (niet toegewezen) +│ + ABAC │ → Noodtoegang flow activeren +└──────┬───────┘ + ▼ +┌──────────────────────────────────────┐ +│ NEW: Break-the-Glass Dialog │ +│ "U bent niet toegewezen aan deze │ +│ patiënt. Noodtoegang vereist een │ +│ reden." │ +│ │ +│ Reden: [dropdown] │ +│ - Medisch noodgeval │ +│ - Dienstdoend arts (geen toewijzing) │ +│ - Vervanging collega │ +│ Toelichting: [vrij tekstveld] │ +│ │ +│ [Annuleren] [Noodtoegang activeren] │ +└──────┬───────────────────────────────┘ + │ [gebruiker bevestigt] + ▼ +┌──────────────┐ +│ C26 Audit │ P1 AUDIT EVENT: +│ Trail │ action: 'emergency_access' +│ │ purpose: reden uit formulier +│ │ → Automatische notificatie naar privacy officer +└──────┬───────┘ + ▼ +┌──────────────┐ +│ C21 Patiënt │ Tijdelijke toegang (bijv. 4 uur) +│ Service │ Auto-expire na timeout +└──────────────┘ + +NIEUWE COMPONENTEN NODIG: + 🔴 Break-the-glass UI component + 🔴 Tijdelijke toegang mechanisme in C25 + 🔴 Automatische notificatie service + 🔴 Auto-expire logica +``` + +--- + +## 4. Gap Analyse — Samenvatting + +### 4.1 Kritieke gaten (blokkeren enterprise deployment) + +| # | Gap | Impact | Benodigde componenten | Inspanning | +|---|-----|--------|----------------------|------------| +| G1 | **Geen audit trail** | NEN 7513 niet-compliant, geen bewijs bij audit | C26 volledig bouwen | 2-3 weken | +| G2 | **Geen multi-tenancy** | Kan niet bij meerdere instellingen draaien | C24 volledig bouwen | 2-3 weken | +| G3 | **Geen RBAC/ABAC** | Iedereen ziet alles, geen rolgebaseerde toegang | C25 volledig bouwen | 2-3 weken | +| G4 | **Intent Registry ontbreekt** | Patronen verspreid over 3-4 bestanden | C05 centraliseren | 2-3 dagen | +| G5 | **Protocol Engine niet actief** | Nudges bestaan maar worden nooit getoond | C10 aansluiten + C11 rules store | 1-2 weken | +| G6 | **Geen versioning op rapportages** | Wijzigingsgeschiedenis niet traceerbaar | C15 uitbreiden | 3-5 dagen | +| G7 | **Geen field encryptie** | BSN en diagnoses onversleuteld in DB | C27 bouwen | 1 week | + +### 4.2 Functionele gaten (ontbrekende GGZ-modules) + +| # | Gap | Impact | Inspanning | +|---|-----|--------|------------| +| G8 | **Behandelplan module** | Kernfunctie GGZ ontbreekt volledig | C18: 3-4 weken | +| G9 | **Medicatie module** | Wettelijk verplicht, hoog-risico domein | C19: 3-4 weken | +| G10 | **Wvggz registratie** | Kan geen verplichte zorg registreren | C34 + C22: 2-3 weken | +| G11 | **Incident/MIC module** | Wkkgz niet-compliant | Uitbreiding C15 + intent: 1-2 weken | +| G12 | **Knowledge Layer** | Geen protocol-gestuurde nudges | C11-C14: 4-6 weken | + +### 4.3 Technische gaten + +| # | Gap | Impact | Inspanning | +|---|-----|--------|------------| +| G13 | **Geen SSO/SAML** | Enterprise instellingen vereisen SSO | C23 uitbreiden: 1 week | +| G14 | **Geen structured logging** | Console.log in productie = blind vliegen | C30: 1 week | +| G15 | **Geen health checks** | Geen alerting bij uitval | C32: 2-3 dagen | +| G16 | **Circuit breaker incompleet** | Alleen voor classify, niet generiek | C31 generaliseren: 3-5 dagen | +| G17 | **PII filter incompleet** | Patiëntdata lekt naar AI prompts | C33 uitbreiden: 3-5 dagen | +| G18 | **Geen FHIR Bundle export** | Alleen Patient endpoint, rest ontbreekt | C28 uitbreiden: 1-2 weken | +| G19 | **Geen notificatie service** | Geen alerts bij incidenten, Wvggz-termijnen | Nieuw component: 1-2 weken | +| G20 | **Geen caching** | AI samenvattingen elke keer opnieuw genereren | Cache layer toevoegen: 3-5 dagen | + +--- + +## 5. Use Case × Component Kruistabel + +Welk component is nodig voor welke use case? `●` = nodig, `○` = optioneel, `-` = niet relevant. + +``` + UC UC UC UC UC UC UC UC UC UC UC UC UC +Component 01 05 07 10 11 21 23 24 26 27 31 32 33 + dag ovdr zoek afsp ann beh inc wvgz aud fhir ver grp nood +───────────────────────────────────────────────────────────────────────────── +C01 EPD UI ○ ● ○ ○ ○ ● ● ● ● ● ● ● ● +C02 Command Center ● ● ● ● ● ○ ● ○ - - - ○ - +C03 Spraak ○ - - - - - ○ - - - - ○ - +C04 Block/Artifact ● ● ● ● ● - ● - - - - - - +C05 Intent Registry ● ● ● ● ● - ● - - - - - - +C06 Reflex ● ● ● ● ● - ● - - - - - - +C07 Orchestrator ○ ○ ○ ○ ○ - ○ - - - - - - +C08 Entity Extract ● - ● ● ● - ● - - - - - - +C09 Action System ● ● ● ● ● - ● - - - - - - +C10 Protocol Engine ● ● - - - ● ● ● - - - - - +C15 Rapportage Svc ● ● - - - - ● - - - ● ● - +C16 Overdracht Svc - ● - - - - - - - - - - - +C17 Agenda Svc - - - ● ● - - - - - - - - +C18 Behandelplan - - - - - ● - - - ○ - - - +C21 Patiënt Svc ● ● ● ● - ● ● ● - ● - - ● +C22 Toestemming - - - - - - - ● - - - - - +C24 Multi-tenancy ● ● ● ● ● ● ● ● ● ● ● ● ● +C25 RBAC/ABAC ● ● ● ● ● ● ● ● ● ● ● ● ● +C26 Audit Trail ● ● ● ● ● ● ● ● ● ● ● ● ● +C27 Field Encrypt - - ○ - - - - ● - ● - - - +C28 FHIR Export - - - - - - - - - ● - - - +C30 Observability ● ● ● ● ● ● ● ● ● ● ● ● ● +C31 Circuit Breaker ○ ● - - - - - - - - - - - +C33 PII Filter ○ ● - - - - - - - - - - - +C34 Wvggz Svc - - - - - - - ● - - - - - +``` + +**Leeswijzer**: C24 (Multi-tenancy), C25 (RBAC), C26 (Audit) en C30 (Observability) zijn nodig voor **elke** use case. Dit zijn de vier horizontale lagen die als eerste gebouwd moeten worden. + +--- + +## 6. Bouwvolgorde — Prioritering op basis van gaps + +### Fase 0: Horizontale lagen (weken 1-4) + +Bouw de vier componenten die **elke** use case nodig heeft: + +``` +Week 1-2: C24 Multi-tenancy (RLS, tenant context middleware) + C26 Audit Trail (immutable log, NEN 7513) + +Week 3-4: C25 RBAC + ABAC Engine (rollen, policies, evaluatie) + C30 Observability (Pino structured logging) +``` + +**Waarom eerst**: Zonder deze vier werkt geen enkele enterprise use case. Retrofit is exponentieel duurder. + +### Fase 1: Intent systeem solide maken (weken 5-6) + +``` +Week 5: C05 Intent Registry (centraliseer patronen uit reflex-classifier) + C06 Reflex refactor (lees uit Registry) + C07 Orchestrator refactor (unified pipeline met Classify) + +Week 6: C10 Protocol Engine activeren (nudge.ts aansluiten) + C15 Rapportage versioning + soft delete (G6) + C33 PII Filter uitbreiden +``` + +**Na deze fase**: UC-01 t/m UC-20 werken enterprise-grade. + +### Fase 2: Ontbrekende GGZ-modules (weken 7-12) + +``` +Week 7-8: C18 Behandelplan Service (UC-21) + C19 Medicatie Service (UC-22) + +Week 9-10: C22 Toestemming Service (UC-25) + C34 Wvggz Service (UC-24) + UC-23 Incident/MIC formulier + +Week 11-12: C27 Field Encryption (BSN, diagnoses) + C23 Auth uitbreiden (SSO/SAML, MFA) + UC-33 Break-the-glass noodtoegang +``` + +### Fase 3: Knowledge Layer + interoperabiliteit (weken 13-18) + +``` +Week 13-14: C11 Protocol Rules Store (database) + C13 Regelvalidatie UI (admin) + +Week 15-16: C12 RAG Pipeline (pgvector, protocol indexering) + C14 Kennisbron Connectors (eerste protocollen inladen) + +Week 17-18: C28 FHIR Export (alle resources) + C29 CDS Hooks Service + C32 Health Check + C31 Circuit Breaker generaliseren +``` + +--- + +## 7. Technische Specificaties per Component + +### 7.1 C24 Multi-tenancy — Specificatie + +**Verantwoordelijkheid**: Isoleer data per instelling/tenant. + +**Database wijzigingen**: +- `tenant_id UUID NOT NULL` kolom op ELKE tabel met patiëntdata +- RLS policy per tabel: `USING (tenant_id = get_current_tenant())` +- Helper function: `get_current_tenant()` leest uit `app.current_tenant_id` setting + +**Middleware**: +```typescript +// Elke request: +// 1. Haal user op uit Supabase Auth +// 2. Lees tenant_id uit user metadata +// 3. Zet als header voor Server Components +// 4. Zet als PostgreSQL setting voor RLS +``` + +**Bestanden**: +- `lib/auth/tenant-context.ts` — Helper om tenant te zetten/lezen +- `middleware.ts` — Injecteer tenant in elke request +- Migratie: `add_tenant_id_to_all_tables.sql` +- Migratie: `create_rls_policies.sql` + +**Test**: Maak twee tenants, voeg patiënt toe aan tenant A, verifieer dat tenant B de patiënt NIET kan zien. + +--- + +### 7.2 C26 Audit Trail — Specificatie + +**Verantwoordelijkheid**: Onwijzigbare log van alle toegang en wijzigingen aan patiëntdata. + +**Database**: +- Tabel `audit_logs` (zie enterprise-epd-architectuur.md §5.2) +- Partitionering per maand +- Triggers die UPDATE/DELETE blokkeren +- Hash chain voor integriteitsverificatie + +**API**: +```typescript +// lib/audit/logger.ts +logAuditEvent({ entityType, entityId, action, purpose, cortexIntent?, metadata? }) + +// Automatisch: +// - user_id, user_role, user_name uit auth context +// - tenant_id uit tenant context +// - timestamp server-side +// - data_hash berekend +// - previous_hash opgehaald +``` + +**Integratiepunten**: Elke API route roept `logAuditEvent()` aan na succesvolle actie. Dit is een **hard requirement** — geen route zonder audit log. + +**Bestanden**: +- `lib/audit/logger.ts` — Core logging functie +- `lib/audit/hash.ts` — Hash chain berekening +- `app/api/audit/route.ts` — Query endpoint (admin only) +- Migratie: `create_audit_logs.sql` + +--- + +### 7.3 C25 RBAC + ABAC — Specificatie + +**Verantwoordelijkheid**: Bepaal of een gebruiker een actie mag uitvoeren op een resource. + +**Twee lagen**: +1. **RBAC** (snel): Rol → vaste permissions set +2. **ABAC** (verfijnd): Context-afhankelijke policies (toewijzing, toestemming, tijdvenster) + +**API**: +```typescript +// lib/access-control/evaluator.ts +const { allowed, reason } = await evaluateAccess({ + userId, action, resource, resourceId, tenantId +}); + +if (!allowed) { + return Response.json({ error: 'Geen toegang', reason }, { status: 403 }); +} +``` + +**Bestanden**: +- `lib/access-control/roles.ts` — Rol definities en basis permissions +- `lib/access-control/policies.ts` — ABAC policy definities +- `lib/access-control/evaluator.ts` — Policy evaluatie engine +- Migratie: `create_access_policies.sql` + +--- + +### 7.4 C05 Intent Registry — Specificatie + +**Verantwoordelijkheid**: Single source of truth voor alle intent definities. + +**Structuur per intent**: +```typescript +interface IntentDefinition { + id: CortexIntent; // 'dagnotitie', 'zoeken', etc. + label: { nl: string; en: string }; // Mensleesbare labels + description: string; // Voor LLM context + priority: 'P1' | 'P2' | 'P3'; + + // Reflex patterns + reflexPatterns: Array<{ + pattern: RegExp; + weight: number; + extractHints?: string[]; // Welke entities te extracten + }>; + + // Orchestrator hints + aiExamples: Array<{ + input: string; + expectedIntent: CortexIntent; + expectedEntities: Record; + }>; + + // Entity configuratie + entities: { + required: string[]; // Welke entities verplicht + optional: string[]; + }; + + // Action mapping + artifactType: string; // Welk block/formulier openen + requiresConfirmation: boolean; // Destructieve actie? + + // Access control + allowedRoles?: string[]; // Welke rollen mogen dit intent gebruiken + featureFlag?: string; // Feature flag voor geleidelijke uitrol + enabled: boolean; +} +``` + +**Opslag**: TypeScript config file (fase 1), migreerbaar naar database (fase 3). + +**Bestanden**: +- `lib/cortex/registry/intent-registry.ts` — Registry class +- `lib/cortex/registry/definitions/dagnotitie.ts` — Per intent een definitie +- `lib/cortex/registry/definitions/zoeken.ts` +- `lib/cortex/registry/definitions/index.ts` — Barrel export +- `lib/cortex/registry/types.ts` — IntentDefinition interface + +--- + +### 7.5 C10 Protocol Engine — Specificatie + +**Verantwoordelijkheid**: Evalueer klinische regels na afgeronde acties. Stel vervolgacties voor. + +**Pure function**: `(completedAction, patientContext, rules) → suggestions[]` + +**Regel evaluatie**: +```typescript +// lib/cortex/protocol-engine/evaluator.ts + +async function evaluateRules( + completedAction: CompletedAction, + patientContext: PatientContext, + rules: ProtocolRule[] +): Promise { + + const applicableRules = rules.filter(rule => + rule.status === 'actief' && + rule.trigger.afterIntent?.includes(completedAction.intent) + ); + + const suggestions: NudgeSuggestion[] = []; + + for (const rule of applicableRules) { + const conditionMet = await evaluateCondition(rule.condition, patientContext); + if (conditionMet) { + suggestions.push({ + ruleId: rule.id, + message: rule.suggestion.message, + priority: rule.suggestion.priority, + evidence: rule.suggestion.evidence, + suggestedIntent: rule.suggestion.suggestedIntent, + source: rule.source, + }); + } + } + + return suggestions.sort((a, b) => + a.priority.localeCompare(b.priority) // P1 eerst + ); +} +``` + +**Bestanden**: +- `lib/cortex/protocol-engine/evaluator.ts` — Rule evaluatie +- `lib/cortex/protocol-engine/conditions.ts` — Conditie evaluatie (static + query) +- `lib/cortex/protocol-engine/rules/` — Gevalideerde regels per domein +- `app/api/cortex/nudge/route.ts` — API endpoint + +--- + +## 8. Validatie Conclusie + +### De architectuur ondersteunt alle use cases MITS: + +1. **De vier horizontale lagen eerst gebouwd worden** (G1-G3 + G14): multi-tenancy, audit, RBAC, logging +2. **Het intent systeem gecentraliseerd wordt** (G4): Intent Registry als single source of truth +3. **De Protocol Engine aangesloten wordt** (G5): nudge.ts → protocol-engine met rules store +4. **Ontbrekende GGZ-modules gebouwd worden** (G8-G12): behandelplan, medicatie, Wvggz, incidenten + +### Wat de architectuur GOED doet: + +- Dual interface (traditioneel + intent) ondersteunt alle use cases via twee paden +- De pipeline (Registry → Classify → Resolve → Action → Protocol) is generiek genoeg voor nieuwe intents +- Multi-tenancy via RLS is pragmatisch en past bij Supabase +- Audit trail als horizontale laag dekt alle use cases zonder per-module implementatie + +### Wat nog aandacht nodig heeft: + +- ~~**Notificatie service** (niet in architectuur): incidenten, Wvggz-termijnen, break-the-glass alerts~~ → **Opgelost: C34** (zie `enterprise-componenten-uitbreiding.md`) +- **Groepstherapie** (UC-32): één rapportage voor meerdere patiënten — huidige datamodel is 1:1 +- ~~**Caching strategie**: AI-samenvattingen zijn duur, caching ontbreekt in architectuur~~ → **Opgelost: C37** (zie `enterprise-componenten-uitbreiding.md`) +- **Offline support**: niet besproken, maar relevant voor mobiele zorgverleners + +### Uitbreiding: 10 nieuwe componenten (C34–C43) + +Na de initiële gap analyse zijn 10 aanvullende enterprise componenten geïdentificeerd en gespecificeerd. Deze zijn gedocumenteerd in **`enterprise-componenten-uitbreiding.md`** en omvatten: + +| Component | Laag | Status | +|-----------|------|--------| +| C34 Notificatie Service | Platform Services | Interface gedefinieerd | +| C35 Workflow Engine (State Machine) | Platform Services | Interface + voorbeeldworkflows | +| C36 Full-Text Search | Platform Services | Interface + PostgreSQL tsvector schema | +| C37 Caching Layer | Platform Services | Interface + TTL strategie | +| C38 Scheduled Jobs | Platform Services | Interface + job definities | +| C39 Webhook System | Platform Services | Interface + security (HMAC) | +| C40 ZPM Facturatie | Externe Integraties | Interface + database schema | +| C41 Vecozo Connector | Externe Integraties | Interface + mock (voorbereiding) | +| C42 Zorgdomein Connector | Externe Integraties | Interface + mock (voorbereiding) | +| C43 BI Module | Analytics | Materialized views gedefinieerd | + +De gap items G19 (notificatie) en G20 (caching) uit §4.3 zijn hiermee opgelost. Zie het uitbreidingsdocument voor volledige interface definities, database schemas en integratiepunten. diff --git a/docs/releasenotes/RELEASE_INTAKE_BEHANDELPLAN.md b/docs/releasenotes/RELEASE_INTAKE_BEHANDELPLAN.md new file mode 100644 index 0000000..3e7fde4 --- /dev/null +++ b/docs/releasenotes/RELEASE_INTAKE_BEHANDELPLAN.md @@ -0,0 +1,129 @@ +# Release Notes – Intake & Behandelplan +**Datum:** 9 maart 2026 | **Doelgroep:** Behandelaars + +--- + +## Wat is er nieuw? + +Deze release levert een volledige intake-werkruimte en een AI-ondersteund behandelplan. Samen vormen ze één doorgaande lijn: van eerste screening tot actief behandelplan met SMART-doelen. + +--- + +## Cliëntenoverzicht + +Het overzicht van alle cliënten is uitgebreid met filters en statusinformatie, zodat je snel ziet waar een cliënt in het traject staat. + +**Nieuw:** +- **Statusbadges** per cliënt: *Actief*, *Screening* of *Afgemeld* — direct zichtbaar in de lijst +- **Filteren** op status én geslacht via de filterbalk +- **Zoeken** op naam of BSN +- Kolom "Laatst gewijzigd" toont datum en tijdstip van de meest recente aanpassing + +--- + +## Patiëntdashboard + +Per cliënt is er nu een overzichtspagina die als startpunt dient voor het hele zorgtraject. + +**Nieuw:** +- Drie snelkoppelingen: *Basisgegevens*, *Screening*, *Intake* +- Sectie **Recente Intakes** met titel, afdeling, datum en status (*bezig* / *afgerond*) +- Sectie **Agenda Afspraken** met aankomende en recente afspraken inclusief type en tijdstip +- Preview van het **actieve behandelplan** en een "Volgende stappen"-blok + +--- + +## Intake + +De intakewerkruimte bestaat uit negen tabs die het volledige diagnostisch traject dekken. Je werkt ze niet verplicht op volgorde af — je kunt altijd naar elke tab navigeren. + +### Tabs + +| Tab | Wat je hier doet | +|---|---| +| **Algemeen** | Titel, afdeling, status en startdatum van de intake; notitieveld | +| **Contactmomenten** | Registreer gesprekken (datum, tijd, type, locatie, notities) | +| **Kindcheck** | Vastleggen of er kinderen betrokken zijn, zorgen en ondernomen acties | +| **Risicotaxatie** | Risico's per type met ernst (laag / middel / hoog) en vervolgacties | +| **Anamnese** | Psychiatrische, sociale en familiegeschiedenis | +| **Onderzoeken** | Psychodiagnostisch onderzoek met type, datum en uitkomst | +| **ROM** | Outcome-meting met scores per instrument | +| **Diagnose** | ICD-10 diagnoses met hoofd- en nevendiagnose, ernst en datum | +| **Behandeladvies** | Advies, aanbevolen behandeling, gekoppelde psycholoog en programma | + +### Diagnoses registreren + +- Zoek en koppel een **ICD-10 code** via de zoekbalk (combobox) +- Markeer één diagnose als **hoofddiagnose**; overige worden als nevendiagnose geregistreerd +- Registreer de **ernst**: mild, matig of ernstig +- Meerdere diagnoses per intake zijn mogelijk; de hoofddiagnose staat altijd bovenaan + +--- + +## Behandelplan + +Het behandelplan is het hart van de behandeling. Je kunt een plan **handmatig opbouwen** of laten **genereren door AI** op basis van de intake. + +### AI-gegenereerd plan + +Via de knop **"Genereer met AI"** maakt het systeem een volledig conceptplan aan. De AI (Claude) gebruikt hiervoor: + +- De intakenotities en het behandeladvies +- De gestelde **ICD-10 diagnose** en ernst +- De **leefgebiedenscores** (zie hieronder) +- Eventuele extra instructies die je zelf meegeeft (max. 500 tekens) + +Het gegenereerde plan bevat: +- **SMART-behandeldoelen** met bijbehorende interventies +- Een **behandelstructuur** (duur, frequentie, sessievorm) +- **Evaluatiemomenten** (tussentijds en eindevaluatie) +- Een **veiligheidsplan** — automatisch meegenomen bij een ernstige diagnose + +Het plan wordt aangemaakt als concept; je kunt het volledig aanpassen vóór publicatie. + +### Leefgebieden + +Bij het opstellen van een behandelplan scoor je zeven leefgebieden op een schaal van 0–10 en geef je per domein een prioriteit mee: + +- Dagelijkse Levensvaardigheden +- Gezondheid +- Werk & Activiteiten +- Huisvesting +- Sociale Relaties +- Maatschappelijke Participatie +- Veiligheid + +Deze scores kleuren het behandelplan: de AI koppelt doelen automatisch aan de domeinen met de hoogste prioriteit. + +### Behandeldoelen + +Per doel leg je vast: +- Titel en omschrijving +- Gekoppeld leefgebied en prioriteit +- Voortgang (0–100 %) en status: *Niet gestart* / *Bezig* / *Gehaald* +- Eindweek +- Bijbehorende **interventies** (inline, per doel) + +### Versiebeheer + +- Elk behandelplan krijgt een versienummer (v1, v2, …) +- Je kunt een nieuw concept aanmaken terwijl het vorige plan actief blijft +- Statussen: *Concept*, *Actief*, *On hold*, *Afgerond*, *Ingetrokken* +- Alle versies blijven raadpleegbaar via de versieselectie in het zijpaneel + +### Planning & Evaluatie + +In het uitklapbare blok "Planning & Evaluatie" vind je: +- **Behandelstructuur**: duur van het traject, sessiefrequentie, aantal sessies en vorm (individueel / groep / online) +- **Sessieplanning**: per sessie een nummer, focus en datum +- **Evaluatiemomenten**: week en type (tussentijds / eind / crisis), met status *gepland* of *afgerond* +- **Veiligheidsplan**: waarschuwingssignalen, copingstrategieën, noodcontacten en afgesproken restricties + +--- + +## Bekende beperkingen + +- **Behandeldoelen** starten leeg bij een nieuw handmatig plan; sjablonen zijn nog niet beschikbaar. +- **Sortering en dubbele-codevalidatie** bij diagnoses volgt in een volgende release. +- Het **notitieveld** in de Algemeen-tab ondersteunt nog geen opmaak (geen vetgedrukte tekst, lijsten, e.d.). +- AI-generatie vereist dat er minimaal een intake met notities aanwezig is; zonder intake-context is het resultaat beperkt. diff --git a/docs/releasenotes/Release_Intake_Behandelplan.docx b/docs/releasenotes/Release_Intake_Behandelplan.docx new file mode 100644 index 0000000000000000000000000000000000000000..b90ecbe69a389f6e6277987b524134fc973a2018 GIT binary patch literal 675600 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℞4^QkdcXnnHlX@@^Pq|fZMAQ(!Dk7M z_gid0k3sKntQv#h0{cDUQXpav%aR0#F!%eoPeKspj4SL&PK%PROOnM3z_>}VeWfjoJ}pqle}$AT3`j8Camr6%1mA9F zG~s6yCJ7q9>15t%-QEiDtM`>OY=AUxzBV%jN3@>7wAQaVFQwk-1h1BYMfulorN)Bf zx*exz5gnKf$d)YTOiZ0ki&YY$b1y=|Lzcaq5kd9(8fICjkVJb^zS5m~wf$9gsoq8} z)V=%!R?-uDqhD>tfeSfm+_xpgCi@}xTB1P@VSdhAsUT+Bhr-m}I%~uf@43$d9?s35 zUnWvh0~xRSv3azx)5{yd3BX+Bx>QWvgR^eT@s%l|{d9cq9erV-e$R&9H{R+4cVr`d zW0<$%@uj(;tLltmBbZX#%O4LV3VA4H_g{qttY4eryKJ1H54<=+h=qbHkBE&80Wqc- z`y=x_d~_8Xek$lG^-j^@va^P@LGHH<8AEZNlx&HRS&Bh=HV#l%1Cfh%b0GG_b@BUQSL~Rr_^KY(vs&AbR)oH~Fk2_W6pwcB68pX)zG92hrsriQ z92RfRHeEV_aHYv`5}VaDIo=*h&Odg?q%xUmL=mb^66t`@J(it3fXBg4R4X zjq}#NM1${MEekQ~tkY2T6(^e2geja2+vPuC;usOaalGeqm?I&ja6J5AP#>3F>cZ-A zOyT>|#bf>a^Qde~4h)cTfryr`ww-_AhDO~3+Tu1tCh?e3IlFV_$3d(zCn{e5T z#5V$N_38OQZIN5Pj_@b*l1{nk>^fZ2)>hFw`B9_OdHIAEyv~~Ajr+!vXXm>k**mk8 zjj;2u<*MI4o}X6LeQ8%R$@>aB#Im=HkvGM=v{+``JwG*J|8TTf^yjm0dxkbU+8anq z^$~2Q&#p+qqP`A$mpO2(G3t^g2X?Tuxf*ypiY-9Qy0%1UGXC{JlQk=wr{ecKYQzPx zcl^9~xVP{24hV&)>0O75y=Hrr`^(KSJs_K~6>mPCV@+;A63-=o@^+r*x60zs)Dlma z!o8v@A*rFMWlcmz-G&{)18SuORC5Sr14R_->PgN#FX)HfH6-ugJk4w|?ej6MJPbh| z`P;d~FX>MUY@oZaKof>|v)ZS<-m^)OPfxTpcxXeT-ti)e&bU#xI-IdRZ!=?2`r$bD zaBvohR$+eP`tY=Fz*p*4)n#wvMH1}qIGX(^x-IHNfZHM0D(z{9om%*lQsIvXwTUP0 z+@$nEl>LYU@Z=WabhI&kx%VgS`5fa~HJ)&H2D%a_b=n@Gj^G|w(ZKdBokX4#&TjHM z)}`S7uEKrq+AZSj1)d=i%~=0QI$(94ZnfRHho|Q*%zay1R_gJbGJ`**e}3crJ(a^S6s!;x`Q#epk@V0)5~>ut*eM|H?yW|n4&nRJgY6s~8* zh~cr%@<$H+otF%-Z@3aZGlj_8`+ZU*Mb~_2;^;dygy1`I#bblj``#^sMp-tS+hW+~ zPTvazm)(nQ)ElE!t~1^xA<7xgqo@4vSnKvH!aJ)b13Yn<^L2O@q8p96 z&mx%31hsR}@$bR{z3w()_mF1;Z8jJ9eLM#n#Rf#az(5wt!EWEr&pnEpLsecJY{HQd zm?Dhn5oXe>ChYVK#2Z@2O-NP&V-4X^TqJiugD=$owZMI`N&875vq3(hpLilwUx~C{ z*;TYU_!jEyE4B=gLk`bMi{b3F-&PxF&UQ<0z)DD&hWU5%hbXb|zcvI?kj`kNe6x)M zF)Nbk>*CR@!6o{!D%dT7;jIPh`)1_Mit>eRc>oCBW1>i}Zjard#Y47uu$xv#0sE#; zRDK$D`PA(n}1(=p9xy2?prGpX3NhK*P;&Y9W#r@oVGL1ZE&1anPC zMHqg_q&M;B&85&B*UK<2uZlEPaMg@A*DfI!8=qO2769#B<@= zn{%SdFtMmma^Qaj*FZlCle%mPz*O?5|0DgU(R$rpK?q&L9gMq0d4K@e^f3N}zJN+y!*1jlf;_>&EC| zv@=KFQrT8TvT5j@7mEg@ozf*xFNYd?lyipkutTP;#ePz5%ZRRHj4F_Leiw+xnXuP%rRf$1H3BDrk z%tXH)*N((nuXDC0uNNt@cK_x8DIlGg5aIq{p48d;pqtohKJ+J`=#s=D z-xY8wxECDU0Yk#;Ql^i%j8SKv1czcRjPp*1(qV!0ypB0GH+v6P!`!cn^g}dazQoIV*a5~p2o7S1 zf~E~^#)S|(7VCBAB^5z`!OmcvO&`YNFKv6iyNA?_(WlN5Hvj5V3PgqcO2$nNoIKOCV<+ZlD{vh~@Wkd-S%3tmIA$g0awh}4Oxx@$J-%TFbUGJU zZ67;5`{tpH2wvZZTL&Z~H@nbmQMvIj+8AfBW_GBT>+(cvW(b-FZ%#<>YgsEucx%Po z+Svk)_h`tuU88zi?~1sQUZY zb~5w8q|SICp8z;e~cTcbri?{X*W$$Lhd zc3GZau`a7=Vc?_&+*CgCTXu@3YJh9?hCyCejOvw3-Ho}&RZ!4Sxa)8GiS*3EqVo_2 zr9cR00bs*#V*q^II|s*z|5jov?Ym%Gd_Su zI42Opt5-U(gA%XDfQ8Ru$h<$_g$jd8=kgaC2>J6-jf{vG?I@<@9o~{}mF5>z{Sd9z@RniP+^!sZp zJI)<~oke_8v*5`NMaw~*Zs)ocN-kbkvq6RpPQl>^tR|(JZcxlp9K%G}ZkH%wT$9sX z=(;pDsBf>nO_juR&bo^;>TORcW&obhBdn;bvxcrV?|~J)23g-&K%hyn2Vrv=qs_Zr zJ~U>JyVKAdfJK%Cmu3Elb*qS6Ceymt##ap=NqtNSk&C)0Zyqo#%k*Wp{bE%k>$p>O zDziOkf2H~)Lvo9#!^<7G$%nJ`5}vbp?wt%*GjSQFv||f)t=D~CSV;NF*m^~NShEVt zH|KMKbk0>H6e(EPR}FIJ0m6br<3WKoi{4Qad(@A2LP>Ceb#GKUVMZ zOmA&W!ZVj@Uxxq29RO=Ya>+~)naJC%&7WMGa)kQL9Bel)l6_;}44S<7xrd9?HiWXz z7Yh6A&K(`p*H&qG-1ioTqbIQyVkltL?v5&77T$kxHRBun|9MOs0m7ImNmYHP6TDnWK&R_qZy)+FJmsi7tlrrK6^D}s(`aPNOw7$Xe zExn8TC|+c&C~{(?8m7t1+R5EkgCe^(*Jml=P1-XZhqdf>=QD7n(&RLyTWL6T{p2}9 zYfWAk+-@KGz0;t~U=TV76UCH49y3tneCc9PFpSR@GAT=m7U^)tR9Yf4Sam7-UaE0! zzf86Z!(BnAq0SAri+8$rD7#IUV;OH`d7kKf`an+G*|(hR#pG-QRT*#7xG_S7G!j95 zD3j5k|HaN*2F2NQYomk!2^v9z2X}WEG9w7hgh?=lH{HpoWo+);`*iK~HljMNk^LHbznXS)n0jQ+7!+Aqhb_xoxsAp_ z%V2Yh+&|!d8hKnwX2$!PV#Bu#-AZ#)bi3yg#$nQBB9~Bzso~aPUQF`>`lFGMr+fU; zDKU2@px4#F${Ifw5>mUk0^CM5^baw%KJs>9+0;|y5ZZppv8rl#3t6k@&NghE8kwtY z0i!!=^N7jM;=4=POKCqJ;yyUmWY5-){H|P~pW>VGseDaY!0XvNL3e+Ti|g^zR{p~% zg@*@~rMr@N(!)y0G?wnFVjXpfVO8AavSx7B8C zzRJ+aR$A#;%)%7L$o5t;>H^~#M-6tTm2U;7rvZRTMk^EOSdPJg44*??UA>n^_y$4s z$HC%IRY#+YbH9vLQ1d6Vo8{i-kZNqC*>V%K^N zD^3Fws%^}xF2G*2DlNZ!iIM^K)Is??VSH?#JMD%k_<6M$0j#(GW#I*l)7&gZdXw|C#$`}~(W7A&;o|W$idEB&n zTZu13FFz*g7Zd0`-l->dA9qv;Xo&9Qd6G|{xTcvo3pw`6^j0YBC*&OdYRBhuTqWFFh-qX?i=T~iA4V2t3r0;yiX$Sl}*n`6) z4MfYa&k=2jX+&{L7A%YHE6vmGyKk*bI%;%OYMM$1gRVVRd55lXwO?fE+KQox@cyVO z$wFBG?2`RH`xd4h%zO6CDj3zu?X9CL1KphhJVQ%CeCt9=mH?o0ZWwXdg1;|9%3$J(=w za*K-44REkq3ti^k@%L9!?|ml7BA7PMXV0V=(U=9$f=ppMDmFO7=JxKvKPb)k$Qx2U zxBTp79`&mTkCO#7N@~u{Aw|I34UndTek)b^&Ih+@Gv-%n)7=F^Zentq&Cic&2(e6} z=FXk=0(l+=Ufg!}wY4LyWN4QoaOE3MOt+%3?G5QNIrqRYh~mHB+>dI1l(WsD=T?np z2r#<)CKLiP1YOD<97QMYuHmBe*tELzB3$ioO9|ecyF-!iTA}_I7SdNXg0CA(E&WVt z2X?Co5C$fhTVdTAbD}#lP*`|M_4nu~Bx-_UnP0Wbk6J&L7=Pb=I$h;o9OA1}Oj`m! zR*n^$LEfDx*kIbUUhXe4A2bM1SWLMg^}jmOvR>llBA$m4yDG(&8g@5u*4U9i9YB$BAkTdDt~ykx^pID5}@b*hiV zoEE<>82`hm`^E!1re(`77U21+1s=`TA^ajIY5?Atlw=q6tD_9!6@l@!L$Locvk4=t z#ThW|E?>rd0*jb%Lv*L6xTx=fdo!g1rdK?;@mnOPF}W{S*g1RsExANixz@HQp3|Yj zlxzmt zEPejdN$;}1bSGb|s==XB3U#&M!!7XP)>z|`64JFLdTJDzKC`7>sTjq_PltK74K3{fdsFeTOlxy{GxgxkPsmtvSy2;$i%x z2Z_x9N4vx{ib@OjB~~l@1cZIpR<{=}xCnG;azU49mm&E0F%G1qpGZH-bG@bt3W2X% zya3DTE>}!jEm5Au+eDNel(OEy9{E)YX|L!ug79;0R>~a^UC-7>tWVGOcBvw?_~L?} zz)S>X(Z1)Yu|pn}^&-XB$!@!Dftv|?r|%vt?uDjC$mM)(6Gd__R7a-5%2GJ(@XcyQ z)SEnB0v-lnz!7+ajUZ~<`Vv!>y>2^JVZ%_h;w=1JYwPF855nX`F_k_Pv}XE{V5HA3 zhjp_WJ_8N`h9xsBMB1aN^kA$7$;ks!KHPe3YxKpfN|^f<5zADiqAo1DYamc57z)vn zSQRzj!OB4M+L-%cZ0a>tC)W5pZq)<}I>hb5J+Q)t@MRO-ZZ0Y3Bi-`y*w zec9H1n4K7GJa`E>y&X@>Nqx(I^x&st5*VI)QCJAS8*_qxHkPH6Ldo%V(2KLzFlv*h zdaSv;Ub5Y>y5ieHjhOkgg&C9A&i8)h?Bk7hSM{$qikqE}U7nYzn2vPqcK!P4qLw~5 zLB~Ofq6KpL1kxDq^yU0X@wrRvefpSmyW&Wk;#b;YKUUV6Wh2{=(X=r>{b5ZncuKA@ zghKMuu6(eq1kuqscV?SjBG*u@rFIz@cDN+zwrmJOs#T}N@1PR-Q`zwCd}jLD`wLF z;~x6M8A3)~f9~Lefc@66bcM-VZ%f}!RUhVl(L-tGj%&r7t#7T?8>_P z?qKZ5=k9l)fZXa{av%UlQ&xGoq4U$_CngzqaU+%->NSD@?mtwc> zet>~Vb$pIk<@yfevsE$sU^-ieg0&3GI>{Sb=jx;$56DmtxZ?3c)h0W&EmxXvlfhxM zT{^iQ^2odn(GY&H8zRsga#7-2<=y99;G`b%NaClureZ!dUS;D{Eg znoVXHxCmW{*_F*SaKe3FbXhW4x|LyjHWM7+!mo_9Rpo$=Ptc%=R9on3#l z;2>g|Nb;OwdCz{k19eC@16E}|``3TZGO#lCwys5KQr2BGEfir4&nKpYcmCdR)L3gV zUp0yk^ue8cxaV-bBt9y7iNLy|etZVfc+tP5IzjAp(MeIl8$6Cq!aWZ9hF42K8H^J# zMyY&wI8GbFPZ5FiGCNM_oWr)DcukzboAa}J`YiS8J2u%k$9I&Ko@}|YUT;S6>ORvL zDWnOJQ=dD~TxJ6Y@I=&meC$~L|BbMu*e|ntk}3-n(Q!ncTtXmnc3c>xaa?7X@}&FZ zNI58Qx6%e<(I9D>nHyMw8q4R4SXp0}5|m(E1o93a^F#;hei7 zm*gRvu{uK$s?(nDl&rc{%!UP5Vt1v3$tYbwR+#jMr3K$=Y|>;7$kdR*TL_zk{nii_ zztchdHYTfby$5oC=1z&rz*2#0=P+LmR|@DqszZbb8CZ-YQPUnwy*IA%e;^%^3Pw=g z40t}R ze&2|aX2%_TvHZX^sBXhHFm}***`FtL8NXQQsMBbd>~VLWE}`kZzHP_rvYxM0MI3lq z9L#UJN_V5lXp|L36yINoBYV}-`4N0Y#A9h*=lp1(+K?6#yH|s^rvo}z@(PcG;tRTN zlDY1kEmg4E=M^tvIWuJ^*BVvd&3R=L0-QwsLlT+DsfKE1>nZ<8uJQ#zlr1~HvQQ=C z_vL&5!f|r1jSwe=cn;RcX8CPM5!^=&2!)8EFPzf2a{9*y3>`D=MlR#kecl7>sM(6zIfv_h8Yo*X*#C4LLbTrZ>$4&2e4(Zetx~r4 z!o+tU&G{PL(4Y#(4J2OY!zRo5`ss;!$CD2D!I`%W4^{zF(|z}~)p5$*r~~_m^l}X% zzBkk+2v02a)Lu$*UAa*U`&R1;*w%E#@5VCS`UX}WHF`S;8-2R zQLD`xP2uD-vOx3DIx`5>^inP}5wD(G)St?0&O1YwkJ5-I_%fb1y31Glj?!=XLxV-H z+6nMyy@T7-5SYy&;7>$QE8j8u@S=1p@=I4{0#)F}8UKS4Ne-^{f~7jC`?t1h<_Mo8 z$hRIAE2^THp3%Js#ZYZc;WREUQw?_B50(64h`1+b*!j`TS#Y`~TB4IQH{=XHzQz_Inya!I@5usB|KiX(BCJX|U;t-g{NL7`EQ`@88=?U{}1Rkva3d^DNbqmfDc1%1`$gGgK>gb+Mgm)Od_gU0wi0f&LcI3R#PLkkC)PG zX`#a4%*i1vg|}j0_X0!-xy`1}I&l39^R|VruLyXj^D>4D>uHl8nVy{ys9%`4gbfuq zMfO*vT+o?#@KG0OB5l%Q#6UY_`R#W`&2(;&fc6>e~!$whALd^dS#RH47 z6;WE{hP2?rC3gus040Xh^GMIEa7O~!(&z_^}-bSV- zNdIik2nZu708?$k^sx<;%!%K8aoJYz2}W-UWi;y;6&TfftjYRoQp8O(tUfVLaPM)m z8$(#V{HJNS-l(WY^U<1p6phccx)V?wYH^j5RSA$a5J{rV^7{DDv1l>nR@Px@d0mt0 zZrszfVGc;{R2pg+7eU@vU=8M|L34IHjQ*30)fR+TT*}TJ93OP16kz{NZAH4Gx0leD znECo^wK>u-I-=D@)0@-Q9ZaLGUo;9M2ytcjmJE8$n`QC>Q5Ff@Gvx{3fJBNk1P#N> z=slY#(17|c2U8Ys9oB#*@O|~V(U4hxJaxRIw4+@pZsMTF`yA_vjecC9irZ-xML$9#ClAm=QQdbJr)@8I5*kJG_Iw* ziq32_RmJ$=#=%~<_I0QowcMpApAWxbNp{1nTsl*;ro|+kaY2F{m%It-vrPNASAQ|V zr=_R0x7aUbipjo=76f2b?=<`Wz|Bnv<$p1tj##oMU}v}RN4mOyX<3!Xif?S?C0ohq z1T>SU8mm%%M?%CRyzY;F>AznfK{^>zdD&sGQRq~983FpcZohw&5ouU|Bmn$hykvsU z=uDXf4by!7w#R4QLDRo~J)#d#&*4%Tn6&j9JM#J*xMwM+CG!5y#Pomuls|e8%wlC3 zO1zayMj-2`%oz@TfJTiV@z?B1MZr6XS0O zM0hW}VfmUTgzRso^m|qlWKSK;BaL|flE;(c^%uC03d1>#W~e>sH+ z;n(oM5hR~Zn!mOAr)2_;X7_@Hsb$m#Q!rJ zAuMH%-DUqDDTqDhObsOd4)D3Ipod*SfYiVs)3d0`eN=E~+UrN4``v0IrTe9&=eW+H z@YRLD#SA2hQg(AthcYewPXn#Mzs%+@vwwDz82hwv=x=8J;{<}ah3qsDcR8vR360&T zP`!v^b+tZ6CdYoP$_`RrqnQ;fVY#_~GuARFmV0+WZz^@D&3m6_aWWQb-#P4@RF`ws zE4wO+c$eF_;8VH96yuai%rdD_=~%cvOyF5x)OGe}hzIvfYeW}Lz~spT9xLeI`wz=^ zRcsUuKg1MNuEP!?*^tJm(^<(f+0qo=6pn@Wf8MboAGqn1X8c38vPc9bOrIX~y@3iu zOrzavk<)g5W`f!#v4HSMTwTvAw#jdKfA+gRgOc8HmGR+#(U0(tuJB(`HgRDE+67H9 z^dOmrg^Pp`JWdg+BFY2sFabYW9Fra;xuil=YNM0vFS4%)L5n7G1Ux4*ypYWhG<*T& zxO~vsj6?Y@UA=Er%c_<`m<#g7%6?+y*j2blh5j!#=u+Jt5mB~B{a8ys1>J5w8q7JR zShG=g!2F)C+9tYf_{8UVfYJ81@(TM&zW&U;@u@;3)wyab%AN7v^kv^_%NJ<3>Ri@y zWW1AXcucAMOLG!zM#tInmCmhqQ#Kg|orVolR%J`~#?Z}@F(^#oobz|A{+Of z#VRMUPnaywU1# z*kW77q>_t=k+>?!r}AMlFSdC}^c}T&S`_E^4e zEm*t#Mi>0v>lI;|@Qnr8wfG;QlnHVdH%z87zCGwkt+TP=u?O6X)u&6BKNmJR-BU@j z!WQF?`fp>|*E^l{SnZa zNwCgqV-IHeU&aa+MhwR@hYuw-N(nv;MIYYXoShB@+q~=EZ`R=-Y}gn#-fq*4;&n*) zn9Qn9RS^55OqkVu>)>Fcp!bMfsjT(BKxrtBNmU!^VYbs_B$a!(ixY?qpdDH)3u38u;z zpFiBF6GL{f+Z#$0Lqu6opR%%-Q@#g_&fW}KP1=RiR?(jpDA#=eD3HowaUvI{;n457z7L#yFlklJKaC=`uAGplHR)R>c=xp=l^|D6yBBuPUAEjj6bX6_Ft=* z9CjX%eRS8`904(iqvA&4PtsB63s)Cn8{hQ_0IiwZMkMEVhxdkseP50G zB1G7X2i8BdCnbpf$!L$4-`mc{R1T`!y!K%FkUOf$@CxvlR@DgO-8mQLc7;_E+i%;( zsH|@XvK!BA7i_vbM5)@3M%(mtnVk)tbQl-qbV8U1a!dG)mVLxbyat94<(KsNsV56< z7IUR^NZ2y5b$@t-koy#+w!woJ8x1;f{4(wQ_)Pd+W;+0UA$ zq%aiie2~E&ls-ytjX^Im8OV4Ll3nEE49PjLXwbEgq2%JS)|m#lU-5Ti(IqSw+XQ=C z%{%d}&dfG2j*L|U`#<%#T^{*#%HbF51@o=pClzp7DQ8Q)35OYLtTpVdc&1b45a#|d zNY+&#YvXL}llVzU*E+YvZ4^!AC5&XhJKN|ibC>?oAOYFffvuN@l^9RX$(?q9^!lZR z)PBSc#z*xY?lFMPfoxmF%9$Ze4|ih9O;XSL^OzL$AcxNiKI69xehsVpdG4NPSqWvQ|GoE^zM({<=NNoa8?Omdd4kie7QnhHhf0o@88fy<_ z)S=XiG(Qy!UmkL+v?aeA!hDs$u{UKCceXX!E1N#y*ZRUWrcml}+S`B%v?_Y5+n3y1 ze4iu;aht6GCx;LTO?IvB<)yVI-;d=4C4;S=-2YaW`1)C$w7>X4)s92Tu|EICV4Rx8 zyd@Q~HaBSJBzQ~UGU1OE1)nN8(oC~C@fKnl6WGqy;fPgsk*6}5#;b~}^v)dH_Lny+ zlhg;bN*5D%qOvt`vK_5lt^BTk zQzwhfzSml_*}9UWKu-*ZS&yFI=?F8sM7KWWgY`0F)}#)b(NLGBvT(`$u4`<=5BucC z&tFw^yDKQ=8uT|35$?!*9%+0;#3TmJHP0r#-+xOvX&@<6Y^id5yd>XpcGsztIPIPW z7>#dAnL!2@eXBp4ekP{x4RhCiSemb{)U>(mRA`MxC#c;%x_{hXeBps5PJnbw4ah`% z*?hH>eMKf7Nk&E%$t4tew(V5P?arLQ(b918DIs`gT)U?p3eQj!z2UJk;1Fqq z|7TP96iaGi#nJ=8iMR2&#O+VAJ6@f9*Q{7^YJ@~`GbE@DuA7o|;IC|XP z9LcS~^fBo&00sYOtbOLYILar*$0Nlud2n+|mEo@@v+MIgUB2#bZ%iM=Bh#vX5ia5F*s9ts4GP*n3)=0#jZqMIiF4Tc>iCVWqWX+>f2yQSLArDMpZQzGgX*n-Lc zCCCx%z4{0tT>`-`ho!mG^5N)5blqmB=e!O^wOZ-f`tn6?^)iawx%QHw28_@Rlk<_+ z<78@i0sj80nIE03`WDcFI*2Ktw-aP>_8AdzC558_*99#COEv8h^5 za_rmb6BA>dcU!7KNB4d0V=ED_Q}`U-2qv*kBPIwP+ zIs}AVEt?ngddF-Y%{e37OMVo;V&>CAAK3)9>+H~~*GhgQSrjxkxak#2nf>`gbfxDS6||&fD1@f% zqVpRbDjW5uAWzcAR%_)11n}b*fTt`Md^!+M^SQ7(eX^*_U15SD_&*nS8`#)Ydd}Sv zJ9|em98WqL!nO*Sr_k;HAjy9;NoP?h+-%jlLf{V0wmEH-aYsf*uElbs<1z~K0$#{q zGk>uWv)As+lUiUZfZ!+J6RX4N*~vrd*E(& zKSdNmGJ!d&qGve|_4peZZcup&fGrA9FlzyqYYjxBX2%~>OAusr!=YP%NA@^{tc;<1 z(6XPTt$MpQv%;%!^HG)bg10Rh!tlu2Ejt00iQ|-t2gPxJ8mBEuIOyew*1X6_793(4 zG7ArE$hYhd8z%e-m52HgsUGkb^YDf*Q1Wh{op70`AN}K_Pp|%t%EFVpy}m&DXRV=$ zz(>SOkqebfg?;>sZKY^{^Q#P$A3<0C|D@2QU}S`VFDw1g)Y1*(1_lOPR*$V0^S0+* zn#pnCuCIqMK-d0P`qy|^#mTtD#Kir&gdv6oMSY|gA;!p3{a$c#?a>@i zU73NReYW1K?1Q3W#M0d{ax2tpd@C{O^z4Up0_zsZeT(`dYeKC{teLJQGm~C(BtyE4TXp zmINvM2K!0=P%G9EXWM7Qk}rgWEs6i_wyhy*-xfx#T}AOrJwy5I^CH|YVrmf3&MA>k zoQyqy)$4B49K@lU*0-HX%vl6%yQ6%3Z>7bI#TfI-g8N|NY%E7EYaa9M+aS(lCsI({ z$Kzw$UcZ3wAD)BOQm?dMIXge4<08z|&FZyByxG&SX{CwH>?q>Vc*x1pOp0F6J%z`=^SYe05_~!a9fMdmzuq=#Eq(PnLm6!Q~mhT7v3+D+#QF9 zmv`r&OuG@WB$@lmlaCysePzcvM=>=vqGRr^n?_6nBn>ZB9V29S&)J5oVBV z?rdxO(tfiqC?K5JuyYEaQEB(Wn%+?Bgw8?7Bi<_gK1^vB7YoyCzBq0Gq$pI`5s;juaKIUVrBdp*L%FsQwRslx4dS#)t{%bOP9hB!YI9WqJI(a1NCKfrweqIUU*aTG)f|F zjubUe=)*>XE+X217XuqV?B;b<2B7`=v8@?U|jbLAg?$b zv5Q`XK#D)!cY7QP@wL$$&N~xLvS!Q3%3?EzkoS&es6YNH)Rceu60KvXUe*z= zEOTxdZD)LU#pPq~&!cuR$9uCc7{oHKHRs5Bi-ngKXuiW=P0g7fIA9j~#@fyHir$=& zDjsxl3t_0FH-n^L6RN(E)sv>==8+kWA7NDK3OlK8D}B;Lw($f=4+*W>)8tH>-E*cA z@EOr2L%mJnj~$YT#^L#-2ig}6pX#INyi;|(a$Amsa00^8d}~qeWPXC7HGqcNhN4?- zCY|axDyEEI?sNiWpAyb;7043hXNyt0g$4(qTa48Fxs_1K@aMo(RL2Z$Yo~8kdWQTX zn>ZeF{~lIUzx?2cE6eCUc%Kc2_*PrkH*8E+$qhq-Q4?4;_B=pgyC2561XR>gk(?`$vz?O!E<1X*5qEECb6Ous}L5n$V3Y$Y|sxJsA+b--o=Ulcz zP25gUjAitHCYW7sr%v&;(a$&Uxs#0d-V<6iO5FFHtzlb$NnNGVZ6+EW<>!4dWFph0>CO{nIakL{ljM~Ki{@@# zuZRJGx#lEY(gQ=TvP!LL*d8apK)20=LdY`s-E*ul!o_*J&-j}3)QLjkypKU7S1f8@ zt827i3qyJpTq7_SU??X;`r?UL%XDcON9l9qB-v4eommUr;)CS!1@+Xqz0s{`YK5OW z$)0@M%;~6SpAOg^o`QO@RxS1;!KL2=VZR&s1GmZxZJ5{9*9JTNRE+Q8#52zi3%M;6 zZCP5B4Fv|#5v@SY+1!};_=QuCN>@>F$fxzyS3J7PfbQ12ZL0}Y+JT&GIq28P!uV>} zpM1HH&;y=5l$%%o7I*jnsoGdgRc4=U9V(O3A_6yc1e6}73krS9#-Pe>)G}^r$R;vB z6yS5;eu%AVi0V)yj(U52*bFP|T^3V03vDYl^L4Ykn{XYvwMfKZ!7orB-jY4)9HWCX z%a)3B?7nw%l1RmW(@ahoYF9tj?dT1h8Z32tkQvq4(ZmNu@(mV&Yx9MRv5?iK%5=nA zOH~gLpR!W%#Y(%?u}MCNLxfBwJ&dwD?SNR&32Cw@X8hR)P4%%2dHf}U*^1k~dA#84 z7jeYpQQtK_Dx}qCxc`*dHO%5LQyh0Ga0ev2C!6Hs+K0%eH-5H{cI^g|&eN0=iOo7a zxiYZ6+Ek=>I+mtFP<2hud3~T2K&SkcIu{Z%8jTPlDW4JufQ9b@e|Fw_5-_q5%(uLo zXBAA3vgUK=N|#F4F??r{{;s|~!!fWUx2?E%T;oC}j(9MtLDOw>AYtTfLM&N9>)u3u zcHSN`o7_Qoc3D_KmlL6JbFCJ)czMSSSlH=7=y9iNruJwl9BBLzhCgo?21H)|2kb@( zzt5X2gTdh(4IfBJ3NWE0rGzTsL%-n9w`9Q=OB5O+(@m<0$i9o`ltTP8o)4FrO%oSW zq)c&5y<-(h2DqT0q3jk&{lTi|#)CodNT9`S@eOw%j)h9nEiR_5g6NEl_EV@b5HWKg zmd>Q98dfiIPCE*3oW_f)`qmz1mh~P}vt@B-_1vxpSh<4k0GjmWM3PUcVl}E} z$SB*eyT5A#g5QY}oTr((lxI$@>C%NOXTlok%N9p+=1iD}DT&~309+-j%V*GRQD^*vN^ z7iI6nLRgjINYnr>>cvY~X6!ZA>TYMct*-oI4QvmkmZMsca6b^H1tG0gRo&U~6#&Xm z{7N-n$7vvnsbOQ3==77ScUqbc=}JEmR`*?3Di>F)Zh~$Xx@vSSVKmS_nYmpIo0^GN z()4$!_$swpIre?g^o_tWS+OraL zkdxSMl=p&nq>3#ptSrYoOD?)?2B0U@Y+aRT?wj3Rk~wxEqaa3}Q_esw^1}hQbo)fs z*mCwnWovsfG_CD6H1v@}8Gtu!wUo0Lt?IPTo89YHJ&`=qG(dG>vF+HywwaG5og-j7 z0lZ%F(r?iSDKlO^Dui&$0AhXJ9-X*EHwGOzqX~ zvz5>@f3hgb84YFJ6Q7fc;Wi!7=};(iu6)D6_32#6FWm0NLt++~UCRnFp}?a93>z<~ zNeeM}iJjrx2j_;G?_KDb0VN?APHXwM3$nZ(`&GpJnzd@UB#)96BBWb}- zdljED%~4H@`Je+H5GelaAIfFGXO}5*1(IBV2ZN!H!RW71sB&kECTB zzuv)weVOroZmvZfG~iWEKq%aS@fv+cuIt`{H;{UGk8J-$UhP8nlpq&VjN`3qs1x1(}MQ!Ch5N zAxiYkFS9N~Ld;wZ-K3=Q&7)f}fbYgFA#oQ?z=6#fxB5Bd^t&?9<@??1>Y8GDLw^%R zXuK8y^Mo?s;o;d!^?7XW*_N4p4rgcQ6afcfA@n5g`f>jq{gQIekG+a+eggtKI}FcY z+(P^Qp3Q=i@36bLneD7Bw5Ox*qrj99J4->2K9r0&$n*9?l_F&>757y_ev=S;DWx!6hxJZ{ zTcrohPE+*-C$#GO*H{WEocOk4V64(bO{lDNmKzJf#*wjwtyT`a^@n6F@wbpUK$X37naT?d36`#y&M%w5TTTaqXJ!%VEm7nV5)<{%W@#Wa}U=p>4K>j zt?%98E63962qoQX-_MtC@eH2+LlIlqPuTZ7C3ea6=^5{Pc-Knz`PL{R3kva3P5z`_ z@#sileMOed{Bp4K0sr^s6~8MLjaHx!s3Sd9vh->;J-ea&j-w#tfdQUwO%Jy2DxN&* zh_*B0-kGFsC}HyJEtP*84&_Kid@BpkBVn>W>tt;!miD~Lmel`T0HalEJB4$iwNt29 z_=~a{9AcEBcl#_w*H-SoPo4i4W}P5^5@MHkYC+|1%B#q~t8k(o)=7V^1!747;L%2M z(+r0JIsb19tqrX>IHp#3P53tK=dtaV0HHuxZ0!JetRG5kv$M#hBO|uX4*r$V(V-T0 ztbcr?B<2r(9s;blNUlGg{tP51)lDys@)htg$lM98g$zU@6|(sekjdH{+91&wcMQ{&UItsVR`>z2{JB z1HKqkFN5yi4E~BM0A_NG<;fQ1Enm5NKMzp&0LuNmde@iA?q0Q%@;9$kB;`e+(6GJS zy-0Ssiax}VV{(GR*uI-0h@m={Md}fT*j1G8jbC?omVu$}1rFCH+BgzQ<_Stb$ zX7g_?%`G7a_N!y6LkaiXOnUXXd9wPK&9$H`;g*HSxIKQCltb{~iX{b3%U_*P6$pP1 z;RUriapHw1q=ej@?&ohD0`x-g0LYD(`?WJ&oswaDHxeteYof>kb^}#HEH)29$W7R4 z|9t%YpUoNi2z`L*fz`M3{Lt{IycN`jq$;yV&VV`R( zsj(GHzR5;#$Fbl{^O0>8gifmtP6mgW(8|pcQ(IeGvB(75(Paz0dD}GI@dGs1=KJ)k zR()ua`0=sr^msTie<0($Q@ixNdb1W~3_WNJSe=gl!g)4mGJ>OrG6=Uj7~Q;6b<#q& zrVxB}DD=e_@ig;>K6G_`-6-kch$KS=b@{A09O=S*moFsI$45k?+U+@$ZbL}NSCovW zkZtSWz-|JaD&g0tHzy(%aQQZt6SQYFIP|*~y;Gr@e=Vw+!Uw^4_RJ?@sl0+Qt0Yvn z*rG6i`ERVH_wCc%ixp#-lz>8SgD7?8s$8xPrde(KGzfX!;A83H{6YrjyjG-Qfb$p_ z813F7SuCGE>ouLYp=!6BH0`CKYPv*xN*nti1RzC$`zc^07!7wZSf`1(-Xp`xvoQqAZ`vo99;v!ypvx#jyD#yqxwD z6;<-Sr)>2~(`#pC{}kK8k@UP3`^<60ap}&B1=2&90&xCSwbL7ZZ@0f->Oh5o0@+e4%|L$n|a2-JZ*0-elGe5)^WBud%{TSgf*Uwci->`5GLz=Y8g#?!MaW zyxf%|tFBn7i#lH6A@WS}^-C0tPVz_6NwEb)v*v}#ZY|tN%*EL^Nj+Tu(xBI)@R_>{ zd^8kj4?gc*2w#UdnhC6|67xQn6R>$JF#XL&X-e`xm(5n&C!25DCBM|7?ySKd>d7+0 z_Fp?7fJ`w}FX4-5YB8PvCCsMTUrbV7g532a75~Xa^FQV4VLM(7ip^3ElAz5i-e5&w z&V8&~TJ0Ah*SAXD<6F|ufVGuX!vt1~v|Y2^Jl`bs)q{IsW|dq=RHCdM3kbehpyr?W)c(72EMRB0k3Q zNYQ$=;X;~1w=L_X2F&FG&IXT%H>J9bK3>4vHIRAJ0#V~783PB}^dtxO)whY>je%Iv zOy3*u{nLg|Sy^34(BBK{wFunuez=e~%Je3G*(W}$5B8brotM=~ko)nt$kS0;f&MR} zq=sjM-vJ%kAc3Ph zZQJzfIq1LiSqjdli*H)$=Vxh4fL_j4LCkG+(dttuNyg*0oDFR8>n%X#eRC$qzIMIV z)z9uW++j`#qJ8UfZ#W{#VKevA^=wnE*)-isvL`(iVDbHsalY~Bb*juYQ7lfq*Rrmg z&P|?LXkqU3hPZ>|I(M_jSr)gc! z&t9vlBR)5Bu^lrz}%$j!5e_8M@rc{*!y6*qQ$XAC&-L>6H zt4N3-2og$3OLr*J-5pBjP(#ens3_fC(m8Z9gh+RHch?L<4IF&*dB1c1Ip6!&Tr=18 zi@Eo`?|ZGa*WOdoUX-kd?0;sh*dv^zduUGsj5GG)f3xz-jC2s#5J$VZ_XW+~Gd8OBe@_)(&B z`#&&oH`_=80ML-=$KAS2Q6f5^DcO35lL`tYP1Kqw!^uYcC1Wva|Z@Zmzp?c>69?X?lIGMmedAWQXb7E+`XRcV(Lut^v z9rnIf+o)sbtiOXDNYI_cj$=O$M%My*;~O!AZ3t0o!xLhc*|7fu+w`bj4RX61Py>B( z>kxmhbN2hpHzi%RynhmHaUy;fxp}|~jdQe&9|(RZmPFS%hP{K)Xmy5r19j&g%x~Qa zinVb>b}Dd(?K!x6c*Me9cO-<4Vr(>n1Hu6&R4BhdoXD-(+eVB^gvs3Jql<>24>ALg}Mx13@(7T zFBJ6*N^0FOUkbYt?D5)47#n9Wyd`@{@JZIjwi&6V*BrtyX8vOffp**@MeZ_ddUoll z;FnDh!ER0qrTWibCdBuX-w|@0ViUu#82g3Y-QIOyZ-}Ke|K^4CE7TJ&NZTGM!+Jp5 z!oL_ITFf)u<~NkvJZJ>PU!Py8hBA<`KQEMzi0L3miOn#5AIG|MlMn9eC8=2Jdh%IF zE|RcS91GqV?uD79k&J*Plxh?;`5H7L*3MHKFIFoNj%%GPu&WbdA#WIo)mTmkLbx&G z{Ut{(yM>8OEvy&09Sr~u>B&Ujc$JpI7y(U-sBYstok)OyH`1<#bc+Yg`*7|VTMH~R zZRsfQaC^L-Y|-luTe`vI(K4%1Ip!9dK1cPE=iEkL-20`)g}0^`?&QOk z5izKK?|$3^gcXuX84vtAyT5=r;E^;V6~Ac28M;#V*7c*G&Nx_tb+)*FLf49d?haXb zfaRy~uT*C2cOf)|Pe&j72_a)^h<6iUqDM1(gQMqK;AqnI-oKI~w^)VdZ4u=iSus6y zsy?0qFgcn~=>-O=?1_*qP2^LHq_wxVuN0}iyfz&)Ef+}iK|t6%JvrKDW@c77Ch25* zKizfRc1OJOs_OWBa}P#MPs&rgwKvUrx9!ecOYE3tJNaKpJTjFwS(>(s2VA|gis|I6DM)O@!{ z8P4jQ{VE~6*WcXJ7M-?;WouiMN!ZR9-E>_=&xvo@z<AycO}RvVvK7|88VC8uypK$T%=ZRyJ%->Ugv zR2N?)DvyLgYHG^z%H}7ZgWocRG(O5DIHpDJzZ4NPU8Vfr*+Y2P(mc_pRUgxEqFf5D z4-oY1XO!3fFC!rKXqw0l?&M~s{Ed?AG0hKObhC}4h%f&uQNDaMO}@bn8paI#OwA?q za%Dv+YRRy&gHT!$b#PG80qFWQguPF_vuC@tyx@PkSCH>Qn~shV>W8#L4osG=AEB!~ zwf~hE$NYFYc5?a?PKxw@L+*W1%OAhxBV&3>{NLRB&G8MYqpZ!%O|scP&~4R-itouo zmGEJQWf@eQz>?|vujealjiv%dJuRkqRrqE1GxfV5fe{BM zH9R-?v2+AWnd-j}c&SEpA;b6n1pVXgQwYT)m6Vli%tB}XB2b-R`I6#$l1jzDv&k0q z$zUhlugm*PX~&ipn=~?@R>=1)=J&M~ub~frK$NeL1xc07i2HZY{0Nz;P-c#$tg)Uk zQrXzkyCurtYYQKfI4BZ7&F41yT>5W5N~@s0V#FuApkZ!9t=QBifW-#RTR+eCZ%b2T zbx`xu{ZIB0DEZb((WY_N-lI<%UoqqS23rPlZGz3OszoeucD*$@IRBA@vz7fEe2AjG zGF(~NQ7ct&CV0%|Mlt_$C)I4RjK>jIqK_0}T5Z+E9*zD#7t^Huwia3pu&CUZKxV3U zBVzRvoZo}1{7`0TL>|ry{pszDWqZRqA$KN3ki{nAy$b#10x@^r2DE+@)T~iVOv}si z>_2m#c)9*75=+`Y^Bv=NM^$1gG_)!iFTy&nKkQC{iZ<2eJ{{&pHa+iq$NB#zTwZe4gu{z4hzdF;GxYy3>T2Qc_mk_Tw4Gwv3Uv z2l+Zs)f-BZ$v?@D%c5N2U{90)|1xjK=r{Xhr-`5%dg90$rM*S^5TV9{>*{y<<<&)>yrY#R4zAgvDt7beTB=Qn?h z(@goDRmXh4qQ4ZJNczzh=_ksrx9^>VZEbn)`y~OozXsk!Hi-!jkDyg_)xZL64Q0oWP>UR_lBPH+7CAyc`ghj;)M3!vSsFX%({H28(@SYB4lhcUuFx%p3__|LQgt=h zEjqPLyCXzKU8Fpz{Wc1A=_>nQKvi|8=R#-v9M-pC|qr0wynxCPsp)WM(%h z0v{ZF?%_OHN>b1+cmIkzJX-;1d-aNh%hta^hnZ8rZP&PuQUB||8touANy-LR;{98? zqK2i2XwN>6UoLjUzfI%RLBzqKM}eZ7%s=NZ<&Mp!(#u@hTudUjycaK)gwQcCINx5+ zM-~6mC)OU%pLl%>=%U72>DNnsRYH8|(XdB#5IoVBp&mKES$R1dIff-Sw~C)~0PAoQ zcsp05XWEH^lEnLc ze2$ij>xs`@B>@&Lxp-&D3+0kt?0l`pq=GPwUB$`PRw_@GI$x{V+>*vJ$1_~%hIS`2 zxlE6-uMTd`oC7V6XEl(sS-4)lAsi!B!1Ca##Bw%UPQBv(!Ml%IkKFHIeHWiw2ipxb ziyy1M-~<7Y{V|>H$3w#9rZd+2vtZ?Pw7R+v*>}@!%ikzaS614k^7YGK8rthqLLjUU z@$kAXWLl^LNnPKmKJ4|7%_6qRat&qFwFwZ2pRNGbD#q&kj**eDWL|+QC*c{^f|yT7zow2=$vj}+p+28qLYr7ybAsUeSK3=g{I1$ zG54;9#SdTTpsf|z>D3%{iU5VP25d@~k4K(OSJ>f=7P@pDLB}N1<+|Z0mkO*Kzj`W3 zu3MH~8<=QUn^U_UiewClGR824Y9;g52<(sb&tN;=-J)^jYdted&lLzem|veU06jp$ zzdR%Q(>asGWJRYOR0X%)`MF*msI{IeQ+;{(@796s#rX!rLyt-@{Wi}b7L6r*$iSnM z?+J!hy{mKTeFCM*&&qc4z(awYXe!RzzM~Q*75rST)4pmkYgx=nGC%TP_S3dzs zT!zO8Jm0`PtX!p+kEtUV*LIulWO&iB0=LC%^B)g?&2Kc#NfBvM$rBdHN9_ePjlCdv z5@#psy&tY$Utx0jb18z!!j+I&gUm_;SJP{u^Jtz?PO>E8;z(1?jF`@Da;|IOBX? zaNN(@i|RN$*C?KOVlimgny}(^a@z>_Rd>66(vo?^mIe28b8`cVYh^V2C=~Hd7a(9A zWIgUtqc}A<+T9Jp!lU@q?Q3|kzvgxVM0h8NoUsAVq8o8xvSJr|Y$Csgpe++Xo$Ii8 z=jVFOSvlS_ibqEc8P`+k(^X-Yhz9h8)RYvM_@Goa{o(dUuTNFWPyULo4~Dpl=Po-| z%$fGMJCF1Mc^14jbGpvS=jn-~qps^-sR$s7D4(lE5TN^`6-1H2zO40KxRklhcf6;;uNj|tp8o$QksO>6j z>Psd4%H|j71tL9hQ)Ao1$mJkF(Cz5s&d;4XZ+qU`1QEPr3azlshE&qco4Llj zGDEkq%~XN9tJxy9J!3oDgSR|yP__^Dh<99JH|J_zPd#d6U$Jx;if1W`{9b{VW<`~O zqtVr0{L&H(0Hl4*k@B1X0E7u*Vvj~k)gP}h0(Fh2w|nZG4kWX!71Q~{z0tZdOiy0( zIh#^L(q_Jg6}t8HYLK~XVw-%deI;=CEN#kW?;X#!@qSOhp5yK?=6JE8OgbQi56Cksg1ovGB2S3@h-ZGsBZ*~BTV``GPoqow zcXhExmWnpTrjCxuktgmS#ryHR7h%}K)@zWxChK+(^A7oucWje~(@t7$#hlYS_+$rE zm+B3lHXBtU-laDr zB{3}xsG92VYVjf?mP_XMt3QspdZB69E}i7|jt3_+XAQ)EzY@p=W=lb07NHFZ{uQIi zh+u$sMG`5yHS+H+;F?Fr`t3YU^mabs01M{_t|<@Wl8z1jEu$<8QEY1YuB z>U|y=8m|XEfEnHJje5iEW1lZI69lIGinR7<=H0XkrEQ(9yA)&`II`gLFoxpB^-2s< zUg3@jOASvPHpY2A=SevhI&|=iq$`;O`c$e%n1+fEcz0X+_l&~yvM3%0-1%MSzgJ~^MLK2Me zrTSxQt-ZhUO@@=$+;?FfNY~Vc03PQ&ZpW3U9BSQ()?b_@ef87_Vm4Ik_G4Gx*G` z05O~4L~wF?z1F?ru@K{$gGc0)W*T0x=x`Ddqcr%H!nz9Ruem|K1)r8xe`&X)oh#KT3 z5aw(2JW#wr9&JiXHNyLV!^Iz~rN=IQa|N;YkL2~UM$w8|Z9_Bd-5bq6D2>g``NO!_ z+~_?gyE%XG*l9tX=<{H>vDk@HVX2=(y68;mq#KrFgMFkfD`;Q2g*D%v=SA+4PnQPb z4ntJkB3SR-$mtXlF=W7=4qGjesKuSKfGYd1xrK=BB)A@Y+76re4ts~c()H4okWEt> z!FYl|@IId!^7CuUMNlXOBy+s$%nH{1jo_m5s8#V~NPi^+ZH-Y{C30H)%6}y)q1Uel zf9a|w?4`#I@Lw_?n7XEey3tlw66(!5u1`OL+P<5poYF0y8rC&P`MpHgs)Ak^$MnRb zj3%TNZUvxTo>x@c_|dEtQ9YnM2KI0Szr#b`wuOnpoR=@jyDvvwiVy8@ErY`hL6)@rTjl-`ykM zZ$4^Sl388F==wPpw&Sm@!u$>dsF+Fz;=>zkKef049m{Q^_r@I*jJ&U(?T!})eQ~BM zFs!U+x12@~Aw?8*fM{q>zeiiZBNUvn>SLw{6__=DegC5>9HTPq=u@i%RNiB<3BQ?7 z7-t!pu^d-ofCaA)O3rR>5^Dk@V153ZJip(xEGo4%BPU#ir<6(41;JB|Ow~=xpSu$= zP0K>JppEd@?dKJo0~!b6ZmmryZ-vCtQ~Wk&I?W@+2lNiP&=!@rzsOm zoyXzOuk7mWJ%1>35W447*o2?X4$EE=L-^yLu2Rdf;&nn-X2Fkj=AHzg19FHPaOgeh9|lwR#oBz@EMq)qO= z9(LM!!~|#mZRC&G25&ff;grpn-xh**(4;E?$$N}xu5nEJR|l0rC*bD09x5#9j%OkR zx!POI&df4O&jH5eyPMYWQ(~*)&lgY3W_5mZ$|(Ki@zA$IPu%@G&8R`{3B1y|q53O$ zI=R}o*N6LDrCT0`K6hjIME(6JkNWLr8|1&J>i}lz0OI@BSvflY*2E5mt7W?jI%lB}|C-UpY0u(>>DiCAeY2I&uamp0LVxrh160E=g*#$4+ejNm zZ5t2yI+u+kYOjt-fj4`N&js?6hud`c0hZ^d!2)|9#x%)K3VYwbYMcIYS3JJ;vb2aS zRcN9PZl~Mg?^kHid(RqS{8G5Fw{Abzm*8~{v4(HR*4kp6!|Hc$estlXIj*e6emhy! zc&pCgZhLdY<`p>}cXUC*d;F5q^kzP>@=g zf*fV>bfshfwmoxlX5GD!!bJi;bs_A}aODluC#_Iz`5M>+lzf{3|p?`%YZPf42Q=pD}6sY6G)-wcOG7pmF z^_uOmOcP(ua7ZNshCUApW3B8~>w$>ssfBFfTEdh2qK{vRMd5m!14O0d zINxyQ4Eo$9erIbuZzEnhpImD;?N2~KyK-q~V&fj(^MM%(>T3xbcPS-(KTTFMJhO(RNK7`$RpnLE0>X*{@DZCUGGun@Rv?d7?kGP_UaOvCQwGRxz zqqh?TA7&P$y+eXtN4sIlU%{0;$JQ)_p=qR2wM*eky8;`OkCbbzCe)4i;)1(3JK|gu z*Z@1#(64d3%UpkkZvi#Y@CNnNA?7ty)jOHvC3TnL7_V>-qMlIZ>^iaGQBin9k8F@> zfp)z+rpUo*K(iR*T3e4B+t~vf zU*%O8Kqo(65y-qY(wk5@5U(FL{`k?PuI!hWRzGMw$B@ZN<2Z%^F!*N|>u+E11ggGd z)29{N&mU$&Gzh!Xv3`qSxwkxBE(g@s&b0YVdkX27@eqqTQtMYW&e8e6W8uHWi5(*) zEkBBctZDE1fiR}xy8u$6W5qqmNS@2CC7UwuYm_I*=4YN9X5YAm7I`VX7x1_lTjV@;<&r8knBd28k3|h)2VBTvvck=MzlV8YdJeWa|3Y(^^zy}L@i+?1a z27v2@KB8`+(ku~oG6`T*!_?Q?p>#%&%YoO;tC%qx<_Yh{Sh=CK-i38ogxPW!skg*= z#RxR1moC-CB+PzPGB_ulRpX8S?ZS>A#aLa_r(qxD#&_+4v{Td3Yz6!Jvt$?G>5zzTV8%qiBoOYY}mF>usfrvbALPlFpq!)Bg!ZRA2qq zrD*&{mmI8Op}1<>;Hq8oLQL#Cu9B8p___Nl8&~8aiOpn!6)dH?7ExTQ_N$s8EA6v) z+}=|+^-bm;8aiH6xya;Shw~cb9_mB0TMRWR$wEp<{Xe!~)p#+_6q|3_nedd@3>&}s znR4Keih8N`V~NM>qf-0*Uu-~0{ouvc;*+P+d8`)}TJNwKJe`!IcRpW zPgmH8Lh>nU_$R{8k~I2?(hP=FQ_|E;m?-!>-(%r2#xi|RnW1L&o^L$LQ*~M7#;~BR zD>FIzn4-2Lo|9Hc)R$jQkS<}yY6SI5y$+)a-9^#LyTYEXID4==ng6ZI+EbFD(^E+a z&rDS_hsEnT{;ArUto=;6QQlF$WgG_zB-E%FL!Mlvuw#eFVB<4 zA7_$+iRHs0kcCpBH}j25K?UVzcL|jbi!=f6Z#_LSG0e@t>~>n6J~KaVmzdU8K;XP7 zx3;TG;c=)IbM;u9S5;LSJ4>!B$(fx;Sh#@g4DO#pZTwBIvuFD@H3;or-YebXbL9sF&(LZ$wabP-4fK zzEwfw0w<@*M=d9LRfHXjh|33g56}0 zAmrjwZ+$3QZNcgm-=LYY5DiKjO!WTlsoI2y{sh#AmXGP(0tK>jn~{73mNx2>HpJ1Nht+wX%ozG!41ItK(VOl}{` zQ=DYsI;5+aNO_&DJ%pBy-s+siuLaZ^b`&Y>?HwFbKBl4f1JN!V1C#(E+E0Baq+a`1 za4gzRX*DSySSih}SBXAan0);OTMV@1eJsN}mMcrh7J}iU$OWz4_!2_Ij_4!VFujLY!#>IX-^=9TE20!`w|6H_TRg(?t(l1WB%k4}e~gJIn|v=9yQ$p^Cv%IC%bC8~ z96JZe)5_SLTwO0X%EIGf9~7fo%vITbcANbWVsf#U9_)B=@j`egUn$LO{uf+t++YgX zJc2Ui0IZ!=5~tg3wUn5c)2zAslv;SP8GR0_W?{5se5c7UItQE|ufHf9)63VYj7sCN z?04zct9mTl?1>kwSsa*`C)jy2D!w#=+;;S}HqnBn+;BQ}dXDF-Dq`7eAWt(f)E~H( z;|?}!*D}%#Y5NW>g2nURL@(9?CwTM?3`!vMaOs_^nZ`E>qP2?rSBvppWpePFfw6sw ziEDS>AmX0zqvk6yHmznCcH0G@Z<|g@n@?1hFZ##3D-Opo7>yLYm2(@aM>+7|{Y!pV zS@>#8SX4(amC@q7>rq(92FUYHV1L1fOMK1 z^pgCwH(COnkk?Zu-c^M1_>L!K3+kwzd1uU1lHokEFmlmQeMW;%GQjA>>L0IGYcY!d zqDcG})G12Q_dPml#hRdOq?G2CGu^)06GWr2}u^NA0N|4G$1I1AfTU`yd~G$<)VlA zj#=4VB_XwfpwV z5qtouhtt+)A??3m>oK6Rn049KhrB*4I$2>MvY_Yg*SmUBcYN%ZGm|3uuMr6CAq~jk ze0|1ZjV1BO=j7*8liVbw;Jv*oZl@gEBD_OX9NHW7t>6a&sT4zY2wW0 zWT9sh@oXdtBI*qfojdZcW}n737N_C&z@rk_1cbWto3?N z?AQr!288rkqiYOIMNYYCkeV=DPt?_HN^}Oro+@MLg*sXdY++$w?XjDfC4~etF(ie) z_EUXf^K)T90ZY+rUVCSO2_D00C>{RF#!fhKYjyvVI`Kh$5~-4#`x4;zsKJip?Wd&2 zi>O9Li(RpO@j*4r^vbP~7`h?H?QzjVx30|9)mp(^+XWQ=vzw5L6&1m&^hGOD_qbc< zF&={L{WjF1#V-ZQ(b~8Pb}We7`yZgbKkRVBr&V85JT@_Hix0DBt#JyR;UJz7gq!0v#K}4CE^|9n>S;}EgaBy%W zmOe%UgI14PZr`esWycr7e7zKMZeqKHjYK_97VwJ~tDX&zO{u&a;cBpegsd>qewZ+e zc{x+L9nZmPE6Kg6G9E=;ga;`!gsKF`=V5V}OP8urfR`6|lM*|dLmN`E)#6SZ0{q{r zTW>IeL{0RLQf7(seQo475_Z2QGnim{B75dQPhV`gUVKhW5Hxd;FLDsTc&XU>uz!;E z(476E0d6(ydaUXrJv5tR042AloTmDZqezcxee%V;9zRK<(cz1yDGRj^{4A&|Hb_{M z)Us<%qW))xd#k-48&9#nY?(#5DeU+`K<#rYzR16xm$#_j3I6Hqg6A68ZBx-(ul;N8 zZfbGp)gRP$e3G7XYk8l!RJJtrT#dkSeu5G8>dO)SAno^!gldiCfC1$QdErlFK zR$m-F1WD0uP1AS=rulu~J05RIofjuM9&a-g>$Z>!H*e=}#WQKBv$Z%KJeMbfM|-ne z8`}wwVSaKiw?^{lH-ONPU@r(5o$Q*deKkcMCGZ)^YZNUa&+190Nuiwbry1Pon+}2< zn16+zH_HyF_A^0LM^i;qL#j@$311_?yOP~`5`%qahSQggoirlAmPLH=VlKE}caO*>ZB!ezYP5aQGfDV^Hy%Yn#&*lq%Km=H zJb&en?~l!0E$8&Ls7;0r=fNbYjd(ww!HvjcgZLU@>QG0$p`)oawTV3#Z_{Ks(|Zl; zPdk^h8*8RM8pdKQ*YHV4(!Y{mxMX0lGR#YCM&RF)_?W~`$0{j0nRvcZ zYF=o^SHUd$UzeV=IjYBmdj&!i$up^$eiBTg$ufyi{~s6Mch==>e;;<5wr}Y*(hi!a zkQUrMbG0v&u9Oh8%Aq+hPfci#d-00(6s<;C4go%X{+1r;HTUkRHy-5<$h1i->tPYP z4COUeYx@FDmy%Jd8?x)u$PqQLY*L$5xmvt4FSH@mf!n(nb`$H;eP|D{oLJF&a&sa_ z0{vv>mB=RinI%V(XSWviatfZ!`bb+8v<^VsLW zK>Gqh9-vP-^wpy6TZnME2EMyDJw(BaERobZhr-~Kp3tc$@!X)r>(XCt|JtY7BJ>Bj zZ_++b1K(mE&ER@4+sr(#cHStrT40%iWL!qI3>P`!Aj_p*jMWqTBqph1-o5sw?SIsiaQH9iCsme7UemR9xU>UEEUta9&eOtV!7@lRhR?d_bSs#3Q`3cg}@YD>x z=@qe+6e~yVbGYB2_;ctd=@8e5UTZWiYbdGL#gT4u>W{U7q#_LNNEhN#IX$5cQj_KP{95bp2jdK*OtLx7PdBeqlJ1@YhyKLF87?}+h*wAaxMSec3LgR;eK~| z<1R%Vk4Ed4`{c4jjVi3Os48GrDyt5(>*t>4+5e|sBTt01Z$mfnp1VrfQ* z4}7=^?B-iI6<-~Q!+}Xs6fW+AanrdlEb!9#!h^K{D_14ptJO@{FQd9ooL9gDk`fg) zi&C*o`5hJQ98F4oGm)>}caMaG2ySs_99vidtvc^>oYNx%J^Ga$zapcFk3Tl%o^$cfuq7vKk*B2{f-Zz?EIB-v3q!%f8v#?rEYIx> z$Itk9V`o$<1S|enC2tSX@j$-Eh1vm%OLoHTO4+UAVkpWfi_%I@zsXshs2X$! zeEH`j00fevz_1uRl5M|1;s!c9Yh-TUyb{@h6Jj%0ZjL=19W z3tbB60_izr8s@sc1CH>l`tRRTTa4E&)H~|K(;lh5Kxd3+%B{rcUWmgAOMOSm=4PtC zrnS|-iMDe9-oD`HeoLv`ppD|5r)0zNt-+uk8+bRuSqHvDaXk?Adz=%TpT=OwNaCfn z^ppweH$Shxys_eEtMeK}Yy@@0vS8Jh2rEvc4z;=!!>BQ9w2BFbk)CUGWk~z!gXZq* z^;%ilRsq^NM<>FN2%SxCz`$W|(CY#VbGI0+0_j;_krmMZ zo_<3NnODx`g_SdCaJ5VXFLVn0J&(AHFoL4&G{U8$hEQ*ea!xhAq_5k}K>`l-Q1G%a zY<89N3N+&^A;l*tZXOz>~2@ z79odlXs=idcW~`s@5i0%*-=DJv;fN6-OvUFex-=ufKhCzv_3+nZ%=l{w(UAyAU`aU zkS0Tyieh3BB129ZIzhcmOlQFnPHXcejR+M-IVG2W&jP42wqNf(%&Mh&p&XVX6bMF8 zW*RT1bjM#O7L0rz+bVq>?Iv(QI~G>pOxu=k%71anF-`4hnyzpp2eWk~hu2<{=O{>W zLy5CG#<+W$(WKVXJBrLY8Wbwr&0^}=)bxZ7v;2 zv80_RTY4w#)aafkQIaMJcq4NUT#ZPdq;dli`NKvkX6KD3IRHJRF9fcLuf^?dVp`U> zteg){pV2GLtc7yS?JA6IVLjn&JLzy;P;~AG;Jh%gZ>5O7l$+|s%GD~5OT1&|ZJSp| zOxL+zdcsVv*M6xX$0;TC_8k?{*q3gogg?%WB+uw>vg)#2eJCN7zclglM7AHf^84V6 z-3QgF))&*j%fqZoXV*Fl<^8wC#pQl4bH_C`b2?y zeNjYt(C*OSxqh)^dbK3CU)^W1BwxcT2CTPH$%B*C3KCnDzV^CchMu`oo#vS3EZ{4&ND3gjInW|0)@FDQPY|tg(K{J@ZPzp_$sK$cao>Lz8XoH0_ z?3C`n@|kO0Gb-416VIwDkvG2Za%mp=saXzOG8WV z0deB{m zewg#}IGb#(F)Xqw(?ZPo9FttnOov_sJV1R&6(Q-nY)gu3exKgF53{3X*yiv=sk=1m z-&^g>Lke(4t&E4D%sTb&3KL=NU#O}3LnlCVb+x@ZIhqrXc^)>JT^o+j)59NWc=@ZR zzg@8G^c;bw1?9>c)_YgJ6mpX1;@dCS#w$+GLsEw$8YfNPTQVsvxCPkG*7S)eT#Z%n zkFHfrItA=>fVbcVcGeq9@(mwYKp&UZDtKxv4w1FzWl-JdsOXI#IXxNfvC3?Vc%GUq z8PE4o^FVRl`orGy(L4+KxoDo=`Bqqs(ZNRHob?D|RRX(bT=Xv1rorenFKqh_V$mtq zAkRltRk5#5rgD9y5j1Dw)3gLU$1J=xz5ur|Ua#A=BtxpMC+Icd1*$C120RQV>Z^s% z0}r=Z=oJ79mS=147l_j@*(*LBm={=#a@gR#0>GJU6?gpSiDG?gm|vma|+%796s+Wq4o7`CZ@RQizyySgJc}jxduP zE=}!t842*XEafdmOf0?yl{ly!$=P*=v?wgA|IT+Qy)ZW;h+7rJ5IjGf6%EaG-(4iL zjSJgm5!~mV*v)4-U58HfOl*S0_xK=gnvl6q5aL<6p}x8905=$ymoGHW)AeO|o*Uxq zTs_e2A(ig~R1YbtWz-h7n^z96x^kybL8U)cVBViGw_!ObKVko5`FxoalIgZ#og|fj)>m^|> z&EPW;V+sdR@70)j(16)F#kc0JB->Afzo(~PB}Ro%$;nKk>7(EI&hAI$tTbvm z-xnzn&O)6NUvKG+%mSF6`x9AkpY>6mZLH=3)w-g%3t*ZFF^z!=M>sgURzuncNRNJf zbeq`)vFIQrwx7Tmx--IDOyz~X%>(dyGNpNUKrNz5_#<~m+Bw~XoqglElLb5=Fnl(x zK50=(&QiLp>Ga~jRoBM>zT;7lIw=aYRMQgYfmI^i;# zkt**be;t4m9erLm=Ga)R+1l(TT`2;&JD@g|x$^>$Ki>n4M83;_I>7_Gc%PZ`P0=Pl zD9@#sw*y^IzU9p%&&hpce0MpdD%dy=lby`dx-+O59NY`XKIqBn;$E3*85o%R;4CgM zJ3kMJxAzjZK$fq)!BC*$9n8KM8O;%Qo^#e5Q|7f(ZqKf?Kg{nGybqkOm@78n+qKg4 zu%W}O<0c>B8tgZm@<)ou!HHz^f*jw2A0sQPl5~9?-XpN9u*@ZuEk*$s-!KC*s9By& zq-U$Q6efDM&#U!=>uS%Lal*E=^MV)jE{$1TYT&+I@I;VVs>TqoWMvN?mi5j{TP`@) z67mURa(*akyZLz9CJ@mgJ&^rl3MFi@@ycPEp4umlRHIMs>}&OYfPM|i?eFxwAKWmp zj7xhNc9hN(ZP@f+?REm}o0rwrz#gC1oeY&&F>E6 zC&R`z-|bIs-hRt+Z|od~2g?f>u?TDyE)F>mD)k{f7JlHl@I$Odp>8W1-hpdEFOQlH zqw5Z}YD;trQapJbbD=F&?b+e3+)h;ow}%6IM+)4$;=0h|K?f`KE+KqNip{YVsyF{k zBMWT&6ydqgwD<4Zj?wRs$(Wcupkq%I0wDD5P0d1UeEMIz`?-(3l2)AbYdavCbo~pOg<$#SII-DXO!T zPuu28JmH!%7Be{_UOaHuY+xc+;{;p_Sf*gP`;lb_$urejlDE{^_Rb2Rw+HY>8cwRV z3gPGK6u<14hur37j{riAaD%4iT&{&zA^Rmsu6h zM!Khhn^2P$0j@aQwd@zNTw~vG8{b|Oje|MDT!o?FGgjl#9xKi21hw)_ks-~?-Y0H3 zQ{PzRTjTuyNqbEyq*U_Qq#5p?PVlhf+@IFWf)NnBjD zLvY~la*Lk)riMBJbYU4n$f7!oX%1|fB{G-S63&I4lbQNMP%uza?8XZWdqPskYI2K6&K7_x#YxH`o9_^uBrhsfKgm3u04oWWQh#ka$^V>0mI69ZZqX#t zsk4Q04xAj9t8E}=g7+2mTPhb2vlTLS*GTZVr;ipVlyyG%8c|)k6c4$!wFDV_04!Qj zL_Mxt>JcDpk6fdlciR9i{!UP|q(S9i5t6(aA#3$|>0R|w%PshvhB&3?}s@FFXrqKivh0XATSeT>!1X;@9A$Oefm}G+odr0)lNX= z)jmAopQ?8(9$#fmWkPqma$`V7MhsA$?M%LYiZP0`J3Oc@r&g%ImCKg!IkOp(SE7a5 zgwVmQrSo_~2cTg|9G~X7w%kwC;;ye7+8tSU78{S9TH4D?n)BQgq88y_X4AOd!JX(N zs-Ald?{9w}x1~Lta;*88D7x6h%{iSM&|HmoP;0L_WoTm0`+wMbueheRZVyzDA}XSw zARVPim)@Hoy(kD6dT*gaKzdV=4$`|IMQVT$dICuAJwT|^J5mFLa$)cNoqHb6mUCb3 z(|K9H5Z0Pw%u)Yi&M{Xo4DMd1jm8N~D{4t0Pf^8d-=bi8Xhan+a$*qFOW_#ip_HUi zQZr8&^OJ-3X@P&2d+1olH2?XSjuh(q8ZPg{n%$moDSXX!d?{I`w?(CC2QH9zTC0&n z%8F-Geny0r=|ZE_V&T0pU%&e#+O@xP&Sn^)R!jbDdF-bCx;=5!(PpRSL?I>peY+Pa z=Qh8)Pou+dp>!a0G+TY6Ekf$|X^D6U&uA%*$>Ca`q`^7eC2IK%-aY&>Nn>T<)EOVB z(R4ztpU>*i%upRrm~`(@+CBG@gpiEP#$EzQiLU@en!`FpypN30flK9z$;e6_o&wwU zVb7ytjx8Tvx%E~5@2V$0pyhg%6ga!}>gwAfegk!tyz$*r7wRkP%+OxgZ1DB~m7^1d z_6^V_tV$P|qs# z;|2kl7#h>RIbyq!6*NtI3v`gu^RTXy*DWy4KS^)TDW%lGXtGLOeM_@mA*^|E|n*okk_~m|;ox7SWs0!d^7P6$jJKbDg zFz78?xmQK7ow-i`@_4>BUH99yp&5ieD3NDQ*${%cx({ZP`E1m9>heQGqdi@1S?s+; zkSbb*?+`Q8L%8jS7auo3sT-eX>JK4^Fnf*${#OCLN663S^56f06{&1*8mA8WlWtR_ zdKa-u-txbHcXQlLNr9xHG{pnH?Q!|*Y5x1=hFh87Nj*83z&<$xd(a}rU2gx0Qr*+) z(1`s43@v=?^ukqjFp_o@W~oXD!`Ki@FY*)}bN4P+=NO@cse<%<-+W-6IVxl#<^7gy z8DZerY;A2U3co7<+j9FHDaBPM$L7Ga_?g?X308*M8Fc4HT{fQ0TJ2Vju_H6EQsi`C#v@ORGDfl}OZ5>dIbQd)b12MhF zyP~-U21|UjYJ4n&`8>uA{-$(!$d3ef>u=&HZ;C|L2CNnbC$e_b9o)=AjaA--@E zT(l`#$206$EM@R!6234Z82}>AR}X|$8~W9Tk7~i7GaME4q%Lrc&uAI`aY1rdymvsE zylOih-75vC?VCKu91}fu3jd`&J6Um67EeV!8~r6t?WyM!fu=06wNx-d0lz-xmf2w< zVvXdHbXI-Mow+7hXK>qE549mMwgq#y80iO5E74wQR8X0QyM*^3)vInYb+|8m;aXB* zezZ@Mr!kOI6p5q0azd5CCSEbl=goVM6Gv@D^cph?*-+G)+xsPxo|E>O0goz^b9K`> zEy}j0YeDT|XcLv;hqc70BaoLqrB04_;pb&@`+8O$rq3DhOPMj{K6E`-^Rr%zmw%Vs zFiebPPnjT^-tAkq7|s+PtN`75J)&ygp!6Lh0XUd)^5ie^!`^Pddj``vc4qo|hbz}a zW0$sMAhhVuc}FfuIJx~#5=T8q1!bqx|Hc4yST-+5Tv9r(#x%z^*Dz?27S2z|(o?aq<@C;<{512-XSyHdoj8&kod;wnn z-^Asv;g=3^Ka5$bfB2gw3ZM%5V2P~h0K))%o4kV}rXF1f-wxfVZf%`q=7%ZgDJnd8 zI9_fNDQ%0iY7e%3Uze;Z>Q6u^$li^xiG36Eyi9V7S*=Jelfr?40`r=2H*Bs2Z93r+ z-o*;}x|FO1d#h|jMr+tfZhqLkkH^k=oA>@&W%1W#iP8b{681U>Ip!(vyx!mL&ob$; zW?nGdPah6>0Q|OqVtn`M-=NY$U|N6pDg6heDA=3%h z-fB>{)!#SGJvXH4&i%VG`s2kEdaG%oh&b2#?@9jQ(s<`#>QV;AO#{-*;bH_pd?d_C zZo1L$RukX?|7IS29?}SG;F`Mn-#D2o24`=)>Hiq~!v*Uk#SjITqH+VkmGC0F0bg!> zVi6mo0mlM2{8(PIWO8$``0cdy-tqL9hi?0;8%>I)>fSNE06Ekuh*h7|_BI4oSMh{t zuFX~3bSTW7%X~gV?FE;vhZW`B8$}isgjFsgAndS;%4!103Vv9uo|?|9GeN*3kA0H8 zGX(9EybbKv#nBQOJfK9$KXdhW?u^H=U`&}QB}?3zh8D-NYD&XTFZd^}f?NIGg@f3 zih+;_^?beJEX!|)1A`0YJ`27uOUjKym`04yP~~fH3y#Sjy~3M(B_OXPF^APJUVO&& ztlE__U)9yJt#kHp*vKs%nRVY z(HfLvx|_8ErHp%YlfvEZ9`g#Mj7l>at8{(toiv*(RF#_;qTk%EXx|))+c5n#G}vNgqQ4lxs1WqNU}R>_q*#hW=#x<&=&t=wP|+ivBQBb$NxQTECqu zGoR+srtphHYps~5Im4s|%bZvaEd^thbgn~wxnSehInL;Kt05}kBXzh9Q@&PVa*=l3 zAi|LXcjrcPbjCg-OQjU_Nv^Qbl_eV~dEU^I$bm~h?cDV-D5y&r#t!N;=#VyTxVjuQ_LJ?vXQUZ*|5FMjlgWX;sU})kL)(YJ^GcM*67)6Q>0{-OZ_J+8D0pxH8~}{ zTp~EBz8p6GTpt(N@RZg>34KMi3}bw7A+JN7V1`{!7)p%)aO0GZjZ9uH+K^P(F?m8_wYJyFr52=w{~;Iffr=aZ?&GLSQSXNO^Ia{c z$v}=y`r?$XB}#4ibL41RvE@ssVmrd=GHqlslh<^G9I)=FlRA*HZZAcT|A zWNDJxCoWGZ3g9_xU30lsrS#H$EUDOC>W1**pUOU0HD?oS{AsBWmG0^x;);UyS&aps z<3?8ZrK2j2)XuxY_=W9v?VeyED( zgO-1{*m{xxbuJm!FB5j%0`=9YY)-f}<|-i?i{hPfQQP_B0`f{q<&y95&s;5sM{48~ zB1pPR2gLF{h@ilCWlaE84V6T{(g+iB(}3;>Li1&&8(q>9>mu~%T2mxlap}VODK+aElyswNjBaH`qZ_>uWRN}%%=!Zv8Z6Qq30Ic3{^c42I_ge zng?|E)zCnPHvywv$$s{!f_=@h5%P}Qxh3&wo<|uPk=Xx>kb-#zvh+Nn{7RkM6AvBK z*pd>e8Nb)}Gy3vYmBO@XFydBsA(A z_dz#7jK!B+2{CtOO&ol378b-=!t(f_rp!#?J7#-z4g%_ZNJ}f@IL%gzfrWXteC6w# z60G>WMtA^&jc)(*73Yr>ADcQ11*|>^~T&vwXiwIo(ueXT2iZycr>Q8&l_1#8y z;tT1Y83j!3w`^3x0vPD`Xi-z9w_!O7k7LF%JR2+XFm&;cDs4yKTWb_9LSgp+nUcm^ zY3MdwgDze-G5SYWc@7yCM-FqG{KV7FccXsrF|n2G2ZjOA*-j+4>#2zQk-wN)oyY48 zSE4I`bD!cAcCd}q^Z;3H4D+Qk(=#x11}Da-6M-56#4DiuEWiEN zm=7>uVgnl=!-z|GxtKeS{(+~;7$v-W%PU=gf2t>SEUpc0seVRaAcP^VESC{6(zc@R zLaw0gzh|b{xgU9`To)yX<@8O$;f-GlBLh)tuYU%9&_4oly}Nqoug_>&aV5sLl9jT5 zgBtt0SAX)0YxUjzCjvf?0*sM)hyjF_i&zpP=rQ%A|3Iy|YQ(@s zU=On{&@`TI>z^CZ*c4-Aq?Eax8Ub@fg*d}kUs+)yg&AIc^V<}qFj1$l&~E1Wk1f`` zl2E@`1^Lxbbd2ajB4Spwo1Zla|NXxc^+w0yOcWItw^Wc+%zvZ1sEW}JmC>9UGnD8! zJFyRe$TV_bo=P#icm{Yt85%b?ClP$-Ui_PVs>dD9&wNg9jpO}OaS_WYs6>C@uH4M8 zmKJU+%EjvG(P!PxYleQVyR-k#*tXZEd9>0!@sDXvV_wuEUN|6QH^l%)kylRgXuNDE zF_xWbEhDXFi=JJqbE-)BYfJXyt6<@%)6M!{6_~%D-z~fccV7~iV9T55qIX+A1Mv-F ze+2%mhi&3HZCW>99}3Zb^rhEmFh+Ke+Pij1C?JNl_r-7K+aXFBDe|h_>L1JUBf!)J z9{Wi@`6pyo8(y)>o*04u55R9!_M6JGqv?5mW9bQaCgH%x^3ICrrjqNS1JPBHiu058 zh5@hS^aK;j0`e-3@1|h9pW7v|1obz1LI%p;)FUVoL?Q|v@FZ>CzKLDL-wAxi{d8Hhex^VrhZSOqBh zAz}!-{};<8rdAG`p1syvl!NH#=9#(5mz88BYm#+RM>N>v-B5XQ7YnB>fjF9NMx3Ijy5)7x@Vlb4WHJOwvZ5mwuh<8vR^cA()FA&jp8s_-Hyvz z0sdE~(~8G0Xol*I*e2CAhbe)Eu5-CN!|%q-($${jdqe*LVid{NcdslV#`@NM1A~Z zu6KubL)(>Tyw*9x>$I0{Wk`#vL9gK53)U- z%{gYCHY^)KnSdRtB@dASWh>rrHE&E#g6FyF)71~;9j|_B{`GfiiFy$E*?7WQ2Q$rMEW6JOdNgpw1KJ%xt zHn)ksD$U8hc&|q28w>R*_^k;Q?new2D(bXnZ@u0~?VM{tY}GBnRAuCQt>dyiMnlTo zW+hLKg7WuTaXGrn7C6hz(Cl@%-r_FR@o5)civ(ONvt~p2diMYgj)h*LuH{~52yV4Z z-8CNB?=U-qRdH!%y?2_mZYrV|nco>Yrm(xSi}AYp^h$LZluo3?wl6C_V&UdZ#FJv} zh5B9evoxJW7D-1t?2Er_INxDt`0bSbr+^`ki7Znxz-|tp7kefj(b6KX=49OtQ9^#Q zZ37PyDx0NJE?rX9>lJ9iJFq^hcI!pLneQc(!~?G!zCLn zP6I=ZB5~Ei_{@JTF(4*x5#3q5je+08ke3=?PXBzrX~HSwPt(xCs%QpG%tt%Ttujr9 zYH|mfYwqee9CegEb+5e~aEbJsQ$*#|UA)q=Hq;EodD|V&{!BJ9?f3Y*Z^56%Edq+k zEYr@=HiGV4ny#BjM&1G{N5ohe*X*ffbnd@AF=JFdIxw|9egCOidX0+gm`A!-z8HUXU; zEatijd-k%j-E{FJ%;)qW#PNYa5$^iF{))G6d-Y=%ivnj!Mb!9gr}u3Fcjr8CtXqs~f-xs71rsVZSjc_knFpdG(L! z&8u3b59yUHuXonGC~n&L?a|(eCx=4xt7x?nCHee!nW^>1(hZPx$Swafx`$UlzNyJS zj58%e%%$(izpsplFn?o;;N8yLjVv7q3)1AC`ROhZNg=MhSh0ftvsvn#s(#elx*sW( zI|jUpUi2a&JycU6yn{n8(rR@@bNd-<8j>%e?GR#7q}M;h`kDraJx>%v$L$QZ*cu!X z`eV|COGv*jrS#;}!nU~H#&aeqRzdaDf^3quPkZ!92`Ov>3VN58FftS(ODGqkeY_WE zCc$w{1`%=BOM<=DPjcKBYRf%$E+DSOl1LJ&1|2G|Wm{5v%yMrJx45e!Tmr}YB+ZN4 zCxnhMPi|5(JVz6%U}4*hiM3ZQVXPMNF_}^B#hU>h?h*rX(k3>>hza{nK*u z`twfi<<9K2{ly8~Q@O46C*IaCuM#||z=7x5G_?3&eF%|f%cZ^6QMN$%h{|rL6lXG5 zO-+q%*|g{}`@7!($zne9*&jcB`hw%jbZ3#ypAsD*zcwEY@Q_3IHjY2(e%v|aJs|MM z{H5yO6H<1}TU;jY-)CXa8uD00UC*;s-_lT%ysM+q>cL0Sn=nQPHzt5Awb*tD6BvxF zZ-#rl)v@>Jv)K5AeiAa+<$MA_HBz95v9hg~*z2myn;yAxV0jwF_EgZP zp)yl%CU}JMhN8}hzCm- z(L7P6p=n5axe|KQjdx6gZZ%D8zOl%-5i0Ir-RWDdi%cc@QyTosBR3z?2&7Q1Z{7%0 z_tLJ2d!eG8f8I!)@*1d0rFq|k1SQ~C*f(WI%t__xP1MV!{N`+2e?U}kG#j@o;``IG zeRww^I0@G~S2g$p&{6P>8dA9;4o7zg8r?|!!4>kJ$m|olaT{nB?~1q^wIE~IP1Gl@ zO9|nTi9h6>zb}izSHw@YX;(hpNL~2KKFouJ(9$=VhZp0+*qy$_zwM}l&>#C=LT3hK zS)t7M^7ZseZZCA>@E%jT(S1b8l_b0SqsNxgt6~l!C8_x7TUuNL@av( zG(nRsSzv4_FW4JR(1l+mYN~oN&7YCLN5a29xyGSeuRC+@@Z(*+uK!%o?8wBUf7PcQ zAx*KP-D!n@=2ca7SNgSm{1OX7z@R%G9M9BnZWS0f?J@l<<38n5QA!LWLe~DPxh=RH zoK}Z2KYl|*M3lzRu9_;abCm9}t?bEq>ABy$KNFAt?-nUL=irrEUujv=gM>~mV9@1c zcl0G*Zj?Kx-sL4KjXdMgmXQVTu5A*uwsviVUUD`~ z*ivmY9PiAkIUZP)Z?!m1cyq}x`|Kx)aQns=qZgK6)NQQ|liusM6YvTI3ue#DAwk2N6qiV$e<*-PcebeE15n@R*F-Aw|ah=v>(9!Wor+Y0@ zow!a(4?b?ez9-XR>s=Dx7QWt@*(__iT54~$zLRgzw&0V<8pjf!AU1}IB^xaq7iHxZ zjbpqNl5*XgqKylmrMK1T%ArJN*P%o`QQcqO&Q1y`habjGvqP^+87gNX5;nE*T!U@* zr6nt*!b_Onp+G#l4qN9kUdiXfjSh`z;SAJCo>lC>Wked>yV;42tDV`>YZ^J9UBK^@ zE2`G2!#5Tq#Pj3^qu#7p#am<_6i&)9lQ6SBp}iOUfausNsAQ=uAW>v zmD?{DpkkJRRS}S3KeHf3?au1A8HqGN$-41`%C_Wh^QpeXT_bD0@&|2fedpGtju#Dz zW(Qi-DH6NXd+4x<2))h^M2}|-JqCpWAj!rbj>i^KH$d~v&zhI&q62gEQi!eM^Y|g& zD|RW{fQ>W34eF#S!(hm%R_=L&4>iXxqs%^`h&Ul1o6zNO8;8nEVJXu&St-iGO|&Pq z_cK*d*U0*#p%|-pVRK_+l`c?~2u)#6yc6N1rs-g^!ONi_e+0Yys zyhsp3HU20yoIi=ymrGQSpIV#&KO~`|`?gZ)D6EB^u`_WMN=WwfMHQleLsl8N5alNk ztgP_$o8K)w=7%)0JzT10@U_;u)8CR-THDX_wTc!28u8Rq9KPGgD;VcXHfO6}un7Rw zvkk+=4hQ|u_M}K@0c4rVd7@@fr`j+cbDsM1#C9OpCK1a*lI(t zz#;3!7{{U&)#{ulcW51F3q*EntZ-Njt07+7y5N|LqpKTiLX#PHj(lejXv+>Qr{4p= zAQ2Lt?6Zg+dGbUy_1bJD3e=~^9GWBBI~TGBrT!CrX~<6MhKT4#2K5}D?!HE*w-EKX z0|&oV;FuqNK(L=nxk_`C!t4krg`S_!QhFgS-v4U`<@Fy8QV+@~1Y}o>^5W-Ko;t=J zr16es3+uCuDWT;{_&88mFbDgj-Owp<&*aB^Fgsos^mkINBQb8UZ7P?j3+Pmss2;?T ztbbD8xnP4%$IPQHc~95t^OWiPcSJ`il%;3ai}rh#W*z^6<3%^Ld#f@~i#=M4xG!2} zHZp3W&h10dM)%J!dZQyV0)Touhp0s)MQF6~>*vF%{&{9r%zyPz9@G3j|7c*k13%BI z`CVl@yLG=}#-|&~_qvpCcj-%6mPs9-&71avSZ_onvcl0j>10gg#Nxs@#_2<{Jc-vQ zrOO5TI=kO!aB#`k-qfY2WjpxXZO}=0M^OivG6J0f4m|}9O6>5P_*4w1RM{mQF|aul zCy#E{U*zjSYTp%nh)$#4I~hBI&8G2prdb5kO5u)0Gv!tl=f2ag^@1wb*s!FvXS~g| zuwGJlvPmpjQmrK8EiB1rKVdh_I#vJ}rI6yCsBlm59&=}-4< zfmd}Xf?*bc#rwpp(EN<85N_Xe9$2i!#bKm!nut-)N}u-yC$OX_5_wf|N^+e++_FuB z=Z6Yj69q@i(Cv8ru2J6iYKCfcUfd3{Q6w8+vkjQfFOVKL5A z&30zh&UDEq9Lfc8lM4HkA5NOIHH3$ULi_=GJ3j0>Ra>#elMJiOYt!FDDTfh#iQ*fG zJRjoVVEMhx?%NchW|NhASDdwKpX!cDeNLKzgvJ*|)hY{hnqD$W5qx za&qkgi1&%A|9Ka{|ENq!|M^TK^RV&fTs{jPYdU$+6&zYk2R`A1TWkeZpAJDiVTy%j zgBP&Axy^5Jp-Uf(0}e{m)VK3JeNa)JiH(~^!w}cja5u%lfj5(t=!{)G&+hr#o=fUP zQKFAYfI}?QamLH<`!yi<{VwYQIyxObi-F8mHUt%Vq!%bFp+QlO_&} z%IWS)D==Q)ftaGwz185lq@FKU_7u4m=q(5PK?wT=)48CG?gR0aFA<}KV5eNlt@G|g zNPMvPzog4{teM*C!20o`a8VXYgUW-Brafd<&7K7~#dI=w!S!T-w>#Bh`ezu5%xD`Z z9D-vGEfREkW8C9n>hQ&6RB*N`UBGqq}*^O@( zZi7U6cf^u}D1K!Zlbeopj-Yq7!H&U0e3m*LO9Ifbov{rqckAUMGkGQ^rw!@`Iq5g0 z2PNA3MTdfpO}-hL4Af~j=0Gj*3nTOTmM1{|94nYZ<{e?MKR^ep{aS}#ncn;wd{JYq zj})+<4rNIqJ*j>4eKI(8mM`nxA$6yE*uh3^Y@_;+v7>EvgOtYfyez8#s3mx$SvCT> z`xbPuI=GM}3IuJAoq~YD9JXt&q)f;N$2|n1yCIa$nx6DpV9id=(aJ2%9zuLRPZs?3 z(XaNOed+LmgSp&ho|FEbvDn+mGOKLgnl+y?{I`bDs08eQ-t%F@;YUpDf>7@M)|~Fi z#^p1heZn_xlqSe);+FFcsJUz;B6^+ky9M>yX*X)GMclXRw~E%WQpH&teD8Qld@J~Sh#u{4+Wq9vObvDcjYLeM%sqj2P9{#U5iOlG0{@YD!E&l5A{ z(cw@mumC~momObs|LcKxWOM@!T%d+u|XV3G{nLh(Q4Teimpt7mCWU zD&7g7Hk(sK$=edejuJvoe&V8)hf5>5nHWM!tfZK(W>kgcQZyt4Rlf}dA6*W(JEaL_ zi&V3d~9~VC8sz2G8uAAM?eUm8{ z{N+y7a3Mn49lyuAe?i!;Mn#PJARZsSJ`QP?iGWN(?Z>)~ln_)E83bsA`*C|jS`^6z zs)YOXo|)Fn^H1F)36dERr3=05@2gbBko|};PT+}ebxg#+v=DYkVG=2o?oY1ra(PYP zT|1nNOzWEidam8jX&vG zY`FwyeNqOOj%*KZv!FJG=~_dG%VBoYV`)J6WH`YDGnwHFyQ8adhtWnG z)QsDBY&BBKbs~h9kUE1V4OvC3EPi%2Owc*Zagd;e_N7aX&{Ds ztu?{gfS*5qDp@ZH)SUFm=4f=can0|evM(>w<4GCPc5-_sv)$_orP~vxVV)U9dJU2x zkD2JE*?}Bnti78<-+XLOtcG|zFGRr&I#k|s?7}k}!qi^u?g`;wu+xaRJ_M1_&MhR9gU8g=8WJ~WFmzz!~ z4BoQk?1-+Vhv%zb)6)Gn8)5iPfC< zGZ9(~HI1-ns?FF=%ct|26k69nTyG27w7G9Jn5N^;S@&yGYE{Os{aTlE-~9cd-G<-0 zU9$!Swi>Eca&Mn^hHJ6Edyk{%RD*vDC}gG#*?jR!QgY8MZ+mYwm2}8%zUt_hok>S> zd3%}(ZLBI(;O<3$cPG{WT-$_Wa(GtJ4nFERFE??EJoE+}dqGB2RNy1M@}M)q)WgG% zZYke3^9(LoJqdDMVeoS#`%u2Ji2;Arp+W*PI~&hIMQ_U zSbh&R_35ak@LdTF7=G{(zh^xFy$uK4O-|3WhYOGAzDC^ocJ#x0rFUg%h#O|lduvls z2i|2phk{iZ#9n${C{Mtf?|Y?x6 zuzd=3M7}s?#ckF(q``0t4W9a-N3iDMjyrkp$c)HvbP36Qln&?bEMEee{+eGZpTeqv z#U*6;j^K3iC*Iodj;yEQ&h=tBH}KXjNW!(i@!@%=S)>c(ANAY6*Du1VD(V4FYdFj; zeBFNO?K_abWj@uPMN06hSBn39d()%}RVn_j+toF1C5HFXeSX(CQ=P_y>x960o@zhm znM#_eHjg&8svMJ8uT9x;tmH3MW*kh24`gU8r2nmCy~vq>dh9LOr3WGlfs4dV0!I^c zfCz}FhvFyM?0hG)rFE-_CQycUna8gzu0m8VVM;7r8H0xN?m#KeNm&TCZLqf;+a>t@Xa%&O{&r}SJJzKBfIB0&16*0bv=3BAGZ z6YAACjwi`shv7 z`#*ME+ak8`*y>HM8pruss0o+T<}J=Jzc14chcY^BnByxWM@LeptXv!KV~YKA^0EJH zCcdO@)>lA=Ii6|0_C>q$4wvW~+UGxQ?3L_s^A=z@DHtuhmWleiImHK+ZbifTwPdMm zdIc>2|1neURdk=8XHV@{Lc0s`#mMr@#%Gf$RmPw8tUU799b;JmQ)j*>4K6*Tg6Xuf zk@7Y+sj)0NLcKn^lOvD2wN-B;$e#ZDsV3dT#s&uZ-SO}Z(}Av5i||ViBevy?;_Dp= zdXqi`pGmJZz}I{eU{4*2eh)ztP{j?=hj#H!b3~s)3&wjRC`5nRI%g!HR+0Ly$%Z|B zqUbF?_1ymGBxmA@H9d2{Y`cEUr*1?C9#J;sLF>~KmzEC}lPqI)Q9=P8*il9@%azVPte2G+Zd6PCB(_yZt0-7aKFba{;%XyZ>IR zGM$VNtvnyE{xDqV=7;~AO860NM$$R_a8RqyyFa}_n#y<0djg8`W94f4g`3Vfxveyf z00dtp2?2Zm(5?h|{+EUL@vLvpQvCtND~dYWJG!qugEhgLCq<1#c6k_`U2)9EY%dGZ zBQ%aVAtY%}UKTsNtx>wyv+l#ASB9fEtf)>w3V6dKr(~$v`fvMfji2tVKCPIQE{;zD zjvOL|kACV{C>mguvsQs|ETI-faEc~vd)&oUy~%H`Pm*39+PiOWaV)Lw#;8@Aax!V< zeyr;C($_El@HVCGDhq2mk$P&9k5_>5EPo&MiRDj2Q+SJL?R{PCD&gBjh+be+LAs<%eGcbdn4e*#oaC#T zw2nfdgB!Xbkuzp1CxL(7lkfv$3K18>UraDY(TiFfx_D&BTZmY-i9}lPPq1cO)iuiA zn?D>{bBePS(aTN)VNZ0RYJ%>^C54oQTnF17Q=3fwkX%N1N&8Zz)&?pjH$@-3PtPu< zZ)~hG!TI1jpIwZKt&RZ7AWuePrNU%Bq#G&7p!~8Xn?f`mIq9}ma5z+Ihi_r1$pWgY z2$%P-m;4%|EIe zyy@7M{}kh#U_qk%%C9^1)_$4>C9iK+MI4rNLySF;8T;8bYhTT6I)*HGFNeY0Io>I` zeHE=N2(%CU;N+!-avu?>|`LmV`Y?!B2M&#{btRib?Jo@dP)n(iSoVOE}7=uuDA z$prS{T?^2Rjv=4*{)6^hl7o`9fXEb=Mj^Y6^~03KP{kjl-_5aN8%4@2_fcDKBx zMj95Ipq*hEFJbPqKbz@a{@(2Cs*U{Kt|AxxGn&xQqqjDp`WQ=C#kT3oK|35Y8{v*M zh3&d2%#af*Tg%Zma&jJIl5L#yJPFAV{_KxCrA$!(PT~es>S$wOg!tr666$pxr5Q{y z5_xZncf)ey)eMN@y{g&SA}JxvF=cAJE|iXrp>qJtD3=l+-p}%~aEmyEbv56;PARbA zs$e;)6=UUT*$~paIaECS4eSTt27eDKGMU*;rxZ1(L?0cMz%*qeGoIgzFZvoaXK01| z5pe*^A9KgGfI<76u+EsS50huR^&F%ss|JDow4YA?S4#m~6F|#B8C3MT{d>+8O~hSO z#HGNHutET2ZLRddAC&0yUBbNe{aG?%oQOvfpvug8L&83FC-lJ7=4&2h;H2S7Q_gExNp-geZ0YrC1@D$K1}Tm z&bZrt+Sw@w4C6x8@(eK6U)MRKJO>zAMNtmMAENY9sb{=1^@qx^kFO!L5Ruq zjqK8MrZxdBZH)4-)XM1?^K|8iZ2pw-1(j%CzLaL#;fCgC0-iql zBQm%ADPBAz&v+rL(vou#DaiUh1Sd#7>V%s2PaSDa4H941qMl?VvX(gpJ8hcQKW2Gs zjtOn5*=xC)P*-Glpv*0dpvJPq55bCZv4o$R>3Ke0<_PM3`1j6U8t@&Ga^<2s26Wv*T-drn)TFp!*9T^El;W_C%6G)j9EV@Huh^^AbASd^RCO_;1^#?N( zBOZ9%PR21%EosMeMYfx<)$y7v4WF3&&)#pdkN;%MvzY(GgH8AMD9I>RZ(umjuk9X> zU6jr>!+Y|Msds4R9?PkyM1PaGKrLYz{rj{2Ud-QiF~i9h<6pVZR(YvW+}!12edY2s zrwa>nH+H#HT{rl!Wjt=bvBRfEyAj+pA&Mq&Z&k2Q8w-Db^Lqjo2{9V5EqISl_dIFM zkejb923NWCsw^^4b6WuNvKs^E!;aUOk^t`_$TC|35og|FOXvH#LJc6l;wvxXvr?3F=*?%yYkjLdb!?iN6@m6QC3_d1s z^8wbs$HBJHN|`IbG52({Vqqg2i$4#F=z2(0v^A9*tcxtMB7*=fS!0s+6S}`MJk_a{ zeha97uE5Zn$cU5)L~0C=^sXn(UYyA?$8*r)uOm9v^*TG%%l58-=h8ZhP}0m#?BVIz zQ+yqIkA1$i(PER@Lzks!lXkPN13@P#FgqbJnN#2CyPG)mFCytEpR<`t8fjhXj*r?i zQ;-{c9<5g8L7%T#Q=jH0%BxptacPvV1u6fCg&S=5y>;+2aN1c}{9x+V1k|&knE2__ z7dZ;VF(ql*-5^nR;jvs-7|!*tEiER@*@Vd-o^25{D6A-Irwa?zIfmj_pAx2udK`ST zt+E(FxXiQMN_ZgQK{_Sk{g2RULCiCOLAMay9h}tx09~kk_w+ zVSnf*1ejNr_ysE|OVte5SQYt-C=B_{&C- zJ8i08<9o@wRKfUx@8vWH!vwXxV9!+0?1*2u2|M*S8z4{P1QjIFpICV3re0XU6ys-^^eB| zbAYaL_UctDxhBulEGZtCM-sZoGny(DPiH%_*es!Gh@U17FZ9CtIMh+Fzc7PlhVZOs;!`DMY;9k@5ea z2LU})F^bW8mg~9M*>Ve~&}?(4LgmEmpolNp6?QXn%dGF2ui#nfum($<+brAuokcu< zb%vKIiP-)CHwyfV+{6bpk4Wzf^rfT0_b+U+d92^?s|P}^H^d2W@MApDGfEDK^FR}- ze>YCn$5+O=8Nr?ZiKIBJcCLBW4l{&=zu38Ha^rKmN=wJ}Sps7sFPGSVdjD+@PGSr*8%Dz`;!2yEPa}|F%Dt9Bp<2zeT*>*C>2>xyj$u4ZSnMZrd;OSa|JXIW4gE1_m=* z!3aAu5lVmOZ_HG|Y_jC8%~z6V>q8~1feY+Le^`)dWYZvYf6^97aTm`9@|H#%Pp-{I z1C&mXSF9kCdc7gCI@An&xzUKkgvn>s{Drn1L?JK z_!DL=R*U*#pV@M60zUic93TDG@8<2?a`36so zzW>+Hto+xH3jMc_G@jVyYyvtZE{>x6E47uc4!f4Qh15OkP4YO5xA&BP@AB!=LOHDt zmD6F5_qZw}Y?HH6m_e*t+04%M#=XQ!r&}x^h<67t#x5V65ntL(heoLKNsg!0RTKG; z(89^?u&}T^F+FUej#*waTs|bP8u6%3e|o$eD%A0al=M^jInF}QNw-I;?xmgd$Gbm# za2exH$Q-!uc+Zj+-2V3D-JE(rnJS9dAZT^huj#Rfi@C4Jo;e9*BK_5oq(} z=b?Sxv@f&k2S(0%zTU|@8>-Rcu0P6p_MTg>SdXP?$~8aM4(@a)g!4nN%1+zBAj=Oz zggC2{!nFt=J6kQjY|K-Vr(-mh~K_@C0p(F#qo@I$P8-*90-=JFb z5!|&nTh(~nN(o5cxfeyFLY0K6`1r6us{V!uZ`_DRz&Rk|%a@kYj5gz;>Wl%XvyOM) z%4}H6>MUcEq8Un9NN7G`mLbdWd+mE3Pmy@Ac4RTL1JI@+;+)*u!wokOBJ&8Y{y!_} z?~moGG?M|4HYU&Nx~z{0nJuMdJ4QPf%%1yild(uc^S^zJea@b{4b#OoN#QLD#{m`m znj2LAqLGvr6p_X`{d2k(+k!)PuxVlggC8{T4ihqz?c(_H?$5Tiw#=}*!~`C7;I0DE zh{Cbk&o(C87+Yw6yFT>#^}W4AkT5ZhVJUn`NR9cu!lMj9H`4P{m*MtBMU6N;pv?-0 z-l(Ke%@|U-&ZR1?m`x>Lt#es>;S>e&&#*yAnAMlG^iDn_xbM3*kw?=H)y6grlxi-$ z{Ehb{HbRk4r6;@7E7YA>=F8n%W!H`&T?jICF6@M*alM~8Zj6X~dU|*#O;i~4lVf$T zI57PJMe8%>KarUM50a#=kGMwy{-!sU@bVb4GnlETDBaEB5tfqGO=Az>r*?I%{BZf5 zgVU@HvuL6e+c%8t^R^!H*96Hdf)qjK~>>h()=fPUg7 zUcg9xvN1uZE^gCpBy3$}$xZ6LAax7p4@fyrq-L zDvwv-Rvn4(a6CM2d`KBzQ66x84hMTLQ-b21_b***fcuX7JuQig`wb`ri#7h5bS&FK zc%G10uoXASe5^K0UDhe7IS?3l75Gisx6dt4rM<)6V2p#sFQX>PY7S2JEB}4gds!0q z=O5<9-;TY^J~dV0&F8WDegV;tS3c@U$n4@_q7G$r)dVuhyp{!inb&{)M!T3E-GBj3 z4&tQi6?4!<*eT1&HKHwOf$uW$&=xQU>n0|4iR_+R1I z+mqe-cqeish$(roLrd?9v|7<&QFmBWepjqb=eyW^XD8o$(+Mw^GViW5e;&;h{5>iL zb}LZ>kxlY&%~aYlFnZ_#N!Rp6?G84^VVn*TZOT*8@k zGI*w_o1y6XTVXG`IlF$8HK0$D(~?2nz*G>Di$0a4QO<$4v3X{@r@lVhcQ)&~^=n~% zHWfxUPb}t2V|}A6VfKsOa64nINM}p~HBb%30)t;@rJ=6~G*iTTQ#P+`mc_Rt?)Ver zn2w0wz+N$UzkQpDuQMo{AUhiG+>CX8UXU(RyqW-U8?FJYr07`=PH8O?l1CXS>!fcoNzs^ldkYq1?ZbzkDWm z7^%7qz?37Kf7~P{NRPs2hm`w`X}IlvN#*8llH0|n~=?ExwZ!zId4`>?yJ2mvHh7S+n-cU1KjDaPZ40O z|Ndw{oqfmPG)2T;01?rC`EcLgLF!hwbh_fHt{(bQ=`c#JgOPjWoiAtI-c*FZ7%bO0 z49@R*8fipFIROv!uw6}Uf^%7?#iItu^Y(4@5%CH9S zWVaMfqgT7*>>kf=y^usn1j%u5aESS=Q?90$19D4#U2W%&DT7lO7H$ung|Am;`Q28y zLwyCLQO(!x*7_4A$}I#}KQHq5oNm3DYavPaV&%y42(8mh2>^3|%50$?FV;d`zpokk zJ4I~*dLvLkq*_TQ;XA!8_6=4r&;tVvYw_k~&MLj*!FIUki=U^tOjpIlk zgS>MrSGV6%=@FUmGbxPEqs{m%KxEb|}C1ici- zBZbqd<7wwGM13$PB6Z_U{v^HWJ8CwL4(>UiS)r_48XZVC7|#8P>=A+^9w_|!ML9fO zLFsxJOe5&fw0OYZ1h9{yYJUDs`WMA%2Iq_L@bK50n?XjPZWFsj9DV{19JLF!iR4yX zr>7F`lFM5wUxTZ&!NegNWM|@C=J`kSS7<3!7L24xWzifu79C=z^sqD1&&GhXv`kg6 z4bVBF=Z$zBipAPAMic*z2BrJb>0fWq!z|ED?*_2pBHAw zsv1s*RBtxBdG^`0inaP`;5)gnd3Zz9{wR;&-r6Rf)q^)Kn3l6mAp@O$JC;T3Pas#NGOfZC=u zHGb|jt^v*Q%;YwEE`*SMbp!M%vbf|sfkw=+bJp%(qKgGhq2TJwJW;xr^nD)IO$%mi zzZ*#iRR@NZdMqB-l7Bw7n=ly$|002`6W`6$K9Rurn$qY`Hs4zaZ`Ov zNgaO*fFxoX<6&x5S}8EHFp*>W?LD>dmb#fTqt4hRKh)ieZg63LK}JB9_p}n~LKP|I zJ}{Q7?d3xIi*7G9&Gt?1EOjfZ!LIG@=}Zk33rX~cJbm%KxVEdQ&ST?0^QA>sl9Wvq zJNy9weU9i5<5@^ySpRLb%@q1`^sxG59bVnvcXVq4oL(^_Kc=pUq)qy7hYc!nb?mvB zRhXhw+IjCwH>+$Y-!9y|8FYjN+X3BR3Xf|;C-o&o<9AK6WKuugeV0HsvjxWyEk-HH zi+i{r&5?5vn#4wGD-mH!_x=i=RLngX7_L~}3qL%1ow|J@Cu5?)yrCYGKarZ+AfY`e zx2Fm0(o7LZPh-3OLx!~t)1d}}LDhaSwK!B+k6Z(bRQqTj0!}!#!S%%N1+OZ`Z26#C z63l@<9>2LaXoZOE-zWP~ACT^y)MA18(`rur_0&bO;OgJEczF4mY zrF6@UG@wqlAh5-VA%|Zls9GH+D-sy%_wy3(93zCHD#< zf?IwHi%ze1Y!^g$*|0X)t~w9AsAuYn?%U_tblajqe0E@kk% zh9cb`1;B~pLkD*Sx5&T6-heeU=_lhT@K3Ulij$-@)3+b1VBiE!KXOjK^_n5{3;O z{uu~B>r+gHqA(2WjdsKBg#z+H?wf|tytK&}|A9~>&wRR9uZ(AcYE#-ASoi0m0y6dP z*y(bqG7SDs=@UPbrXHW@BT*E5ZC(1dR^a+z!%0kNYWuohn6j`P?BmVhe9mzx36pv# z2*1KI6HC68Z}a?m8}DsVBSX0Q9iZb{G0>V5A?kautX7m;WrWd4!bwbraWY5ekI(k2 zq?!g2SsZs^N9e#sjH9A*c*Iub4Y!?-Vc5R!2^@~Ex84Y&aTF8FcaSyY_zc^OD zXvl_;;p2vy6taH}sHQCevS2VI8Zi#)LdoOh2ij+8iZ<17=~~d`lCvym_=x5jNWN7I z(S3TI+5t;Sb&lLH@ACfE$Fv7;LsL!SP;7#_%wtv8Yv%-gZ6oMgN>yC%cjgxmOc51o zj74&x)6r-XdF5dJyopNKO%YXIDXTGZbBcewTnjB43*};*p1K2``+jZ|qKD@@)!Qq9 z44C{nsm5Ay-$RnXtcPfuMgn(ipdb(3^N!hy+_hyAy3V(l$$dK=ch!C-vV?MvCSQ@!PK%B;IMr@Sv~tUfnmXT6QTnmBDkg2NQGa)awZfa2BBctRSE_qzi8 zyU|!bd(j^LQmSoe-S)(ahm#FALv2yd&Uf?gjgPi%n|AkF*3v6{GHFaE#g+&|qq4%O z2}XomZiL&YxbRe)CUv2@HYI&^x@QM=NToUZMNp!*h<-oecGF?yeyQk;dCX=`P!b-B zxCus9u8mE+vCAr_PCFK*FP<4N2Vcw7zL$wku;aMBgzNR8n23nUY&9)=_5qzrG%|Pc zx4J$zPdk;0skgTkyj|}V2wLv8CyN^>iIK!yq4rWrQkotgMR^^En4aJJ)-lESUK!biW4*7;4Uz8_2E4ccDiZ+9ju1Zwpr zV4^n$zYM|LuwC>fuPp^CqX^L?eKm4dm|Q}61Zqw71C|d5W{>32mD_`mzR3p#GYwG# zPMxcIMYwcub7fjfG)t@WW_ij{wfNMl6wL;e(QXC-65})nZ8=#(N8G^{jgk1 zG~S5lcU9%PBw2gBdv#Mb|85I6i{ImhWu~^M5Dsib)RF|GxgX_j&XjTJW@Nh5l_s<$ z-i~dQ=gKp(3(t?nVloB3?>*<9q;g|;Yc{R_BS!KL0|Wvks9s!KtWu5_tpqQP2)*9i zjwH&m%RBJgKjzVGBYk3#xRyHV?8Ce;ygNZ8ck~`HE&^yj(TWKmEYkRL-O-CLS#7G( zr_k?JrsGC2x>L6g)GCY%zgd^l8`OUg_*mt_vl59k=c6WN`q1z(CJ$zUxp4HKnm+a?Q=M_l{`5>TA zLIg>P-sW`^z(BZFi7>=eP_|vEZ+2#Oy4a?FR#4iUg@k1ylDX8WJGp#8nlPibvNE*1 zuPrfhkgG)3cCs$Ybwm{rTsU;Sd`6W0Q|*LNkGz`jzEqCjx|sTFaI2Bt_*E^F(M3o6 zrPD9<@nRsQ0-5@xndjgcm4K&;g+Vm2n1KNwJueX13=@-g)E!E&u;TIAp`Ps+O zbW>?+WB!YL?EQcZzMH#b-b~wewPL_VtGqIoWW1}K)@n^!V-;)}Cp2>M;`(AlVoMv) zZ?dETEge{TP2l4ue-=jT7XAZ4`Q3|3ynBT?t4gfY&NMa#tiwvDna`O3gi&3E@sVyU@i@PjFbb z<+Dj48{PFCC+7NNiT_O}pkvxa&5`;+15hDl04lg;kxQ$Df`OdoRCI5c;c@wz2FSaw z9O|TyNA$O+f&NIi!co9LrQQ@CHZC#>JdD+u8X2*|G$zp5N9|^HP62N>yTAy)$x4%Z z$9EsPavCg*T%+Da-hkSMRubfA`X><&XBR^`o2q#C3J*?Irt4|ESm6h-f$t;O`tQEH zwJScCd!t$9e0{cWnHE%AYt*Wzl-R1>pe&&Vb)@CmARgwqV55h%S2uEKO&@HpJeTtJ zKGPxwqQ}}83K6_ZehzT%m>z7#DmL7B-*PRB-5PyhAHSc>mh^l*k{9jpj>EUOFZ5iZ z6jrNH*gqF(7MZVxcw$!;$`fg3(5J($RgD?ExSMHHcC6LdG?yLbEur!516iMPzo*S3 ziY-V?^E?#us7d=0c#2+&myogg zx+xu%{k&ceBu86qTme}tX3Lk6ga!0n_V-c(hRdsQbe~d5s}lj1U9TjlO8v{(_!F%ZVTmmz`0fP`k8A5+miX4fin%2>1Nz#36aye zA@hbNCLtIaWrZ24Rks5f@wmoR~V(q8?$@lnMc<)iLYc)em|T zgCJJCWQ;a}e5km)Ou6nG+c0yWhDj2bhN}jHen2~Xg6v{D5|)*jmY1L{#B1ivtSRnJ z^0eMejs(#Lc4nS0@1y}3x=2?UbM5`*lpi4>yDa;r0iwO*b`wc(d9%@5g5(I+kAc^} zwel$4of^L~%bac#nKc^!5yHg3^@Oqd`X^VY&0@j{=RT2&#Cl|wi7+2~t6af;!&ZOg z_Tv1^eywQc#D-Z9siJKbYj#ois6V^vPVXI>6smXYzP)weFy&`6+Ks_9E2 zR^wVEh}-=%FEfD6MSXgUurWTVqu>?wZ8lYaVe5BH)$RVs;z-;3TWz`igUj- zlb0{^0G@_n>fJUAu1Hc!ddm5c*}N1=pcX6TxG1FB0C1(cOWb~#oot1kr~w+1#W$IN z`Jo|RwTposU;d=OSKE2de!ZKcE;VLh0o}aL<{r-f^UU=lDn`dprX)&L)K+>@Ut0Tc zYpwE{83LnIcalvW1ey6cxd1!!Ob(xy*eT~0i3!^q@ADPFu8`A=y6B7tm-A{=w_2M8 z{Tt@V3JnDKpN^<7Dyk5QIdah7C#pChS_RmVP~w>LuYVghBAT^ENa#;byq#!*OfV#$=U?GOBS?*uoHoEhYE)sj7pronb#drpk~pNxUugN-;%nW0x_hniG2|D_-i z$)dDKqux#7CwX`9KY#m=lm<}G23O;z@Sqr|Nye?l0YC#_vjAQmy7LF2EQ4%g1I8iB zexh?W^x^Sl%qlbW5n?!*rfffa32ZtjyHmz#tj4To^SsB+ei5lqJpi6!)c*vM?{n>t zh2KMg;H^XUt{cY1pDuLM!u+UhVECDIi}(sk($8ag;@_)$*<%R0Xd|S-O-VsLo)2>? zz`XR!FrueuDx;P0;PHzT&%%rK2>gM`lD`(7Dhsz+bMh1HbYpxD8aL+OW<& zSGqOzSC(}jo$Q#9fFEeaD=R8L=BJIb_%!lJRktl&Du)oBWYaZaqlHX3i-Gk5u-nR+v|XWU-2UFZCUg) zw3wjeu!xX>l(BFBYwR!d6QKY4Er9QT~ptk@+Qug zBkVj2(BXFV?JHH_5YnvWlmz|#$QwWS)cHc19`Xkii5Qj{SG6mi&$GgWo+ z7O56|2E!u`tYc8&)&nEM;g_4K6HQkMuhBQuV|-NmIH&lQv-ZFFI} z;T(pT#P*OWVJTBcbLim}MT?&*UEGKMo(%tiHzK50qK4%qo3btKaoT057Rbz2XePZW zgU1Cy-#98m&luNy4>h3M;-Ed!#7fIG6c)`&N|UyGBwk*4N~>ipRv)|+@MqbN!+%ARH!_Z3g zL3b{&w(s@sa%iI*eC5Lu>-ZrgC%8J@eP3f^;6s1G*^6(8J!RydT?p@o&FQB$NNH zPOlWQfc?(%Nh8Sx`08wp<);`ZWr#&{9S;O;_Amd9F}API)lH({B_m0>s-WlYqVv&0 z>2MxoCK=c&i#*SeS`O#sZ7O#RPP;t4_4Cqcdsj?dp1|YRoK17-b@vnCVzo%lE;b2> zDb~qDZ=(=Euy2{etJ@}x2ee=Gu4B56XrS24`YKZ;+oBQ2q`pC=YFR*KO&^bEyLsb< z``>P$6Aa|z_<)`Z&_C>E9*@AmL#S3fU#QH;kxZmE*slN!J=&tw%q z&H^mwV9t+ZWi^3cF0W}j@V-UHp&NO<1>>_1Tl)2z`577}-_XvNg=Fx|r^KB)nsfcS z-5p==T#IDht2DEgh*FlRwi586qb`7?r0N4C0UxV{0?FW#dRLKOo0}JjXYHf*1k+as z8orE1hiUu_TU}^@m7fwXD1d}XoOzgfx)e9Zx61SB*pV9~>yNKu70mQSxACpk{9;`Q zjRS}@!C0~nZxXVF(fb{f9AU2p}fqR(u&M>JEdJ&J!!H0LG?ne1{T)bL~K<$r$l(=qE

~KUojIU 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 Curq-G literal 0 HcmV?d00001 diff --git a/docs/styleguide-ux.md b/docs/styleguide-ux.md new file mode 100644 index 0000000..5d0c461 --- /dev/null +++ b/docs/styleguide-ux.md @@ -0,0 +1,433 @@ +# Mini-EPD Style Guide & UX + +> Geëxtraheerd uit de mini-epd-prototype codebase. Gebruik dit document om dezelfde look & feel in een ander project toe te passen. + +--- + +## 1. Tech Stack & Tooling + +| Categorie | Keuze | Versie | +|---|---|---| +| Framework | Next.js (App Router) | 14.2 | +| Taal | TypeScript | 5.x | +| Styling | Tailwind CSS | 3.4 | +| Component variants | `class-variance-authority` (CVA) | 0.7 | +| Class merging | `tailwind-merge` | 3.4 | +| Animaties | `tailwindcss-animate` + Framer Motion | 1.0 / 12.x | +| UI primitives | Radix UI | diverse | +| Iconen | Lucide React | 0.553 | +| State management | Zustand | 5.x | +| Formulieren | React Hook Form + Zod | 7.x / 4.x | +| Rich text | TipTap | 3.x | + +### Utility helper + +```ts +// lib/utils.ts +import { clsx, type ClassValue } from 'clsx' +import { twMerge } from 'tailwind-merge' + +export function cn(...inputs: ClassValue[]) { + return twMerge(clsx(inputs)) +} +``` + +--- + +## 2. Kleurensysteem + +### 2.1 Basiskleuren + +| Token | Hex | Gebruik | +|---|---|---| +| `app-background` | `#F8FAFC` | Pagina-achtergrond (slate-50) | +| `surface` | `#FFFFFF` | Cards, panels | +| `surface-sub` | `#F1F5F9` | Secundaire achtergrond (slate-100) | +| `text-primary` | `#0F172A` | Primaire tekst (slate-900) | +| `text-secondary` | `#475569` | Secundaire/meta-tekst (slate-600) | +| `border` | `#E2E8F0` | Standaard borders (slate-200) | + +### 2.2 Brand (Teal-first) + +De primaire brandkleur is **teal**. Alle interactieve elementen, focus-states en links gebruiken deze kleur. + +| Token | Hex | Ratio | Gebruik | +|---|---|---|---| +| `brand-50` | `#F0FDFA` | — | Subtiele achtergrond | +| `brand-100` | `#CCFBF1` | — | Info-subtiel | +| `brand-200` | `#99F6E4` | — | Lichte tint | +| `brand-400` | `#2DD4BF` | — | Decoratief | +| `brand-500` | `#14B8A6` | — | Accent | +| `brand-600` | `#0D9488` | 3:1 | UI-componenten (non-text) | +| **`brand-700`** | **`#0F766E`** | **5.47:1** | **Primaire tekst & CTA (WCAG AA) ✓** | +| `brand-800` | `#115E59` | — | Hover state | +| `brand-900` | `#134E4A` | — | Donkerste tint | + +```css +/* CSS custom properties */ +--color-brand: #0F766E; +--color-brand-hover: #115E59; +--color-brand-active: #0D9488; +--color-brand-subtle: #F0FDFA; +``` + +### 2.3 AI Features (Amber) + +AI-gerelateerde acties worden visueel onderscheiden door een **amber** kleurenpalet. + +| Token | Hex | Gebruik | +|---|---|---| +| `ai-50` | `#FFFBEB` | Subtiele AI-achtergrond | +| `ai-500` | `#F59E0B` | Primaire AI-kleur | +| `ai-600` | `#D97706` | AI-tekst (WCAG AA large) | +| `ai-700` | `#B45309` | AI hover | + +### 2.4 Module-accenten + +Verschillende modules hebben een eigen kleurig accent: + +| Module | Achtergrond | Accent | Border | +|---|---|---|---| +| Afspraken | `#E8F8EF` | `#16A34A` (groen) | `#CDECDC` | +| Medicatie | `#FEF6DC` | `#F59E0B` (amber) | `#F6E7B6` | +| Lab | `#FFEBDC` | `#F97316` (oranje) | `#FFD2B8` | + +### 2.5 Status & Feedback + +| Status | Kleur | Subtiel | +|---|---|---| +| Success | `#16A34A` | `#ECFDF5` | +| Warning | `#EAB308` | `#FEFCE8` | +| Error | `#DC2626` | `#FEF2F2` | +| Info | `#0F766E` (teal) | `#CCFBF1` | + +### 2.6 Severity Badges (DSM-light) + +| Ernst | Achtergrond | Tekst | +|---|---|---| +| Low | `#E5E7EB` | `#374151` | +| Medium | `#FEF3C7` | `#92400E` | +| High | `#FEE2E2` | `#991B1B` | + +### 2.7 Dark Mode + +Dark mode is optioneel geïmplementeerd (MVP = licht thema): + +```css +.dark { + --color-bg: #0a0a0a; + --color-surface: #1a1a1a; + --color-text: #ededed; + --color-text-secondary: #a1a1a1; + --color-border: #333333; +} +``` + +--- + +## 3. Typografie + +### 3.1 Font Families + +Drie fonts worden lokaal geladen via `next/font/local`: + +| Variabele | Font | Gewichten | Gebruik | +|---|---|---|---| +| `--font-serif` | **Lora** | 400, 400i, 600 | Long-form content, manifesto teksten | +| `--font-sans` | **Roboto** | 400, 500, 600 (+italic) | UI, navigatie, metadata, body | +| `--font-mono` | **Source Code Pro** | 400, 600 | Code, technische details, nummers | + +**Body default:** `var(--font-sans), system-ui, -apple-system, sans-serif` + +### 3.2 Typografische Schaal + +| Token | Waarde | Toepassing | +|---|---|---| +| `--text-hero` | `clamp(2.5rem, 6vw, 4rem)` | Hero quotes | +| `--text-h1` | `clamp(2rem, 5vw, 3rem)` | Sectie-koppen | +| `--text-h2` | `clamp(1.5rem, 4vw, 2.5rem)` | Subsecties | +| `--text-body` | `1.25rem` | Content, lopende tekst | +| `--text-small` | `0.875rem` | Metadata, labels | + +### 3.3 Line Heights + +| Token | Waarde | Gebruik | +|---|---|---| +| `--line-height-tight` | `1.2` | Headings | +| `--line-height-relaxed` | `1.8` | Body/content | + +--- + +## 4. Shadows & Border Radius + +### Shadows + +| Token | Waarde | +|---|---| +| `shadow-sm` | `0 1px 2px rgba(15,23,42,0.06)` | +| `shadow-md` | `0 2px 6px rgba(15,23,42,0.08)` | +| `shadow-lg` | `0 8px 20px rgba(15,23,42,0.10)` | + +> Alle shadows zijn gebaseerd op **slate-900** alpha — geen hard zwart. + +### Border Radius + +| Token | Waarde | +|---|---| +| `--radius` | `0.625rem` (10px) | +| `rounded-lg` | `var(--radius)` | +| `rounded-md` | `calc(var(--radius) - 2px)` ≈ 8px | +| `rounded-sm` | `calc(var(--radius) - 4px)` ≈ 6px | + +--- + +## 5. Formulieren + +| State | Property | Waarde | +|---|---|---| +| Default | bg | `#FFFFFF` | +| Default | border | `#CBD5E1` | +| Default | tekst | `#0F172A` | +| Placeholder | kleur | `#94A3B8` | +| Hover | border | `#94A3B8` | +| Focus | ring/border | `#0F766E` (teal-700) | +| Disabled | bg | `#F1F5F9` | +| Disabled | tekst | `#94A3B8` | +| Invalid | border | `#DC2626` | +| Invalid | tekst | `#B91C1C` | + +**Input component patroon:** +```tsx + +``` + +--- + +## 6. Component Patronen + +### 6.1 Component Architectuur + +- Alle componenten gebruiken **`React.forwardRef`** voor ref-forwarding +- Varianten via **`class-variance-authority`** (CVA) +- Styling via Tailwind classes + `cn()` utility +- Radix UI als headless primitives (Dialog, Tabs, Select, Popover, etc.) +- **Default = server component**; `"use client"` alleen wanneer interactiviteit vereist is + +### 6.2 Button + +| Variant | Stijl | +|---|---| +| `default` | `bg-primary text-primary-foreground hover:bg-primary/90` | +| `destructive` | `bg-destructive text-destructive-foreground hover:bg-destructive/90` | +| `outline` | `border border-input bg-background hover:bg-accent` | +| `secondary` | `bg-secondary text-secondary-foreground hover:bg-secondary/80` | +| `ghost` | `hover:bg-accent hover:text-accent-foreground` | +| `link` | `text-primary underline-offset-4 hover:underline` | + +| Size | Afmetingen | +|---|---| +| `default` | `h-10 px-4 py-2` | +| `sm` | `h-9 px-3` | +| `lg` | `h-11 px-8` | +| `icon` | `h-10 w-10` | + +### 6.3 AI Button + +Speciaal component voor AI-acties. Visueel onderscheiden door **amber gradient**. + +| Variant | Stijl | +|---|---| +| `default` | Amber gradient (`from-amber-600 to-amber-700`) + witte tekst | +| `outline` | `border-2 border-amber-500`, tekst `amber-700` | +| `ghost` | Transparant, tekst `amber-700`, hover `amber-50` | + +Features: +- Sparkle-icoon (✨) als visuele AI-indicator +- Loading state met `Loader2` spinner +- Drie maten: `sm`, `md`, `lg` + +### 6.4 Card + +``` +┌─────────────────────────────┐ +│ CardHeader (p-6) │ +│ CardTitle (semibold) │ +│ CardDescription (muted) │ +│ CardContent (p-6 pt-0) │ +│ CardFooter (p-6 pt-0) │ +└─────────────────────────────┘ +``` +- `rounded-xl`, `border`, `bg-card`, `shadow` + +### 6.5 Badge + +Varianten: `default`, `secondary`, `destructive`, `outline` +Base: `rounded-md`, `px-2.5 py-0.5`, `text-xs font-semibold` + +### 6.6 Tabs + +- `TabsList`: `rounded-lg bg-muted p-1` +- `TabsTrigger`: `rounded-md px-3 py-1 text-sm font-medium` +- Active state: `bg-background text-foreground shadow` + +### 6.7 Toast + +- Positie: top op mobile, bottom-right op desktop +- Swipe-to-dismiss ondersteuning +- Slide-in animatie (top op mobile, bottom op desktop) +- Varianten: `default` en `destructive` + +--- + +## 7. Layout & Navigatie + +### 7.1 App Shell + +``` +┌──────────────────────────────────────┐ +│ ┌──────────┐ ┌─────────────────────┐ │ +│ │ │ │ │ │ +│ │ Sidebar │ │ Main Content │ │ +│ │ (fixed) │ │ (scrollable) │ │ +│ │ │ │ │ │ +│ │ │ │ │ │ +│ └──────────┘ └─────────────────────┘ │ +└──────────────────────────────────────┘ +``` + +- **Container**: `min-h-screen bg-slate-50 flex` +- **Sidebar**: fixed, `w-78` open / `w-28` collapsed +- **Main content**: flex-grow, scrollable + +### 7.2 Sidebar UX + +| Eigenschap | Waarde | +|---|---| +| Desktop breedte (open) | `w-78` (312px) | +| Desktop breedte (collapsed) | `w-28` (112px) | +| Achtergrond | `bg-white` | +| Border | `border-r border-slate-200` | +| Transition | `duration-300 ease-in-out` | +| Mobile | Full overlay met `bg-black/40 backdrop-blur-sm` | + +**Active nav item**: `bg-teal-50 text-teal-700` + icoon `text-teal-600` +**Inactive nav item**: `text-slate-600 hover:bg-slate-50 hover:text-slate-900` + +**Collapsed state**: tooltips verschijnen links met een pijl-indicator (`bg-slate-800 text-white`) + +**Profiel sectie**: avatar cirkel, naam, rol, online-indicator (`bg-green-500` dot) +**Logout**: `text-red-600 hover:bg-red-50` + +--- + +## 8. Animaties + +### 8.1 Float Animatie + +Subtiele zweef-animatie voor badges of decoratieve elementen: + +```css +@keyframes float { + 0%, 100% { transform: translateY(0px) rotate(0deg); } + 25% { transform: translateY(-5px) rotate(0.5deg); } + 50% { transform: translateY(-3px) rotate(-0.5deg); } + 75% { transform: translateY(-7px) rotate(0.3deg); } +} +.animate-float { animation: float 5s ease-in-out infinite; } +``` + +### 8.2 Artifact Slide-in + +Panel slide-in van rechts: + +```css +@keyframes artifact-enter { + from { transform: translateX(100%); opacity: 0; } + to { transform: translateX(0); opacity: 1; } +} +.artifact-enter { animation: artifact-enter 200ms ease-out; } +``` + +### 8.3 Transition Defaults + +- Navigatie / sidebar: `transition-all duration-300 ease-in-out` +- Buttons / interactie: `transition-colors` of `transition-all duration-200` +- Toasts: slide-in + fade via `tailwindcss-animate` + +### 8.4 Reduced Motion + +Volledige `prefers-reduced-motion` ondersteuning: + +```css +@media (prefers-reduced-motion: reduce) { + *, *::before, *::after { + animation-duration: 0.02ms !important; + transition-duration: 0.03ms !important; + scroll-behavior: auto !important; + } +} +``` + +--- + +## 9. Toegankelijkheid (A11y) + +| Aspect | Implementatie | +|---|---| +| Focus indicator | `outline: 2px solid var(--color-brand)`, `outline-offset: 2px` | +| Focus ring (components) | `ring-2 ring-ring ring-offset-2` | +| Skip to main | Verborgen link, zichtbaar bij focus | +| Kleurcontrast | Brand teal-700 = 5.47:1 op wit (WCAG AA ✓) | +| ARIA labels | Alle interactieve elementen (toggle buttons, sidebar) | +| Reduced motion | Alle animaties gerespecteerd | +| Iconen | `aria-hidden="true"` op decoratieve iconen | +| Taal | `` | + +--- + +## 10. AI UX Conventies + +AI-functies worden visueel onderscheiden van standaard UI: + +| Element | Conventie | +|---|---| +| Kleur | Amber-palet (geel/goud), nooit teal | +| Button | `AIButton` component met Sparkle-icoon (✨) | +| Highlight | `.ai-source-highlight` — lichtgeel (`#fef08a`) met `border-radius: 2px` | +| Loading | `Loader2` spinner (animatie: `animate-spin`) | +| Feedback | Confidence indicators bij AI-gegenereerde content | + +--- + +## 11. Quick-Start Checklist + +Om deze stijl in een nieuw project over te nemen: + +1. **Installeer dependencies:** + ```bash + pnpm add class-variance-authority clsx tailwind-merge tailwindcss-animate + pnpm add lucide-react framer-motion + pnpm add @radix-ui/react-dialog @radix-ui/react-tabs @radix-ui/react-select + # + overige Radix primitives naar behoefte + ``` + +2. **Kopieer fonts** (Lora, Roboto, Source Code Pro) naar `public/fonts/` en configureer in `layout.tsx` + +3. **Kopieer CSS custom properties** uit `globals.css` (sectie `:root`) + +4. **Kopieer Tailwind config** — met name `colors`, `boxShadow`, `borderRadius` extensies + +5. **Kopieer `cn()` utility** naar `lib/utils.ts` + +6. **Kopieer UI components** uit `components/ui/` (shadcn-patroon met CVA) + +7. **Zet `antialiased`** op de `` tag + +8. **Zet `lang="nl"`** op de `` tag + +--- + +*Gegenereerd op basis van de mini-epd-prototype codebase (maart 2026).* diff --git a/docs/swift/cortex-architectuur-analyse.md b/docs/swift/cortex-architectuur-analyse.md new file mode 100644 index 0000000..652007b --- /dev/null +++ b/docs/swift/cortex-architectuur-analyse.md @@ -0,0 +1,1514 @@ +# Cortex Architectuuranalyse — Van Prototype naar Productie + +> **Type**: Architectuurrapport +> **Scope**: Cortex drie-laags AI-systeem + EPD-integratie +> **Status**: Analyse & aanbevelingen +> **Datum**: 2026-02-14 +> **Doelgroep**: Technisch team, AI-systemen voor vervolganalyse + +--- + +## 1. Inleiding + +### 1.1 Doel van dit rapport + +Dit rapport beschrijft het huidige Cortex-systeem (as-is) en doet concrete voorstellen voor een productiewaardige architectuur (to-be). Het is bedoeld als referentiedocument voor verdere analyse en iteratieve verbetering. + +### 1.2 Scope + +- Cortex drie-laags architectuur (Reflex, Orchestrator, Nudge) +- Intent-classificatiesysteem +- Integratie met EPD-modules (API's, state management, UI-flow) +- Beknopte enterprise-eisen (NEN 7510, audit, RBAC) + +**Buiten scope**: Volledig datamodel, autorisatiemodel, FHIR-integratie. Deze worden als afhankelijkheden benoemd maar niet uitgewerkt. + +### 1.3 Ontwerpprincipes + +De aanbevelingen in dit rapport volgen deze principes: + +1. **Single Responsibility** — Elk onderdeel heeft precies één doel +2. **Single Source of Truth** — Geen dubbele definities; één canonieke bron +3. **Graceful Degradation** — Het systeem blijft functioneel als onderdelen falen +4. **Minimale complexiteit** — Geen abstracties voor hypothetische toekomstige eisen +5. **Observability by design** — Elk onderdeel is meetbaar en debugbaar + +--- + +## 2. Concept + +### 2.1 Probleemstelling + +Zorgverleners in de GGZ besteden een significant deel van hun werktijd aan administratie: rapportages schrijven, afspraken beheren, overdrachten voorbereiden, en door dossiers navigeren. Deze handelingen onderbreken het primaire proces — directe patiëntenzorg — en vereisen constante contextwisselingen tussen klinisch denken en systeembediening. + +Het kernprobleem is niet dat deze taken bestaan, maar dat ze **gestructureerde input vereisen** (formulieren, knoppen, menustructuren) terwijl de zorgverlener in **ongestructureerde taal** denkt en communiceert. De kloof tussen "Jan heeft zijn medicatie geweigerd" en het invullen van het juiste formulier in de juiste categorie voor de juiste patiënt is waar productiviteit verloren gaat. + +### 2.2 Visie + +Cortex is de **intelligente tussenschakel** tussen natuurlijke taal en gestructureerde EPD-acties. Het stelt zorgverleners in staat om in hun eigen woorden te communiceren — gesproken of getypt — en vertaalt dit naar de juiste actie in het juiste systeem, met de juiste context. + +De kernbelofte: + +> **Zeg wat je wilt doen, niet hoe het systeem het verwacht.** + +Cortex is geen chatbot en geen zoekmachine. Het is een **command interface** dat drie dingen doet: + +1. **Begrijpen** — Wat bedoelt de gebruiker? (intent + entities) +2. **Uitvoeren** — De juiste actie starten met de juiste voorvulling +3. **Voorstellen** — Proactief vervolgacties suggereren op basis van klinische protocollen + +### 2.3 Ontwerpfilosofie + +#### Snelheid boven volledigheid + +70% van de commando's in een EPD is routine: "notitie jan medicatie", "agenda vandaag", "overdracht". Deze moeten in milliseconden verwerkt worden, niet in seconden. AI wordt alleen ingezet wanneer lokale verwerking niet volstaat. Dit is een bewuste keuze: **optimaliseer voor de veelvoorkomende gevallen, investeer AI-capaciteit in de uitzonderingen.** + +#### Vertrouwen door transparantie + +Zorgverleners moeten het systeem kunnen vertrouwen. Dat betekent: +- Geen automatische opslag zonder bevestiging +- Altijd tonen wat het systeem begrepen heeft (prefilled formulier, niet een weggeschreven record) +- Bij twijfel: vragen, niet raden +- Bevestiging vereisen bij destructieve acties (annuleren, verwijderen) + +#### Klinisch relevante intelligentie + +De AI-component is geen generieke assistent. Cortex kent het domein: diensten (nacht/ochtend/middag/avond), rapportagecategorieën (medicatie/ADL/gedrag/incident/observatie), klinische protocollen (wondzorg, medicatie-evaluatie). Deze domeinkennis maakt het verschil tussen een nuttige suggestie en ruis. + +### 2.4 Gebruiksmodel + +``` +┌──────────────────────────────────────────────────────────────────┐ +│ Werkdag van een verpleegkundige │ +│ │ +│ 07:00 Start dienst │ +│ └─ "Wat moet ik weten?" → Overdracht met AI-samenvatting │ +│ │ +│ 08:30 Medicatieronde │ +│ └─ "Jan medicatie gegeven" → Dagnotitie, categorie auto │ +│ └─ "Marie weigert medicatie" → Dagnotitie + incident? │ +│ │ +│ 10:00 Intake nieuw patiënt │ +│ └─ "Wat moet ik nog doen?" → Intake checklist │ +│ └─ "Ga naar risico" → Navigatie naar risicotaxatie │ +│ │ +│ 12:00 Afsprakenbeheer │ +│ └─ "Afspraken vanmiddag" → Agendaoverzicht │ +│ └─ "Verzet Jan naar 15:00" → Afspraak wijzigen │ +│ │ +│ 14:30 Wondverzorging │ +│ └─ "Notitie jan wondverzorging uitgevoerd" → Dagnotitie │ +│ └─ 🔔 Nudge: "Wondcontrole inplannen over 3 dagen?" │ +│ │ +│ 16:45 Einde dienst │ +│ └─ "Overdracht" → Overdracht genereren │ +└──────────────────────────────────────────────────────────────────┘ +``` + +--- + +## 3. Architectuur — Conceptueel + +### 3.1 Het drie-laags model + +De architectuur is geïnspireerd op hoe het menselijk zenuwstelsel informatie verwerkt: + +| Laag | Analogie | Functie | Wanneer | +|------|----------|---------|---------| +| **Layer 1: Reflex** | Ruggenmerg | Directe, snelle respons op herkenbare patronen | Altijd (eerste poging) | +| **Layer 2: Orchestrator** | Hersenen | Bewuste analyse van complexe, ambigue input | Bij twijfel of complexiteit | +| **Layer 3: Nudge** | Geweten | Proactieve suggestie op basis van professionele kennis | Na afgeronde actie | + +Dit model heeft twee architecturele voordelen: + +**1. Kostenefficiëntie**: AI API-calls zijn duur en traag. Door 70%+ lokaal af te handelen worden kosten en latency gedrukt. De AI wordt alleen aangesproken wanneer de waarde evident is. + +**2. Resilience**: Als de AI-service onbeschikbaar is, blijft Layer 1 volledig functioneel. Het systeem degradeert graceful van "intelligent" naar "snel en betrouwbaar" in plaats van volledig te falen. + +### 3.2 De intent als architecturaal primitief + +Het centrale concept in Cortex is de **intent**: een gestructureerde representatie van wat de gebruiker wilt bereiken. + +``` +Gebruikersinput: "Notitie jan medicatie gegeven" + │ + ▼ + ┌─────────────────┐ + │ Intent │ + ├─────────────────┤ + │ type: dagnotitie│ + │ confidence: 0.95│ + │ entities: │ + │ patient: jan │ + │ category: med │ + │ content: ... │ + └─────────────────┘ + │ + ▼ + ┌─────────────────┐ + │ Actie │ + │ Open formulier │ + │ met prefill │ + └─────────────────┘ +``` + +Een intent bestaat uit drie delen: + +1. **Type** — Wát de gebruiker wil (dagnotitie, zoeken, overdracht, etc.) +2. **Confidence** — Hoe zeker het systeem is van deze interpretatie (0.0–1.0) +3. **Entities** — De relevante parameters (patiëntnaam, categorie, datum, etc.) + +De confidence bepaalt het systeemgedrag: + +| Confidence | Gedrag | +|------------|--------| +| ≥ 0.9 | Direct uitvoeren (formulier openen met prefill) | +| 0.7–0.9 | Uitvoeren met bevestigingsvraag | +| 0.5–0.7 | Verduidelijkingsvraag stellen | +| < 0.5 | "Ik begrijp het niet, kun je het anders zeggen?" | + +### 3.3 IntentChain — Meervoudige acties + +Gebruikers combineren regelmatig acties in één zin: "Annuleer de afspraak van Jan en maak een notitie." Het systeem modelleert dit als een **IntentChain**: een geordende reeks intents die sequentieel worden uitgevoerd. + +``` +Input: "Annuleer jan en maak notitie griep" + │ + ▼ + ┌─────────────────┐ + │ IntentChain │ + ├─────────────────┤ + │ Action 1: │ + │ cancel_appt │ ──▶ Uitvoeren (met bevestiging) + │ {patient: jan}│ + │ │ + │ Action 2: │ + │ dagnotitie │ ──▶ Wacht op Action 1, dan uitvoeren + │ {patient: jan,│ + │ content: ..} │ + └─────────────────┘ +``` + +Multi-intent is architectureel ondersteund maar beperkt tot sequentiële uitvoering. Parallelle uitvoering is bewust niet geïmplementeerd: de gebruiker verwacht een logische volgorde. + +### 3.4 Nudge — Protocol-gedreven suggesties + +De Nudge-laag is conceptueel anders dan Layer 1 en 2. Waar die lagen **reactief** zijn (gebruiker vraagt, systeem handelt), is Layer 3 **proactief**: het systeem stelt iets voor dat de gebruiker niet gevraagd heeft maar dat klinisch relevant is. + +``` + ┌───────────────────────────────┐ + │ Afgeronde actie │ + │ dagnotitie: wondverzorging │ + └───────────────┬───────────────┘ + │ + ▼ + ┌───────────────────────────────┐ + │ Protocol Rule Engine │ + │ │ + │ Regel: "wondzorg-controle" │ + │ Trigger: dagnotitie + │ + │ content ~ "wond" │ + │ ────────────────────────── │ + │ Match! → Suggestie genereren│ + └───────────────┬───────────────┘ + │ + ▼ + ┌───────────────────────────────┐ + │ Nudge Suggestie │ + │ │ + │ "Wondcontrole inplannen │ + │ over 3 dagen?" │ + │ │ + │ Protocol: V&VN Wondzorg §4.2│ + │ [Accepteren] [Verwerpen] │ + └───────────────────────────────┘ +``` + +De klinische onderbouwing (protocolnaam, paragraafverwijzing, rationale) is essentieel: het maakt de suggestie controleerbaar en vertrouwenswaardig. De zorgverlener beslist altijd zelf. + +### 3.5 Anatomie van een Intent — De bouwsteen + +Een intent is niet alleen een classificatieresultaat. Het is een **end-to-end bouwsteen** die door 8 lagen van het systeem snijdt. Elk nieuw intent raakt al deze lagen; de kwaliteit van het systeem hangt af van de consistentie ertussen. + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ ANATOMIE VAN EEN INTENT │ +│ │ +│ ┌─ 1. TYPE DEFINITIE ─────────────────────────────────────┐ │ +│ │ CortexIntent union type + ExtractedEntities │ │ +│ │ Bron: lib/cortex/types.ts │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ ↓ │ +│ ┌─ 2. REFLEX PATRONEN ────────────────────────────────────┐ │ +│ │ Regex-patronen met gewichten (1.0 = exact, 0.7 = zwak) │ │ +│ │ Bron: lib/cortex/reflex-classifier.ts │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ ↓ │ +│ ┌─ 3. AI PROMPTBESCHRIJVING ──────────────────────────────┐ │ +│ │ Intent beschrijving + triggers + entity definitie │ │ +│ │ + voorbeelddialoog met verwacht JSON-resultaat │ │ +│ │ Bron: app/api/cortex/chat/route.ts (system prompt) │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ ↓ │ +│ ┌─ 4. VALIDATIESCHEMA ───────────────────────────────────┐ │ +│ │ Zod-schema voor intent + entities in AI response │ │ +│ │ Bron: lib/cortex/action-parser.ts │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ ↓ │ +│ ┌─ 5. ACTIE-ROUTING ─────────────────────────────────────┐ │ +│ │ Intent → artifact mapping + entity requirements check │ │ +│ │ Bepaalt of er een artifact opent of navigatie plaatsvindt│ │ +│ │ Bron: lib/cortex/action-parser.ts │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ ↓ │ +│ ┌─ 6. API ROUTE (optioneel) ─────────────────────────────┐ │ +│ │ Server-side data ophalen voor het block │ │ +│ │ Bron: app/api/cortex/[domain]/route.ts │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ ↓ │ +│ ┌─ 7. BLOCK COMPONENT ──────────────────────────────────┐ │ +│ │ React component die het intent visualiseert │ │ +│ │ Ontvangt prefill data uit entities │ │ +│ │ Bron: components/cortex/blocks/[intent]-block.tsx │ │ +│ └──────────────────────────────────────────────────────────┘ │ +│ ↓ │ +│ ┌─ 8. ARTIFACT CONTAINER ────────────────────────────────┐ │ +│ │ Registratie in de artifact renderer (import, case, titel)│ │ +│ │ Bron: components/cortex/artifacts/artifact-container.tsx │ │ +│ └──────────────────────────────────────────────────────────┘ │ +└─────────────────────────────────────────────────────────────────┘ +``` + +#### Drie intenttypen + +Niet elk intent heeft alle 8 lagen nodig. Er zijn drie typen: + +| Type | Beschrijving | Lagen nodig | Voorbeeld | +|------|-------------|-------------|-----------| +| **Query Block** | Toont data (read-only) | Alle 8 | `risico_query`, `diagnose_query` | +| **Action Block** | Formulier voor data-invoer | Alle 8 | `dagnotitie`, `create_appointment` | +| **Navigatie Intent** | Navigeert naar een pagina | 1–5 (geen block/artifact) | `intake_navigeer` | + +#### Entity-schema per intent + +Elk intent definieert welke entities het verwacht: + +| Veld | Beschrijving | Voorbeeld | +|------|-------------|-----------| +| **required** | Moet aanwezig zijn voor uitvoering | `patientName` bij dagnotitie | +| **optional** | Verrijkt het resultaat als aanwezig | `category` bij dagnotitie | +| **prefill** | Wordt doorgegeven aan het block als voorvulling | Alle entities | + +Wanneer required entities ontbreken en confidence < 0.7, stelt het systeem een verduidelijkingsvraag ("Met welke patiënt?"). Wanneer ze aanwezig zijn en confidence >= 0.9, opent het direct het artifact met prefill. + +#### Block lifecycle + +Een block doorloopt vier states: + +``` +┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ +│ Empty │────▶│ Loading │────▶│ Data │────▶│ Error │ +│ (no ctx) │ │ (fetch) │ │ (render) │ │ (retry?) │ +└──────────┘ └──────────┘ └──────────┘ └──────────┘ +``` + +Elke state heeft een standaard UI-component (`BlockEmpty`, `BlockLoading`, `BlockError`) zodat blocks consistent gedrag vertonen. + +### 3.6 Relatie met het EPD + +Cortex is geen losstaand systeem maar een **laag bovenop het EPD** die bestaande modules aanstuurt: + +``` +┌─────────────────────────────────────────────────────────┐ +│ CORTEX LAAG │ +│ Natuurlijke taal → Intent → Actie → Nudge │ +└──────────┬──────────┬──────────┬──────────┬─────────────┘ + │ │ │ │ + ▼ ▼ ▼ ▼ +┌────────────┐ ┌──────────┐ ┌────────┐ ┌─────────┐ +│ Rapportage │ │ Agenda │ │Dossier │ │Overdracht│ +│ module │ │ module │ │ module │ │ module │ +└────────────┘ └──────────┘ └────────┘ └─────────┘ + │ │ │ │ + ▼ ▼ ▼ ▼ +┌─────────────────────────────────────────────────────────┐ +│ DATA LAAG (Supabase) │ +│ reports │ encounters │ patients │ conditions │ ... │ +└─────────────────────────────────────────────────────────┘ +``` + +Cortex kent de EPD-modules niet direct. Het produceert **intents met entities**, en de UI-laag vertaalt deze naar de juiste module-interactie (formulier openen, navigeren, data ophalen). Dit houdt Cortex ontkoppeld van de specifieke EPD-implementatie. + +### 3.7 Referentiekaders — Positionering in het bredere landschap + +Cortex gebruikt concepten die herkenbaar zijn in bestaande NLU- en AI-architecturen, maar combineert ze op een domeinspecifieke manier. Deze sectie positioneert Cortex ten opzichte van gangbare patronen, zodat een architect de vertaling kan maken naar bekende referentiekaders. + +#### 3.7.1 NLU Pipelines (Rasa, Dialogflow, LUIS) + +Klassieke NLU-systemen volgen een vaste pipeline: **tokenize → featurize → classify → extract entities**. Cortex wijkt hier op twee punten af: + +| Aspect | Klassieke NLU | Cortex | +|--------|--------------|--------| +| **Classificatie** | Eén model (ML of rule-based) | Twee lagen: Reflex (regex) + Orchestrator (LLM) | +| **Entity-extractie** | Geïntegreerd in pipeline (NER) | Gescheiden: Reflex classificeert alleen, Orchestrator extraheert | +| **Training** | Vereist gelabelde dataset + trainingsloop | Geen training: regex-patronen + few-shot prompting | +| **Deployment** | Model artifact deployen | Geen model artifact; patronen in code, LLM via API | + +**Mapping voor een architect**: +- Cortex **Reflex Arc** ≈ Rule-based intent classifier (vergelijkbaar met Rasa's `RegexFeaturizer` + `FallbackClassifier`) +- Cortex **Orchestrator** ≈ LLM-as-NLU (vergelijkbaar met Dialogflow CX's generative fallback, maar als primaire escalatielaag) +- Cortex **IntentChain** ≈ Multi-intent parsing (vergelijkbaar met Rasa's `OR`-intents of Dialogflow's composite entities, maar sequentieel uitgevoerd) + +**Bewuste afwijking**: Cortex gebruikt geen getraind ML-model. Dit is een bewuste keuze: in een GGZ-context is de vocabulary beperkt en stabiel (medische termen, vaste werkprocessen), waardoor regex-patronen hoge accuracy bereiken zonder de overhead van modeltraining en -onderhoud. Het LLM fungeert als vangnet voor de uitzonderingen. + +#### 3.7.2 Agentic Architectures (Tool Use, Function Calling) + +Moderne LLM-architecturen gebruiken "tool use" of "function calling": het model beslist zelf welke tools het aanroept op basis van de gebruikersvraag. Cortex lijkt hierop maar verschilt fundamenteel: + +| Aspect | Agentic (tool use) | Cortex | +|--------|-------------------|--------| +| **Beslisser** | LLM beslist autonoom welke tool | Reflex beslist lokaal; LLM alleen bij escalatie | +| **Uitvoering** | LLM roept tools aan en verwerkt resultaat | UI voert acties uit; LLM classificeert alleen | +| **Autonomie** | Hoog (model plant en voert uit) | Laag (mens bevestigt altijd) | +| **Kosten per interactie** | Elke interactie = API call | 70%+ zonder API call | + +**Mapping voor een architect**: +- Cortex **intent** ≈ een function/tool definitie (naam, parameters, beschrijving) +- Cortex **IntentChain** ≈ een tool-use plan (sequence of function calls) +- Cortex **entities** ≈ function parameters (geëxtraheerd uit natuurlijke taal) +- Cortex **artifact/block** ≈ tool execution UI (maar met menselijke bevestiging ertussen) + +**Bewuste afwijking**: Cortex is expliciet **niet** agentic. In een zorgcontext is autonome uitvoering onacceptabel — de zorgverlener moet altijd de laatste beslissing nemen. Cortex bereidt acties voor en vult formulieren in, maar schrijft nooit zelfstandig naar het dossier. Dit is een harde eis, geen beperking. + +#### 3.7.3 Clinical Decision Support (CDS) + +De Nudge-laag (Layer 3) raakt aan Clinical Decision Support — systemen die zorgverleners proactief attenderen op klinisch relevante acties. + +| Aspect | CDS (HL7 CDS Hooks) | Cortex Nudge | +|--------|---------------------|--------------| +| **Trigger** | Workflow event (order-sign, patient-view) | Intent completion (dagnotitie opgeslagen) | +| **Regelformat** | CQL (Clinical Quality Language) of FHIR PlanDefinition | TypeScript conditie-objecten (equals, contains, matches) | +| **Output** | CDS Card (suggestion, info, warning) | NudgeSuggestion (suggestie + protocol referentie) | +| **Standaard** | HL7 CDS Hooks specificatie | Eigen formaat | + +**Mapping voor een architect**: +- Cortex **NudgeSuggestion** ≈ CDS Hooks `Card` (suggestion type) +- Cortex **ProtocolMetadata** ≈ CDS `source` (clinical evidence reference) +- Cortex **PROTOCOL_RULES** ≈ CDS service rules (maar in code i.p.v. FHIR PlanDefinition) + +**Pad naar standaardisatie**: Voor enterprise-gebruik kan de Nudge-engine evolueren naar CDS Hooks-compatibiliteit. Dit vereist: +1. Regels uitdrukken als FHIR `PlanDefinition` resources (i.p.v. TypeScript objecten) +2. Trigger-events mappen naar CDS Hooks trigger types +3. Output formatteren als CDS Cards + +Dit is **niet** nodig voor MVP maar bepaalt of de Nudge-laag kan integreren met externe CDS-systemen (bijv. ziekenhuis-CDS die al HL7-compatibel is). + +#### 3.7.4 FHIR en SMART on FHIR + +Het EPD gebruikt een FHIR-geïnspireerd datamodel (patients, observations, conditions, encounters), maar is geen FHIR-server. Cortex raakt FHIR op twee punten: + +**1. Entities → FHIR Resources** + +Geëxtraheerde entities moeten uiteindelijk mappen naar FHIR-resources: + +| Cortex Entity | FHIR Resource | Voorbeeld | +|---------------|---------------|-----------| +| `patientName` / `patientId` | `Patient` | Patient/123 | +| `category` + `content` | `Observation` of `DocumentReference` | Rapportage opslaan | +| `datetime` + `appointmentType` | `Appointment` | Afspraak aanmaken | +| `navigationTarget` (diagnose) | `Condition` | Diagnoselijst bekijken | + +**2. SMART on FHIR als launch-context** + +In een enterprise-omgeving wordt Cortex mogelijk gestart vanuit een bestaand EPD via SMART on FHIR launch. De launch-context (welke patiënt, welke practitioner, welke encounter) vervangt dan de huidige `CortexContext`: + +| Cortex Context | SMART on FHIR equivalent | +|----------------|--------------------------| +| `activePatient` | Launch context `patient` | +| `currentView` | Launch context `encounter` | +| `shift` | Geen equivalent (domeinspecifiek) | +| `agendaToday` | Geen equivalent (custom query) | + +**Implicatie voor architectuur**: De `CortexContext` interface moet zo ontworpen zijn dat hij zowel intern (uit de eigen UI) als extern (uit een SMART launch) gevuld kan worden. Het huidige ontwerp sluit dit niet uit, maar de context-opbouw zit verweven in de store i.p.v. in een aparte context-provider. + +#### 3.7.5 Samenvattende positionering + +``` + Autonomie + ▲ + │ + Agentic │ + (tool use) │ + ● │ + │ + │ Cortex + │ Orchestrator + │ ● + │ + │ Cortex + │ Reflex + NLU │ ● + pipeline ● │ + │ + ─────────────┼──────────────────▶ Domeinkennis + Generiek │ Zorgspecifiek + │ + │ ● Cortex Nudge + │ (≈ CDS) + │ +``` + +Cortex zit in het kwadrant **laag-autonoom + hoog-domeinspecifiek**. Het gebruikt NLU-concepten (intent, entity, confidence) maar past ze toe in een context waar snelheid (Reflex), veiligheid (geen autonome uitvoering) en klinische relevantie (protocol-gedreven nudges) zwaarder wegen dan modelflexibiliteit. + +--- + +## 4. Huidige Implementatie (As-Is) + +### 4.1 Overzicht + +De conceptuele architectuur uit hoofdstuk 3 is in het prototype als volgt geïmplementeerd: + +``` +Gebruikersinput (tekst/spraak) + │ + ▼ +┌─────────────────────┐ +│ Layer 1: Reflex │ <20ms, regex, lokaal +│ (reflex-classifier)│ +└────────┬────────────┘ + │ escalatie bij lage confidence/ambiguïteit/complexiteit + ▼ +┌─────────────────────┐ +│ Layer 2: Orchestr. │ Claude Haiku, AI-classificatie +│ (orchestrator) │ +└────────┬────────────┘ + │ na succesvolle actie + ▼ +┌─────────────────────┐ +│ Layer 3: Nudge │ Protocolregels, suggesties +│ (nudge) │ +└─────────────────────┘ +``` + +### 4.2 Layer 1: Reflex Arc + +**Bestand**: `lib/cortex/reflex-classifier.ts` + +**Doel**: Snelle, lokale intentclassificatie via gewogen regex-patronen. + +**Werking**: +1. Detecteert eerst escalatietriggers (multi-intent, voornaamwoorden, relatieve tijd) +2. Bij escalatietrigger → direct doorsturen naar Layer 2 met best-guess intent +3. Zonder trigger → patroonmatching met gewichten (1.0=exact, 0.8=sterk, 0.6=partieel) +4. Houdt top-2 matches bij voor ambiguïteitdetectie +5. Escaleert als confidence <0.7 of als top-2 delta <0.1 + +**Huidige intents** (11 totaal): +| Intent | Categorie | Patronen | +|--------|-----------|----------| +| `dagnotitie` | P1 (kritiek) | 12 patronen | +| `zoeken` | P1 | 10 patronen | +| `overdracht` | P1 | 10 patronen | +| `agenda_query` | P2 | 10 patronen | +| `create_appointment` | P2 | 8 patronen | +| `cancel_appointment` | P2 | 6 patronen | +| `reschedule_appointment` | P2 | 7 patronen | +| `intake_status` | P3 (intake) | 7 patronen | +| `intake_navigeer` | P3 | 10 patronen | +| `risico_query` | P3 | 6 patronen | +| `diagnose_query` | P3 | 6 patronen | + +**Beperking**: Reflex doet geen entity-extractie. Het resultaat bevat altijd `entities: {}`. Entities worden pas door Layer 2 of de Chat API geëxtraheerd. + +### 4.3 Layer 2: Orchestrator + +**Bestand**: `lib/cortex/orchestrator.ts` + +**Doel**: AI-gestuurde classificatie voor complexe input via Claude 3.5 Haiku. + +**Werking**: +1. Ontvangt input + volledige applicatiecontext (actieve patiënt, agenda, recente acties) +2. Formatteert context naar leesbare prompt +3. Claude analyseert en retourneert JSON met: actions[], reasoning, needsClarification +4. Zod-validatie op AI-response met fallback bij parse-fouten +5. Bouwt `IntentChain` met één of meer sequentiële acties +6. Bij falen: fallback naar Reflex-resultaat met confidence gecapped op 0.6 + +**Capabilities**: +- Multi-intent splitting ("annuleer afspraak en maak notitie" → 2 acties) +- Voornaamwoordresolutie ("hij" → actieve patiënt) +- Relatieve tijdparsing ("morgen" → concrete datum) +- Bevestigingsvlaggen voor destructieve acties + +**Timeout**: 5 seconden via `Promise.race` + +### 4.4 Layer 3: Nudge + +**Bestand**: `lib/cortex/nudge.ts` + +**Doel**: Proactieve suggesties na afgeronde acties op basis van klinische protocollen. + +**Werking**: +1. Na voltooiing van een actie wordt `evaluateNudge()` aangeroepen +2. Controleert alle protocolregels: intent-match + conditiechecks (AND-logica) +3. Condities: `equals`, `contains`, `matches` (regex), `exists` +4. Genereert `NudgeSuggestion` met voorgeinvulde entities +5. Sorteert op prioriteit (high → medium → low) +6. Suggesties verlopen na 5 minuten (configureerbaar per regel) + +**Huidige regels** (2 MVP): +| Regel | Trigger | Suggestie | +|-------|---------|-----------| +| Wondzorg-controle | dagnotitie + content bevat "wond" | Wondcontrole inplannen over 3 dagen | +| Medicatie-controle | dagnotitie + content bevat "medicatie" + "gewijzigd" | Medicatie evaluatie over 1 week | + +### 4.5 API-integratie + +#### Classify API (`/api/cortex/classify`) + +Hybride endpoint dat Layer 1 en 2 combineert: +1. Authenticatie via Supabase +2. Zod-validatie op request (input, context, options) +3. Feature flag check (`CORTEX_V2_ENABLED`) +4. Reflex → eventueel Orchestrator → eventueel Fallback +5. Retourneert `IntentChain` + debug-informatie + +#### Chat API (`/api/cortex/chat`) + +Streaming conversatie-endpoint (SSE) met Claude Sonnet: +- Eigen system prompt met volledige intentbeschrijvingen +- Conversatiegeschiedenis (max 20 berichten) +- Genereert JSON action objects in de tekststroom +- In-memory rate limiting (20 req/min per gebruiker) +- Eigen entity-extractie via prompt engineering + +#### Overige Cortex APIs +- `/api/cortex/context` — Gebruikerscontext ophalen +- `/api/cortex/patients/search` — Patiëntzoeken +- `/api/cortex/agenda/*` — CRUD voor afspraken +- `/api/cortex/intake/*` — Intakequeries + +### 4.6 State Management + +**Bestand**: `stores/cortex-store.ts` (Zustand) + +Eén monolithische store voor alle Cortex-state: +- **Context**: activePatient, shift, recentPatients +- **Chat**: chatMessages, isStreaming, pendingAction +- **Artifacts**: openArtifacts (max 3), activeArtifactId +- **V2 Chain**: activeChain, chainHistory +- **Nudge**: suggestions (add/accept/dismiss) +- **Clarification**: pendingClarification +- **UI**: inputValue, isVoiceActive, patientSidebarOpen + +### 4.7 Feature Flags + +**Bestand**: `lib/config/feature-flags.ts` + +Vier flags via environment variables: +- `CORTEX_V2_ENABLED` — Drie-laags architectuur aan/uit +- `CORTEX_MULTI_INTENT` — Multi-intent detectie +- `CORTEX_NUDGE` — Proactieve suggesties +- `CORTEX_LOGGING` — Debug logging + +In development staan alle flags standaard aan (tenzij expliciet `false`). + +--- + +## 5. Analyse: Sterke punten + +### 5.1 Architecturele beslissingen + +| Beslissing | Toelichting | +|------------|-------------| +| **Drie-laags fallback** | Graceful degradation: als AI faalt, valt het systeem terug op lokale matching | +| **Gewogen patroonmatching** | Nuanced confidence via weights i.p.v. binaire matches | +| **Ambiguïteitdetectie** | Top-2 tracking voorkomt foutieve classificatie bij twijfelgevallen | +| **Zod-validatie op AI output** | Beschermt tegen onverwachte LLM-responses met gestructureerde fallbacks | +| **IntentChain-model** | Multi-intent support is architectureel correct opgezet | +| **Protocol-based nudges** | Klinische onderbouwing via metadata (naam, referentie, rationale) | + +### 5.2 Implementatiekwaliteit + +- TypeScript-types zijn doordacht en consistent +- Escalatielogica is helder: detectie → reden → result +- Fallback-chain is compleet: AI fout → Reflex result met confidence cap +- Zod-schemas met `.catch()` en `.passthrough()` voor robuuste parsing + +--- + +## 6. Analyse: Knelpunten + +### 6.1 K1 — Twee divergente classificatiepaden + +**Probleem**: De Classify API (`/api/cortex/classify`) en de Chat API (`/api/cortex/chat`) zijn volledig onafhankelijke implementaties van intentherkenning. + +| Aspect | Classify API | Chat API | +|--------|-------------|----------| +| Classificatie | Reflex → Orchestrator | Eigen system prompt | +| Model | Claude Haiku | Claude Sonnet | +| Entity-extractie | AI (Orchestrator) | Prompt engineering | +| Output | IntentChain (gestructureerd) | JSON-in-tekststroom | +| Intents beschreven | `orchestrator.ts` prompt | `chat/route.ts` prompt | + +**Impact**: Intentbeschrijvingen worden op twee plekken bijgehouden. Wijzigingen in het ene pad worden niet automatisch doorgevoerd in het andere. + +**Ernst**: Hoog — Dit is de belangrijkste architecturale schuld. + +### 6.2 K2 — Intent-definities op drie plekken + +Een intent wordt momenteel op drie locaties gedefinieerd: + +1. **types.ts** — TypeScript type (`CortexIntent` union type) +2. **reflex-classifier.ts** — Regex-patronen en gewichten +3. **orchestrator.ts** — Systemprompt met intentbeschrijvingen en voorbeelden + +Een nieuw intent toevoegen vereist wijzigingen op alle drie plekken, plus optioneel de Chat API prompt (vierde plek). + +**Impact**: Hoog risico op inconsistentie bij wijzigingen. + +### 6.3 K3 — Reflex doet geen entity-extractie + +Layer 1 retourneert altijd `entities: {}`. Dit betekent dat zelfs bij een hoge-confidence match ("notitie jan medicatie") geen entities worden doorgegeven aan de UI. De actie wordt geopend zonder prefill-data. + +**Impact**: Gemiste kans op snellere interactie. In 70%+ van de gevallen (Reflex handled) gaat entity-informatie verloren. + +### 6.4 K4 — Nudge-systeem is niet geïntegreerd + +De `evaluateNudge()` functie bestaat maar er is geen duidelijk aanroeppunt in de applicatiecode na actievoltooiing. De integratie tussen actiecompletie (store) en nudge-evaluatie ontbreekt. + +**Impact**: Layer 3 is effectief inactief zonder expliciete aanroep. + +### 6.5 K5 — Monolithische store + +De Zustand store bevat ~580 regels en beheert 7 verschillende domeinen (context, chat, artifacts, chains, nudges, clarification, UI). Dit maakt de store moeilijk te testen en te refactoren. + +### 6.6 K6 — Operationele blinde vlekken + +- **Logging**: Alleen `console.log` met feature flag; geen gestructureerde logging +- **Metrics**: Geen tracking van classificatiesnelheid, hit rates, of fallback-frequentie in productie +- **Rate limiting**: In-memory (verloren bij restart), niet geschikt voor multi-instance deployment + +### 6.7 K7 — Orchestrator timeout is niet doorverbonden + +De `classifyWithTimeout` wrapper maakt een `AbortController` aan, maar verbindt het signal niet met de daadwerkelijke `fetch`-call in `classifyWithOrchestrator`. Bij timeout wordt het API-verzoek naar Claude niet afgebroken — het blijft lopen. + +--- + +## 7. Doelarchitectuur (To-Be) + +### 7.1 Architectuuroverzicht + +``` +┌───────────────────────────────────────────────────────────────────┐ +│ CORTEX COMMAND CENTER │ +│ │ +│ ┌─────────┐ ┌──────────────────────────────────────────────┐ │ +│ │ Input │──▶│ Classification Pipeline │ │ +│ │ (tekst/ │ │ │ │ +│ │ spraak) │ │ ┌──────────┐ ┌──────────┐ ┌────────┐ │ │ +│ └─────────┘ │ │ Reflex │──▶│ Orchestr.│──▶│ Entity │ │ │ +│ │ │ (Layer 1)│ │ (Layer 2)│ │ Enrich │ │ │ +│ │ └──────────┘ └──────────┘ └────────┘ │ │ +│ │ ↑ │ │ +│ │ Intent Registry (single source) │ │ +│ └──────────────────┬───────────────────────────┘ │ +│ │ │ +│ ▼ │ +│ ┌──────────────────────────────────────────────┐ │ +│ │ Action Executor │ │ +│ │ Chain uitvoering → API calls → Result │ │ +│ └──────────────────┬───────────────────────────┘ │ +│ │ │ +│ ▼ │ +│ ┌──────────────────────────────────────────────┐ │ +│ │ Nudge Evaluator (Layer 3) │ │ +│ │ Protocol rules → Suggesties │ │ +│ └──────────────────────────────────────────────┘ │ +│ │ +│ ┌───────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ +│ │ Chat │ │ Artifact │ │ Nudge │ │ Context │ │ +│ │ Store │ │ Store │ │ Store │ │ Store │ │ +│ └───────────┘ └────────────┘ └────────────┘ └────────────┘ │ +└───────────────────────────────────────────────────────────────────┘ +``` + +**Kernwijziging**: Eén classificatiepipeline als backbone. Chat en Classify gebruiken dezelfde pipeline. De Chat API voegt conversatie-context toe, maar delegeert classificatie. + +### 7.2 Intent Registry — Single Source of Truth + +**Probleem opgelost**: K1, K2 + +Het centrale concept is een `IntentRegistry`: één plek waar elk intent volledig is gedefinieerd. + +```typescript +// lib/cortex/intent-registry.ts + +interface IntentDefinition { + /** Uniek ID */ + id: CortexIntent; + + /** Weergavenaam (Nederlands) */ + label: string; + + /** Beschrijving voor AI-prompt (Nederlands) */ + description: string; + + /** Prioriteit: P1 (kritiek), P2 (belangrijk), P3 (overig) */ + priority: 'P1' | 'P2' | 'P3'; + + /** Regex-patronen voor Reflex Arc met gewichten */ + reflexPatterns: Array<{ pattern: RegExp; weight: number }>; + + /** Entity-schema voor dit intent */ + entitySchema: { + required: string[]; + optional: string[]; + extraction: EntityExtractionRule[]; + }; + + /** Of dit intent bevestiging vereist */ + requiresConfirmation: boolean; + + /** Voorbeelden voor AI-prompt (input → verwacht resultaat) */ + examples: Array<{ input: string; entities: Record }>; + + /** Gekoppeld artifact type */ + artifactType: BlockType | null; + + /** Feature flag (optioneel) */ + featureFlag?: FeatureFlagKey; +} +``` + +**Voordelen**: +- Eén plek om een intent toe te voegen of te wijzigen +- Reflex-patronen en AI-promptbeschrijvingen komen uit dezelfde bron +- Entity-schema's zijn herbruikbaar voor validatie +- Voorbeelden dienen zowel de AI-prompt als test-cases +- Feature flags per intent voor granulaire rollout + +**Afgeleide functies**: +- `getReflexPatterns()` → genereert patroonmap voor Layer 1 +- `buildOrchestratorPrompt()` → genereert systemprompt voor Layer 2 vanuit registry +- `buildChatPrompt()` → genereert systemprompt voor Chat API vanuit registry +- `getEntitySchema(intent)` → retourneert Zod-schema voor entity-validatie + +### 7.3 Layer 1: Reflex Arc (verbeterd) + +**Probleem opgelost**: K3 + +``` +Input + │ + ├─ 1. Escalatiedetectie (ongewijzigd) + │ + ├─ 2. Patroonmatching via IntentRegistry + │ + └─ 3. [NIEUW] Basis entity-extractie + │ + └─ EntityExtractionRule's uit registry + Voorbeeld: patientName via /^notitie\s+(\w+)/ +``` + +**Wijzigingen t.o.v. huidige implementatie**: + +1. **Patronen laden uit IntentRegistry** i.p.v. hardcoded `INTENT_PATTERNS` object +2. **Basis entity-extractie toevoegen** via capture groups in regex-patronen +3. **Patroonmatching optimalisatie**: patronen per intent gesorteerd op gewicht (hoogste eerst), met early-exit bij weight 1.0 + +**Entity-extractie voorbeeld**: +```typescript +interface EntityExtractionRule { + /** Regex met named capture groups */ + pattern: RegExp; + /** Mapping: capture group naam → entity veld */ + mapping: Record; +} + +// Voorbeeld voor dagnotitie: +{ + pattern: /^notitie\s+(?\w+)\s+(?medicatie|adl|gedrag)/i, + mapping: { patient: 'patientName', cat: 'category' } +} +``` + +**Wat NIET wijzigt**: De escalatielogica, confidence thresholds, en ambiguïteitdetectie blijven ongewijzigd. Deze werken goed. + +### 7.4 Layer 2: Orchestrator (verbeterd) + +**Probleem opgelost**: K1, K7 + +**Wijzigingen**: + +#### 7.4.1 Promptgeneratie uit IntentRegistry + +De systemprompt wordt niet meer handmatig bijgehouden maar gegenereerd: + +```typescript +function buildOrchestratorPrompt(registry: IntentDefinition[]): string { + const intentSection = registry + .map(intent => ` +**${intent.id}** — ${intent.description} + Entities: ${intent.entitySchema.required.join(', ')} (verplicht), ${intent.entitySchema.optional.join(', ')} (optioneel) + Voorbeelden: ${intent.examples.map(e => `"${e.input}"`).join(', ')} + `).join('\n'); + + return `${ORCHESTRATOR_BASE_PROMPT}\n\n## Intent Types\n${intentSection}`; +} +``` + +De basisprompt (instructies over multi-intent, voornaamwoordresolutie, etc.) blijft statisch. Alleen de intentlijst wordt dynamisch gegenereerd. + +#### 7.4.2 AbortController doorverbinden + +```typescript +// Fix: signal doorverbinden naar fetch +const response = await fetch('https://api.anthropic.com/v1/messages', { + signal, // AbortController.signal + // ... rest +}); +``` + +#### 7.4.3 Circuit breaker (simpel) + +In plaats van alleen een timeout, een eenvoudig circuit breaker-patroon: + +```typescript +interface CircuitState { + failures: number; + lastFailure: number; + isOpen: boolean; +} + +// Na 3 opeenvolgende fouten: circuit open voor 30 seconden +// Gedurende open circuit: directe fallback naar Reflex zonder API-call +``` + +Dit voorkomt dat bij een Claude API-storing elk request 5 seconden wacht op timeout. + +### 7.5 Unified Classification Pipeline + +**Probleem opgelost**: K1 + +De kern van de verbetering: één pipeline die zowel de Classify als Chat API gebruiken. + +``` +┌──────────────────────────────────────────────────────────┐ +│ Classification Pipeline │ +│ │ +│ classifyInput(input, context) → ClassificationResult │ +│ │ +│ 1. Reflex Arc → LocalResult │ +│ 2. if (shouldEscalate) → Orchestrator → AIResult │ +│ 3. if (AIResult fails) → Fallback │ +│ 4. Entity enrichment → Final result │ +│ │ +│ Output: { intent, confidence, entities, chain, source } │ +└──────────────────────────────────────────────────────────┘ + │ │ + ▼ ▼ +┌──────────────────┐ ┌──────────────────────┐ +│ Classify API │ │ Chat API │ +│ Retourneert │ │ Gebruikt result als │ +│ pipeline result │ │ context voor LLM │ +│ direct │ │ conversatie │ +└──────────────────┘ └──────────────────────┘ +``` + +**Chat API wijziging**: In plaats van intentherkenning te dupliceren in de systemprompt, stuurt de Chat API eerst de input door de pipeline. Het resultaat wordt meegegeven aan de LLM als context: + +``` +Systemprompt (kort): Je bent Cortex Assistent. [tone of voice, regels] + +Context: { classificationResult, activePatient, shift } + +Opdracht: Formuleer een natuurlijk antwoord en bevestig de actie. +``` + +De LLM hoeft niet meer te classificeren — alleen te converseren. + +### 7.6 Layer 3: Nudge (verbeterd) + +**Probleem opgelost**: K4 + +#### 7.6.1 Integratiepatroon + +De integratie loopt via de Action Executor: + +```typescript +// In de action executor (na succesvolle actie): +async function executeAction(action: IntentAction): Promise { + // ... actie uitvoeren ... + + // Na succes: nudge evalueren + const nudges = evaluateNudge({ + intent: action.intent, + actionId: action.id, + entities: action.entities, + content: originalInput, + }); + + // Nudges toevoegen aan store + for (const nudge of nudges) { + nudgeStore.addSuggestion(nudge); + } +} +``` + +#### 7.6.2 Regelopslag scheiden van engine + +``` +┌─────────────────────────────────────────────┐ +│ Nudge Engine │ +│ │ +│ evaluateNudge(input, rules) → suggestions │ +│ │ +│ - Puur functioneel: input → output │ +│ - Geen kennis van waar regels vandaan komen │ +└──────────────────────┬──────────────────────┘ + │ + Regels laden uit: + │ + ┌─────────────┴─────────────┐ + │ │ + ┌────▼────┐ ┌───────▼──────┐ + │ Hardcod │ │ Database/ │ + │ (MVP) │ │ Config (v2) │ + └─────────┘ └──────────────┘ +``` + +De `evaluateNudge` functie accepteert regels als parameter i.p.v. het importeren van `PROTOCOL_RULES`. Dit maakt de engine testbaar en de regelbron vervangbaar. + +#### 7.6.3 Feedback loop (post-MVP) + +Track per regel: +- Aantal keer getoond +- Aantal keer geaccepteerd +- Aantal keer verworpen +- Gemiddelde reactietijd + +Dit is bewust post-MVP maar het datamodel moet er nu al rekening mee houden door `accept/dismiss` events op te slaan. + +### 7.7 State Management (opsplitsing) + +**Probleem opgelost**: K5 + +Splits de monolithische store in domein-specifieke stores: + +``` +stores/ +├── cortex-context-store.ts # activePatient, shift, recentPatients +├── cortex-chat-store.ts # chatMessages, isStreaming, pendingAction +├── cortex-artifact-store.ts # openArtifacts, activeArtifactId +├── cortex-action-store.ts # activeChain, chainHistory +└── cortex-nudge-store.ts # suggestions, accept/dismiss +``` + +**Koppeling tussen stores**: Via Zustand's `subscribe` mechanisme. Voorbeeld: + +```typescript +// Wanneer een chain completeert, evalueer nudges +cortexActionStore.subscribe( + state => state.activeChain, + (chain, previousChain) => { + if (previousChain && !chain) { + // Chain is zojuist voltooid + const completedActions = previousChain.actions.filter(a => a.status === 'success'); + // → evaluateNudge voor elke voltooide actie + } + } +); +``` + +Elke store blijft klein (<150 regels), testbaar, en verantwoordelijk voor één domein. + +### 7.8 Observability + +**Probleem opgelost**: K6 + +#### 7.8.1 Gestructureerde logging + +Vervang `console.log` door gestructureerde log-events: + +```typescript +interface CortexLogEvent { + timestamp: string; + layer: 'reflex' | 'orchestrator' | 'nudge' | 'pipeline'; + event: string; + data: Record; + durationMs?: number; + userId?: string; +} + +// Voorbeeld: +log({ + layer: 'reflex', + event: 'classification_complete', + data: { + input: input.slice(0, 50), + intent: result.intent, + confidence: result.confidence, + escalated: result.shouldEscalateToAI, + escalationReason: result.escalationReason, + }, + durationMs: result.processingTimeMs, +}); +``` + +#### 7.8.2 Metrics + +Minimale set metrics voor productie: + +| Metric | Type | Beschrijving | +|--------|------|-------------| +| `cortex.classify.duration_ms` | histogram | Totale classificatietijd | +| `cortex.reflex.hit_rate` | counter | % dat Reflex zelfstandig afhandelt | +| `cortex.orchestrator.fallback_rate` | counter | % AI-fouten met fallback | +| `cortex.orchestrator.timeout_rate` | counter | % timeouts | +| `cortex.nudge.shown` | counter | Nudges getoond per regel-ID | +| `cortex.nudge.accepted` | counter | Nudges geaccepteerd per regel-ID | +| `cortex.intent.distribution` | counter | Frequentie per intent type | + +In eerste instantie te loggen naar de bestaande `ai_events` tabel. Externe monitoring (Datadog, Grafana) als post-MVP. + +--- + +## 8. Integratiearchitectuur + +### 8.1 API-structuur (herzien) + +``` +/api/cortex/ +├── classify/ # POST — Classification Pipeline (bestaand, herzien) +├── chat/ # POST — Streaming chat (herzien: gebruikt pipeline) +├── context/ # GET — Gebruikerscontext (ongewijzigd) +├── patients/search/ # GET — Patiëntzoeken (ongewijzigd) +├── agenda/ # GET — Dagagenda (ongewijzigd) +├── agenda/create/ # POST — Afspraak maken (ongewijzigd) +├── agenda/cancel/ # POST — Afspraak annuleren (ongewijzigd) +├── agenda/reschedule/ # POST — Afspraak verzetten (ongewijzigd) +└── intake/ # GET — Intakequeries (ongewijzigd) +``` + +De primaire wijziging is dat `/api/cortex/chat` intern de classification pipeline aanroept in plaats van classificatie te dupliceren. + +### 8.2 Dataflow: Input tot Actie + +``` +1. Gebruiker typt/spreekt: "Notitie jan medicatie gegeven" + │ +2. Client stuurt naar: POST /api/cortex/chat + │ +3. Chat API: │ + a. classifyInput(input, context) + → Reflex: intent=dagnotitie, confidence=1.0, entities={patientName:"jan", category:"medicatie"} + → Geen escalatie nodig + │ + b. LLM call met: + - Systemprompt (tone of voice, regels) + - Classification result als context + - Conversatiegeschiedenis + │ + c. LLM genereert: "Komt voor elkaar. Jan, medicatie." + + JSON action block + │ +4. Client ontvangt SSE stream + │ +5. Action parsing → pendingAction in store + │ +6. CommandCenter opent DagnotitieBlock met prefill: + { patientName: "jan", category: "medicatie", content: "medicatie gegeven" } + │ +7. Gebruiker bevestigt/past aan → POST /api/reports + │ +8. Na succes: evaluateNudge() + → Geen match (content bevat geen "wond" of "medicatie gewijzigd") + → Geen nudge +``` + +### 8.3 Afhankelijkheden buiten scope + +| Afhankelijkheid | Relatie met Cortex | Status | +|-----------------|-------------------|--------| +| **Autorisatiemodel** | Bepaalt welke intents een gebruiker mag uitvoeren | Niet geïmplementeerd | +| **Datamodel (FHIR)** | Entities moeten mappen naar FHIR-resources | Gedeeltelijk | +| **Audit trail** | Elke Cortex-actie moet gelogd worden | Basis via `ai_events` tabel | +| **Notificatiesysteem** | Nudges zouden ook via push/email kunnen | Niet aanwezig | + +--- + +## 9. Enterprise-eisen + +### 9.1 Niet-Functionele Eisen (NFR's) + +#### 9.1.1 Latency + +| Scenario | Target (P95) | Target (P99) | Huidige status | +|----------|-------------|-------------|----------------| +| Reflex-only classificatie | <20ms | <50ms | Voldoet (regex, lokaal) | +| Reflex + Orchestrator (AI) | <3s | <5s | ~2-4s (afhankelijk van Claude API) | +| End-to-end: input → artifact open | <500ms (Reflex) / <4s (AI) | <1s / <6s | Niet gemeten | +| Chat response (first token) | <1s | <2s | ~1-2s (SSE streaming) | +| Nudge evaluatie | <10ms | <20ms | Voldoet (lokale regelengine) | + +**Latency budget uitsplitsing** (worst case, AI-pad): + +``` +Gebruikersinput 0ms +├─ Reflex classificatie 20ms +├─ Escalatiebeslissing 1ms +├─ Orchestrator API call 3000ms ← dominante factor +├─ Response parsing + validatie 5ms +├─ Entity enrichment 10ms +├─ Store update + UI render 50ms +└─ Artifact open (data fetch) 200ms + Totaal: ~3.3s +``` + +**Implicatie**: De Orchestrator API call bepaalt de E2E latency. Optimalisatie moet zich richten op (1) Reflex hit-rate verhogen zodat minder naar AI geëscaleerd wordt, en (2) circuit breaker zodat bij API-traagheid snel gefallbacked wordt. + +#### 9.1.2 Beschikbaarheid + +| Component | Beschikbaarheidseis | Failover-strategie | +|-----------|--------------------|--------------------| +| **Reflex Arc** | 99.9% (systeembeschikbaarheid) | Geen externe dependency; draait in-process | +| **Orchestrator** | Best-effort (afhankelijk van AI-provider) | Fallback naar Reflex met confidence cap 0.6 | +| **Nudge Engine** | 99.9% (lokale regelengine) | Geen externe dependency | +| **Chat API** | Best-effort | Fallback: classificatie werkt nog, conversatie niet | +| **Cortex als geheel** | 99.9% voor basisclassificatie | Drie degradatieniveaus (zie hieronder) | + +**Degradatieniveaus**: + +``` +Niveau 0: Volledig operationeel + Reflex + Orchestrator + Nudge + Chat + Latency: P95 <3s (AI-pad), <500ms (Reflex-pad) + +Niveau 1: AI-provider onbeschikbaar + Reflex + Nudge + Chat (zonder classificatie) + Impact: Complexe input wordt minder goed begrepen + Latency: P95 <500ms (alles lokaal) + Automatische trigger: Circuit breaker na 3 fouten + +Niveau 2: Database onbeschikbaar + Alleen Reflex classificatie (geen data-acties) + Impact: Intents worden herkend maar niet uitgevoerd + Gebruikersfeedback: "Classificatie succesvol, maar + de actie kan momenteel niet worden uitgevoerd" + +Niveau 3: Volledig onbeschikbaar + Cortex command center niet bereikbaar + Impact: Gebruiker valt terug op traditionele EPD-navigatie + EPD-modules blijven direct bereikbaar +``` + +#### 9.1.3 AI-provider abstractie + +Het systeem is momenteel hard gekoppeld aan Anthropic Claude (Haiku voor classificatie, Sonnet voor chat). Dit is een vendor lock-in risico. + +**Huidige koppelingen**: + +| Koppeling | Locatie | Impact bij providerwisseling | +|-----------|---------|------------------------------| +| Model ID (`claude-3-5-haiku`) | `orchestrator.ts` | Aanpassen | +| Model ID (`claude-sonnet-4-5-20250929`) | `chat/route.ts` | Aanpassen | +| Anthropic SDK (`@anthropic-ai/sdk`) | Beide API routes | Vervangen | +| Prompt-format (system/user rollen) | Orchestrator + Chat | Herschrijven (model-afhankelijk) | +| Response-parsing (JSON uit LLM) | `orchestrator.ts` | Herijken (output varieert per model) | + +**Aanbevolen abstractie** (minimaal): + +```typescript +interface LLMProvider { + classify(input: string, systemPrompt: string, context: string): Promise; + stream(messages: Message[], systemPrompt: string): AsyncIterable; +} +``` + +Eén interface, twee implementaties (Anthropic, OpenAI). Geen framework (LangChain, Vercel AI SDK) nodig — de interface is klein genoeg om direct te implementeren. + +**Prompt-portabiliteit**: Prompts zijn niet 1-op-1 overdraagbaar tussen modellen. De systeemprompt (met JSON-outputformat, intentbeschrijvingen, en voorbeelden) is geoptimaliseerd voor Claude. Bij een providerwisseling moeten prompts geherijkt worden. Dit is inherent aan LLM-gebruik en niet volledig te abstraheren. + +#### 9.1.4 Schaalbaarheid + +| Dimensie | Huidig ontwerp | Enterprise target | Bottleneck | +|----------|---------------|-------------------|------------| +| Concurrent users | Onbeperkt (stateless API) | 100-500 per organisatie | Rate limiting (nu in-memory) | +| Intents per seconde | Niet gemeten | 50-100 req/s | AI-provider rate limits | +| Aantal intents | 11 | 30-50 | Reflex patroonmatching O(n×p) | +| Conversatie-lengte | 20 berichten (hardcoded) | 20-50 berichten | Context window + kosten | +| Nudge-regels | 2 (hardcoded) | 20-50 | Evaluatietijd O(r×c) | + +**Reflex schaalbaarheid bij meer intents**: + +Bij 11 intents × ~8 patronen = ~88 regex evaluaties per classificatie. Bij 50 intents × 8 patronen = ~400 evaluaties. Dit blijft <50ms maar kan geoptimaliseerd worden met: + +1. **Keyword pre-filter**: Eerste woord matchen tegen index → alleen relevante intents evalueren +2. **Prioriteit-gebaseerde volgorde**: P1-intents eerst; bij hoge-confidence match, stop +3. **Categorie-groepering**: Intents per domein (klinisch, administratief, navigatie) → per categorie evalueren + +Deze optimalisaties zijn beschreven in `docs/intent/design/architecture-intent-scalability.md`. + +**Rate limiting** (enterprise): + +In-memory rate limiting (huidige implementatie) verliest state bij restart en werkt niet bij meerdere server-instances. Enterprise-alternatief: + +| Optie | Complexiteit | Geschikt voor | +|-------|-------------|---------------| +| Supabase rate limit tabel | Laag | Single-instance, eenvoudig | +| Redis (Upstash) | Medium | Multi-instance, serverless | +| API Gateway rate limiting | Laag | Als er al een API gateway is | + +#### 9.1.5 Data-eigenaarschap en retentie + +| Datatype | Eigenaar | Retentie | Locatie | +|----------|---------|----------|---------| +| **Classificatieresultaten** | Organisatie | 90 dagen (analytics) | `ai_events` tabel | +| **Chatberichten** | Organisatie | Sessie-duur (niet persistent) | In-memory (client) | +| **AI API calls (input/output)** | Organisatie + AI-provider | Per provider-DPA | Anthropic servers (niet persistent bij API) | +| **Nudge-interacties** | Organisatie | 1 jaar (kwaliteitsverbetering) | Database | +| **Audit events** | Organisatie | 5 jaar (NEN 7510) | Audit-tabel (append-only) | + +**Aandachtspunten**: +- Chatberichten worden niet naar de database geschreven. Bij een enterprise-omgeving met auditplicht moet overwogen worden of chatgeschiedenis persistent moet zijn. +- AI API calls bevatten potentieel patiëntgegevens in de prompt. Anthropic's data processing agreement garandeert dat API-data niet gebruikt wordt voor training, maar dit moet contractueel geborgd zijn. +- PII in logs: Alle log-events moeten door een sanitisatiestap gaan die patiëntnamen, BSN, en andere PII verwijdert of hasht voordat ze worden opgeslagen. + +### 9.2 NEN 7510 (Informatiebeveiliging in de zorg) + +| Eis | Huidige status | Actie nodig | +|-----|---------------|-------------| +| Toegangsbeveiliging | Supabase Auth + RLS | Rol-gebaseerde intentfiltering toevoegen | +| Logging van toegang | Gedeeltelijk (`ai_events`) | Uitbreiden naar alle Cortex-acties | +| Geen PII in logs | Niet gegarandeerd | Inputsanitisatie in log-events | +| Encryptie in transit | HTTPS (Vercel default) | Voldoende | +| Encryptie at rest | Supabase managed | Voldoende | +| Integriteitscontrole | Niet aanwezig | Checksums op audit-records (append-only tabel) | +| Incidentregistratie | Niet aanwezig | Cortex-fouten loggen als beveiligingsincident bij herhaaldelijk falen | + +### 9.3 Audit Logging + +Elke Cortex-interactie moet gelogd worden: + +```typescript +interface AuditEvent { + userId: string; + action: 'classify' | 'chat' | 'nudge_shown' | 'nudge_accepted' | 'action_executed'; + intent?: CortexIntent; + confidence?: number; + source?: 'reflex' | 'orchestrator' | 'fallback'; + patientId?: string; + input?: string; // Gesanitiseerd (PII verwijderd) + result?: string; // Samenvatting, geen volledige response + timestamp: string; + sessionId?: string; // Voor correlatie binnen één gebruikerssessie + durationMs?: number; // Verwerkingstijd + metadata?: Record; +} +``` + +**Opslagvereisten**: +- Append-only tabel (geen UPDATE of DELETE) +- Retentie: minimaal 5 jaar (NEN 7510) +- Indexen op: `userId`, `patientId`, `timestamp`, `action` + +### 9.4 Role-Based Access (voorbereiding) + +Het intent-systeem moet voorbereid zijn op rolgebaseerde filtering: + +```typescript +interface IntentDefinition { + // ... bestaande velden ... + + /** Welke rollen mogen dit intent gebruiken */ + allowedRoles?: string[]; // Leeg = iedereen +} +``` + +Voorbeeldtoepassing: + +| Rol | Toegestane intents | Geblokkeerde intents | +|-----|-------------------|---------------------| +| Verpleegkundige | dagnotitie, overdracht, zoeken, agenda_* | — | +| Behandelaar | Alle | — | +| Stagiair | zoeken, agenda_query | cancel_appointment, reschedule_appointment | +| Admin | Alle + systeem-intents | — | + +Dit hoeft nu niet geïmplementeerd te worden, maar het veld moet gereserveerd zijn in de IntentRegistry. De filtering kan als middleware in de Classification Pipeline worden toegevoegd: + +``` +Input → [RBAC filter] → Reflex → Orchestrator → Result + ↓ + Als intent niet toegestaan: + → "Je hebt geen toegang tot deze functie" +``` + +--- + +## 10. Migratiepad + +### 10.1 Fase 1 — Intent Registry + Reflex entity-extractie + +**Doel**: Single Source of Truth voor intents, betere Reflex output. + +1. Maak `lib/cortex/intent-registry.ts` met alle 11 intents +2. Refactor `reflex-classifier.ts` om patronen uit registry te laden +3. Voeg basis entity-extractie toe aan Reflex (capture groups) +4. Genereer Orchestrator-prompt uit registry +5. Tests: verifieer dat bestaande classificatie niet breekt + +**Risico**: Laag — Refactoring zonder gedragswijziging (behalve entity-extractie toevoeging). + +### 10.2 Fase 2 — Unified Pipeline + Chat integratie + +**Doel**: Eén classificatiepad, Chat API als conversatielaag. + +1. Extract `classifyInput()` als standalone pipeline-functie +2. Pas Chat API aan om pipeline te gebruiken +3. Vereenvoudig Chat systemprompt (geen intentherkenning meer) +4. Fix AbortController doorverbinding +5. Voeg circuit breaker toe + +**Risico**: Medium — Chat-gedrag kan subtiel veranderen. Uitgebreid testen met bestaande scenarios. + +### 10.3 Fase 3 — Nudge integratie + Store opsplitsing + +**Doel**: Layer 3 daadwerkelijk actief, state management opgeschoond. + +1. Splits Zustand store in 5 domein-stores +2. Integreer `evaluateNudge()` via store subscription na chain completion +3. Voeg 3-5 klinische regels toe aan nudge systeem +4. Implementeer nudge tracking (getoond/geaccepteerd/verworpen) + +**Risico**: Laag — Nieuwe functionaliteit, geen breaking changes. + +### 10.4 Fase 4 — Observability + Enterprise + +**Doel**: Productieklare logging en monitoring. + +1. Gestructureerde logging implementeren +2. Metrics toevoegen aan classification pipeline +3. Audit events loggen naar database +4. Rate limiting naar database-backed (Redis of Supabase) +5. Input sanitisatie voor logs (geen PII) + +**Risico**: Laag — Cross-cutting concerns, geen functionaliteitswijziging. + +--- + +## 11. Samenvatting + +### Kernboodschap + +Het huidige prototype heeft een architectureel solide basis (drie-laags model, fallback-strategie, Zod-validatie). De belangrijkste verbeterslag is **unificatie**: één Intent Registry als bron van waarheid, één classificatiepipeline die zowel directe classificatie als chat bedient, en gesplitste state management voor onderhoudbaarheid. + +### Prioriteiten + +| # | Wijziging | Impact | Inspanning | +|---|-----------|--------|------------| +| 1 | Intent Registry (Single Source of Truth) | Hoog | Medium | +| 2 | Unified Classification Pipeline | Hoog | Medium | +| 3 | Reflex entity-extractie | Medium | Laag | +| 4 | Nudge integratie | Medium | Laag | +| 5 | Store opsplitsing | Medium | Medium | +| 6 | Observability | Medium | Laag | +| 7 | Circuit breaker + AbortController fix | Laag | Laag | +| 8 | Enterprise (audit, RBAC-voorbereiding) | Laag (nu) | Laag | + +### Wat bewust NIET wordt voorgesteld + +- **Event bus / pub-sub**: Overkill voor single-tenant applicatie; Zustand subscriptions volstaan +- **Microservices**: Cortex als apart systeem deployen voegt complexiteit toe zonder voordeel bij deze schaal +- **ML-model voor classificatie**: Regex + LLM fallback is effectiever en beter debugbaar dan een custom model +- **Nudge learning via ML**: Accept/dismiss tracking is voldoende; automatische regeloptimalisatie is premature complexiteit +- **Multi-tenancy**: Buiten scope; de architectuur sluit het niet uit maar optimaliseert er niet voor + +--- + +## 12. Appendix — Documentatie-index + +Dit rapport is de architecturale toegangspoort tot het Cortex-systeem. Onderstaande index verwijst naar alle gerelateerde documentatie in de codebase, gegroepeerd per fase van het ontwerpproces. + +### 12.1 Strategie & Product + +| Document | Pad | Beschrijving | +|----------|-----|-------------| +| PRD Cortex V2 | `docs/intent/prd-cortex-v2.md` | Product Requirements: transformatie van reactief "spraakgestuurd toetsenbord" naar AI Collega met context-awareness en multi-intent | +| MVP User Stories | `docs/intent/mvp-userstories-intent-system.md` | Scope-definitie voor de publieke Cortex-prototype met agency en multi-intent demonstratie | +| Haalbaarheidsanalyse | `docs/intent/haalbaarheidsanalyse-cortex-v2.md` | Conclusie: Cortex V2 haalbaar met 70% bestaande infrastructuur; gefaseerde aanpak | +| Demo Script | `docs/intent/demo-script-cortex-v2.md` | 5-minuten demonstratiescript met environment setup en feature flag configuratie | + +### 12.2 Functioneel & Technisch Ontwerp + +| Document | Pad | Beschrijving | +|----------|-----|-------------| +| Functioneel Ontwerp V2 | `docs/intent/fo-cortex-intent-system-v2.md` | FO gericht op contextbegrip, meerdere intenties en proactieve ondersteuning | +| Technisch Ontwerp V2 | `docs/intent/to-cortex-v2.md` | Vertaling naar concrete architectuur, techstack, datamodellen en implementatiedetails | +| Bouwplan Cortex V2 | `docs/intent/bouwplan-cortex-v2.md` | Implementatieplan met epic-structuur voor drie-laag architectuur | +| Review Rapport | `docs/intent/review-cortex-v2.md` | Architectuurreview met goedkeuring en aanbevelingen | + +### 12.3 Architectuur & Design + +| Document | Pad | Beschrijving | +|----------|-----|-------------| +| Architectuur Cortex V2 | `docs/intent/design/architecture-cortex-v2.md` | Uitgebreid architectuurplan: drie-laag model, datamodels, APIs, frontend componenten | +| Intent Schaalbaarheid | `docs/intent/design/architecture-intent-scalability.md` | Schaalbaarheidsstrategieën van 7 naar 35+ intents met performance-optimalisatie | +| Architectuurvoorstel | `docs/intent/intent-architecture-v2-proposal.md` | Consensus PO/UX/Dev voor hybrid leader/follower architectuur | +| Analyse Intents & Nudges | `docs/intent/design/analyse-intents-nudges.md` | Analyse van geïmplementeerde intents met aanbevelingen voor 7 nieuwe nudges en 4 query intents | +| GGZ Zinnen Dataset | `docs/intent/design/dataset-ggz-zinnen.md` | Dataset van GGZ-specifieke zinnen voor training en testing van classificatiesysteem | +| Mini-EPD Architectuur | `docs/swift/architectuur.md` | Overkoepelende architectuur met kernwaarden (70% <20ms, GDPR-compliance) | +| Architectuuroverzicht | `docs/architectuur/architectuur-overzicht.md` | Mini-EPD als AI-gestuurd EPD voor GGZ met spraakinterface | + +### 12.4 Intent Implementatie + +| Document | Pad | Beschrijving | +|----------|-----|-------------| +| Intent Overzicht | `docs/architectuur/intent-overzicht.md` | Wat intents zijn en hoe gebruikersinvoer wordt geclassificeerd naar acties | +| Implementatieplan Nieuwe Intents | `docs/architectuur/implementatieplan-nieuwe-intents.md` | Stappenplan: 8 aanraakpunten per intent met tijdsindicatie per type | + +### 12.5 UX Research + +| Document | Pad | Beschrijving | +|----------|-----|-------------| +| UX Evaluatie Schaalbaarheid | `docs/intent/ux-evaluation-intent-scalability.md` | Dialoog PO/UX/klant over problemen van strikte hiërarchie | +| UX Simulatie Next Level | `docs/intent/ux-simulation-intent-next-level.md` | Brainstormsessie: Command-Response → Proactive Assistant met input van zorgprofessionals | +| UX Analyse Patiëntselectie | `docs/intent/patient-search/ux-analyse-patient-selectie.md` | Probleemdefinitie en oplossingen voor inline patiëntselectie-ervaring | +| Bouwplan Patiëntselectie | `docs/intent/patient-search/bouwplan-patient-selectie-v1.md` | @mentions en persistent patient sidebar (19/19 user stories compleet) | + +### 12.6 Intake-proces + +| Document | Pad | Beschrijving | +|----------|-----|-------------| +| Intake Process Intents | `docs/intent/intake-intent-proces/intake-process-intents.md` | Intake-proces met bijbehorende Cortex intents en UI-componenten | +| Gap Analyse Intake-Cortex | `docs/intent/intake-intent-proces/gap-analyse-intake-cortex.md` | Backend 90% compleet; 26 intake intents en API routes ontbreken volledig | +| Block Template Pattern | `docs/intent/intake-intent-proces/block-template-pattern.md` | Herbruikbaar patroon voor Cortex blocks met loading/success/error states | +| Shared Components FO/TO | `docs/intent/intake-intent-proces/fo-to-cortex-shared-components.md` | Herbruikbare shared components en hooks voor alle Cortex Intake Blocks | +| Bouwplan Shared Components | `docs/intent/intake-intent-proces/bouwplan-cortex-shared-components.md` | Foundation components die door alle 26 intake-intents worden hergebruikt | +| Intake Blocks MVP FO/TO | `docs/intent/intake-intent-proces/fo-to-bouwplan-intake-blocks-mvp.md` | FO/TO/Bouwplan voor 4 meest waardevolle intake blocks | +| Testplan Intake Blocks | `docs/intent/intake-intent-proces/testplan-intake-blocks-mvp.md` | Testplan voor intake_status, risico_query, diagnose_query en intake_navigeer | + +### 12.7 Leeswijzer + +Voor een architect die het systeem voor het eerst benadert, is de aanbevolen leesvolgorde: + +``` +1. Dit rapport (cortex-architectuur-analyse.md) + └─ Geeft het volledige beeld: concept, architectuur, analyse, doelarchitectuur + +2. PRD + Functioneel Ontwerp + └─ prd-cortex-v2.md → fo-cortex-intent-system-v2.md + └─ Geeft de product-context en gebruikersverwachtingen + +3. Technisch Ontwerp + Architectuur Design + └─ to-cortex-v2.md → design/architecture-cortex-v2.md + └─ Geeft de technische verdieping per laag + +4. Implementatieplan Nieuwe Intents + └─ architectuur/implementatieplan-nieuwe-intents.md + └─ Geeft het hands-on beeld van hoe een intent gebouwd wordt + +5. Schaalbaarheid + Analyse + └─ design/architecture-intent-scalability.md → design/analyse-intents-nudges.md + └─ Geeft de toekomstvisie voor groei van 11 naar 50+ intents +``` diff --git a/docs/visuele-styleguide.md b/docs/visuele-styleguide.md new file mode 100644 index 0000000..ded1ad6 --- /dev/null +++ b/docs/visuele-styleguide.md @@ -0,0 +1,89 @@ +# Visuele Style Guide & UX Identity + +Dit document beschrijft de visuele identiteit en de gebruikerservaring (UX) van het Mini-EPD. De focus ligt op de 'look & feel' en de ontwerpkeuzes, zonder technische code. + +--- + +## 1. De Visuele Persoonlijkheid + +Het ontwerp van het EPD is gestoeld op drie kernwaarden: +1. **Betrouwbaarheid**: Een rustig, professioneel fundament (Slate & Teal). +2. **Menselijkheid**: Gebruik van klassieke typografie (Serif) voor verslagen. +3. **Innovatie**: Een warme, magische uitstraling voor AI-functies (Amber & Goud). + +--- + +## 2. Kleurgebruik & Betekenis + +Het kleurenpalet is functioneel ingezet om de gebruiker te gidsen door de complexe medische data. + +### 2.1 De Basis (Rust & Ruimte) +De interface ademt rust door het gebruik van een zeer lichte, bijna witte achtergrond (**Lichtgrijs/Slate**). Dit zorgt ervoor dat de content (patiëntdata) de meeste aandacht krijgt. Borders zijn subtiel en zacht, waardoor er geen harde lijnen in het zicht staan. + +### 2.2 Actie & Focus (Teal / Groenblauw) +**Teal** is de primaire accentkleur. Het wordt gebruikt voor alles wat "standaard" en "veilig" is: +* Navigatie en menu's. +* Primaire knoppen voor dagelijkse handelingen. +* Focus-ringen (om aan te geven waar de gebruiker is). +* Bevestigingen en succesmeldingen. +* *Gevoel: Professioneel, medisch, kalm.* + +### 2.3 AI & Intelligentie (Amber / Goud) +**Amber** is gereserveerd voor alle functies waarbij de computer met de gebruiker meedenkt (AI): +* Knoppen die samenvattingen genereren. +* Highlights bij automatisch herkende tekst. +* AI-assistent iconen (gecombineerd met een sterretje/sparkle ✨). +* *Gevoel: Magisch, waardevol, onderscheidend.* + +### 2.4 Module Kleuren +Om snel te kunnen schakelen tussen dossiers, hebben specifieke onderdelen hun eigen kleuraccent: +* **Afspraken**: Groen (Fris, vooruitgang). +* **Medicatie**: Geel/Amber (Waarschuwing, actie). +* **Labuitslagen**: Oranje (Energie, resultaat). + +--- + +## 3. Typografie (De Stem van de App) + +De app gebruikt drie verschillende lettertypes om context te geven aan de tekst. + +* **De Stem van de Arts (Serif)**: Voor medische verslagen en verhalen wordt een klassiek lettertype met schreef gebruikt. Dit leest prettiger bij lange teksten en geeft een gevoel van autoriteit en menselijkheid, zoals in een gedrukt medisch dossier. +* **De Stem van de App (Sans-Serif)**: Voor alle menu's, knoppen en navigatie wordt een modern, strak lettertype zonder schreef gebruikt. Dit zorgt voor optimale leesbaarheid en een efficiënte uitstraling. +* **De Stem van de Data (Monospace)**: Voor getallen, uitslagen en technische details worden letters gebruikt die allemaal even breed zijn (zoals bij een typemachine). Dit zorgt ervoor dat kolommen met cijfers altijd strak onder elkaar staan. + +--- + +## 4. Knoppen & Interactie + +### 4.1 Standaard Knoppen +Standaard knoppen hebben zachte, afgeronde hoeken en een rustige uitstraling. +* **Primaire actie**: Een volle Teal kleur. +* **Secundaire actie**: Een witte achtergrond met een dunne rand. +* **Subtiele actie**: Geen achtergrond, alleen tekst die oplicht bij aanraking. + +### 4.2 De 'Magische' AI-Knop +De knoppen voor AI-functies vallen direct op. Ze gebruiken geen egale kleur, maar een verloop (**gradient**) van goud naar donker-amber. Dit geeft de suggestie van diepte en "energie". Vaak vergezeld door een klein sparkle-icoontje. + +--- + +## 5. Layout & UX Patronen + +### 5.1 De 'Geleende' Sidebar +De navigatie bevindt zich aan de linkerkant. +* **Open**: Toont iconen en tekst voor volledige duidelijkheid. +* **Ingeklapt**: Toont alleen iconen om werkruimte te maximaliseren. Voor de duidelijkheid verschijnen er 'zwevende' labels (tooltips) als je over de iconen beweegt. +* **Contrast**: De sidebar is vaak iets donkerder of heeft een duidelijke verticale lijn om de scheiding tussen "besturing" en "inhoud" aan te geven. + +### 5.2 Kaarten (Cards) +Informatie wordt gepresenteerd op witte "kaarten" die licht boven de achtergrond lijken te zweven door een zachte schaduw. Dit voorkomt dat de interface rommelig wordt en maakt duidelijk welke informatie bij elkaar hoort. + +### 5.3 Feedback & Animaties +De interface voelt "levend" aan: +* Elementen glijden soepel in beeld (slide-in). +* Belangrijke meldingen zweven lichtjes (floating effect) om subtiel de aandacht te trekken zonder te storen. +* Knoppen reageren direct door een kleine kleurverandering als je eroverheen beweegt. + +--- + +## 6. Samenvatting van de Vibe +De app ziet eruit als een modern, high-end dashboard. Het combineert de zakelijkheid van een bank-app (veiligheid) met de slimheid van een moderne AI-tool (amber accenten) en de warmte van een magazine (serif typografie).