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/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 }),
+  })),
+);