feat: Phase 3c — dose logging + adherence, profile management, tests

Three workstreams, all backend+frontend (per scope decisions):

Dose logging + real adherence (backend + frontend):
* log_dose now returns the created dose (201 + body) instead of an empty 201.
* get_adherence implemented for real: queries the medication_doses collection
  over the last 30 days, counts taken vs total, computes the rate. The previous
  implementation hardcoded zeros. Removed the dead calculate_adherence stub.
* Frontend: fixed DoseLog type to match backend MedicationDose (taken:bool,
  loggedAt, camelCase); added AdherenceStats + LogDoseRequest types; logDose() +
  getAdherence() in api.ts; loadAdherence/logDose actions in the medication
  store (adherence cache keyed by med id); new DoseLogger component (Taken/
  Skipped buttons + LinearProgress adherence bar) embedded in each
  MedicationManager card.

Profile management (backend + frontend):
* New GET/PUT /api/profiles/me endpoints (ProfileResponse excludes encryption
  fields; find_by_user_id + update_name on ProfileRepository).
* Register auto-creates a default 'patient' profile (deterministic profile_id =
  profile_<user_id>) — this is the contract the frontend relies on.
* Frontend: Profile type; getProfile()/updateProfileName() in api.ts; useProfileStore;
  new ProfileEditor component (view/edit name, shows role) as a 4th Dashboard tab.
* Resolved the MedicationManager profile_id TODO: now derives profile_<user_id>
  instead of the 'default' fallback.
* NOTE: profile name is stored plaintext (the model anticipates encryption via
  nameIv/nameAuthTag but no crypto layer is implemented yet — TODO).

Vitest tests:
* Added @testing-library/user-event; setupTests clears localStorage + cleanup
  between tests; new test/mockStore.ts helper (mocks the co-located stores,
  handles both selector and no-selector call patterns).
* 5 test files, 20 tests: SeverityChip (4), useMedicationStore actions incl.
  loadMedications/createMedication/logDose (4), MedicationManager render+dialog
  (5), InteractionsChecker selection+results (4), HealthStats table+dialog (3).

Verified: backend cargo fmt/build/clippy 0 warnings, 19 unit tests pass;
frontend npm build clean, 20 vitest tests pass. Solaria round-trip confirmed:
profile auto-created on register (GET /profiles/me), PUT updates name, dose log
returns the dose body, adherence computes 66.7% for 2-taken/1-skipped.

KNOWN FOLLOW-UP (separate task): the backend Medication list response is deeply
nested + camelCase + stores fields inside medicationData.data; the frontend
Medication type assumes flat top-level snake_case fields. This pre-dates Phase 3c
and affects the whole MedicationManager — needs a backend serialization fix or a
frontend adapter.

web/normogen-web/src/components/common/SeverityChip.test.tsx

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { SeverityChip } from './SeverityChip';
+import { InteractionSeverity } from '../../types/api';
+
+describe('SeverityChip', () => {
+  it('renders the severe label', () => {
+    render(<SeverityChip severity={InteractionSeverity.Severe} />);
+    expect(screen.getByText('Severe')).toBeInTheDocument();
+  });
+
+  it('renders moderate', () => {
+    render(<SeverityChip severity={InteractionSeverity.Moderate} />);
+    expect(screen.getByText('Moderate')).toBeInTheDocument();
+  });
+
+  it('renders mild', () => {
+    render(<SeverityChip severity={InteractionSeverity.Mild} />);
+    expect(screen.getByText('Mild')).toBeInTheDocument();
+  });
+
+  it('renders unknown for the unknown severity', () => {
+    render(<SeverityChip severity={InteractionSeverity.Unknown} />);
+    expect(screen.getByText('Unknown')).toBeInTheDocument();
+  });
+});

