fix(mobile): recover from a failed share discard and discard a superseded sheet's share

A rejected discardShare left the share latched as discarded forever, so it
sat in the inbox unreachable. Clear the latch and re-run presentation.

A newer share arriving while an earlier share's sheet was still open reset
the tracked share, so closing that sheet never discarded it and it came
back later. Keep tracking the open sheet's share until it closes.

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

Author: juliusmarminge

apps/mobile/src/Stack.tsx

@@ -10,7 +10,7 @@ import {
   createNativeStackScreen,
   type NativeStackNavigationOptions,
 } from "@react-navigation/native-stack";
-import { useEffect, useRef } from "react";
+import { useEffect, useRef, useState } from "react";
 import { Platform, Pressable, ScrollView, StyleSheet, View } from "react-native";
 import { useResolveClassNames } from "uniwind";
 
@@ -404,6 +404,7 @@ function RootStackLayout(props: {
   const navigation = useNavigation();
   const { pendingShare, discardShare } = useIncomingShare();
   const sharePresentationRef = useRef(EMPTY_INCOMING_SHARE_PRESENTATION_STATE);
+  const [sharePresentationRetry, setSharePresentationRetry] = useState(0);
   useAgentNotificationNavigation();
   // Presents the T3 Connect onboarding sheet after an in-session sign-in.
   useConnectOnboardingNavigation();
@@ -418,7 +419,16 @@ function RootStackLayout(props: {
     });
     sharePresentationRef.current = transition.state;
     if (transition.shareIdToDiscard) {
-      void discardShare(transition.shareIdToDiscard);
+      const shareId = transition.shareIdToDiscard;
+      discardShare(shareId).catch((error: unknown) => {
+        console.warn("[incoming-share] could not discard dismissed share", error);
+        // Drop the latch so the share is presented again instead of sitting
+        // in the inbox unreachable until the next foreground refresh.
+        if (sharePresentationRef.current.discardedShareId === shareId) {
+          sharePresentationRef.current = EMPTY_INCOMING_SHARE_PRESENTATION_STATE;
+          setSharePresentationRetry((attempt) => attempt + 1);
+        }
+      });
     }
     if (!transition.shareIdToPresent) {
       return;
@@ -427,7 +437,7 @@ function RootStackLayout(props: {
       screen: "NewTask",
       params: { incomingShareId: transition.shareIdToPresent },
     });
-  }, [discardShare, navigation, pendingShare, props.state]);
+  }, [discardShare, navigation, pendingShare, props.state, sharePresentationRetry]);
   // Full pathname (sheets included) for keyboard-command scoping; the
   // workspace layout only reacts to the underlying non-overlay route.
   const path = getPathFromState(props.state, navigationPathConfig);

apps/mobile/src/features/sharing/incoming-share-presentation.test.ts

@@ -84,20 +84,35 @@ describe("transitionIncomingSharePresentation", () => {
     expect(present("share-1", empty.state).presentedShareId).toBe("share-1");
   });
 
