@agent-native/toolkit 0.225.2-nightly-20261106152255 → 0.226.0

package/src/app/settings/useBuilderStatus.ts

@@ -856,6 +856,10 @@ export function useBuilderConnectFlow(
   const [builderEnabled, setBuilderEnabled] = useState(false);
   const [orgName, setOrgName] = useState<string | null>(null);
   const [connecting, setConnecting] = useState(false);
+  const [reconciling, setReconciling] = useState<string | null>(null);
+  const pollEpochRef = useRef(0);
+  const [pollEpoch, setPollEpoch] = useState(0);
+  const pendingPollRef = useRef<number | null>(null);
   const errorRevisionRef = useRef(0);
   const [errorState, setErrorState] = useState<{
     kind: BuilderConnectErrorKind;
@@ -888,6 +892,11 @@ export function useBuilderConnectFlow(
   const provisionAccountAttemptRef = useRef(false);
   const connectAttemptIdRef = useRef<string | null>(null);
   const cancelledConnectAttemptIdRef = useRef<string | null>(null);
+  const blockedLaunchRef = useRef<{
+    from: string | null;
+    to: string;
+    revision: number;
+  } | null>(null);
   const activePopupRef = useRef<Window | null>(null);
   const confirmConnectSuccessRef = useRef<(attemptId: string) => Promise<void>>(
     async () => {},
@@ -927,13 +936,14 @@ export function useBuilderConnectFlow(
     source: trackingSource,
     flow: trackingFlow,
   });
+  // A new generation must not wait for a transport that ignores abort.
   const getConnectPollInterval = useCallback(
     () =>
       Math.min(
         MAX_POLL_INTERVAL_MS,
         POLL_INTERVAL_MS * 2 ** statusPollFailuresRef.current,
       ),
-    [],
+    [pollEpoch],
   );
 
   useEffect(() => {
@@ -1062,6 +1072,7 @@ export function useBuilderConnectFlow(
       setBuilderEnabled(false);
       setOrgName(null);
       setConnecting(false);
+      setReconciling(null);
       setError(null);
       markStatusAvailable();
       setAccountExists(false);
@@ -1079,15 +1090,31 @@ export function useBuilderConnectFlow(
     let refreshGeneration = 0;
     const refresh = async () => {
       const errorRevisionAtStart = errorRevisionRef.current;
+      const attemptIdAtStart = connectAttemptIdRef.current;
       const generation = ++refreshGeneration;
       const isCurrentRefresh = () => generation === refreshGeneration;
       const s = await fetchStatus();
-      if (cancelled || !mountedRef.current || !isCurrentRefresh()) return;
-      if (errorRevisionRef.current !== errorRevisionAtStart) return;
+      const blocked = blockedLaunchRef.current;
+      const sameBlockedLaunch =
+        blocked?.from === attemptIdAtStart &&
+        blocked.to === connectAttemptIdRef.current &&
+        blocked.revision === errorRevisionRef.current;
+      if (
+        cancelled ||
+        !mountedRef.current ||
+        !isCurrentRefresh() ||
+        (!sameBlockedLaunch &&
+          (connectAttemptIdRef.current !== attemptIdAtStart ||
+            errorRevisionRef.current !== errorRevisionAtStart))
+      )
+        return;
       setHasFetchedStatus(true);
       setStatusReadSettledCount((count) => count + 1);
       if (!s) {
-        markStatusUnavailable();
+        if (sameBlockedLaunch) {
+          statusUnavailableRef.current = true;
+          setStatusUnavailableRevision(errorRevisionAtStart);
+        } else markStatusUnavailable();
         return;
       }
       if (statusUnavailableRef.current) {
@@ -1102,7 +1129,11 @@ export function useBuilderConnectFlow(
       setCanDisconnect(!!s.canDisconnect);
       setAgentNativeProvisioningEnabled(!!s.agentNativeProvisioningEnabled);
       setAgentNativeProvisioningToken(s.agentNativeProvisioningToken ?? null);
-      setAccountExists(s.connectError?.code === "account_exists");
+      if (
+        !connectAttemptIdRef.current ||
+        cancelledConnectAttemptIdRef.current !== connectAttemptIdRef.current
+      )
+        setAccountExists(s.connectError?.code === "account_exists");
       setBuilderEnabled(!!s.builderEnabled);
       const nextConnectUrl = s.connectUrl ?? null;
       setStatusConnectUrl(nextConnectUrl);
@@ -1116,6 +1147,7 @@ export function useBuilderConnectFlow(
       if (connectComplete) {
         connectStartedAtRef.current = null;
         setConnecting(false);
+        setReconciling(null);
       }
       if (connectComplete && !notifiedConnectedRef.current) {
         notifiedConnectedRef.current = true;
@@ -1131,7 +1163,12 @@ export function useBuilderConnectFlow(
       }
       if (errorRevisionRef.current === errorRevisionAtStart) {
         const activeConnectStartedAt = connectStartedAtRef.current;
-        if (isCurrentConnectError(s.connectError, activeConnectStartedAt)) {
+        if (
+          (!connectAttemptIdRef.current ||
+            cancelledConnectAttemptIdRef.current !==
+              connectAttemptIdRef.current) &&
+          isCurrentConnectError(s.connectError, activeConnectStartedAt)
+        ) {
           setError(s.connectError.message);
         } else if (!activeConnectStartedAt && s.authError?.message) {
           setError(s.authError.message);
@@ -1180,11 +1217,33 @@ export function useBuilderConnectFlow(
     setError,
   ]);
 
+  useEffect(() => {
+    if (!reconciling) return;
+    const timer = setTimeout(
+      () => {
+        if (connectAttemptIdRef.current !== reconciling) return;
+        callbackSuccessCancelRef.current?.cancel();
+        callbackSuccessRequestControllerRef.current?.controller.abort();
+        connectStartedAtRef.current = null;
+        setReconciling(null);
+        if (pendingPollRef.current === pollEpochRef.current)
+          markStatusUnavailable();
+      },
+      POPUP_CLOSED_CONFIRMATION_GRACE_MS +
+        CALLBACK_SUCCESS_STATUS_RETRIES *
+          (STATUS_FETCH_ABORT_MS + CALLBACK_SUCCESS_STATUS_RETRY_MS),
+    );
+    return () => clearTimeout(timer);
+  }, [reconciling, markStatusUnavailable]);
+
   const retry = useCallback(() => retryStatusRef.current(), []);
   const cancel = useCallback(() => {
     const started = connectStartedAtRef.current;
     if (started === null) return;
     const attemptId = connectAttemptIdRef.current;
+    setConnecting(false);
+    setReconciling(attemptId);
+    setPollEpoch(++pollEpochRef.current);
     provisionAccountAttemptRef.current = false;
     cancelledConnectAttemptIdRef.current = attemptId;
     popupClosedAtRef.current ??= Date.now();
@@ -1192,6 +1251,7 @@ export function useBuilderConnectFlow(
       callbackSuccessCancelRef.current.cancel();
     if (callbackSuccessRequestControllerRef.current?.started === started)
       callbackSuccessRequestControllerRef.current.controller.abort();
+    callbackSuccessStartedAtRef.current = null;
     try {
       activePopupRef.current?.close();
     } catch {
@@ -1218,7 +1278,9 @@ export function useBuilderConnectFlow(
     (startOptions?: BuilderConnectStartOptions) => {
       if (!enabled) return;
       const started = Date.now();
+      const previousAttemptId = connectAttemptIdRef.current;
       const connectAttemptId = createBuilderConnectAttemptId();
+      blockedLaunchRef.current = null;
       const clickTrackingSource =
         startOptions?.trackingSource ?? trackingSource;
       const clickTrackingFlow = startOptions?.trackingFlow ?? trackingFlow;
@@ -1244,6 +1306,8 @@ export function useBuilderConnectFlow(
       callbackSuccessRequestControllerRef.current?.controller.abort();
       connectStartedAtRef.current = started;
       connectAttemptIdRef.current = connectAttemptId;
+      setReconciling(null);
+      setPollEpoch(++pollEpochRef.current);
       provisionAccountAttemptRef.current = provisionAccountForStart;
       cancelledConnectAttemptIdRef.current = null;
       statusPollFailuresRef.current = 0;
@@ -1551,18 +1615,21 @@ export function useBuilderConnectFlow(
               "Couldn't open Builder. Allow popups and try again.",
               "launch",
             );
+            blockedLaunchRef.current = {
+              from: previousAttemptId,
+              to: connectAttemptId,
+              revision: errorRevisionRef.current,
+            };
             return;
           }
 
+          const isCurrentHostAttempt = () =>
+            mountedRef.current &&
+            connectAttemptIdRef.current === connectAttemptId &&
+            cancelledConnectAttemptIdRef.current !== connectAttemptId;
           void (async () => {
             const s = await fetchStatus(undefined, connectAttemptId);
-            if (
-              !mountedRef.current ||
-              connectAttemptIdRef.current !== connectAttemptId ||
-              cancelledConnectAttemptIdRef.current === connectAttemptId
-            ) {
-              return;
-            }
+            if (!isCurrentHostAttempt()) return;
             if (s) markStatusAvailable();
             else markStatusUnavailable();
             if (s) {
@@ -1599,7 +1666,7 @@ export function useBuilderConnectFlow(
             });
             const openedByHost =
               await openBuilderConnectViaMcpHost(trackedHostUrl);
-            if (!mountedRef.current || openedByHost) return;
+            if (!isCurrentHostAttempt() || openedByHost) return;
             connectStartedAtRef.current = null;
             setConnecting(false);
             if (!s) restoreExistingAccount();
@@ -1738,12 +1805,18 @@ export function useBuilderConnectFlow(
   usePollLoop(
     async (signal) => {
       const started = connectStartedAtRef.current;
-      if (started == null) return;
-      const s = await fetchStatus(
-        signal,
-        connectAttemptIdRef.current ?? undefined,
-      );
-      if (!mountedRef.current || connectStartedAtRef.current !== started) {
+      const attemptId = connectAttemptIdRef.current;
+      const epoch = pollEpochRef.current;
+      if (started == null || !attemptId) return;
+      pendingPollRef.current = epoch;
+      const s = await fetchStatus(signal, attemptId);
+      if (pendingPollRef.current === epoch) pendingPollRef.current = null;
+      if (
+        !mountedRef.current ||
+        connectStartedAtRef.current !== started ||
+        connectAttemptIdRef.current !== attemptId ||
+        pollEpochRef.current !== epoch
+      ) {
         return;
       }
       if (s) {
@@ -1767,7 +1840,8 @@ export function useBuilderConnectFlow(
         setCanDisconnect(!!s.canDisconnect);
         setAgentNativeProvisioningEnabled(!!s.agentNativeProvisioningEnabled);
         setAgentNativeProvisioningToken(s.agentNativeProvisioningToken ?? null);
-        setAccountExists(s.connectError?.code === "account_exists");
+        if (cancelledConnectAttemptIdRef.current !== attemptId)
+          setAccountExists(s.connectError?.code === "account_exists");
         setBuilderEnabled(!!s.builderEnabled);
         const nextConnectUrl = s.connectUrl ?? null;
         setStatusConnectUrl(nextConnectUrl);
@@ -1777,6 +1851,7 @@ export function useBuilderConnectFlow(
       if (s && isBuilderConnectComplete(s, connectTargetRef.current)) {
         setAccountExists(false);
         setConnecting(false);
+        setReconciling(null);
         connectStartedAtRef.current = null;
         notifiedConnectedRef.current = true;
         notifyProvisionedAccount();
@@ -1788,7 +1863,10 @@ export function useBuilderConnectFlow(
           // already flipped; re-arming the flow on a consumer callback failure
           // would reconnect an account that is connected.
         }
-      } else if (isCurrentConnectError(s?.connectError, started)) {
+      } else if (
+        cancelledConnectAttemptIdRef.current !== attemptId &&
+        isCurrentConnectError(s?.connectError, started)
+      ) {
         connectStartedAtRef.current = null;
         setConnecting(false);
         setAccountExists(s.connectError.code === "account_exists");
@@ -1798,6 +1876,7 @@ export function useBuilderConnectFlow(
             : `Couldn't save Builder credentials: ${s.connectError.message}. Try again or contact support.`,
         );
       } else if (
+        cancelledConnectAttemptIdRef.current !== attemptId &&
         (isPopupClosed(activePopupRef.current) ||
           popupClosedAtRef.current !== null) &&
         callbackSuccessInFlightAtRef.current !== started
@@ -1821,7 +1900,10 @@ export function useBuilderConnectFlow(
           });
           if (s) setError(t("agentChat.settingsShell.builder.setupFailed"));
         }
-      } else if (Date.now() - started > POLL_TIMEOUT_MS) {
+      } else if (
+        cancelledConnectAttemptIdRef.current !== attemptId &&
+        Date.now() - started > POLL_TIMEOUT_MS
+      ) {
         connectStartedAtRef.current = null;
         setConnecting(false);
         const { source, flow } = activeTrackingRef.current;
@@ -1844,7 +1926,7 @@ export function useBuilderConnectFlow(
     {
       intervalMs: getConnectPollInterval,
       leading: false,
-      enabled: enabled && connecting,
+      enabled: enabled && (connecting || !!reconciling),
     },
   );
 
@@ -1859,7 +1941,11 @@ export function useBuilderConnectFlow(
       code: string | undefined,
       attemptId: string | undefined,
     ) => {
-      if (!isCurrentConnectAttempt(attemptId)) return;
+      if (
+        !isCurrentConnectAttempt(attemptId) ||
+        cancelledConnectAttemptIdRef.current === attemptId
+      )
+        return;
       connectStartedAtRef.current = null;
       setConnecting(false);
       setAccountExists(code === "account_exists");
@@ -1893,6 +1979,9 @@ export function useBuilderConnectFlow(
         started,
         cancel: cancelConfirmation,
       };
+      const isActiveConfirmation = () =>
+        callbackSuccessCancelRef.current?.cancel === cancelConfirmation;
+      const wasPopupClosed = () => popupClosedAtRef.current !== null;
       try {
         for (let i = 0; i < CALLBACK_SUCCESS_STATUS_RETRIES; i += 1) {
           const controller =
@@ -1910,10 +1999,7 @@ export function useBuilderConnectFlow(
             : null;
           try {
             s = await Promise.race([
-              fetchStatus(
-                controller?.signal,
-                connectAttemptIdRef.current ?? undefined,
-              ),
+              fetchStatus(controller?.signal, attemptId),
               cancelledPromise,
             ]);
           } finally {
@@ -1928,14 +2014,16 @@ export function useBuilderConnectFlow(
           if (
             cancelled ||
             !mountedRef.current ||
-            connectStartedAtRef.current !== started
+            connectStartedAtRef.current !== started ||
+            connectAttemptIdRef.current !== attemptId
           ) {
             return;
           }
           if (s) markStatusAvailable();
           if (
             (s && isBuilderConnectComplete(s, connectTargetRef.current)) ||
-            isCurrentConnectError(s?.connectError, started)
+            (cancelledConnectAttemptIdRef.current !== attemptId &&
+              isCurrentConnectError(s?.connectError, started))
           ) {
             break;
           }
@@ -1948,31 +2036,39 @@ export function useBuilderConnectFlow(
           }
         }
       } finally {
-        if (callbackSuccessCancelRef.current?.started === started) {
+        if (isActiveConfirmation()) {
           callbackSuccessCancelRef.current = null;
-        }
-        if (callbackSuccessRequestControllerRef.current?.started === started) {
-          callbackSuccessRequestControllerRef.current.controller.abort();
-          callbackSuccessRequestControllerRef.current = null;
-        }
-        if (callbackSuccessInFlightAtRef.current === started) {
-          callbackSuccessInFlightAtRef.current = null;
           if (
-            popupClosedAtRef.current !== null &&
-            !(s && isBuilderConnectComplete(s, connectTargetRef.current))
+            callbackSuccessRequestControllerRef.current?.started === started
           ) {
-            popupClosedAtRef.current = Date.now();
+            callbackSuccessRequestControllerRef.current.controller.abort();
+            callbackSuccessRequestControllerRef.current = null;
+          }
+          if (callbackSuccessInFlightAtRef.current === started) {
+            callbackSuccessInFlightAtRef.current = null;
+            if (
+              wasPopupClosed() &&
+              !(s && isBuilderConnectComplete(s, connectTargetRef.current))
+            ) {
+              popupClosedAtRef.current = Date.now();
+            }
           }
         }
       }
-      if (!mountedRef.current || connectStartedAtRef.current !== started) {
+      if (
+        !mountedRef.current ||
+        connectStartedAtRef.current !== started ||
+        connectAttemptIdRef.current !== attemptId
+      ) {
         return;
       }
       if (!s) return;
       if (!isBuilderConnectComplete(s, connectTargetRef.current)) {
-        const connectError = isCurrentConnectError(s?.connectError, started)
-          ? s?.connectError
-          : null;
+        const connectError =
+          cancelledConnectAttemptIdRef.current !== attemptId &&
+          isCurrentConnectError(s.connectError, started)
+            ? s.connectError
+            : null;
         setHasFetchedStatus(true);
         if (s) {
           setStatusResolved(true);
@@ -1990,7 +2086,8 @@ export function useBuilderConnectFlow(
           setAgentNativeProvisioningToken(
             s.agentNativeProvisioningToken ?? null,
           );
-          setAccountExists(s.connectError?.code === "account_exists");
+          if (cancelledConnectAttemptIdRef.current !== attemptId)
+            setAccountExists(s.connectError?.code === "account_exists");
           setBuilderEnabled(!!s.builderEnabled);
           const nextConnectUrl = s.connectUrl ?? null;
           setStatusConnectUrl(nextConnectUrl);
@@ -2027,6 +2124,7 @@ export function useBuilderConnectFlow(
       const org = s.orgName ?? null;
       setOrgName(org);
       setConnecting(false);
+      setReconciling(null);
       connectStartedAtRef.current = null;
       notifyProvisionedAccount();
       notifiedConnectedRef.current = true;

package/src/composer/ComposerContextMenu.spec.tsx

@@ -136,32 +136,91 @@ describe("connected composer menus", () => {
     );
   const open = async () => {
     await openRoot();
-    if (document.querySelector('[role="menuitem"][aria-haspopup="menu"]'))
-      await key(row("Add context"), "ArrowRight");
   };
   async function click(label: string) {
     await act(async () => row(label).click());
   }
+  it("keeps integration failures visible with a working retry outside source choices", async () => {
+    const retry = vi.fn().mockResolvedValue(undefined);
+    await render(
+      [
+        {
+          id: "source",
+          label: "Reference",
+          section: "context",
+          onSelect: vi.fn(),
+        },
+      ],
+      { integrationStatus: { loading: true } },
+    );
+    await openRoot();
+    const menu = menus()[0];
+    expect(menu.querySelector('[aria-busy="true"]')).not.toBeNull();
+    expect(menu.textContent).toContain("Loading...");
+    expect(menu.querySelector('[role="status"]')).toBeNull();
+    await render(
+      [
+        {
+          id: "source",
+          label: "Reference",
+          section: "context",
+          onSelect: vi.fn(),
+        },
+      ],
+      {
+        integrationStatus: { error: "Connection unavailable", onRetry: retry },
+      },
+    );
+    expect(menus()[0].textContent).toContain("Connection unavailable");
+    expect(row("Reference")).toBeDefined();
+    await click("Retry");
+    expect(retry).toHaveBeenCalledOnce();
+    expect(menus()).toHaveLength(1);
+  });
   it("keeps the root menu compact and puts context choices in nested menus", async () => {
-    await render(items, { addAttachment: vi.fn() });
+    await render(
+      [
+        {
+          id: "references",
+          label: "Design references",
+          order: 20,
+          children: items,
+        },
+        { id: "figma", label: "Figma design", order: 10, onSelect: vi.fn() },
+        { id: "zeta", label: "Zeta", order: 30, onSelect: vi.fn() },
+        { id: "alpha", label: "Alpha", order: 30, onSelect: vi.fn() },
+      ],
+      { addAttachment: vi.fn() },
+    );
     await openRoot();
     expect(document.querySelectorAll('[role="searchbox"]')).toHaveLength(0);
-    // Menus are text-only.
-    expect(row("Upload File").querySelector("svg")).toBeNull();
-    expect(row("Add context").getAttribute("aria-haspopup")).toBe("menu");
+    expect(row("Files and images").querySelector("svg")).not.toBeNull();
+    expect(
+      Array.from(menus()[0].querySelectorAll('[role="menuitem"]')).map(
+        (entry) => entry.textContent,
+      ),
+    ).toEqual([
+      "Files and images",
+      "Figma design",
+      "Design references",
+      "Alpha",
+      "Zeta",
+    ]);
+    expect(row("Design references").getAttribute("aria-haspopup")).toBe("menu");
+    expect(menus()[0].textContent).toContain("Add context");
     expect(menus()).toHaveLength(1);
     expect(menus()[0].classList.contains("w-64")).toBe(true);
     expect(menus()[0].style.boxShadow).toBe("none");
     expect(menus()[0].className).toContain("data-[state=open]:fade-in-100");
     expect(menus()[0].className).toContain("data-[state=closed]:fade-out-100");
-    await key(row("Add context"), "ArrowRight");
+    await key(row("Design references"), "ArrowRight");
     expect(row("Documents")).toBeDefined();
     expect(row("Library")).toBeDefined();
     expect(document.querySelectorAll('[role="searchbox"]')).toHaveLength(0);
     expect(menus()).toHaveLength(2);
-    expect(menus()[1].style.boxShadow).toBe("none");
-    expect(menus()[1].className).toContain("data-[state=open]:fade-in-100");
-    expect(menus()[1].className).toContain("data-[state=closed]:fade-out-100");
+    expect(menus()[0].style.boxShadow).toBe("none");
+    expect(menus()[0].className).toContain("data-[state=open]:fade-in-100");
+    expect(menus()[0].className).toContain("data-[state=closed]:fade-out-100");
   });
   it("hides the Add context tooltip while the host storage popover is open", async () => {
     const warning = vi.spyOn(console, "warn").mockImplementation(() => {});
@@ -198,7 +257,7 @@ describe("connected composer menus", () => {
     expect(row("Workspace apps")).toBeDefined();
     await key(row("Workspace apps"), "ArrowRight");
     expect(row("DesignInteractive prototypes")).toBeDefined();
-    expect(menus()).toHaveLength(3);
+    expect(menus()).toHaveLength(2);
     await key(row("DesignInteractive prototypes"), "Enter");
     expect(menus()).toHaveLength(0);
   });
@@ -235,13 +294,13 @@ describe("connected composer menus", () => {
       await openRoot();
       expect(menus()[0].classList.contains("w-64")).toBe(true);
       expect(menus()[0].style.width).toBe("");
-      expect(menus()[0].style.maxHeight).toBe("280px");
+      expect(menus()[0].style.maxHeight).toBe("376px");
     },
   );
   it.each([
     [8, "bottom", 240],
     [40, "bottom", 208],
-    [100, "top", 136],
+    [100, "bottom", 148],
     [180, "top", 216],
   ] as const)(
     "keeps actions reachable at plus-button top %ipx in a short viewport",
@@ -270,7 +329,7 @@ describe("connected composer menus", () => {
         expect(menus()[0].style.maxHeight).toBe(`${maxHeight}px`);
         expect(menus()[0].getAttribute("data-side")).toBe(side);
         expect(menus()[0].querySelector('[role="menuitem"]')).not.toBeNull();
-        expect(menus()[0].querySelector(".overflow-y-auto")).not.toBeNull();
+        expect(menus()[0].classList.contains("overflow-y-auto")).toBe(true);
       } finally {
         window.innerHeight = previousHeight;
       }
@@ -318,7 +377,7 @@ describe("connected composer menus", () => {
         viewport.dispatchEvent(new Event("scroll"));
       });
       expect(menus()[0].style.maxHeight).toBe("118px");
-      await key(row("Add context"), "Escape");
+      await key(row("Documents"), "Escape");
       expect(removeListener).toHaveBeenCalledWith(
         "resize",
         expect.any(Function),
@@ -351,7 +410,6 @@ describe("connected composer menus", () => {
       },
     ]);
     await openRoot();
-    await key(row("Add context"), "ArrowLeft");
     expect(menus()[0].getAttribute("dir")).toBe("rtl");
     await key(row("Source"), "ArrowLeft");
     expect(row("One")).toBeDefined();
@@ -398,7 +456,6 @@ describe("connected composer menus", () => {
     }
     await key(row("Project brief"), "Escape");
     await key(row("Documents"), "Escape");
-    await key(row("Add context"), "Escape");
     expect(observation.disconnect).toHaveBeenCalled();
   });
   it("closes a context picker when its composer becomes disabled", async () => {
@@ -469,7 +526,7 @@ describe("connected composer menus", () => {
     await key(row("Documents"), "ArrowRight");
     expect(row("Project brief")).toBeDefined();
     expect(row("Notes")).toBeDefined();
-    expect(menus()).toHaveLength(3);
+    expect(menus()).toHaveLength(2);
     await click("Project brief");
     expect(select).toHaveBeenCalledOnce();
     expect(menus()).toHaveLength(0);
@@ -477,21 +534,20 @@ describe("connected composer menus", () => {
   it("supports native keyboard navigation across nested context menus", async () => {
     await render();
     await openRoot();
-    await key(row("Add context"), "ArrowRight");
     await key(row("Documents"), "ArrowRight");
-    expect(menus()).toHaveLength(3);
-    await key(row("Project brief"), "ArrowDown");
+    expect(menus()).toHaveLength(2);
+    await key(row("Archive"), "ArrowDown");
+    expect(document.activeElement).toBe(row("Project brief"));
+    await key(row("Project brief"), "ArrowUp");
     expect(document.activeElement).toBe(row("Archive"));
     await key(row("Archive"), "ArrowRight");
     expect(row("Meeting notes")).toBeDefined();
-    expect(menus()).toHaveLength(4);
-    await key(row("Meeting notes"), "Escape");
     expect(menus()).toHaveLength(3);
-    await key(row("Archive"), "Escape");
+    await key(row("Meeting notes"), "Escape");
     expect(menus()).toHaveLength(2);
-    await key(row("Documents"), "Escape");
+    await key(row("Archive"), "Escape");
     expect(menus()).toHaveLength(1);
-    await key(row("Add context"), "Escape");
+    await key(row("Documents"), "Escape");
     expect(menus()).toHaveLength(0);
   });
   it("preserves native upload accepts, cancellation, multiple files and errors", async () => {
@@ -511,7 +567,7 @@ describe("connected composer menus", () => {
     expect(input.multiple).toBe(true);
     expect(input.accept).toBe("text/plain");
     await openRoot();
-    await click("Upload File");
+    await click("Files and images");
     expect(picker).toHaveBeenCalledOnce();
     await act(async () =>
       input.dispatchEvent(new Event("change", { bubbles: true })),
@@ -527,11 +583,18 @@ describe("connected composer menus", () => {
   });
   it("requests gated upload after the menu closes", async () => {
     const onAttachmentRequest = vi.fn();
-    await render([], { onAttachmentRequest });
+    const addAttachment = vi.fn();
+    await render([], { onAttachmentRequest, addAttachment });
+    const input =
+      document.querySelector<HTMLInputElement>('input[type="file"]');
+    if (!input) throw new Error("Missing file input");
+    const choose = vi.spyOn(input, "click");
     await openRoot();
-    await click("Upload File");
+    await click("Files and images");
     await act(async () => new Promise((resolve) => setTimeout(resolve, 0)));
     expect(onAttachmentRequest).toHaveBeenCalledOnce();
+    expect(choose).not.toHaveBeenCalled();
+    expect(addAttachment).not.toHaveBeenCalled();
     expect(menus()).toHaveLength(0);
     expect(document.activeElement?.getAttribute("aria-label")).toBe(
       "Add context",
@@ -570,7 +633,7 @@ describe("connected composer menus", () => {
     expect(select).toHaveBeenCalledOnce();
     expect(container.querySelector('[aria-label="Prompt draft"]')).toBe(draft);
     await act(async () => controls.onBack());
-    expect(menus()).toHaveLength(2);
+    expect(menus()).toHaveLength(1);
     expect(dismiss).toHaveBeenCalledTimes(2);
   });
   it("ignores stale legacy close and reports resume of a removed source", async () => {
@@ -593,7 +656,7 @@ describe("connected composer menus", () => {
     const old = controls;
     await act(async () => controls.onBack());
     await act(async () => old.onClose());
-    expect(menus()).toHaveLength(2);
+    expect(menus()).toHaveLength(1);
     await render([]);
     await act(async () => old.onResume());
     expect(document.querySelector('[role="alert"]')?.textContent).toBe(
@@ -617,7 +680,7 @@ describe("connected composer menus", () => {
       ]);
       await open();
       await click("Reference");
-      expect(menus()).toHaveLength(3);
+      expect(menus()).toHaveLength(2);
       expect(document.querySelector('[role="alert"]')?.textContent).toBe(
         "Reference unavailable",
       );