web/normogen-web/src/components/health/HealthStats.test.tsx

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { mockStoreFactory, setMockStore, resetMockStore } from '../../test/mockStore';
+
+vi.mock('../../store/useStore', () => mockStoreFactory());
+
+const { HealthStats } = await import('./HealthStats');
+
+const healthActions = {
+  loadStats: vi.fn(),
+  createStat: vi.fn(),
+  updateStat: vi.fn(),
+  deleteStat: vi.fn(),
+  loadTrends: vi.fn(),
+  clearError: vi.fn(),
+  isLoading: false,
+  error: null,
+  stats: [],
+  trends: [],
+};
+
+describe('HealthStats', () => {
+  beforeEach(() => resetMockStore());
+
+  it('shows the empty state when there are no readings', () => {
+    setMockStore({ useHealthStore: { ...healthActions } });
+    render(<HealthStats />);
+    expect(screen.getByText(/No health readings yet/i)).toBeInTheDocument();
+  });
+
+  it('renders the readings table when stats exist', () => {
+    setMockStore({
+      useHealthStore: {
+        ...healthActions,
+        stats: [
+          {
+            stat_id: 's1',
+            stat_type: 'weight',
+            value: 78.5,
+            unit: 'kg',
+            measured_at: '2026-06-01T10:00:00.000Z',
+          },
+        ],
+      },
+    });
+    render(<HealthStats />);
+    // "weight" appears in both the chart selector and the table; the value
+    // string is unique to the table cell.
+    expect(screen.getByText('78.5 kg')).toBeInTheDocument();
+    expect(screen.getByText('Jun 1, 07:00')).toBeInTheDocument();
+  });
+
+  it('opens the record dialog when Record is clicked', () => {
+    setMockStore({ useHealthStore: { ...healthActions } });
+    render(<HealthStats />);
+    fireEvent.click(screen.getByText('Record'));
+    expect(screen.getByText('Record a measurement')).toBeInTheDocument();
+  });
+});

web/normogen-web/src/components/interactions/InteractionsChecker.test.tsx

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { mockStoreFactory, setMockStore, resetMockStore } from '../../test/mockStore';
+
+vi.mock('../../store/useStore', () => mockStoreFactory());
+
+const { InteractionsChecker } = await import('./InteractionsChecker');
+
+const interactionActions = {
+  checkInteractions: vi.fn(),
+  checkNewMedication: vi.fn(),
+  clearInteractions: vi.fn(),
+  clearError: vi.fn(),
+  isChecking: false,
+  error: null,
+  interactions: [],
+};
+
+const medActions = {
+  loadMedications: vi.fn(),
+  createMedication: vi.fn(),
+  updateMedication: vi.fn(),
+  deleteMedication: vi.fn(),
+  selectMedication: vi.fn(),
+  clearError: vi.fn(),
+  loadAdherence: vi.fn(),
+  logDose: vi.fn(),
+  isLoading: false,
+  error: null,
+  adherence: {},
+  selectedMedication: null,
+};
+
+describe('InteractionsChecker', () => {
+  beforeEach(() => resetMockStore());
+
+  it('prompts to add medications when none exist', () => {
+    setMockStore({
+      useMedicationStore: { ...medActions, medications: [] },
+      useInteractionStore: { ...interactionActions },
+    });
+    render(<InteractionsChecker />);
+    expect(screen.getByText(/Add medications first/i)).toBeInTheDocument();
+  });
+
+  it('renders a chip per medication', () => {
+    setMockStore({
+      useMedicationStore: {
+        ...medActions,
+        medications: [
+          { medication_id: 'm1', name: 'Warfarin' },
+          { medication_id: 'm2', name: 'Aspirin' },
+        ],
+      },
+      useInteractionStore: { ...interactionActions },
+    });
+    render(<InteractionsChecker />);
+    expect(screen.getByText('Warfarin')).toBeInTheDocument();
+    expect(screen.getByText('Aspirin')).toBeInTheDocument();
+  });
+
+  it('disables the check button until two medications are selected', () => {
+    setMockStore({
+      useMedicationStore: {
+        ...medActions,
+        medications: [
+          { medication_id: 'm1', name: 'Warfarin' },
+          { medication_id: 'm2', name: 'Aspirin' },
+        ],
+      },
+      useInteractionStore: { ...interactionActions },
+    });
+    render(<InteractionsChecker />);
+    const button = screen.getByText('Check interactions');
+    expect(button).toBeDisabled();
+
+    fireEvent.click(screen.getByText('Warfarin'));
+    expect(button).toBeDisabled();
+
+    fireEvent.click(screen.getByText('Aspirin'));
+    expect(button).not.toBeDisabled();
+  });
+
+  it('renders interaction results when present', () => {
+    setMockStore({
+      useMedicationStore: {
+        ...medActions,
+        medications: [
+          { medication_id: 'm1', name: 'Warfarin' },
+          { medication_id: 'm2', name: 'Aspirin' },
+        ],
+      },
+      useInteractionStore: {
+        ...interactionActions,
+        interactions: [
+          {
+            medications: ['warfarin', 'aspirin'],
+            severity: 'severe',
+            description: 'Increased bleeding risk.',
+            disclaimer: 'For informational purposes only.',
+          },
+        ],
+      },
+    });
+    render(<InteractionsChecker />);
+    // Pre-select two meds so the results section renders.
+    fireEvent.click(screen.getByText('Warfarin'));
+    fireEvent.click(screen.getByText('Aspirin'));
+
+    expect(screen.getByText('Increased bleeding risk.')).toBeInTheDocument();
+    expect(screen.getByText('Severe')).toBeInTheDocument();
+  });
+});