-  it("presents the next queued share after the previous one is consumed", () => {
+  it("keeps tracking the open sheet's share when a newer share arrives, then discards it on close", () => {
     const state = seen("share-1", present("share-1"));
-    const consumedWhileOpen = transitionIncomingSharePresentation(state, {
+    const newerWhileOpen = transitionIncomingSharePresentation(state, {
       ...sheetWith("share-1"),
       pendingShareId: "share-2",
     });
-    expect(consumedWhileOpen.shareIdToPresent).toBeNull();
-    expect(consumedWhileOpen.shareIdToDiscard).toBeNull();
+    expect(newerWhileOpen).toEqual({ state, shareIdToPresent: null, shareIdToDiscard: null });
 
-    const next = transitionIncomingSharePresentation(consumedWhileOpen.state, {
+    const next = transitionIncomingSharePresentation(newerWhileOpen.state, {
       ...closed,
       pendingShareId: "share-2",
     });
+    expect(next.shareIdToDiscard).toBe("share-1");
     expect(next.shareIdToPresent).toBe("share-2");
+    expect(next.state).toEqual({
+      presentedShareId: "share-2",
+      sheetSeen: false,
+      discardedShareId: "share-1",
+    });
+  });
+
+  it("presents a newer share directly when the earlier request never landed", () => {
+    const requested = present("share-1");
+    const next = transitionIncomingSharePresentation(requested, {
+      ...closed,
+      pendingShareId: "share-2",
+    });
+    expect(next.shareIdToPresent).toBe("share-2");
+    expect(next.shareIdToDiscard).toBeNull();
   });
 
   it("holds while another route is pushed above the seen sheet", () => {

apps/mobile/src/features/sharing/incoming-share-presentation.ts

@@ -63,8 +63,11 @@ export function incomingShareIdOfSheetRoute(
  * user has walked away from it. A share counts as dismissed only after the
  * sheet was seen carrying it and then left the stack; until then a missing
  * sheet means the navigation never landed (container not ready, another route
- * won the race) and the request is simply repeated. Dismissal discards the share so that sharing
- * the same content again yields a fresh handoff instead of a silent no-op.
+ * won the race) and the request is simply repeated. Dismissal discards the
+ * share so that sharing the same content again yields a fresh handoff instead
+ * of a silent no-op. The tracked share survives a newer pending one arriving
+ * while its sheet is still up, so closing that sheet discards it rather than
+ * letting it resurface after the newer share is handled.
  */
 export function transitionIncomingSharePresentation(
   state: IncomingSharePresentationState,
@@ -90,36 +93,31 @@ export function transitionIncomingSharePresentation(
     return hold;
   }
 
-  if (state.presentedShareId === pendingShareId) {
-    if (input.isSheetPresented) {
-      if (input.sheetShareId === pendingShareId && !state.sheetSeen) {
-        return { ...hold, state: { ...state, sheetSeen: true } };
-      }
-      return hold;
+  const tracked = state.presentedShareId;
+  if (input.isSheetPresented) {
+    if (tracked === null) {
+      // A sheet nobody here asked for (a manual new task). Wait for it to close.
+      return { ...hold, state: EMPTY_INCOMING_SHARE_PRESENTATION_STATE };
     }
-    if (state.sheetSeen) {
-      return {
-        state: { presentedShareId: null, sheetSeen: false, discardedShareId: pendingShareId },
-        shareIdToPresent: null,
-        shareIdToDiscard: pendingShareId,
-      };
+    if (input.sheetShareId === tracked && !state.sheetSeen) {
+      return { ...hold, state: { ...state, sheetSeen: true } };
     }
-    return { ...hold, shareIdToPresent: pendingShareId };
-  }
-
-  if (input.isSheetPresented) {
-    // Someone else owns the sheet (a manual new task, or the sheet of a share
-    // that was just consumed). Wait for it to close.
-    return {
-      state: { presentedShareId: null, sheetSeen: false, discardedShareId: null },
-      shareIdToPresent: null,
-      shareIdToDiscard: null,
-    };
+    return hold;
   }
 
+  // The sheet is gone. A tracked share that was seen is dismissed; anything
+  // else is a request that never landed and is repeated. A consumed share can
+  // also land here (its sheet closed onto the thread); discarding it again is
+  // a no-op since the inbox no longer has it.
+  const shareIdToDiscard = tracked !== null && state.sheetSeen ? tracked : null;
+  const shareIdToPresent = shareIdToDiscard === pendingShareId ? null : pendingShareId;
   return {
-    state: { presentedShareId: pendingShareId, sheetSeen: false, discardedShareId: null },
-    shareIdToPresent: pendingShareId,
-    shareIdToDiscard: null,
+    state: {
+      presentedShareId: shareIdToPresent,
+      sheetSeen: false,
+      discardedShareId: shareIdToDiscard,
+    },
+    shareIdToPresent,
+    shareIdToDiscard,
   };
 }