@@ -1100,6 +1100,35 @@ describe("WebRTC-only iOS devices", () => {
     expect(closes.map(fixture.bodyOf)).toEqual([{ sessionId: offer.sessionId }]);
   });
 
+  it("reconnects a WebRTC feed that stops producing frames", async () => {
+    const fixture = webRtcFixture({ webCodecs: true });
+    fixture.client.start();
+    await fixture.settle();
+    const peer = fixture.peers[0]!;
+    peer.ontrack?.({ streams: [{}], track: {} });
+    fixture.frameCallbacks.shift()?.();
+    expect(fixture.events.onStatus).toHaveBeenLastCalledWith("streaming", undefined);
+    // Frames keep coming: nothing happens.
+    await vi.advanceTimersByTimeAsync(10_000);
+    fixture.frameCallbacks.shift()?.();
+    await vi.advanceTimersByTimeAsync(10_000);
+    expect(fixture.peers).toHaveLength(1);
+    expect(peer.closed).toBe(false);
+    // Then none for the first-frame deadline (checked every 5 s): the feed
+    // reconnects through the usual retry path.
+    await vi.advanceTimersByTimeAsync(15_000);
+    expect(peer.closed).toBe(true);
+    expect(fixture.events.onStatus).toHaveBeenLastCalledWith(
+      "connecting",
+      "Device stream stalled. Reconnecting…",
+    );
+    await vi.advanceTimersByTimeAsync(1_000);
+    await fixture.settle();
+    expect(fixture.peers).toHaveLength(2);
+    expect(fixture.peers[1]!.remoteDescription).toEqual({ type: "answer", sdp: "v=0 answer" });
+    fixture.client.stop();
+  });
+
   it("retries a WebRTC offer while another viewer is negotiating", async () => {
     const fixture = webRtcFixture({ webCodecs: true, offerStatuses: [409] });
     fixture.client.start();
 
@@ -126,6 +126,11 @@ export type DeviceHardwareButton = "home" | "back" | "recents" | "power" | "appS
 
 const RETRY_DELAY_MS = 1_000;
 const FIRST_FRAME_TIMEOUT_MS = 15_000;
+// A WebRTC feed that shows no frame for this long is reconnected; checked
+// every WEBRTC_STALL_CHECK_MS, so a transient `disconnected` peer that
+// recovers is left alone.
+const WEBRTC_STALL_TIMEOUT_MS = FIRST_FRAME_TIMEOUT_MS;
+const WEBRTC_STALL_CHECK_MS = 5_000;
 const TRANSPORT_PROBE_TIMEOUT_MS = 5_000;
 // Offers carry every candidate: serve-sim does not accept trickled ICE.
 const ICE_GATHERING_TIMEOUT_MS = 2_000;
@@ -884,16 +889,37 @@ export function createDeviceStreamClient(
       generation === lifecycle &&
       videoGeneration === feedGeneration &&
       peer === current;
+    // After the first frame nothing else bounds a feed that stops: the peer
+    // can sit `disconnected` with the last frame on the canvas. A long gap
+    // between frames reconnects through the same path as a failed connection.
+    let checksWithoutFrame = 0;
+    let watchdog: ReturnType<typeof setInterval> | null = null;
+    const clearWatchdog = () => {
+      if (watchdog !== null) clearInterval(watchdog);
+      watchdog = null;
+    };
     const retry = (detail: string) => {
+      clearWatchdog();
       if (!isCurrent()) return;
       closePeer();
       connecting(detail);
       scheduleRetry("video", () => void readIosWebRtc(settings));
     };
     const presentFrame = () => {
-      if (!isCurrent()) return;
+      if (!isCurrent()) {
+        clearWatchdog();
+        return;
+      }
       if (video.videoWidth > 0 && video.videoHeight > 0) {
         paint(video, video.videoWidth, video.videoHeight);
+        checksWithoutFrame = 0;
+        watchdog ??= setInterval(() => {
+          if (!isCurrent()) return clearWatchdog();
+          checksWithoutFrame++;
+          if (checksWithoutFrame * WEBRTC_STALL_CHECK_MS >= WEBRTC_STALL_TIMEOUT_MS) {
+            retry("Device stream stalled. Reconnecting…");
+          }
+        }, WEBRTC_STALL_CHECK_MS);
       }
       video.requestVideoFrameCallback(presentFrame);
     };