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;

web/normogen-web/src/pages/Dashboard.tsx

@@ -5,8 +5,9 @@ import { useAuthStore } from '../store/useStore';
 import { MedicationManager } from '../components/medication/MedicationManager';
 import { HealthStats } from '../components/health/HealthStats';
 import { InteractionsChecker } from '../components/interactions/InteractionsChecker';
+import { ProfileEditor } from '../components/profile/ProfileEditor';
 
-type TabIndex = 0 | 1 | 2;
+type TabIndex = 0 | 1 | 2 | 3;
 
 export const Dashboard: FC = () => {
   const navigate = useNavigate();
@@ -14,7 +15,7 @@ export const Dashboard: FC = () => {
   const [tab, setTab] = useState<TabIndex>(0);
 
   // On mount, refresh the user record from the backend (confirms the token is
-  // still valid, and medication-create needs user.profile_id).
+  // still valid, and medication-create derives profile_id from user_id).
   useEffect(() => {
     if (isAuthenticated && !user) {
       loadUser();
@@ -49,12 +50,14 @@ export const Dashboard: FC = () => {
           <Tab label="Medications" />
           <Tab label="Health" />
           <Tab label="Interactions" />
+          <Tab label="Profile" />
         </Tabs>
 
         <Box>
           {tab === 0 && <MedicationManager />}
           {tab === 1 && <HealthStats />}
           {tab === 2 && <InteractionsChecker />}
+          {tab === 3 && <ProfileEditor />}
         </Box>
       </Container>
     </>

web/normogen-web/src/services/api.ts

@@ -14,6 +14,10 @@ import {
   CreateHealthStatRequest,
   TrendData,
   ApiError,
+  DoseLog,
+  LogDoseRequest,
+  AdherenceStats,
+  Profile,
 } from '../types/api';
 
 // API base URL. In dev this is "/api", proxied by the Vite dev server to the
@@ -206,6 +210,18 @@ class ApiService {
     return response.data;
   }
 
+  // ---- Profile (Phase 3c) ----
+
+  async getProfile(): Promise<Profile> {
+    const response = await this.client.get<Profile>('/profiles/me');
+    return response.data;
+  }
+
+  async updateProfileName(name: string): Promise<Profile> {
+    const response = await this.client.put<Profile>('/profiles/me', { name });
+    return response.data;
+  }
+
   // ---- Medications ----
 
   async getMedications(): Promise<Medication[]> {
@@ -234,6 +250,18 @@ class ApiService {
     await this.client.post(`/medications/${id}/delete`);
   }
 
+  // ---- Dose logging + adherence (Phase 3c) ----
+
+  async logDose(medicationId: string, req: LogDoseRequest): Promise<DoseLog> {
+    const response = await this.client.post<DoseLog>(`/medications/${medicationId}/log`, req);
+    return response.data;
+  }
+
+  async getAdherence(medicationId: string): Promise<AdherenceStats> {
+    const response = await this.client.get<AdherenceStats>(`/medications/${medicationId}/adherence`);
+    return response.data;
+  }
+
   // ---- Drug Interactions (Phase 2.8) ----
 
   async checkInteractions(medications: string[]): Promise<DrugInteraction[]> {

web/normogen-web/src/setupTests.ts

@@ -1,5 +1,16 @@
-// jest-dom adds custom jest matchers for asserting on DOM nodes.
-// allows you to do things like:
-// expect(element).toHaveTextContent(/react/i)
-// learn more: https://github.com/testing-library/jest-dom
 import '@testing-library/jest-dom';
+import { afterEach, beforeEach } from 'vitest';
+import { cleanup } from '@testing-library/react';
+
+// Unmount anything rendered between tests (RTL auto-runs this in watch mode but
+// we set it explicitly so single-run `vitest run` stays isolated).
+afterEach(() => {
+  cleanup();
+});
+
+// The auth store is persisted under localStorage key 'normogen-auth', and the
+// api client reads 'token'/'refresh_token' from localStorage. Clear between
+// tests so state never bleeds across cases.
+beforeEach(() => {
+  localStorage.clear();
+});

web/normogen-web/src/store/useStore.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Mock the api client so the store's real reducer logic is exercised without HTTP.
+const apiMock = {
+  getMedications: vi.fn(),
+  createMedication: vi.fn(),
+  logDose: vi.fn(),
+  getAdherence: vi.fn(),
+};
+vi.mock('../services/api', () => ({ default: apiMock }));
+
+// Import the store AFTER the mock is registered.
+const { useMedicationStore } = await import('./useStore');
+
+describe('useMedicationStore', () => {
+  beforeEach(() => {
+    useMedicationStore.setState({
+      medications: [],
+      isLoading: false,
+      error: null,
+      adherence: {},
+    });
+    apiMock.getMedications.mockReset();
+    apiMock.createMedication.mockReset();
+  });
+
+  it('loadMedications populates state from the api client', async () => {
+    const meds = [{ medication_id: 'm1', name: 'Aspirin', dosage: '100mg' }];
+    apiMock.getMedications.mockResolvedValue(meds);
+
+    await useMedicationStore.getState().loadMedications();
+
+    expect(apiMock.getMedications).toHaveBeenCalledOnce();
+    expect(useMedicationStore.getState().medications).toEqual(meds);
+    expect(useMedicationStore.getState().isLoading).toBe(false);
+  });
+
+  it('loadMedications sets an error message on failure (and does not throw)', async () => {
+    apiMock.getMedications.mockRejectedValue(new Error('boom'));
+
+    // Should NOT throw — load actions swallow.
+    await useMedicationStore.getState().loadMedications();
+
+    expect(useMedicationStore.getState().error).toBe('boom');
+    expect(useMedicationStore.getState().isLoading).toBe(false);
+  });
+
+  it('createMedication appends the new medication and re-throws on error', async () => {
+    apiMock.createMedication.mockResolvedValue({ medication_id: 'm2', name: 'New' });
+
+    await useMedicationStore.getState().createMedication({ name: 'New' });
+
+    expect(useMedicationStore.getState().medications).toEqual([
+      { medication_id: 'm2', name: 'New' },
+    ]);
+
+    // Now an error path: createMedication rejects -> store re-throws.
+    apiMock.createMedication.mockRejectedValue(new Error('nope'));
+    await expect(
+      useMedicationStore.getState().createMedication({ name: 'Bad' }),
+    ).rejects.toThrow('nope');
+  });
+
+  it('logDose logs the dose then refreshes adherence', async () => {
+    apiMock.logDose.mockResolvedValue({});
+    apiMock.getAdherence.mockResolvedValue({
+      medication_id: 'm1',
+      total_doses: 1,
+      scheduled_doses: 1,
+      taken_doses: 1,
+      missed_doses: 0,
+      adherence_rate: 100,
+      period_days: 30,
+    });
+
+    await useMedicationStore.getState().logDose('m1', true);
+
+    expect(apiMock.logDose).toHaveBeenCalledWith('m1', { taken: true, notes: undefined });
+    expect(apiMock.getAdherence).toHaveBeenCalledWith('m1');
+    expect(useMedicationStore.getState().adherence['m1'].adherence_rate).toBe(100);
+  });
+});

web/normogen-web/src/store/useStore.ts

@@ -1,6 +1,13 @@
 import { create } from 'zustand';
 import { devtools, persist } from 'zustand/middleware';
-import { User, Medication, HealthStat, DrugInteraction } from '../types/api';
+import {
+  User,
+  Medication,
+  HealthStat,
+  DrugInteraction,
+  AdherenceStats,
+  Profile,
+} from '../types/api';
 import apiService from '../services/api';
 
 interface AuthState {
@@ -23,7 +30,9 @@ interface MedicationState {
   selectedMedication: Medication | null;
   isLoading: boolean;
   error: string | null;
-  
+  // Adherence cache: medicationId -> stats. Loaded on demand per medication.
+  adherence: Record<string, AdherenceStats>;
+
   // Actions
   loadMedications: () => Promise<void>;
   createMedication: (data: any) => Promise<void>;
@@ -31,6 +40,8 @@ interface MedicationState {
   deleteMedication: (id: string) => Promise<void>;
   selectMedication: (medication: Medication | null) => void;
   clearError: () => void;
+  loadAdherence: (medicationId: string) => Promise<void>;
+  logDose: (medicationId: string, taken: boolean, notes?: string) => Promise<void>;
 }
 
 interface HealthState {
@@ -52,7 +63,7 @@ interface InteractionState {
   interactions: DrugInteraction[];
   isChecking: boolean;
   error: string | null;
-  
+
   // Actions
   checkInteractions: (medications: string[]) => Promise<void>;
   checkNewMedication: (name: string, dosage: string) => Promise<void>;
@@ -60,6 +71,15 @@ interface InteractionState {
   clearError: () => void;
 }
 
+interface ProfileState {
+  profile: Profile | null;
+  isLoading: boolean;
+  error: string | null;
+  loadProfile: () => Promise<void>;
+  updateName: (name: string) => Promise<void>;
+  clearError: () => void;
+}
+
 // Auth Store
 export const useAuthStore = create<AuthState>()(
   devtools(
@@ -178,6 +198,7 @@ export const useMedicationStore = create<MedicationState>()(
     selectedMedication: null,
     isLoading: false,
     error: null,
+    adherence: {},
 
     loadMedications: async () => {
       set({ isLoading: true, error: null });
@@ -252,10 +273,34 @@ export const useMedicationStore = create<MedicationState>()(
     },
 
     clearError: () => set({ error: null }),
+
+    loadAdherence: async (medicationId) => {
+      try {
+        const stats = await apiService.getAdherence(medicationId);
+        set((state) => ({
+          adherence: { ...state.adherence, [medicationId]: stats },
+        }));
+      } catch (error: any) {
+        // Adherence is non-critical; surface nothing disruptive.
+        set({ error: error.message || 'Failed to load adherence' });
+      }
+    },
+
+    logDose: async (medicationId, taken, notes) => {
+      try {
+        await apiService.logDose(medicationId, { taken, notes });
+        // Refresh adherence for this med so the % reflects the new dose.
+        const stats = await apiService.getAdherence(medicationId);
+        set((state) => ({
+          adherence: { ...state.adherence, [medicationId]: stats },
+        }));
+      } catch (error: any) {
+        set({ error: error.message || 'Failed to log dose' });
+        throw error;
+      }
+    },
   }))
 );
-
-// Health Store
 export const useHealthStore = create<HealthState>()(
   devtools((set, get) => ({
     stats: [],
@@ -383,3 +428,41 @@ export const useInteractionStore = create<InteractionState>()(
     clearError: () => set({ error: null }),
   }))
 );
+
+// Profile Store (Phase 3c)
+export const useProfileStore = create<ProfileState>()(
+  devtools((set, get) => ({
+    profile: null,
+    isLoading: false,
+    error: null,
+
+    loadProfile: async () => {
+      set({ isLoading: true, error: null });
+      try {
+        const profile = await apiService.getProfile();
+        set({ profile, isLoading: false });
+      } catch (error: any) {
+        set({
+          error: error.message || 'Failed to load profile',
+          isLoading: false,
+        });
+      }
+    },
+
+    updateName: async (name) => {
+      set({ isLoading: true, error: null });
+      try {
+        const profile = await apiService.updateProfileName(name);
+        set({ profile, isLoading: false });
+      } catch (error: any) {
+        set({
+          error: error.message || 'Failed to update profile',
+          isLoading: false,
+        });
+        throw error;
+      }
+    },
+
+    clearError: () => set({ error: null }),
+  })),
+);

web/normogen-web/src/test/mockStore.ts

@@ -0,0 +1,49 @@
+import { vi } from 'vitest';
+
+/**
+ * Test helper for mocking the zustand stores. Because the stores are co-located
+ * in one module (../store/useStore) and consumed both with and without a
+ * selector (`useAuthStore(s => s.user)` vs `useMedicationStore()`), the mock
+ * returns a function that accepts an optional selector.
+ *
+ * Usage in a test file:
+ *
+ *   vi.mock('../store/useStore', () => mockStoreFactory());
+ *   // then per test:
+ *   setMockStore({ useMedicationStore: { medications: [...], ... } });
+ *
+ * Each store's actions default to vi.fn() mocks; override them in setMockStore.
+ */
+export type StoreSlice = Record<string, unknown>;
+
+const state: Record<string, StoreSlice> = {};
+
+function makeHook(name: string) {
+  const fn = vi.fn((selector?: (s: StoreSlice) => unknown) =>
+    selector ? selector(state[name] ?? {}) : state[name] ?? {},
+  );
+  return fn;
+}
+
+export function mockStoreFactory() {
+  return {
+    useAuthStore: makeHook('useAuthStore'),
+    useMedicationStore: makeHook('useMedicationStore'),
+    useHealthStore: makeHook('useHealthStore'),
+    useInteractionStore: makeHook('useInteractionStore'),
+    useProfileStore: makeHook('useProfileStore'),
+  };
+}
+
+/** Set/override the state a store returns for the current test. */
+export function setMockStore(next: Record<string, StoreSlice>) {
+  for (const [name, slice] of Object.entries(next)) {
+    // Merge so callers can update one field without re-declaring actions.
+    state[name] = { ...state[name], ...slice };
+  }
+}
+
+/** Reset all mocked store state between tests. */
+export function resetMockStore() {
+  for (const key of Object.keys(state)) delete state[key];
+}

web/normogen-web/src/types/api.ts

@@ -235,16 +235,46 @@ export interface LabResult {
   created_at?: string;
 }
 
-// Dose Log Types
+// Dose Log Types — match backend MedicationDose (camelCase serialization).
 export interface DoseLog {
-  log_id?: string;
-  medication_id: string;
-  scheduled_time: string;
-  taken_time?: string;
-  status: 'scheduled' | 'taken' | 'skipped' | 'missed';
+  id?: string;
+  medicationId: string;
+  userId?: string;
+  loggedAt: string;
+  scheduledTime?: string;
+  taken: boolean;
   notes?: string;
 }
 
+// Request body for POST /medications/:id/log.
+export interface LogDoseRequest {
+  taken?: boolean;
+  scheduled_time?: string;
+  notes?: string;
+}
+
+// Response from GET /medications/:id/adherence.
+export interface AdherenceStats {
+  medication_id: string;
+  total_doses: number;
+  scheduled_doses: number;
+  taken_doses: number;
+  missed_doses: number;
+  adherence_rate: number;
+  period_days: number;
+}
+
+// Profile Types — match backend ProfileResponse.
+export interface Profile {
+  profile_id: string;
+  user_id: string;
+  name: string;
+  role: string;
+  permissions: string[];
+  created_at: string;
+  updated_at: string;
+}
+
 // Error Types
 export interface ApiError {
   message: string;