web/normogen-web/src/components/medication/DoseLogger.tsx

@@ -0,0 +1,84 @@
+import { useEffect, useState, type FC } from 'react';
+import { Box, Button, LinearProgress, Stack, Typography } from '@mui/material';
+import CheckIcon from '@mui/icons-material/Check';
+import CloseIcon from '@mui/icons-material/Close';
+import { useMedicationStore } from '../../store/useStore';
+
+interface Props {
+  medicationId: string;
+}
+
+/**
+ * Per-medication dose logging + adherence display. Renders inside each
+ * MedicationManager card. Loads adherence on mount and refreshes after a dose
+ * is logged.
+ */
+export const DoseLogger: FC<Props> = ({ medicationId }) => {
+  const { adherence, loadAdherence, logDose } = useMedicationStore();
+  const [busy, setBusy] = useState(false);
+
+  useEffect(() => {
+    loadAdherence(medicationId);
+  }, [medicationId, loadAdherence]);
+
+  const stats = adherence[medicationId];
+  const rate = stats ? Math.round(stats.adherence_rate) : 0;
+
+  const handleLog = async (taken: boolean) => {
+    setBusy(true);
+    try {
+      await logDose(medicationId, taken);
+    } catch {
+      /* store surfaces error in the MedicationManager banner */
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <Box sx={{ mt: 1.5 }}>
+      <Stack direction="row" spacing={1} sx={{ mb: 1 }}>
+        <Button
+          size="small"
+          variant="outlined"
+          color="success"
+          startIcon={<CheckIcon />}
+          disabled={busy}
+          onClick={() => handleLog(true)}
+        >
+          Taken
+        </Button>
+        <Button
+          size="small"
+          variant="outlined"
+          color="inherit"
+          startIcon={<CloseIcon />}
+          disabled={busy}
+          onClick={() => handleLog(false)}
+        >
+          Skipped
+        </Button>
+      </Stack>
+
+      {stats && (
+        <Box>
+          <Stack direction="row" justifyContent="space-between" sx={{ mb: 0.5 }}>
+            <Typography variant="caption" color="text.secondary">
+              Adherence (last {stats.period_days}d)
+            </Typography>
+            <Typography variant="caption" fontWeight={600}>
+              {rate}% · {stats.taken_doses}/{stats.total_doses} taken
+            </Typography>
+          </Stack>
+          <LinearProgress
+            variant="determinate"
+            value={rate}
+            color={rate >= 80 ? 'success' : rate >= 50 ? 'warning' : 'error'}
+          />
+        </Box>
+      )}
+    </Box>
+  );
+};
+
+export default DoseLogger;

web/normogen-web/src/components/medication/MedicationManager.test.tsx

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { mockStoreFactory, setMockStore, resetMockStore } from '../../test/mockStore';
+
+vi.mock('../../store/useStore', () => mockStoreFactory());
+
+// Import AFTER the mock is registered so the component picks up the mock.
+const { MedicationManager } = await import('./MedicationManager');
+const { useAuthStore } = await import('../../store/useStore');
+
+const med = (overrides: Partial<Record<string, unknown>> = {}) => ({
+  medication_id: 'm1',
+  name: 'Ibuprofen',
+  dosage: '200mg',
+  frequency: 'daily',
+  active: true,
+  instructions: undefined,
+  ...overrides,
+});
+
+const baseActions = {
+  loadMedications: vi.fn(),
+  createMedication: vi.fn(),
+  updateMedication: vi.fn(),
+  deleteMedication: vi.fn(),
+  selectMedication: vi.fn(),
+  clearError: vi.fn(),
+  loadAdherence: vi.fn(),
+  logDose: vi.fn(),
+  isLoading: false,
+  error: null,
+  adherence: {},
+  selectedMedication: null,
+};
+
+describe('MedicationManager', () => {
+  beforeEach(() => {
+    resetMockStore();
+    setMockStore({
+      useAuthStore: { user: { user_id: 'u1', username: 'tester' }, profile: {} },
+    });
+    baseActions.loadMedications.mockClear();
+  });
+
+  it('renders the medications from the store', () => {
+    setMockStore({
+      useMedicationStore: {
+        ...baseActions,
+        medications: [med({ name: 'Aspirin' }), med({ medication_id: 'm2', name: 'Warfarin' })],
+      },
+    });
+    render(<MedicationManager />);
+    expect(screen.getByText('Aspirin')).toBeInTheDocument();
+    expect(screen.getByText('Warfarin')).toBeInTheDocument();
+  });
+
+  it('shows the empty state when there are no medications', () => {
+    setMockStore({ useMedicationStore: { ...baseActions, medications: [] } });
+    render(<MedicationManager />);
+    expect(screen.getByText(/No medications yet/i)).toBeInTheDocument();
+  });
+
+  it('loads medications on mount', () => {
+    setMockStore({ useMedicationStore: { ...baseActions, medications: [] } });
+    render(<MedicationManager />);
+    expect(baseActions.loadMedications).toHaveBeenCalled();
+  });
+
+  it('opens the create dialog when Add is clicked', () => {
+    setMockStore({ useMedicationStore: { ...baseActions, medications: [] } });
+    render(<MedicationManager />);
+    fireEvent.click(screen.getByText('Add'));
+    expect(screen.getByText('Add medication')).toBeInTheDocument();
+  });
+
+  it('renders an error banner when the store has an error', () => {
+    setMockStore({
+      useMedicationStore: { ...baseActions, medications: [], error: 'Something broke' },
+    });
+    render(<MedicationManager />);
+    expect(screen.getByText('Something broke')).toBeInTheDocument();
+  });
+});

web/normogen-web/src/components/medication/MedicationManager.tsx

@@ -30,6 +30,7 @@ import type {
   CreateMedicationRequest,
   UpdateMedicationRequest,
 } from '../../types/api';
+import { DoseLogger } from './DoseLogger';
 
 const ROUTES = ['oral', 'topical', 'injection', 'inhalation', 'other'] as const;
 
@@ -66,11 +67,12 @@ export const MedicationManager: FC = () => {
   }, [loadMedications]);
 
   const openCreate = () => {
-    // TODO: real profile management — for now, source profile_id from the user,
-    // falling back to 'default' (the backend accepts any string).
+    // profile_id is deterministic: profile_<user_id>. The backend auto-creates
+    // this profile on register, so the id always resolves to a real profile.
+    const profileId = user?.profile_id ?? `profile_${user?.user_id ?? 'default'}`;
     setCreateForm({
       ...emptyCreate,
-      profile_id: user?.profile_id ?? 'default',
+      profile_id: profileId,
     });
     setCreateOpen(true);
   };
