Reminder subsystem: exact alarms, escalation, boot re-arm — verified on emulator

Milestone 4. AlarmScheduler is the only AlarmManager writer; one stable
PendingIntent requestCode per dose-time means re-arming replaces and can
never stack (the no-drift invariant is OS-enforced). DoseAlarmReceiver
handles both occurrence and escalation alarms idempotently and always
re-arms the next occurrence before anything else so the chain can't
break. nagCount lives in dose_log so the ~6-nag cap survives reboot.
SCHEDULE_EXACT_ALARM added maxSdk 32 (USE_EXACT_ALARM is 33+ only).

Emulator-verified (API 35): exact alarm armed (window=0,
policy_permission), fired on time, HIGH notification with Tatt/Utsett,
escalation armed +10 min, next day re-armed, Tatt → TAKEN + inventory
10→9 + escalation cancelled, reboot → BootReceiver re-armed everything.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

app/src/main/java/no/naiv/meddetsamme/alarm/DoseActionReceiver.kt

@@ -0,0 +1,72 @@
+package no.naiv.meddetsamme.alarm
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import no.naiv.meddetsamme.data.DoseStatus
+import no.naiv.meddetsamme.data.MedDatabase
+import no.naiv.meddetsamme.notify.Notifications
+
+/**
+ * Handles the notification actions (and later, the same actions from the UI).
+ *
+ * Contract (CLAUDE.md, load-bearing):
+ * - Taken  → TAKEN, decrement inventory by the *logged* amount, stop escalating.
+ * - Snooze → SNOOZED, next nag in 15 min, keeps escalating (and counting) after.
+ * - Skip   → SKIPPED, stop escalating, no inventory change.
+ */
+class DoseActionReceiver : BroadcastReceiver() {
+
+    companion object {
+        const val ACTION_TAKEN = "no.naiv.meddetsamme.action.TAKEN"
+        const val ACTION_SNOOZE = "no.naiv.meddetsamme.action.SNOOZE"
+        const val ACTION_SKIP = "no.naiv.meddetsamme.action.SKIP"
+        const val EXTRA_LOG_ID = "logId"
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val logId = intent.getLongExtra(EXTRA_LOG_ID, -1)
+        if (logId < 0) return
+        val action = intent.action ?: return
+        val pending = goAsync()
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                handle(context, action, logId)
+            } finally {
+                pending.finish()
+            }
+        }
+    }
+
+    private suspend fun handle(context: Context, action: String, logId: Long) {
+        val db = MedDatabase.get(context)
+        val scheduler = AlarmScheduler(context)
+        val log = db.doseLogDao().getById(logId) ?: return
+        val now = System.currentTimeMillis()
+
+        when (action) {
+            ACTION_TAKEN -> {
+                // Idempotence: double-tap on a laggy notification must not
+                // decrement stock twice.
+                if (log.status == DoseStatus.TAKEN) return
+                db.doseLogDao().setStatus(logId, DoseStatus.TAKEN, now)
+                db.medicationDao().decrementInventory(log.medId, log.amount)
+                scheduler.cancelEscalation(logId)
+                Notifications.cancel(context, Notifications.doseNotificationId(logId))
+            }
+            ACTION_SNOOZE -> {
+                db.doseLogDao().setStatus(logId, DoseStatus.SNOOZED, now)
+                scheduler.armEscalation(logId, delayMinutes = AlarmScheduler.SNOOZE_MINUTES)
+                Notifications.cancel(context, Notifications.doseNotificationId(logId))
+            }
+            ACTION_SKIP -> {
+                db.doseLogDao().setStatus(logId, DoseStatus.SKIPPED, now)
+                scheduler.cancelEscalation(logId)
+                Notifications.cancel(context, Notifications.doseNotificationId(logId))
+            }
+        }
+    }
+}