chore: release v1.14.3 (#271)

* feat: make medication names clickable in Dashboard dose schedule

Add click handlers to med-name-stack divs in all three dose schedule
sections (past, current/overdue, future) on DashboardPage, opening the
MedDetail modal on click.

Add early-return guards to all four modal openers in AppContext
(openMedDetail, openImageLightbox, openScheduleLightbox, openUserFilter)
to prevent duplicate pushState entries on double-click, which caused
unexpected navigation to the Medications page.

Closes #266

* fix: stabilize dashboard modal and image click handling

* fix: close medication detail on first backdrop click

README.md

@@ -18,8 +18,8 @@
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/Backend_Tests-558%2F558-brightgreen?logo=vitest" alt="Backend Tests 454/454" />
-  <img src="https://img.shields.io/badge/Frontend_Tests-776%2F776-brightgreen?logo=vitest" alt="Frontend Tests 611/611" />
+  <img src="https://img.shields.io/badge/Backend_Tests-564%2F564-brightgreen?logo=vitest" alt="Backend Tests 454/454" />
+  <img src="https://img.shields.io/badge/Frontend_Tests-777%2F777-brightgreen?logo=vitest" alt="Frontend Tests 611/611" />
 </p>
 
 ### 🤖 AI-Generated Code

backend/drizzle/0010_mean_spot.sql

@@ -0,0 +1 @@
+ALTER TABLE `dose_tracking` ADD `taken_source` text DEFAULT 'manual' NOT NULL;

backend/drizzle/meta/_journal.json

@@ -71,6 +71,13 @@
       "when": 1771164000000,
       "tag": "0009_add_medication_start_date",
       "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "6",
+      "when": 1771694832866,
+      "tag": "0010_mean_spot",
+      "breakpoints": true
     }
   ]
 }

backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "medassist-ng-backend",
-  "version": "1.12.0",
+  "version": "1.14.3",
   "private": true,
   "type": "module",
   "scripts": {

backend/src/db/db-utils.ts

@@ -111,6 +111,8 @@ export async function runAlterMigrations(client: Client): Promise<{ success: boo
 		`ALTER TABLE user_settings ADD COLUMN max_nagging_reminders integer NOT NULL DEFAULT 5`,
 		// Added in v1.2.3 - dismiss missed doses without deducting stock
 		`ALTER TABLE dose_tracking ADD COLUMN dismissed integer NOT NULL DEFAULT 0`,
+		// Added for intake automation auditability (manual vs automatic taken)
+		`ALTER TABLE dose_tracking ADD COLUMN taken_source text NOT NULL DEFAULT 'manual'`,
 		// Added in v1.3.x - stock calculation mode (automatic/manual)
 		`ALTER TABLE user_settings ADD COLUMN stock_calculation_mode text NOT NULL DEFAULT 'automatic'`,
 		// Added for stock correction - hidden offset that doesn't affect looseTablets

backend/src/db/schema.ts

@@ -163,6 +163,7 @@ export const doseTracking = sqliteTable("dose_tracking", {
 	doseId: text("dose_id", { length: 255 }).notNull(), // e.g. "med-5-1-86400000-1735200000000"
 	takenAt: integer("taken_at", { mode: "timestamp" }).notNull().default(sql`(strftime('%s','now'))`),
 	markedBy: text("marked_by", { length: 100 }), // null = user, "Daniel" = via share link
+	takenSource: text("taken_source", { length: 20 }).notNull().default("manual"), // manual or automatic
 	dismissed: integer("dismissed", { mode: "boolean" }).notNull().default(false), // true = missed dose acknowledged without taking
 });
 

backend/src/routes/doses.ts

@@ -56,6 +56,7 @@ export async function doseRoutes(app: FastifyInstance) {
 				doseId: d.doseId,
 				takenAt: d.takenAt?.getTime() ?? Date.now(),
 				markedBy: d.markedBy,
+				takenSource: d.takenSource ?? "manual",
 				dismissed: d.dismissed ?? false,
 			})),
 		};
@@ -94,6 +95,7 @@ export async function doseRoutes(app: FastifyInstance) {
 				userId,
 				doseId,
 				markedBy: null, // Marked by the user themselves
+				takenSource: "manual",
 			});
 
 			return { success: true };
@@ -227,6 +229,7 @@ export async function doseRoutes(app: FastifyInstance) {
 				doseId: d.doseId,
 				takenAt: d.takenAt?.getTime() ?? Date.now(),
 				markedBy: d.markedBy,
+				takenSource: d.takenSource ?? "manual",
 				dismissed: d.dismissed ?? false,
 			})),
 		};
@@ -270,6 +273,7 @@ export async function doseRoutes(app: FastifyInstance) {
 				userId: share.userId,
 				doseId,
 				markedBy: share.takenBy, // e.g. "Daniel"
+				takenSource: "manual",
 			});
 
 			return { success: true };

backend/src/routes/export.ts

@@ -72,6 +72,7 @@ const doseHistorySchema = z.object({
 	scheduledTime: z.string(), // ISO datetime
 	takenAt: z.string(), // ISO datetime
 	markedBy: z.string().nullable().optional(),
+	takenSource: z.enum(["manual", "automatic"]).default("manual"),
 	dismissed: z.boolean().default(false),
 	takenByPerson: z.string().nullable().optional(), // Person suffix from dose ID (e.g., "Daniel")
 });
@@ -364,6 +365,7 @@ export async function exportRoutes(app: FastifyInstance) {
 					scheduledTime: scheduledTimeIso,
 					takenAt: takenAtIso,
 					markedBy: dose.markedBy,
+					takenSource: dose.takenSource === "automatic" ? "automatic" : "manual",
 					dismissed: dose.dismissed ?? false,
 					takenByPerson: parsed.person,
 				};
@@ -625,6 +627,7 @@ export async function exportRoutes(app: FastifyInstance) {
 					doseId,
 					takenAt: new Date(dose.takenAt),
 					markedBy: dose.markedBy || null,
+					takenSource: dose.takenSource ?? "manual",
 					dismissed: dose.dismissed ?? false,
 				});
 			}

backend/src/routes/medications.ts

@@ -6,7 +6,7 @@ import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
 import { z } from "zod";
 import { db } from "../db/client.js";
 import { getDataDir } from "../db/db-utils.js";
-import { doseTracking, medications } from "../db/schema.js";
+import { doseTracking, medications, userSettings } from "../db/schema.js";
 import { getAnonymousUserId, requireAuth } from "../plugins/auth.js";
 import { env } from "../plugins/env.js";
 import type { AuthUser } from "../types/fastify.js";
