react-native-notify-kit 10.7.2 → 10.8.1

package/android/src/test/java/app/notifee/core/ForegroundServiceTest.java

@@ -1,22 +1,30 @@
 package app.notifee.core;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import android.app.ForegroundServiceStartNotAllowedException;
+import android.app.InvalidForegroundServiceTypeException;
+import android.app.MissingForegroundServiceTypeException;
 import android.app.Notification;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.app.Service;
 import android.content.ComponentName;
 import android.content.Context;
+import android.content.ContextWrapper;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.content.pm.ServiceInfo;
+import android.os.Build;
 import android.os.Bundle;
+import android.os.Looper;
 import androidx.core.app.NotificationCompat;
 import app.notifee.core.event.ForegroundServiceEvent;
 import app.notifee.core.event.NotificationEvent;
@@ -24,6 +32,14 @@ import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import org.greenrobot.eventbus.Subscribe;
 import org.greenrobot.eventbus.ThreadMode;
 import org.junit.After;
@@ -37,28 +53,4258 @@ import org.robolectric.android.controller.ServiceController;
 import org.robolectric.annotation.Config;
 import org.robolectric.annotation.Implementation;
 import org.robolectric.annotation.Implements;
+import org.robolectric.shadows.ShadowLog;
 import org.robolectric.shadows.ShadowNotificationManager;
 import org.robolectric.shadows.ShadowService;
 
 @RunWith(RobolectricTestRunner.class)
 public class ForegroundServiceTest {
 
+  private final List<ServiceController<ForegroundService>> controllers = new ArrayList<>();
+
   @Before
   public void setUp() {
     // Initialize ContextHolder so the service can access the application context
     ContextHolder.setApplicationContext(RuntimeEnvironment.getApplication());
   }
 
-  @After
-  public void tearDown() throws Exception {
-    // Reset public and private static fields to prevent cross-test pollution. The three private
-    // statics are cleared via reflection here so that tests which seed them directly (to exercise
-    // onTimeout without running the full START path) cannot leak state into neighbouring tests.
-    ForegroundService.mCurrentNotificationId = null;
-    ForegroundService.mCurrentForegroundServiceType = -1;
-    setPrivateStatic("mCurrentNotificationBundle", null);
-    setPrivateStatic("mCurrentNotification", null);
-    setPrivateStatic("mCurrentHashCode", 0);
+  @After
+  public void tearDown() throws Exception {
+    for (int i = controllers.size() - 1; i >= 0; i--) {
+      controllers.get(i).destroy();
+    }
+    org.robolectric.Shadows.shadowOf(Looper.getMainLooper()).idle();
+    ContextHolder.setApplicationContext(RuntimeEnvironment.getApplication());
+    // Reset caches and lifecycle registries only after runtime observations, so preserved
+    // UNKNOWN obligations and services created directly cannot leak into neighbouring tests.
+    ForegroundService.mCurrentNotificationId = null;
+    ForegroundService.mCurrentForegroundServiceType = -1;
+    setPrivateStatic("mCurrentNotificationBundle", null);
+    setPrivateStatic("mCurrentNotification", null);
+    setPrivateStatic("mCurrentHashCode", 0);
+    // Undelivered UNKNOWN obligations must survive runtime teardown, but never leak across tests.
+    issue81Pending().clear();
+    setPrivateStatic("sStopRequest", null);
+    setPrivateStatic("sRunGeneration", 0L);
+    setPrivateStatic("sInstance", null);
+    setPrivateStatic("sStateOwner", null);
+    SliceAShadowService.reset();
+  }
+
+  // Slice A's platform model deliberately separates acceptance, delivery, promotion and stop.
+  // Its state is a host oracle, not a simulation claiming to reproduce AMS/Binder semantics.
+  private ForegroundService sliceAService(int type) throws Exception {
+    SliceAShadowService.reset();
+    declareForegroundServiceTypes(type);
+    createChannel();
+    ForegroundService service = buildService().create().get();
+    sliceADeliver(service, buildStartIntent("slice-a", 820, "A", type), 1);
+    return service;
+  }
+
+  private static SliceAShadowService sliceAPlatform(ForegroundService service) {
+    return (SliceAShadowService) org.robolectric.Shadows.shadowOf(service);
+  }
+
+  private static void sliceADeliver(ForegroundService service, Intent intent, int id) {
+    SliceAShadowService platform = sliceAPlatform(service);
+    platform.accepted = Math.max(platform.accepted, id);
+    platform.delivered = id;
+    service.onStartCommand(intent, 0, id);
+  }
+
+  private static void sliceATimeout(ForegroundService service, int id) {
+    service.onTimeout(id, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+  }
+
+  @Test
+  @Config(
+      sdk = {34, 35},
+      shadows = SliceAShadowService.class)
+  public void sliceA_demotionPrecedesDestructiveRetirementAndEventWork() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    Object runner = issue81Field(service, "mRunnerToken");
+    SliceAShadowService.beforeDemotion =
+        () -> {
+          try {
+            assertCurrentState("slice-a", 820, "A");
+            assertSame(runner, issue81Field(service, "mRunnerToken"));
+            assertTrue(SliceAShadowService.order.isEmpty());
+          } catch (Exception e) {
+            throw new AssertionError(e);
+          }
+        };
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      sliceATimeout(service, 1);
+      assertEquals(
+          java.util.Arrays.asList("demote", "stop:1", "event"),
+          SliceAShadowService.order.stream()
+              .filter(x -> !x.equals("log"))
+              .collect(java.util.stream.Collectors.toList()));
+      assertEquals(1, events.events.size());
+      assertEquals(9, events.events.get(0).getType());
+      assertFalse(sliceAPlatform(service).foreground);
+      assertTrue(sliceAPlatform(service).stopped);
+      assertNull(ForegroundService.mCurrentNotificationId);
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_oldInstanceAndOldRunPreserveSuccessor() throws Exception {
+    ForegroundService old = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    ForegroundService current = buildService().create().get();
+    sliceADeliver(
+        current,
+        buildStartIntent("new", 821, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+        2);
+    SliceAShadowService.order.clear();
+    sliceATimeout(old, 1);
+    assertTrue(SliceAShadowService.order.isEmpty());
+    assertCurrentState("new", 821, "B");
+    sliceADeliver(current, buildStopIntent(), 3);
+    sliceADeliver(
+        current,
+        buildStartIntent("new", 821, "C", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+        4);
+    SliceAShadowService.order.clear();
+    sliceATimeout(current, 2);
+    assertTrue(SliceAShadowService.order.isEmpty());
+    assertCurrentState("new", 821, "C");
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_ambiguousCompatibleCallbackDemotesWithoutSuccessorStop() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    // No immutable Android epoch is available for this coincident callback ID after type promotion.
+    sliceADeliver(
+        service,
+        buildStartIntent(
+            "slice-a",
+            820,
+            "B",
+            ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+                | ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK),
+        2);
+    SliceAShadowService.order.clear();
+    sliceATimeout(service, 2);
+    assertFalse(sliceAPlatform(service).foreground);
+    assertFalse(sliceAPlatform(service).stopped);
+    assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_unknownCallbackIdCompatibleDemotesWithoutBorrowingDeliveredId()
+      throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    sliceATimeout(service, 99);
+    assertFalse(sliceAPlatform(service).foreground);
+    assertFalse(sliceAPlatform(service).stopped);
+    assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_incompatibleTypeAndSingleArgumentDoNothing() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    service.onTimeout(1, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK);
+    service.onTimeout(1);
+    assertTrue(SliceAShadowService.order.isEmpty());
+    assertTrue(sliceAPlatform(service).foreground);
+    assertCurrentState("slice-a", 820, "A");
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_reservedUnknownAndAcceptedUndeliveredStartsRemainHeld() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    RecordingServiceContext context = useRecordingContext();
+    context.startFailure = new RuntimeException("lost Binder reply");
+    assertThrows(
+        RuntimeException.class,
+        () ->
+            ForegroundService.start(821, buildNotification(), buildNotificationBundle("pending")));
+    Object pending = issue81Pending().values().iterator().next();
+    sliceAPlatform(service).accepted = 2;
+    sliceATimeout(service, 1);
+    assertEquals(1, issue81Pending().size());
+    assertSame(pending, issue81Pending().values().iterator().next());
+    assertFalse(sliceAPlatform(service).foreground);
+    assertFalse(sliceAPlatform(service).stopped);
+    assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+    assertTrue(
+        ShadowLog.getLogsForTag("NOTIFEE").stream().anyMatch(x -> x.msg.contains("stop=deferred")));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_acceptedButUndeliveredAmsStartRefusesConditionalStop() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    sliceAPlatform(service).accepted = 2; // framework accepted another START outside the registry
+    sliceATimeout(service, 1);
+    assertEquals(1, sliceAPlatform(service).delivered);
+    assertFalse(sliceAPlatform(service).stopped);
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+    assertTrue(
+        ShadowLog.getLogsForTag("NOTIFEE").stream().anyMatch(x -> x.msg.contains("stop=refused")));
+  }
+
+  @Test
+  @Config(
+      sdk = {34, 35},
+      shadows = SliceAShadowService.class)
+  public void sliceA_shortServiceInitialIdStopsLatestSatisfiedSameRun() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+    sliceADeliver(
+        service,
+        buildStartIntent("slice-a", 820, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        2);
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      service.onTimeout(1);
+      assertTrue(sliceAPlatform(service).stopped);
+      assertTrue(SliceAShadowService.order.contains("stop:2"));
+      assertEquals("B", events.events.get(0).getNotification().toBundle().getString("title"));
+      assertEquals(1, events.events.get(0).getExtras().getInt("startId"));
+      assertEquals(-1, events.events.get(0).getExtras().getInt("fgsType"));
+      assertEquals(1, sliceAPlatform(service).promotions);
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_failedUpdateRetainsLatestA() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAShadowService.promotionFailure = new SecurityException("update B failed");
+    assertThrows(
+        SecurityException.class,
+        () ->
+            sliceADeliver(
+                service,
+                buildStartIntent(
+                    "slice-a", 820, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK),
+                2));
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      sliceATimeout(service, 1);
+      assertEquals("A", events.events.get(0).getNotification().toBundle().getString("title"));
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_stopRefusalIsNotSuccessAndIsNotRetried() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAShadowService.stopResult = false;
+    sliceATimeout(service, 1);
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+    sliceATimeout(service, 1);
+    idleMain();
+    assertEquals(1, SliceAShadowService.order.stream().filter(x -> x.startsWith("stop:")).count());
+    assertTrue(
+        ShadowLog.getLogsForTag("NOTIFEE").stream().anyMatch(x -> x.msg.contains("stop=refused")));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_stopThrowStillAttemptsEventAndPropagatesOriginal() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    RuntimeException failure = new SecurityException("stop failure");
+    SliceAShadowService.stopFailure = failure;
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      assertSame(failure, assertThrows(RuntimeException.class, () -> sliceATimeout(service, 1)));
+      assertEquals(1, events.events.size());
+      assertNull(ForegroundService.mCurrentNotificationId);
+      assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+      sliceATimeout(service, 1);
+      assertEquals(1, events.events.size());
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_demotionThrowPreservesEvidenceAndPrimaryEvenWhenStopThrows() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    Object runner = issue81Field(service, "mRunnerToken");
+    RuntimeException primary = new SecurityException("demotion failure");
+    RuntimeException secondary = new IllegalStateException("fallback failure");
+    SliceAShadowService.demotionFailure = primary;
+    SliceAShadowService.stopFailure = secondary;
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      assertSame(primary, assertThrows(RuntimeException.class, () -> sliceATimeout(service, 1)));
+      assertCurrentState("slice-a", 820, "A");
+      assertSame(runner, issue81Field(service, "mRunnerToken"));
+      assertTrue(sliceAPlatform(service).foreground);
+      assertEquals(1, events.events.size());
+      assertTrue(java.util.Arrays.asList(primary.getSuppressed()).contains(secondary));
+      sliceATimeout(service, 1);
+      assertEquals(1, events.events.size());
+      assertEquals(1, SliceAShadowService.order.stream().filter(x -> x.equals("demote")).count());
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_demotionThrowFallbackAcceptedRetiresButStillThrows() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    RuntimeException failure = new SecurityException("demotion failure");
+    SliceAShadowService.demotionFailure = failure;
+    assertSame(failure, assertThrows(RuntimeException.class, () -> sliceATimeout(service, 1)));
+    assertTrue(sliceAPlatform(service).stopped);
+    assertTrue((boolean) issue81Field(service, "mStopInitiated"));
+    assertNull(ForegroundService.mCurrentNotificationId);
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_demotionThrowWithPendingDoesNotFallback() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    useRecordingContext();
+    ForegroundService.start(821, buildNotification(), buildNotificationBundle("pending"));
+    sliceAPlatform(service).accepted = 2;
+    RuntimeException failure = new SecurityException("demotion failure");
+    SliceAShadowService.demotionFailure = failure;
+    assertSame(failure, assertThrows(RuntimeException.class, () -> sliceATimeout(service, 1)));
+    assertCurrentState("slice-a", 820, "A");
+    assertEquals(1, issue81Pending().size());
+    assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_duplicatesAcrossOverloadsAttemptOnce() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      service.onTimeout(1);
+      service.onTimeout(1, ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+      service.onTimeout(1);
+      assertEquals(1, events.events.size());
+      assertEquals(1, SliceAShadowService.order.stream().filter(x -> x.equals("demote")).count());
+      assertEquals(
+          1, SliceAShadowService.order.stream().filter(x -> x.startsWith("stop:")).count());
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_multipleTypeMaskPreservesOriginalMetadata() throws Exception {
+    int mask =
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+            | ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK;
+    ForegroundService service = sliceAService(mask);
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      service.onTimeout(1, mask);
+      assertFalse(sliceAPlatform(service).foreground);
+      assertEquals(mask, events.events.get(0).getExtras().getInt("fgsType"));
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_reentrantPromotionAfterDemotionProtectsSuccessor() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAShadowService.afterDemotion =
+        () ->
+            sliceADeliver(
+                service,
+                buildStartIntent(
+                    "slice-a", 820, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+                2);
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      sliceATimeout(service, 1);
+      assertCurrentState("slice-a", 820, "B");
+      assertTrue(sliceAPlatform(service).foreground);
+      assertTrue((boolean) issue81Field(service, "mForegroundActive"));
+      assertNotNull(issue81Field(service, "mRunnerToken"));
+      assertFalse(sliceAPlatform(service).stopped);
+      assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+      assertEquals("A", events.events.get(0).getNotification().toBundle().getString("title"));
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_reentrantReservationDuringDemotionDefersStop() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    useRecordingContext();
+    SliceAShadowService.afterDemotion =
+        () -> {
+          ForegroundService.start(821, buildNotification(), buildNotificationBundle("pending"));
+          sliceAPlatform(service).accepted = 2;
+        };
+    sliceATimeout(service, 1);
+    assertEquals(1, issue81Pending().size());
+    assertFalse(sliceAPlatform(service).stopped);
+    assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_reentrantStopReplyCannotMarkSuccessorStopped() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAShadowService.afterStop =
+        () ->
+            sliceADeliver(
+                service,
+                buildStartIntent("new", 821, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+                2);
+    sliceATimeout(service, 1);
+    assertCurrentState("new", 821, "B");
+    assertTrue((boolean) issue81Field(service, "mForegroundActive"));
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_timeoutAndStopInBothOrders() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    sliceATimeout(service, 1);
+    ForegroundService.stop();
+    idleMain();
+    assertEquals(1, SliceAShadowService.order.stream().filter(x -> x.startsWith("stop:")).count());
+    sliceADeliver(
+        service,
+        buildStartIntent("new", 821, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+        2);
+    ForegroundService.stop();
+    idleMain();
+    SliceAShadowService.order.clear();
+    sliceATimeout(service, 2);
+    assertTrue(SliceAShadowService.order.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_timeoutAndRunnerCompletionInBothOrders() throws Exception {
+    SliceAShadowService.reset();
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    createChannel();
+    ForegroundService service = buildService().create().get();
+    FgsRunnerCapture runners = new FgsRunnerCapture();
+    EventBus.register(runners);
+    try {
+      sliceADeliver(
+          service,
+          buildStartIntent("slice-a", 820, "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+          1);
+      sliceATimeout(service, 1);
+      runners.events.get(0).setCompletionResult();
+      assertEquals(1, SliceAShadowService.order.stream().filter(x -> x.equals("demote")).count());
+      sliceADeliver(
+          service,
+          buildStartIntent("new", 821, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+          2);
+      runners.events.get(1).setCompletionResult();
+      SliceAShadowService.order.clear();
+      sliceATimeout(service, 2);
+      assertTrue(SliceAShadowService.order.isEmpty());
+    } finally {
+      EventBus.unregister(runners);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_api36And37PolicySimulation() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    try {
+      for (int api : new int[] {36, 37}) {
+        org.robolectric.util.ReflectionHelpers.setStaticField(Build.VERSION.class, "SDK_INT", api);
+        if (api == 37)
+          sliceADeliver(
+              service,
+              buildStartIntent("new", 821, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+              2);
+        sliceATimeout(service, api == 36 ? 1 : 2);
+        assertFalse(sliceAPlatform(service).foreground);
+      }
+    } finally {
+      org.robolectric.util.ReflectionHelpers.setStaticField(Build.VERSION.class, "SDK_INT", 35);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_explicitUnresolvedTypeDoesNotMasqueradeAsShortSentinel() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+    service.onTimeout(1, ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST);
+    service.onTimeout(1, ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE);
+    assertTrue(SliceAShadowService.order.isEmpty());
+    assertCurrentState("slice-a", 820, "A");
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_reservedBinderReplyDoesNotBlockDemotionOrLoseAcceptance() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    try (Issue81LateReply pending = new Issue81LateReply(null, true)) {
+      pending.awaitDispatch();
+      Object request = issue81Pending().values().iterator().next();
+      assertFalse((boolean) issue82RequestField(request, "accepted"));
+      sliceATimeout(service, 1);
+      assertFalse(sliceAPlatform(service).foreground);
+      assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+      assertSame(request, issue81Pending().values().iterator().next());
+      pending.settle();
+      sliceAPlatform(service).accepted = 2;
+      assertTrue((boolean) issue82RequestField(request, "accepted"));
+      idleMain();
+      assertSame(request, issue81Pending().values().iterator().next());
+      assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_unfulfilledDeliveredStartCannotBecomeStopId() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    // A failed replacement reserves a new run without satisfying its publication authority.
+    ForegroundService.stop();
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService.start(821, buildNotification(), buildNotificationBundle("replacement"));
+    SliceAShadowService.promotionFailure = new SecurityException("replacement failed");
+    assertThrows(SecurityException.class, () -> sliceADeliver(service, context.starts.get(0), 2));
+    sliceATimeout(service, 1);
+    assertFalse(sliceAPlatform(service).foreground);
+    assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_nestedTimeoutPublishesOutsideBothLocksWithoutWaiting() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      SliceAShadowService.afterDemotion =
+          () -> {
+            sliceADeliver(
+                service,
+                buildStartIntent("new", 821, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+                2);
+            sliceATimeout(service, 2);
+          };
+      sliceATimeout(service, 1);
+      assertEquals(2, events.events.size());
+      assertFalse(
+          "publication must not inherit a reentrant caller's monitors", events.publishedUnderLock);
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_eventFailureIsBestEffortAndCannotReplaceDemotionFailure() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    RuntimeException primary = new SecurityException("demotion failure");
+    RuntimeException eventFailure = new IllegalArgumentException("event failure");
+    SliceAShadowService.demotionFailure = primary;
+    SliceAShadowService.stopResult = false;
+    int[] attempts = {0};
+    try (org.mockito.MockedStatic<EventBus> mocked =
+        org.mockito.Mockito.mockStatic(EventBus.class, org.mockito.Mockito.CALLS_REAL_METHODS)) {
+      mocked
+          .when(() -> EventBus.post(org.mockito.ArgumentMatchers.any()))
+          .thenAnswer(
+              invocation -> {
+                Object event = invocation.getArgument(0);
+                if (event instanceof NotificationEvent
+                    && ((NotificationEvent) event).getType() == 9) {
+                  attempts[0]++;
+                  throw eventFailure;
+                }
+                return invocation.callRealMethod();
+              });
+      assertSame(primary, assertThrows(RuntimeException.class, () -> sliceATimeout(service, 1)));
+      assertTrue(java.util.Arrays.asList(primary.getSuppressed()).contains(eventFailure));
+      sliceATimeout(service, 1);
+      assertEquals(1, attempts[0]);
+      assertTrue(
+          ShadowLog.getLogsForTag("NOTIFEE").stream().anyMatch(x -> x.throwable == eventFailure));
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_reentrantDuplicateAndExplicitStopPreserveTheirAuthority() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAShadowService.beforeDemotion = () -> sliceATimeout(service, 1);
+    SliceAShadowService.afterDemotion = ForegroundService::stop;
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      sliceATimeout(service, 1);
+      Object stop = getPrivateStatic("sStopRequest");
+      assertNotNull(stop);
+      assertEquals(1, events.events.size());
+      assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+      idleMain();
+      assertEquals(1, SliceAShadowService.order.stream().filter(x -> x.equals("stop:1")).count());
+      assertNull(getPrivateStatic("sStopRequest"));
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_timeoutDiagnosticRemainsErrorLogEventAfterDemotion() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      sliceATimeout(service, 1);
+      assertEquals(1, events.logs.size());
+      assertEquals(app.notifee.core.event.LogEvent.LEVEL_ERROR, events.logs.get(0).getLevel());
+      assertEquals(
+          java.util.Arrays.asList("demote", "stop:1", "event", "log"), SliceAShadowService.order);
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_diagnosticEventFailureCannotReplacePrimary() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    RuntimeException primary = new SecurityException("demotion failure");
+    RuntimeException logFailure = new IllegalArgumentException("diagnostic event failure");
+    SliceAShadowService.demotionFailure = primary;
+    SliceAShadowService.stopResult = false;
+    int[] attempts = {0};
+    try (org.mockito.MockedStatic<EventBus> mocked =
+        org.mockito.Mockito.mockStatic(EventBus.class, org.mockito.Mockito.CALLS_REAL_METHODS)) {
+      mocked
+          .when(() -> EventBus.post(org.mockito.ArgumentMatchers.any()))
+          .thenAnswer(
+              invocation -> {
+                if (invocation.getArgument(0) instanceof app.notifee.core.event.LogEvent) {
+                  attempts[0]++;
+                  throw logFailure;
+                }
+                return invocation.callRealMethod();
+              });
+      assertSame(primary, assertThrows(RuntimeException.class, () -> sliceATimeout(service, 1)));
+      assertEquals(1, attempts[0]);
+      assertTrue(java.util.Arrays.asList(primary.getSuppressed()).contains(logFailure));
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_failedDemotionConsumesRunnerAuthorityWithoutErasingEvidence()
+      throws Exception {
+    SliceAShadowService.reset();
+    createChannel();
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    ForegroundService service = buildService().create().get();
+    FgsRunnerCapture runners = new FgsRunnerCapture();
+    EventBus.register(runners);
+    try {
+      sliceADeliver(
+          service,
+          buildStartIntent("slice-a", 820, "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+          1);
+      Object runner = issue81Field(service, "mRunnerToken");
+      RuntimeException failure = new SecurityException("demotion failure");
+      SliceAShadowService.demotionFailure = failure;
+      SliceAShadowService.stopResult = false;
+      assertSame(failure, assertThrows(RuntimeException.class, () -> sliceATimeout(service, 1)));
+      runners.events.get(0).setCompletionResult();
+      assertFalse(ForegroundService.repostIfActive("slice-a"));
+      assertCurrentState("slice-a", 820, "A");
+      assertSame(runner, issue81Field(service, "mRunnerToken"));
+      assertEquals(1, SliceAShadowService.order.stream().filter(x -> x.equals("demote")).count());
+    } finally {
+      EventBus.unregister(runners);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_supersededOldDeliveryCannotBorrowCurrentRunStopAuthority() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService.start(820, buildNotification(), buildNotificationBundle("old"));
+    Intent old = context.starts.get(0);
+    ForegroundService.stop();
+    ForegroundService.start(821, buildNotification(), buildNotificationBundle("new"));
+    Intent current = context.starts.get(1);
+    sliceADeliver(service, current, 3);
+    sliceADeliver(service, old, 2); // actual older START delivered after its successor
+    assertEquals(3, sliceAPlatform(service).accepted);
+    assertEquals(2, sliceAPlatform(service).delivered);
+    assertTrue(issue81Pending().isEmpty());
+    SliceAShadowService.order.clear();
+    sliceATimeout(service, 3);
+    assertFalse(sliceAPlatform(service).foreground);
+    assertFalse(
+        "old run delivery must not supply the timeout stop ID",
+        SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+  }
+
+  @Test
+  @Config(
+      sdk = 35,
+      shadows = {SliceAShadowService.class, SliceAPostingShadowManager.class})
+  public void sliceA_reentrantPostingTimeoutDrainsAtUnlockedBoundary() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      SliceAPostingShadowManager.callback = () -> sliceATimeout(service, 1);
+      assertTrue(ForegroundService.repostIfActive("slice-a"));
+      assertFalse(sliceAPlatform(service).foreground);
+      assertEquals(
+          "an admitted timeout must attempt its event before the outer call returns",
+          1,
+          events.events.size());
+      assertFalse(events.publishedUnderLock);
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Implements(NotificationManager.class)
+  public static class SliceAPostingShadowManager extends ShadowNotificationManager {
+    static Runnable callback;
+
+    @Implementation
+    protected void notify(String tag, int id, Notification notification) {
+      if (callback != null) {
+        Runnable timeout = callback;
+        callback = null;
+        timeout.run();
+      }
+      super.notify(tag, id, notification);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_retiredCallbackMetadataCannotStopNewlyDeliveredSuccessor() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService.start(821, buildNotification(), buildNotificationBundle("new"));
+    Intent successor = context.starts.get(0);
+    sliceAPlatform(service).accepted = 2;
+    sliceATimeout(service, 2); // Android metadata names an accepted, not yet delivered START.
+    assertEquals(1, issue81Pending().size());
+    sliceADeliver(service, successor, 2);
+    assertTrue(issue81Pending().isEmpty());
+    SliceAShadowService.order.clear();
+    sliceATimeout(service, 2); // Indistinguishable old duplicate or fresh timeout: A3 applies.
+    assertFalse(sliceAPlatform(service).foreground);
+    assertFalse(
+        "matching callback metadata is not immutable Android epoch provenance",
+        sliceAPlatform(service).stopped);
+    assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_explicitStopReplyCannotRetireReentrantSuccessor() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAShadowService.afterStop =
+        () ->
+            sliceADeliver(
+                service,
+                buildStartIntent("new", 821, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+                2);
+    ForegroundService.stop();
+    idleMain();
+    assertCurrentState("new", 821, "B");
+    assertTrue((boolean) issue81Field(service, "mForegroundActive"));
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_terminalStopReplyCannotRetireReentrantSuccessor() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAShadowService.afterStop =
+        () ->
+            sliceADeliver(
+                service,
+                buildStartIntent("new", 821, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+                3);
+    sliceADeliver(service, buildStopIntent(), 2);
+    assertCurrentState("new", 821, "B");
+    assertTrue((boolean) issue81Field(service, "mForegroundActive"));
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_denialStopReplyCannotMarkReentrantSuccessorStopped() throws Exception {
+    SliceAShadowService.reset();
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    createChannel();
+    ForegroundService service = buildService().create().get();
+    RecordingServiceContext context = useRecordingContext();
+    Intent denied = issue82Dispatch(context, "A", 821);
+    SliceAShadowService.promotionFailure =
+        new ForegroundServiceStartNotAllowedException("tracked denial");
+    SliceAShadowService.afterStop =
+        () -> {
+          SliceAShadowService.promotionFailure = null;
+          sliceADeliver(
+              service,
+              buildStartIntent("new", 822, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+              2);
+        };
+    sliceADeliver(service, denied, 1);
+    assertCurrentState("new", 822, "B");
+    assertTrue((boolean) issue81Field(service, "mForegroundActive"));
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_timeoutStopReplyWithNewPendingCannotMarkAdmissionStopped() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    useRecordingContext();
+    SliceAShadowService.afterStop =
+        () -> ForegroundService.start(821, buildNotification(), buildNotificationBundle("pending"));
+    sliceATimeout(service, 1);
+    assertEquals(1, issue81Pending().size());
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+  }
+
+  @Test
+  @Config(
+      sdk = 35,
+      shadows = {SliceAShadowService.class, SliceAPostingShadowManager.class})
+  public void sliceA_timeoutDuringUpdateCannotRepublishRetiredCache() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAEvents events = new SliceAEvents();
+    EventBus.register(events);
+    try {
+      SliceAPostingShadowManager.callback = () -> sliceATimeout(service, 1);
+      sliceADeliver(
+          service,
+          buildStartIntent("slice-a", 820, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+          2);
+      assertNull(ForegroundService.mCurrentNotificationId);
+      assertNull(getPrivateStatic("mCurrentNotificationBundle"));
+      assertNull(getPrivateStatic("mCurrentNotification"));
+      assertEquals(-1, ForegroundService.mCurrentForegroundServiceType);
+      assertNull(issue81Field(service, "mRunnerToken"));
+      assertFalse((boolean) issue81Field(service, "mForegroundActive"));
+      assertEquals(1, events.events.size());
+      assertEquals("A", events.events.get(0).getNotification().toBundle().getString("title"));
+      assertFalse(events.publishedUnderLock);
+    } finally {
+      EventBus.unregister(events);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_explicitStopRefusalRestoresOnlyOriginalRequest() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAShadowService.stopResult = false;
+    ForegroundService.stop();
+    Object request = getPrivateStatic("sStopRequest");
+    idleMain();
+    assertSame(request, getPrivateStatic("sStopRequest"));
+    assertCurrentState("slice-a", 820, "A");
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+    idleMain();
+    assertEquals(1, SliceAShadowService.order.stream().filter(x -> x.startsWith("stop:")).count());
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_explicitStopThrowRestoresOnlyOriginalRequestAndPropagates() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    RuntimeException failure = new SecurityException("explicit stop failure");
+    SliceAShadowService.stopFailure = failure;
+    ForegroundService.stop();
+    Object request = getPrivateStatic("sStopRequest");
+    assertSame(failure, assertThrows(RuntimeException.class, ForegroundServiceTest::idleMain));
+    assertSame(request, getPrivateStatic("sStopRequest"));
+    assertCurrentState("slice-a", 820, "A");
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_retiredCallbackCollisionAcrossGenerationCannotStopSuccessor()
+      throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService.stop();
+    ForegroundService.start(821, buildNotification(), buildNotificationBundle("new"));
+    Intent successor = context.starts.get(0);
+    sliceAPlatform(service).accepted = 2;
+    sliceATimeout(service, 2);
+    assertEquals(1, issue81Pending().size());
+    sliceADeliver(service, successor, 2);
+    assertTrue(issue81Pending().isEmpty());
+    SliceAShadowService.order.clear();
+    sliceATimeout(service, 2);
+    assertFalse(sliceAPlatform(service).foreground);
+    assertFalse(
+        "a generation change cannot prove Android callback provenance",
+        sliceAPlatform(service).stopped);
+    assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = SliceAShadowService.class)
+  public void sliceA_retiredSameRunPromotionRemainsAmbiguous() throws Exception {
+    ForegroundService service = sliceAService(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    SliceAShadowService.stopResult = false;
+    sliceATimeout(service, 1);
+    sliceADeliver(
+        service,
+        buildStartIntent("new", 821, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+        2);
+    SliceAShadowService.stopResult = true;
+    SliceAShadowService.order.clear();
+    sliceATimeout(service, 2);
+    assertFalse(sliceAPlatform(service).foreground);
+    assertFalse(sliceAPlatform(service).stopped);
+    assertFalse(SliceAShadowService.order.stream().anyMatch(x -> x.startsWith("stop:")));
+  }
+
+  public static class SliceAEvents {
+    boolean publishedUnderLock;
+    final List<NotificationEvent> events = new ArrayList<>();
+    final List<app.notifee.core.event.LogEvent> logs = new ArrayList<>();
+
+    @Subscribe(threadMode = ThreadMode.POSTING)
+    public void notification(NotificationEvent event) {
+      if (event.getType() == 9) {
+        try {
+          publishedUnderLock |=
+              Thread.holdsLock(getPrivateStatic("sLifecycleLock"))
+                  || Thread.holdsLock(getPrivateStatic("sLock"));
+        } catch (Exception e) {
+          throw new AssertionError(e);
+        }
+        SliceAShadowService.order.add("event");
+        events.add(event);
+      }
+    }
+
+    @Subscribe(threadMode = ThreadMode.POSTING)
+    public void log(app.notifee.core.event.LogEvent event) {
+      logs.add(event);
+      SliceAShadowService.order.add("log");
+    }
+  }
+
+  @Implements(Service.class)
+  public static class SliceAShadowService extends ShadowService {
+    static final List<String> order = new ArrayList<>();
+    static RuntimeException promotionFailure, demotionFailure, stopFailure;
+    static Runnable beforeDemotion, afterDemotion, afterStop;
+    static boolean stopResult;
+    int accepted, delivered, promotions, type;
+    boolean foreground, stopped;
+
+    static void reset() {
+      order.clear();
+      promotionFailure = demotionFailure = stopFailure = null;
+      beforeDemotion = afterDemotion = afterStop = null;
+      stopResult = true;
+    }
+
+    @Implementation
+    protected void startForeground(int id, Notification notification, int foregroundServiceType) {
+      if (promotionFailure != null) throw promotionFailure;
+      promotions++;
+      foreground = true;
+      stopped = false;
+      type = foregroundServiceType;
+      super.startForeground(id, notification, foregroundServiceType);
+    }
+
+    @Implementation
+    protected void stopForeground(int flags) {
+      if (beforeDemotion != null) {
+        Runnable hook = beforeDemotion;
+        beforeDemotion = null;
+        hook.run();
+      }
+      order.add("demote");
+      assertEquals(Service.STOP_FOREGROUND_REMOVE, flags);
+      if (demotionFailure != null) throw demotionFailure;
+      foreground = false;
+      type = 0;
+      super.stopForeground(flags);
+      if (afterDemotion != null) {
+        Runnable hook = afterDemotion;
+        afterDemotion = null;
+        hook.run();
+      }
+    }
+
+    @Implementation
+    protected boolean stopSelfResult(int startId) {
+      order.add("stop:" + startId);
+      if (stopFailure != null) throw stopFailure;
+      boolean result = stopResult && startId == accepted;
+      if (result) {
+        stopped = true;
+        foreground = false;
+        super.stopSelfResult(startId);
+      }
+      if (afterStop != null) {
+        Runnable hook = afterStop;
+        afterStop = null;
+        hook.run();
+      }
+      return result;
+    }
+
+    @Implementation
+    protected void stopSelf(int startId) {
+      order.add("forbidden-stop:" + startId);
+      throw new AssertionError("timeout must use observable conditional stopSelfResult");
+    }
+
+    @Implementation
+    protected void stopSelf() {
+      throw new AssertionError("indiscriminate stop is forbidden");
+    }
+  }
+
+  // Slice D uses the real UUID reservation/dispatch path. API 36/37 below are policy-boundary
+  // simulations on the API 35 Robolectric runtime; they are not Android 16/17 framework proof.
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_initialTrackedDenial_isSelectiveAndNonFatal() throws Exception {
+    for (String message :
+        new String[] {
+          "Time limit already exhausted for foreground service type dataSync",
+          "Background start not allowed",
+          "opaque",
+          ""
+        }) {
+      RecordingServiceContext context = useRecordingContext();
+      ForegroundService service = issue81Service();
+      Issue81ShadowService.failure = new ForegroundServiceStartNotAllowedException(message);
+      issue81ObserveRecoveryStop(service);
+      Intent a = issue82Dispatch(context, "A", 810);
+      String id = a.getStringExtra(ISSUE81_REQUEST_ID);
+      Object request = issue81Pending().get(id);
+      FgsRunnerCapture capture = new FgsRunnerCapture();
+      EventBus.register(capture);
+      try {
+        int result;
+        try {
+          result = service.onStartCommand(a, 0, 7);
+        } catch (RuntimeException denial) {
+          assertSame(Issue81ShadowService.failure, denial);
+          assertEquals(java.util.Collections.singletonList(810), Issue81ShadowService.promotions);
+          assertEquals(
+              java.util.Collections.singletonList(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+              Issue81ShadowService.types);
+          assertSame(request, issue81Pending().get(id));
+          issue81AssertUnpromoted(service);
+          throw denial; // causal RED: actual tracked initial platform promotion was attempted
+        }
+        assertEquals(Service.START_NOT_STICKY, result);
+        assertTrue(issue81Pending().isEmpty());
+        assertTrue((boolean) issue82RequestField(request, "accepted"));
+        assertTrue((boolean) issue82RequestField(request, "promotionDenied"));
+        issue81AssertUnpromoted(service);
+        assertTrue(capture.events.isEmpty());
+        assertEquals(java.util.Arrays.asList("promote:810", "stop:7"), Issue81ShadowService.order);
+        issue82AssertDiagnostic(id, "accepted");
+      } finally {
+        EventBus.unregister(capture);
+      }
+      issue82DestroyServices();
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_api36And37_policyBoundarySimulation() throws Exception {
+    try {
+      for (int api : new int[] {36, 37}) {
+        org.robolectric.util.ReflectionHelpers.setStaticField(Build.VERSION.class, "SDK_INT", api);
+        RecordingServiceContext context = useRecordingContext();
+        ForegroundService service = issue81Service();
+        Intent a = issue82Dispatch(context, "A", 810);
+        assertEquals(Service.START_NOT_STICKY, service.onStartCommand(a, 0, 7));
+        issue81AssertUnpromoted(service);
+        assertTrue(issue81Pending().isEmpty());
+        assertEquals(java.util.Collections.singletonList(7), Issue81ShadowService.stops);
+        issue82AssertDiagnostic(a.getStringExtra(ISSUE81_REQUEST_ID), "accepted");
+        issue82DestroyServices();
+      }
+    } finally {
+      org.robolectric.util.ReflectionHelpers.setStaticField(Build.VERSION.class, "SDK_INT", 35);
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 32, 33, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue82_api31Through34_trackedDenialRemainsFatal() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    Intent a = issue82Dispatch(context, "A", 810);
+    Object request = issue81Pending().get(a.getStringExtra(ISSUE81_REQUEST_ID));
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 7)));
+    assertSame(request, issue81Pending().get(a.getStringExtra(ISSUE81_REQUEST_ID)));
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+    issue81AssertUnpromoted(service);
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_otherPromotionExceptionsRemainFatal() throws Exception {
+    for (RuntimeException failure :
+        new RuntimeException[] {
+          new SecurityException("permission"), new MissingForegroundServiceTypeException("missing"),
+          new InvalidForegroundServiceTypeException("invalid"),
+              new IllegalArgumentException("argument"),
+          new IllegalStateException("state"), new RuntimeException("other")
+        }) {
+      RecordingServiceContext context = useRecordingContext();
+      ForegroundService service = issue81Service();
+      Intent a = issue82Dispatch(context, "A", 810);
+      Object request = issue81Pending().get(a.getStringExtra(ISSUE81_REQUEST_ID));
+      Issue81ShadowService.failure = failure;
+      assertSame(
+          failure, assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 7)));
+      assertSame(request, issue81Pending().get(a.getStringExtra(ISSUE81_REQUEST_ID)));
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      issue81AssertUnpromoted(service);
+      issue82DestroyServices();
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_untrackedAndWrongActionRemainFatal_incompletePayloadDoesNotPromote()
+      throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(
+            RuntimeException.class, () -> service.onStartCommand(issue81UnknownStart(), 0, 1)));
+    Intent a = issue82Dispatch(context, "A", 810);
+    a.setAction("another.START");
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 2)));
+    a.setAction(ForegroundService.START_FOREGROUND_SERVICE_ACTION);
+    a.removeExtra("notification");
+    service.onStartCommand(a, 0, 3);
+    assertEquals(2, Issue81ShadowService.promotions.size());
+    assertEquals(1, issue81Pending().size());
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_deniedA_preservesAcceptedAndDeliveredUnfulfilledB() throws Exception {
+    for (boolean delivered : new boolean[] {false, true}) {
+      RecordingServiceContext context = useRecordingContext();
+      ForegroundService service = issue81Service();
+      Intent a = issue82Dispatch(context, "A", 810);
+      Intent b = issue82Dispatch(context, "B", 812);
+      Object request = issue81Pending().get(b.getStringExtra(ISSUE81_REQUEST_ID));
+      if (delivered) {
+        Intent incomplete = new Intent(b);
+        incomplete.removeExtra("notification");
+        service.onStartCommand(incomplete, 0, 6);
+      }
+      assertEquals(Service.START_NOT_STICKY, service.onStartCommand(a, 0, 7));
+      assertSame(request, issue81Pending().get(b.getStringExtra(ISSUE81_REQUEST_ID)));
+      assertEquals(1, issue81Pending().size());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      issue81AssertUnpromoted(service);
+      assertNotNull(issue81Field(service, "mDeniedStartRecovery"));
+      issue82AssertDiagnostic(a.getStringExtra(ISSUE81_REQUEST_ID), "deferred");
+      service.onStartCommand(b, 0, 8);
+      idleMain();
+      assertCurrentState("B", 812, "B");
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      issue82DestroyServices();
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_pendingB_definiteRejectionReevaluatesRecovery_unknownDoesNot()
+      throws Exception {
+    for (RuntimeException reply :
+        new RuntimeException[] {
+          null, new SecurityException("reject"), new IllegalStateException("Binder UNKNOWN")
+        }) {
+      RecordingServiceContext context = useRecordingContext();
+      ForegroundService service = issue81Service();
+      Intent a = issue82Dispatch(context, "A", 810);
+      try (Issue81LateReply b = new Issue81LateReply(reply, false)) {
+        b.awaitDispatch();
+        Object request = issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID));
+        assertFalse((boolean) issue82RequestField(request, "accepted"));
+        assertEquals(Service.START_NOT_STICKY, service.onStartCommand(a, 0, 7));
+        assertSame(request, issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID)));
+        assertTrue(Issue81ShadowService.stops.isEmpty());
+        issue82AssertDiagnostic(a.getStringExtra(ISSUE81_REQUEST_ID), "deferred");
+        b.settle();
+        assertSame(reply, b.failure.get());
+        idleMain();
+        if (reply instanceof IllegalStateException) {
+          assertSame(request, issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID)));
+          assertTrue(Issue81ShadowService.stops.isEmpty());
+          assertNotNull(issue81Field(service, "mDeniedStartRecovery"));
+          service.onStartCommand(b.intent, 0, 8);
+          assertCurrentState("B", 812, "B");
+        } else {
+          assertTrue(issue81Pending().isEmpty());
+          assertEquals(java.util.Collections.singletonList(7), Issue81ShadowService.stops);
+          issue82AssertDiagnostic(a.getStringExtra(ISSUE81_REQUEST_ID), "accepted");
+        }
+      }
+      issue82DestroyServices();
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_pendingB_acceptanceInvalidatesRecovery() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    Intent a = issue82Dispatch(context, "A", 810);
+    try (Issue81LateReply b = new Issue81LateReply(null, true)) {
+      b.awaitDispatch();
+      service.onStartCommand(a, 0, 7);
+      b.settle();
+      idleMain();
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      assertEquals(1, issue81Pending().size());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      service.onStartCommand(b.intent, 0, 8);
+      assertCurrentState("B", 812, "B");
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_lateAReply_doesNotResurrectOrCancelLaterStop() throws Exception {
+    for (RuntimeException reply :
+        new RuntimeException[] {
+          null, new SecurityException("late negative"), new IllegalStateException("late UNKNOWN")
+        }) {
+      for (boolean positive : new boolean[] {false, true}) {
+        ForegroundService service = issue81Service();
+        Issue81ShadowService.stopResult = false;
+        try (Issue81LateReply a = new Issue81LateReply(reply, positive, "A", 810)) {
+          a.awaitDispatch();
+          String id = a.intent.getStringExtra(ISSUE81_REQUEST_ID);
+          Object request = issue81Pending().get(id);
+          service.onStartCommand(a.intent, 0, 7);
+          assertTrue(issue81Pending().isEmpty());
+          assertTrue((boolean) issue82RequestField(request, "accepted"));
+          ForegroundService.stop();
+          Object stop = getPrivateStatic("sStopRequest");
+          a.settle();
+          assertSame(reply, a.failure.get());
+          assertTrue(issue81Pending().isEmpty());
+          assertSame(stop, getPrivateStatic("sStopRequest"));
+          idleMain();
+          assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+        }
+        issue82DestroyServices();
+      }
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_lateAReply_doesNotInvalidateNewRecovery() throws Exception {
+    for (RuntimeException reply :
+        new RuntimeException[] {
+          null, new SecurityException("late negative"), new IllegalStateException("late UNKNOWN")
+        }) {
+      for (boolean positive : new boolean[] {false, true}) {
+        RecordingServiceContext context = useRecordingContext();
+        ForegroundService service = issue81Service();
+        Intent b = issue82Dispatch(context, "B", 812);
+        try (Issue81LateReply a = new Issue81LateReply(reply, positive, "A", 810)) {
+          a.awaitDispatch();
+          service.onStartCommand(a.intent, 0, 7);
+          Object first = issue81Field(service, "mDeniedStartRecovery");
+          service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 8);
+          Object newer = issue81Field(service, "mDeniedStartRecovery");
+          assertNotNull(newer);
+          assertFalse(first == newer);
+          a.settle();
+          assertSame(reply, a.failure.get());
+          idleMain();
+          assertSame(newer, issue81Field(service, "mDeniedStartRecovery"));
+          assertEquals(1, issue81Pending().size());
+          assertTrue(Issue81ShadowService.stops.isEmpty());
+          service.onStartCommand(b, 0, 9);
+          assertCurrentState("B", 812, "B");
+        }
+        issue82DestroyServices();
+      }
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_stopRefusedOrThrows_doesNotCleanOrRetry() throws Exception {
+    for (boolean throwsStop : new boolean[] {false, true}) {
+      RecordingServiceContext context = useRecordingContext();
+      ForegroundService service = issue81Service();
+      Intent a = issue82Dispatch(context, "A", 810);
+      Issue81ShadowService.stopResult = false;
+      if (throwsStop) {
+        Issue81ShadowService.stopFailure = new SecurityException("stop failed");
+        assertSame(
+            Issue81ShadowService.stopFailure,
+            assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 7)));
+      } else {
+        assertEquals(Service.START_NOT_STICKY, service.onStartCommand(a, 0, 7));
+      }
+      assertTrue(issue81Pending().isEmpty());
+      issue81AssertUnpromoted(service);
+      assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      issue82AssertDiagnostic(
+          a.getStringExtra(ISSUE81_REQUEST_ID), throwsStop ? "failed" : "refused");
+      idleMain();
+      assertEquals(java.util.Collections.singletonList(7), Issue81ShadowService.stops);
+      issue82DestroyServices();
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_failedReplacement_preservesPromotedBAndRunner() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      Intent b = issue82Dispatch(context, "B", 812);
+      service.onStartCommand(b, 0, 1);
+      Object runner = issue81Field(service, "mRunnerToken");
+      Object bundle = getPrivateStatic("mCurrentNotificationBundle");
+      ForegroundService.stop();
+      Intent a = issue82Dispatch(context, "A", 810);
+      assertSame(
+          Issue81ShadowService.failure,
+          assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 2)));
+      assertCurrentState("B", 812, "B");
+      assertSame(bundle, getPrivateStatic("mCurrentNotificationBundle"));
+      assertEquals(
+          ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+          ForegroundService.mCurrentForegroundServiceType);
+      assertSame(runner, issue81Field(service, "mRunnerToken"));
+      assertTrue(ForegroundService.repostIfActive("B"));
+      assertEquals(1, capture.events.size());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      capture.events.get(0).setCompletionResult();
+      idleMain();
+      assertCurrentState("B", 812, "B");
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_postTimeoutSameInstance_isExplicitlyExcluded() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    Intent b = issue82Dispatch(context, "B", 812);
+    service.onStartCommand(b, 0, 1);
+    service.onTimeout(1, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    assertTrue((boolean) issue81Field(service, "mStartForegroundCalled"));
+    assertEquals(1, issue81Field(service, "mRunFirstStartId"));
+    Intent a = issue82Dispatch(context, "A", 810);
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 2)));
+    assertEquals(java.util.Arrays.asList(812, 810), Issue81ShadowService.promotions);
+    assertNull(issue81Field(service, "mDeniedStartRecovery"));
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_eligibilityRecheckedAfterPromotionAttempt() throws Exception {
+    for (String fieldName :
+        new String[] {
+          "sInstance", "sStateOwner", "sRunGeneration", "mRunGeneration", "mLastStartId"
+        }) {
+      RecordingServiceContext context = useRecordingContext();
+      ForegroundService service = issue81Service();
+      Intent a = issue82Dispatch(context, "A", 810);
+      Field field = ForegroundService.class.getDeclaredField(fieldName);
+      field.setAccessible(true);
+      Object owner = fieldName.startsWith("s") ? null : service;
+      Object original = field.get(owner);
+      Issue81ShadowService.beforePromotion =
+          () -> {
+            try {
+              if (fieldName.endsWith("Generation")) field.set(owner, ((Long) original) + 1);
+              else if (fieldName.equals("mLastStartId")) field.set(owner, 99);
+              else field.set(owner, new ForegroundService());
+            } catch (Exception e) {
+              throw new AssertionError(e);
+            }
+          };
+      try {
+        assertSame(
+            Issue81ShadowService.failure,
+            assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 7)));
+        assertEquals(1, issue81Pending().size());
+        assertTrue(Issue81ShadowService.stops.isEmpty());
+      } finally {
+        field.set(owner, original);
+        Issue81ShadowService.beforePromotion = null;
+      }
+      issue82DestroyServices();
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_deferredCallback_revalidatesAllAuthority() throws Exception {
+    for (String fieldName :
+        new String[] {
+          "sInstance", "sStateOwner", "sRunGeneration", "mRunGeneration", "mLastStartId"
+        }) {
+      RecordingServiceContext context = useRecordingContext();
+      ForegroundService service = issue81Service();
+      Intent a = issue82Dispatch(context, "A", 810);
+      try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+        b.awaitDispatch();
+        service.onStartCommand(a, 0, 7);
+        b.settle(); // queues recovery with A's identity, before we revoke one fence
+        Field field = ForegroundService.class.getDeclaredField(fieldName);
+        field.setAccessible(true);
+        Object owner = fieldName.startsWith("s") ? null : service;
+        Object original = field.get(owner);
+        try {
+          if (fieldName.endsWith("Generation")) field.set(owner, ((Long) original) + 1);
+          else if (fieldName.equals("mLastStartId")) field.set(owner, 99);
+          else field.set(owner, new ForegroundService());
+          idleMain();
+          assertTrue(Issue81ShadowService.stops.isEmpty());
+          assertNull(issue81Field(service, "mDeniedStartRecovery"));
+        } finally {
+          field.set(owner, original);
+        }
+      }
+      issue82DestroyServices();
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_trackedFrameworkFlags_useSliceD_notUntrackedRedeliveryPolicy()
+      throws Exception {
+    for (int flags :
+        new int[] {
+          Service.START_FLAG_RETRY,
+          Service.START_FLAG_REDELIVERY,
+          Service.START_FLAG_RETRY | Service.START_FLAG_REDELIVERY
+        }) {
+      RecordingServiceContext context = useRecordingContext();
+      ForegroundService service = issue81Service();
+      Intent a = issue82Dispatch(context, "A", 810);
+      service.onStartCommand(a, flags, 7);
+      assertTrue(issue81Pending().isEmpty());
+      issue81AssertUnpromoted(service);
+      assertEquals(java.util.Collections.singletonList(7), Issue81ShadowService.stops);
+      assertTrue(
+          ShadowLog.getLogsForTag("NOTIFEE").stream()
+              .anyMatch(
+                  item ->
+                      item.msg.contains("PROMOTION_DENIED")
+                          && item.msg.contains("flags=" + flags)));
+      issue82DestroyServices();
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_manifestAndNoneDenialsRemainOutsideCatch() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    Intent a = issue82Dispatch(context, "A", 810);
+    a.getBundleExtra("notificationBundle").getBundle("android").remove("foregroundServiceTypes");
+    PackageManager manager = org.mockito.Mockito.mock(PackageManager.class);
+    org.mockito.Mockito.when(
+            manager.getServiceInfo(
+                org.mockito.ArgumentMatchers.any(ComponentName.class),
+                org.mockito.ArgumentMatchers.anyInt()))
+        .thenThrow(Issue81ShadowService.failure);
+    ContextHolder.setApplicationContext(
+        new ContextWrapper(RuntimeEnvironment.getApplication()) {
+          @Override
+          public PackageManager getPackageManager() {
+            return manager;
+          }
+        });
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 7)));
+    assertTrue(Issue81ShadowService.promotions.isEmpty());
+    assertEquals(1, issue81Pending().size());
+    // Actual resolved NONE reaches the defensive placeholder, not the initial real promotion.
+    ContextHolder.setApplicationContext(null);
+    RuntimeException denial =
+        assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 8));
+    assertSame(Issue81ShadowService.failure, denial.getCause());
+    assertEquals(
+        java.util.Collections.singletonList(Integer.MAX_VALUE - 1),
+        Issue81ShadowService.promotions);
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+    assertEquals(1, issue81Pending().size());
+  }
+
+  @Test
+  @Config(
+      sdk = 35,
+      shadows = {Issue81ShadowService.class, Issue81NotificationShadowManager.class})
+  public void issue82_trackedSameIdNotifyAndTypeChangeDenials_preserveState() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    Intent b = issue82Dispatch(context, "B", 812);
+    service.onStartCommand(b, 0, 1);
+    Object runner = issue81Field(service, "mRunnerToken");
+    Object bundle = getPrivateStatic("mCurrentNotificationBundle");
+    for (int type :
+        new int[] {
+          ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+          ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+        }) {
+      Intent update = buildStartIntent("B", 812, "A", type);
+      ForegroundService.start(
+          812,
+          update.getParcelableExtra("notification"),
+          update.getBundleExtra("notificationBundle"));
+      Intent delivered = context.starts.get(context.starts.size() - 1);
+      assertSame(
+          Issue81ShadowService.failure,
+          assertThrows(RuntimeException.class, () -> service.onStartCommand(delivered, 0, 2)));
+      assertCurrentState("B", 812, "B");
+      assertSame(bundle, getPrivateStatic("mCurrentNotificationBundle"));
+      assertSame(runner, issue81Field(service, "mRunnerToken"));
+      assertEquals(
+          ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+          ForegroundService.mCurrentForegroundServiceType);
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+    }
+    assertEquals(java.util.Arrays.asList(812, 812), Issue81ShadowService.promotions);
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_supersededTrackedDenial_isExcluded() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    Intent a = issue82Dispatch(context, "A", 810);
+    ForegroundService.stop();
+    Intent b = issue82Dispatch(context, "B", 812);
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      service.onStartCommand(b, 0, 1);
+      capture.events.get(0).setCompletionResult();
+      assertSame(
+          Issue81ShadowService.failure,
+          assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 2)));
+      assertEquals(1, issue81Pending().size());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_requestIdentityAndOwnership_fencedBeforeAndAfterAttempt() throws Exception {
+    for (boolean duringAttempt : new boolean[] {false, true}) {
+      for (String authority : new String[] {"sInstance", "sStateOwner", "request"}) {
+        RecordingServiceContext context = useRecordingContext();
+        ForegroundService service = issue81Service();
+        Intent a = issue82Dispatch(context, "A", 810);
+        String id = a.getStringExtra(ISSUE81_REQUEST_ID);
+        Field field =
+            ForegroundService.class.getDeclaredField(
+                authority.equals("request") ? "sPendingStarts" : authority);
+        field.setAccessible(true);
+        Object original = field.get(null);
+        Runnable revoke =
+            () -> {
+              try {
+                if (authority.equals("request")) issue81Pending().remove(id);
+                else field.set(null, new ForegroundService());
+              } catch (Exception e) {
+                throw new AssertionError(e);
+              }
+            };
+        if (duringAttempt) Issue81ShadowService.beforePromotion = revoke;
+        else revoke.run();
+        try {
+          assertSame(
+              Issue81ShadowService.failure,
+              assertThrows(RuntimeException.class, () -> service.onStartCommand(a, 0, 7)));
+          assertTrue(Issue81ShadowService.stops.isEmpty());
+        } finally {
+          if (!authority.equals("request")) field.set(null, original);
+          Issue81ShadowService.beforePromotion = null;
+        }
+        issue82DestroyServices();
+      }
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_deferredRecovery_newAdmissionStopAndDestroyInvalidateStaleCallback()
+      throws Exception {
+    for (String action : new String[] {"admission", "stop", "destroy", "delivery"}) {
+      RecordingServiceContext context = useRecordingContext();
+      ForegroundService service = issue81Service();
+      Intent a = issue82Dispatch(context, "A", 810);
+      try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+        b.awaitDispatch();
+        service.onStartCommand(a, 0, 7);
+        Object recovery = issue81Field(service, "mDeniedStartRecovery");
+        b.settle(); // queued callback carries recovery A; lifecycle changes happen before it runs
+        if (action.equals("admission")) {
+          Intent c = issue82Dispatch(useRecordingContext(), "C", 814);
+          assertNull(issue81Field(service, "mDeniedStartRecovery"));
+          idleMain();
+          assertTrue(Issue81ShadowService.stops.isEmpty());
+          service.onStartCommand(c, 0, 8);
+          assertCurrentState("C", 814, "C");
+        } else if (action.equals("stop")) {
+          ForegroundService.stop();
+          assertNull(issue81Field(service, "mDeniedStartRecovery"));
+          idleMain();
+          assertEquals(java.util.Collections.singletonList(7), Issue81ShadowService.stops);
+          assertFalse(
+              ShadowLog.getLogsForTag("NOTIFEE").stream()
+                  .anyMatch(
+                      item ->
+                          item.msg.contains("PROMOTION_DENIED")
+                              && item.msg.contains("stop=accepted")));
+        } else if (action.equals("destroy")) {
+          issue82DestroyServices();
+          assertTrue(Issue81ShadowService.stops.isEmpty());
+        } else {
+          Intent incomplete = new Intent().setAction("incomplete");
+          service.onStartCommand(incomplete, 0, 8);
+          idleMain();
+          assertTrue(Issue81ShadowService.stops.isEmpty());
+        }
+        assertNotNull(recovery);
+        assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      }
+      issue82DestroyServices();
+    }
+  }
+
+  @Test
+  @Config(sdk = 35, shadows = Issue81ShadowService.class)
+  public void issue82_queuedRecovery_newPendingReservationDefersUntilDefiniteRejection()
+      throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    Intent a = issue82Dispatch(context, "A", 810);
+    try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(a, 0, 7);
+      Object recovery = issue81Field(service, "mDeniedStartRecovery");
+      b.settle();
+      try (Issue81LateReply c = new Issue81LateReply(null, false, "C", 814)) {
+        c.awaitDispatch();
+        Object request = issue81Pending().get(c.intent.getStringExtra(ISSUE81_REQUEST_ID));
+        idleMain();
+        assertSame(recovery, issue81Field(service, "mDeniedStartRecovery"));
+        assertSame(request, issue81Pending().get(c.intent.getStringExtra(ISSUE81_REQUEST_ID)));
+        assertTrue(Issue81ShadowService.stops.isEmpty());
+        c.settle();
+        idleMain();
+        assertTrue(issue81Pending().isEmpty());
+        assertNull(issue81Field(service, "mDeniedStartRecovery"));
+        assertEquals(java.util.Collections.singletonList(7), Issue81ShadowService.stops);
+        issue82AssertDiagnostic(a.getStringExtra(ISSUE81_REQUEST_ID), "accepted");
+      }
+    }
+  }
+
+  private static Object issue82RequestField(Object request, String name) throws Exception {
+    Field field = request.getClass().getDeclaredField(name);
+    field.setAccessible(true);
+    return field.get(request);
+  }
+
+  private static Intent issue82Dispatch(RecordingServiceContext context, String id, int hash) {
+    Intent start = buildStartIntent(id, hash, id, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    ForegroundService.start(
+        hash, start.getParcelableExtra("notification"), start.getBundleExtra("notificationBundle"));
+    return context.starts.get(context.starts.size() - 1);
+  }
+
+  private void issue82DestroyServices() {
+    for (int i = controllers.size() - 1; i >= 0; i--) controllers.get(i).destroy();
+    controllers.clear();
+    idleMain();
+  }
+
+  private static void issue82AssertDiagnostic(String id, String outcome) {
+    assertTrue(
+        ShadowLog.getLogsForTag("NOTIFEE").stream()
+            .anyMatch(
+                item ->
+                    item.type == android.util.Log.WARN
+                        && item.throwable == Issue81ShadowService.failure
+                        && item.msg.contains("PROMOTION_DENIED")
+                        && item.msg.contains("cause=UNKNOWN")
+                        && item.msg.contains("requestId=" + id)
+                        && item.msg.contains("notificationId=A")
+                        && item.msg.contains("api=" + Build.VERSION.SDK_INT)
+                        && item.msg.contains("type=1")
+                        && item.msg.contains("startId=7")
+                        && item.msg.contains("flags=0")
+                        && item.msg.contains("generation=")
+                        && item.msg.contains("stop=" + outcome)));
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 33, 34, 35},
+      shadows = Issue81ShadowService.class)
+  public void issue81_retryFreshDenied_recoversWithoutClaimingPromotion() throws Exception {
+    issue81AssertFreshRecovery(Service.START_FLAG_RETRY);
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 33, 34, 35},
+      shadows = Issue81ShadowService.class)
+  public void issue81_redeliveryFreshDenied_recoversWithoutClaimingPromotion() throws Exception {
+    issue81AssertFreshRecovery(Service.START_FLAG_REDELIVERY);
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_bothFlagsAndUppercaseUuid_recovers() throws Exception {
+    ForegroundService service = issue81Service();
+    Intent intent = issue81UnknownStart();
+    intent.putExtra(
+        ISSUE81_REQUEST_ID,
+        intent.getStringExtra(ISSUE81_REQUEST_ID).toUpperCase(java.util.Locale.ROOT));
+    assertEquals(
+        Service.START_NOT_STICKY,
+        service.onStartCommand(
+            intent, Service.START_FLAG_RETRY | Service.START_FLAG_REDELIVERY, 1));
+    issue81AssertUnpromoted(service);
+    assertEquals(java.util.Collections.singletonList(1), Issue81ShadowService.stops);
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_trackedStartDenied_isFatalEvenWithFrameworkFlags() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    Issue81ShadowService.rejectTitle = null;
+    for (int flags :
+        new int[] {
+          0,
+          Service.START_FLAG_RETRY,
+          Service.START_FLAG_REDELIVERY,
+          Service.START_FLAG_RETRY | Service.START_FLAG_REDELIVERY
+        }) {
+      ForegroundService.start(811, buildNotification(), buildNotificationBundle("tracked"));
+      Intent intent = context.starts.get(context.starts.size() - 1);
+      String requestId = intent.getStringExtra(ISSUE81_REQUEST_ID);
+      Object request = issue81Pending().get(requestId);
+      assertNotNull(request);
+      assertSame(
+          Issue81ShadowService.failure,
+          assertThrows(RuntimeException.class, () -> service.onStartCommand(intent, flags, 1)));
+      assertSame(request, issue81Pending().get(requestId));
+    }
+    assertEquals(4, Issue81ShadowService.promotions.size());
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+    issue81AssertUnpromoted(service);
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_missingOrInvalidUuid_isFatal() throws Exception {
+    ForegroundService service = issue81Service();
+    for (String requestId :
+        new String[] {
+          null,
+          "",
+          "not-a-uuid",
+          "1-1-1-1-1",
+          "000000000-000-0000-0000-000000000000",
+          " " + UUID.randomUUID(),
+          "00000000-0000-0000-0000-00000000000z"
+        }) {
+      Intent intent = issue81UnknownStart();
+      if (requestId == null) {
+        intent.removeExtra(ISSUE81_REQUEST_ID);
+      } else {
+        intent.putExtra(ISSUE81_REQUEST_ID, requestId);
+      }
+      assertSame(
+          Issue81ShadowService.failure,
+          assertThrows(
+              RuntimeException.class,
+              () -> service.onStartCommand(intent, Service.START_FLAG_RETRY, 1)));
+    }
+    Intent wrongType = issue81UnknownStart().putExtra(ISSUE81_REQUEST_ID, 81);
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(
+            RuntimeException.class,
+            () -> service.onStartCommand(wrongType, Service.START_FLAG_RETRY, 1)));
+    assertEquals(8, Issue81ShadowService.promotions.size());
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_missingFrameworkFlagsOrWrongAction_isFatal() throws Exception {
+    ForegroundService service = issue81Service();
+    Intent intentFlagsOnly = issue81UnknownStart().setFlags(0x4);
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(RuntimeException.class, () -> service.onStartCommand(intentFlagsOnly, 0, 1)));
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(
+            RuntimeException.class, () -> service.onStartCommand(issue81UnknownStart(), 0x4, 2)));
+    for (String action : new String[] {null, "another.START"}) {
+      Intent intent = issue81UnknownStart().setAction(action);
+      assertSame(
+          Issue81ShadowService.failure,
+          assertThrows(
+              RuntimeException.class,
+              () -> service.onStartCommand(intent, Service.START_FLAG_RETRY, 3)));
+    }
+    assertEquals(4, Issue81ShadowService.promotions.size());
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+  }
+
+  @Test
+  @Config(
+      sdk = {24, 30, 31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_unrelatedPromotionFailures_remainFatal() throws Exception {
+    ForegroundService service = issue81Service();
+    List<RuntimeException> failures = new ArrayList<>();
+    failures.add(new SecurityException("permission"));
+    failures.add(new IllegalStateException("other denial"));
+    failures.add(new RuntimeException("other failure"));
+    if (Build.VERSION.SDK_INT >= 34) {
+      failures.add(new MissingForegroundServiceTypeException("missing type"));
+      failures.add(new InvalidForegroundServiceTypeException("invalid type"));
+    }
+    for (RuntimeException failure : failures) {
+      Issue81ShadowService.failure = failure;
+      assertSame(
+          failure,
+          assertThrows(
+              RuntimeException.class,
+              () -> service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 1)));
+    }
+    assertEquals(failures.size(), Issue81ShadowService.promotions.size());
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+    issue81AssertUnpromoted(service);
+  }
+
+  @Test
+  @Config(
+      sdk = {33, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deniedA_preservesPendingBAndAllowsItsPromotion() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    issue81StartB();
+    Intent b = context.starts.get(0);
+    Object request = issue81Pending().get(b.getStringExtra(ISSUE81_REQUEST_ID));
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      assertEquals(
+          Service.START_NOT_STICKY,
+          service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 1));
+      assertSame(request, issue81Pending().get(b.getStringExtra(ISSUE81_REQUEST_ID)));
+      assertEquals(1, issue81Pending().size());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertTrue(capture.events.isEmpty());
+      issue81AssertUnpromoted(service);
+      assertFalse((boolean) issue81Field(service, "mStartCommandFailed"));
+      service.onStartCommand(b, 0, 2);
+      assertCurrentState("B", 812, "B");
+      assertEquals(1, capture.events.size());
+      assertTrue(issue81Pending().isEmpty());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_deliveredUnfulfilledB_isNotSettledByDeniedA() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    issue81StartB();
+    Intent b = context.starts.get(0);
+    String requestId = b.getStringExtra(ISSUE81_REQUEST_ID);
+    Object request = issue81Pending().get(requestId);
+    Intent incomplete = new Intent(b);
+    incomplete.removeExtra("notification");
+    service.onStartCommand(incomplete, 0, 1);
+    Field instance = request.getClass().getDeclaredField("instance");
+    instance.setAccessible(true);
+    assertSame(service, instance.get(request));
+    assertTrue(Issue81ShadowService.promotions.isEmpty());
+    assertEquals(
+        Service.START_NOT_STICKY,
+        service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 2));
+    assertSame(request, issue81Pending().get(requestId));
+    assertEquals(1, issue81Pending().size());
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+    issue81AssertUnpromoted(service);
+    service.onStartCommand(b, 0, 3);
+    assertCurrentState("B", 812, "B");
+    assertTrue(issue81Pending().isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_deniedA_withQueuedStop_promotesBBeforeStopping() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    issue81StartB();
+    ForegroundService.stop();
+    Object stopRequest = getPrivateStatic("sStopRequest");
+    assertEquals(
+        Service.START_NOT_STICKY,
+        service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 1));
+    idleMain();
+    assertSame(stopRequest, getPrivateStatic("sStopRequest"));
+    assertEquals(1, issue81Pending().size());
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+    service.onStartCommand(context.starts.get(0), 0, 2);
+    idleMain();
+    assertEquals(
+        java.util.Arrays.asList("promote:810", "promote:812", "stop:2"),
+        Issue81ShadowService.order);
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(ForegroundService.mCurrentNotificationId);
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_refusedStop_preservesAdmissionForLaterStart() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    Issue81ShadowService.stopResult = false;
+    issue81ObserveRecoveryStop(service);
+    assertEquals(
+        Service.START_NOT_STICKY,
+        service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 1));
+    idleMain();
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+    issue81AssertUnpromoted(service);
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertEquals(java.util.Collections.singletonList(1), Issue81ShadowService.stops);
+    issue81StartB();
+    service.onStartCommand(context.starts.get(0), 0, 2);
+    assertCurrentState("B", 812, "B");
+    assertTrue(issue81Pending().isEmpty());
+    assertEquals(1, Issue81ShadowService.stops.size());
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_activeReplacementDenial_preservesStateAndFencesOldCompletion()
+      throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = issue81Service();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      service.onStartCommand(buildStartIntent("live", 813, "live"), 0, 1);
+      Object runner = issue81Field(service, "mRunnerToken");
+      ForegroundService.stop();
+      issue81StartB();
+      Object request =
+          issue81Pending().get(context.starts.get(0).getStringExtra(ISSUE81_REQUEST_ID));
+      assertSame(
+          Issue81ShadowService.failure,
+          assertThrows(
+              RuntimeException.class,
+              () -> service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 2)));
+      assertCurrentState("live", 813, "live");
+      assertSame(runner, issue81Field(service, "mRunnerToken"));
+      assertSame(
+          request, issue81Pending().get(context.starts.get(0).getStringExtra(ISSUE81_REQUEST_ID)));
+      assertTrue(ForegroundService.repostIfActive("live"));
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      service.onStartCommand(context.starts.get(0), 0, 3);
+      capture.events.get(0).setCompletionResult();
+      idleMain();
+      assertCurrentState("B", 812, "B");
+      assertEquals(2, capture.events.size());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_priorPromotionAfterRunnerCompletion_isFatal() throws Exception {
+    ForegroundService service = issue81Service();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      service.onStartCommand(buildStartIntent("live", 813, "live"), 0, 1);
+      capture.events.get(0).setCompletionResult();
+      assertNull(ForegroundService.mCurrentNotificationId);
+      assertNull(issue81Field(service, "mRunnerToken"));
+      assertSame(
+          Issue81ShadowService.failure,
+          assertThrows(
+              RuntimeException.class,
+              () -> service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 2)));
+      assertTrue((boolean) issue81Field(service, "mStartForegroundCalled"));
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_staleInstanceDenial_preservesCurrentOwner() throws Exception {
+    ForegroundService old = issue81Service();
+    ForegroundService current = buildService().create().get();
+    current.onStartCommand(buildStartIntent("live", 813, "live"), 0, 1);
+    Object runner = issue81Field(current, "mRunnerToken");
+    ForegroundService.stop();
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(
+            RuntimeException.class,
+            () -> old.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 2)));
+    assertCurrentState("live", 813, "live");
+    assertSame(current, getPrivateStatic("sInstance"));
+    assertSame(current, getPrivateStatic("sStateOwner"));
+    assertSame(runner, issue81Field(current, "mRunnerToken"));
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 34, shadows = Issue81ShadowService.class)
+  public void issue81_sameIdTypeChangeDenial_isFatalAndPreservesCache() throws Exception {
+    ForegroundService service = issue81Service();
+    service.onStartCommand(
+        buildStartIntent("live", 813, "live", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC), 0, 1);
+    Object runner = issue81Field(service, "mRunnerToken");
+    Intent update =
+        buildStartIntent("live", 813, "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
+            .putExtra(ISSUE81_REQUEST_ID, UUID.randomUUID().toString());
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(
+            RuntimeException.class,
+            () -> service.onStartCommand(update, Service.START_FLAG_RETRY, 2)));
+    assertCurrentState("live", 813, "live");
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+        ForegroundService.mCurrentForegroundServiceType);
+    assertSame(runner, issue81Field(service, "mRunnerToken"));
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 34, shadows = Issue81ShadowService.class)
+  public void issue81_noneDefensiveDenial_remainsFatal() throws Exception {
+    ForegroundService service = issue81Service();
+    Intent none = issue81UnknownStart();
+    Bundle android = none.getBundleExtra("notificationBundle").getBundle("android");
+    android.remove("foregroundServiceTypes");
+    ContextHolder.setApplicationContext(null);
+    RuntimeException thrown =
+        assertThrows(
+            RuntimeException.class,
+            () -> service.onStartCommand(none, Service.START_FLAG_RETRY, 1));
+    assertSame(Issue81ShadowService.failure, thrown.getCause());
+    assertEquals(
+        java.util.Collections.singletonList(Integer.MAX_VALUE - 1),
+        Issue81ShadowService.promotions);
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_manifestLookupDenial_remainsFatal() throws Exception {
+    ForegroundService service = issue81Service();
+    Intent intent = issue81UnknownStart();
+    intent
+        .getBundleExtra("notificationBundle")
+        .getBundle("android")
+        .remove("foregroundServiceTypes");
+    PackageManager manager = org.mockito.Mockito.mock(PackageManager.class);
+    org.mockito.Mockito.when(
+            manager.getServiceInfo(
+                org.mockito.ArgumentMatchers.any(ComponentName.class),
+                org.mockito.ArgumentMatchers.anyInt()))
+        .thenThrow(Issue81ShadowService.failure);
+    ContextHolder.setApplicationContext(
+        new ContextWrapper(RuntimeEnvironment.getApplication()) {
+          @Override
+          public PackageManager getPackageManager() {
+            return manager;
+          }
+        });
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(
+            RuntimeException.class,
+            () -> service.onStartCommand(intent, Service.START_FLAG_RETRY, 1)));
+    assertTrue(Issue81ShadowService.promotions.isEmpty());
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+  }
+
+  @Test
+  @Config(
+      sdk = 33,
+      shadows = {Issue81ShadowService.class, Issue81NotificationShadowManager.class})
+  public void issue81_sameIdNotifyDenial_remainsFatal() throws Exception {
+    ForegroundService service = issue81Service();
+    service.onStartCommand(buildStartIntent("live", 813, "live"), 0, 1);
+    Intent update =
+        buildStartIntent("live", 813, "A")
+            .putExtra(ISSUE81_REQUEST_ID, UUID.randomUUID().toString());
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(
+            RuntimeException.class,
+            () -> service.onStartCommand(update, Service.START_FLAG_RETRY, 2)));
+    assertCurrentState("live", 813, "live");
+    assertEquals(java.util.Collections.singletonList(813), Issue81ShadowService.promotions);
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_stopOperationDenial_remainsFatal() throws Exception {
+    ForegroundService service = issue81Service();
+    Issue81ShadowService.stopFailure =
+        new ForegroundServiceStartNotAllowedException("stop operation denied");
+    assertSame(
+        Issue81ShadowService.stopFailure,
+        assertThrows(
+            RuntimeException.class,
+            () -> service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 1)));
+    assertEquals(java.util.Collections.singletonList(1), Issue81ShadowService.stops);
+    issue81AssertUnpromoted(service);
+    assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+    assertTrue(
+        ShadowLog.getLogsForTag("NOTIFEE").stream()
+            .anyMatch(
+                item ->
+                    item.type == android.util.Log.WARN
+                        && item.throwable == Issue81ShadowService.failure
+                        && item.msg.contains("stop=failed")));
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_pendingBLateReply_doesNotCancelStopAfterDelivery() throws Exception {
+    CountDownLatch dispatched = new CountDownLatch(1);
+    CountDownLatch reply = new CountDownLatch(1);
+    List<Intent> starts = new ArrayList<>();
+    ContextHolder.setApplicationContext(
+        new ContextWrapper(RuntimeEnvironment.getApplication()) {
+          @Override
+          public ComponentName startForegroundService(Intent intent) {
+            starts.add(new Intent(intent));
+            dispatched.countDown();
+            try {
+              if (!reply.await(5, TimeUnit.SECONDS)) {
+                throw new IllegalStateException("reply timed out");
+              }
+            } catch (InterruptedException e) {
+              throw new RuntimeException(e);
+            }
+            return intent.getComponent();
+          }
+        });
+    ForegroundService service = issue81Service();
+    AtomicReference<Throwable> failure = new AtomicReference<>();
+    Thread sender =
+        new Thread(
+            () -> {
+              try {
+                issue81StartB();
+              } catch (Throwable e) {
+                failure.set(e);
+              }
+            });
+    sender.start();
+    try {
+      assertTrue(dispatched.await(5, TimeUnit.SECONDS));
+      Object request = issue81Pending().get(starts.get(0).getStringExtra(ISSUE81_REQUEST_ID));
+      assertEquals(
+          Service.START_NOT_STICKY,
+          service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 1));
+      assertSame(request, issue81Pending().get(starts.get(0).getStringExtra(ISSUE81_REQUEST_ID)));
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      service.onStartCommand(starts.get(0), 0, 2);
+      ForegroundService.stop();
+      Object stop = getPrivateStatic("sStopRequest");
+      reply.countDown();
+      sender.join(5000);
+      assertFalse(sender.isAlive());
+      assertNull(failure.get());
+      assertSame(stop, getPrivateStatic("sStopRequest"));
+      idleMain();
+      assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      assertEquals(java.util.Collections.singletonList(2), Issue81ShadowService.stops);
+    } finally {
+      reply.countDown();
+      sender.join(5000);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_successfulRetry_usesNormalRunnerAndSameIdUpdate() throws Exception {
+    ForegroundService service = issue81Service();
+    Issue81ShadowService.failure = null;
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 1);
+      assertCurrentState("A", 810, "A");
+      assertTrue((boolean) issue81Field(service, "mStartForegroundCalled"));
+      assertEquals(1, capture.events.size());
+      service.onStartCommand(
+          buildStartIntent("A", 810, "updated", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+          0,
+          2);
+      assertCurrentState("A", 810, "updated");
+      assertEquals(java.util.Collections.singletonList(810), Issue81ShadowService.promotions);
+      assertEquals(1, capture.events.size());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = Issue81ShadowService.class)
+  public void issue81_retryWithoutPayload_doesNotAttemptRecovery() throws Exception {
+    ForegroundService service = issue81Service();
+    Intent intent = issue81UnknownStart();
+    intent.removeExtra("notification");
+    assertEquals(
+        Service.START_NOT_STICKY, service.onStartCommand(intent, Service.START_FLAG_RETRY, 1));
+    assertTrue(Issue81ShadowService.promotions.isEmpty());
+    assertTrue(Issue81ShadowService.stops.isEmpty());
+    issue81AssertUnpromoted(service);
+  }
+
+  private static final String ISSUE81_REQUEST_ID = "notifee.foregroundServiceStartRequestId";
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_lateSecurityRejection_stops() throws Exception {
+    issue81AssertLateRejection(new SecurityException("B rejected"));
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_lateFgsRejection_stops() throws Exception {
+    issue81AssertLateRejection(new ForegroundServiceStartNotAllowedException("B rejected"));
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_lateNullComponent_stops() throws Exception {
+    issue81AssertLateRejection(null);
+  }
+
+  private void issue81AssertLateRejection(RuntimeException rejection) throws Exception {
+    ForegroundService service = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(rejection, false)) {
+      b.awaitDispatch();
+      Object request = issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID));
+      assertNotNull(request);
+      assertEquals(
+          Service.START_NOT_STICKY,
+          service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11));
+      idleMain();
+      assertSame(request, issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID)));
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      issue81AssertUnpromoted(service);
+      assertSame(service, getPrivateStatic("sInstance"));
+      assertEquals(11, issue81Field(service, "mLastStartId"));
+      assertNull(getPrivateStatic("sStopRequest"));
+      b.settle();
+      assertSame(rejection, b.failure.get());
+      assertTrue(issue81Pending().isEmpty());
+      issue81ObserveRecoveryStop(service);
+      idleMain();
+      assertEquals(
+          "The last definite rejection must re-evaluate denied A's stop",
+          java.util.Collections.singletonList(11),
+          Issue81ShadowService.stops);
+      assertTrue((boolean) issue81Field(service, "mStopInitiated"));
+      issue81AssertUnpromoted(service);
+      assertNull(getPrivateStatic("sStopRequest"));
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_acceptedB_waitsForPromotion() throws Exception {
+    ForegroundService service = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(null, true)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      Object request = issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID));
+      b.settle();
+      assertNull(b.failure.get());
+      idleMain();
+      assertSame(request, issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID)));
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      service.onStartCommand(b.intent, 0, 12);
+      idleMain();
+      assertCurrentState("B", 812, "B");
+      assertTrue(issue81Pending().isEmpty());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertNull(getPrivateStatic("sStopRequest"));
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_deliveredB_lateNegativeReplyPreservesRun() throws Exception {
+    ForegroundService service = issue81Service();
+    RuntimeException rejection = new SecurityException("late B rejection after delivery");
+    try (Issue81LateReply b = new Issue81LateReply(rejection, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      service.onStartCommand(b.intent, 0, 12);
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      b.settle();
+      assertSame(rejection, b.failure.get());
+      idleMain();
+      assertCurrentState("B", 812, "B");
+      assertTrue((boolean) issue81Field(service, "mForegroundActive"));
+      assertTrue(issue81Pending().isEmpty());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertNull(getPrivateStatic("sStopRequest"));
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_ambiguousReply_keepsObligation() throws Exception {
+    ForegroundService service = issue81Service();
+    RuntimeException unknown = new IllegalStateException("lost B reply");
+    try (Issue81LateReply b = new Issue81LateReply(unknown, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      Object request = issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID));
+      b.settle();
+      assertSame(unknown, b.failure.get());
+      idleMain();
+      assertSame(request, issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID)));
+      assertEquals(1, issue81Pending().size());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      issue81AssertUnpromoted(service);
+      assertNotNull(issue81Field(service, "mDeniedStartRecovery"));
+      service.onStartCommand(b.intent, 0, 12);
+      idleMain();
+      assertCurrentState("B", 812, "B");
+      assertTrue(issue81Pending().isEmpty());
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_newAcceptedStart_invalidatesQueuedRecovery()
+      throws Exception {
+    ForegroundService service = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      b.settle();
+      RecordingServiceContext context = useRecordingContext();
+      issue81StartB();
+      idleMain();
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertEquals(1, issue81Pending().size());
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      assertNull(getPrivateStatic("sStopRequest"));
+      service.onStartCommand(context.starts.get(0), 0, 12);
+      idleMain();
+      assertCurrentState("B", 812, "B");
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_newDelivery_invalidatesQueuedRecovery() throws Exception {
+    ForegroundService service = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      b.settle();
+      // Even an incomplete new delivery supersedes the denied startId; it grants no promotion.
+      Intent later = issue81UnknownStart();
+      later.removeExtra("notification");
+      service.onStartCommand(later, 0, 12);
+      idleMain();
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      issue81AssertUnpromoted(service);
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_refusedStop_isConsumedWithoutCleanupOrRetry()
+      throws Exception {
+    ForegroundService service = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      b.settle();
+      Issue81ShadowService.stopResult = false;
+      issue81ObserveRecoveryStop(service);
+      idleMain();
+      assertEquals(java.util.Collections.singletonList(11), Issue81ShadowService.stops);
+      assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      issue81AssertUnpromoted(service);
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      issue81RejectAnotherDispatch();
+      idleMain();
+      assertEquals(1, Issue81ShadowService.stops.size());
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_throwingStop_preservesErrorAndDiagnostic() throws Exception {
+    ForegroundService service = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      b.settle();
+      Issue81ShadowService.stopFailure = new SecurityException("recovery stop failed");
+      issue81ObserveRecoveryStop(service);
+      assertSame(
+          Issue81ShadowService.stopFailure, assertThrows(RuntimeException.class, () -> idleMain()));
+      assertEquals(java.util.Collections.singletonList(11), Issue81ShadowService.stops);
+      assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+      issue81AssertUnpromoted(service);
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      assertTrue(
+          ShadowLog.getLogsForTag("NOTIFEE").stream()
+              .anyMatch(
+                  item ->
+                      item.throwable == Issue81ShadowService.failure
+                          && item.msg.contains("startId=11")
+                          && item.msg.contains("stop=failed")));
+      issue81RejectAnotherDispatch();
+      idleMain();
+      assertEquals(1, Issue81ShadowService.stops.size());
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_staleGenerations_doNotStop() throws Exception {
+    ForegroundService service = issue81Service();
+    for (String generation : new String[] {"sRunGeneration", "mRunGeneration"}) {
+      try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+        b.awaitDispatch();
+        service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+        assertNotNull(issue81Field(service, "mDeniedStartRecovery"));
+        // Isolate each immutable generation fence without introducing a separate client STOP.
+        Field field = ForegroundService.class.getDeclaredField(generation);
+        field.setAccessible(true);
+        synchronized (getPrivateStatic("sLifecycleLock")) {
+          Object owner = generation.startsWith("s") ? null : service;
+          field.setLong(owner, field.getLong(owner) + 1);
+        }
+        b.settle();
+        idleMain();
+        assertTrue(Issue81ShadowService.stops.isEmpty());
+        assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      }
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_replacementAndOldDestroy_preserveNewOwner()
+      throws Exception {
+    ForegroundService old = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+      b.awaitDispatch();
+      old.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      b.settle();
+      ForegroundService current = buildService().create().get();
+      current.onStartCommand(buildStartIntent("new", 814, "new"), 0, 12);
+      controllers.get(0).destroy();
+      controllers.remove(0);
+      idleMain();
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertSame(current, getPrivateStatic("sInstance"));
+      assertCurrentState("new", 814, "new");
+      assertNull(issue81Field(old, "mDeniedStartRecovery"));
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_destroyBeforeLateAcceptance_preservesUndeliveredB()
+      throws Exception {
+    ForegroundService old = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(null, true)) {
+      b.awaitDispatch();
+      old.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      controllers.get(0).destroy();
+      controllers.remove(0);
+      assertNull(issue81Field(old, "mDeniedStartRecovery"));
+      b.settle();
+      idleMain();
+      assertNull(b.failure.get());
+      assertEquals(1, issue81Pending().size());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      ForegroundService current = buildService().create().get();
+      current.onStartCommand(b.intent, 0, 12);
+      idleMain();
+      assertCurrentState("B", 812, "B");
+      assertTrue(issue81Pending().isEmpty());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_previousFailedCommand_doesNotSuppressNewRecovery()
+      throws Exception {
+    ForegroundService service = issue81Service();
+    assertSame(
+        Issue81ShadowService.failure,
+        assertThrows(
+            RuntimeException.class, () -> service.onStartCommand(issue81UnknownStart(), 0, 10)));
+    assertTrue((boolean) issue81Field(service, "mStartCommandFailed"));
+    try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      b.settle();
+      idleMain();
+      assertEquals(java.util.Collections.singletonList(11), Issue81ShadowService.stops);
+    }
+  }
+
+  private void issue81RejectAnotherDispatch() {
+    RecordingServiceContext context = useRecordingContext();
+    context.startFailure = new SecurityException("another definite rejection");
+    assertSame(context.startFailure, assertThrows(RuntimeException.class, () -> issue81StartB()));
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_newPendingStart_defersUntilItsDefiniteRejection()
+      throws Exception {
+    ForegroundService service = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      b.settle();
+      try (Issue81LateReply c = new Issue81LateReply(null, false)) {
+        c.awaitDispatch();
+        Object request = issue81Pending().get(c.intent.getStringExtra(ISSUE81_REQUEST_ID));
+        idleMain();
+        assertTrue(Issue81ShadowService.stops.isEmpty());
+        assertSame(request, issue81Pending().get(c.intent.getStringExtra(ISSUE81_REQUEST_ID)));
+        assertNotNull(issue81Field(service, "mDeniedStartRecovery"));
+        c.settle();
+        idleMain();
+        assertTrue(issue81Pending().isEmpty());
+        assertEquals(java.util.Collections.singletonList(11), Issue81ShadowService.stops);
+        assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      }
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_terminalDelivery_replacesRecoveryWithExplicitStop()
+      throws Exception {
+    for (Intent terminal : new Intent[] {buildStopIntent(), null}) {
+      ForegroundService service = issue81Service();
+      try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+        b.awaitDispatch();
+        service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+        service.onStartCommand(terminal, 0, 12);
+        assertNull(issue81Field(service, "mDeniedStartRecovery"));
+        Object explicitStop = getPrivateStatic("sStopRequest");
+        assertNotNull(explicitStop);
+        idleMain();
+        assertTrue(Issue81ShadowService.stops.isEmpty());
+        assertEquals(1, issue81Pending().size());
+        b.settle();
+        assertSame(explicitStop, getPrivateStatic("sStopRequest"));
+        idleMain();
+        assertEquals(java.util.Collections.singletonList(12), Issue81ShadowService.stops);
+        assertNull(getPrivateStatic("sStopRequest"));
+      }
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_lateOldRunnerCompletion_doesNotCancelRecovery()
+      throws Exception {
+    ForegroundService old = issue81Service();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      old.onStartCommand(buildStartIntent("old", 814, "old"), 0, 1);
+      ForegroundService service = buildService().create().get();
+      try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+        b.awaitDispatch();
+        service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+        Object recovery = issue81Field(service, "mDeniedStartRecovery");
+        capture.events.get(0).setCompletionResult();
+        assertSame(recovery, issue81Field(service, "mDeniedStartRecovery"));
+        issue81AssertUnpromoted(service);
+        b.settle();
+        idleMain();
+        assertEquals(java.util.Collections.singletonList(11), Issue81ShadowService.stops);
+        assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      }
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_staleOwnershipOrStartId_rejectsQueuedCallback()
+      throws Exception {
+    for (String authority : new String[] {"sInstance", "sStateOwner", "mLastStartId"}) {
+      ForegroundService service = issue81Service();
+      try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+        b.awaitDispatch();
+        service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+        b.settle();
+        // Independently exercise callback revalidation after it has captured the original token.
+        Field field = ForegroundService.class.getDeclaredField(authority);
+        field.setAccessible(true);
+        Object owner = authority.startsWith("s") ? null : service;
+        Object original = field.get(owner);
+        try {
+          synchronized (getPrivateStatic("sLifecycleLock")) {
+            field.set(owner, authority.equals("mLastStartId") ? 12 : new ForegroundService());
+          }
+          idleMain();
+          assertTrue(Issue81ShadowService.stops.isEmpty());
+          assertNull(issue81Field(service, "mDeniedStartRecovery"));
+        } finally {
+          field.set(owner, original);
+        }
+      }
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_deliveredUnfulfilledB_lateNullReplyKeepsObligation()
+      throws Exception {
+    issue81AssertUnfulfilledLateReply(null);
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_deliveredUnfulfilledB_lateSecurityReplyKeepsObligation()
+      throws Exception {
+    issue81AssertUnfulfilledLateReply(new SecurityException("B already delivered"));
+  }
+
+  private void issue81AssertUnfulfilledLateReply(RuntimeException rejection) throws Exception {
+    ForegroundService service = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(rejection, false)) {
+      b.awaitDispatch();
+      Intent incomplete = new Intent(b.intent);
+      incomplete.removeExtra("notification");
+      service.onStartCommand(incomplete, 0, 10);
+      Object request = issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID));
+      assertNotNull(request);
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      b.settle();
+      assertSame(rejection, b.failure.get());
+      idleMain();
+      assertSame(request, issue81Pending().get(b.intent.getStringExtra(ISSUE81_REQUEST_ID)));
+      assertEquals(1, issue81Pending().size());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      issue81AssertUnpromoted(service);
+      service.onStartCommand(b.intent, 0, 12);
+      idleMain();
+      assertCurrentState("B", 812, "B");
+      assertTrue(issue81Pending().isEmpty());
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      assertNull(getPrivateStatic("sStopRequest"));
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 34},
+      shadows = Issue81ShadowService.class)
+  public void issue81_deferredRecovery_explicitStop_invalidatesRecoveryWhileBPending()
+      throws Exception {
+    ForegroundService service = issue81Service();
+    try (Issue81LateReply b = new Issue81LateReply(null, false)) {
+      b.awaitDispatch();
+      service.onStartCommand(issue81UnknownStart(), Service.START_FLAG_RETRY, 11);
+      assertNotNull(issue81Field(service, "mDeniedStartRecovery"));
+      ForegroundService.stop();
+      assertNull(issue81Field(service, "mDeniedStartRecovery"));
+      Object explicitStop = getPrivateStatic("sStopRequest");
+      assertNotNull(explicitStop);
+      idleMain();
+      assertTrue(Issue81ShadowService.stops.isEmpty());
+      assertEquals(1, issue81Pending().size());
+      b.settle();
+      assertSame(explicitStop, getPrivateStatic("sStopRequest"));
+      idleMain();
+      assertEquals(java.util.Collections.singletonList(11), Issue81ShadowService.stops);
+      assertNull(getPrivateStatic("sStopRequest"));
+    }
+  }
+
+  // Suspend the actual START sender's platform reply, without blocking lifecycle delivery.
+  private static final class Issue81LateReply implements AutoCloseable {
+    final CountDownLatch dispatched = new CountDownLatch(1);
+    final CountDownLatch reply = new CountDownLatch(1);
+    final AtomicReference<Throwable> failure = new AtomicReference<>();
+    final Thread sender;
+    Intent intent;
+
+    Issue81LateReply(RuntimeException rejection, boolean accepted) {
+      this(rejection, accepted, "B", 812);
+    }
+
+    Issue81LateReply(RuntimeException rejection, boolean accepted, String id, int hash) {
+      ContextHolder.setApplicationContext(
+          new ContextWrapper(RuntimeEnvironment.getApplication()) {
+            @Override
+            public ComponentName startForegroundService(Intent start) {
+              intent = new Intent(start);
+              dispatched.countDown();
+              try {
+                if (!reply.await(5, TimeUnit.SECONDS)) {
+                  throw new IllegalStateException("B reply timed out");
+                }
+              } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new IllegalStateException(e);
+              }
+              if (rejection != null) {
+                throw rejection;
+              }
+              return accepted ? start.getComponent() : null;
+            }
+          });
+      sender =
+          new Thread(
+              () -> {
+                try {
+                  Intent start =
+                      buildStartIntent(id, hash, id, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+                  ForegroundService.start(
+                      hash,
+                      start.getParcelableExtra("notification"),
+                      start.getBundleExtra("notificationBundle"));
+                } catch (Throwable e) {
+                  failure.set(e);
+                }
+              });
+      sender.start();
+    }
+
+    void awaitDispatch() throws Exception {
+      assertTrue(dispatched.await(5, TimeUnit.SECONDS));
+    }
+
+    void settle() throws Exception {
+      reply.countDown();
+      sender.join(5000);
+      assertFalse(sender.isAlive());
+    }
+
+    @Override
+    public void close() throws Exception {
+      settle();
+    }
+  }
+
+  private ForegroundService issue81Service() throws Exception {
+    Issue81ShadowService.failure =
+        Build.VERSION.SDK_INT >= 31
+            ? new ForegroundServiceStartNotAllowedException("initial A promotion denied")
+            : new IllegalStateException("initial A promotion denied");
+    Issue81ShadowService.stopFailure = null;
+    Issue81ShadowService.rejectTitle = "A";
+    Issue81ShadowService.stopResult = true;
+    Issue81ShadowService.beforeStop = null;
+    Issue81ShadowService.beforePromotion = null;
+    Issue81ShadowService.promotions.clear();
+    Issue81ShadowService.types.clear();
+    Issue81ShadowService.stops.clear();
+    Issue81ShadowService.order.clear();
+    ShadowLog.clear();
+    if (Build.VERSION.SDK_INT >= 34) {
+      declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    }
+    if (Build.VERSION.SDK_INT >= 26) {
+      createChannel();
+    }
+    return buildService().create().get();
+  }
+
+  private static Intent issue81UnknownStart() {
+    return buildStartIntent("A", 810, "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
+        .putExtra(ISSUE81_REQUEST_ID, UUID.randomUUID().toString());
+  }
+
+  private static void issue81StartB() {
+    Intent b = buildStartIntent("B", 812, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    ForegroundService.start(
+        812, b.getParcelableExtra("notification"), b.getBundleExtra("notificationBundle"));
+  }
+
+  private void issue81AssertFreshRecovery(int flags) throws Exception {
+    ForegroundService service = issue81Service();
+    issue81ObserveRecoveryStop(service);
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      int result;
+      try {
+        result = service.onStartCommand(issue81UnknownStart(), flags, 7);
+      } catch (RuntimeException denied) {
+        // RED is admissible only after the real handler attempted the real notification/type.
+        assertSame(Issue81ShadowService.failure, denied);
+        assertEquals(java.util.Collections.singletonList(810), Issue81ShadowService.promotions);
+        assertEquals(
+            java.util.Collections.singletonList(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+            Issue81ShadowService.types);
+        issue81AssertUnpromoted(service);
+        throw denied;
+      }
+      assertEquals(Service.START_NOT_STICKY, result);
+      assertEquals(java.util.Collections.singletonList(810), Issue81ShadowService.promotions);
+      assertEquals(
+          java.util.Collections.singletonList(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+          Issue81ShadowService.types);
+      assertEquals(java.util.Arrays.asList("promote:810", "stop:7"), Issue81ShadowService.order);
+      issue81AssertUnpromoted(service);
+      assertTrue((boolean) issue81Field(service, "mStopInitiated"));
+      assertTrue(capture.events.isEmpty());
+      assertTrue(issue81Pending().isEmpty());
+      assertTrue(
+          ShadowLog.getLogsForTag("NOTIFEE").stream()
+              .anyMatch(
+                  item ->
+                      item.type == android.util.Log.WARN
+                          && item.throwable == Issue81ShadowService.failure
+                          && item.msg.contains("startId=7")
+                          && item.msg.contains("flags=" + flags)));
+      ForegroundService current = buildService().create().get();
+      current.onStartCommand(buildStartIntent("new", 814, "new"), 0, 8);
+      controllers.get(0).destroy();
+      controllers.remove(0);
+      assertCurrentState("new", 814, "new");
+      assertSame(current, getPrivateStatic("sInstance"));
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  private static void issue81AssertUnpromoted(ForegroundService service) throws Exception {
+    assertFalse((boolean) issue81Field(service, "mStartForegroundCalled"));
+    assertFalse((boolean) issue81Field(service, "mForegroundActive"));
+    assertFalse((boolean) issue81Field(service, "mStartCommandSatisfied"));
+    assertNull(issue81Field(service, "mRunnerToken"));
+    assertEquals(0, issue81Field(service, "mRunFirstStartId"));
+    assertNull(ForegroundService.mCurrentNotificationId);
+    assertEquals(-1, ForegroundService.mCurrentForegroundServiceType);
+    assertNull(getPrivateStatic("mCurrentNotificationBundle"));
+    assertNull(getPrivateStatic("mCurrentNotification"));
+    assertEquals(0, getPrivateStatic("mCurrentHashCode"));
+  }
+
+  private static void issue81ObserveRecoveryStop(ForegroundService service) {
+    Issue81ShadowService.beforeStop =
+        () -> {
+          try {
+            assertTrue(Thread.holdsLock(getPrivateStatic("sLifecycleLock")));
+            assertFalse(Thread.holdsLock(getPrivateStatic("sLock")));
+            issue81AssertUnpromoted(service);
+            assertFalse((boolean) issue81Field(service, "mStopInitiated"));
+          } catch (Exception e) {
+            throw new AssertionError(e);
+          }
+        };
+  }
+
+  private static Object issue81Field(Object instance, String name) throws Exception {
+    Field field = ForegroundService.class.getDeclaredField(name);
+    field.setAccessible(true);
+    return field.get(instance);
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, ?> issue81Pending() throws Exception {
+    return (Map<String, ?>) getPrivateStatic("sPendingStarts");
+  }
+
+  @Implements(Service.class)
+  public static class Issue81ShadowService extends ShadowService {
+    static RuntimeException failure;
+    static RuntimeException stopFailure;
+    static String rejectTitle;
+    static boolean stopResult;
+    static Runnable beforeStop;
+    static Runnable beforePromotion;
+    static final List<Integer> promotions = new ArrayList<>();
+    static final List<Integer> types = new ArrayList<>();
+    static final List<Integer> stops = new ArrayList<>();
+    static final List<String> order = new ArrayList<>();
+    private boolean forwardingTyped;
+
+    private void recordPromotion(int id, Notification notification, int type) {
+      promotions.add(id);
+      types.add(type);
+      order.add("promote:" + id);
+      if (beforePromotion != null) beforePromotion.run();
+      if (failure != null
+          && (id == Integer.MAX_VALUE - 1
+              || rejectTitle == null
+              || rejectTitle.equals(notification.extras.getString(Notification.EXTRA_TITLE)))) {
+        throw failure;
+      }
+    }
+
+    @Implementation
+    protected void startForeground(int id, Notification notification) {
+      if (!forwardingTyped) {
+        recordPromotion(id, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE);
+      }
+      super.startForeground(id, notification);
+    }
+
+    @Implementation
+    protected void startForeground(int id, Notification notification, int type) {
+      recordPromotion(id, notification, type);
+      // ShadowService's typed overload delegates to the two-argument shadow. Record only the
+      // actual platform invocation so the witness cannot count that delegation as a second call.
+      forwardingTyped = true;
+      try {
+        super.startForeground(id, notification, type);
+      } finally {
+        forwardingTyped = false;
+      }
+    }
+
+    @Implementation
+    protected boolean stopSelfResult(int startId) {
+      if (beforeStop != null) {
+        beforeStop.run();
+      }
+      stops.add(startId);
+      order.add("stop:" + startId);
+      if (stopFailure != null) {
+        throw stopFailure;
+      }
+      return stopResult && super.stopSelfResult(startId);
+    }
+  }
+
+  @Implements(NotificationManager.class)
+  public static class Issue81NotificationShadowManager extends ShadowNotificationManager {
+    @Implementation
+    protected void notify(String tag, int id, Notification notification) {
+      if ("A".equals(notification.extras.getString(Notification.EXTRA_TITLE))) {
+        throw Issue81ShadowService.failure;
+      }
+      super.notify(tag, id, notification);
+    }
+  }
+
+  @Test
+  @Config(sdk = {24, 26, 30, 33, 34})
+  public void stop_withoutInstance_doesNotStartServiceOrEmitRunner() {
+    RecordingServiceContext context = useRecordingContext();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      ForegroundService.stop();
+      idleMain();
+      assertTrue(context.starts.isEmpty());
+      assertEquals(0, context.stops);
+      assertTrue(capture.events.isEmpty());
+      assertNull(ForegroundService.mCurrentNotificationId);
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_startStopDestroySecondStop_doesNotRecreateService() {
+    RecordingServiceContext context = useRecordingContext();
+    ServiceController<ForegroundService> controller = buildService();
+    ForegroundService service = controller.create().get();
+    createChannel();
+    service.onStartCommand(buildStartIntent("first", 101), 0, 1);
+
+    ForegroundService.stop();
+    idleMain();
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    controller.destroy();
+    controllers.remove(controller);
+    ForegroundService.stop();
+    idleMain();
+    assertTrue(context.starts.isEmpty());
+    assertNull(ForegroundService.mCurrentNotificationId);
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_nullNotificationCache_stillStopsLiveInstance() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = buildService().create().get();
+    createChannel();
+    service.onStartCommand(buildStartIntent("live", 102), 0, 1);
+    ForegroundService.mCurrentNotificationId = null;
+    ForegroundService.mCurrentForegroundServiceType = -1;
+    setPrivateStatic("mCurrentNotificationBundle", null);
+    setPrivateStatic("mCurrentNotification", null);
+    setPrivateStatic("mCurrentHashCode", 0);
+
+    ForegroundService.stop();
+    idleMain();
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertTrue(context.starts.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_concurrentDestroy_doesNotDispatchNewGeneration() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ServiceController<ForegroundService> controller = buildService();
+    ForegroundService service = controller.create().get();
+    createChannel();
+    service.onStartCommand(buildStartIntent("old", 103), 0, 1);
+    CountDownLatch begin = new CountDownLatch(1);
+    AtomicReference<Throwable> failure = new AtomicReference<>();
+    Thread stop =
+        new Thread(
+            () -> {
+              try {
+                assertTrue(begin.await(5, TimeUnit.SECONDS));
+                ForegroundService.stop();
+              } catch (Throwable e) {
+                failure.set(e);
+              }
+            });
+    stop.start();
+    begin.countDown();
+    controller.destroy();
+    controllers.remove(controller);
+    stop.join(5000);
+    assertFalse(stop.isAlive());
+    assertNull(failure.get());
+    idleMain();
+    assertTrue(context.starts.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void onDestroy_oldInstance_preservesNewInstanceAndAllNotificationState() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ServiceController<ForegroundService> oldController = buildService();
+    ForegroundService old = oldController.create().get();
+    createChannel();
+    old.onStartCommand(buildStartIntent("old", 104), 0, 1);
+    ForegroundService current = buildService().create().get();
+    current.onStartCommand(buildStartIntent("new", 105, "new title"), 0, 2);
+    oldController.destroy();
+    controllers.remove(oldController);
+
+    assertCurrentState("new", 105, "new title");
+    ForegroundService.stop();
+    idleMain();
+    assertTrue(org.robolectric.Shadows.shadowOf(current).isStoppedBySelf());
+    assertTrue(context.starts.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void runnerCompletion_oldInstance_doesNotDemoteOrClearNewInstance() throws Exception {
+    useRecordingContext();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      ForegroundService old = buildService().create().get();
+      createChannel();
+      old.onStartCommand(buildStartIntent("old", 106), 0, 1);
+      ForegroundService current = buildService().create().get();
+      current.onStartCommand(buildStartIntent("new", 107, "new title"), 0, 2);
+      assertEquals(2, capture.events.size());
+
+      capture.events.get(0).setCompletionResult();
+      idleMain();
+      assertCurrentState("new", 107, "new title");
+      assertFalse(org.robolectric.Shadows.shadowOf(current).isForegroundStopped());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void runnerCompletion_oldRunOnSameInstance_preservesNewRun() throws Exception {
+    useRecordingContext();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      ForegroundService service = buildService().create().get();
+      createChannel();
+      service.onStartCommand(buildStartIntent("old", 108), 0, 1);
+      service.onStartCommand(buildStopIntent(), 0, 2);
+      service.onStartCommand(buildStartIntent("new", 109, "new title"), 0, 3);
+      assertEquals(2, capture.events.size());
+
+      capture.events.get(0).setCompletionResult();
+      idleMain();
+      assertCurrentState("new", 109, "new title");
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+      capture.events.get(1).setCompletionResult();
+      idleMain();
+      assertNull(ForegroundService.mCurrentNotificationId);
+      assertTrue(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_acceptedPendingStart_fulfillsRealContractBeforeStopping() {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    ForegroundService.start(110, buildNotification(), buildNotificationBundle("pending"));
+    ForegroundService.stop();
+    idleMain();
+    assertEquals(1, context.starts.size());
+    ForegroundService service = buildService().create().get();
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    service.onStartCommand(context.starts.get(0), 0, 1);
+    idleMain();
+    assertEquals(110, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(ForegroundService.mCurrentNotificationId);
+    assertEquals(1, context.starts.size());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_betweenCreateAndPendingDelivery_doesNotStopBeforeRealPromotion() {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    ForegroundService.start(111, buildNotification(), buildNotificationBundle("pending"));
+    ForegroundService service = buildService().create().get();
+    ForegroundService.stop();
+    idleMain();
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(org.robolectric.Shadows.shadowOf(service).getLastForegroundNotification());
+
+    service.onStartCommand(context.starts.get(0), 0, 1);
+    idleMain();
+    assertEquals(111, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertEquals(1, context.starts.size());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_newStartAcceptedBeforeQueuedStop_doesNotCancelLaterStart() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(buildStartIntent("same", 112, "A"), 0, 1);
+    ForegroundService.stop();
+    Intent later = buildStartIntent("same", 112, "B");
+    ForegroundService.start(
+        112, later.getParcelableExtra("notification"), later.getBundleExtra("notificationBundle"));
+    idleMain();
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    service.onStartCommand(context.starts.get(0), 0, 2);
+    idleMain();
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertCurrentState("same", 112, "B");
+  }
+
+  @Test
+  @Config(
+      sdk = {28, 33, 34},
+      shadows = {RejectBStartForegroundShadowService.class, RejectBNotificationShadowManager.class})
+  public void stop_failedRestart_preservesPreviousSubmittedStateAndRunner() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    if (Build.VERSION.SDK_INT >= 34) {
+      declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    }
+    createChannel();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      ForegroundService service = buildService().create().get();
+      Intent a = buildStartIntent("same", 177, "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+      ForegroundService.start(
+          177, a.getParcelableExtra("notification"), a.getBundleExtra("notificationBundle"));
+      service.onStartCommand(context.starts.get(0), 0, 1);
+      Field tokenField = ForegroundService.class.getDeclaredField("mRunnerToken");
+      tokenField.setAccessible(true);
+      Object tokenA = tokenField.get(service);
+      int typeA = ForegroundService.mCurrentForegroundServiceType;
+
+      ForegroundService.stop();
+      Intent b = buildStartIntent("same", 177, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+      ForegroundService.start(
+          177, b.getParcelableExtra("notification"), b.getBundleExtra("notificationBundle"));
+      SecurityException failure =
+          assertThrows(
+              SecurityException.class, () -> service.onStartCommand(context.starts.get(1), 0, 2));
+
+      assertEquals("posting B rejected", failure.getMessage());
+      assertEquals(
+          "A",
+          org.robolectric.Shadows.shadowOf(
+                  (NotificationManager)
+                      RuntimeEnvironment.getApplication()
+                          .getSystemService(Context.NOTIFICATION_SERVICE))
+              .getNotification(177)
+              .extras
+              .getString(Notification.EXTRA_TITLE));
+      assertCurrentState("same", 177, "A");
+      assertEquals(typeA, ForegroundService.mCurrentForegroundServiceType);
+      assertTrue(tokenA == tokenField.get(service));
+      assertEquals(1, capture.events.size());
+      assertTrue(ForegroundService.repostIfActive("same"));
+      idleMain();
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      capture.events.get(0).setCompletionResult();
+      idleMain();
+      assertCurrentState("same", 177, "A");
+      assertTrue(tokenA == tokenField.get(service));
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+
+      // A failed reservation must still be replaced by a fresh runner when C succeeds in the
+      // reserved session, even if C uses a different notification ID.
+      Intent c = buildStartIntent("new", 178, "C", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+      ForegroundService.start(
+          178, c.getParcelableExtra("notification"), c.getBundleExtra("notificationBundle"));
+      service.onStartCommand(context.starts.get(2), 0, 3);
+      assertCurrentState("new", 178, "C");
+      assertFalse(tokenA == tokenField.get(service));
+      assertEquals(2, capture.events.size());
+      capture.events.get(0).setCompletionResult();
+      idleMain();
+      assertCurrentState("new", 178, "C");
+      capture.events.get(1).setCompletionResult();
+      idleMain();
+      assertNull(ForegroundService.mCurrentNotificationId);
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void onStartCommand_stopAndNullWithPendingStart_doNotSuppressRealStart() {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    ForegroundService.start(113, buildNotification(), buildNotificationBundle("pending"));
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(buildStopIntent(), 0, 1);
+    service.onStartCommand(null, 0, 2);
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(org.robolectric.Shadows.shadowOf(service).getLastForegroundNotification());
+
+    service.onStartCommand(context.starts.get(0), 0, 3);
+    idleMain();
+    assertEquals(113, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+  }
+
+  @Test
+  @Config(
+      sdk = {31, 33, 34, 35},
+      shadows = DefensiveFailureShadowService.class)
+  public void onStartCommand_stopAndNullDenied_areNonFatalAndDoNotClaimPromotion()
+      throws Exception {
+    if (Build.VERSION.SDK_INT >= 34) {
+      declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    }
+    DefensiveFailureShadowService.failure = new ForegroundServiceStartNotAllowedException("denied");
+    DefensiveFailureShadowService.attempts = 0;
+    ShadowLog.clear();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(buildStopIntent(), 0, 1);
+    service.onStartCommand(null, 0, 2);
+
+    assertEquals(2, DefensiveFailureShadowService.attempts);
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertTrue(
+        ShadowLog.getLogsForTag("NOTIFEE").stream()
+            .anyMatch(item -> item.throwable == DefensiveFailureShadowService.failure));
+  }
+
+  @Test
+  @Config(sdk = 31, shadows = DefensiveFailureShadowService.class)
+  public void onStartCommand_stopDeniedApi31_isNonFatal() {
+    DefensiveFailureShadowService.failure = new ForegroundServiceStartNotAllowedException("denied");
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(buildStopIntent(), 0, 1);
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+  }
+
+  @Test
+  @Config(
+      sdk = {24, 30, 33},
+      shadows = DefensiveFailureShadowService.class)
+  public void onStartCommand_stopGenericIllegalState_remainsObservable() {
+    assertTerminalFailureObservable(new IllegalStateException("unrelated ISE"));
+  }
+
+  @Test
+  @Config(sdk = 34, shadows = DefensiveFailureShadowService.class)
+  public void onStartCommand_stopMissingType_remainsObservable() throws Exception {
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    assertTerminalFailureObservable(new MissingForegroundServiceTypeException("missing type"));
+  }
+
+  @Test
+  @Config(sdk = 34, shadows = DefensiveFailureShadowService.class)
+  public void onStartCommand_stopInvalidType_remainsObservable() throws Exception {
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    assertTerminalFailureObservable(new InvalidForegroundServiceTypeException("invalid type"));
+  }
+
+  @Test
+  @Config(sdk = 34, shadows = DefensiveFailureShadowService.class)
+  public void onStartCommand_noneDenied_isNotSoftSuppressed() throws Exception {
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    DefensiveFailureShadowService.failure =
+        new ForegroundServiceStartNotAllowedException("NONE denied");
+    ForegroundService service = buildService().create().get();
+    Intent none = buildStartIntent("none", 114, "none", ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE);
+    // The model normalizes NONE to MANIFEST on API 34. Removing only the application context
+    // makes manifest resolution return NONE; the Service still has its declared defensive type.
+    ContextHolder.setApplicationContext(null);
+    RuntimeException thrown =
+        assertThrows(RuntimeException.class, () -> service.onStartCommand(none, 0, 1));
+    assertTrue(
+        thrown == DefensiveFailureShadowService.failure
+            || thrown.getCause() == DefensiveFailureShadowService.failure);
+    assertEquals(Integer.MAX_VALUE - 1, DefensiveFailureShadowService.lastId);
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC, DefensiveFailureShadowService.lastType);
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = SecurityDefensiveChannelShadowManager.class)
+  public void onStartCommand_terminalChannelSecurityException_remainsObservable() {
+    for (Intent terminal : new Intent[] {buildStopIntent(), null}) {
+      ForegroundService service = buildService().create().get();
+      SecurityException thrown =
+          assertThrows(SecurityException.class, () -> service.onStartCommand(terminal, 0, 1));
+      assertEquals("defensive channel failure", thrown.getMessage());
+      assertNull(org.robolectric.Shadows.shadowOf(service).getLastForegroundNotification());
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    }
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = SecurityStopForegroundShadowService.class)
+  public void onStartCommand_terminalTeardownSecurityException_remainsObservable() {
+    for (Intent terminal : new Intent[] {buildStopIntent(), null}) {
+      ForegroundService service = buildService().create().get();
+      SecurityException thrown =
+          assertThrows(SecurityException.class, () -> service.onStartCommand(terminal, 0, 1));
+      assertEquals("defensive teardown failure", thrown.getMessage());
+      assertEquals(
+          Integer.MAX_VALUE - 1,
+          org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    }
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = DefensiveFailureShadowService.class)
+  public void onStartCommand_pendingStartDenied_isNotSoftSuppressedByStop() {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService.start(115, buildNotification(), buildNotificationBundle("pending"));
+    ForegroundService.stop();
+    DefensiveFailureShadowService.failure =
+        new ForegroundServiceStartNotAllowedException("real START denied");
+    ForegroundService service = buildService().create().get();
+    assertThrows(
+        ForegroundServiceStartNotAllowedException.class,
+        () -> service.onStartCommand(context.starts.get(0), 0, 1));
+    idleMain();
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+  }
+
+  private void assertTerminalFailureObservable(RuntimeException failure) {
+    DefensiveFailureShadowService.failure = failure;
+    ForegroundService service = buildService().create().get();
+    RuntimeException thrown =
+        assertThrows(RuntimeException.class, () -> service.onStartCommand(buildStopIntent(), 0, 1));
+    assertTrue(thrown == failure || thrown.getCause() == failure);
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void runnerCompletion_stopSupersededByNewStart_preservesLaterRun() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      ForegroundService service = buildService().create().get();
+      createChannel();
+      service.onStartCommand(buildStartIntent("same", 116, "A"), 0, 1);
+      ForegroundService.stop();
+      Intent later = buildStartIntent("same", 116, "B");
+      ForegroundService.start(
+          116,
+          later.getParcelableExtra("notification"),
+          later.getBundleExtra("notificationBundle"));
+      service.onStartCommand(context.starts.get(0), 0, 2);
+      capture.events.get(0).setCompletionResult();
+      idleMain();
+
+      assertCurrentState("same", 116, "B");
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      assertEquals(2, capture.events.size());
+      capture.events.get(1).setCompletionResult();
+      idleMain();
+      assertNull(ForegroundService.mCurrentNotificationId);
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_createdButUnpublishedStart_waitsForRealStartCommand() {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = buildService().create().get();
+    ForegroundService.stop();
+    idleMain();
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(org.robolectric.Shadows.shadowOf(service).getLastForegroundNotification());
+    createChannel();
+    service.onStartCommand(buildStartIntent("unknown", 117), 0, 1);
+    idleMain();
+    assertEquals(117, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertTrue(context.starts.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_multiplePendingStarts_waitsForAllRealCommands() {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    ForegroundService.start(118, buildNotification(), buildNotificationBundle("pending"));
+    ForegroundService.start(118, buildNotification(), buildNotificationBundle("pending"));
+    ForegroundService.stop();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(context.starts.get(0), 0, 1);
+    idleMain();
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    service.onStartCommand(context.starts.get(1), 0, 2);
+    idleMain();
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertEquals(2, org.robolectric.Shadows.shadowOf(service).getStopSelfResultId());
+    assertEquals(2, context.starts.size());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void onStartCommand_pendingWithoutPromotion_doesNotAcquireStopAuthority() {
+    RecordingServiceContext context = useRecordingContext();
+    // Accepted START, but its delivery has no notification. STOP must not turn this into a
+    // successful/absent START obligation, even though malformed START handling is out of scope.
+    ForegroundService.start(119, null, buildNotificationBundle("pending"));
+    ForegroundService.stop();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(context.starts.get(0), 0, 1);
+    idleMain();
+    ForegroundService.stop();
+    service.onStartCommand(null, 0, 2);
+    idleMain();
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(org.robolectric.Shadows.shadowOf(service).getLastForegroundNotification());
+    assertEquals(1, context.starts.size());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void start_dispatchFailure_doesNotCancelEarlierStop() {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(buildStartIntent("live", 120), 0, 1);
+    ForegroundService.stop();
+    context.startFailure = new ForegroundServiceStartNotAllowedException("dispatch rejected");
+    assertThrows(
+        ForegroundServiceStartNotAllowedException.class,
+        () -> ForegroundService.start(121, buildNotification(), buildNotificationBundle("failed")));
+    idleMain();
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(ForegroundService.mCurrentNotificationId);
+    assertEquals(1, context.starts.size());
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = RefuseStopSelfShadowService.class)
+  public void stop_frameworkRefusesTokenStop_preservesCurrentState() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService service = buildService().create().get();
+    createChannel();
+    service.onStartCommand(buildStartIntent("live", 122, "live title"), 0, 1);
+    ForegroundService.stop();
+    idleMain();
+    assertCurrentState("live", 122, "live title");
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+    assertTrue(context.starts.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 34)
+  public void onTimeout_oldInstance_doesNotClearNewStateOrEmitNewInstanceEvent() throws Exception {
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+    createChannel();
+    ForegroundService old = buildService().create().get();
+    old.onStartCommand(
+        buildStartIntent("old", 123, "old", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        0,
+        1);
+    ForegroundService current = buildService().create().get();
+    current.onStartCommand(
+        buildStartIntent(
+            "new", 124, "new title", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        0,
+        2);
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      old.onTimeout(1);
+      assertCurrentState("new", 124, "new title");
+      assertEquals(
+          ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE,
+          ForegroundService.mCurrentForegroundServiceType);
+      assertTrue(capture.events.isEmpty());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = FailStopForegroundShadowService.class)
+  public void onStartCommand_denialOutsidePromotion_isStillFatal() {
+    ForegroundService service = buildService().create().get();
+    RuntimeException thrown =
+        assertThrows(RuntimeException.class, () -> service.onStartCommand(buildStopIntent(), 0, 1));
+    assertTrue(
+        thrown instanceof ForegroundServiceStartNotAllowedException
+            || thrown.getCause() instanceof ForegroundServiceStartNotAllowedException);
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_duringStartAcceptance_preservesAndThenStopsAcceptedStart() throws Exception {
+    CountDownLatch dispatchEntered = new CountDownLatch(1);
+    CountDownLatch releaseDispatch = new CountDownLatch(1);
+    CountDownLatch stopAttempted = new CountDownLatch(1);
+    RecordingServiceContext context =
+        new RecordingServiceContext(RuntimeEnvironment.getApplication()) {
+          @Override
+          public ComponentName startForegroundService(Intent intent) {
+            dispatchEntered.countDown();
+            try {
+              assertTrue(releaseDispatch.await(5, TimeUnit.SECONDS));
+            } catch (InterruptedException e) {
+              throw new AssertionError(e);
+            }
+            return super.startForegroundService(intent);
+          }
+        };
+    ContextHolder.setApplicationContext(context);
+    createChannel();
+    Notification notification = buildNotification();
+    Bundle bundle = buildNotificationBundle("pending");
+    ExecutorService workers = Executors.newFixedThreadPool(2);
+    try {
+      Future<?> start = workers.submit(() -> ForegroundService.start(125, notification, bundle));
+      assertTrue(dispatchEntered.await(5, TimeUnit.SECONDS));
+      Future<?> stop =
+          workers.submit(
+              () -> {
+                stopAttempted.countDown();
+                ForegroundService.stop();
+              });
+      assertTrue(stopAttempted.await(5, TimeUnit.SECONDS));
+      releaseDispatch.countDown();
+      start.get(5, TimeUnit.SECONDS);
+      stop.get(5, TimeUnit.SECONDS);
+
+      ForegroundService service = buildService().create().get();
+      service.onStartCommand(context.starts.get(0), 0, 1);
+      idleMain();
+      assertEquals(
+          125, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+      assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      assertEquals(1, context.starts.size());
+    } finally {
+      releaseDispatch.countDown();
+      workers.shutdownNow();
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_queuedForDestroyedInstance_doesNotTouchLaterInstance() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    ServiceController<ForegroundService> oldController = buildService();
+    ForegroundService old = oldController.create().get();
+    old.onStartCommand(buildStartIntent("old", 126), 0, 1);
+    ForegroundService.stop();
+    oldController.destroy();
+    controllers.remove(oldController);
+    ForegroundService current = buildService().create().get();
+    current.onStartCommand(buildStartIntent("new", 127, "new title"), 0, 2);
+    idleMain();
+    assertCurrentState("new", 127, "new title");
+    assertFalse(org.robolectric.Shadows.shadowOf(current).isStoppedBySelf());
+    assertTrue(context.starts.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_liveInstanceWithUnavailableApplicationContext_stillReachesInstance() {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(buildStartIntent("live", 128), 0, 1);
+    ContextHolder.setApplicationContext(null);
+    ForegroundService.stop();
+    idleMain();
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertTrue(context.starts.isEmpty());
+  }
+
+  @Test
+  @Config(sdk = 24)
+  public void stop_pendingStartBeforeApi26_preservesPlainStartContract() {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService.start(129, buildNotification(), buildNotificationBundle("pending"));
+    ForegroundService.stop();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(context.starts.get(0), 0, 1);
+    idleMain();
+    assertEquals(129, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertEquals(1, context.starts.size());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void runnerCompletion_afterStopBeforeNewDelivery_doesNotDemotePendingRun() {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      ForegroundService service = buildService().create().get();
+      service.onStartCommand(buildStartIntent("same", 130), 0, 1);
+      ForegroundService.stop();
+      ForegroundService.start(130, buildNotification(), buildNotificationBundle("same"));
+      capture.events.get(0).setCompletionResult();
+      idleMain();
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      service.onStartCommand(context.starts.get(0), 0, 2);
+      assertEquals(2, capture.events.size());
+      assertEquals("same", ForegroundService.mCurrentNotificationId);
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void stop_laterRealPromotion_settlesEarlierDeliveredUnknownContract() {
+    RecordingServiceContext context = useRecordingContext();
+    ForegroundService.start(131, null, buildNotificationBundle("unknown"));
+    ForegroundService.stop();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(context.starts.get(0), 0, 1);
+    idleMain();
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    createChannel();
+    ForegroundService.start(132, buildNotification(), buildNotificationBundle("valid"));
+    service.onStartCommand(context.starts.get(1), 0, 2);
+    ForegroundService.stop();
+    idleMain();
+    assertEquals(132, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(ForegroundService.mCurrentNotificationId);
+    assertEquals(2, context.starts.size());
+  }
+
+  @Test
+  @Config(sdk = 28, shadows = RejectBStartForegroundShadowService.class)
+  public void stop_failedUpdateOnRealForegroundInstance_doesNotFenceStopForever() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(buildStartIntent("same", 133, "A"), 0, 1);
+    Intent update = buildStartIntent("same", 133, "B");
+    ForegroundService.start(
+        133,
+        update.getParcelableExtra("notification"),
+        update.getBundleExtra("notificationBundle"));
+    assertThrows(
+        SecurityException.class, () -> service.onStartCommand(context.starts.get(0), 0, 2));
+    assertCurrentState("same", 133, "A");
+    ForegroundService.stop();
+    idleMain();
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(ForegroundService.mCurrentNotificationId);
+  }
+
+  @Test
+  @Config(sdk = 34)
+  public void onTimeout_oldRunOnSameInstance_preservesNewRun() throws Exception {
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+    createChannel();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(
+        buildStartIntent("old", 134, "old", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        0,
+        1);
+    service.onStartCommand(buildStopIntent(), 0, 2);
+    service.onStartCommand(
+        buildStartIntent(
+            "new", 135, "new title", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        0,
+        3);
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      service.onTimeout(1);
+      assertCurrentState("new", 135, "new title");
+      assertEquals(
+          ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE,
+          ForegroundService.mCurrentForegroundServiceType);
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+      assertTrue(capture.events.isEmpty());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 34)
+  public void onTimeout_sameRunEarlierStartId_preservesLatestUpdateTimeoutBehavior()
+      throws Exception {
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+    createChannel();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(
+        buildStartIntent("same", 136, "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        0,
+        1);
+    service.onStartCommand(
+        buildStartIntent("same", 136, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        0,
+        2);
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      service.onTimeout(1);
+      assertNull(ForegroundService.mCurrentNotificationId);
+      assertTrue(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+      assertEquals(1, capture.events.size());
+      assertEquals("B", capture.events.get(0).getNotification().toBundle().getString("title"));
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void start_serviceDeliveryBeforeDispatchReturns_canFulfillRealContract() throws Exception {
+    CountDownLatch dispatchEntered = new CountDownLatch(1);
+    CountDownLatch promotionObserved = new CountDownLatch(1);
+    AtomicReference<Boolean> blocked = new AtomicReference<>(false);
+    RecordingServiceContext context =
+        new RecordingServiceContext(RuntimeEnvironment.getApplication()) {
+          @Override
+          public ComponentName startForegroundService(Intent intent) {
+            ComponentName result = super.startForegroundService(intent);
+            dispatchEntered.countDown();
+            try {
+              // The timeout releases the simulated Binder reply even for the broken candidate.
+              blocked.set(!promotionObserved.await(2, TimeUnit.SECONDS));
+            } catch (InterruptedException e) {
+              throw new AssertionError(e);
+            }
+            return result;
+          }
+        };
+    ContextHolder.setApplicationContext(context);
+    createChannel();
+    Notification notification = buildNotification();
+    Bundle bundle = buildNotificationBundle("pending");
+    ExecutorService worker = Executors.newSingleThreadExecutor();
+    try {
+      Future<?> start = worker.submit(() -> ForegroundService.start(137, notification, bundle));
+      assertTrue(dispatchEntered.await(5, TimeUnit.SECONDS));
+      ForegroundService service = buildService().create().get();
+      service.onStartCommand(context.starts.get(0), 0, 1);
+      promotionObserved.countDown();
+      start.get(5, TimeUnit.SECONDS);
+      assertFalse("Service promotion waited for the dispatch caller", blocked.get());
+      assertEquals(
+          137, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+    } finally {
+      promotionObserved.countDown();
+      worker.shutdownNow();
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void start_ambiguousDispatchFailure_retainsRealObligationUntilDelivery() {
+    RecordingServiceContext context = useRecordingContext();
+    context.startFailure = new IllegalStateException("Binder outcome unknown");
+    assertThrows(
+        IllegalStateException.class,
+        () ->
+            ForegroundService.start(138, buildNotification(), buildNotificationBundle("pending")));
+    ForegroundService.stop();
+    ForegroundService service = buildService().create().get();
+    service.onStartCommand(null, 0, 1);
+    assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+    assertNull(org.robolectric.Shadows.shadowOf(service).getLastForegroundNotification());
+    createChannel();
+    service.onStartCommand(context.starts.get(0), 0, 2);
+    idleMain();
+    assertEquals(138, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+    assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void onStartCommand_oldAmbiguousDelivery_preservesNewForegroundRun() throws Exception {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    context.startFailure = new IllegalStateException("old reply unknown");
+    assertThrows(
+        IllegalStateException.class,
+        () -> ForegroundService.start(139, buildNotification(), buildNotificationBundle("old")));
+    ForegroundService.stop();
+    context.startFailure = null;
+    Intent fresh = buildStartIntent("new", 140, "new title");
+    ForegroundService.start(
+        140, fresh.getParcelableExtra("notification"), fresh.getBundleExtra("notificationBundle"));
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      ForegroundService service = buildService().create().get();
+      service.onStartCommand(context.starts.get(1), 0, 1);
+      service.onStartCommand(context.starts.get(0), 0, 2);
+      idleMain();
+      assertCurrentState("new", 140, "new title");
+      assertEquals(1, capture.events.size());
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+      capture.events.get(0).setCompletionResult();
+      assertNull(ForegroundService.mCurrentNotificationId);
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void onStartCommand_oldAmbiguousDeliveryAfterNewRunnerEnds_fulfillsThenStopsOnlyOldWork() {
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    context.startFailure = new IllegalStateException("old reply unknown");
+    assertThrows(
+        IllegalStateException.class,
+        () -> ForegroundService.start(141, buildNotification(), buildNotificationBundle("old")));
+    ForegroundService.stop();
+    context.startFailure = null;
+    ForegroundService.start(142, buildNotification(), buildNotificationBundle("new"));
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      ForegroundService service = buildService().create().get();
+      service.onStartCommand(context.starts.get(1), 0, 1);
+      capture.events.get(0).setCompletionResult();
+      service.onStartCommand(context.starts.get(0), 0, 2);
+      idleMain();
+      assertEquals(
+          141, org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+      assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      assertTrue(org.robolectric.Shadows.shadowOf(service).isForegroundStopped());
+      assertNull(ForegroundService.mCurrentNotificationId);
+      assertEquals(1, capture.events.size());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void start_lateDispatchReply_doesNotCancelStopAfterRealDelivery() throws Exception {
+    CountDownLatch dispatchEntered = new CountDownLatch(1);
+    CountDownLatch releaseReply = new CountDownLatch(1);
+    RecordingServiceContext context =
+        new RecordingServiceContext(RuntimeEnvironment.getApplication()) {
+          @Override
+          public ComponentName startForegroundService(Intent intent) {
+            ComponentName result = super.startForegroundService(intent);
+            dispatchEntered.countDown();
+            try {
+              assertTrue(releaseReply.await(5, TimeUnit.SECONDS));
+            } catch (InterruptedException e) {
+              throw new AssertionError(e);
+            }
+            return result;
+          }
+        };
+    ContextHolder.setApplicationContext(context);
+    createChannel();
+    ExecutorService worker = Executors.newSingleThreadExecutor();
+    Notification notification = buildNotification();
+    Bundle bundle = buildNotificationBundle("pending");
+    try {
+      Future<?> start = worker.submit(() -> ForegroundService.start(143, notification, bundle));
+      assertTrue(dispatchEntered.await(5, TimeUnit.SECONDS));
+      ForegroundService service = buildService().create().get();
+      service.onStartCommand(context.starts.get(0), 0, 1);
+      ForegroundService.stop();
+      releaseReply.countDown();
+      start.get(5, TimeUnit.SECONDS);
+      idleMain();
+      assertTrue(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      assertNull(ForegroundService.mCurrentNotificationId);
+    } finally {
+      releaseReply.countDown();
+      worker.shutdownNow();
+    }
+  }
+
+  @Test
+  @Config(
+      sdk = {33, 34},
+      shadows = DenyOldNotificationShadowService.class)
+  public void onStartCommand_supersededStartDenial_remainsARealStartFailure() throws Exception {
+    if (Build.VERSION.SDK_INT >= 34) {
+      declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    }
+    RecordingServiceContext context = useRecordingContext();
+    createChannel();
+    Intent old = buildStartIntent("old", 144, "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    context.startFailure = new IllegalStateException("old reply unknown");
+    assertThrows(
+        IllegalStateException.class,
+        () ->
+            ForegroundService.start(
+                144,
+                old.getParcelableExtra("notification"),
+                old.getBundleExtra("notificationBundle")));
+    ForegroundService.stop();
+    context.startFailure = null;
+    ForegroundService.start(145, buildNotification(), buildNotificationBundle("new"));
+    FgsRunnerCapture capture = new FgsRunnerCapture();
+    EventBus.register(capture);
+    try {
+      ForegroundService service = buildService().create().get();
+      service.onStartCommand(context.starts.get(1), 0, 1);
+      capture.events.get(0).setCompletionResult();
+      assertThrows(
+          ForegroundServiceStartNotAllowedException.class,
+          () -> service.onStartCommand(context.starts.get(0), 0, 2));
+      idleMain();
+      assertFalse(org.robolectric.Shadows.shadowOf(service).isStoppedBySelf());
+      assertNull(ForegroundService.mCurrentNotificationId);
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Implements(Service.class)
+  public static class DenyOldNotificationShadowService extends ShadowService {
+    @Implementation
+    protected void startForeground(int id, Notification notification) {
+      if ("B".equals(notification.extras.getString(Notification.EXTRA_TITLE))) {
+        throw new ForegroundServiceStartNotAllowedException("real old START denied");
+      }
+      super.startForeground(id, notification);
+    }
+  }
+
+  @Implements(Service.class)
+  public static class RefuseStopSelfShadowService extends ShadowService {
+    @Implementation
+    protected boolean stopSelfResult(int startId) {
+      return false;
+    }
+  }
+
+  @Implements(Service.class)
+  public static class FailStopForegroundShadowService extends ShadowService {
+    @Implementation
+    protected void stopForeground(int flags) {
+      throw new ForegroundServiceStartNotAllowedException("not from startForeground");
+    }
+  }
+
+  private static void assertCurrentState(String id, int hash, String title) throws Exception {
+    assertEquals(id, ForegroundService.mCurrentNotificationId);
+    assertEquals(hash, getPrivateStatic("mCurrentHashCode"));
+    assertEquals(
+        title, ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+    assertEquals(
+        title,
+        ((Notification) getPrivateStatic("mCurrentNotification"))
+            .extras.getString(Notification.EXTRA_TITLE));
+  }
+
+  private static void idleMain() {
+    org.robolectric.Shadows.shadowOf(Looper.getMainLooper()).idle();
+  }
+
+  private RecordingServiceContext useRecordingContext() {
+    RecordingServiceContext context =
+        new RecordingServiceContext(RuntimeEnvironment.getApplication());
+    ContextHolder.setApplicationContext(context);
+    return context;
+  }
+
+  private ServiceController<ForegroundService> buildService() {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    controllers.add(controller);
+    return controller;
+  }
+
+  private static class RecordingServiceContext extends ContextWrapper {
+    final List<Intent> starts = new ArrayList<>();
+    int stops;
+    RuntimeException startFailure;
+
+    RecordingServiceContext(Context base) {
+      super(base);
+    }
+
+    @Override
+    public ComponentName startService(Intent intent) {
+      starts.add(new Intent(intent));
+      return intent.getComponent();
+    }
+
+    @Override
+    public ComponentName startForegroundService(Intent intent) {
+      starts.add(new Intent(intent));
+      if (startFailure != null) {
+        throw startFailure;
+      }
+      return intent.getComponent();
+    }
+
+    @Override
+    public boolean stopService(Intent intent) {
+      stops++;
+      return true;
+    }
+  }
+
+  @Implements(Service.class)
+  public static class DefensiveFailureShadowService extends ShadowService {
+    static RuntimeException failure;
+    static int attempts;
+    static int lastId;
+    static int lastType;
+
+    @Implementation
+    protected void startForeground(int id, Notification notification) {
+      attempts++;
+      lastId = id;
+      lastType = ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE;
+      throw failure;
+    }
+
+    @Implementation
+    protected void startForeground(int id, Notification notification, int foregroundServiceType) {
+      attempts++;
+      lastId = id;
+      lastType = foregroundServiceType;
+      throw failure;
+    }
+  }
+
+  @Implements(NotificationManager.class)
+  public static class SecurityDefensiveChannelShadowManager extends ShadowNotificationManager {
+    @Implementation
+    protected void createNotificationChannel(NotificationChannel channel) {
+      if ("notifee_fg_default".equals(channel.getId())) {
+        throw new SecurityException("defensive channel failure");
+      }
+      super.createNotificationChannel(channel);
+    }
+  }
+
+  @Implements(Service.class)
+  public static class SecurityStopForegroundShadowService extends ShadowService {
+    @Implementation
+    protected void stopForeground(int flags) {
+      throw new SecurityException("defensive teardown failure");
+    }
   }
 
   /**
@@ -68,8 +4314,7 @@ public class ForegroundServiceTest {
    */
   @Test
   public void onStartCommand_stopIntentBeforeStart_doesNotCrash() {
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     Intent stopIntent = new Intent();
@@ -86,8 +4331,7 @@ public class ForegroundServiceTest {
    */
   @Test
   public void onStartCommand_nullIntent_doesNotCrash() {
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     // Null intent simulates service recreation after process kill
@@ -103,8 +4347,7 @@ public class ForegroundServiceTest {
    */
   @Test
   public void onStartCommand_stopIntent_resetsPublicStaticState() {
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     // Set some stale state to simulate a prior invocation
@@ -132,8 +4375,7 @@ public class ForegroundServiceTest {
   public void onStartCommand_stopIntentApi34NoManifestType_throwsRuntimeException() {
     // Robolectric's default shadow PackageManager returns FOREGROUND_SERVICE_TYPE_NONE (0)
     // for services without an explicit foregroundServiceType in the test manifest.
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     Intent stopIntent = new Intent();
@@ -148,8 +4390,7 @@ public class ForegroundServiceTest {
   @Test
   @Config(sdk = 34)
   public void onStartCommand_stopIntentApi34NoManifestType_messageContainsDocUrl() {
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     Intent stopIntent = new Intent();
@@ -171,8 +4412,7 @@ public class ForegroundServiceTest {
   @Test
   @Config(sdk = 33)
   public void onStartCommand_stopIntentApiBelow34_defensivePathRunsNormally() {
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     Intent stopIntent = new Intent();
@@ -192,8 +4432,7 @@ public class ForegroundServiceTest {
   @Test
   @Config(sdk = 33)
   public void onStartCommand_stopIntentAfterSuccessfulStart_skipsDefensivePath() {
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     Intent stopIntent = new Intent();
@@ -214,8 +4453,7 @@ public class ForegroundServiceTest {
     declareForegroundServiceTypes(
         ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
             | ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     int result = service.onStartCommand(buildStopIntent(), 0, 1);
@@ -231,8 +4469,7 @@ public class ForegroundServiceTest {
       throws Exception {
     declareForegroundServiceTypes(
         ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA | ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     int result = service.onStartCommand(buildStopIntent(), 0, 1);
@@ -250,8 +4487,7 @@ public class ForegroundServiceTest {
     declareForegroundServiceTypes(
         ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE
             | ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE);
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     int result = service.onStartCommand(buildStopIntent(), 0, 1);
@@ -266,8 +4502,7 @@ public class ForegroundServiceTest {
   public void onStartCommand_stopIntentApi34MicrophoneOnly_doesNotUseUndeclaredShortService()
       throws Exception {
     declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE);
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     int result = service.onStartCommand(buildStopIntent(), 0, 1);
@@ -281,8 +4516,7 @@ public class ForegroundServiceTest {
   @Config(sdk = 34, shadows = ThrowingStartForegroundShadowService.class)
   public void onStartCommand_stopIntentApi34SecurityException_doesNotCrash() throws Exception {
     declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE);
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     int result = service.onStartCommand(buildStopIntent(), 0, 1);
@@ -308,8 +4542,7 @@ public class ForegroundServiceTest {
   public void onStartCommand_startIntent_setsCurrentNotificationIdAndCallsStartForeground()
       throws Exception {
     createChannel();
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     String id = "fgs-start-happy";
@@ -814,12 +5047,12 @@ public class ForegroundServiceTest {
   @Test
   @Config(sdk = 34)
   public void onTimeout_api34_emitsFgTimeoutEventWithStartIdAndSentinelFgsType() throws Exception {
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     String id = "fgs-timeout-api34";
-    seedActiveForegroundServiceState(id);
+    seedActiveForegroundServiceState(
+        service, id, 42, ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
 
     FgsEventCapture capture = new FgsEventCapture();
     EventBus.register(capture);
@@ -857,12 +5090,11 @@ public class ForegroundServiceTest {
   @Test
   @Config(sdk = 35)
   public void onTimeout_api35_emitsFgTimeoutEventWithExplicitFgsType() throws Exception {
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     String id = "fgs-timeout-api35";
-    seedActiveForegroundServiceState(id);
+    seedActiveForegroundServiceState(service, id, 7, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
 
     FgsEventCapture capture = new FgsEventCapture();
     EventBus.register(capture);
@@ -894,8 +5126,7 @@ public class ForegroundServiceTest {
   @Test
   @Config(sdk = 34)
   public void onTimeout_withNoActiveState_doesNotCrashOrEmitEvent() {
-    ServiceController<ForegroundService> controller =
-        Robolectric.buildService(ForegroundService.class);
+    ServiceController<ForegroundService> controller = buildService();
     ForegroundService service = controller.create().get();
 
     FgsEventCapture capture = new FgsEventCapture();
@@ -1011,19 +5242,12 @@ public class ForegroundServiceTest {
     return (int) method.invoke(shadowService);
   }
 
-  /**
-   * Populates the service's private static tracking fields directly, simulating the post-START
-   * state that onTimeout expects to observe. Using reflection here (rather than running a full
-   * START first) keeps the onTimeout tests SDK-independent — the START path would trip the API 34+
-   * manifest-type check, but onTimeout itself is sdk-agnostic because its body only uses pre-API-34
-   * primitives.
-   */
-  private static void seedActiveForegroundServiceState(String id) throws Exception {
-    ForegroundService.mCurrentNotificationId = id;
-    ForegroundService.mCurrentForegroundServiceType = 1;
-    setPrivateStatic("mCurrentNotificationBundle", buildNotificationBundle(id));
-    setPrivateStatic("mCurrentNotification", buildNotification());
-    setPrivateStatic("mCurrentHashCode", id.hashCode());
+  // Exercise timeout against an actual successful START, including its lifecycle authority.
+  private static void seedActiveForegroundServiceState(
+      ForegroundService service, String id, int startId, int type) throws Exception {
+    createChannel();
+    declareForegroundServiceTypes(type);
+    service.onStartCommand(buildStartIntent(id, id.hashCode(), "FGS test", type), 0, startId);
   }
 
   private static void setPrivateStatic(String name, Object value) throws Exception {