feat(cortex): add Intake Blocks MVP for voice/text commands

Adds 4 new intents for intake workflow:
- intake_status: shows completion percentage and section checklist
- intake_navigeer: navigation to specific intake tabs
- risico_query: displays risk assessments with severity indicators
- diagnose_query: shows primary/secondary diagnoses

New components:
- IntakeStatusBlock, RisicoBlock, DiagnoseBlock
- Shared block components (BlockLoading, BlockError, BlockEmpty, BlockSection, BlockItem, BlockFooter)
- useBlockData and useIntakeContext hooks

New API routes:
- GET /api/cortex/intake/status
- GET /api/cortex/intake/risico
- GET /api/cortex/intake/diagnose

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app/api/cortex/intake/risico/route.ts

@@ -0,0 +1,201 @@
+/**
+ * Intake Risk Assessment API
+ *
+ * GET /api/cortex/intake/risico?patientId=xxx&intakeId=xxx
+ *
+ * Returns risk assessments for an intake.
+ * Used by RisicoBlock in Cortex Command Center.
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { createClient } from '@/lib/auth/server';
+import { z } from 'zod';
+
+// Query parameter schema
+const QuerySchema = z.object({
+  patientId: z.string().uuid({ message: 'patientId moet een geldige UUID zijn' }),
+  intakeId: z.string().uuid({ message: 'intakeId moet een geldige UUID zijn' }).optional(),
+});
+
+// Risk level type
+type RiskLevel = 'laag' | 'matig' | 'hoog' | 'acuut';
+
+export interface RiskAssessmentItem {
+  id: string;
+  type: string;
+  level: RiskLevel;
+  rationale: string;
+  measures: string | null;
+  assessmentDate: string;
+  evaluationDate: string | null;
+  notes: string | null;
+}
+
+export interface IntakeRisicoResponse {
+  intakeId: string;
+  patientId: string;
+  risks: RiskAssessmentItem[];
+  summary: {
+    total: number;
+    highestLevel: RiskLevel | null;
+    hasSuicideRisk: boolean;
+    hasSelfHarmRisk: boolean;
+    hasAggressionRisk: boolean;
+  };
+  lastUpdated: string | null;
+}
+
+// Map risk type to category for summary
+function categorizeRiskType(type: string): 'suicide' | 'selfharm' | 'aggression' | 'other' {
+  const lowerType = type.toLowerCase();
+  if (lowerType.includes('suïcid') || lowerType.includes('suicide') || lowerType.includes('suicid')) {
+    return 'suicide';
+  }
+  if (lowerType.includes('zelfbeschadig') || lowerType.includes('automutil')) {
+    return 'selfharm';
+  }
+  if (lowerType.includes('agressie') || lowerType.includes('geweld')) {
+    return 'aggression';
+  }
+  return 'other';
+}
+
+// Determine highest risk level
+function getHighestLevel(levels: RiskLevel[]): RiskLevel | null {
+  if (levels.length === 0) return null;
+  const priority: Record<RiskLevel, number> = {
+    laag: 1,
+    matig: 2,
+    hoog: 3,
+    acuut: 4,
+  };
+  return levels.reduce((highest, level) => {
+    return priority[level] > priority[highest] ? level : highest;
+  });
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    // Auth check
+    const supabase = await createClient();
+    const {
+      data: { user },
+      error: authError,
+    } = await supabase.auth.getUser();
+
+    if (authError || !user) {
+      return NextResponse.json(
+        { error: 'Niet geautoriseerd. Log opnieuw in.' },
+        { status: 401 }
+      );
+    }
+
+    // Parse and validate query parameters
+    const searchParams = request.nextUrl.searchParams;
+    const patientId = searchParams.get('patientId');
+    const intakeId = searchParams.get('intakeId');
+
+    if (!patientId) {
+      return NextResponse.json(
+        { error: 'Query parameter "patientId" is verplicht' },
+        { status: 400 }
+      );
+    }
+
+    const validation = QuerySchema.safeParse({ patientId, intakeId });
+    if (!validation.success) {
+      const errorMessage = validation.error.issues
+        .map((e) => e.message)
+        .join(', ');
+      return NextResponse.json({ error: errorMessage }, { status: 400 });
+    }
+
+    // If no intakeId provided, get the most recent active intake for this patient
+    let targetIntakeId = validation.data.intakeId;
+
+    if (!targetIntakeId) {
+      const { data: latestIntake, error: intakeError } = await supabase
+        .from('intakes')
+        .select('id')
+        .eq('patient_id', patientId)
+        .eq('status', 'bezig')
+        .order('start_date', { ascending: false })
+        .limit(1)
+        .maybeSingle();
+
+      if (intakeError) {
+        console.error('Error fetching latest intake:', intakeError);
+        return NextResponse.json(
+          { error: 'Fout bij ophalen intake' },
+          { status: 500 }
+        );
+      }
+
+      if (!latestIntake) {
+        return NextResponse.json(
+          { error: 'Geen actieve intake gevonden voor deze patiënt' },
+          { status: 404 }
+        );
+      }
+
+      targetIntakeId = latestIntake.id;
+    }
+
+    // Fetch risk assessments
+    const { data: riskData, error: riskError } = await supabase
+      .from('risk_assessments')
+      .select('*')
+      .eq('intake_id', targetIntakeId)
+      .order('assessment_date', { ascending: false });
+
+    if (riskError) {
+      console.error('Error fetching risk assessments:', riskError);
+      return NextResponse.json(
+        { error: 'Fout bij ophalen risicotaxaties' },
+        { status: 500 }
+      );
+    }
+
+    const risks: RiskAssessmentItem[] = (riskData || []).map((risk) => ({
+      id: risk.id,
+      type: risk.risk_type,
+      level: risk.risk_level as RiskLevel,
+      rationale: risk.rationale,
+      measures: risk.measures,
+      assessmentDate: risk.assessment_date,
+      evaluationDate: risk.evaluation_date,
+      notes: risk.notes,
+    }));
+
+    // Build summary
+    const riskCategories = risks.map((r) => categorizeRiskType(r.type));
+    const riskLevels = risks.map((r) => r.level);
+
+    const summary = {
+      total: risks.length,
+      highestLevel: getHighestLevel(riskLevels),
+      hasSuicideRisk: riskCategories.includes('suicide'),
+      hasSelfHarmRisk: riskCategories.includes('selfharm'),
+      hasAggressionRisk: riskCategories.includes('aggression'),
+    };
+
+    // Get last updated timestamp
+    const lastUpdated = risks.length > 0 ? risks[0].assessmentDate : null;
+
+    const response: IntakeRisicoResponse = {
+      intakeId: targetIntakeId,
+      patientId,
+      risks,
+      summary,
+      lastUpdated,
+    };
+
+    return NextResponse.json(response, { status: 200 });
+  } catch (error) {
+    console.error('Error in intake risk API:', error);
+    return NextResponse.json(
+      { error: 'Er ging iets mis bij het ophalen van de risicotaxaties.' },
+      { status: 500 }
+    );
+  }
+}