@@ -792,26 +792,38 @@ export async function medicationRoutes(app: FastifyInstance) {
 			.where(and(eq(medications.userId, userId), eq(medications.isObsolete, false)))
 			.orderBy(medications.id);
 
+		const [settingsRow] = await db
+			.select({ stockCalculationMode: userSettings.stockCalculationMode })
+			.from(userSettings)
+			.where(eq(userSettings.userId, userId));
+		const stockCalculationMode = settingsRow?.stockCalculationMode === "manual" ? "manual" : "automatic";
+
 		// Get all taken doses for this user to calculate actual consumption
 		const takenDoses = await db
 			.select()
 			.from(doseTracking)
 			.where(and(eq(doseTracking.userId, userId), eq(doseTracking.dismissed, false)));
 
-		// Create a map of medication ID to taken dose count
-		const takenDosesMap = new Map<number, { blisterIdx: number; usage: number }[]>();
+		const takenDoseIdsByMed = new Map<number, Set<string>>();
+		const takenDoseTimestamps = new Map<string, number>();
 		takenDoses.forEach((dose) => {
 			const parts = dose.doseId.split("-");
-			if (parts.length >= 3) {
-				const medId = parseInt(parts[0], 10);
-				const blisterIdx = parseInt(parts[1], 10);
-				if (!Number.isNaN(medId) && !Number.isNaN(blisterIdx)) {
-					if (!takenDosesMap.has(medId)) {
-						takenDosesMap.set(medId, []);
-					}
-					takenDosesMap.get(medId)!.push({ blisterIdx, usage: 0 }); // usage filled later
-				}
+			if (parts.length < 3) return;
+			const medId = parseInt(parts[0], 10);
+			if (Number.isNaN(medId)) return;
+
+			if (!takenDoseIdsByMed.has(medId)) {
+				takenDoseIdsByMed.set(medId, new Set());
 			}
+			takenDoseIdsByMed.get(medId)!.add(dose.doseId);
+			const rawTakenAt = Number(dose.takenAt);
+			let takenAtMs: number;
+			if (Number.isFinite(rawTakenAt)) {
+				takenAtMs = rawTakenAt < 1_000_000_000_000 ? rawTakenAt * 1000 : rawTakenAt;
+			} else {
+				takenAtMs = new Date(dose.takenAt).getTime();
+			}
+			takenDoseTimestamps.set(dose.doseId, takenAtMs);
 		});
 
 		// Use current time as the reference point for "available" stock
@@ -838,66 +850,109 @@ export async function medicationRoutes(app: FastifyInstance) {
 					? looseTablets + stockAdjustment
 					: packCount * blistersPerPack * pillsPerBlister + looseTablets + stockAdjustment;
 
-			// Calculate consumption based on ACTUAL taken doses from dose_tracking
-			// This ensures Planner shows the same "current stock" as the Dashboard/Modal
-			// Use the same logic as frontend: generate expected doses and check which are marked
+			// Calculate consumption with the same automatic/manual behavior as frontend coverage.
 			const stockCorrectionCutoff = row.lastStockCorrectionAt ? new Date(row.lastStockCorrectionAt).getTime() : 0;
-
-			// Build a Set of taken dose IDs for quick lookup
-			const takenDoseIds = new Set(
-				takenDoses
-					.filter((dose) => {
-						const parts = dose.doseId.split("-");
-						return parts.length >= 3 && parseInt(parts[0], 10) === row.id;
-					})
-					.map((dose) => dose.doseId)
-			);
+			const takenDoseIds = takenDoseIdsByMed.get(row.id) ?? new Set<string>();
 
 			// Count consumed pills by generating expected doses and checking if they're taken
 			let consumedUntilNow = 0;
 			const msPerDay = 86400000;
 
-			blisters.forEach((blister, blisterIdx) => {
-				const blisterStart = parseLocalDateTime(blister.start);
-				if (Number.isNaN(blisterStart.getTime())) return;
+			if (stockCalculationMode === "automatic") {
+				blisters.forEach((blister, blisterIdx) => {
+					const blisterStart = parseLocalDateTime(blister.start).getTime();
+					if (Number.isNaN(blisterStart)) return;
 
-				const period = Math.max(1, blister.every) * msPerDay;
+					const period = Math.max(1, blister.every) * msPerDay;
 
-				// After a stock correction, start counting from the NEXT scheduled
-				// dose, because the user's pill count already reflects all
-				// consumption up to the correction time.
-				let effectiveStart: number;
-				if (stockCorrectionCutoff > 0 && stockCorrectionCutoff >= blisterStart.getTime()) {
-					effectiveStart = stockCorrectionCutoff + period;
-				} else {
-					effectiveStart = blisterStart.getTime();
-				}
-				if (effectiveStart > now.getTime()) return;
+					let effectiveStart: number;
+					if (stockCorrectionCutoff > 0 && stockCorrectionCutoff >= blisterStart) {
+						const elapsedSinceStart = stockCorrectionCutoff - blisterStart;
+						const periodsElapsed = Math.floor(elapsedSinceStart / period);
+						effectiveStart = blisterStart + (periodsElapsed + 1) * period;
+					} else {
+						effectiveStart = blisterStart;
+					}
 
-				const occurrences = Math.floor((now.getTime() - effectiveStart) / period) + 1;
+					const intake = intakes[blisterIdx];
+					const intakePerson = intake?.takenBy;
+					const fallbackPeople = parseTakenByJson(row.takenByJson);
+					let peopleForThisIntake: Array<string | null>;
+					if (intakePerson) {
+						peopleForThisIntake = [intakePerson];
+					} else if (fallbackPeople.length > 0) {
+						peopleForThisIntake = fallbackPeople;
+					} else {
+						peopleForThisIntake = [null];
+					}
 
-				// Get the people for this intake (from intakes array or medication takenBy)
-				const takenByJson = row.takenByJson ? JSON.parse(row.takenByJson) : [];
-				const intake = intakes[blisterIdx];
-				const intakePerson = intake?.takenBy;
-				const takenByFallback: (string | null)[] = takenByJson.length > 0 ? takenByJson : [null];
-				const peopleForThisIntake: (string | null)[] = intakePerson ? [intakePerson] : takenByFallback;
+					let timeBasedConsumed = 0;
+					let lastAutoConsumedDateMs = 0;
 
-				// Generate expected dose IDs and check if they're taken
-				for (let i = 0; i < occurrences; i++) {
-					const doseDate = new Date(effectiveStart + i * period);
-					const dateOnlyMs = new Date(doseDate.getFullYear(), doseDate.getMonth(), doseDate.getDate()).getTime();
-					const baseDoseId = `${row.id}-${blisterIdx}-${dateOnlyMs}`;
+					if (effectiveStart <= now.getTime()) {
+						const occurrences = Math.floor((now.getTime() - effectiveStart) / period) + 1;
+						timeBasedConsumed = occurrences * blister.usage * peopleForThisIntake.length;
 
-					// Check if each person has taken this dose
-					for (const person of peopleForThisIntake) {
-						const doseId = person ? `${baseDoseId}-${person}` : baseDoseId;
-						if (takenDoseIds.has(doseId)) {
+						const lastDoseTime = new Date(effectiveStart + (occurrences - 1) * period);
+						lastAutoConsumedDateMs = new Date(
+							lastDoseTime.getFullYear(),
+							lastDoseTime.getMonth(),
+							lastDoseTime.getDate()
+						).getTime();
+					}
+
+					const stockCorrectionDateOnly =
+						stockCorrectionCutoff > 0
+							? new Date(
+									new Date(stockCorrectionCutoff).getFullYear(),
+									new Date(stockCorrectionCutoff).getMonth(),
+									new Date(stockCorrectionCutoff).getDate()
+								).getTime()
+							: 0;
+					const earlyCutoff = Math.max(lastAutoConsumedDateMs, stockCorrectionDateOnly);
+
+					let earlyTakenConsumed = 0;
+					for (const doseId of takenDoseIds) {
+						const parts = doseId.split("-");
+						if (parts.length < 3) continue;
+						const bIdx = parseInt(parts[1], 10);
+						const timestamp = parseInt(parts[2], 10);
+						if (!Number.isNaN(bIdx) && !Number.isNaN(timestamp) && bIdx === blisterIdx && timestamp > earlyCutoff) {
+							earlyTakenConsumed += blister.usage;
+						}
+					}
+
+					consumedUntilNow += timeBasedConsumed + earlyTakenConsumed;
+				});
+			} else {
+				blisters.forEach((blister, blisterIdx) => {
+					const blisterStart = parseLocalDateTime(blister.start);
+					const blisterStartDateOnly = new Date(
+						blisterStart.getFullYear(),
+						blisterStart.getMonth(),
+						blisterStart.getDate()
+					).getTime();
+					if (Number.isNaN(blisterStartDateOnly)) return;
+
+					for (const doseId of takenDoseIds) {
+						const parts = doseId.split("-");
+						if (parts.length < 3) continue;
+
+						const parsedBlisterIdx = parseInt(parts[1], 10);
+						const doseTimestamp = parseInt(parts[2], 10);
+						if (Number.isNaN(parsedBlisterIdx) || Number.isNaN(doseTimestamp) || parsedBlisterIdx !== blisterIdx) {
+							continue;
+						}
+
+						const takenAt = takenDoseTimestamps.get(doseId) ?? 0;
+						const afterCorrectionOrNoCorrection = stockCorrectionCutoff === 0 || takenAt > stockCorrectionCutoff;
+
+						if (doseTimestamp >= blisterStartDateOnly && afterCorrectionOrNoCorrection) {
 							consumedUntilNow += blister.usage;
 						}
 					}
-				}
-			});
+				});
+			}
 
 			const currentStock = Math.max(0, originalTotalPills - consumedUntilNow);
 
@@ -943,6 +998,7 @@ export async function medicationRoutes(app: FastifyInstance) {
 				medicationId: row.id,
 				medicationName: row.name,
 				totalPills: currentStock,
+				currentPills: currentStock,
 				plannerUsage: usageTotal,
 				blisterSize: pillsPerBlister,
 				blistersNeeded,

backend/src/routes/refills.ts

@@ -77,7 +77,10 @@ export async function refillRoutes(app: FastifyInstance) {
 		const newPackCount = med.packCount + effectivePacksAdded;
 		const newLooseTablets = med.looseTablets + effectiveLoosePillsAdded;
 
-		const consumedRefills = usePrescription ? (isBottle ? 1 : effectivePacksAdded) : 0;
+		let consumedRefills = 0;
+		if (usePrescription) {
+			consumedRefills = isBottle ? 1 : effectivePacksAdded;
+		}
 		const newRemainingRefills = usePrescription
 			? Math.max(0, remainingPrescriptionRefills - consumedRefills)
 			: (med.prescriptionRemainingRefills ?? null);

backend/src/routes/report.ts

@@ -51,17 +51,22 @@ export async function reportRoutes(app: FastifyInstance) {
 				doseId: doseTracking.doseId,
 				takenAt: doseTracking.takenAt,
 				dismissed: doseTracking.dismissed,
+				takenSource: doseTracking.takenSource,
 			})
 			.from(doseTracking)
 			.where(eq(doseTracking.userId, userId));
 
 		// Group doses by medication ID
-		const dosesByMed = new Map<number, { takenAt: Date; dismissed: boolean }[]>();
+		const dosesByMed = new Map<number, { takenAt: Date; dismissed: boolean; takenSource: string }[]>();
 		for (const dose of allDoses) {
 			const medId = Number.parseInt(dose.doseId.split("-")[0], 10);
 			if (Number.isNaN(medId) || !medicationIds.includes(medId)) continue;
 			if (!dosesByMed.has(medId)) dosesByMed.set(medId, []);
-			dosesByMed.get(medId)!.push({ takenAt: dose.takenAt, dismissed: dose.dismissed });
+			dosesByMed.get(medId)!.push({
+				takenAt: dose.takenAt,
+				dismissed: dose.dismissed,
+				takenSource: dose.takenSource ?? "manual",
+			});
 		}
 
 		// Fetch refill history for requested medications
@@ -69,6 +74,7 @@ export async function reportRoutes(app: FastifyInstance) {
 			number,
 			{
 				dosesTaken: number;
+				automaticDosesTaken: number;
 				dosesDismissed: number;
 				firstDoseAt: string | null;
 				lastDoseAt: string | null;
@@ -79,6 +85,7 @@ export async function reportRoutes(app: FastifyInstance) {
 		for (const medId of medicationIds) {
 			const doses = dosesByMed.get(medId) ?? [];
 			const takenDoses = doses.filter((d) => !d.dismissed);
+			const automaticTakenDoses = takenDoses.filter((d) => d.takenSource === "automatic");
 			const dismissedDoses = doses.filter((d) => d.dismissed);
 
 			const sortedTaken = takenDoses.map((d) => d.takenAt.getTime()).sort((a, b) => a - b);
@@ -88,6 +95,7 @@ export async function reportRoutes(app: FastifyInstance) {
 
 			result[medId] = {
 				dosesTaken: takenDoses.length,
+				automaticDosesTaken: automaticTakenDoses.length,
 				dosesDismissed: dismissedDoses.length,
 				firstDoseAt: sortedTaken.length > 0 ? new Date(sortedTaken[0]).toISOString() : null,
 				lastDoseAt: sortedTaken.length > 0 ? new Date(sortedTaken[sortedTaken.length - 1]).toISOString() : null,

backend/src/services/intake-reminder-scheduler.ts

@@ -50,6 +50,113 @@ function saveIntakeReminderState(state: IntakeReminderState): void {
 	writeFileSync(intakeReminderStateFile, JSON.stringify(state, null, 2));
 }
 
+function buildDoseIdForIntake(intake: UpcomingIntake & { medicationId: number; blisterIndex: number }): string {
+	const intakeDate = intake.intakeTime;
+	const dateOnlyMs = new Date(intakeDate.getFullYear(), intakeDate.getMonth(), intakeDate.getDate()).getTime();
+	if (intake.takenBy) {
+		return `${intake.medicationId}-${intake.blisterIndex}-${dateOnlyMs}-${intake.takenBy}`;
+	}
+	return `${intake.medicationId}-${intake.blisterIndex}-${dateOnlyMs}`;
+}
+
+async function autoMarkDueIntakesAsTaken(
+	settings: UserSettings & { userId: number },
+	rows: (typeof medications.$inferSelect)[],
+	locale: string,
+	tz: string,
+	logger: ServiceLogger
+): Promise<number> {
+	if (settings.stockCalculationMode !== "automatic") {
+		return 0;
+	}
+
+	const now = new Date();
+	const nowInTimezone = new Date(now.toLocaleString("en-US", { timeZone: tz }));
+	const todayStart = new Date(now.toLocaleString("en-US", { timeZone: tz }));
+	todayStart.setHours(0, 0, 0, 0);
+	const todayEnd = new Date(now.toLocaleString("en-US", { timeZone: tz }));
+	todayEnd.setHours(23, 59, 59, 999);
+
+	const existingToday = await db
+		.select({ doseId: doseTracking.doseId })
+		.from(doseTracking)
+		.where(
+			and(
+				eq(doseTracking.userId, settings.userId),
+				gte(doseTracking.takenAt, todayStart),
+				lte(doseTracking.takenAt, todayEnd)
+			)
+		);
+	const existingDoseIds = new Set(existingToday.map((d) => d.doseId));
+
+	let inserted = 0;
+
+	for (const med of rows) {
+		if (med.isObsolete) {
+			continue;
+		}
+
+		const intakes = parseIntakesJson(
+			med.intakesJson,
+			{ usageJson: med.usageJson, everyJson: med.everyJson, startJson: med.startJson },
+			med.intakeRemindersEnabled ?? false
+		);
+		if (intakes.length === 0) {
+			continue;
+		}
+
+		const medicationTakenBy = parseTakenByJson(med.takenByJson);
+		const todaysIntakes = getTodaysIntakes(
+			med.name,
+			intakes,
+			medicationTakenBy,
+			med.pillWeightMg,
+			locale,
+			tz,
+			med.id,
+			med.doseUnit ?? "mg"
+		);
+
+		for (const intake of todaysIntakes) {
+			const intakeTimeInTimezone = new Date(intake.intakeTime.toLocaleString("en-US", { timeZone: tz }));
+			if (intakeTimeInTimezone.getTime() > nowInTimezone.getTime()) {
+				continue;
+			}
+			if (intake.medicationId === undefined || intake.blisterIndex === undefined) {
+				continue;
+			}
+
+			const doseId = buildDoseIdForIntake({
+				...intake,
+				medicationId: intake.medicationId,
+				blisterIndex: intake.blisterIndex,
+			});
+
+			if (existingDoseIds.has(doseId)) {
+				continue;
+			}
+
+			await db.insert(doseTracking).values({
+				userId: settings.userId,
+				doseId,
+				takenAt: intake.intakeTime,
+				markedBy: null,
+				takenSource: "automatic",
+				dismissed: false,
+			});
+
+			existingDoseIds.add(doseId);
+			inserted++;
+		}
+	}
+
+	if (inserted > 0) {
+		logger.info(`[IntakeReminder] User ${settings.userId}: Auto-marked ${inserted} due intake dose(s) as taken`);
+	}
+
+	return inserted;
+}
+
 async function sendIntakeReminderEmail(
 	email: string,
 	intakes: UpcomingIntake[],
@@ -246,6 +353,17 @@ async function checkAndSendIntakeRemindersForUser(
 		`[IntakeReminder] Checking user ${settings.userId} - repeat:${settings.repeatRemindersEnabled} skip:${settings.skipRemindersForTakenDoses}`
 	);
 
+	const rows = await db
+		.select()
+		.from(medications)
+		.where(eq(medications.userId, settings.userId))
+		.orderBy(medications.id);
+
+	const locale = getDateLocale(language);
+	const tz = getTimezone();
+
+	await autoMarkDueIntakesAsTaken(settings, rows, locale, tz, logger);
+
 	// Check if any intake reminder notifications are enabled (granular check)
 	const emailEnabled = settings.emailEnabled && settings.notificationEmail && settings.emailIntakeReminders;
 	const shoutrrrEnabled = settings.shoutrrrEnabled && settings.shoutrrrUrl && settings.shoutrrrIntakeReminders;
@@ -262,11 +380,6 @@ async function checkAndSendIntakeRemindersForUser(
 	);
 
 	// Get all medications with intake reminders enabled for this user
-	const rows = await db
-		.select()
-		.from(medications)
-		.where(eq(medications.userId, settings.userId))
-		.orderBy(medications.id);
 	const medsWithReminders = rows.filter((row) => row.intakeRemindersEnabled);
 
 	if (medsWithReminders.length === 0) {
@@ -280,9 +393,6 @@ async function checkAndSendIntakeRemindersForUser(
 
 	const state = loadIntakeReminderState();
 	const allUpcoming: (UpcomingIntake & { medicationId: number; blisterIndex: number })[] = [];
-	const locale = getDateLocale(language);
-	const tz = getTimezone();
-
 	// Get start and end of today in user's timezone (for filtering today's doses only)
 	const now = new Date();
 	const todayStart = new Date(now.toLocaleString("en-US", { timeZone: tz }));

backend/src/services/reminder-scheduler.ts

@@ -1,10 +1,10 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { and, eq } from "drizzle-orm";
 import nodemailer from "nodemailer";
 import { db } from "../db/client.js";
 import { getDataDir } from "../db/db-utils.js";
-import { medications, userSettings } from "../db/schema.js";
+import { doseTracking, medications, userSettings } from "../db/schema.js";
 import { getFooterHtml, getFooterPlain, getTranslations, type Language, t } from "../i18n/translations.js";
 import { getAllUserSettings, sendShoutrrrNotification, type UserSettings } from "../routes/settings.js";
 import type { ServiceLogger } from "../utils/logger.js";
@@ -19,8 +19,10 @@ import {
 	getNextScheduledTime,
 	getTimezone,
 	getTodayInTimezone,
-	parseBlisters,
+	parseIntakesJson,
+	parseLocalDateTime,
 	parseReminderState,
+	parseTakenByJson,
 	type ReminderState,
 } from "../utils/scheduler-utils.js";
 
@@ -38,6 +40,56 @@ function escapeHtml(text: string): string {
 const REMINDER_HOUR = parseInt(process.env.REMINDER_HOUR ?? "6", 10); // Default 6:00 AM local time
 
 const reminderStateFile = resolve(getDataDir(), "reminder-state.json");
+const reminderLocksDir = resolve(getDataDir(), "scheduler-locks");
+const LOCK_STALE_MS = 15 * 60 * 1000;
+
+function ensureReminderLocksDir(): void {
+	if (!existsSync(reminderLocksDir)) {
+		mkdirSync(reminderLocksDir, { recursive: true });
+	}
+}
+
+function acquireReminderSendLock(lockKey: string): string | null {
+	ensureReminderLocksDir();
+	const lockFilePath = resolve(reminderLocksDir, `${lockKey}.lock`);
+
+	const tryCreateLock = (): boolean => {
+		try {
+			const fd = openSync(lockFilePath, "wx");
+			closeSync(fd);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+
+	if (tryCreateLock()) {
+		return lockFilePath;
+	}
+
+	try {
+		const stats = statSync(lockFilePath);
+		if (Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+			unlinkSync(lockFilePath);
+			if (tryCreateLock()) {
+				return lockFilePath;
+			}
+		}
+	} catch {
+		// ignore; lock acquisition fails safely
+	}
+
+	return null;
+}
+
+function releaseReminderSendLock(lockFilePath: string | null): void {
+	if (!lockFilePath) return;
+	try {
+		unlinkSync(lockFilePath);
+	} catch {
+		// ignore release errors
+	}
+}
 
 function loadReminderState(): ReminderState {
 	try {
@@ -119,10 +171,6 @@ export async function updateUserReminderSentTime(
 	}
 }
 
-function parseBlistersFromRow(row: { usageJson: string; everyJson: string; startJson: string }): Blister[] {
-	return parseBlisters(row);
-}
-
 type LowStockItem = {
 	name: string;
 	medsLeft: number;
@@ -142,7 +190,8 @@ async function getMedicationsNeedingReminder(
 	userId: number,
 	reminderDaysBefore: number,
 	lowStockDays: number,
-	language: Language
+	language: Language,
+	stockCalculationMode: "automatic" | "manual"
 ): Promise<LowStockItem[]> {
 	const rows = await db
 		.select()
@@ -150,15 +199,152 @@ async function getMedicationsNeedingReminder(
 		.where(and(eq(medications.userId, userId), eq(medications.isObsolete, false)))
 		.orderBy(medications.id);
 
+	const takenDoseRows = await db
+		.select()
+		.from(doseTracking)
+		.where(and(eq(doseTracking.userId, userId), eq(doseTracking.dismissed, false)));
+
+	const takenDoseIdsByMed = new Map<number, Set<string>>();
+	const takenDoseTimestamps = new Map<string, number>();
+	for (const dose of takenDoseRows) {
+		const parts = dose.doseId.split("-");
+		if (parts.length < 3) continue;
+		const medId = parseInt(parts[0], 10);
+		if (Number.isNaN(medId)) continue;
+
+		if (!takenDoseIdsByMed.has(medId)) {
+			takenDoseIdsByMed.set(medId, new Set());
+		}
+		takenDoseIdsByMed.get(medId)!.add(dose.doseId);
+		const rawTakenAt = Number(dose.takenAt);
+		let takenAtMs: number;
+		if (Number.isFinite(rawTakenAt)) {
+			takenAtMs = rawTakenAt < 1_000_000_000_000 ? rawTakenAt * 1000 : rawTakenAt;
+		} else {
+			takenAtMs = new Date(dose.takenAt).getTime();
+		}
+		takenDoseTimestamps.set(dose.doseId, takenAtMs);
+	}
+
 	const lowStock: LowStockItem[] = [];
+	const now = Date.now();
+	const msPerDay = 86_400_000;
 
 	for (const row of rows) {
-		const blisters = parseBlistersFromRow(row);
-		const totalPills =
+		const intakes = parseIntakesJson(
+			row.intakesJson,
+			{ usageJson: row.usageJson, everyJson: row.everyJson, startJson: row.startJson },
+			row.intakeRemindersEnabled ?? false
+		);
+		const blisters: Blister[] = intakes.map((i) => ({ usage: i.usage, every: i.every, start: i.start }));
+
+		const originalTotalPills =
 			(row.packageType ?? "blister") === "bottle"
 				? row.looseTablets + (row.stockAdjustment ?? 0)
 				: row.packCount * row.blistersPerPack * row.pillsPerBlister + row.looseTablets + (row.stockAdjustment ?? 0);
-		const { daysLeft, depletionDate } = calculateDepletionInfo({ count: totalPills, blisters }, language);
+
+		const stockCorrectionCutoff = row.lastStockCorrectionAt ? new Date(row.lastStockCorrectionAt).getTime() : 0;
+		const takenDoseIds = takenDoseIdsByMed.get(row.id) ?? new Set<string>();
+
+		let consumed = 0;
+
+		if (stockCalculationMode === "automatic") {
+			blisters.forEach((blister, blisterIdx) => {
+				const blisterStart = parseLocalDateTime(blister.start).getTime();
+				if (Number.isNaN(blisterStart)) return;
+
+				const period = Math.max(1, blister.every) * msPerDay;
+
+				let effectiveStart: number;
+				if (stockCorrectionCutoff > 0 && stockCorrectionCutoff >= blisterStart) {
+					const elapsedSinceStart = stockCorrectionCutoff - blisterStart;
+					const periodsElapsed = Math.floor(elapsedSinceStart / period);
+					effectiveStart = blisterStart + (periodsElapsed + 1) * period;
+				} else {
+					effectiveStart = blisterStart;
+				}
+
+				const intake = intakes[blisterIdx];
+				const intakePerson = intake?.takenBy;
+				const fallbackPeople = parseTakenByJson(row.takenByJson);
+				let peopleForThisIntake: Array<string | null>;
+				if (intakePerson) {
+					peopleForThisIntake = [intakePerson];
+				} else if (fallbackPeople.length > 0) {
+					peopleForThisIntake = fallbackPeople;
+				} else {
+					peopleForThisIntake = [null];
+				}
+
+				let timeBasedConsumed = 0;
+				let lastAutoConsumedDateMs = 0;
+
+				if (effectiveStart <= now) {
+					const occurrences = Math.floor((now - effectiveStart) / period) + 1;
+					timeBasedConsumed = occurrences * blister.usage * peopleForThisIntake.length;
+
+					const lastDoseTime = new Date(effectiveStart + (occurrences - 1) * period);
+					lastAutoConsumedDateMs = new Date(
+						lastDoseTime.getFullYear(),
+						lastDoseTime.getMonth(),
+						lastDoseTime.getDate()
+					).getTime();
+				}
+
+				const stockCorrectionDateOnly =
+					stockCorrectionCutoff > 0
+						? new Date(
+								new Date(stockCorrectionCutoff).getFullYear(),
+								new Date(stockCorrectionCutoff).getMonth(),
+								new Date(stockCorrectionCutoff).getDate()
+							).getTime()
+						: 0;
+				const earlyCutoff = Math.max(lastAutoConsumedDateMs, stockCorrectionDateOnly);
+
+				let earlyTakenConsumed = 0;
+				for (const doseId of takenDoseIds) {
+					const parts = doseId.split("-");
+					if (parts.length < 3) continue;
+					const bIdx = parseInt(parts[1], 10);
+					const timestamp = parseInt(parts[2], 10);
+					if (!Number.isNaN(bIdx) && !Number.isNaN(timestamp) && bIdx === blisterIdx && timestamp > earlyCutoff) {
+						earlyTakenConsumed += blister.usage;
+					}
+				}
+
+				consumed += timeBasedConsumed + earlyTakenConsumed;
+			});
+		} else {
+			blisters.forEach((blister, blisterIdx) => {
+				const blisterStart = parseLocalDateTime(blister.start);
+				const blisterStartDateOnly = new Date(
+					blisterStart.getFullYear(),
+					blisterStart.getMonth(),
+					blisterStart.getDate()
+				).getTime();
+				if (Number.isNaN(blisterStartDateOnly)) return;
+
+				for (const doseId of takenDoseIds) {
+					const parts = doseId.split("-");
+					if (parts.length < 3) continue;
+
+					const parsedBlisterIdx = parseInt(parts[1], 10);
+					const doseTimestamp = parseInt(parts[2], 10);
+					if (Number.isNaN(parsedBlisterIdx) || Number.isNaN(doseTimestamp) || parsedBlisterIdx !== blisterIdx) {
+						continue;
+					}
+
+					const takenAt = takenDoseTimestamps.get(doseId) ?? 0;
+					const afterCorrectionOrNoCorrection = stockCorrectionCutoff === 0 || takenAt > stockCorrectionCutoff;
+					if (doseTimestamp >= blisterStartDateOnly && afterCorrectionOrNoCorrection) {
+						consumed += blister.usage;
+					}
+				}
+			});
+		}
+
+		const currentPills = Math.max(0, originalTotalPills - consumed);
+		const { daysLeft, depletionDate } = calculateDepletionInfo({ count: currentPills, blisters }, language);
 
 		if (daysLeft === null) continue;
 
@@ -168,7 +354,7 @@ async function getMedicationsNeedingReminder(
 		if (isCritical || isLow) {
 			lowStock.push({
 				name: row.name,
-				medsLeft: totalPills,
+				medsLeft: currentPills,
 				daysLeft,
 				depletionDate,
 				isCritical,
@@ -200,6 +386,25 @@ async function getMedicationsNeedingPrescriptionReminder(userId: number): Promis
 		}));
 }
 
+// Test-only hook to validate scheduler stock semantics against planner/coverage behavior.
+export async function getMedicationsNeedingReminderForTests(
+	userId: number,
+	reminderDaysBefore: number,
+	lowStockDays: number,
+	language: Language,
+	stockCalculationMode: "automatic" | "manual"
+): Promise<
+	Array<{
+		name: string;
+		medsLeft: number;
+		daysLeft: number | null;
+		depletionDate: string | null;
+		isCritical: boolean;
+	}>
+> {
+	return getMedicationsNeedingReminder(userId, reminderDaysBefore, lowStockDays, language, stockCalculationMode);
+}
+
 async function sendReminderEmail(
 	email: string,
 	lowStock: LowStockItem[],
@@ -403,172 +608,191 @@ async function checkAndSendReminderForUser(
 		settings.userId,
 		settings.reminderDaysBefore,
 		settings.lowStockDays,
-		language
+		language,
+		settings.stockCalculationMode
 	);
 	const allPrescriptionLow = await getMedicationsNeedingPrescriptionReminder(settings.userId);
 
 	if (allLowStock.length > 0 && (stockEmailEnabled || stockPushEnabled)) {
 		if (!state.notifiedMedications.includes(userStockNotifiedKey) || settings.repeatDailyReminders) {
-			logger.info(
-				`[Reminder] User ${settings.userId}: Sending stock reminder for ${allLowStock.length} medications...`
-			);
-
-			let emailSuccess = false;
-			let shoutrrrSuccess = false;
-
-			if (stockEmailEnabled) {
-				const result = await sendReminderEmail(
-					settings.notificationEmail!,
-					allLowStock,
-					language,
-					settings.repeatDailyReminders
-				);
-				emailSuccess = result.success;
-				if (!result.success) {
-					logger.error(`[Reminder] User ${settings.userId}: Failed to send stock email: ${result.error}`);
-				}
-			}
-
-			if (stockPushEnabled) {
-				const emptyMeds = allLowStock.filter((m) => m.medsLeft <= 0);
-				const criticalMeds = allLowStock.filter((m) => m.medsLeft > 0 && m.isCritical);
-				const lowStockMeds = allLowStock.filter((m) => m.medsLeft > 0 && !m.isCritical);
-
-				const titleParts: string[] = [];
-				if (emptyMeds.length > 0) titleParts.push(`🚨 ${emptyMeds.length} ${tr.push.empty}`);
-				if (criticalMeds.length > 0) titleParts.push(`🚨 ${criticalMeds.length} ${tr.push.critical}`);
-				if (lowStockMeds.length > 0) titleParts.push(`⚠️ ${lowStockMeds.length} ${tr.push.lowStock}`);
-				const title = `MedAssist-ng: ${titleParts.join(", ")} - ${tr.push.reorderNow}`;
-
-				const messageParts: string[] = [];
-				if (emptyMeds.length > 0) {
-					messageParts.push(`🚨 ${tr.push.emptySection}:`);
-					emptyMeds.forEach((m) => messageParts.push(`  • ${m.name}`));
-				}
-				if (criticalMeds.length > 0) {
-					if (messageParts.length > 0) messageParts.push("");
-					messageParts.push(`🚨 ${tr.push.criticalSection}:`);
-					criticalMeds.forEach((m) =>
-						messageParts.push(
-							`  • ${m.name}: ${t(tr.push.pillsLeft, { count: m.medsLeft })}, ${t(tr.push.daysLeft, { count: m.daysLeft ?? 0 })}`
-						)
+			const stockSendLock = acquireReminderSendLock(userStockNotifiedKey);
+			if (!stockSendLock) {
+				logger.debug(`[Reminder] User ${settings.userId}: stock reminder lock already held, skipping duplicate send`);
+			} else {
+				try {
+					logger.info(
+						`[Reminder] User ${settings.userId}: Sending stock reminder for ${allLowStock.length} medications...`
 					);
-				}
-				if (lowStockMeds.length > 0) {
-					if (messageParts.length > 0) messageParts.push("");
-					messageParts.push(`⚠️ ${tr.push.lowStockSection}:`);
-					lowStockMeds.forEach((m) =>
-						messageParts.push(
-							`  • ${m.name}: ${t(tr.push.pillsLeft, { count: m.medsLeft })}, ${t(tr.push.daysLeft, { count: m.daysLeft ?? 0 })}`
-						)
-					);
-				}
-				const message = `${messageParts.join("\n")}\n\n---\n${getFooterPlain(language)}`;
-				const result = await sendShoutrrrNotification(settings.shoutrrrUrl!, title, message);
-				shoutrrrSuccess = result.success;
-				if (!result.success) {
-					logger.error(`[Reminder] User ${settings.userId}: Failed to send stock push: ${result.error}`);
-				}
-			}
 
-			if (emailSuccess || shoutrrrSuccess) {
-				const currentState = loadReminderState();
-				const singleChannel = emailSuccess ? "email" : "push";
-				const channel = emailSuccess && shoutrrrSuccess ? "both" : singleChannel;
-				saveReminderState({
-					lastAutoEmailSent: new Date().toISOString(),
-					lastAutoEmailDate: today,
-					notifiedMedications: [...new Set([...currentState.notifiedMedications, userStockNotifiedKey])],
-					nextScheduledCheck: currentState.nextScheduledCheck,
-					lastNotificationType: "stock",
-					lastNotificationChannel: channel,
-				});
+					let emailSuccess = false;
+					let shoutrrrSuccess = false;
 
-				const medNames = allLowStock.map((m) => m.name).join(", ");
-				await updateUserReminderSentTime(settings.userId, "stock", channel, medNames);
+					if (stockEmailEnabled) {
+						const result = await sendReminderEmail(
+							settings.notificationEmail!,
+							allLowStock,
+							language,
+							settings.repeatDailyReminders
+						);
+						emailSuccess = result.success;
+						if (!result.success) {
+							logger.error(`[Reminder] User ${settings.userId}: Failed to send stock email: ${result.error}`);
+						}
+					}
+
+					if (stockPushEnabled) {
+						const emptyMeds = allLowStock.filter((m) => m.medsLeft <= 0);
+						const criticalMeds = allLowStock.filter((m) => m.medsLeft > 0 && m.isCritical);
+						const lowStockMeds = allLowStock.filter((m) => m.medsLeft > 0 && !m.isCritical);
+
+						const titleParts: string[] = [];
+						if (emptyMeds.length > 0) titleParts.push(`🚨 ${emptyMeds.length} ${tr.push.empty}`);
+						if (criticalMeds.length > 0) titleParts.push(`🚨 ${criticalMeds.length} ${tr.push.critical}`);
+						if (lowStockMeds.length > 0) titleParts.push(`⚠️ ${lowStockMeds.length} ${tr.push.lowStock}`);
+						const title = `MedAssist-ng: ${titleParts.join(", ")} - ${tr.push.reorderNow}`;
+
+						const messageParts: string[] = [];
+						if (emptyMeds.length > 0) {
+							messageParts.push(`🚨 ${tr.push.emptySection}:`);
+							emptyMeds.forEach((m) => messageParts.push(`  • ${m.name}`));
+						}
+						if (criticalMeds.length > 0) {
+							if (messageParts.length > 0) messageParts.push("");
+							messageParts.push(`🚨 ${tr.push.criticalSection}:`);
+							criticalMeds.forEach((m) =>
+								messageParts.push(
+									`  • ${m.name}: ${t(tr.push.pillsLeft, { count: m.medsLeft })}, ${t(tr.push.daysLeft, { count: m.daysLeft ?? 0 })}`
+								)
+							);
+						}
+						if (lowStockMeds.length > 0) {
+							if (messageParts.length > 0) messageParts.push("");
+							messageParts.push(`⚠️ ${tr.push.lowStockSection}:`);
+							lowStockMeds.forEach((m) =>
+								messageParts.push(
+									`  • ${m.name}: ${t(tr.push.pillsLeft, { count: m.medsLeft })}, ${t(tr.push.daysLeft, { count: m.daysLeft ?? 0 })}`
+								)
+							);
+						}
+						const message = `${messageParts.join("\n")}\n\n---\n${getFooterPlain(language)}`;
+						const result = await sendShoutrrrNotification(settings.shoutrrrUrl!, title, message);
+						shoutrrrSuccess = result.success;
+						if (!result.success) {
+							logger.error(`[Reminder] User ${settings.userId}: Failed to send stock push: ${result.error}`);
+						}
+					}
+
+					if (emailSuccess || shoutrrrSuccess) {
+						const currentState = loadReminderState();
+						const singleChannel = emailSuccess ? "email" : "push";
+						const channel = emailSuccess && shoutrrrSuccess ? "both" : singleChannel;
+						saveReminderState({
+							lastAutoEmailSent: new Date().toISOString(),
+							lastAutoEmailDate: today,
+							notifiedMedications: [...new Set([...currentState.notifiedMedications, userStockNotifiedKey])],
+							nextScheduledCheck: currentState.nextScheduledCheck,
+							lastNotificationType: "stock",
+							lastNotificationChannel: channel,
+						});
+
+						const medNames = allLowStock.map((m) => m.name).join(", ");
+						await updateUserReminderSentTime(settings.userId, "stock", channel, medNames);
+					}
+				} finally {
+					releaseReminderSendLock(stockSendLock);
+				}
 			}
 		}
 	}
 
 	if (allPrescriptionLow.length > 0 && (prescriptionEmailEnabled || prescriptionPushEnabled)) {
 		if (!state.notifiedMedications.includes(userPrescriptionNotifiedKey) || settings.repeatDailyReminders) {
-			logger.info(
-				`[Reminder] User ${settings.userId}: Sending prescription reminder for ${allPrescriptionLow.length} medications...`
-			);
+			const prescriptionSendLock = acquireReminderSendLock(userPrescriptionNotifiedKey);
+			if (!prescriptionSendLock) {
+				logger.debug(
+					`[Reminder] User ${settings.userId}: prescription reminder lock already held, skipping duplicate send`
+				);
+			} else {
+				try {
+					logger.info(
+						`[Reminder] User ${settings.userId}: Sending prescription reminder for ${allPrescriptionLow.length} medications...`
+					);
 
-			const emptyRx = allPrescriptionLow.filter((m) => m.remainingRefills <= 0);
-			const lowRx = allPrescriptionLow.filter((m) => m.remainingRefills > 0);
-			const lines = allPrescriptionLow.map((m) => {
-				const expirySuffix = m.expiryDate ? t(tr.prescriptionReminder.expiresSuffix, { date: m.expiryDate }) : "";
-				if (m.remainingRefills <= 0) {
-					return `- ${t(tr.prescriptionReminder.lineEmpty, {
-						name: m.name,
-						expirySuffix,
-					})}`;
-				}
-				return `- ${t(tr.prescriptionReminder.line, {
-					name: m.name,
-					refills: m.remainingRefills,
-					expirySuffix,
-				})}`;
-			});
+					const emptyRx = allPrescriptionLow.filter((m) => m.remainingRefills <= 0);
+					const lowRx = allPrescriptionLow.filter((m) => m.remainingRefills > 0);
+					const lines = allPrescriptionLow.map((m) => {
+						const expirySuffix = m.expiryDate ? t(tr.prescriptionReminder.expiresSuffix, { date: m.expiryDate }) : "";
+						if (m.remainingRefills <= 0) {
+							return `- ${t(tr.prescriptionReminder.lineEmpty, {
+								name: m.name,
+								expirySuffix,
+							})}`;
+						}
+						return `- ${t(tr.prescriptionReminder.line, {
+							name: m.name,
+							refills: m.remainingRefills,
+							expirySuffix,
+						})}`;
+					});
 
-			let emailSuccess = false;
-			let shoutrrrSuccess = false;
+					let emailSuccess = false;
+					let shoutrrrSuccess = false;
 
-			if (prescriptionEmailEnabled) {
-				const smtpHost = process.env.SMTP_HOST;
-				const smtpUser = process.env.SMTP_USER;
-				const smtpPass = process.env.SMTP_TOKEN || process.env.SMTP_PASS;
-				const smtpPort = parseInt(process.env.SMTP_PORT ?? "587", 10);
-				const smtpSecure = process.env.SMTP_SECURE === "true";
-				const smtpFrom = process.env.SMTP_FROM ?? smtpUser;
+					if (prescriptionEmailEnabled) {
+						const smtpHost = process.env.SMTP_HOST;
+						const smtpUser = process.env.SMTP_USER;
+						const smtpPass = process.env.SMTP_TOKEN || process.env.SMTP_PASS;
+						const smtpPort = parseInt(process.env.SMTP_PORT ?? "587", 10);
+						const smtpSecure = process.env.SMTP_SECURE === "true";
+						const smtpFrom = process.env.SMTP_FROM ?? smtpUser;
 
-				if (smtpHost && smtpUser) {
-					try {
-						const transporter = nodemailer.createTransport({
-							host: smtpHost,
-							port: smtpPort,
-							secure: smtpSecure,
-							auth: { user: smtpUser, pass: smtpPass ?? "" },
-						});
+						if (smtpHost && smtpUser) {
+							try {
+								const transporter = nodemailer.createTransport({
+									host: smtpHost,
+									port: smtpPort,
+									secure: smtpSecure,
+									auth: { user: smtpUser, pass: smtpPass ?? "" },
+								});
 
-						const subject =
-							allPrescriptionLow.length === 1
-								? tr.prescriptionReminder.subjectSingle
-								: t(tr.prescriptionReminder.subjectMultiple, { count: allPrescriptionLow.length });
+								const subject =
+									allPrescriptionLow.length === 1
+										? tr.prescriptionReminder.subjectSingle
+										: t(tr.prescriptionReminder.subjectMultiple, { count: allPrescriptionLow.length });
 
-						const bodyText =
-							emptyRx.length > 0 ? tr.prescriptionReminder.descriptionEmpty : tr.prescriptionReminder.descriptionLow;
-						const emptyAlert =
-							emptyRx.length === 1
-								? tr.prescriptionReminder.alertEmptySingle
-								: t(tr.prescriptionReminder.alertEmptyMultiple, { count: emptyRx.length });
-						const lowAlert =
-							lowRx.length === 1
-								? tr.prescriptionReminder.alertLowSingle
-								: t(tr.prescriptionReminder.alertLowMultiple, { count: lowRx.length });
-						const alertText = emptyRx.length > 0 ? emptyAlert : lowAlert;
+								const bodyText =
+									emptyRx.length > 0
+										? tr.prescriptionReminder.descriptionEmpty
+										: tr.prescriptionReminder.descriptionLow;
+								const emptyAlert =
+									emptyRx.length === 1
+										? tr.prescriptionReminder.alertEmptySingle
+										: t(tr.prescriptionReminder.alertEmptyMultiple, { count: emptyRx.length });
+								const lowAlert =
+									lowRx.length === 1
+										? tr.prescriptionReminder.alertLowSingle
+										: t(tr.prescriptionReminder.alertLowMultiple, { count: lowRx.length });
+								const alertText = emptyRx.length > 0 ? emptyAlert : lowAlert;
 
-						const tableRows = allPrescriptionLow
-							.map((item) => {
-								const isEmpty = item.remainingRefills <= 0;
-								const safeName = escapeHtml(item.name);
-								const safeRefills = Number(item.remainingRefills) || 0;
-								const safeThreshold = Number(item.lowThreshold) || 0;
-								const safeExpiry = item.expiryDate ? escapeHtml(String(item.expiryDate)) : "-";
-								const rowBg = isEmpty ? "#fef2f2" : "white";
-								return `
+								const tableRows = allPrescriptionLow
+									.map((item) => {
+										const isEmpty = item.remainingRefills <= 0;
+										const safeName = escapeHtml(item.name);
+										const safeRefills = Number(item.remainingRefills) || 0;
+										const safeThreshold = Number(item.lowThreshold) || 0;
+										const safeExpiry = item.expiryDate ? escapeHtml(String(item.expiryDate)) : "-";
+										const rowBg = isEmpty ? "#fef2f2" : "white";
+										return `
       <tr style="background: ${rowBg};">
         <td style="padding: 10px 12px; border-bottom: 1px solid #e5e7eb; white-space: nowrap;">${isEmpty ? "🚨" : "⚠️"} ${safeName}</td>
         <td style="padding: 10px 12px; border-bottom: 1px solid #e5e7eb; text-align: center; white-space: nowrap; ${isEmpty ? "color: #dc2626; font-weight: 600;" : ""}"><strong>${safeRefills}</strong></td>
         <td style="padding: 10px 12px; border-bottom: 1px solid #e5e7eb; text-align: center; white-space: nowrap;">${safeThreshold}</td>
         <td style="padding: 10px 12px; border-bottom: 1px solid #e5e7eb; text-align: center; white-space: nowrap;">${safeExpiry}</td>
       </tr>`;
-							})
-							.join("");
+									})
+									.join("");
 
-						const html = `
+								const html = `
     <div style="font-family: system-ui, -apple-system, sans-serif; max-width: 100%; margin: 0 auto; padding: 12px; background: #f9fafb;">
       <div style="background: white; border-radius: 12px; padding: 16px; box-shadow: 0 1px 3px rgba(0,0,0,0.1);">
         <h2 style="color: #1f2937; margin: 0 0 8px; font-size: 18px;">${emptyRx.length > 0 ? tr.prescriptionReminder.titleEmpty : tr.prescriptionReminder.title}</h2>
@@ -608,80 +832,85 @@ async function checkAndSendReminderForUser(
       </div>
     </div>
   `;
-						const text = `${emptyRx.length > 0 ? tr.prescriptionReminder.titleEmpty : tr.prescriptionReminder.title}\n\n${bodyText}\n\n${lines.join("\n")}\n\n---\n${getFooterPlain(language)}${settings.repeatDailyReminders ? `\n\n${tr.prescriptionReminder.repeatDailyNote}` : ""}`;
+								const text = `${emptyRx.length > 0 ? tr.prescriptionReminder.titleEmpty : tr.prescriptionReminder.title}\n\n${bodyText}\n\n${lines.join("\n")}\n\n---\n${getFooterPlain(language)}${settings.repeatDailyReminders ? `\n\n${tr.prescriptionReminder.repeatDailyNote}` : ""}`;
 
-						await transporter.sendMail({
-							from: smtpFrom,
-							to: settings.notificationEmail!,
-							subject,
-							text,
-							html,
+								await transporter.sendMail({
+									from: smtpFrom,
+									to: settings.notificationEmail!,
+									subject,
+									text,
+									html,
+								});
+								emailSuccess = true;
+							} catch (error) {
+								const errorMessage = error instanceof Error ? error.message : "Unknown error";
+								logger.error(`[Reminder] User ${settings.userId}: Failed to send prescription email: ${errorMessage}`);
+							}
+						}
+					}
+
+					if (prescriptionPushEnabled) {
+						const titleParts: string[] = [];
+						if (emptyRx.length > 0)
+							titleParts.push(
+								`🚨 ${emptyRx.length} ${emptyRx.length === 1 ? tr.prescriptionReminder.pushEmptySingle : tr.prescriptionReminder.pushEmpty}`
+							);
+						if (lowRx.length > 0)
+							titleParts.push(
+								`🚨 ${lowRx.length} ${lowRx.length === 1 ? tr.prescriptionReminder.pushLowSingle : tr.prescriptionReminder.pushLow}`
+							);
+						const title = `MedAssist-ng: ${titleParts.join(", ")} - ${tr.prescriptionReminder.pushRenewNow}`;
+
+						const messageParts: string[] = [];
+						if (emptyRx.length > 0) {
+							messageParts.push(`🚨 ${tr.prescriptionReminder.pushEmptySection}:`);
+							for (const m of emptyRx) {
+								messageParts.push(`  • ${m.name}`);
+							}
+						}
+						if (lowRx.length > 0) {
+							if (emptyRx.length > 0) messageParts.push("");
+							messageParts.push(`🚨 ${tr.prescriptionReminder.pushLowSection}:`);
+							for (const m of lowRx) {
+								messageParts.push(
+									`  • ${m.name}: ${t(tr.prescriptionReminder.pushRefillsLeft, { count: m.remainingRefills })}`
+								);
+							}
+						}
+						const message = `${messageParts.join("\n")}\n\n---\n${getFooterPlain(language)}`;
+						const result = await sendShoutrrrNotification(settings.shoutrrrUrl!, title, message);
+						shoutrrrSuccess = result.success;
+						if (!result.success) {
+							logger.error(`[Reminder] User ${settings.userId}: Failed to send prescription push: ${result.error}`);
+						}
+					}
+
+					if (emailSuccess || shoutrrrSuccess) {
+						const currentState = loadReminderState();
+						const singleChannel = emailSuccess ? "email" : "push";
+						const channel = emailSuccess && shoutrrrSuccess ? "both" : singleChannel;
+						saveReminderState({
+							lastAutoEmailSent: new Date().toISOString(),
+							lastAutoEmailDate: today,
+							notifiedMedications: [...new Set([...currentState.notifiedMedications, userPrescriptionNotifiedKey])],
+							nextScheduledCheck: currentState.nextScheduledCheck,
+							lastNotificationType: "prescription",
+							lastNotificationChannel: channel,
 						});
-						emailSuccess = true;
-					} catch (error) {
-						const errorMessage = error instanceof Error ? error.message : "Unknown error";
-						logger.error(`[Reminder] User ${settings.userId}: Failed to send prescription email: ${errorMessage}`);
+
+						const medNames = allPrescriptionLow.map((m) => m.name).join(", ");
+						await updateUserReminderSentTime(settings.userId, "prescription", channel, medNames);
 					}
+				} finally {
+					releaseReminderSendLock(prescriptionSendLock);
 				}
 			}
-
-			if (prescriptionPushEnabled) {
-				const titleParts: string[] = [];
-				if (emptyRx.length > 0)
-					titleParts.push(
-						`🚨 ${emptyRx.length} ${emptyRx.length === 1 ? tr.prescriptionReminder.pushEmptySingle : tr.prescriptionReminder.pushEmpty}`
-					);
-				if (lowRx.length > 0)
-					titleParts.push(
-						`🚨 ${lowRx.length} ${lowRx.length === 1 ? tr.prescriptionReminder.pushLowSingle : tr.prescriptionReminder.pushLow}`
-					);
-				const title = `MedAssist-ng: ${titleParts.join(", ")} - ${tr.prescriptionReminder.pushRenewNow}`;
-
-				const messageParts: string[] = [];
-				if (emptyRx.length > 0) {
-					messageParts.push(`🚨 ${tr.prescriptionReminder.pushEmptySection}:`);
-					for (const m of emptyRx) {
-						messageParts.push(`  • ${m.name}`);
-					}
-				}
-				if (lowRx.length > 0) {
-					if (emptyRx.length > 0) messageParts.push("");
-					messageParts.push(`🚨 ${tr.prescriptionReminder.pushLowSection}:`);
-					for (const m of lowRx) {
-						messageParts.push(
-							`  • ${m.name}: ${t(tr.prescriptionReminder.pushRefillsLeft, { count: m.remainingRefills })}`
-						);
-					}
-				}
-				const message = `${messageParts.join("\n")}\n\n---\n${getFooterPlain(language)}`;
-				const result = await sendShoutrrrNotification(settings.shoutrrrUrl!, title, message);
-				shoutrrrSuccess = result.success;
-				if (!result.success) {
-					logger.error(`[Reminder] User ${settings.userId}: Failed to send prescription push: ${result.error}`);
-				}
-			}
-
-			if (emailSuccess || shoutrrrSuccess) {
-				const currentState = loadReminderState();
-				const singleChannel = emailSuccess ? "email" : "push";
-				const channel = emailSuccess && shoutrrrSuccess ? "both" : singleChannel;
-				saveReminderState({
-					lastAutoEmailSent: new Date().toISOString(),
-					lastAutoEmailDate: today,
-					notifiedMedications: [...new Set([...currentState.notifiedMedications, userPrescriptionNotifiedKey])],
-					nextScheduledCheck: currentState.nextScheduledCheck,
-					lastNotificationType: "prescription",
-					lastNotificationChannel: channel,
-				});
-
-				const medNames = allPrescriptionLow.map((m) => m.name).join(", ");
-				await updateUserReminderSentTime(settings.userId, "prescription", channel, medNames);
-			}
 		}
 	}
 }
 
 let schedulerTimeout: NodeJS.Timeout | null = null;
+let schedulerStarted = false;
 
 function scheduleNextCheck(logger: ServiceLogger): void {
 	const msUntilNext = getMsUntilNextCheck(REMINDER_HOUR);
@@ -706,6 +935,11 @@ function scheduleNextCheck(logger: ServiceLogger): void {
 }
 
 export function startReminderScheduler(logger: ServiceLogger): void {
+	if (schedulerStarted) {
+		logger.info(`[Reminder] Scheduler already started, skipping duplicate start call`);
+		return;
+	}
+	schedulerStarted = true;
 	logger.info(`[Reminder] Starting reminder scheduler (timezone: ${getTimezone()})...`);
 
 	// Check if we need to run immediately (missed today's check)
@@ -725,9 +959,15 @@ export function startReminderScheduler(logger: ServiceLogger): void {
 	logger.info(`[Reminder] Scheduler started - daily check at ${REMINDER_HOUR}:00 ${getTimezone()}`);
 }
 
+export async function runReminderSchedulerNow(logger: ServiceLogger): Promise<void> {
+	logger.info(`[Reminder] Manual trigger: running reminder check now (${getTimezone()})`);
+	await checkAndSendReminder(logger);
+}
+
 export function stopReminderScheduler(): void {
 	if (schedulerTimeout) {
 		clearTimeout(schedulerTimeout);
 		schedulerTimeout = null;
 	}
+	schedulerStarted = false;
 }

backend/src/test/e2e-routes.test.ts

@@ -171,6 +171,7 @@ async function createSchema(client: Client) {
       dose_id text NOT NULL,
       taken_at integer NOT NULL DEFAULT (strftime('%s','now')),
       marked_by text,
+		taken_source text NOT NULL DEFAULT 'manual',
       dismissed integer NOT NULL DEFAULT 0,
       FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
     )`,

backend/src/test/export.test.ts

@@ -152,8 +152,8 @@ async function registerExportRoutes(ctx: TestContext) {
 	});
 
 	// POST /import
-	// biome-ignore lint/suspicious/noExplicitAny: test helper with dynamic import data shape
 	app.post("/import", async (request, reply) => {
+		// biome-ignore lint/suspicious/noExplicitAny: test helper with dynamic import data shape
 		const importData = request.body as any;
 
 		// Basic validation

backend/src/test/integration.test.ts

@@ -165,6 +165,7 @@ async function createSchema(client: Client) {
       dose_id text NOT NULL,
       taken_at integer NOT NULL DEFAULT (strftime('%s','now')),
       marked_by text,
+		taken_source text NOT NULL DEFAULT 'manual',
       dismissed integer NOT NULL DEFAULT 0,
       FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
     )`,

backend/src/test/oidc.test.ts

@@ -1,5 +1,5 @@
 import cookie from "@fastify/cookie";
-import Fastify, { type FastifyInstance } from "fastify";
+import Fastify from "fastify";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 type OidcMocks = {

backend/src/test/stock-semantics-parity.test.ts

@@ -0,0 +1,350 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { migrate } from "drizzle-orm/libsql/migrator";
+import Fastify, { type FastifyInstance } from "fastify";
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { runAlterMigrations } from "../db/db-utils.js";
+
+const { testClient, testDb, mockedEnv } = vi.hoisted(() => {
+	const { createClient } = require("@libsql/client");
+	const { drizzle } = require("drizzle-orm/libsql");
+	const client = createClient({ url: ":memory:" });
+	const db = drizzle(client);
+	return {
+		testClient: client,
+		testDb: db,
+		mockedEnv: {
+			AUTH_ENABLED: false,
+			OIDC_ENABLED: false,
+			OIDC_PROVIDER_NAME: "SSO",
+			NODE_ENV: "test",
+		},
+	};
+});
+
+vi.mock("../db/client.js", () => ({
+	db: testDb,
+	migrationsReady: Promise.resolve(),
+}));
+
+vi.mock("../plugins/env.js", () => ({ env: mockedEnv }));
+
+vi.mock("../plugins/auth.js", () => ({
+	requireAuth: async () => {},
+	getAnonymousUserId: async () => 1,
+}));
+
+const { medicationRoutes } = await import("../routes/medications.js");
+const { getMedicationsNeedingReminderForTests } = await import("../services/reminder-scheduler.js");
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const migrationsFolder = resolve(__dirname, "../../drizzle");
+
+async function clearTables() {
+	await testClient.execute("DELETE FROM refill_history");
+	await testClient.execute("DELETE FROM dose_tracking");
+	await testClient.execute("DELETE FROM share_tokens");
+	await testClient.execute("DELETE FROM user_settings");
+	await testClient.execute("DELETE FROM medications");
+	await testClient.execute("DELETE FROM users");
+}
+
+async function seedAnonymousUser() {
+	await testClient.execute({
+		sql: "INSERT INTO users (id, username, auth_provider, is_active) VALUES (?, ?, ?, 1)",
+		args: [1, "anon", "anonymous"],
+	});
+}
+
+async function setStockMode(mode: "automatic" | "manual") {
+	await testClient.execute({
+		sql: `INSERT INTO user_settings (user_id, stock_calculation_mode, reminder_days_before, low_stock_days, language)
+              VALUES (?, ?, 7, 365, 'en')`,
+		args: [1, mode],
+	});
+}
+
+async function createMedication(options: {
+	name: string;
+	packCount?: number;
+	blistersPerPack?: number;
+	pillsPerBlister?: number;
+	looseTablets?: number;
+	stockAdjustment?: number;
+	lastStockCorrectionAt?: number | null;
+	isObsolete?: boolean;
+	takenBy?: string[];
+	intakes: Array<{ usage: number; every: number; start: string; takenBy?: string | null }>;
+}) {
+	const {
+		name,
+		packCount = 1,
+		blistersPerPack = 1,
+		pillsPerBlister = 10,
+		looseTablets = 0,
+		stockAdjustment = 0,
+		lastStockCorrectionAt = null,
+		isObsolete = false,
+		takenBy = [],
+		intakes,
+	} = options;
+
+	const usageJson = JSON.stringify(intakes.map((i) => i.usage));
+	const everyJson = JSON.stringify(intakes.map((i) => i.every));
+	const startJson = JSON.stringify(intakes.map((i) => i.start));
+	const intakesJson = JSON.stringify(
+		intakes.map((i) => ({
+			usage: i.usage,
+			every: i.every,
+			start: i.start,
+			takenBy: i.takenBy ?? null,
+			intakeRemindersEnabled: false,
+		}))
+	);
+
+	const result = await testClient.execute({
+		sql: `INSERT INTO medications (
+        user_id, name, taken_by_json, package_type,
+        pack_count, blisters_per_pack, pills_per_blister, loose_tablets,
+        stock_adjustment, last_stock_correction_at,
+        usage_json, every_json, start_json, intakes_json,
+        is_obsolete, intake_reminders_enabled
+      ) VALUES (?, ?, ?, 'blister', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+      RETURNING id`,
+		args: [
+			1,
+			name,
+			JSON.stringify(takenBy),
+			packCount,
+			blistersPerPack,
+			pillsPerBlister,
+			looseTablets,
+			stockAdjustment,
+			lastStockCorrectionAt,
+			usageJson,
+			everyJson,
+			startJson,
+			intakesJson,
+			isObsolete ? 1 : 0,
+		],
+	});
+
+	return Number(result.rows[0].id);
+}
+
+async function markDoseTaken(options: {
+	medicationId: number;
+	blisterIdx: number;
+	doseDateOnlyMs: number;
+	takenAtMs: number;
+	personSuffix?: string;
+}) {
+	const { medicationId, blisterIdx, doseDateOnlyMs, takenAtMs, personSuffix } = options;
+	const baseId = `${medicationId}-${blisterIdx}-${doseDateOnlyMs}`;
+	const doseId = personSuffix ? `${baseId}-${personSuffix}` : baseId;
+	await testClient.execute({
+		sql: "INSERT INTO dose_tracking (user_id, dose_id, taken_at, dismissed) VALUES (?, ?, ?, 0)",
+		args: [1, doseId, Math.floor(takenAtMs / 1000)],
+	});
+}
+
+async function getUsageRow(app: FastifyInstance, startDate: string, endDate: string, medicationName: string) {
+	const response = await app.inject({
+		method: "POST",
+		url: "/medications/usage",
+		payload: { startDate, endDate },
+	});
+
+	expect(response.statusCode).toBe(200);
+	const rows = response.json();
+	const row = rows.find((r: { medicationName: string }) => r.medicationName === medicationName);
+	expect(row).toBeDefined();
+	return row;
+}
+
+function toDateOnlyMs(date: Date) {
+	return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+
+describe("Stock semantics parity (planner usage vs scheduler)", () => {
+	let app: FastifyInstance;
+
+	beforeAll(async () => {
+		await migrate(testDb, { migrationsFolder });
+		await runAlterMigrations(testClient);
+		app = Fastify({ logger: false });
+		await app.register(medicationRoutes);
+		await app.ready();
+	});
+
+	afterAll(async () => {
+		await app.close();
+		testClient.close();
+	});
+
+	beforeEach(async () => {
+		await clearTables();
+		await seedAnonymousUser();
+	});
+
+	it("keeps automatic mode current stock in sync", async () => {
+		await setStockMode("automatic");
+		const medName = "Auto Sync";
+		await createMedication({
+			name: medName,
+			packCount: 1,
+			blistersPerPack: 1,
+			pillsPerBlister: 10,
+			intakes: [{ usage: 1, every: 1, start: "2026-01-01T08:00:00" }],
+		});
+
+		const usageRow = await getUsageRow(app, "2026-01-01T00:00:00.000Z", "2026-01-31T23:59:59.999Z", medName);
+		const lowStock = await getMedicationsNeedingReminderForTests(1, 7, 365, "en", "automatic");
+		const schedulerRow = lowStock.find((r) => r.name === medName);
+
+		expect(schedulerRow).toBeDefined();
+		expect(usageRow.currentPills).toBe(usageRow.totalPills);
+		expect(usageRow.currentPills).toBe(schedulerRow!.medsLeft);
+	});
+
+	it("keeps manual mode current stock in sync and does not auto-consume", async () => {
+		await setStockMode("manual");
+		const medName = "Manual Sync";
+		await createMedication({
+			name: medName,
+			packCount: 1,
+			blistersPerPack: 1,
+			pillsPerBlister: 10,
+			intakes: [{ usage: 1, every: 1, start: "2026-01-01T08:00:00" }],
+		});
+
+		const usageRow = await getUsageRow(app, "2026-01-01T00:00:00.000Z", "2026-01-31T23:59:59.999Z", medName);
+		const lowStock = await getMedicationsNeedingReminderForTests(1, 7, 365, "en", "manual");
+		const schedulerRow = lowStock.find((r) => r.name === medName);
+
+		expect(schedulerRow).toBeDefined();
+		expect(usageRow.currentPills).toBe(10);
+		expect(usageRow.currentPills).toBe(schedulerRow!.medsLeft);
+	});
+
+	it("respects lastStockCorrectionAt cutoff in manual mode by takenAt", async () => {
+		await setStockMode("manual");
+		const medName = "Manual Correction";
+		const correctionMs = new Date("2026-01-05T12:00:00.000Z").getTime();
+		const medicationId = await createMedication({
+			name: medName,
+			packCount: 1,
+			blistersPerPack: 1,
+			pillsPerBlister: 10,
+			lastStockCorrectionAt: correctionMs,
+			intakes: [{ usage: 1, every: 1, start: "2026-01-01T08:00:00" }],
+		});
+
+		const jan5DateOnly = toDateOnlyMs(new Date("2026-01-05T00:00:00.000Z"));
+		const jan6DateOnly = toDateOnlyMs(new Date("2026-01-06T00:00:00.000Z"));
+
+		await markDoseTaken({
+			medicationId,
+			blisterIdx: 0,
+			doseDateOnlyMs: jan5DateOnly,
+			takenAtMs: new Date("2026-01-05T10:00:00.000Z").getTime(),
+		});
+		await markDoseTaken({
+			medicationId,
+			blisterIdx: 0,
+			doseDateOnlyMs: jan6DateOnly,
+			takenAtMs: new Date("2026-01-06T10:00:00.000Z").getTime(),
+		});
+
+		const usageRow = await getUsageRow(app, "2026-01-01T00:00:00.000Z", "2026-01-31T23:59:59.999Z", medName);
+		const lowStock = await getMedicationsNeedingReminderForTests(1, 7, 365, "en", "manual");
+		const schedulerRow = lowStock.find((r) => r.name === medName);
+
+		expect(schedulerRow).toBeDefined();
+		expect(usageRow.currentPills).toBe(schedulerRow!.medsLeft);
+	});
+
+	it("counts early taken dose in automatic mode without drift", async () => {
+		await setStockMode("automatic");
+		const medName = "Early Taken";
+		const now = new Date();
+		const tomorrow = new Date(now);
+		tomorrow.setDate(now.getDate() + 1);
+		tomorrow.setHours(20, 0, 0, 0);
+		const medicationId = await createMedication({
+			name: medName,
+			packCount: 1,
+			blistersPerPack: 1,
+			pillsPerBlister: 10,
+			intakes: [{ usage: 1, every: 1, start: tomorrow.toISOString().slice(0, 19) }],
+		});
+
+		const tomorrowDateOnly = toDateOnlyMs(tomorrow);
+		await markDoseTaken({
+			medicationId,
+			blisterIdx: 0,
+			doseDateOnlyMs: tomorrowDateOnly,
+			takenAtMs: now.getTime(),
+		});
+
+		const rangeStart = new Date(now);
+		rangeStart.setDate(now.getDate() - 1);
+		const rangeEnd = new Date(now);
+		rangeEnd.setDate(now.getDate() + 7);
+		const usageRow = await getUsageRow(app, rangeStart.toISOString(), rangeEnd.toISOString(), medName);
+		const lowStock = await getMedicationsNeedingReminderForTests(1, 7, 365, "en", "automatic");
+		const schedulerRow = lowStock.find((r) => r.name === medName);
+
+		expect(schedulerRow).toBeDefined();
+		expect(usageRow.currentPills).toBe(9);
+		expect(usageRow.currentPills).toBe(schedulerRow!.medsLeft);
+	});
+
+	it("handles mixed intake-level and fallback takenBy consistently", async () => {
+		await setStockMode("automatic");
+		const medName = "Mixed TakenBy";
+		await createMedication({
+			name: medName,
+			packCount: 2,
+			blistersPerPack: 1,
+			pillsPerBlister: 10,
+			takenBy: ["Alice", "Bob"],
+			intakes: [
+				{ usage: 1, every: 1, start: "2026-01-01T08:00:00", takenBy: "Alice" },
+				{ usage: 1, every: 1, start: "2026-01-01T20:00:00", takenBy: null },
+			],
+		});
+
+		const usageRow = await getUsageRow(app, "2026-01-01T00:00:00.000Z", "2026-01-31T23:59:59.999Z", medName);
+		const lowStock = await getMedicationsNeedingReminderForTests(1, 7, 365, "en", "automatic");
+		const schedulerRow = lowStock.find((r) => r.name === medName);
+
+		expect(schedulerRow).toBeDefined();
+		expect(usageRow.currentPills).toBe(schedulerRow!.medsLeft);
+		expect(usageRow.currentPills).toBeLessThan(20);
+	});
+
+	it("excludes obsolete medications from planner usage and scheduler", async () => {
+		await setStockMode("automatic");
+		await createMedication({
+			name: "Obsolete Med",
+			isObsolete: true,
+			packCount: 1,
+			blistersPerPack: 1,
+			pillsPerBlister: 10,
+			intakes: [{ usage: 1, every: 1, start: "2026-01-01T08:00:00" }],
+		});
+
+		const response = await app.inject({
+			method: "POST",
+			url: "/medications/usage",
+			payload: { startDate: "2026-01-01T00:00:00.000Z", endDate: "2026-01-31T23:59:59.999Z" },
+		});
+		expect(response.statusCode).toBe(200);
+		expect(response.json().some((r: { medicationName: string }) => r.medicationName === "Obsolete Med")).toBe(false);
+
+		const lowStock = await getMedicationsNeedingReminderForTests(1, 7, 365, "en", "automatic");
+		expect(lowStock.some((r) => r.name === "Obsolete Med")).toBe(false);
+	});
+});

frontend/e2e/fixtures/index.ts

@@ -70,7 +70,7 @@ async function setupAuthMeMock(page: Page): Promise<void> {
  * auth.spec.ts should keep importing from `@playwright/test` directly
  * since it tests the unauthenticated flow.
  */
-export const test = base.extend<{}>({
+export const test = base.extend<object>({
 	page: async ({ page }, use) => {
 		await setupAuthMeMock(page);
 		await use(page);

frontend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "medassist-ng-frontend",
-  "version": "1.12.0",
+  "version": "1.14.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "medassist-ng-frontend",
-      "version": "1.12.0",
+      "version": "1.14.2",
       "dependencies": {
         "i18next": "^25.8.10",
         "i18next-browser-languagedetector": "^8.2.1",
@@ -23,6 +23,7 @@
         "@testing-library/jest-dom": "^6.9.1",
         "@testing-library/react": "^16.3.2",
         "@testing-library/user-event": "^14.6.1",
+        "@types/node": "^25.3.0",
         "@types/react": "^18.3.4",
         "@types/react-dom": "^18.3.0",
         "@types/react-router-dom": "^5.3.3",
@@ -1735,6 +1736,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/node": {
+      "version": "25.3.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.3.0.tgz",
+      "integrity": "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.18.0"
+      }
+    },
     "node_modules/@types/prop-types": {
       "version": "15.7.15",
       "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
@@ -3302,6 +3313,13 @@
         "node": ">=20.18.1"
       }
     },
+    "node_modules/undici-types": {
+      "version": "7.18.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/update-browserslist-db": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",

frontend/package.json

@@ -1,7 +1,7 @@
 {
   "name": "medassist-ng-frontend",
   "private": true,
-  "version": "1.12.0",
+  "version": "1.14.3",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -40,6 +40,7 @@
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
+    "@types/node": "^25.3.0",
     "@types/react": "^18.3.4",
     "@types/react-dom": "^18.3.0",
     "@types/react-router-dom": "^5.3.3",

frontend/src/App.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useState } from "react";
+import { useCallback, useEffect, useState } from "react";
 import { Navigate, Route, Routes, useNavigate } from "react-router-dom";
 import {
 	AboutModal,
@@ -119,8 +119,6 @@ function AppContent() {
 		// Medications
 		meds,
 		loadMeds,
-		// Settings
-		settings,
 		// Refill
 		showRefillModal,
 		setShowRefillModal,
@@ -190,6 +188,17 @@ function AppContent() {
 	// Local-only state (not shared across components)
 	const [showProfile, setShowProfile] = useState(false);
 	const [showAbout, setShowAbout] = useState(false);
+	const closeProfile = useCallback(() => {
+		if (showProfile) {
+			window.history.back();
+		}
+	}, [showProfile]);
+
+	const closeAbout = useCallback(() => {
+		if (showAbout) {
+			window.history.back();
+		}
+	}, [showAbout]);
 
 	// Get centralized stockThresholds from context
 	const { stockThresholds } = ctx;
@@ -389,25 +398,15 @@ function AppContent() {
 		openEditStockModal(selectedMed, coverage);
 	};
 
-	function openProfile() {
+	const openProfile = useCallback(() => {
 		setShowProfile(true);
 		window.history.pushState({ modal: "profile" }, "");
-	}
-	function closeProfile() {
-		if (showProfile) {
-			window.history.back();
-		}
-	}
+	}, []);
 
-	function openAbout() {
+	const openAbout = useCallback(() => {
 		setShowAbout(true);
 		window.history.pushState({ modal: "about" }, "");
-	}
-	function closeAbout() {
-		if (showAbout) {
-			window.history.back();
-		}
-	}
+	}, []);
 
 	return (
 		<main className="page">

frontend/src/components/Auth.tsx

@@ -1,3 +1,4 @@
+/* biome-ignore-all lint/correctness/useExhaustiveDependencies: auth refresh callbacks intentionally coordinate via refs/guards */
 import { createContext, type ReactNode, useCallback, useContext, useEffect, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { log } from "../utils/logger";
@@ -70,7 +71,7 @@ export function AuthProvider({ children }: { children: ReactNode }) {
 		initialFetchDone.current = true;
 		fetchAuthState();
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, []);
+	}, [fetchAuthState]);
 
 	// Proactively refresh token every 10 minutes to prevent expiration
 	useEffect(() => {
@@ -89,7 +90,7 @@ export function AuthProvider({ children }: { children: ReactNode }) {
 
 		return () => clearInterval(refreshInterval);
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [user, authState?.authEnabled]);
+	}, [user, authState?.authEnabled, refreshUser, tryRefreshToken]);
 
 	async function fetchAuthState(retryCount = 0) {
 		const maxRetries = 3;
@@ -756,7 +757,7 @@ export function UserProfile({ onClose }: { onClose?: () => void }) {
 
 				<div className="profile-actions">
 					<button type="button" className="btn btn-ghost" onClick={onClose}>
-						{t("common.cancel", "Cancel")}
+						{t("common.close", "Close")}
 					</button>
 					<button type="submit" className="btn btn-primary" disabled={loading || !hasChanges}>
 						{loading ? t("common.saving", "Saving...") : t("auth.updatePassword", "Update Password")}

frontend/src/components/ConfirmModal.tsx

@@ -47,7 +47,7 @@ export function ConfirmModal({
 			}}
 		>
 			<div
-				className="modal-content"
+				className="modal-content confirm-modal"
 				onClick={(e) => e.stopPropagation()}
 				onKeyDown={(e) => e.stopPropagation()}
 				style={{ maxWidth: "450px" }}

frontend/src/components/ExportModal.tsx

@@ -64,7 +64,7 @@ export default function ExportModal({ isOpen, onClose, onExport, exporting }: Ex
 				</div>
 				<div className="modal-footer" style={{ padding: "1rem 0 0 0", borderTop: "none", justifyContent: "flex-end" }}>
 					<button type="button" className="ghost" onClick={onClose}>
-						{t("exportImport.cancelButton")}
+						{t("common.close")}
 					</button>
 				</div>
 			</div>

frontend/src/components/Lightbox.tsx

@@ -3,7 +3,6 @@
 // =============================================================================
 
 import type { MouseEvent } from "react";
-import { useEffect } from "react";
 
 export interface LightboxProps {
 	src: string;
@@ -12,17 +11,6 @@ export interface LightboxProps {
 }
 
 export function Lightbox({ src, alt, onClose }: LightboxProps) {
-	useEffect(() => {
-		const handleKeyDown = (event: KeyboardEvent) => {
-			if (event.key === "Escape") {
-				onClose();
-			}
-		};
-
-		document.addEventListener("keydown", handleKeyDown);
-		return () => document.removeEventListener("keydown", handleKeyDown);
-	}, [onClose]);
-
 	function handleOverlayClick(e: MouseEvent) {
 		e.stopPropagation();
 		if (e.target === e.currentTarget) {
@@ -31,7 +19,16 @@ export function Lightbox({ src, alt, onClose }: LightboxProps) {
 	}
 
 	return (
-		<div className="lightbox-overlay" onClick={handleOverlayClick}>
+		<div
+			className="lightbox-overlay"
+			onClick={handleOverlayClick}
+			onKeyDown={(e) => {
+				if (e.key === "Escape") {
+					e.stopPropagation();
+					onClose();
+				}
+			}}
+		>
 			<div className="lightbox-container">
 				<button className="lightbox-close" onClick={onClose}>
 					×

frontend/src/components/MedDetailModal.tsx

@@ -6,6 +6,8 @@
  * 1. Context mode: Uses useAppContext() for all state (when no props provided)
  * 2. Props mode: Accepts all required data as props (for gradual adoption)
  */
+/* biome-ignore-all lint/a11y/noLabelWithoutControl: modal uses label-styled wrappers with custom interactive rows */
+/* biome-ignore-all lint/style/noNestedTernary: stock/preview rendering keeps explicit branch mapping */
 
 import { Bell, Calendar, ClipboardList, FilePenLine, Minus, NotebookPen, Pencil, Plus, X } from "lucide-react";
 import { useEffect, useRef, useState } from "react";
@@ -15,31 +17,12 @@ import type { Coverage, Medication, RefillEntry, StockThresholds } from "../type
 import { getMedTotal, getPackageSize } from "../types";
 import { formatNumber, generateICS, getExpiryClass, getSystemLocale } from "../utils";
 import { getStockStatus } from "../utils/schedule";
+import { splitCurrentBlisterStock } from "../utils/stock";
 
 // =============================================================================
 // Local Helper Functions
 // =============================================================================
 
-/**
- * Calculate blister stock - divides current pills into full blisters and partial
- */
-function getBlisterStock(
-	currentPills: number,
-	pillsPerBlister: number,
-	originalLooseTablets: number,
-	_originalTotalPills: number
-): { fullBlisters: number; openBlisterPills: number; loosePills: number } {
-	if (pillsPerBlister <= 0 || pillsPerBlister === 1) {
-		return { fullBlisters: 0, openBlisterPills: 0, loosePills: currentPills };
-	}
-	const safeCurrent = Math.max(0, currentPills);
-	const loosePills = Math.min(safeCurrent, Math.max(0, originalLooseTablets));
-	const sealedPills = Math.max(0, safeCurrent - loosePills);
-	const fullBlisters = Math.floor(sealedPills / pillsPerBlister);
-	const openBlisterPills = sealedPills % pillsPerBlister;
-	return { fullBlisters, openBlisterPills, loosePills };
-}
-
 /**
  * Format full blisters column
  */
@@ -230,14 +213,12 @@ export function MedDetailModal({
 	const status = medCoverage ? getStockStatus(medCoverage.daysLeft, medCoverage.medsLeft, settings) : null;
 	const fallbackTextClass = status?.className === "warning" ? "warning-text" : "success-text";
 	const textClass = status?.className === "danger" ? "danger-text" : fallbackTextClass;
-	const stock = getBlisterStock(currentStock, selectedMed.pillsPerBlister, selectedMed.looseTablets, packageSize);
+	const stock = splitCurrentBlisterStock(currentStock, selectedMed.pillsPerBlister, selectedMed.looseTablets);
 	const currentFullBlisters = Math.max(0, stock.fullBlisters);
 	const currentPartialPills = Math.max(0, stock.openBlisterPills);
 	const currentLoosePills = Math.max(0, stock.loosePills);
-	const pillsPerPack = Math.max(1, selectedMed.blistersPerPack * selectedMed.pillsPerBlister);
-	const remainingPacks = Math.max(0, Math.ceil(Math.max(0, currentStock) / pillsPerPack));
 	const stockDisplayTotal =
-		selectedMed.packageType === "bottle" ? (selectedMed.totalPills ?? packageSize) : Math.max(0, currentStock);
+		selectedMed.packageType === "bottle" ? (selectedMed.totalPills ?? packageSize) : Math.max(0, structuralMax);
 	const maxPartialPills = Math.min(
 		Math.max(0, selectedMed.pillsPerBlister),
 		Math.max(0, structuralMax - Math.max(0, editStockFullBlisters) * selectedMed.pillsPerBlister)
@@ -495,7 +476,7 @@ export function MedDetailModal({
 														const rawFull = raw === "" ? 0 : Math.max(0, parseStockInput(raw));
 														const rawPartial = Math.max(0, parseStockInput(editStockPartialInput));
 														const rawLoose = Math.max(0, parseStockInput(editStockLooseInput));
-														const rawTotal = rawFull * selectedMed.pillsPerBlister + rawPartial + rawLoose;
+														const _rawTotal = rawFull * selectedMed.pillsPerBlister + rawPartial + rawLoose;
 														setEditStockFullInput(raw);
 														const normalized = normalizeBlisterStock(rawFull, rawPartial, rawLoose);
 														onEditStockFullBlistersChange(normalized.full);
@@ -524,7 +505,7 @@ export function MedDetailModal({
 														const rawFull = Math.max(0, parseStockInput(editStockFullInput) + delta);
 														const rawPartial = Math.max(0, parseStockInput(editStockPartialInput));
 														const rawLoose = Math.max(0, parseStockInput(editStockLooseInput));
-														const rawTotal = rawFull * selectedMed.pillsPerBlister + rawPartial + rawLoose;
+														const _rawTotal = rawFull * selectedMed.pillsPerBlister + rawPartial + rawLoose;
 														const normalized = normalizeBlisterStock(rawFull, rawPartial, rawLoose);
 														onEditStockFullBlistersChange(normalized.full);
 														onEditStockPartialBlisterPillsChange(normalized.partial);
@@ -581,7 +562,7 @@ export function MedDetailModal({
 														const nextPartial = Math.max(0, parseStockInput(editStockPartialInput) + delta);
 														const nextFull = Math.max(0, parseStockInput(editStockFullInput));
 														const nextLoose = Math.max(0, parseStockInput(editStockLooseInput));
-														const rawTotal = nextFull * selectedMed.pillsPerBlister + nextPartial + nextLoose;
+														const _rawTotal = nextFull * selectedMed.pillsPerBlister + nextPartial + nextLoose;
 														const normalized = normalizeBlisterStock(nextFull, nextPartial, nextLoose);
 														onEditStockFullBlistersChange(normalized.full);
 														onEditStockPartialBlisterPillsChange(normalized.partial);
@@ -647,7 +628,7 @@ export function MedDetailModal({
 
 					<div className="modal-footer">
 						<button className="ghost" onClick={onCloseEditStockModal}>
-							{t("common.cancel")}
+							{t("common.close")}
 						</button>
 						<button className="info" onClick={() => onSubmitStockCorrection(selectedMed.id)} disabled={editStockSaving}>
 							{editStockSaving ? t("editStock.saving") : t("editStock.save")}
@@ -667,8 +648,11 @@ export function MedDetailModal({
 			className="modal-overlay med-detail-overlay"
 			onClick={onClose}
 			onKeyDown={(e) => {
-				if (showEditStockModal) return;
-				if (e.key === "Escape") onClose();
+				if (showEditStockModal || showImageLightbox || showRefillModal) return;
+				if (e.key === "Escape") {
+					e.stopPropagation();
+					onClose();
+				}
 			}}
 		>
 			<div
@@ -782,7 +766,7 @@ export function MedDetailModal({
 								<>
 									<div className="med-detail-item">
 										<span className="med-detail-label">{t("modal.packs")}</span>
-										<span className="med-detail-value">{remainingPacks}</span>
+										<span className="med-detail-value">{selectedMed.packCount}</span>
 									</div>
 									<div className="med-detail-item">
 										<span className="med-detail-label">{t("modal.blistersPerPack")}</span>
@@ -824,6 +808,72 @@ export function MedDetailModal({
 						</div>
 					</div>
 
+					{/* Intake Schedule Section */}
+					{selectedMed.blisters.length > 0 && (
+						<div className="med-detail-section">
+							<h3>
+								{t("modal.intakeSchedule")}{" "}
+								{selectedMed.intakeRemindersEnabled && (
+									<span className="reminder-icon info-tooltip" data-tooltip={t("tooltips.intakeReminders")}>
+										<Bell size={14} aria-hidden="true" />
+									</span>
+								)}
+							</h3>
+							<div className="med-detail-schedules">
+								{(selectedMed.intakes && selectedMed.intakes.length > 0
+									? selectedMed.intakes
+									: selectedMed.blisters.map((blister) => ({
+											usage: blister.usage,
+											every: blister.every,
+											start: blister.start,
+											takenBy: null,
+											intakeRemindersEnabled: selectedMed.intakeRemindersEnabled ?? false,
+										}))
+								).map((intake, idx) => {
+									const hasPerIntakeTakenBy = !!intake.takenBy;
+									const personCount = Math.max(1, selectedMed.takenBy?.length ?? 0);
+									const totalUsage = hasPerIntakeTakenBy ? intake.usage : intake.usage * personCount;
+									const showIntakeBell = intake.intakeRemindersEnabled ?? selectedMed.intakeRemindersEnabled ?? false;
+
+									return (
+										<div key={`${intake.start}-${intake.usage}-${intake.every}-${idx}`} className="med-schedule-item">
+											<span className="med-schedule-usage">
+												{totalUsage} {totalUsage !== 1 ? t("common.pills") : t("common.pill")}
+												{selectedMed.pillWeightMg &&
+													` (${totalUsage * selectedMed.pillWeightMg} ${selectedMed.doseUnit ?? "mg"})`}
+											</span>
+											<span className="med-schedule-freq">
+												{intake.every === 1 ? t("common.daily") : t("common.everyNDays", { count: intake.every })}
+											</span>
+											{hasPerIntakeTakenBy && (
+												<span className="med-schedule-person">
+													{intake.takenBy}
+													{showIntakeBell && (
+														<span className="med-schedule-bell" role="img" aria-label={t("tooltips.intakeReminders")}>
+															<Bell size={13} aria-hidden="true" />
+														</span>
+													)}
+												</span>
+											)}
+											{!hasPerIntakeTakenBy && showIntakeBell && (
+												<span className="med-schedule-bell" role="img" aria-label={t("tooltips.intakeReminders")}>
+													<Bell size={13} aria-hidden="true" />
+												</span>
+											)}
+											<span className="med-schedule-time">
+												{t("modal.at")}{" "}
+												{new Date(intake.start).toLocaleTimeString(getSystemLocale(i18n.language), {
+													hour: "2-digit",
+													minute: "2-digit",
+												})}
+											</span>
+										</div>
+									);
+								})}
+							</div>
+						</div>
+					)}
+
 					{/* Prescription Details Section */}
 					{selectedMed.prescriptionEnabled && (
 						<div className="med-detail-section">
@@ -860,50 +910,6 @@ export function MedDetailModal({
 						</div>
 					)}
 
-					{/* Intake Schedule Section */}
-					{selectedMed.blisters.length > 0 && (
-						<div className="med-detail-section">
-							<h3>
-								{t("modal.intakeSchedule")}{" "}
-								{selectedMed.intakeRemindersEnabled && (
-									<span className="reminder-icon info-tooltip" data-tooltip={t("tooltips.intakeReminders")}>
-										<Bell size={14} aria-hidden="true" />
-									</span>
-								)}
-							</h3>
-							<div className="med-detail-schedules">
-								{selectedMed.blisters.map((blister, idx) => {
-									// When using new intakes format with per-intake takenBy,
-									// each intake already represents one person's dose — don't multiply.
-									// For legacy intakes (no per-intake takenBy), multiply by personCount.
-									const intake = selectedMed.intakes?.[idx];
-									const hasPerIntakeTakenBy = !!intake?.takenBy;
-									const personCount = hasPerIntakeTakenBy ? 1 : Math.max(1, selectedMed.takenBy?.length || 1);
-									const totalUsage = blister.usage * personCount;
-									return (
-										<div key={idx} className="med-schedule-item">
-											<span className="med-schedule-usage">
-												{totalUsage} {totalUsage !== 1 ? t("common.pills") : t("common.pill")}
-												{selectedMed.pillWeightMg &&
-													` (${totalUsage * selectedMed.pillWeightMg} ${selectedMed.doseUnit ?? "mg"})`}
-											</span>
-											<span className="med-schedule-freq">
-												{blister.every === 1 ? t("common.daily") : t("common.everyNDays", { count: blister.every })}
-											</span>
-											<span className="med-schedule-time">
-												{t("modal.at")}{" "}
-												{new Date(blister.start).toLocaleTimeString(getSystemLocale(i18n.language), {
-													hour: "2-digit",
-													minute: "2-digit",
-												})}
-											</span>
-										</div>
-									);
-								})}
-							</div>
-						</div>
-					)}
-
 					{/* Coverage Status Section */}
 					{medCoverage && status && (
 						<div className="med-detail-section">
@@ -930,10 +936,10 @@ export function MedDetailModal({
 					{selectedMed.notes && (
 						<div className="med-detail-section">
 							<h3>
+								{t("modal.notes")}{" "}
 								<span className="notes-icon notes-icon-static" aria-hidden="true">
 									<NotebookPen size={14} />
-								</span>{" "}
-								{t("modal.notes")}
+								</span>
 							</h3>
 							<div className="med-notes-content">{selectedMed.notes}</div>
 						</div>
@@ -990,44 +996,45 @@ export function MedDetailModal({
 							)}
 						</div>
 					)}
-					{/* Footer */}
-					<div className="med-detail-footer">
-						<button onClick={onClose}>{t("common.close")}</button>
-						<div className="footer-actions">
-							<button className="success" onClick={onOpenRefillModal}>
-								{t("refill.button")}
+				</div>
+
+				{/* Footer */}
+				<div className="med-detail-footer">
+					<button onClick={onClose}>{t("common.close")}</button>
+					<div className="footer-actions">
+						<button className="success" onClick={onOpenRefillModal}>
+							{t("refill.button")}
+						</button>
+						{onOpenMedicationEdit && (
+							<button
+								className="info icon-only tooltip-trigger"
+								onClick={onOpenMedicationEdit}
+								aria-label={t("common.edit")}
+								data-tooltip={t("common.edit")}
+							>
+								<Pencil size={18} aria-hidden="true" />
 							</button>
-							{onOpenMedicationEdit && (
-								<button
-									className="info icon-only tooltip-trigger"
-									onClick={onOpenMedicationEdit}
-									aria-label={t("common.edit")}
-									data-tooltip={t("common.edit")}
-								>
-									<Pencil size={18} aria-hidden="true" />
-								</button>
-							)}
-							{onOpenEditStockModal && (
-								<button
-									className="icon-stock-correction icon-only tooltip-trigger"
-									onClick={onOpenEditStockModal}
-									aria-label={t("editStock.buttonLabel")}
-									data-tooltip={t("editStock.buttonLabel")}
-								>
-									<FilePenLine size={18} aria-hidden="true" />
-								</button>
-							)}
-							{selectedMed.blisters.length > 0 && (
-								<button
-									className="secondary icon-only tooltip-trigger"
-									onClick={() => generateICS(selectedMed)}
-									aria-label={t("modal.exportTooltip")}
-									data-tooltip={t("modal.exportTooltip")}
-								>
-									<Calendar size={18} aria-hidden="true" />
-								</button>
-							)}
-						</div>
+						)}
+						{onOpenEditStockModal && (
+							<button
+								className="icon-stock-correction icon-only tooltip-trigger"
+								onClick={onOpenEditStockModal}
+								aria-label={t("editStock.buttonLabel")}
+								data-tooltip={t("editStock.buttonLabel")}
+							>
+								<FilePenLine size={18} aria-hidden="true" />
+							</button>
+						)}
+						{selectedMed.blisters.length > 0 && (
+							<button
+								className="secondary icon-only tooltip-trigger"
+								onClick={() => generateICS(selectedMed)}
+								aria-label={t("modal.exportTooltip")}
+								data-tooltip={t("modal.exportTooltip")}
+							>
+								<Calendar size={18} aria-hidden="true" />
+							</button>
+						)}
 					</div>
 				</div>
 			</div>
@@ -1131,7 +1138,7 @@ export function MedDetailModal({
 
 						<div className="modal-footer">
 							<button className="ghost" onClick={onCloseRefillModal}>
-								{t("common.cancel")}
+								{t("common.close")}
 							</button>
 							<div className="refill-footer-right">
 								<button

frontend/src/components/ReportModal.tsx

@@ -16,6 +16,7 @@ type ReportData = Record<
 	number,
 	{
 		dosesTaken: number;
+		automaticDosesTaken: number;
 		dosesDismissed: number;
 		firstDoseAt: string | null;
 		lastDoseAt: string | null;
@@ -256,7 +257,7 @@ export function ReportModal({ isOpen, onClose, medications }: ReportModalProps)
 				{/* Actions */}
 				<div className="report-actions">
 					<button type="button" className="ghost" onClick={onClose}>
-						{t("common.cancel")}
+						{t("common.close")}
 					</button>
 					<button
 						type="button"
@@ -382,6 +383,9 @@ function generateTextReport(
 			lines.push(h3(t("report.docIntakeHistory")));
 			if (data.dosesTaken > 0 || data.dosesDismissed > 0) {
 				lines.push(item(t("report.docDosesTaken"), String(data.dosesTaken)));
+				if (data.automaticDosesTaken > 0) {
+					lines.push(item(`🤖 ${t("report.docDosesTakenAutomatic")}`, String(data.automaticDosesTaken)));
+				}
 				if (data.dosesDismissed > 0) lines.push(item(t("report.docDosesDismissed"), String(data.dosesDismissed)));
 				if (data.firstDoseAt) lines.push(item(t("report.docFirstDose"), fmtDate(data.firstDoseAt)));
 				if (data.lastDoseAt) lines.push(item(t("report.docLastDose"), fmtDate(data.lastDoseAt)));
@@ -580,6 +584,9 @@ function buildPrintHtml(
 			if (data.dosesTaken > 0 || data.dosesDismissed > 0) {
 				s += `<table><tbody>`;
 				s += `<tr><td class="label">${escHtml(t("report.docDosesTaken"))}</td><td>${data.dosesTaken}</td></tr>`;
+				if (data.automaticDosesTaken > 0) {
+					s += `<tr><td class="label">${escHtml(`🤖 ${t("report.docDosesTakenAutomatic")}`)}</td><td>${data.automaticDosesTaken}</td></tr>`;
+				}
 				if (data.dosesDismissed > 0)
 					s += `<tr><td class="label">${escHtml(t("report.docDosesDismissed"))}</td><td>${data.dosesDismissed}</td></tr>`;
 				if (data.firstDoseAt)

frontend/src/components/ShareDialog.tsx

@@ -124,8 +124,12 @@ export function ShareDialog({
 					return (
 						<div className="share-dialog-form">
 							<div className="form-group">
-								<label>{t("share.selectPerson")}</label>
-								<select value={shareSelectedPerson} onChange={(e) => onShareSelectedPersonChange(e.target.value)}>
+								<label htmlFor="share-person-select">{t("share.selectPerson")}</label>
+								<select
+									id="share-person-select"
+									value={shareSelectedPerson}
+									onChange={(e) => onShareSelectedPersonChange(e.target.value)}
+								>
 									{sharePeople.map((person) => (
 										<option key={person} value={person}>
 											{person}
@@ -135,8 +139,12 @@ export function ShareDialog({
 							</div>
 
 							<div className="form-group">
-								<label>{t("share.selectPeriod")}</label>
-								<select value={shareSelectedDays} onChange={(e) => onShareSelectedDaysChange(Number(e.target.value))}>
+								<label htmlFor="share-period-select">{t("share.selectPeriod")}</label>
+								<select
+									id="share-period-select"
+									value={shareSelectedDays}
+									onChange={(e) => onShareSelectedDaysChange(Number(e.target.value))}
+								>
 									<option value={30}>{t("dashboard.schedules.1month")}</option>
 									<option value={90}>{t("dashboard.schedules.3months")}</option>
 									<option value={180}>{t("dashboard.schedules.6months")}</option>
@@ -145,7 +153,7 @@ export function ShareDialog({
 
 							<div className="share-dialog-footer">
 								<button className="ghost" onClick={onClose}>
-									{t("common.cancel")}
+									{t("common.close")}
 								</button>
 								<button onClick={onGenerateShareLink} disabled={shareGenerating || !shareSelectedPerson}>
 									{shareGenerating ? t("share.generating") : t("share.generateLink")}

frontend/src/components/SharedSchedule.tsx

@@ -1,6 +1,8 @@
 // =============================================================================
 // SharedSchedule Component - Public view for shared schedules
 // =============================================================================
+/* biome-ignore-all lint/style/noNestedTernary: rendering branches are intentionally explicit in schedule UI */
+/* biome-ignore-all lint/correctness/useExhaustiveDependencies: modal and helper callbacks are stable at runtime */
 
 import { useEffect, useMemo, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";

frontend/src/components/UserFilterModal.tsx

@@ -98,13 +98,14 @@ export function UserFilterModal({
 									{med.genericName && <span className="user-med-generic">{med.genericName}</span>}
 									{personIntakes.length > 0 && (
 										<div className="user-med-intakes">
-											{personIntakes.map((intake, idx) => {
+											{personIntakes.map((intake) => {
 												const timeStr = new Date(intake.start).toLocaleTimeString(getSystemLocale(i18n.language), {
 													hour: "2-digit",
 													minute: "2-digit",
 												});
+												const intakeKey = `${intake.start}-${intake.usage}-${intake.every}-${intake.takenBy ?? ""}`;
 												return (
-													<span key={idx} className="user-med-intake-item">
+													<span key={intakeKey} className="user-med-intake-item">
 														{intake.usage} {intake.usage !== 1 ? t("common.pills") : t("common.pill")}
 														{med.pillWeightMg != null &&
 															` (${intake.usage * med.pillWeightMg} ${med.doseUnit ?? "mg"})`}{" "}

frontend/src/context/AppContext.tsx

@@ -1,9 +1,9 @@
 import type React from "react";
-import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { useAuth } from "../components/Auth";
 import { useCollapsedDays, useDoses, useMedications, useRefill, useSettings, useShare } from "../hooks";
-import type { Coverage, Medication, ScheduleEvent, StockThresholds } from "../types";
+import type { Coverage, FormState, Medication, ScheduleEvent, StockThresholds } from "../types";
 import { getSystemLocale } from "../utils/formatters";
 import { log } from "../utils/logger";
 import { buildSchedulePreview, calculateCoverage, computeMissedPastDoseIds } from "../utils/schedule";
@@ -72,6 +72,7 @@ export interface AppContextValue {
 	showClearMissedConfirm: boolean;
 	setShowClearMissedConfirm: (show: boolean) => void;
 	getDoseId: (baseDoseId: string, person: string | null) => string;
+	isDoseTakenAutomatically: (doseId: string) => boolean;
 	countTakenDoses: (doses: Array<{ id: string; takenBy: string[] }>) => { total: number; taken: number };
 	markDoseTaken: (doseId: string) => Promise<void>;
 	undoDoseTaken: (doseId: string) => Promise<void>;
@@ -127,7 +128,7 @@ export interface AppContextValue {
 	submitRefill: (
 		medId: number,
 		editingId: number | null,
-		setForm: React.Dispatch<React.SetStateAction<any>>,
+		setForm: React.Dispatch<React.SetStateAction<FormState>>,
 		loadMeds: () => void,
 		usePrescription?: boolean
 	) => Promise<void>;
@@ -212,7 +213,17 @@ export interface AppContextValue {
 // Context
 // =============================================================================
 
-const AppContext = createContext<AppContextValue | null>(null);
+const APP_CONTEXT_SINGLETON_KEY = "__MEDASSIST_APP_CONTEXT_SINGLETON__";
+
+const AppContext = (() => {
+	const globalRef = globalThis as typeof globalThis & {
+		[APP_CONTEXT_SINGLETON_KEY]?: React.Context<AppContextValue | null>;
+	};
+	if (!globalRef[APP_CONTEXT_SINGLETON_KEY]) {
+		globalRef[APP_CONTEXT_SINGLETON_KEY] = createContext<AppContextValue | null>(null);
+	}
+	return globalRef[APP_CONTEXT_SINGLETON_KEY];
+})();
 
 // Helper for user-specific localStorage keys
 function userStorageKey(userId: number | undefined, key: string): string {
@@ -242,9 +253,32 @@ export function AppProvider({ children }: { children: React.ReactNode }) {
 
 	// Modal state
 	const [selectedMed, setSelectedMed] = useState<Medication | null>(null);
+	const selectedMedIdRef = useRef<number | null>(null);
+	const medDetailOpenedAtRef = useRef(0);
+	const medDetailCloseInFlightRef = useRef(false);
+	useEffect(() => {
+		selectedMedIdRef.current = selectedMed?.id ?? null;
+		if (!selectedMed) {
+			medDetailCloseInFlightRef.current = false;
+		}
+	}, [selectedMed]);
 	const [showImageLightbox, setShowImageLightbox] = useState(false);
+	const imageLightboxOpenedAtRef = useRef(0);
+	const imageLightboxCloseInFlightRef = useRef(false);
 	const [scheduleLightboxImage, setScheduleLightboxImage] = useState<string | null>(null);
+	const scheduleLightboxOpenedAtRef = useRef(0);
+	const scheduleLightboxCloseInFlightRef = useRef(false);
 	const [selectedUser, setSelectedUser] = useState<string | null>(null);
+	useEffect(() => {
+		if (!showImageLightbox) {
+			imageLightboxCloseInFlightRef.current = false;
+		}
+	}, [showImageLightbox]);
+	useEffect(() => {
+		if (!scheduleLightboxImage) {
+			scheduleLightboxCloseInFlightRef.current = false;
+		}
+	}, [scheduleLightboxImage]);
 
 	// Export/Import state
 	const [exporting, setExporting] = useState(false);
@@ -456,6 +490,10 @@ export function AppProvider({ children }: { children: React.ReactNode }) {
 	// Modal helpers with browser history support
 	const openMedDetail = useCallback(
 		(med: Medication) => {
+			if (selectedMedIdRef.current === med.id) return;
+			selectedMedIdRef.current = med.id;
+			medDetailOpenedAtRef.current = Date.now();
+			medDetailCloseInFlightRef.current = false;
 			setSelectedMed(med);
 			refill.setRefillHistoryExpanded(false);
 			refill.loadRefillHistory(med.id);
@@ -465,37 +503,78 @@ export function AppProvider({ children }: { children: React.ReactNode }) {
 	);
 
 	const closeMedDetail = useCallback(() => {
-		if (selectedMed) {
-			window.history.back();
+		if (!selectedMed || medDetailCloseInFlightRef.current) return;
+
+		// Ignore ultra-fast close requests caused by rapid double-click races
+		if (Date.now() - medDetailOpenedAtRef.current < 320) return;
+
+		const currentState = window.history.state as { modal?: string } | null;
+		if (currentState?.modal !== "medDetail") {
+			// State already popped by another event: close locally without another back step.
+			selectedMedIdRef.current = null;
+			setSelectedMed(null);
+			return;
 		}
+
+		medDetailCloseInFlightRef.current = true;
+		window.history.back();
 	}, [selectedMed]);
 
 	const openImageLightbox = useCallback(() => {
+		if (showImageLightbox) return;
+		imageLightboxOpenedAtRef.current = Date.now();
+		imageLightboxCloseInFlightRef.current = false;
 		setShowImageLightbox(true);
 		window.history.pushState({ modal: "imageLightbox" }, "");
-	}, []);
-
-	const closeImageLightbox = useCallback(() => {
-		if (showImageLightbox) {
-			window.history.back();
-		}
 	}, [showImageLightbox]);
 
-	const openScheduleLightbox = useCallback((imageUrl: string) => {
-		setScheduleLightboxImage(imageUrl);
-		window.history.pushState({ modal: "scheduleLightbox" }, "");
-	}, []);
+	const closeImageLightbox = useCallback(() => {
+		if (!showImageLightbox || imageLightboxCloseInFlightRef.current) return;
+		if (Date.now() - imageLightboxOpenedAtRef.current < 320) return;
+
+		const currentState = window.history.state as { modal?: string } | null;
+		if (currentState?.modal !== "imageLightbox") {
+			setShowImageLightbox(false);
+			return;
+		}
+
+		imageLightboxCloseInFlightRef.current = true;
+		window.history.back();
+	}, [showImageLightbox]);
+
+	const openScheduleLightbox = useCallback(
+		(imageUrl: string) => {
+			if (scheduleLightboxImage) return;
+			scheduleLightboxOpenedAtRef.current = Date.now();
+			scheduleLightboxCloseInFlightRef.current = false;
+			setScheduleLightboxImage(imageUrl);
+			window.history.pushState({ modal: "scheduleLightbox" }, "");
+		},
+		[scheduleLightboxImage]
+	);
 
 	const closeScheduleLightbox = useCallback(() => {
-		if (scheduleLightboxImage) {
-			window.history.back();
+		if (!scheduleLightboxImage || scheduleLightboxCloseInFlightRef.current) return;
+		if (Date.now() - scheduleLightboxOpenedAtRef.current < 320) return;
+
+		const currentState = window.history.state as { modal?: string } | null;
+		if (currentState?.modal !== "scheduleLightbox") {
+			setScheduleLightboxImage(null);
+			return;
 		}
+
+		scheduleLightboxCloseInFlightRef.current = true;
+		window.history.back();
 	}, [scheduleLightboxImage]);
 
-	const openUserFilter = useCallback((person: string) => {
-		setSelectedUser(person);
-		window.history.pushState({ modal: "userFilter", person }, "");
-	}, []);
+	const openUserFilter = useCallback(
+		(person: string) => {
+			if (selectedUser === person) return;
+			setSelectedUser(person);
+			window.history.pushState({ modal: "userFilter", person }, "");
+		},
+		[selectedUser]
+	);
 
 	const closeUserFilter = useCallback(() => {
 		if (selectedUser) {
@@ -732,6 +811,7 @@ export function AppProvider({ children }: { children: React.ReactNode }) {
 			showClearMissedConfirm: doses.showClearMissedConfirm,
 			setShowClearMissedConfirm: doses.setShowClearMissedConfirm,
 			getDoseId: doses.getDoseId,
+			isDoseTakenAutomatically: doses.isDoseTakenAutomatically,
 			countTakenDoses: doses.countTakenDoses,
 			markDoseTaken: doses.markDoseTaken,
 			undoDoseTaken: doses.undoDoseTaken,

frontend/src/hooks/index.ts

@@ -8,6 +8,7 @@ export type { UseMedicationFormReturn } from "./useMedicationForm";
 export { defaultBlister, defaultForm, useMedicationForm } from "./useMedicationForm";
 export type { UseMedicationsReturn } from "./useMedications";
 export { useMedications } from "./useMedications";
+export { useModalHistory } from "./useModalHistory";
 export type { UseRefillReturn } from "./useRefill";
 export { useRefill } from "./useRefill";
 export type { Settings, UseSettingsReturn } from "./useSettings";

frontend/src/hooks/useDoses.ts

@@ -8,10 +8,12 @@ export interface UseDosesReturn {
 	takenDoses: Set<string>;
 	setTakenDoses: React.Dispatch<React.SetStateAction<Set<string>>>;
 	takenDoseTimestamps: Map<string, number>;
+	takenDoseSources: Map<string, "manual" | "automatic">;
 	dismissedDoses: Set<string>;
 	showClearMissedConfirm: boolean;
 	setShowClearMissedConfirm: (show: boolean) => void;
 	getDoseId: (baseDoseId: string, person: string | null) => string;
+	isDoseTakenAutomatically: (doseId: string) => boolean;
 	countTakenDoses: (doses: Array<{ id: string; takenBy: string[] }>) => { total: number; taken: number };
 	markDoseTaken: (doseId: string) => Promise<void>;
 	undoDoseTaken: (doseId: string) => Promise<void>;
@@ -21,6 +23,7 @@ export interface UseDosesReturn {
 export function useDoses(): UseDosesReturn {
 	const [takenDoses, setTakenDoses] = useState<Set<string>>(new Set());
 	const [takenDoseTimestamps, setTakenDoseTimestamps] = useState<Map<string, number>>(new Map());
+	const [takenDoseSources, setTakenDoseSources] = useState<Map<string, "manual" | "automatic">>(new Map());
 	const [dismissedDoses, setDismissedDoses] = useState<Set<string>>(new Set());
 	const [showClearMissedConfirm, setShowClearMissedConfirm] = useState(false);
 
@@ -42,6 +45,7 @@ export function useDoses(): UseDosesReturn {
 				const data = await res.json();
 				const taken = new Set<string>();
 				const timestamps = new Map<string, number>();
+				const sources = new Map<string, "manual" | "automatic">();
 				const dismissed = new Set<string>();
 				for (const d of data.doses) {
 					if (d.dismissed) {
@@ -49,10 +53,12 @@ export function useDoses(): UseDosesReturn {
 					} else {
 						taken.add(d.doseId);
 						timestamps.set(d.doseId, d.takenAt);
+						sources.set(d.doseId, d.takenSource === "automatic" ? "automatic" : "manual");
 					}
 				}
 				setTakenDoses(taken);
 				setTakenDoseTimestamps(timestamps);
+				setTakenDoseSources(sources);
 				setDismissedDoses(dismissed);
 			}
 			// Don't reset on error - keep current state
@@ -75,6 +81,13 @@ export function useDoses(): UseDosesReturn {
 		return person ? `${baseDoseId}-${person}` : baseDoseId;
 	}, []);
 
+	const isDoseTakenAutomatically = useCallback(
+		(doseId: string): boolean => {
+			return takenDoseSources.get(doseId) === "automatic";
+		},
+		[takenDoseSources]
+	);
+
 	// Count taken doses for a day/item
 	const countTakenDoses = useCallback(
 		(doses: Array<{ id: string; takenBy: string[] }>): { total: number; taken: number } => {
@@ -106,6 +119,11 @@ export function useDoses(): UseDosesReturn {
 				next.set(doseId, Date.now());
 				return next;
 			});
+			setTakenDoseSources((prev) => {
+				const next = new Map(prev);
+				next.set(doseId, "manual");
+				return next;
+			});
 
 			// Send to server
 			try {
@@ -127,6 +145,11 @@ export function useDoses(): UseDosesReturn {
 					next.delete(doseId);
 					return next;
 				});
+				setTakenDoseSources((prev) => {
+					const next = new Map(prev);
+					next.delete(doseId);
+					return next;
+				});
 			} finally {
 				mutationInFlightRef.current--;
 				// Re-sync with server after mutation completes
@@ -150,6 +173,11 @@ export function useDoses(): UseDosesReturn {
 				next.delete(doseId);
 				return next;
 			});
+			setTakenDoseSources((prev) => {
+				const next = new Map(prev);
+				next.delete(doseId);
+				return next;
+			});
 
 			// Send to server
 			try {
@@ -177,10 +205,12 @@ export function useDoses(): UseDosesReturn {
 		takenDoses,
 		setTakenDoses,
 		takenDoseTimestamps,
+		takenDoseSources,
 		dismissedDoses,
 		showClearMissedConfirm,
 		setShowClearMissedConfirm,
 		getDoseId,
+		isDoseTakenAutomatically,
 		countTakenDoses,
 		markDoseTaken,
 		undoDoseTaken,

frontend/src/hooks/useMedicationForm.ts

@@ -151,7 +151,7 @@ export function useMedicationForm(): UseMedicationFormReturn {
 			if (error) errors[f] = error;
 		});
 		setFieldErrors(errors);
-	}, [form.name, form.genericName, form.notes, validateField]);
+	}, [form.name, form.genericName, form.notes, validateField, form]);
 
 	const setBlisterValue = useCallback((idx: number, field: keyof FormBlister, value: string) => {
 		setForm((prev) => {

frontend/src/hooks/useModalHistory.ts

@@ -0,0 +1,32 @@
+import { useEffect, useRef } from "react";
+
+/**
+ * Push a history entry when a modal opens so the browser back button closes it.
+ * On popstate (back), calls `onClose` to dismiss the modal.
+ */
+export function useModalHistory(isOpen: boolean, modalKey: string, onClose: () => void) {
+	const pushedRef = useRef(false);
+
+	useEffect(() => {
+		if (isOpen) {
+			window.history.pushState({ modal: modalKey }, "");
+			pushedRef.current = true;
+		} else if (pushedRef.current) {
+			pushedRef.current = false;
+		}
+	}, [isOpen, modalKey]);
+
+	useEffect(() => {
+		if (!isOpen) return;
+
+		const handlePopState = () => {
+			if (pushedRef.current) {
+				pushedRef.current = false;
+				onClose();
+			}
+		};
+
+		window.addEventListener("popstate", handlePopState);
+		return () => window.removeEventListener("popstate", handlePopState);
+	}, [isOpen, onClose]);
+}

frontend/src/hooks/useSettings.ts

@@ -249,11 +249,7 @@ export function useSettings(): UseSettingsReturn {
 				body: JSON.stringify(payload),
 			}).catch(() => null);
 
-			const updatedSettings = {
-				...settingsToSave,
-				emailEnabled: effectiveEmailEnabled,
-				shoutrrrEnabled: effectiveShoutrrrEnabled,
-			};
+			const updatedSettings = { ...settingsToSave };
 			setSettings(updatedSettings);
 			setSettingsSaving(false);
 			setSavedSettings(updatedSettings);

frontend/src/i18n/de.json

@@ -153,6 +153,7 @@
   },
   "form": {
     "editEntry": "Bearbeiten",
+    "editEntryWithName": "Bearbeiten: {{name}}",
     "viewEntry": "Ansehen",
     "newEntry": "Neues Medikament",
     "badge": "Packungen + lose Tabletten",
@@ -350,6 +351,7 @@
   },
   "tooltips": {
     "intakeReminders": "Einnahme-Erinnerungen aktiviert",
+    "automaticTaken": "Automatisch eingenommen",
     "hasNotes": "Hat Notizen",
     "stockExceedsCapacity": "Bestand überschreitet Packungskapazität — Packungsanzahl anpassen",
     "lightMode": "Zum hellen Modus wechseln",
@@ -462,7 +464,9 @@
     "pillsTotal": "{{count}} Tabletten gesamt",
     "pillsTotal_one": "{{count}} Tablette gesamt",
     "pillsTotal_other": "{{count}} Tabletten gesamt",
-    "max": "max"
+    "max": "max",
+    "on": "An",
+    "off": "Aus"
   },
   "share": {
     "button": "Teilen",
@@ -645,6 +649,7 @@
     "docPrescriptionExpiry": "Rezeptablauf",
     "docIntakeHistory": "Einnahme-Verlauf",
     "docDosesTaken": "Eingenommene Dosen",
+    "docDosesTakenAutomatic": "Automatisch eingenommen",
     "docDosesDismissed": "Verworfene Dosen",
     "docFirstDose": "Erste Dosis",
     "docLastDose": "Letzte Dosis",

frontend/src/i18n/en.json

@@ -153,6 +153,7 @@
   },
   "form": {
     "editEntry": "Edit",
+    "editEntryWithName": "Edit: {{name}}",
     "viewEntry": "View",
     "newEntry": "New medication",
     "badge": "Packs + loose pills",
@@ -350,6 +351,7 @@
   },
   "tooltips": {
     "intakeReminders": "Intake reminders enabled",
+    "automaticTaken": "Automatically taken",
     "hasNotes": "Has notes",
     "stockExceedsCapacity": "Stock exceeds package capacity — consider updating pack count",
     "lightMode": "Switch to light mode",
@@ -462,7 +464,9 @@
     "pillsTotal": "{{count}} pills total",
     "pillsTotal_one": "{{count}} pill total",
     "pillsTotal_other": "{{count}} pills total",
-    "max": "max"
+    "max": "max",
+    "on": "On",
+    "off": "Off"
   },
   "share": {
     "button": "Share",
@@ -645,6 +649,7 @@
     "docPrescriptionExpiry": "Prescription expiry",
     "docIntakeHistory": "Intake History",
     "docDosesTaken": "Doses taken",
+    "docDosesTakenAutomatic": "Automatically taken",
     "docDosesDismissed": "Doses dismissed",
     "docFirstDose": "First dose",
     "docLastDose": "Last dose",

frontend/src/pages/DashboardPage.tsx

@@ -1,60 +1,21 @@
+/* biome-ignore-all lint/style/noNestedTernary: timeline rendering uses explicit UI-state branching */
 import { Bell, NotebookPen, Share2 } from "lucide-react";
 import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { ConfirmModal, MedicationAvatar } from "../components";
 import { useAuth } from "../components/Auth";
 import { useAppContext } from "../context";
-import type { Coverage } from "../types";
+import { useModalHistory } from "../hooks";
 import { formatNumber, getExpiryClass, getSystemLocale } from "../utils/formatters";
 import { expandDoseIds, getStockStatus, isDoseDismissed } from "../utils/schedule";
-
-// Helper for user-specific localStorage keys
-export function userStorageKey(userId: number | undefined, key: string): string {
-	return userId ? `user_${userId}_${key}` : key;
-}
-
-// Helper function to calculate blister stock
-export function getBlisterStock(
-	totalPills: number,
-	pillsPerBlister: number,
-	_looseTablets: number,
-	_originalTotal: number
-) {
-	const fullBlisters = Math.floor(totalPills / pillsPerBlister);
-	const openBlisterPills = totalPills % pillsPerBlister;
-	return { fullBlisters, openBlisterPills, loosePills: openBlisterPills };
-}
-
-// Helper to format full blisters
-export function formatFullBlisters(count: number, t: (key: string) => string): string {
-	return `${count} ${count === 1 ? t("common.blister") : t("common.blisters")}`;
-}
-
-// Helper to format open blister and loose pills
-export function formatOpenBlisterAndLoose(
-	openBlisterPills: number,
-	loosePills: number,
-	pillsPerBlister: number,
-	t: (key: string) => string
-): string {
-	if (openBlisterPills === 0 && loosePills === 0) return "-";
-	return `${openBlisterPills} ${t("common.of")} ${pillsPerBlister} ${t("common.pills")}`;
-}
-
-// Get total pills for a medication (packageType-aware)
-export function getMedTotal(med: {
-	packCount: number;
-	blistersPerPack: number;
-	pillsPerBlister: number;
-	looseTablets: number;
-	stockAdjustment?: number | null;
-	packageType?: string;
-}): number {
-	if (med.packageType === "bottle") {
-		return med.looseTablets + (med.stockAdjustment ?? 0);
-	}
-	return med.packCount * med.blistersPerPack * med.pillsPerBlister + med.looseTablets + (med.stockAdjustment ?? 0);
-}
+import {
+	formatFullBlisters,
+	formatOpenBlisterAndLoose,
+	getBlisterStock,
+	getMedTotal,
+	getReminderStatusData,
+	userStorageKey,
+} from "./dashboard-helpers";
 
 // Notification bell SVG icon (no emoji)
 function NotificationBellIcon() {
@@ -76,108 +37,6 @@ function NotificationBellIcon() {
 	);
 }
 
-// Get structured reminder status data
-export function getReminderStatusData(
-	reminderDaysBefore: number,
-	lowStockDays: number,
-	_allLowCoverage: Coverage[],
-	allCoverage: Coverage[],
-	lastAutoEmailSent: string | null,
-	_lastNotificationType: string | null,
-	_lastNotificationChannel: string | null,
-	lastReminderMedName: string | null,
-	lastReminderTakenBy: string | null,
-	lastStockReminderSent: string | null,
-	_lastStockReminderChannel: string | null,
-	lastStockReminderMedNames: string | null,
-	t: (key: string, options?: Record<string, unknown>) => string,
-	locale: string
-): {
-	status: { text: string; className: string };
-	lowStockMeds: { name: string; daysLeft: number; isCritical: boolean }[];
-	lastStockSent: { date: string; medNames: string | null } | null;
-	lastIntakeSent: { date: string; medName: string | null; takenBy: string | null } | null;
-} {
-	const lowStockMap = new Map<string, { name: string; daysLeft: number; isCritical: boolean }>();
-
-	for (const c of allCoverage) {
-		if (c.medsLeft <= 0) {
-			lowStockMap.set(c.name, { name: c.name, daysLeft: 0, isCritical: true });
-			continue;
-		}
-
-		if (c.daysLeft === null) continue;
-
-		const roundedDaysLeft = Math.round(c.daysLeft);
-		const isCritical = c.daysLeft <= reminderDaysBefore;
-		const isLow = c.daysLeft < lowStockDays;
-		if (!isCritical && !isLow) continue;
-
-		const existing = lowStockMap.get(c.name);
-		if (!existing || roundedDaysLeft < existing.daysLeft || (isCritical && !existing.isCritical)) {
-			lowStockMap.set(c.name, { name: c.name, daysLeft: roundedDaysLeft, isCritical });
-		}
-	}
-
-	const lowStockMeds = Array.from(lowStockMap.values()).sort((a, b) => a.daysLeft - b.daysLeft);
-	const criticalCount = lowStockMeds.filter((m) => m.isCritical).length;
-	const lowCount = lowStockMeds.filter((m) => !m.isCritical).length;
-
-	// Determine status
-	let status: { text: string; className: string };
-	if (criticalCount > 0) {
-		status = {
-			text: t("dashboard.reminders.criticalMeds", { count: criticalCount }),
-			className: "danger",
-		};
-	} else if (lowCount > 0) {
-		status = {
-			text: t("dashboard.reminders.lowMeds", { count: lowCount }),
-			className: "warning",
-		};
-	} else {
-		status = {
-			text: t("dashboard.reminders.allOk"),
-			className: "success",
-		};
-	}
-
-	// Parse last stock reminder sent info (from dedicated stock tracking columns)
-	let lastStockSent: { date: string; medNames: string | null } | null = null;
-	if (lastStockReminderSent) {
-		const sentDate = new Date(lastStockReminderSent);
-		const formattedDate = sentDate.toLocaleDateString(locale, {
-			day: "2-digit",
-			month: "short",
-			hour: "2-digit",
-			minute: "2-digit",
-		});
-		lastStockSent = {
-			date: formattedDate,
-			medNames: lastStockReminderMedNames,
-		};
-	}
-
-	// Parse last intake reminder sent info (from intake tracking columns)
-	let lastIntakeSent: { date: string; medName: string | null; takenBy: string | null } | null = null;
-	if (lastAutoEmailSent) {
-		const sentDate = new Date(lastAutoEmailSent);
-		const formattedDate = sentDate.toLocaleDateString(locale, {
-			day: "2-digit",
-			month: "short",
-			hour: "2-digit",
-			minute: "2-digit",
-		});
-		lastIntakeSent = {
-			date: formattedDate,
-			medName: lastReminderMedName,
-			takenBy: lastReminderTakenBy,
-		};
-	}
-
-	return { status, lowStockMeds, lastStockSent, lastIntakeSent };
-}
-
 export function DashboardPage() {
 	const { t, i18n } = useTranslation();
 	const { user } = useAuth();
@@ -206,6 +65,7 @@ export function DashboardPage() {
 		missedPastDoseIds,
 		getDayStockStatus,
 		getDoseId,
+		isDoseTakenAutomatically,
 		showClearMissedConfirm,
 		setShowClearMissedConfirm,
 		clearingMissed,
@@ -218,6 +78,8 @@ export function DashboardPage() {
 		loadSettings,
 	} = useAppContext();
 
+	useModalHistory(showClearMissedConfirm, "clearMissed", () => setShowClearMissedConfirm(false));
+
 	// Get structured reminder data
 	const reminderData = getReminderStatusData(
 		settings.reminderDaysBefore,
@@ -650,7 +512,21 @@ export function DashboardPage() {
 									>
 										<span data-label={t("table.name")} className="cell-with-avatar">
 											<span className="med-name-line">
-												<MedicationAvatar name={row.name} imageUrl={med?.imageUrl} />
+												<span
+													className={med?.imageUrl ? "med-avatar-clickable" : undefined}
+													onClick={(e) => {
+														e.stopPropagation();
+														if (med?.imageUrl) openScheduleLightbox(`/api/images/${med.imageUrl}`);
+													}}
+													onKeyDown={(e) => {
+														e.stopPropagation();
+														if (e.key === "Enter" || e.key === " ") {
+															if (med?.imageUrl) openScheduleLightbox(`/api/images/${med.imageUrl}`);
+														}
+													}}
+												>
+													<MedicationAvatar name={row.name} imageUrl={med?.imageUrl} />
+												</span>
 												<span className="med-name-block-dash">
 													<span className="med-name-text">
 														{row.name}
@@ -868,7 +744,15 @@ export function DashboardPage() {
 																	>
 																		<MedicationAvatar name={item.medName} imageUrl={med?.imageUrl} size="sm" />
 																	</div>
-																	<div className="med-name-stack">
+																	<div
+																		className="med-name-stack clickable"
+																		onClick={() => med && openMedDetail(med)}
+																		onKeyDown={(e) => {
+																			if (e.key === "Enter" || e.key === " ") {
+																				if (med) openMedDetail(med);
+																			}
+																		}}
+																	>
 																		<span className="med-name-text">{item.medName}</span>
 																		{med?.genericName && <span className="med-generic-inline">{med.genericName}</span>}
 																	</div>
@@ -907,6 +791,8 @@ export function DashboardPage() {
 																				{people.map((person) => {
 																					const doseId = getDoseId(dose.id, person);
 																					const isTaken = takenDoses.has(doseId);
+																					const isAutomaticallyTaken =
+																						isTaken && isDoseTakenAutomatically(doseId) && dose.when <= Date.now();
 																					return (
 																						<div key={doseId} className={`dose-person ${isTaken ? "taken" : ""}`}>
 																							{person && (
@@ -926,6 +812,14 @@ export function DashboardPage() {
 																									onClick={() => undoDoseTaken(doseId)}
 																									title={t("common.undo")}
 																								>
+																									{isAutomaticallyTaken && (
+																										<span
+																											className="info-tooltip"
+																											data-tooltip={t("tooltips.automaticTaken")}
+																										>
+																											🤖
+																										</span>
+																									)}
 																									↩
 																								</button>
 																							) : (
@@ -1110,7 +1004,15 @@ export function DashboardPage() {
 																	>
 																		<MedicationAvatar name={item.medName} imageUrl={med?.imageUrl} size="sm" />
 																	</div>
-																	<div className="med-name-stack">
+																	<div
+																		className="med-name-stack clickable"
+																		onClick={() => med && openMedDetail(med)}
+																		onKeyDown={(e) => {
+																			if (e.key === "Enter" || e.key === " ") {
+																				if (med) openMedDetail(med);
+																			}
+																		}}
+																	>
 																		<span className="med-name-text">{item.medName}</span>
 																		{med?.genericName && <span className="med-generic-inline">{med.genericName}</span>}
 																	</div>
@@ -1153,6 +1055,8 @@ export function DashboardPage() {
 																				{people.map((person) => {
 																					const doseId = getDoseId(dose.id, person);
 																					const isTaken = takenDoses.has(doseId);
+																					const isAutomaticallyTaken =
+																						isTaken && isDoseTakenAutomatically(doseId) && dose.when <= Date.now();
 																					return (
 																						<div key={doseId} className={`dose-person ${isTaken ? "taken" : ""}`}>
 																							{person && (
@@ -1172,6 +1076,14 @@ export function DashboardPage() {
 																									onClick={() => undoDoseTaken(doseId)}
 																									title={t("common.undo")}
 																								>
+																									{isAutomaticallyTaken && (
+																										<span
+																											className="info-tooltip"
+																											data-tooltip={t("tooltips.automaticTaken")}
+																										>
+																											🤖
+																										</span>
+																									)}
 																									↩
 																								</button>
 																							) : (
@@ -1323,7 +1235,15 @@ export function DashboardPage() {
 																	>
 																		<MedicationAvatar name={item.medName} imageUrl={med?.imageUrl} size="sm" />
 																	</div>
-																	<div className="med-name-stack">
+																	<div
+																		className="med-name-stack clickable"
+																		onClick={() => med && openMedDetail(med)}
+																		onKeyDown={(e) => {
+																			if (e.key === "Enter" || e.key === " ") {
+																				if (med) openMedDetail(med);
+																			}
+																		}}
+																	>
 																		<span className="med-name-text">{item.medName}</span>
 																		{med?.genericName && <span className="med-generic-inline">{med.genericName}</span>}
 																	</div>
@@ -1362,6 +1282,8 @@ export function DashboardPage() {
 																				{people.map((person) => {
 																					const doseId = getDoseId(dose.id, person);
 																					const isTaken = takenDoses.has(doseId);
+																					const isAutomaticallyTaken =
+																						isTaken && isDoseTakenAutomatically(doseId) && dose.when <= Date.now();
 																					return (
 																						<div key={doseId} className={`dose-person ${isTaken ? "taken" : ""}`}>
 																							{person && (
@@ -1381,6 +1303,14 @@ export function DashboardPage() {
 																									onClick={() => undoDoseTaken(doseId)}
 																									title={t("common.undo")}
 																								>
+																									{isAutomaticallyTaken && (
+																										<span
+																											className="info-tooltip"
+																											data-tooltip={t("tooltips.automaticTaken")}
+																										>
+																											🤖
+																										</span>
+																									)}
 																									↩
 																								</button>
 																							) : (

frontend/src/pages/MedicationsPage.tsx

@@ -1,3 +1,6 @@
+/* biome-ignore-all lint/a11y/noLabelWithoutControl: form uses custom inputs and display fields wrapped in label-like layout */
+/* biome-ignore-all lint/correctness/useExhaustiveDependencies: modal-history callbacks are intentionally managed outside hook deps */
+/* biome-ignore-all lint/suspicious/noArrayIndexKey: local draft intake rows do not have stable ids before persistence */
 import { Bell, Eye, Minus, Pencil, Plus, Trash2 } from "lucide-react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
@@ -5,9 +8,9 @@ import { useSearchParams } from "react-router-dom";
 import { ConfirmModal, DateInput, Lightbox, MedicationAvatar, MobileEditModal, ReportModal } from "../components";
 import { useAuth } from "../components/Auth";
 import { useAppContext, useUnsavedChanges } from "../context";
-import { useMedicationForm, useUnsavedChangesWarning } from "../hooks";
+import { useMedicationForm, useModalHistory, useUnsavedChangesWarning } from "../hooks";
 import type { DoseUnit, Medication } from "../types";
-import { DOSE_UNITS, FIELD_LIMITS, getMedTotal, getPackageSize } from "../types";
+import { DOSE_UNITS, FIELD_LIMITS, getPackageSize } from "../types";
 import { combineDateAndTime, formatDate, formatDateTime, formatNumber } from "../utils/formatters";
 import { log } from "../utils/logger";
 
@@ -31,7 +34,6 @@ export function MedicationsPage() {
 		deleteMedImage,
 		uploadingImage,
 		existingPeople,
-		coverage,
 		coverageByMed,
 	} = useAppContext();
 
@@ -72,6 +74,10 @@ export function MedicationsPage() {
 
 	// Mobile modal state (declared early because it's used in useEffect below)
 	const [showEditModal, setShowEditModal] = useState(false);
+	const showEditModalRef = useRef(false);
+	useEffect(() => {
+		showEditModalRef.current = showEditModal;
+	}, [showEditModal]);
 	const processedEditMedIdRef = useRef<string | null>(null);
 	const hasDesktopFormHistoryState = useRef(false);
 
@@ -125,6 +131,7 @@ export function MedicationsPage() {
 	const [showObsolete, setShowObsolete] = useState(true);
 	const [readOnlyView, setReadOnlyView] = useState(false);
 	const [showReportModal, setShowReportModal] = useState(false);
+	useModalHistory(showReportModal, "report", () => setShowReportModal(false));
 	const [showNameValidation, setShowNameValidation] = useState(false);
 
 	useEffect(() => {
@@ -196,6 +203,8 @@ export function MedicationsPage() {
 
 	// Open mobile edit modal
 	function openEditModal() {
+		if (showEditModalRef.current) return;
+		showEditModalRef.current = true;
 		setShowEditModal(true);
 		window.history.pushState({ modal: "edit" }, "");
 	}
@@ -463,6 +472,20 @@ export function MedicationsPage() {
 
 			// Reset form after successful save
 			if (!editingId) {
+				const shouldCloseMobileModal = showEditModal && window.innerWidth <= 768;
+				if (shouldCloseMobileModal) {
+					// Treat post-save close as confirmed so popstate does not trigger unsaved guards.
+					closeConfirmedRef.current = true;
+					clearEditMedIdParam();
+					setShowEditModal(false);
+					setReadOnlyView(false);
+					setActiveTab("general");
+					setViewMode("grid");
+					resetForm();
+					window.history.back();
+					setSaving(false);
+					return;
+				}
 				resetForm();
 				setViewMode("grid");
 			} else {
@@ -480,6 +503,8 @@ export function MedicationsPage() {
 	// Handle browser back button for modals and unsaved changes
 	useEffect(() => {
 		const handlePopState = () => {
+			const currentEditMedId = new URLSearchParams(window.location.search).get("editMedId");
+
 			// Obsolete confirmation is open — dismiss it and stay where we are
 			if (showObsoleteConfirm) {
 				setShowObsoleteConfirm(false);
@@ -497,6 +522,11 @@ export function MedicationsPage() {
 			// If close was already confirmed programmatically, allow navigation
 			if (closeConfirmedRef.current) {
 				closeConfirmedRef.current = false;
+				if (currentEditMedId) {
+					// Prevent URL popstate from immediately reopening mobile edit for the same id.
+					processedEditMedIdRef.current = currentEditMedId;
+					clearEditMedIdParam();
+				}
 				if (showEditModal) {
 					setShowEditModal(false);
 					resetForm();
@@ -515,6 +545,10 @@ export function MedicationsPage() {
 					setShowUnsavedConfirm(true);
 					return;
 				}
+				if (currentEditMedId) {
+					// Mark as handled before URL cleanup to avoid same-tick re-open races.
+					processedEditMedIdRef.current = currentEditMedId;
+				}
 				clearEditMedIdParam();
 				setShowEditModal(false);
 				resetForm();
@@ -562,37 +596,12 @@ export function MedicationsPage() {
 		return () => document.removeEventListener("keydown", handleEscape);
 	}, [showEditModal, closeEditModal]);
 
-	// Handle edit button click - open modal on mobile, switch to form on desktop
-	const normalizeMedicationForEdit = useCallback(
-		(med: Medication): Medication => {
-			if (med.packageType !== "blister") return med;
-
-			const pillsPerPack = Math.max(1, med.blistersPerPack * med.pillsPerBlister);
-			const fallbackStock = Math.max(0, getMedTotal(med));
-			const currentStock = Math.max(0, Math.round(coverageByMed[med.name]?.medsLeft ?? fallbackStock));
-			const nextPackCount = Math.floor(currentStock / pillsPerPack);
-			const nextLooseTablets = currentStock % pillsPerPack;
-
-			if (nextPackCount === med.packCount && nextLooseTablets === med.looseTablets) {
-				return med;
-			}
-
-			return {
-				...med,
-				packCount: nextPackCount,
-				looseTablets: nextLooseTablets,
-			};
-		},
-		[coverageByMed]
-	);
-
 	function handleEditClick(med: Medication) {
-		const normalizedMed = normalizeMedicationForEdit(med);
 		if (formChanged) {
 			pendingActionRef.current = () => {
 				setShowNameValidation(false);
 				setReadOnlyView(false);
-				startEdit(normalizedMed, openEditModal);
+				startEdit(med, openEditModal);
 				setViewMode("form");
 			};
 			setUnsavedConfirmSource(showEditModal ? "mobile-edit" : "desktop-form");
@@ -602,17 +611,16 @@ export function MedicationsPage() {
 		setShowNameValidation(false);
 		setReadOnlyView(false);
 		setActiveTab("general");
-		startEdit(normalizedMed, openEditModal);
+		startEdit(med, openEditModal);
 		setViewMode("form");
 	}
 
 	function handleViewClick(med: Medication) {
-		const normalizedMed = normalizeMedicationForEdit(med);
 		if (formChanged) {
 			pendingActionRef.current = () => {
 				setShowNameValidation(false);
 				setReadOnlyView(true);
-				startEdit(normalizedMed, openEditModal);
+				startEdit(med, openEditModal);
 				setViewMode("form");
 			};
 			setUnsavedConfirmSource(showEditModal ? "mobile-edit" : "desktop-form");
@@ -622,7 +630,7 @@ export function MedicationsPage() {
 		setShowNameValidation(false);
 		setReadOnlyView(true);
 		setActiveTab("general");
-		startEdit(normalizedMed, openEditModal);
+		startEdit(med, openEditModal);
 		setViewMode("form");
 	}
 
@@ -685,13 +693,13 @@ export function MedicationsPage() {
 		setShowNameValidation(false);
 		setReadOnlyView(false);
 		setActiveTab("general");
-		startEdit(normalizeMedicationForEdit(medicationToEdit), openEditModal);
+		startEdit(medicationToEdit, openEditModal);
 		setViewMode("form");
 
 		const nextParams = new URLSearchParams(searchParams);
 		nextParams.delete("editMedId");
 		setSearchParams(nextParams, { replace: true });
-	}, [allMeds, normalizeMedicationForEdit, openEditModal, searchParams, setSearchParams, startEdit]);
+	}, [allMeds, openEditModal, searchParams, setSearchParams, startEdit]);
 
 	const selectedMedication = useMemo(() => {
 		if (!editingId) return null;

frontend/src/pages/PlannerPage.tsx

@@ -1,3 +1,4 @@
+/* biome-ignore-all lint/a11y/noLabelWithoutControl: planner uses custom DateTimeInput control wrappers */
 import { useEffect, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { DateTimeInput, MedicationAvatar } from "../components";

frontend/src/pages/SchedulePage.tsx

@@ -1,3 +1,5 @@
+/* biome-ignore-all lint/style/noNestedTernary: schedule timeline branches are intentionally explicit */
+import { Bell } from "lucide-react";
 import { useTranslation } from "react-i18next";
 import { MedicationAvatar } from "../components";
 import { useAuth } from "../components/Auth";
@@ -65,6 +67,7 @@ export function SchedulePage() {
 		pastDays,
 		futureDays,
 		takenDoses,
+		isDoseTakenAutomatically,
 		dismissedDoses,
 		markDoseTaken,
 		undoDoseTaken,
@@ -204,13 +207,15 @@ export function SchedulePage() {
 																			className="reminder-icon info-tooltip"
 																			data-tooltip={t("tooltips.intakeReminders")}
 																		>
-																			🔔
+																			<Bell size={14} aria-hidden="true" />
 																		</span>
 																	)}{" "}
 																	<div className="dose-checks">
 																		{people.map((person) => {
 																			const doseId = getDoseId(dose.id, person);
 																			const isTaken = takenDoses.has(doseId);
+																			const isAutomaticallyTaken =
+																				isTaken && isDoseTakenAutomatically(doseId) && dose.when <= Date.now();
 																			return (
 																				<div key={doseId} className={`dose-person ${isTaken ? "taken" : ""}`}>
 																					{person && (
@@ -230,6 +235,14 @@ export function SchedulePage() {
 																							onClick={() => undoDoseTaken(doseId)}
 																							title={t("common.undo")}
 																						>
+																							{isAutomaticallyTaken && (
+																								<span
+																									className="info-tooltip"
+																									data-tooltip={t("tooltips.automaticTaken")}
+																								>
+																									🤖
+																								</span>
+																							)}
 																							↩
 																						</button>
 																					) : (
@@ -365,13 +378,15 @@ export function SchedulePage() {
 																	className="reminder-icon info-tooltip"
 																	data-tooltip={t("tooltips.intakeReminders")}
 																>
-																	🔔
+																	<Bell size={14} aria-hidden="true" />
 																</span>
 															)}
 															<div className="dose-checks">
 																{people.map((person) => {
 																	const doseId = getDoseId(dose.id, person);
 																	const isTaken = takenDoses.has(doseId);
+																	const isAutomaticallyTaken =
+																		isTaken && isDoseTakenAutomatically(doseId) && dose.when <= now;
 																	const isOverdue = !isTaken && dose.when < now && !isPastDay;
 																	return (
 																		<div
@@ -395,6 +410,11 @@ export function SchedulePage() {
 																					onClick={() => undoDoseTaken(doseId)}
 																					title={t("common.undo")}
 																				>
+																					{isAutomaticallyTaken && (
+																						<span className="info-tooltip" data-tooltip={t("tooltips.automaticTaken")}>
+																							🤖
+																						</span>
+																					)}
 																					↩
 																				</button>
 																			) : (

frontend/src/pages/SettingsPage.tsx

@@ -1,3 +1,4 @@
+/* biome-ignore-all lint/a11y/noLabelWithoutControl: settings rows use label-styled text with adjacent custom toggle controls */
 import { useTranslation } from "react-i18next";
 import { ConfirmModal, ExportModal } from "../components";
 import { useAppContext } from "../context";
@@ -89,7 +90,7 @@ export function SettingsPage() {
 										<label className={`toggle-switch small${!settings.emailEnabled ? " disabled" : ""}`}>
 											<input
 												type="checkbox"
-												checked={settings.smtpHost && settings.emailEnabled ? settings.emailStockReminders : false}
+												checked={settings.emailStockReminders}
 												onChange={(e) => setSettings({ ...settings, emailStockReminders: e.target.checked })}
 												disabled={!settings.emailEnabled}
 											/>
@@ -100,9 +101,7 @@ export function SettingsPage() {
 										<label className={`toggle-switch small${!settings.shoutrrrEnabled ? " disabled" : ""}`}>
 											<input
 												type="checkbox"
-												checked={
-													settings.shoutrrrUrl && settings.shoutrrrEnabled ? settings.shoutrrrStockReminders : false
-												}
+												checked={settings.shoutrrrStockReminders}
 												onChange={(e) => setSettings({ ...settings, shoutrrrStockReminders: e.target.checked })}
 												disabled={!settings.shoutrrrEnabled}
 											/>
@@ -116,7 +115,7 @@ export function SettingsPage() {
 										<label className={`toggle-switch small${!settings.emailEnabled ? " disabled" : ""}`}>
 											<input
 												type="checkbox"
-												checked={settings.smtpHost && settings.emailEnabled ? settings.emailIntakeReminders : false}
+												checked={settings.emailIntakeReminders}
 												onChange={(e) => setSettings({ ...settings, emailIntakeReminders: e.target.checked })}
 												disabled={!settings.emailEnabled}
 											/>
@@ -127,9 +126,7 @@ export function SettingsPage() {
 										<label className={`toggle-switch small${!settings.shoutrrrEnabled ? " disabled" : ""}`}>
 											<input
 												type="checkbox"
-												checked={
-													settings.shoutrrrUrl && settings.shoutrrrEnabled ? settings.shoutrrrIntakeReminders : false
-												}
+												checked={settings.shoutrrrIntakeReminders}
 												onChange={(e) => setSettings({ ...settings, shoutrrrIntakeReminders: e.target.checked })}
 												disabled={!settings.shoutrrrEnabled}
 											/>
@@ -143,9 +140,7 @@ export function SettingsPage() {
 										<label className={`toggle-switch small${!settings.emailEnabled ? " disabled" : ""}`}>
 											<input
 												type="checkbox"
-												checked={
-													settings.smtpHost && settings.emailEnabled ? settings.emailPrescriptionReminders : false
-												}
+												checked={settings.emailPrescriptionReminders}
 												onChange={(e) => setSettings({ ...settings, emailPrescriptionReminders: e.target.checked })}
 												disabled={!settings.emailEnabled}
 											/>
@@ -156,11 +151,7 @@ export function SettingsPage() {
 										<label className={`toggle-switch small${!settings.shoutrrrEnabled ? " disabled" : ""}`}>
 											<input
 												type="checkbox"
-												checked={
-													settings.shoutrrrUrl && settings.shoutrrrEnabled
-														? settings.shoutrrrPrescriptionReminders
-														: false
-												}
+												checked={settings.shoutrrrPrescriptionReminders}
 												onChange={(e) => setSettings({ ...settings, shoutrrrPrescriptionReminders: e.target.checked })}
 												disabled={!settings.shoutrrrEnabled}
 											/>

frontend/src/pages/dashboard-helpers.ts

@@ -0,0 +1,147 @@
+import type { Coverage } from "../types";
+import { getMedTotal as getMedTotalFromTypes } from "../types";
+import { splitCurrentBlisterStock } from "../utils/stock";
+
+export function userStorageKey(userId: number | undefined, key: string): string {
+	return userId ? `user_${userId}_${key}` : key;
+}
+
+export function getBlisterStock(
+	totalPills: number,
+	pillsPerBlister: number,
+	looseTablets: number,
+	_originalTotal: number
+) {
+	return splitCurrentBlisterStock(totalPills, pillsPerBlister, looseTablets);
+}
+
+export function formatFullBlisters(count: number, t: (key: string) => string): string {
+	return `${count} ${count === 1 ? t("common.blister") : t("common.blisters")}`;
+}
+
+export function formatOpenBlisterAndLoose(
+	openBlisterPills: number,
+	loosePills: number,
+	pillsPerBlister: number,
+	t: (key: string) => string
+): string {
+	if (openBlisterPills > 0 && loosePills > 0) {
+		return `${openBlisterPills} ${t("common.of")} ${pillsPerBlister} ${t("common.pills")} + ${loosePills} ${t("modal.loosePills")}`;
+	}
+	if (openBlisterPills > 0) {
+		return `${openBlisterPills} ${t("common.of")} ${pillsPerBlister} ${t("common.pills")}`;
+	}
+	if (loosePills > 0) {
+		return `${loosePills} ${t("modal.loosePills")}`;
+	}
+	return "-";
+}
+
+export function getMedTotal(med: {
+	packCount: number;
+	blistersPerPack: number;
+	pillsPerBlister: number;
+	looseTablets: number;
+	stockAdjustment?: number | null;
+	packageType?: string;
+}): number {
+	return getMedTotalFromTypes(med);
+}
+
+export function getReminderStatusData(
+	reminderDaysBefore: number,
+	lowStockDays: number,
+	_allLowCoverage: Coverage[],
+	allCoverage: Coverage[],
+	lastAutoEmailSent: string | null,
+	_lastNotificationType: string | null,
+	_lastNotificationChannel: string | null,
+	lastReminderMedName: string | null,
+	lastReminderTakenBy: string | null,
+	lastStockReminderSent: string | null,
+	_lastStockReminderChannel: string | null,
+	lastStockReminderMedNames: string | null,
+	t: (key: string, options?: Record<string, unknown>) => string,
+	locale: string
+): {
+	status: { text: string; className: string };
+	lowStockMeds: { name: string; daysLeft: number; isCritical: boolean }[];
+	lastStockSent: { date: string; medNames: string | null } | null;
+	lastIntakeSent: { date: string; medName: string | null; takenBy: string | null } | null;
+} {
+	const lowStockMap = new Map<string, { name: string; daysLeft: number; isCritical: boolean }>();
+
+	for (const c of allCoverage) {
+		if (c.medsLeft <= 0) {
+			lowStockMap.set(c.name, { name: c.name, daysLeft: 0, isCritical: true });
+			continue;
+		}
+
+		if (c.daysLeft === null) continue;
+
+		const roundedDaysLeft = Math.round(c.daysLeft);
+		const isCritical = c.daysLeft <= reminderDaysBefore;
+		const isLow = c.daysLeft < lowStockDays;
+		if (!isCritical && !isLow) continue;
+
+		const existing = lowStockMap.get(c.name);
+		if (!existing || roundedDaysLeft < existing.daysLeft || (isCritical && !existing.isCritical)) {
+			lowStockMap.set(c.name, { name: c.name, daysLeft: roundedDaysLeft, isCritical });
+		}
+	}
+
+	const lowStockMeds = Array.from(lowStockMap.values()).sort((a, b) => a.daysLeft - b.daysLeft);
+	const criticalCount = lowStockMeds.filter((m) => m.isCritical).length;
+	const lowCount = lowStockMeds.filter((m) => !m.isCritical).length;
+
+	let status: { text: string; className: string };
+	if (criticalCount > 0) {
+		status = {
+			text: t("dashboard.reminders.criticalMeds", { count: criticalCount }),
+			className: "danger",
+		};
+	} else if (lowCount > 0) {
+		status = {
+			text: t("dashboard.reminders.lowMeds", { count: lowCount }),
+			className: "warning",
+		};
+	} else {
+		status = {
+			text: t("dashboard.reminders.allOk"),
+			className: "success",
+		};
+	}
+
+	let lastStockSent: { date: string; medNames: string | null } | null = null;
+	if (lastStockReminderSent) {
+		const sentDate = new Date(lastStockReminderSent);
+		const formattedDate = sentDate.toLocaleDateString(locale, {
+			day: "2-digit",
+			month: "short",
+			hour: "2-digit",
+			minute: "2-digit",
+		});
+		lastStockSent = {
+			date: formattedDate,
+			medNames: lastStockReminderMedNames,
+		};
+	}
+
+	let lastIntakeSent: { date: string; medName: string | null; takenBy: string | null } | null = null;
+	if (lastAutoEmailSent) {
+		const sentDate = new Date(lastAutoEmailSent);
+		const formattedDate = sentDate.toLocaleDateString(locale, {
+			day: "2-digit",
+			month: "short",
+			hour: "2-digit",
+			minute: "2-digit",
+		});
+		lastIntakeSent = {
+			date: formattedDate,
+			medName: lastReminderMedName,
+			takenBy: lastReminderTakenBy,
+		};
+	}
+
+	return { status, lowStockMeds, lastStockSent, lastIntakeSent };
+}

frontend/src/styles.css

@@ -2212,6 +2212,9 @@ button.has-validation-error {
 .time-main .med-name span.clickable {
 	cursor: pointer;
 }
+.time-main .med-name .med-name-stack.clickable {
+	cursor: pointer;
+}
 .time-main .med-name span.clickable:hover .med-avatar {
 	transform: scale(1.1);
 	box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
@@ -4323,9 +4326,10 @@ button.has-validation-error {
 /* Modal base styles moved to styles/modals-base.css */
 
 /* Medication Detail Modal */
-.med-detail-modal {
+.modal-content.med-detail-modal {
 	padding: 0;
-	width: min(100vw - 1rem, 520px);
+	width: min(100vw - 1rem, 711px);
+	max-width: 711px;
 	max-height: 90vh;
 	background: var(--bg-primary);
 	overscroll-behavior: contain;
@@ -4604,9 +4608,6 @@ button.has-validation-error {
 	align-items: start;
 }
 
-.prescription-detail-grid .med-detail-value {
-}
-
 .med-detail-item {
 	background: var(--bg-secondary);
 	padding: 0.75rem;
@@ -4649,8 +4650,8 @@ button.has-validation-error {
 .med-schedule-item {
 	display: flex;
 	align-items: center;
-	justify-content: flex-start;
-	gap: 1rem;
+	flex-wrap: wrap;
+	gap: 0.35rem 0.75rem;
 	background: var(--bg-secondary);
 	padding: 0.75rem 1rem;
 	border-radius: 8px;
@@ -4664,10 +4665,30 @@ button.has-validation-error {
 
 .med-schedule-freq {
 	color: var(--text-secondary);
+	white-space: nowrap;
 }
 
 .med-schedule-time {
 	font-weight: 500;
+	margin-left: auto;
+	white-space: nowrap;
+}
+
+.med-schedule-person {
+	color: var(--text-secondary);
+	font-size: 0.85rem;
+	white-space: nowrap;
+}
+
+.med-schedule-bell {
+	color: var(--warning);
+	display: inline-flex;
+	align-items: center;
+	margin-left: 0.35rem;
+}
+
+[data-theme="light"] .med-schedule-bell {
+	color: #b45309;
 }
 
 .med-detail-footer {
@@ -4684,12 +4705,12 @@ button.has-validation-error {
 	position: relative;
 	z-index: 1;
 	padding-bottom: calc(1rem + env(safe-area-inset-bottom, 0px));
-	margin: 0 -2rem;
+	margin: 0;
 }
 
 /* Mobile devices can report wide CSS viewports (e.g., 768px in device emulation).
    Use input modality instead of width-only breakpoints so the modal still fills the handset viewport. */
-@media (hover: none) and (pointer: coarse) {
+@media (hover: none) and (pointer: coarse) and (max-width: 500px) {
 	.med-detail-overlay {
 		padding: 0.4rem;
 		align-items: stretch;
@@ -4912,7 +4933,7 @@ button.has-validation-error {
 		justify-content: center;
 		flex-wrap: wrap;
 		gap: 0.75rem;
-		margin: 0 -1.5rem;
+		margin: 0;
 	}
 
 	.med-detail-footer > button {
@@ -4938,7 +4959,7 @@ button.has-validation-error {
 }
 
 /* Hard mobile override for MedDetailModal: remove side frame and use full handset viewport. */
-@media (max-width: 900px) {
+@media (max-width: 500px) {
 	.modal-overlay.med-detail-overlay {
 		padding: 0 !important;
 		align-items: stretch;
@@ -4969,9 +4990,8 @@ button.has-validation-error {
 		margin: 0;
 		padding-left: 1rem;
 		padding-right: 1rem;
-		position: sticky;
-		bottom: 0;
-		z-index: 5;
+		position: relative;
+		z-index: 1;
 	}
 }
 

frontend/src/styles/modals-base.css

@@ -41,6 +41,19 @@
 	padding: 1.5rem;
 }
 
+.modal-content.confirm-modal {
+	margin: 0 auto;
+	width: min(100%, 450px);
+}
+
+@media (max-width: 500px) {
+	.modal-content.confirm-modal {
+		margin: 0 auto;
+		border-radius: 12px;
+		max-height: min(85dvh, 85vh);
+	}
+}
+
 @keyframes slideUp {
 	from {
 		opacity: 0;

frontend/src/styles/schedule-mobile-edit.css

@@ -190,17 +190,27 @@
 }
 
 /* Mobile Edit Modal */
+.mobile-edit-overlay {
+	align-items: flex-start;
+	padding-top: 0.35rem;
+	padding-bottom: 0.35rem;
+}
+
 .edit-modal {
 	max-width: 95vw;
-	max-height: 90vh;
-	overflow-y: auto;
-	padding: 0.75rem;
+	max-height: none;
+	height: min(96dvh, 96vh);
+	padding: 0.6rem;
+	display: flex;
+	flex-direction: column;
+	overflow: hidden;
+	overflow-x: hidden;
 }
 
 .edit-modal-header {
 	display: flex;
 	align-items: center;
-	justify-content: space-between;
+	justify-content: flex-start;
 	gap: 0.75rem;
 	margin-bottom: 1rem;
 }
@@ -208,12 +218,91 @@
 .edit-modal-header h2 {
 	font-size: 1.25rem;
 	margin: 0;
+	text-align: left;
+	min-width: 0;
 }
 
 .mobile-edit-form.form-grid {
-	display: grid;
-	grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
-	gap: 0.75rem 1rem;
+	display: flex;
+	flex-direction: column;
+	gap: 0.5rem;
+	flex: 1;
+	min-height: 0;
+	overflow: hidden;
+	overflow-x: hidden;
+}
+
+.mobile-edit-form .modal-footer {
+	border-top: none;
+	padding: 0.45rem 0.15rem calc(0.45rem + env(safe-area-inset-bottom, 0px));
+	gap: 0.6rem;
+	margin-top: 0;
+}
+
+.mobile-edit-form .readonly-fieldset {
+	display: flex;
+	flex-direction: column;
+	border: 0;
+	margin: 0;
+	padding: 0;
+	min-inline-size: 0;
+	flex: 1;
+	min-height: 0;
+	overflow: hidden;
+	overscroll-behavior: contain;
+}
+
+.mobile-edit-form .readonly-fieldset.swiping-horizontal {
+	overflow-y: hidden;
+}
+
+.mobile-edit-form .mobile-tab-viewport {
+	flex: 1;
+	min-height: 0;
+	overflow: hidden;
+}
+
+.mobile-edit-form .mobile-tab-track {
+	display: flex;
+	height: 100%;
+	will-change: transform;
+}
+
+.mobile-edit-form .mobile-tab-track:not(.is-swiping) {
+	transition: transform 220ms ease;
+}
+
+.mobile-edit-form .mobile-tab-track > .form-tab-panel {
+	display: block;
+	flex: 0 0 100%;
+	min-width: 100%;
+	height: 100%;
+	overflow-y: auto;
+	overflow-x: hidden;
+	-webkit-overflow-scrolling: touch;
+	padding-right: 0.1rem;
+	overscroll-behavior: contain;
+}
+
+.mobile-edit-form .form-tabs {
+	overflow-x: auto;
+	-webkit-overflow-scrolling: touch;
+	scrollbar-width: none;
+}
+
+.mobile-edit-form .form-tabs::-webkit-scrollbar {
+	display: none;
+}
+
+.mobile-edit-form .form-tab {
+	flex: 0 0 auto;
+	min-width: max-content;
+	overflow: visible;
+	text-overflow: clip;
+}
+
+.mobile-edit-form .form-tab-panel.active {
+	display: block;
 }
 
 .mobile-edit-form.form-grid > label {

frontend/src/test/components/Auth.test.tsx

@@ -556,7 +556,7 @@ describe("UserProfile", () => {
 		);
 
 		await waitFor(() => {
-			const cancelBtn = screen.getByText(/common\.cancel/i);
+			const cancelBtn = screen.getByText(/common\.close/i);
 			fireEvent.click(cancelBtn);
 		});
 

frontend/src/test/components/ExportModal.test.tsx

@@ -70,12 +70,12 @@ describe("ExportModal", () => {
 
 	it("renders cancel button", () => {
 		render(<ExportModal {...defaultProps} />);
-		expect(screen.getByText(/exportImport\.cancelButton/i)).toBeInTheDocument();
+		expect(screen.getByText(/common\.close/i)).toBeInTheDocument();
 	});
 
 	it("calls onClose when cancel button is clicked", () => {
 		render(<ExportModal {...defaultProps} />);
-		fireEvent.click(screen.getByText(/exportImport\.cancelButton/i));
+		fireEvent.click(screen.getByText(/common\.close/i));
 		expect(defaultProps.onClose).toHaveBeenCalled();
 	});
 

frontend/src/test/components/Lightbox.test.tsx

@@ -48,9 +48,10 @@ describe("Lightbox", () => {
 
 	it("calls onClose when Escape key is pressed", () => {
 		const onClose = vi.fn();
-		render(<Lightbox {...defaultProps} onClose={onClose} />);
+		const { container } = render(<Lightbox {...defaultProps} onClose={onClose} />);
 
-		fireEvent.keyDown(document, { key: "Escape" });
+		const overlay = container.querySelector(".lightbox-overlay");
+		fireEvent.keyDown(overlay!, { key: "Escape" });
 
 		expect(onClose).toHaveBeenCalled();
 	});

frontend/src/test/components/MedDetailModal.test.tsx

@@ -216,6 +216,32 @@ describe("MedDetailModal", () => {
 		const body = document.querySelector(".med-detail-body");
 		expect(body).toBeInTheDocument();
 	});
+
+	it("shows configured pack count in package details, independent from current stock", () => {
+		const medWithConfiguredPacks: Medication = {
+			...mockMedication,
+			packCount: 11,
+			blistersPerPack: 5,
+			pillsPerBlister: 5,
+		};
+
+		const lowCurrentStockCoverage: Coverage = {
+			...mockCoverage,
+			medsLeft: 47,
+		};
+
+		render(
+			<MedDetailModal
+				{...defaultProps}
+				selectedMed={medWithConfiguredPacks}
+				coverage={{ all: [lowCurrentStockCoverage] }}
+			/>
+		);
+
+		const packsLabel = screen.getByText(/modal\.packs/i);
+		const packsValue = packsLabel.closest(".med-detail-item")?.querySelector(".med-detail-value");
+		expect(packsValue?.textContent).toBe("11");
+	});
 });
 
 describe("MedDetailModal without coverage", () => {
@@ -744,7 +770,7 @@ describe("MedDetailModal stock overflow warning", () => {
 		vi.clearAllMocks();
 	});
 
-	it("does not show overflow warning icon with live stock denominator", () => {
+	it("shows overflow warning icon when stock exceeds blister package capacity", () => {
 		const overflowCoverage: Coverage = {
 			name: "Test Med",
 			medsLeft: 49,
@@ -756,9 +782,9 @@ describe("MedDetailModal stock overflow warning", () => {
 
 		render(<MedDetailModal {...defaultProps} coverage={{ all: [overflowCoverage] }} />);
 
-		// Live denominator uses current stock, so overflow warning is not shown in detail row.
+		// For blister meds, denominator is package capacity (not current stock), so overflow is shown.
 		const warningIcon = document.querySelector(".info-tooltip.tooltip-align-left.warning-text");
-		expect(warningIcon).not.toBeInTheDocument();
+		expect(warningIcon).toBeInTheDocument();
 	});
 
 	it("does not show warning icon when stock is within package capacity", () => {

frontend/src/test/components/ReportModal.test.tsx

@@ -30,7 +30,7 @@ describe("ReportModal", () => {
 		render(<ReportModal isOpen={true} onClose={onClose} medications={[createMedication()]} />);
 
 		expect(screen.getByText(/report\.title/i)).toBeInTheDocument();
-		fireEvent.click(screen.getByRole("button", { name: /common\.cancel/i }));
+		fireEvent.click(screen.getByRole("button", { name: /common\.close/i }));
 		expect(onClose).toHaveBeenCalledTimes(1);
 	});
 

frontend/src/test/components/ShareDialog.test.tsx

@@ -54,7 +54,8 @@ describe("ShareDialog", () => {
 
 	it("calls onClose when close button is clicked", () => {
 		render(<ShareDialog {...defaultProps} />);
-		fireEvent.click(screen.getByRole("button", { name: /common\.close/i }));
+		const closeButtons = screen.getAllByRole("button", { name: /common\.close/i });
+		fireEvent.click(closeButtons[closeButtons.length - 1]);
 		expect(defaultProps.onClose).toHaveBeenCalled();
 	});
 

frontend/src/test/hooks/useMedications.test.ts

@@ -1,6 +1,7 @@
 import { act, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { useMedications } from "../../hooks/useMedications";
+import type { Medication } from "../../types";
 
 describe("useMedications", () => {
 	beforeEach(() => {
@@ -193,7 +194,7 @@ describe("useMedications", () => {
 	it("allows setting meds directly", () => {
 		const { result } = renderHook(() => useMedications());
 
-		const newMeds = [{ id: 1, name: "NewMed" }] as any;
+		const newMeds: Array<Pick<Medication, "id" | "name">> = [{ id: 1, name: "NewMed" }];
 
 		act(() => {
 			result.current.setMeds(newMeds);

frontend/src/test/hooks/useSettings.test.ts

@@ -245,8 +245,8 @@ describe("useSettings", () => {
 			await result.current.saveSettings(mockEvent);
 		});
 
-		// emailEnabled should be false in the saved state
-		expect(result.current.settings.emailEnabled).toBe(false);
+		// Local state preserves user choice; backend receives effective value via payload
+		expect(result.current.settings.emailEnabled).toBe(true);
 	});
 
 	it("auto-disables shoutrrr when URL is empty", async () => {
@@ -274,7 +274,8 @@ describe("useSettings", () => {
 			await result.current.saveSettings(mockEvent);
 		});
 
-		expect(result.current.settings.shoutrrrEnabled).toBe(false);
+		// Local state preserves user choice; backend receives effective value via payload
+		expect(result.current.settings.shoutrrrEnabled).toBe(true);
 	});
 
 	it("refreshes reminder status on interval", async () => {

frontend/src/test/pages/DashboardPage.test.tsx

@@ -1,15 +1,15 @@
 import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import { MemoryRouter } from "react-router-dom";
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { DashboardPage } from "../../pages/DashboardPage";
 import {
-	DashboardPage,
 	formatFullBlisters,
 	formatOpenBlisterAndLoose,
 	getBlisterStock,
 	getMedTotal,
 	getReminderStatusData,
 	userStorageKey,
-} from "../../pages/DashboardPage";
+} from "../../pages/dashboard-helpers";
 
 // Mock data for tests with medications
 const mockMeds = [
@@ -181,6 +181,7 @@ const createMockAppContext = (overrides = {}) => ({
 	missedPastDoseIds: [],
 	getDayStockStatus: vi.fn(() => "success"),
 	getDoseId: vi.fn((id, person) => (person ? `${id}-${person}` : id)),
+	isDoseTakenAutomatically: vi.fn(() => false),
 	showClearMissedConfirm: false,
 	setShowClearMissedConfirm: vi.fn(),
 	clearingMissed: false,
@@ -198,7 +199,7 @@ describe("DashboardPage helper functions", () => {
 	});
 
 	it("calculates blister stock breakdown", () => {
-		expect(getBlisterStock(27, 10, 0, 27)).toEqual({ fullBlisters: 2, openBlisterPills: 7, loosePills: 7 });
+		expect(getBlisterStock(27, 10, 0, 27)).toEqual({ fullBlisters: 2, openBlisterPills: 7, loosePills: 0 });
 	});
 
 	it("formats blister and open blister labels", () => {
@@ -206,7 +207,7 @@ describe("DashboardPage helper functions", () => {
 		expect(formatFullBlisters(1, t)).toBe("1 common.blister");
 		expect(formatFullBlisters(3, t)).toBe("3 common.blisters");
 		expect(formatOpenBlisterAndLoose(0, 0, 10, t)).toBe("-");
-		expect(formatOpenBlisterAndLoose(4, 4, 10, t)).toBe("4 common.of 10 common.pills");
+		expect(formatOpenBlisterAndLoose(4, 4, 10, t)).toBe("4 common.of 10 common.pills + 4 modal.loosePills");
 	});
 
 	it("computes total pills for blister and bottle types", () => {

frontend/src/test/pages/MedicationsPage.test.tsx

@@ -124,6 +124,7 @@ const fetchMock = vi.fn();
 vi.mock("../../hooks", () => ({
 	useMedicationForm: () => mockFormHookValue,
 	useUnsavedChangesWarning: () => ({}),
+	useModalHistory: vi.fn(),
 }));
 
 vi.mock("../../context", () => ({

frontend/src/test/pages/SchedulePage.test.tsx

@@ -111,6 +111,7 @@ const createMockContext = (overrides = {}) => ({
 	manuallyExpandedDays: new Set(),
 	toggleDayCollapse: vi.fn(),
 	openUserFilter: vi.fn(),
+	isDoseTakenAutomatically: vi.fn(() => false),
 	missedPastDoseIds: [],
 	...overrides,
 });

frontend/src/test/utils/formatters.test.ts

@@ -201,7 +201,7 @@ describe("getBlisterStock", () => {
 
 		const result = getBlisterStock(med);
 		expect(result.fullBlisters).toBe(2); // 25 / 10 = 2
-		expect(result.openBlisterPills).toBe(5); // 25 % 10 = 5
+		expect(result.openBlisterPills).toBe(0); // 20 % 10 = 0 after preserving loose tablets
 		expect(result.loosePills).toBe(5);
 	});
 

frontend/src/types/index.ts

@@ -69,6 +69,7 @@ export type PlannerRow = {
 	medicationId: number;
 	medicationName: string;
 	totalPills: number;
+	currentPills?: number;
 	plannerUsage: number;
 	blisterSize: number;
 	blistersNeeded: number;

frontend/src/utils/formatters.ts

@@ -3,6 +3,8 @@
 // =============================================================================
 
 import type { BlisterStock, Medication } from "../types";
+import { getMedTotal } from "../types";
+import { splitCurrentBlisterStock } from "./stock";
 
 /**
  * Map timezone to region code (ISO 3166-1 alpha-2).
@@ -302,12 +304,7 @@ export function getExpiryClass(expiryDate: string | null | undefined, thresholdD
  * Calculate blister stock breakdown for a medication
  */
 export function getBlisterStock(med: Medication): BlisterStock {
-	const total =
-		med.packCount * med.blistersPerPack * med.pillsPerBlister + med.looseTablets + (med.stockAdjustment ?? 0);
-	const bSize = med.pillsPerBlister;
-	const fullBlisters = Math.floor(total / bSize);
-	const openBlisterPills = total % bSize;
-	return { fullBlisters, openBlisterPills, loosePills: openBlisterPills };
+	return splitCurrentBlisterStock(getMedTotal(med), med.pillsPerBlister, med.looseTablets);
 }
 
 /**

frontend/src/utils/index.ts

@@ -5,4 +5,5 @@
 export * from "./formatters";
 export * from "./ics";
 export * from "./schedule";
+export * from "./stock";
 export * from "./storage";

frontend/src/utils/stock.ts

@@ -0,0 +1,43 @@
+import type { Medication } from "../types";
+
+export type BlisterStockSplit = {
+	fullBlisters: number;
+	openBlisterPills: number;
+	loosePills: number;
+};
+
+/**
+ * Split current blister stock into sealed full blisters, open blister pills,
+ * and loose pills using the configured loose-tablets baseline.
+ */
+export function splitCurrentBlisterStock(
+	currentPills: number,
+	pillsPerBlister: number,
+	configuredLooseTablets: number
+): BlisterStockSplit {
+	if (pillsPerBlister <= 0 || pillsPerBlister === 1) {
+		return { fullBlisters: 0, openBlisterPills: 0, loosePills: Math.max(0, currentPills) };
+	}
+
+	const safeCurrent = Math.max(0, currentPills);
+	const loosePills = Math.min(safeCurrent, Math.max(0, configuredLooseTablets));
+	const sealedPills = Math.max(0, safeCurrent - loosePills);
+
+	return {
+		fullBlisters: Math.floor(sealedPills / pillsPerBlister),
+		openBlisterPills: sealedPills % pillsPerBlister,
+		loosePills,
+	};
+}
+
+/**
+ * Convenience helper when medication object already contains stock fields.
+ */
+export function getBlisterStockFromMedication(med: Medication): BlisterStockSplit {
+	const total =
+		(med.packageType === "bottle"
+			? med.looseTablets + (med.stockAdjustment ?? 0)
+			: med.packCount * med.blistersPerPack * med.pillsPerBlister + med.looseTablets + (med.stockAdjustment ?? 0)) ?? 0;
+
+	return splitCurrentBlisterStock(total, med.pillsPerBlister, med.looseTablets);
+}