@agent-native/toolkit 0.204.1-nightly-20261008153353 → 0.205.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/toolkit",
-  "version": "0.204.1-nightly-20261008153353",
+  "version": "0.205.0",
   "description": "Reusable app-building UI and helpers for Agent-Native apps.",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -673,7 +673,7 @@
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.204.1-nightly-20261008153353"
+    "@agent-native/agentkit": "^0.205.0"
   },
   "devDependencies": {
     "@excalidraw/excalidraw": "0.18.1",
@@ -697,10 +697,10 @@
     "typescript-7": "npm:typescript@^7.0.2",
     "vite": "8.1.0",
     "vitest": "^4.1.5",
-    "@agent-native/core": "^0.204.1-nightly-20261008153353"
+    "@agent-native/core": "^0.205.0"
   },
   "peerDependencies": {
-    "@agent-native/core": "0.204.1-nightly-20261008153353",
+    "@agent-native/core": ">=0.196.0",
     "@excalidraw/excalidraw": ">=0.18",
     "@excalidraw/mermaid-to-excalidraw": ">=2",
     "@tanstack/react-query": "^5.99.2",

package/src/app/auth/AuthPage.interaction.spec.tsx

@@ -290,9 +290,18 @@ describe("AuthPage interactions", () => {
       });
 
       expect(sendBeacon).toHaveBeenCalled();
-      for (const [url] of sendBeacon.mock.calls as unknown as [string][]) {
+      const sessionId = window.localStorage.getItem("agent-native.session_id");
+      expect(sessionId).toBeTruthy();
+      for (const [url, body] of sendBeacon.mock.calls as unknown as [
+        string,
+        string,
+      ][]) {
         expect(url).toBe("https://beta.analytics.agent-native.com/track");
+        expect(JSON.parse(body).sessionId).toBe(sessionId);
       }
+      expect(document.cookie).toContain(
+        `an_sid=${encodeURIComponent(sessionId!)}`,
+      );
     } finally {
       delete (window as Window & { __AGENT_NATIVE_CONFIG__?: unknown })
         .__AGENT_NATIVE_CONFIG__;

package/src/app/auth/AuthPage.tsx

@@ -1,5 +1,6 @@
 /** @jsxRuntime classic */
 
+import { getAnalyticsSessionId } from "@agent-native/core/client/analytics";
 import { frameworkRoutePrefix } from "@agent-native/core/client/api-path";
 import {
   isAgentNativeDesktop,
@@ -60,7 +61,6 @@ const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 const TAB_STORAGE_KEY = "an.onboarding.tab";
 const PENDING_SIGNUP_EMAIL_STORAGE_KEY = "an.onboarding.pendingSignupEmail";
 const ANALYTICS_ANONYMOUS_ID_KEY = "agent-native.anonymous_id";
-const ANALYTICS_SESSION_ID_KEY = "agent-native.session_id";
 const FIRST_TOUCH_STORAGE_KEY = "an_attribution";
 const FIRST_TOUCH_COOKIE = "an_ft";
 const GOOGLE_AUTH_URL_PATH = "/_agent-native/google/auth-url";
@@ -265,14 +265,7 @@ function trackAuth(
     if (!config?.agentNativeAnalyticsPublicKey) return;
     const anonymousId = readStorage(ANALYTICS_ANONYMOUS_ID_KEY);
     if (!anonymousId) return;
-    const sessionId = (() => {
-      try {
-        return window.sessionStorage.getItem(ANALYTICS_SESSION_ID_KEY) ?? "";
-      } catch {
-        // coercion-ok: analytics session storage is optional.
-        return "";
-      }
-    })();
+    const sessionId = getAnalyticsSessionId();
     const endpoint = resolveLaneEndpoint(
       config.agentNativeAnalyticsEndpoint ??
         "https://analytics.agent-native.com/track",
@@ -291,7 +284,7 @@ function trackAuth(
         event: event.name,
         properties: event.properties,
         anonymousId,
-        sessionId: sessionId || undefined,
+        sessionId,
         timestamp: new Date().toISOString(),
       });
       if (navigator.sendBeacon?.(endpoint, body)) continue;

package/src/app/chat/AgentSidebar.spec.tsx

@@ -105,6 +105,7 @@ function renderSidebar(
   disableChatShortcut = false,
   enabled = true,
   screenRefreshEnabled = true,
+  forceOverlay = false,
 ) {
   const render = (nextEnabled: boolean) => {
     flushSync(() => {
@@ -114,6 +115,7 @@ function renderSidebar(
             defaultOpen={defaultOpen}
             disableChatShortcut={disableChatShortcut}
             enabled={nextEnabled}
+            forceOverlay={forceOverlay}
             position={position}
             screenRefreshEnabled={screenRefreshEnabled}
           >
@@ -260,6 +262,20 @@ describe("AgentSidebar panel", () => {
     expect(composer?.value).toBe("hello");
   });
 
+  it("can overlay the agent panel above the mobile breakpoint", () => {
+    renderSidebar(true, "right", false, true, true, true);
+
+    const panel = container?.querySelector<HTMLElement>(
+      ".agent-sidebar-panel[data-agent-sidebar-state='open']",
+    );
+    expect(panel?.dataset.agentSidebarLayout).toBe("overlay");
+    expect(panel?.style.position).toBe("fixed");
+    expect(container?.querySelector(".agent-sidebar-backdrop")).toBeTruthy();
+    expect(
+      container?.querySelector("[data-agent-sidebar-main-state='closed']"),
+    ).toBeTruthy();
+  });
+
   it("opens from the global shortcut with the composer available", async () => {
     renderSidebar(false);
     await act(async () => {});

package/src/app/chat/AgentSidebar.tsx

@@ -249,6 +249,8 @@ export interface AgentSidebarProps {
   /** @deprecated Use `defaultSidebarWidth` — this prop is mount-only. */
   sidebarWidth?: number;
   position?: "left" | "right";
+  /** Render the open panel over content even above the mobile breakpoint. */
+  forceOverlay?: boolean;
   defaultOpen?: boolean;
   disableChatShortcut?: boolean;
   showCollapseButton?: boolean;
@@ -326,6 +328,7 @@ export function AgentSidebar({
   defaultSidebarWidth,
   sidebarWidth,
   position,
+  forceOverlay = false,
   defaultOpen,
   disableChatShortcut = false,
   showCollapseButton = true,
@@ -978,10 +981,12 @@ export function AgentSidebar({
   const handleResizeEnd = useCallback(() => setIsResizing(false), []);
 
   const isLeft = effectivePosition === "left";
-  const wideDrawerEnabled = isWideDrawer && !isMobile;
-  const mobileAnimationEnabled = !presentationMode && isMobile && animateMobile;
+  const isOverlay = isMobile || forceOverlay;
+  const wideDrawerEnabled = isWideDrawer && !isOverlay;
+  const mobileAnimationEnabled =
+    !presentationMode && isOverlay && animateMobile;
   const desktopAnimationEnabled =
-    !presentationMode && !isMobile && effectiveAnimateDesktop;
+    !presentationMode && !isOverlay && effectiveAnimateDesktop;
   const sidebarAnimationEnabled =
     mobileAnimationEnabled || desktopAnimationEnabled;
   const [renderAnimatedPanel, setRenderAnimatedPanel] =
@@ -1014,15 +1019,17 @@ export function AgentSidebar({
     enabled &&
     (sidebarAnimationEnabled ? renderAnimatedPanel : shouldMountPanel);
   const panelOpen = enabled && open && shouldMountPanel;
-  const panelLayout = isMobile
-    ? "mobile"
+  const panelLayout = isOverlay
+    ? forceOverlay && !isMobile
+      ? "overlay"
+      : "mobile"
     : wideDrawerEnabled
       ? "drawer"
       : "desktop";
-  const showResizeHandle = !isMobile && !wideDrawerEnabled && panelOpen;
+  const showResizeHandle = !isOverlay && !wideDrawerEnabled && panelOpen;
 
   let panelStyle: AgentPanelStyle;
-  if (isMobile) {
+  if (isOverlay) {
     panelStyle = {
       ...AGENT_PANEL_ROOT_STYLE,
       position: "fixed",
@@ -1169,9 +1176,9 @@ export function AgentSidebar({
             defaultMode={defaultMode}
             onCollapse={() => setOpenPersisted(false)}
             showCollapseButton={showCollapseButton}
-            onSnapTo75Percent={isMobile ? undefined : snapTo75Percent}
-            isWideDrawer={isMobile ? false : isWideDrawer}
-            onExitWideDrawer={isMobile ? undefined : exitWideDrawer}
+            onSnapTo75Percent={isOverlay ? undefined : snapTo75Percent}
+            isWideDrawer={isOverlay ? false : isWideDrawer}
+            onExitWideDrawer={isOverlay ? undefined : exitWideDrawer}
             onFullViewRequest={onFullscreenRequest}
             onOpenSettings={onOpenSettings}
             onNewCliTab={onNewCliTab}
@@ -1232,8 +1239,8 @@ export function AgentSidebar({
         data-agent-native-hosted-chat={isPerAppChatHosted ? "true" : undefined}
         data-agent-sidebar-resizing={isResizing ? "true" : undefined}
       >
-        {/* Mobile backdrop — tapping it closes the sidebar */}
-        {isMobile &&
+        {/* Overlay backdrop — tapping it closes the sidebar */}
+        {isOverlay &&
           !isPerAppChatHosted &&
           !presentationMode &&
           enabled &&
@@ -1265,7 +1272,7 @@ export function AgentSidebar({
           className="agent-sidebar-main-surface flex flex-1 flex-col overflow-auto min-w-0"
           data-agent-sidebar-main-position={effectivePosition}
           data-agent-sidebar-main-state={
-            !isMobile && !presentationMode && panelOpen ? "open" : "closed"
+            !isOverlay && !presentationMode && panelOpen ? "open" : "closed"
           }
           data-agent-sidebar-resizing={isResizing ? "true" : undefined}
         >

package/src/app/chat/RunStuckBanner.spec.tsx

@@ -37,7 +37,11 @@ const hookState = vi.hoisted(() => ({
   awaitingResponse: undefined as boolean | undefined,
 }));
 
-const abortRunMock = vi.hoisted(() => vi.fn(async () => null));
+const abortRunMock = vi.hoisted(() =>
+  vi.fn(
+    async (_runId: string, _reason?: string): Promise<string | null> => null,
+  ),
+);
 
 vi.mock("@agent-native/core/client/agent-chat", () => ({
   useRunStuckDetection: (options: { awaitingResponse?: boolean }) => {
@@ -287,6 +291,132 @@ describe("RunStuckBanner", () => {
     expect(container.querySelectorAll("button")).toHaveLength(0);
   });
 
+  describe.each([
+    { action: "retry", label: "agentChat.common.retry" },
+    { action: "cancel", label: "agentChat.common.cancel" },
+  ])("when the user clicks $action on a stuck run", ({ action, label }) => {
+    const button = () =>
+      Array.from(container.querySelectorAll("button")).find(
+        (candidate) => candidate.textContent === label,
+      )!;
+    const click = () =>
+      act(async () => {
+        button().click();
+      });
+    const bothButtonsEnabled = () =>
+      Array.from(container.querySelectorAll("button")).every(
+        (candidate) => !candidate.disabled,
+      );
+
+    it("keeps both buttons disabled while the abort is in flight", async () => {
+      let finishAbort: (runId: string | null) => void = () => {};
+      abortRunMock.mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            finishAbort = resolve;
+          }),
+      );
+      await render({ threadId: "thread-1" });
+
+      await click();
+
+      expect(abortRunMock).toHaveBeenCalledTimes(1);
+      expect(button().disabled).toBe(true);
+      expect(container.querySelector(".animate-spin")).not.toBeNull();
+      await act(async () => finishAbort(null));
+    });
+
+    it("re-enables the buttons when the abort fails", async () => {
+      await render({ threadId: "thread-1" });
+
+      await click();
+
+      expect(abortRunMock).toHaveBeenCalledWith(
+        "run-1",
+        `user_stuck_${action}`,
+      );
+      expect(bothButtonsEnabled()).toBe(true);
+      expect(container.querySelector(".animate-spin")).toBeNull();
+    });
+
+    it("aborts again on a second click after a failed abort", async () => {
+      await render({ threadId: "thread-1" });
+
+      await click();
+      await click();
+
+      expect(abortRunMock).toHaveBeenCalledTimes(2);
+      expect(bothButtonsEnabled()).toBe(true);
+    });
+
+    it("stays busy once the abort succeeds, until the run is replaced", async () => {
+      abortRunMock.mockResolvedValueOnce("run-1");
+      const onRetry = vi.fn();
+      await render({ threadId: "thread-1", onRetry });
+
+      await click();
+
+      expect(onRetry).toHaveBeenCalledTimes(action === "retry" ? 1 : 0);
+      expect(button().disabled).toBe(true);
+      expect(container.querySelector(".animate-spin")).not.toBeNull();
+
+      hookState.current = { ...STUCK_STATE, runId: "run-2" };
+      await render({ threadId: "thread-1", onRetry });
+      expect(bothButtonsEnabled()).toBe(true);
+    });
+  });
+
+  it.each([
+    { remount: false, laterMs: 0, where: "in the same mount" },
+    { remount: true, laterMs: 0, where: "after the chat remounts or reloads" },
+    {
+      remount: true,
+      laterMs: 30 * 60_000,
+      where: "after a reload past the five-minute retry lease",
+    },
+  ])(
+    "never auto-retries a run the user cancelled, even when the abort failed, $where",
+    async ({ remount, laterMs }) => {
+      const onRetry = vi.fn();
+      const props = {
+        threadId: "thread-cancelled",
+        autoRetry: true,
+        autoRetryOwnerId: "owner-1",
+        onRetry,
+      };
+      // A server-continued dispatch keeps the banner up but defers auto-retry.
+      hookState.current = { ...STUCK_STATE, dispatchMode: "background" };
+      await render(props);
+      expect(abortRunMock).not.toHaveBeenCalled();
+
+      await act(async () => {
+        Array.from(container.querySelectorAll("button"))
+          .find(
+            (candidate) => candidate.textContent === "agentChat.common.cancel",
+          )!
+          .click();
+      });
+      expect(abortRunMock).toHaveBeenCalledTimes(1);
+      expect(abortRunMock).toHaveBeenCalledWith("run-1", "user_stuck_cancel");
+
+      if (remount) {
+        // A reload drops component state; only the persisted claim remembers.
+        await act(async () => root.unmount());
+        root = createRoot(container);
+      }
+      if (laterMs) vi.setSystemTime(Date.now() + laterMs);
+
+      // The run is still stuck and no longer a continued dispatch: auto-retry is
+      // eligible again, but the user already acted on it.
+      hookState.current = { ...STUCK_STATE };
+      await render(props);
+      await act(async () => {});
+
+      expect(abortRunMock).toHaveBeenCalledTimes(1);
+      expect(onRetry).not.toHaveBeenCalled();
+    },
+  );
+
   it("does not auto-abort a run on a stuck verdict it cannot confirm", async () => {
     const props = {
       threadId: "thread-auto-retry",

package/src/app/chat/RunStuckBanner.tsx

@@ -33,6 +33,9 @@ export type RunReconcileOutcome = "settled" | "still_running";
 
 const RECONCILE_RETRY_MS = 30_000;
 const AUTO_RETRY_CLAIM_TTL_MS = 5 * 60 * 1000;
+// A user's Cancel or Retry outlives the short retry lease: a stuck run stays
+// stuck for as long as it takes someone to reload the page.
+const USER_ACTION_CLAIM_TTL_MS = 6 * 60 * 60 * 1000;
 const BACKGROUND_WORKER_FRESH_HEARTBEAT_MS = 30_000;
 
 /**
@@ -43,6 +46,14 @@ const reportedStuckRunIds = new Set<string>();
 
 type BusyState = { type: "none" } | { type: "cancel" | "retry"; runId: string };
 
+// Only the click that set busy for `runId` may clear it.
+const releaseBusy =
+  (runId: string) =>
+  (current: BusyState): BusyState =>
+    current.type !== "none" && current.runId === runId
+      ? { type: "none" }
+      : current;
+
 type MaybeLockManager = {
   request<T>(
     name: string,
@@ -100,6 +111,32 @@ function markAutoRetryClaim(key: string, ownerId: string) {
   }
 }
 
+/**
+ * A run the user cancelled or retried must stay out of auto-retry across a
+ * reload too: the claim every owner checks is the one place that survives it, so
+ * the click takes the claim for itself. Best effort, like the claim itself.
+ */
+function markUserActedOnRun(
+  threadId: string | null | undefined,
+  runId: string,
+) {
+  if (!threadId || typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(
+      autoRetryClaimKey(threadId, runId),
+      JSON.stringify({
+        ownerId: "user-action",
+        expiresAt: Date.now() + USER_ACTION_CLAIM_TTL_MS,
+      }),
+    );
+  } catch (error) {
+    console.warn(
+      "[agent-chat] could not persist the stuck-run user action; it only holds until reload:",
+      error instanceof Error ? error.message : String(error),
+    );
+  }
+}
+
 async function claimAutoRetryAttempt(
   threadId: string | null | undefined,
   runId: string,
@@ -152,6 +189,9 @@ export function RunStuckBanner({
   const [busy, setBusy] = useState<BusyState>({ type: "none" });
   const [autoRetriedRunId, setAutoRetriedRunId] = useState<string | null>(null);
   const autoRetriedRunIdsRef = useRef<Set<string>>(new Set());
+  // A run the user already acted on is never auto-retried: a failed Cancel frees
+  // `busy` again, and an auto-retry gated on other state must not then resume it.
+  const userActedRunIdsRef = useRef<Set<string>>(new Set());
   const generatedOwnerIdRef = useRef<string | null>(null);
   if (!generatedOwnerIdRef.current) {
     generatedOwnerIdRef.current = createAutoRetryOwnerId();
@@ -274,7 +314,8 @@ export function RunStuckBanner({
       !isStuck ||
       !state.runId ||
       busy.type !== "none" ||
-      autoRetriedRunIdsRef.current.has(state.runId)
+      autoRetriedRunIdsRef.current.has(state.runId) ||
+      userActedRunIdsRef.current.has(state.runId)
     ) {
       return;
     }
@@ -282,7 +323,7 @@ export function RunStuckBanner({
     const runId = state.runId;
     void claimAutoRetryAttempt(threadId, runId, ownerId).then((claimed) => {
       autoRetriedRunIdsRef.current.add(runId);
-      if (!claimed) return;
+      if (!claimed || userActedRunIdsRef.current.has(runId)) return;
       setBusy({ type: "retry", runId });
       setAutoRetriedRunId(runId);
       trackEvent("agent_chat_stuck_auto_retry", {
@@ -291,11 +332,7 @@ export function RunStuckBanner({
         stuckSinceMs: state.stuckSinceMs ?? null,
       });
       void abortRun(runId, "auto_stuck_retry").then((aborted) => {
-        setBusy((current) =>
-          current.type !== "none" && current.runId === runId
-            ? { type: "none" }
-            : current,
-        );
+        setBusy(releaseBusy(runId));
         if (aborted) onRetry?.(aborted);
       });
     });
@@ -357,13 +394,19 @@ export function RunStuckBanner({
   const handleCancel = async () => {
     if (!state.runId || busy.type !== "none") return;
     const runId = state.runId;
+    userActedRunIdsRef.current.add(runId);
+    markUserActedOnRun(threadId, runId);
     setBusy({ type: "cancel", runId });
     trackEvent("agent_chat_stuck_cancel", {
       runId,
       threadId: threadId ?? null,
       stuckSinceMs: state.stuckSinceMs ?? null,
     });
-    await abortRun(runId, "user_stuck_cancel");
+    // A replaced run clears busy through the state effect; a failed abort never
+    // replaces it, so the buttons would stay disabled for the same stuck run.
+    if (!(await abortRun(runId, "user_stuck_cancel"))) {
+      setBusy(releaseBusy(runId));
+    }
   };
 
   const handleRetry = async () => {
@@ -376,6 +419,8 @@ export function RunStuckBanner({
       return;
     }
     const runId = state.runId;
+    userActedRunIdsRef.current.add(runId);
+    markUserActedOnRun(threadId, runId);
     setBusy({ type: "retry", runId });
     trackEvent("agent_chat_stuck_retry", {
       runId,
@@ -384,6 +429,7 @@ export function RunStuckBanner({
     });
     const aborted = await abortRun(runId, "user_stuck_retry");
     if (aborted) onRetry?.(aborted);
+    else setBusy(releaseBusy(runId));
   };
 
   const busyType = busy.type;

package/src/app/onboarding/FirstRunOnboarding.spec.tsx

@@ -1302,6 +1302,9 @@ describe("FirstRunOnboarding", () => {
         ?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
     });
 
+    expect(
+      document.body.querySelector("[data-testid='first-run-setup-skip']"),
+    ).toBeNull();
     expect(completedSteps()).toEqual([]);
     expect(skippedSteps()).toEqual(["role"]);
 
@@ -1333,6 +1336,84 @@ describe("FirstRunOnboarding", () => {
     window.history.replaceState(null, "", "/");
   });
 
+  it("lets Clips skip provider setup and finish first-run onboarding", async () => {
+    let resolveCompletion: (() => void) | undefined;
+    mocks.completeFirstRun.mockImplementation(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveCompletion = resolve;
+        }),
+    );
+    mocks.useOnboarding.mockReturnValue({
+      firstRun: true,
+      loading: false,
+      error: null,
+      profile: {
+        appId: "clips",
+        appName: "Clips",
+        capabilities: [],
+      },
+      completeFirstRun: mocks.completeFirstRun,
+      completeFirstRunError: null,
+    });
+
+    await act(async () => {
+      root.render(
+        <TooltipProvider>
+          <FirstRunOnboarding />
+        </TooltipProvider>,
+      );
+      await Promise.resolve();
+    });
+    act(() => {
+      document.body
+        .querySelector("[data-testid='first-run-role-skip']")
+        ?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    });
+
+    const skipSetupButton = document.body.querySelector(
+      "[data-testid='first-run-setup-skip']",
+    );
+    expect(skipSetupButton?.textContent).toBe("Skip for now");
+
+    act(() => {
+      skipSetupButton?.dispatchEvent(
+        new MouseEvent("click", { bubbles: true }),
+      );
+      skipSetupButton?.dispatchEvent(
+        new MouseEvent("click", { bubbles: true }),
+      );
+    });
+    expect(mocks.completeFirstRun).toHaveBeenCalledOnce();
+    expect(
+      mocks.trackOnboardingEvent.mock.calls.filter(
+        ([event, properties]) =>
+          event === "onboarding_step_skipped" &&
+          (properties as Record<string, unknown>).step_id === "choice",
+      ),
+    ).toHaveLength(1);
+
+    await act(async () => {
+      resolveCompletion?.();
+      await Promise.resolve();
+    });
+
+    expect(mocks.completeFirstRun).toHaveBeenCalledOnce();
+    expect(window.location.pathname).toBe("/");
+    expect(mocks.trackOnboardingEvent).toHaveBeenCalledWith(
+      "onboarding_step_skipped",
+      expect.objectContaining({
+        flow: "first_run",
+        step_id: "choice",
+        reason: "user_action",
+      }),
+    );
+    expect(mocks.trackOnboardingEvent).not.toHaveBeenCalledWith(
+      "onboarding_method_clicked",
+      expect.anything(),
+    );
+  });
+
   it("does not start duplicate manual setup attempts while completion is pending", async () => {
     let resolveCompletion: (() => void) | undefined;
     mocks.completeFirstRun.mockImplementation(

package/src/app/onboarding/FirstRunOnboarding.tsx

@@ -303,6 +303,7 @@ export function FirstRunOnboarding({
     extensionIndex: number;
   } | null>(null);
   const completionInFlightRef = useRef(false);
+  const setupSkipStartedRef = useRef(false);
   const onboardingTerminalRef = useRef(false);
   const abandonmentTrackedRef = useRef(false);
   const setupAttemptRef = useRef<FirstRunSetupAttempt | null>(null);
@@ -824,6 +825,27 @@ export function FirstRunOnboarding({
                 </button>
               </section>
             </div>
+            {profile.appId === "clips" && (
+              <div className="flex justify-center">
+                <button
+                  type="button"
+                  data-testid="first-run-setup-skip"
+                  className="inline-flex min-h-9 items-center justify-center rounded-lg px-2.5 text-xs font-medium text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                  onClick={() => {
+                    if (
+                      setupSkipStartedRef.current ||
+                      completionInFlightRef.current
+                    )
+                      return;
+                    setupSkipStartedRef.current = true;
+                    trackFirstRunStepSkipped("choice");
+                    handleFinish(null);
+                  }}
+                >
+                  {t("agentChat.onboarding.skipForNow")}
+                </button>
+              </div>
+            )}
           </div>
           <p className="text-center text-xs leading-5 text-muted-foreground">
             {t("agentChat.onboarding.builderConsentPrefix")}{" "}

package/src/app/sharing/ShareButton.spec.tsx

@@ -440,6 +440,28 @@ describe("ShareButton", () => {
     ).toBe("recover-me@example.com");
   });
 
+  it("opens without a trigger when invoked from an external menu", async () => {
+    popoverTestState.simulateMounting = true;
+
+    await act(async () => {
+      root.render(
+        <QueryClientProvider client={queryClient}>
+          <ShareButton
+            resourceType="document"
+            resourceId="doc-1"
+            defaultOpen
+            hideTrigger
+          />
+        </QueryClientProvider>,
+      );
+    });
+
+    expect(container.querySelector('button[aria-label="Share"]')).toBeNull();
+    expect(
+      container.querySelector("[data-agent-native-share-overlay]"),
+    ).not.toBeNull();
+  });
+
   it("shows the copy action for share URLs regardless of visibility", async () => {
     await act(async () => {
       root.render(