@@ -178,6 +180,7 @@ export const MedicationManager: FC = () => {
                           {med.instructions}
                         </Typography>
                       )}
+                      {med.medication_id && <DoseLogger medicationId={med.medication_id} />}
                     </Box>
                   </Stack>
                 </CardContent>

web/normogen-web/src/components/profile/ProfileEditor.tsx

@@ -0,0 +1,128 @@
+import { useEffect, useState, type FC } from 'react';
+import {
+  Box,
+  Button,
+  Card,
+  CardContent,
+  CircularProgress,
+  Alert,
+  Chip,
+  Stack,
+  TextField,
+  Typography,
+} from '@mui/material';
+import SaveIcon from '@mui/icons-material/Save';
+import { useProfileStore, useAuthStore } from '../../store/useStore';
+
+export const ProfileEditor: FC = () => {
+  const { profile, isLoading, error, loadProfile, updateName, clearError } =
+    useProfileStore();
+  const user = useAuthStore((s) => s.user);
+
+  const [name, setName] = useState('');
+  const [editing, setEditing] = useState(false);
+  const [saving, setSaving] = useState(false);
+
+  useEffect(() => {
+    loadProfile();
+  }, [loadProfile]);
+
+  useEffect(() => {
+    if (profile?.name) setName(profile.name);
+  }, [profile]);
+
+  const handleSave = async () => {
+    setSaving(true);
+    try {
+      await updateName(name);
+      setEditing(false);
+    } catch {
+      /* error surfaced via store */
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  return (
+    <Box>
+      <Typography variant="h6" sx={{ mb: 2 }}>
+        Profile
+      </Typography>
+
+      {error && (
+        <Alert severity="error" sx={{ mb: 2 }} onClose={clearError}>
+          {error}
+        </Alert>
+      )}
+
+      {isLoading && !profile ? (
+        <Box display="flex" justifyContent="center" py={4}>
+          <CircularProgress />
+        </Box>
+      ) : (
+        <Card>
+          <CardContent>
+            <Stack spacing={2}>
+              <Box>
+                <Typography variant="caption" color="text.secondary">
+                  Display name
+                </Typography>
+                {editing ? (
+                  <Stack direction="row" spacing={1} sx={{ mt: 0.5 }}>
+                    <TextField
+                      size="small"
+                      fullWidth
+                      value={name}
+                      onChange={(e) => setName(e.target.value)}
+                      autoFocus
+                    />
+                    <Button
+                      variant="contained"
+                      startIcon={<SaveIcon />}
+                      onClick={handleSave}
+                      disabled={saving || !name.trim()}
+                    >
+                      {saving ? <CircularProgress size={24} /> : 'Save'}
+                    </Button>
+                    <Button onClick={() => { setEditing(false); setName(profile?.name ?? ''); }}>
+                      Cancel
+                    </Button>
+                  </Stack>
+                ) : (
+                  <Stack direction="row" alignItems="center" spacing={1}>
+                    <Typography variant="h6">{profile?.name ?? user?.username ?? '—'}</Typography>
+                    <Button size="small" onClick={() => setEditing(true)}>Edit</Button>
+                  </Stack>
+                )}
+              </Box>
+
+              <Box>
+                <Typography variant="caption" color="text.secondary">
+                  Account
+                </Typography>
+                <Typography variant="body2">{user?.email}</Typography>
+              </Box>
+
+              <Box>
+                <Typography variant="caption" color="text.secondary">
+                  Role
+                </Typography>
+                <Box sx={{ mt: 0.5 }}>
+                  <Chip size="small" label={profile?.role ?? 'patient'} variant="outlined" />
+                </Box>
+              </Box>
+
+              {profile?.profile_id && (
+                <Typography variant="caption" color="text.secondary">
+                  Profile ID: {profile.profile_id}
+                </Typography>
+              )}
+            </Stack>
+          </CardContent>
+        </Card>
+      )}
+    </Box>
+  );
+};
+
+export default ProfileEditor;