feat(alarmas): surface the three native scheduling failures in Dart

Completes the bridge the native side already exposed. AlarmScheduler and
PluriWaveAlarmService record a pre-notice that could not be armed, a
refused foreground-service start, and a per-alarm reschedule that failed
after a reboot -- but nothing read them, so all three still ended at
logcat.

EstadoAlarmas now drains them at startup and turns each into a per-alarm
exception, which the card already knows how to mark. An alarm that never
reached the OS stops looking identical to one that did.

The read is deliberately tolerant: a failure to read is logged and
swallowed, never surfaced as an alarm error, so a diagnostics gap cannot
masquerade as a scheduling problem.

lib/estado/estado_alarmas.dart

@@ -90,6 +90,7 @@ class EstadoAlarmas extends ChangeNotifier {
       );
       await _sincronizarTodas();
       await cargarDiagnostico();
+      await cargarFallosNativos();
       _activarRefresco();
     } catch (e) {
       _error = 'No se pudieron cargar las alarmas: $e';
@@ -228,10 +229,22 @@ class EstadoAlarmas extends ChangeNotifier {
 
   /// Clears a previously recorded scheduling failure once a later attempt
   /// for the same alarm succeeds (D5-style recovery, mirroring how [_error]
-  /// itself already clears on a successful retry).
+  /// itself already clears on a successful retry). Type-scoped: a
+  /// successful `android.programar` call only proves the MAIN alarm
+  /// registration (and, transitively, that any stale post-boot reschedule
+  /// failure no longer applies) -- it says nothing about the pre-notice or
+  /// foreground-service subsystems, so those are left untouched here.
   Future<void> _limpiarFalloProgramacion(String alarmaId) async {
     try {
-      final config = await servicio.limpiarFalloProgramacion(alarmaId);
+      var config = await servicio.limpiarFalloProgramacion(
+        alarmaId,
+        ExcepcionAlarma.tipoFalloProgramacion,
+      );
+      _aplicar(config);
+      config = await servicio.limpiarFalloProgramacion(
+        alarmaId,
+        ExcepcionAlarma.tipoFalloReprogramacionArranque,
+      );
       _aplicar(config);
     } catch (e) {
       debugPrint('[PluriWave][alarmas] limpiar fallo programacion ERROR $e');
@@ -525,6 +538,39 @@ class EstadoAlarmas extends ChangeNotifier {
     notifyListeners();
   }
 
+  /// Drains the failures the NATIVE side recorded on its own and turns each
+  /// into a per-alarm exception, so the card can mark it.
+  ///
+  /// These three paths used to log to logcat and stop there: a pre-notice
+  /// that could not be armed, a refused foreground-service start when the
+  /// alarm should have rung, and a per-alarm reschedule that failed after a
+  /// reboot. None of them run inside a Dart call, so nothing on this side
+  /// ever learned they happened — an alarm could sit switched on in the
+  /// list having never reached the OS. Reading them at startup is what
+  /// makes the reported "as if there were no alarm" visible.
+  ///
+  /// Deliberately tolerant: a failed read is logged and swallowed, never
+  /// surfaced as an alarm error, because a diagnostics gap must not look
+  /// like a scheduling problem.
+  Future<void> cargarFallosNativos() async {
+    try {
+      final fallos = await android.fallosNativosProgramacion();
+      for (final fallo in fallos) {
+        final alarmaId = fallo['alarmaId'] as String?;
+        final tipo = fallo['tipo'] as String?;
+        if (alarmaId == null || tipo == null) continue;
+        await _registrarFalloProgramacion(alarmaId, tipo: tipo);
+      }
+      if (fallos.isNotEmpty) {
+        debugPrint(
+          '[PluriWave][alarmas] fallos nativos recogidos=${fallos.length}',
+        );
+      }
+    } catch (e) {
+      debugPrint('[PluriWave][alarmas] cargar fallos nativos ERROR $e');
+    }
+  }
+
   /// Records a snooze the native layer performed by itself (Decision 2.1).
   /// The native scheduler already re-registered setAlarmClock, so this only
   /// persists the canonical state — it MUST NOT call android.programar again.
@@ -624,6 +670,60 @@ class EstadoAlarmas extends ChangeNotifier {
       debugPrint('[PluriWave][alarmas] sincronizar nativas ERROR $e');
     }
     await _importarSnoozesNativosActivos();
+    await _importarFallosProgramacionNativos();
+  }
+
+  /// Cold-start sync (fix/alarmas-fallos-silenciosos, item 2): imports
+  /// scheduling-reliability failures the NATIVE side recorded on its own --
+  /// a pre-notice `SecurityException`, a refused foreground-service start,
+  /// or a per-alarm reschedule failure after boot/unlock -- none of which
+  /// ever go through a Dart method-channel call that could throw. Without
+  /// this sync, these three failures stayed invisible forever (only
+  /// logcat), even after this app-launch fix reads them.
+  Future<void> _importarFallosProgramacionNativos() async {
+    try {
+      final fallos = await android.obtenerFallosProgramacionNativos();
+      final reportadoPorAlarma = {
+        for (final fallo in fallos) fallo.alarmaId: fallo,
+      };
+      // Reconcile stale copies: the native side clears its OWN record the
+      // next time that specific subsystem succeeds (pre-notice/foreground-
+      // service), so an alarm previously imported with one of those tipos
+      // that is no longer reported here means it already recovered --
+      // without this, the card would keep showing a problem that fixed
+      // itself. `tipoFalloProgramacion`/`tipoFalloReprogramacionArranque`
+      // are NOT reconciled here -- those already clear on the Dart side's
+      // own successful `android.programar` calls.
+      for (final alarma in _alarmas) {
+        final actual = ultimaExcepcionPara(alarma.id);
+        final esTipoReconciliable =
+            actual != null &&
+            (actual.tipo == ExcepcionAlarma.tipoFalloPreaviso ||
+                actual.tipo == ExcepcionAlarma.tipoFalloServicioSonido);
+        if (esTipoReconciliable && !reportadoPorAlarma.containsKey(alarma.id)) {
+          final config = await servicio.limpiarFalloProgramacion(
+            alarma.id,
+            actual.tipo,
+          );
+          _aplicar(config);
+        }
+      }
+      for (final fallo in fallos) {
+        final config = await servicio.registrarFalloProgramacion(
+          fallo.alarmaId,
+          fallo.ocurridoEn,
+          fallo.tipo,
+        );
+        _aplicar(config);
+      }
+      if (fallos.isNotEmpty) {
+        debugPrint(
+          '[PluriWave][alarmas] fallos nativos importados count=${fallos.length}',
+        );
+      }
+    } catch (e) {
+      debugPrint('[PluriWave][alarmas] importar fallos nativos ERROR $e');
+    }
   }
 
   /// Cold-start half of Decision 2.1: imports snoozes the native scheduler