diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 1ed1194a66bb..126cdff114c0 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -42,7 +42,10 @@ function App(): React.JSX.Element {
   useAppShellServices()
   // Why before the startup chain: its effect runs first, and no startup step can skip the load.
   useEffect(startNativeChatDraftLoad, [])
-  useAppStartupHydration(onboardingGate.applyStartupOnboardingState)
+  useAppStartupHydration(
+    onboardingGate.applyStartupOnboardingState,
+    onboardingGate.applyStartupTipCheckInputs
+  )
   useAppSessionPersistence()
   useRuntimeGraphSync()
   usePersistedUIWriter()
diff --git a/src/renderer/src/app-shell/AppRootSurfaces.tsx b/src/renderer/src/app-shell/AppRootSurfaces.tsx
index 59e6c67ee5c4..9f1d24d59335 100644
--- a/src/renderer/src/app-shell/AppRootSurfaces.tsx
+++ b/src/renderer/src/app-shell/AppRootSurfaces.tsx
@@ -18,6 +18,7 @@ import { shouldRenderPetOverlay } from '../components/pet/pet-overlay-visibility
 import { useAppStore } from '../store'
 import type { UpdateStatus } from '../../../shared/update-status-types'
 import { useLazyModalMounts } from './use-lazy-modal-mounts'
+import { AppOpenFeatureTip } from '../components/feature-tips/AppOpenFeatureTip'
 import {
   selectAppRootSurfacePetEnabled,
   selectAppRootSurfaceTelemetryOptedIn,
@@ -26,6 +27,7 @@ import {
 import type { FloatingWorkspacePanelState } from './use-floating-workspace-panel'
 import type { OnboardingGate } from './use-onboarding-and-feature-tips'
 
+const OnboardingFlow = lazy(() => import('../components/onboarding/OnboardingFlow'))
 const QuickOpen = lazy(() => import('../components/QuickOpen'))
 const WorktreeJumpPalette = lazy(() => import('../components/WorktreeJumpPalette'))
 const WorkspaceCleanupDialog = lazy(
@@ -36,13 +38,11 @@ const StatusBar = lazy(() =>
 )
 const SetupGuideModal = lazy(() => import('../components/setup-guide/SetupGuideModal'))
 const FeatureWallModal = lazy(() => import('../components/feature-wall/FeatureWallModal'))
-const FeatureTipsModal = lazy(() => import('../components/feature-tips/FeatureTipsModal'))
 const AddRepoDialog = lazy(() => import('../components/sidebar/AddRepoDialog'))
 const NonGitFolderDialog = lazy(() => import('../components/sidebar/NonGitFolderDialog'))
 const AddProjectFromFolderDialog = lazy(
   () => import('../components/sidebar/AddProjectFromFolderDialog')
 )
-const ProjectAddedDialog = lazy(() => import('../components/sidebar/ProjectAddedDialog'))
 const DeleteWorktreeDialog = lazy(() => import('../components/sidebar/DeleteWorktreeDialog'))
 const PreservedBranchBatchReviewModal = lazy(
   () => import('../components/sidebar/PreservedBranchBatchReviewModal')
@@ -85,8 +85,6 @@ const FloatingTerminalPanel = lazy(() =>
 )
 // Why: lazy so the WebP asset + overlay module aren't fetched unless the experimental flag is on.
 const PetOverlay = lazy(() => import('../components/pet/PetOverlay'))
-// Why: lazy so onboarding's step modules + assets aren't fetched for users past first-launch.
-const OnboardingFlow = lazy(() => import('../components/onboarding/OnboardingFlow'))
 
 type BoundaryProps = {
   boundaryId: string
@@ -146,7 +144,6 @@ export function AppRootSurfaces(props: {
   const updateStatus = useAppStore((s) => s.updateStatus)
   const activeContextualTourId = useAppStore((s) => s.activeContextualTourId)
   const hasSshCredentialRequest = useAppStore((s) => s.sshCredentialQueue.length > 0)
-
   const shouldMountSetupGuideTelemetryObserver = persistedUIReady
   const shouldMountUpdateCard = shouldMountUpdateCardForStatus(updateStatus)
   const shouldMountDictationController = voiceEnabled || dictationState !== 'idle'
@@ -215,11 +212,6 @@ export function AppRootSurfaces(props: {
             <AddProjectFromFolderDialog />
           </ModalBoundary>
         ) : null}
-        {activeModal === 'project-added' ? (
-          <ModalBoundary boundaryId="modal.project-added" resetKey>
-            <ProjectAddedDialog />
-          </ModalBoundary>
-        ) : null}
       </Suspense>
       {/* Why: root overlays can render Radix <Tooltip>s; keep inside the shared provider so lazy surfaces mount from any entry point. */}
       <Suspense fallback={null}>
@@ -256,11 +248,6 @@ export function AppRootSurfaces(props: {
             <FeatureWallModal />
           </ModalBoundary>
         ) : null}
-        {mountedLazyModalIds.has('feature-tips') ? (
-          <ModalBoundary boundaryId="modal.feature-tips" resetKey={activeModal === 'feature-tips'}>
-            <FeatureTipsModal />
-          </ModalBoundary>
-        ) : null}
       </Suspense>
       {shouldMountSetupGuideTelemetryObserver ? (
         <Suspense fallback={null}>
@@ -365,6 +352,9 @@ export function AppRootSurfaces(props: {
           </RecoverableRenderErrorBoundary>
         </Suspense>
       ) : null}
+      {onboardingGate.appOpenTipId ? (
+        <AppOpenFeatureTip tipId={onboardingGate.appOpenTipId} />
+      ) : null}
       {shouldMountDictationController ? (
         <Suspense fallback={null}>
           <OverlayBoundary boundaryId="overlay.dictation" resetKey={activeView}>
diff --git a/src/renderer/src/app-shell/onboarding-contextual-tours.test.tsx b/src/renderer/src/app-shell/onboarding-contextual-tours.test.tsx
new file mode 100644
index 000000000000..2d98060607f7
--- /dev/null
+++ b/src/renderer/src/app-shell/onboarding-contextual-tours.test.tsx
@@ -0,0 +1,175 @@
+// @vitest-environment happy-dom
+
+import { act, lazy, Suspense, type LazyExoticComponent } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { getDefaultSettings } from '../../../shared/constants'
+import { getDefaultOnboardingState } from '../../../shared/onboarding-defaults'
+import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { resetDialogRegistryForTests } from '@/store/dialog-registry-test-state'
+import { ContextualTourOverlay } from '../components/contextual-tours/ContextualTourOverlay'
+import { useContextualTour } from '../components/contextual-tours/use-contextual-tour'
+import OnboardingFlow from '../components/onboarding/OnboardingFlow'
+import { showOnboardingFromRenderer } from '../components/onboarding/show-onboarding-event'
+import { useOnboardingAndFeatureTips, type OnboardingGate } from './use-onboarding-and-feature-tips'
+
+vi.mock('@/lib/feature-education-telemetry', () => ({
+  trackContextualTourShown: vi.fn(),
+  trackContextualTourOutcome: vi.fn()
+}))
+vi.mock('@/lib/telemetry', () => ({ track: vi.fn() }))
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+let root: Root
+let container: HTMLDivElement
+let target: HTMLButtonElement
+let gate: OnboardingGate | null
+let chunk: ReturnType<typeof Promise.withResolvers<{ default: typeof OnboardingFlow }>>
+let LazyOnboarding: LazyExoticComponent<typeof OnboardingFlow>
+
+function App(): React.JSX.Element {
+  const onboarding = useOnboardingAndFeatureTips()
+  gate = onboarding
+  useContextualTour('automations', true, 'automations_open', { recordFeatureInteraction: false })
+  return (
+    <>
+      {onboarding.onboarding && onboarding.shouldRender ? (
+        <Suspense fallback={null}>
+          <LazyOnboarding
+            onboarding={onboarding.onboarding}
+            onOnboardingChange={onboarding.setOnboarding}
+          />
+        </Suspense>
+      ) : null}
+      <ContextualTourOverlay />
+    </>
+  )
+}
+
+async function settle(): Promise<void> {
+  for (let i = 0; i < 4; i += 1) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 30))
+    })
+  }
+}
+
+beforeEach(() => {
+  gate = null
+  chunk = Promise.withResolvers()
+  LazyOnboarding = lazy(() => chunk.promise)
+  useAppStore.setState(useAppStore.getInitialState(), true)
+  useAppStore.setState({
+    settings: getDefaultSettings(''),
+    persistedUIReady: true,
+    contextualToursAutoEligible: true,
+    refreshDetectedAgents: vi.fn(async () => []),
+    refreshPreflightStatus: vi.fn(async () => {})
+  })
+  resetDialogRegistryForTests({ startupSettled: true })
+  Object.assign(window, {
+    api: {
+      ui: { set: vi.fn(async () => undefined) },
+      onboarding: { update: vi.fn(async () => getDefaultOnboardingState()) },
+      cli: { getInstallStatus: vi.fn(async () => ({ supported: false })) }
+    }
+  })
+  target = document.createElement('button')
+  target.dataset.contextualTourTarget = 'automations-create'
+  target.getBoundingClientRect = () => new DOMRect(100, 100, 120, 40)
+  document.body.append(target)
+  container = document.createElement('div')
+  document.body.append(container)
+  root = createRoot(container)
+})
+
+afterEach(async () => {
+  await act(async () => root.unmount())
+  target.remove()
+  container.remove()
+})
+
+it('does not consume a restored-page tour before first-run onboarding content commits', async () => {
+  await act(async () => root.render(<App />))
+  act(() => gate?.applyStartupOnboardingState(getDefaultOnboardingState()))
+  await settle()
+
+  expect(useAppStore.getState().contextualToursAutoEligible).toBe(true)
+  expect(Object.values(useDialogRegistry.getState().startupSources)).not.toContain('pending')
+  expect({
+    onboardingMounted: container.querySelector('[data-onboarding-modal]') !== null,
+    contentKinds: useDialogRegistry.getState().dialogEntries.map((entry) => entry.kind),
+    activeTour: useAppStore.getState().activeContextualTourId,
+    shown: useAppStore.getState().contextualTourShownThisSession,
+    seen: useAppStore.getState().contextualToursSeenIds
+  }).toEqual({
+    onboardingMounted: false,
+    contentKinds: [],
+    activeTour: null,
+    shown: false,
+    seen: []
+  })
+  act(() =>
+    useAppStore.getState().requestContextualTour('automations', 'automations_open', false, {
+      force: true
+    })
+  )
+  expect(useAppStore.getState().activeContextualTourId).toBeNull()
+
+  await act(async () => chunk.resolve({ default: OnboardingFlow }))
+  await settle()
+  expect(container.querySelector('[data-onboarding-modal]')).not.toBeNull()
+  expect(useDialogRegistry.getState().dialogEntries.map((entry) => entry.kind)).toEqual([
+    'onboarding'
+  ])
+  expect(useAppStore.getState().contextualToursSeenIds).toEqual([])
+
+  act(() =>
+    gate?.setOnboarding({ ...getDefaultOnboardingState(), closedAt: 1, outcome: 'completed' })
+  )
+  await settle()
+  expect(useAppStore.getState().activeContextualTourId).toBe('automations')
+  expect(useAppStore.getState().contextualToursSeenIds).toEqual(['automations'])
+})
+
+it('waits for unknown onboarding even when the profile already belongs to the automatic-tour cohort', async () => {
+  await act(async () => root.render(<App />))
+  await settle()
+
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+  expect(useAppStore.getState().activeContextualTourId).toBeNull()
+  expect(useAppStore.getState().contextualToursSeenIds).toEqual([])
+
+  act(() =>
+    gate?.applyStartupOnboardingState({
+      ...getDefaultOnboardingState(),
+      closedAt: 1,
+      outcome: 'completed'
+    })
+  )
+  await settle()
+  expect(useAppStore.getState().activeContextualTourId).toBe('automations')
+  expect(useAppStore.getState().contextualToursSeenIds).toEqual(['automations'])
+})
+
+it('cancels a shown tour when onboarding is reopened before its content mounts', async () => {
+  await act(async () => root.render(<App />))
+  act(() =>
+    gate?.applyStartupOnboardingState({
+      ...getDefaultOnboardingState(),
+      closedAt: 1,
+      outcome: 'completed'
+    })
+  )
+  await settle()
+  expect(useAppStore.getState().activeContextualTourId).toBe('automations')
+
+  await act(async () => showOnboardingFromRenderer())
+  await settle()
+
+  expect(container.querySelector('[data-onboarding-modal]')).toBeNull()
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+  expect(useAppStore.getState().activeContextualTourId).toBeNull()
+  expect(useAppStore.getState().contextualToursSeenIds).toEqual(['automations'])
+})
diff --git a/src/renderer/src/app-shell/self-opening-dialogs.test.tsx b/src/renderer/src/app-shell/self-opening-dialogs.test.tsx
new file mode 100644
index 000000000000..9f36c62b8d34
--- /dev/null
+++ b/src/renderer/src/app-shell/self-opening-dialogs.test.tsx
@@ -0,0 +1,859 @@
+import { STARTUP_DISCOVERY_READ_TIMEOUT_MS } from '../startup/startup-discovery-read'
+// @vitest-environment happy-dom
+
+import { act, StrictMode, useEffect, useLayoutEffect, useState } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectDialogPhase } from '@/store/dialog-registry-state'
+import { resetDialogRegistryForTests } from '@/store/dialog-registry-test-state'
+import { getDefaultSettings } from '../../../shared/constants'
+import type { CrashReportRecord } from '../../../shared/crash-reporting'
+import { NativeChatResumeOnRestartModal } from '../components/NativeChatResumeOnRestartModal'
+import { CrashReportDialog } from '../components/crash-report/CrashReportDialog'
+import { AppOpenFeatureTip } from '../components/feature-tips/AppOpenFeatureTip'
+import { APP_OPEN_FEATURE_TIP_TOKEN } from '../components/feature-tips/feature-tip-startup-gate'
+import { SshPassphraseDialog } from '../components/settings/SshPassphraseDialog'
+import { RecoverableRenderErrorBoundary } from '../components/error-boundaries/RecoverableRenderErrorBoundary'
+import { TooltipProvider } from '../components/ui/tooltip'
+import { Dialog, DialogContent, DialogTitle } from '../components/ui/dialog'
+import type { ResumeCandidate } from '../components/native-chat-resume-on-restart-grouping'
+import {
+  _resetNativeChatRestartOffer,
+  getNativeChatRestartOffer,
+  useNativeChatRestartOffer
+} from '../components/native-chat-resume-on-restart-store'
+import {
+  _resetNativeChatResumeOnRestartDialog,
+  requestNativeChatResumeOnRestartDialog
+} from '../components/native-chat-resume-on-restart-dialog'
+import { resetLocalStructuredChatsForTests } from '@/runtime/local-structured-chats'
+
+const rpc = vi.hoisted(() => vi.fn())
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: rpc,
+  subscribeStructuredAgentSessionStatus: () => new Promise(() => {})
+}))
+vi.mock('@/lib/activate-ai-vault-structured-session', () => ({
+  activateAiVaultStructuredSession: vi.fn(async () => true)
+}))
+vi.mock('sonner', () => ({ toast: Object.assign(vi.fn(), { error: vi.fn() }) }))
+vi.mock('@/lib/telemetry', () => ({ track: vi.fn() }))
+const surface = vi.hoisted(() => ({ loaded: Promise.resolve(), suspended: false, error: false }))
+// The real surfaces have their own tests; here they are a real Dialog, so their entries behave.
+vi.mock('../components/crash-report/CrashReportDialogSurface', async () => {
+  const ui = await import('../components/ui/dialog')
+  return {
+    CrashReportDialogSurface: ({
+      open,
+      report,
+      onOpenChange
+    }: {
+      open: boolean
+      report: CrashReportRecord | null
+      onOpenChange: (open: boolean) => void
+    }) => {
+      if (surface.error) {
+        throw new Error('surface failed')
+      }
+      if (surface.suspended) {
+        // Its lazy chunk is still loading: admitted, nothing on screen yet.
+        throw surface.loaded
+      }
+      return (
+        <ui.Dialog open={open} onOpenChange={onOpenChange}>
+          <ui.DialogContent data-testid="crash-report" data-report={report?.id}>
+            <ui.DialogTitle>Crash report</ui.DialogTitle>
+            <textarea aria-label="notes" />
+            <button type="button" onClick={() => onOpenChange(false)}>
+              Close crash report
+            </button>
+          </ui.DialogContent>
+        </ui.Dialog>
+      )
+    }
+  }
+})
+vi.mock('../components/feature-tips/FeatureTipsModal', async () => {
+  const ui = await import('../components/ui/dialog')
+  return {
+    FeatureTipDialogs: ({
+      open,
+      tipId,
+      onClose
+    }: {
+      open: boolean
+      tipId: string
+      onClose: () => void
+    }) => (
+      <ui.Dialog open={open} onOpenChange={(next) => !next && onClose()}>
+        <ui.DialogContent data-testid="feature-tip">
+          <ui.DialogTitle>Tip {tipId}</ui.DialogTitle>
+          <button type="button" onClick={onClose}>
+            Close tip
+          </button>
+        </ui.DialogContent>
+      </ui.Dialog>
+    )
+  }
+})
+const boundaryReports = vi.hoisted((): CrashReportRecord[] => [])
+vi.mock('@/lib/react-error-boundary-reporting', () => ({
+  REACT_ERROR_BOUNDARY_REPORT_AVAILABLE_EVENT: 'test-boundary-report',
+  takePendingReactErrorBoundaryReports: () => boundaryReports.splice(0),
+  reportReactErrorBoundaryCrash: async () => {}
+}))
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+let root: Root
+let container: HTMLDivElement
+
+const offered: ResumeCandidate[] = [
+  {
+    sessionId: 'a',
+    workspaceId: 'workspace',
+    agent: 'codex',
+    trigger: 'update',
+    latestPrompt: 'Prompt a',
+    recordedAt: 1_800_000_000_000,
+    executionHostId: 'local',
+    workspaceKind: 'git-worktree'
+  }
+]
+
+function crash(id: string): CrashReportRecord {
+  return {
+    id,
+    createdAt: '2026-10-05T00:00:00.000Z',
+    status: 'pending',
+    source: 'renderer',
+    processType: 'renderer',
+    reason: 'crashed',
+    exitCode: 5,
+    appVersion: '1.0.0',
+    platform: 'darwin',
+    osRelease: 'test',
+    arch: 'arm64',
+    electronVersion: '1',
+    chromeVersion: '1',
+    details: {}
+  }
+}
+
+const crashReports = {
+  getLatestPending: vi.fn(async (): Promise<CrashReportRecord | null> => null),
+  getLatestReport: vi.fn(async (): Promise<CrashReportRecord | null> => null),
+  dismiss: vi.fn(async () => undefined)
+}
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 6; i += 1) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0))
+    })
+  }
+}
+
+async function mount(node: React.ReactNode): Promise<void> {
+  await act(async () => root.render(<TooltipProvider>{node}</TooltipProvider>))
+  await flush()
+}
+
+/** What is on screen, top dialog last. */
+function onScreen(): string[] {
+  return [...document.querySelectorAll('[role="dialog"]')].map((dialog) => {
+    const text = dialog.textContent ?? ''
+    if (text.includes('Resume interrupted chats?')) {
+      return 'resume'
+    }
+    if (dialog.getAttribute('data-testid') === 'crash-report') {
+      return `crash:${dialog.getAttribute('data-report')}`
+    }
+    if (dialog.getAttribute('data-testid') === 'feature-tip') {
+      return 'tip'
+    }
+    if (text.includes('SSH Key Passphrase')) {
+      return 'ssh'
+    }
+    return dialog.querySelector('[data-slot="dialog-title"]')?.textContent ?? text
+  })
+}
+
+function click(label: string): void {
+  const found = [...document.querySelectorAll('button')].find(
+    (button) => button.textContent?.trim() === label
+  )
+  if (!found) {
+    throw new Error(`Missing button: ${label}`)
+  }
+  act(() => found.click())
+}
+
+function closeTop(): void {
+  act(() => {
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }))
+  })
+}
+
+/** A modal-slot dialog as the app hosts it. */
+function UserModal(): React.JSX.Element {
+  const open = useAppStore((s) => s.activeModal === 'add-repo')
+  return (
+    <Dialog open={open}>
+      <DialogContent>
+        <DialogTitle>Add project</DialogTitle>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+/** SSH is counted only when its content commits. */
+function SshHost(): React.JSX.Element | null {
+  const asked = useAppStore((s) => s.sshCredentialQueue.length > 0)
+  return asked ? <SshPassphraseDialog /> : null
+}
+
+function Toggle({ children }: { children: React.ReactNode }): React.JSX.Element | null {
+  const [shown, setShown] = useState(true)
+  useEffect(() => {
+    toggleOff = () => setShown(false)
+  }, [])
+  return shown ? <>{children}</> : null
+}
+let toggleOff: () => void = () => {}
+
+function settleTip(answer: 'none' | 'unavailable' = 'none'): void {
+  act(() => useDialogRegistry.getState().settleStartupSource('feature-tip', answer))
+}
+
+/** The startup decision is owned above the lazy tip surface. */
+function DecidedTip(): React.JSX.Element {
+  useLayoutEffect(() => {
+    useDialogRegistry
+      .getState()
+      .settleStartupSource('feature-tip', 'ready', APP_OPEN_FEATURE_TIP_TOKEN)
+  }, [])
+  return <AppOpenFeatureTip tipId="orca-cli" />
+}
+
+function raiseSsh(): void {
+  act(() =>
+    useAppStore.getState().enqueueSshCredentialRequest({
+      requestId: 'r1',
+      targetId: 'host',
+      kind: 'passphrase',
+      detail: '~/.ssh/id_ed25519'
+    })
+  )
+}
+
+const everything = (
+  <>
+    <CrashReportDialog />
+    <DecidedTip />
+    <NativeChatResumeOnRestartModal />
+  </>
+)
+
+beforeEach(() => {
+  rpc.mockReset()
+  rpc.mockResolvedValue({ sessions: offered })
+  crashReports.getLatestPending.mockReset().mockResolvedValue(null)
+  crashReports.getLatestReport.mockReset().mockResolvedValue(null)
+  crashReports.dismiss.mockReset().mockResolvedValue(undefined)
+  _resetNativeChatRestartOffer()
+  _resetNativeChatResumeOnRestartDialog()
+  resetLocalStructuredChatsForTests()
+  resetDialogRegistryForTests()
+  surface.suspended = false
+  surface.error = false
+  boundaryReports.length = 0
+  useAppStore.setState(useAppStore.getInitialState(), true)
+  useAppStore.setState({
+    settings: { ...getDefaultSettings(''), experimentalStructuredNativeChat: true }
+  })
+  Object.assign(window, {
+    api: {
+      crashReports,
+      ui: { onOpenCrashReport: () => () => {}, set: vi.fn(async () => undefined) },
+      ssh: { submitCredential: vi.fn(async () => undefined) },
+      gh: { viewer: vi.fn(async () => null) },
+      app: {
+        holdsStructuredAgentSessions: vi.fn(async () => false),
+        onStructuredAgentSessionsHeldChanged: () => () => {}
+      }
+    }
+  })
+  container = document.createElement('div')
+  document.body.append(container)
+  root = createRoot(container)
+})
+
+afterEach(() => {
+  act(() => root.unmount())
+  container.remove()
+  useAppStore.setState(useAppStore.getInitialState(), true)
+  _resetNativeChatRestartOffer()
+  _resetNativeChatResumeOnRestartDialog()
+})
+
+it('shows the crash report, then the tip, then the resume offer, one at a time', async () => {
+  crashReports.getLatestPending.mockResolvedValue(crash('c1'))
+  await mount(everything)
+  expect(onScreen()).toEqual(['crash:c1'])
+  click('Close crash report')
+  await flush()
+  expect(onScreen()).toEqual(['tip'])
+  click('Close tip')
+  await flush()
+  expect(onScreen()).toEqual(['resume'])
+})
+
+it('a fast resume read waits for a slow crash check, whose report goes first', async () => {
+  const pending = Promise.withResolvers<CrashReportRecord | null>()
+  crashReports.getLatestPending.mockReturnValue(pending.promise)
+  settleTip()
+  await mount(
+    <>
+      <CrashReportDialog />
+      <NativeChatResumeOnRestartModal />
+    </>
+  )
+  expect(onScreen()).toEqual([])
+  await act(async () => pending.resolve(crash('c1')))
+  await flush()
+  expect(onScreen()).toEqual(['crash:c1'])
+  click('Close crash report')
+  await flush()
+  expect(onScreen()).toEqual(['resume'])
+})
+
+it('a fast resume read waits for the tip check, then shows once it has answered', async () => {
+  await mount(
+    <>
+      <CrashReportDialog />
+      <NativeChatResumeOnRestartModal />
+    </>
+  )
+  expect(onScreen()).toEqual([])
+  settleTip()
+  await flush()
+  expect(onScreen()).toEqual(['resume'])
+})
+
+it('a crash check that fails answers unavailable, so later dialogs still show', async () => {
+  crashReports.getLatestPending.mockRejectedValue(new Error('ipc down'))
+  const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+  await mount(everything)
+  expect(useDialogRegistry.getState().startupSources['crash-report']).toBe('unavailable')
+  expect(onScreen()).toEqual(['tip'])
+  consoleError.mockRestore()
+})
+
+it('each crash report takes its own turn, and the same report shows once', async () => {
+  settleTip()
+  await mount(<CrashReportDialog />)
+  act(() => {
+    boundaryReports.push(crash('b1'), crash('b2'))
+    window.dispatchEvent(new Event('test-boundary-report'))
+  })
+  await flush()
+  expect(onScreen()).toEqual(['crash:b1'])
+  act(() => {
+    boundaryReports.push(crash('b1'))
+    window.dispatchEvent(new Event('test-boundary-report'))
+  })
+  await flush()
+  click('Close crash report')
+  await flush()
+  expect(onScreen()).toEqual(['crash:b2'])
+  click('Close crash report')
+  await flush()
+  expect(onScreen()).toEqual([])
+  act(() => {
+    boundaryReports.push(crash('b1'))
+    window.dispatchEvent(new Event('test-boundary-report'))
+  })
+  await flush()
+  expect(onScreen()).toEqual([])
+})
+
+it.each([
+  ['crash:c1', 'tip'],
+  ['tip', 'resume'],
+  ['resume', null]
+] as const)(
+  'a user dialog stacks over a shown %s, which stays as it was; the next waits for both',
+  async (shown, next) => {
+    crashReports.getLatestPending.mockResolvedValue(shown === 'crash:c1' ? crash('c1') : null)
+    await mount(
+      <>
+        {shown === 'resume' ? null : <DecidedTip />}
+        <CrashReportDialog />
+        <NativeChatResumeOnRestartModal />
+        <UserModal />
+      </>
+    )
+    if (shown === 'resume') {
+      settleTip()
+      await flush()
+    }
+    expect(onScreen()).toEqual([shown])
+    const element = document.querySelector('[role="dialog"]')
+    act(() => useAppStore.getState().openModal('add-repo'))
+    await flush()
+    expect(onScreen()).toEqual([shown, 'Add project'])
+    expect(document.querySelector('[role="dialog"]')).toBe(element)
+
+    act(() => useAppStore.getState().closeModal())
+    await flush()
+    expect(onScreen()).toEqual([shown])
+    expect(document.querySelector('[role="dialog"]')).toBe(element)
+    closeTop()
+    await flush()
+    expect(onScreen()).toEqual(next ? [next] : [])
+  }
+)
+
+it('an SSH prompt shows at once, before any startup check has answered', async () => {
+  crashReports.getLatestPending.mockReturnValue(new Promise(() => {}))
+  await mount(
+    <>
+      {everything}
+      <SshHost />
+    </>
+  )
+  raiseSsh()
+  await flush()
+  expect(onScreen()).toEqual(['ssh'])
+})
+
+it('an SSH prompt stacks over a shown resume offer, which stays as it was', async () => {
+  settleTip()
+  await mount(
+    <>
+      <CrashReportDialog />
+      <NativeChatResumeOnRestartModal />
+      <SshHost />
+    </>
+  )
+  const offer = document.querySelector('[role="dialog"]')
+  raiseSsh()
+  await flush()
+  expect(onScreen()).toEqual(['resume', 'ssh'])
+  await act(async () => useAppStore.getState().removeSshCredentialRequest('r1'))
+  await flush()
+  expect(onScreen()).toEqual(['resume'])
+  expect(document.querySelector('[role="dialog"]')).toBe(offer)
+})
+
+it('an owner going away withdraws its dialog, and the next one shows', async () => {
+  crashReports.getLatestPending.mockResolvedValue(crash('c1'))
+  settleTip()
+  await mount(
+    <>
+      <Toggle>
+        <CrashReportDialog />
+      </Toggle>
+      <NativeChatResumeOnRestartModal />
+    </>
+  )
+  expect(onScreen()).toEqual(['crash:c1'])
+  act(() => toggleOff())
+  await flush()
+  expect(onScreen()).toEqual(['resume'])
+})
+
+it('a modal that fails to render ends only its own entry', async () => {
+  const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+  const Thrower = (): null => {
+    throw new Error('composer render bug')
+  }
+  const [other, setOther] = [{ open: true }, (open: boolean) => (other.open = open)]
+  function OtherDialog(): React.JSX.Element {
+    const [open, setOpen] = useState(other.open)
+    useEffect(() => {
+      closeOther = () => {
+        setOther(false)
+        setOpen(false)
+      }
+    }, [])
+    return (
+      <Dialog open={open}>
+        <DialogContent>
+          <DialogTitle>Other</DialogTitle>
+        </DialogContent>
+      </Dialog>
+    )
+  }
+  settleTip()
+  act(() => useAppStore.getState().openModal('new-workspace-composer'))
+  crashReports.getLatestPending.mockResolvedValue(crash('c1'))
+  await mount(
+    <>
+      <RecoverableRenderErrorBoundary boundaryId="modal.composer" surface="modal" compact>
+        <Thrower />
+      </RecoverableRenderErrorBoundary>
+      <OtherDialog />
+      <CrashReportDialog />
+    </>
+  )
+  // The failed modal's entry is gone, while the slot is still set; the other dialog still holds.
+  expect(useAppStore.getState().activeModal).toBe('new-workspace-composer')
+  expect(onScreen()).toEqual(['Other'])
+  act(() => closeOther())
+  await flush()
+  expect(onScreen()).toEqual(['crash:c1'])
+  consoleError.mockRestore()
+})
+let closeOther: () => void = () => {}
+
+it('the user opening the resume offer shows it at once, and the launch offer never repeats it', async () => {
+  crashReports.getLatestPending.mockResolvedValue(crash('c1'))
+  rpc.mockResolvedValue({ sessions: [] })
+  settleTip()
+  await mount(
+    <>
+      <CrashReportDialog />
+      <NativeChatResumeOnRestartModal />
+    </>
+  )
+  expect(onScreen()).toEqual(['crash:c1'])
+  rpc.mockResolvedValue({ sessions: offered })
+  await act(async () => {
+    // As the status bar does: re-read, then ask.
+    await import('../components/native-chat-resume-on-restart-store').then((store) =>
+      store.refreshNativeChatRestartOffer()
+    )
+    requestNativeChatResumeOnRestartDialog('user')
+  })
+  await flush()
+  expect(onScreen()).toEqual(['crash:c1', 'resume'])
+  closeTop()
+  await flush()
+  act(() => requestNativeChatResumeOnRestartDialog('launch'))
+  await flush()
+  click('Close crash report')
+  await flush()
+  // The user has already seen and closed it; the launch's own ask does not bring it back.
+  expect(onScreen()).toEqual([])
+})
+
+it('a tip decided while a user modal is up keeps its place ahead of a queued resume offer', async () => {
+  act(() => useAppStore.getState().openModal('add-repo'))
+  await mount(
+    <>
+      <CrashReportDialog />
+      <NativeChatResumeOnRestartModal />
+      <UserModal />
+    </>
+  )
+  // The resume offer is read and queued; the tip is decided after it.
+  await mount(
+    <>
+      <CrashReportDialog />
+      <NativeChatResumeOnRestartModal />
+      <UserModal />
+      <DecidedTip />
+    </>
+  )
+  expect(onScreen()).toEqual(['Add project'])
+  act(() => useAppStore.getState().closeModal())
+  await flush()
+  expect(onScreen()).toEqual(['tip'])
+  click('Close tip')
+  await flush()
+  expect(onScreen()).toEqual(['resume'])
+})
+
+it('acknowledges a launch crash report only once its content is on screen', async () => {
+  const load = Promise.withResolvers<void>()
+  surface.loaded = load.promise
+  surface.suspended = true
+  crashReports.getLatestPending.mockResolvedValue(crash('c1'))
+  await mount(<CrashReportDialog />)
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([
+    expect.objectContaining({ token: 'crash-report:c1' })
+  ])
+  expect(selectDialogPhase(useDialogRegistry.getState(), 'crash-report:c1')).toBe('opening')
+  expect(crashReports.dismiss).not.toHaveBeenCalled()
+  surface.suspended = false
+  await act(async () => load.resolve())
+  await flush()
+  expect(onScreen()).toEqual(['crash:c1'])
+  expect(crashReports.dismiss).toHaveBeenCalledWith({ reportId: 'c1' })
+})
+
+it('marks the tip seen only once it is on screen', async () => {
+  const markFeatureTipsSeen = vi.fn()
+  useAppStore.setState({ markFeatureTipsSeen })
+  act(() => useAppStore.getState().openModal('add-repo'))
+  await mount(
+    <>
+      <CrashReportDialog />
+      <UserModal />
+      <DecidedTip />
+    </>
+  )
+  expect(markFeatureTipsSeen).not.toHaveBeenCalled()
+  act(() => useAppStore.getState().closeModal())
+  await flush()
+  expect(onScreen()).toEqual(['tip'])
+  expect(markFeatureTipsSeen).toHaveBeenCalledWith(['orca-cli'])
+})
+
+it.each(['user modal', 'SSH prompt'] as const)(
+  'a %s opened while an admitted crash report is still loading stays on top; the report waits for it',
+  async (opened) => {
+    const load = Promise.withResolvers<void>()
+    surface.loaded = load.promise
+    surface.suspended = true
+    settleTip()
+    crashReports.getLatestPending.mockResolvedValue(crash('c1'))
+    await mount(
+      <>
+        <CrashReportDialog />
+        <UserModal />
+        <SshHost />
+      </>
+    )
+    expect(onScreen()).toEqual([])
+    if (opened === 'user modal') {
+      act(() => useAppStore.getState().openModal('add-repo'))
+    } else {
+      raiseSsh()
+    }
+    await flush()
+    surface.suspended = false
+    await act(async () => load.resolve())
+    await flush()
+    const top = opened === 'user modal' ? 'Add project' : 'ssh'
+    expect(onScreen()).toEqual([top])
+    expect(document.querySelector('[data-testid="crash-report"]')).toBeNull()
+
+    if (opened === 'user modal') {
+      act(() => useAppStore.getState().closeModal())
+    } else {
+      await act(async () => useAppStore.getState().removeSshCredentialRequest('r1'))
+    }
+    await flush()
+    expect(onScreen()).toEqual(['crash:c1'])
+  }
+)
+
+it('in StrictMode (dev builds) a tip decided after the resume offer was queued still goes first', async () => {
+  act(() => useDialogRegistry.getState().settleStartupSource('crash-report', 'none'))
+  await mount(
+    <StrictMode>
+      <NativeChatResumeOnRestartModal />
+    </StrictMode>
+  )
+  expect(onScreen()).toEqual([])
+  await mount(
+    <StrictMode>
+      <NativeChatResumeOnRestartModal />
+      <DecidedTip />
+    </StrictMode>
+  )
+  expect(onScreen()).toEqual(['tip'])
+  click('Close tip')
+  await flush()
+  expect(onScreen()).toEqual(['resume'])
+})
+
+it('a never-answering crash read releases the startup order and ignores its late answer', async () => {
+  const pending = Promise.withResolvers<CrashReportRecord | null>()
+  crashReports.getLatestPending.mockReturnValue(pending.promise)
+  settleTip()
+  vi.useFakeTimers()
+  try {
+    await act(async () => root.render(<CrashReportDialog />))
+    await act(async () => vi.advanceTimersByTimeAsync(STARTUP_DISCOVERY_READ_TIMEOUT_MS))
+    expect(useDialogRegistry.getState().startupSources['crash-report']).toBe('unavailable')
+    await act(async () => pending.resolve(crash('late')))
+    expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+    expect(crashReports.dismiss).not.toHaveBeenCalled()
+  } finally {
+    vi.useRealTimers()
+  }
+})
+
+it('failed automatic content releases only its own token, leaving another dialog untouched', async () => {
+  const silent = vi.spyOn(console, 'error').mockImplementation(() => {})
+  const load = Promise.withResolvers<void>()
+  surface.loaded = load.promise
+  surface.suspended = true
+  settleTip()
+  crashReports.getLatestPending.mockResolvedValue(crash('broken'))
+  await mount(
+    <>
+      <CrashReportDialog />
+      <UserModal />
+    </>
+  )
+  surface.suspended = false
+  surface.error = true
+  await act(async () => load.resolve())
+  await flush()
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+  expect(crashReports.dismiss).not.toHaveBeenCalled()
+  act(() => useAppStore.getState().openModal('add-repo'))
+  await flush()
+  expect(onScreen()).toEqual(['Add project'])
+  expect(useDialogRegistry.getState().dialogEntries).toHaveLength(1)
+  silent.mockRestore()
+})
+
+it.each(['settings unavailable', 'held read hung', 'offer read hung'] as const)(
+  'the resume startup discovery ends when %s, without delaying earlier kinds',
+  async (failure) => {
+    if (failure !== 'offer read hung') {
+      useAppStore.setState({
+        settings: failure === 'settings unavailable' ? null : getDefaultSettings(''),
+        persistedUIReady: true
+      })
+    }
+    window.api.app.holdsStructuredAgentSessions = () => new Promise(() => {})
+    rpc.mockReturnValue(new Promise(() => {}))
+    vi.useFakeTimers()
+    try {
+      await act(async () => root.render(<NativeChatResumeOnRestartModal />))
+      await act(async () => vi.advanceTimersByTimeAsync(STARTUP_DISCOVERY_READ_TIMEOUT_MS))
+      expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe('unavailable')
+    } finally {
+      vi.useRealTimers()
+    }
+  }
+)
+
+function OfferDataSubscriber(): null {
+  useNativeChatRestartOffer(true)
+  return null
+}
+
+it.each([false, true])(
+  'a held runtime keeps the owner recovery read enabled with missing settings and hydration %s',
+  async (persistedUIReady) => {
+    useAppStore.setState({ settings: null, persistedUIReady })
+    window.api.app.holdsStructuredAgentSessions = async () => true
+    act(() => useDialogRegistry.getState().settleStartupSource('crash-report', 'none'))
+    settleTip()
+    await mount(<NativeChatResumeOnRestartModal />)
+    expect(rpc).toHaveBeenCalledTimes(1)
+    expect(getNativeChatRestartOffer().candidates).toEqual(offered)
+    expect(onScreen()).toEqual(['resume'])
+    expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe(
+      persistedUIReady ? 'unavailable' : 'pending'
+    )
+  }
+)
+
+it('an ordinary offer subscriber cannot answer or abandon startup discovery', async () => {
+  const read = Promise.withResolvers<{ sessions: ResumeCandidate[] }>()
+  rpc.mockReturnValue(read.promise)
+  await mount(<OfferDataSubscriber />)
+  await act(async () => root.render(null))
+  expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe('pending')
+  await act(async () => read.resolve({ sessions: offered }))
+  expect(getNativeChatRestartOffer().candidates).toEqual(offered)
+  expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe('pending')
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+})
+
+it('losing the resume owner abandons discovery while its data subscriber keeps recovery', async () => {
+  const read = Promise.withResolvers<{ sessions: ResumeCandidate[] }>()
+  rpc.mockReturnValue(read.promise)
+  await mount(
+    <>
+      <Toggle>
+        <NativeChatResumeOnRestartModal />
+      </Toggle>
+      <OfferDataSubscriber />
+    </>
+  )
+  act(() => toggleOff())
+  await flush()
+  expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe('unavailable')
+  await act(async () => read.resolve({ sessions: offered }))
+  await flush()
+  expect(getNativeChatRestartOffer().candidates).toEqual(offered)
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+})
+
+it.each([false, true])('a disabled offer waits for an actual held answer of %s', async (holds) => {
+  const held = Promise.withResolvers<boolean>()
+  useAppStore.setState({ settings: getDefaultSettings('') })
+  window.api.app.holdsStructuredAgentSessions = () => held.promise
+  await mount(<NativeChatResumeOnRestartModal />)
+  expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe('pending')
+  expect(rpc).not.toHaveBeenCalled()
+  const answers: string[][] = []
+  const unsubscribe = useDialogRegistry.subscribe((state) => {
+    if (state.startupSources['native-chat-resume'] === 'ready') {
+      answers.push(state.dialogEntries.map((entry) => entry.token))
+    }
+  })
+  await act(async () => held.resolve(holds))
+  await flush()
+  unsubscribe()
+  expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe(
+    holds ? 'ready' : 'none'
+  )
+  expect(rpc).toHaveBeenCalledTimes(holds ? 1 : 0)
+  if (holds) {
+    expect(answers.length).toBeGreaterThan(0)
+    expect(answers.every((tokens) => tokens.includes('native-chat-resume'))).toBe(true)
+  }
+})
+
+it('an offer arriving after the discovery deadline still recovers and can be shown', async () => {
+  const read = Promise.withResolvers<{ sessions: ResumeCandidate[] }>()
+  rpc.mockReturnValue(read.promise)
+  act(() => useDialogRegistry.getState().settleStartupSource('crash-report', 'none'))
+  settleTip()
+  vi.useFakeTimers()
+  try {
+    await act(async () =>
+      root.render(
+        <TooltipProvider>
+          <NativeChatResumeOnRestartModal />
+        </TooltipProvider>
+      )
+    )
+    await act(async () => vi.advanceTimersByTimeAsync(STARTUP_DISCOVERY_READ_TIMEOUT_MS))
+    expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe('unavailable')
+    await act(async () => read.resolve({ sessions: offered }))
+    expect(getNativeChatRestartOffer().candidates).toEqual(offered)
+    expect(onScreen()).toEqual(['resume'])
+    expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe('unavailable')
+  } finally {
+    vi.useRealTimers()
+  }
+})
+
+it('a failed launch acknowledgement is attempted once in StrictMode and never belongs to runtime reports', async () => {
+  const silent = vi.spyOn(console, 'error').mockImplementation(() => {})
+  crashReports.getLatestPending.mockResolvedValue(crash('launch'))
+  crashReports.dismiss.mockRejectedValue(new Error('write failed'))
+  boundaryReports.push(crash('runtime'))
+  try {
+    await mount(
+      <StrictMode>
+        <CrashReportDialog />
+      </StrictMode>
+    )
+    expect(onScreen()).toEqual(['crash:runtime'])
+    expect(crashReports.dismiss).not.toHaveBeenCalled()
+    click('Close crash report')
+    await flush()
+    expect(onScreen()).toEqual(['crash:launch'])
+    expect(crashReports.dismiss).toHaveBeenCalledExactlyOnceWith({ reportId: 'launch' })
+    click('Close crash report')
+    await flush()
+    expect(onScreen()).toEqual([])
+    expect(crashReports.dismiss).toHaveBeenCalledTimes(1)
+  } finally {
+    silent.mockRestore()
+  }
+})
diff --git a/src/renderer/src/app-shell/startup-tip-check.test.tsx b/src/renderer/src/app-shell/startup-tip-check.test.tsx
new file mode 100644
index 000000000000..ec0eaa7728ef
--- /dev/null
+++ b/src/renderer/src/app-shell/startup-tip-check.test.tsx
@@ -0,0 +1,274 @@
+import type * as DegradedRecovery from '../startup/startup-degraded-recovery'
+import { STARTUP_DISCOVERY_READ_TIMEOUT_MS } from '../startup/startup-discovery-read'
+// @vitest-environment happy-dom
+
+import { act, useEffect } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { resetDialogRegistryForTests } from '@/store/dialog-registry-test-state'
+import { APP_OPEN_FEATURE_TIP_TOKEN } from '../components/feature-tips/feature-tip-startup-gate'
+import { getDefaultSettings } from '../../../shared/constants'
+import type { OnboardingState } from '../../../shared/onboarding-state-types'
+import { getDefaultOnboardingState } from '../../../shared/onboarding-defaults'
+import { useAppStartupHydration } from './use-app-startup-hydration'
+import { useOnboardingAndFeatureTips, type OnboardingGate } from './use-onboarding-and-feature-tips'
+
+const startup = vi.hoisted(() => {
+  const fetchSettings = vi.fn(async () => {})
+  return {
+    fetchSettings,
+    recover: vi.fn<typeof DegradedRecovery.recoverFromDegradedStartup>(async () => {}),
+    // Stable, as the real selector's: a new identity would restart the chain.
+    actions: {
+      fetchOrcaProfiles: vi.fn(async () => {}),
+      fetchSettings,
+      fetchKeybindings: vi.fn(async () => {}),
+      hydratePersistedUI: vi.fn(),
+      initGitHubCache: vi.fn(async () => {})
+    }
+  }
+})
+vi.mock('./use-app-startup-actions', () => ({ useStartupActions: () => startup.actions }))
+vi.mock('../startup/startup-degraded-recovery', () => ({
+  recoverFromDegradedStartup: startup.recover
+}))
+vi.mock('../runtime/local-runtime-capabilities', () => ({
+  ensureLocalRuntimeCapabilities: vi.fn(async () => {})
+}))
+vi.mock('@/components/terminal-pane/codex-detached-pane-restart-scheduler', () => ({
+  installCodexDetachedPaneRestartExecutor: () => () => {}
+}))
+vi.mock('../components/terminal-pane/terminal-appearance', () => ({
+  publishTerminalViewAttributesAtAppStart: vi.fn()
+}))
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+let root: Root
+let container: HTMLDivElement
+
+const existingUser: OnboardingState = {
+  ...getDefaultOnboardingState(),
+  closedAt: 1,
+  outcome: 'completed'
+}
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 6; i += 1) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0))
+    })
+  }
+}
+
+/** Startup as App wires it: the gate, then the chain feeding it. */
+function App({ onGate }: { onGate: (gate: OnboardingGate) => void }): null {
+  const gate = useOnboardingAndFeatureTips()
+  useEffect(() => {
+    onGate(gate)
+  }, [gate, onGate])
+  useAppStartupHydration(gate.applyStartupOnboardingState, gate.applyStartupTipCheckInputs)
+  return null
+}
+
+let gate: OnboardingGate | null = null
+const onboardingRead = { get: vi.fn(async (): Promise<OnboardingState> => existingUser) }
+
+beforeEach(() => {
+  gate = null
+  resetDialogRegistryForTests()
+  startup.fetchSettings.mockReset().mockImplementation(async () => {
+    useAppStore.setState({ settings: getDefaultSettings('') })
+  })
+  startup.recover.mockReset().mockResolvedValue(undefined)
+  onboardingRead.get.mockReset().mockResolvedValue(existingUser)
+  useAppStore.setState(useAppStore.getInitialState(), true)
+  Object.assign(window, {
+    api: {
+      onboarding: onboardingRead,
+      // Startup stops here: everything after this read is out of scope.
+      ui: { get: () => new Promise(() => {}), set: vi.fn(async () => undefined) },
+      cli: { getInstallStatus: vi.fn(async () => ({ supported: false })) }
+    }
+  })
+  container = document.createElement('div')
+  document.body.append(container)
+  root = createRoot(container)
+})
+
+afterEach(() => {
+  act(() => root.unmount())
+  container.remove()
+})
+
+async function start(): Promise<void> {
+  await act(async () => root.render(<App onGate={(next) => (gate = next)} />))
+  await flush()
+}
+
+function tipCheck(): string {
+  return useDialogRegistry.getState().startupSources['feature-tip']
+}
+
+it('a failed settings read answers the tip check unavailable, so later dialogs do not wait', async () => {
+  // The real fetch swallows the failure and leaves settings unset.
+  startup.fetchSettings.mockResolvedValue(undefined)
+  await start()
+  expect(tipCheck()).toBe('unavailable')
+  expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe('unavailable')
+})
+
+it('a failed onboarding read answers the tip check unavailable', async () => {
+  onboardingRead.get.mockRejectedValue(new Error('ipc down'))
+  await start()
+  expect(tipCheck()).toBe('unavailable')
+})
+
+it('startup failing before onboarding is read answers the tip check unavailable', async () => {
+  startup.fetchSettings.mockRejectedValue(new Error('boom'))
+  await start()
+  expect(startup.recover).toHaveBeenCalledTimes(1)
+  expect(onboardingRead.get).not.toHaveBeenCalled()
+  expect(tipCheck()).toBe('unavailable')
+  expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe('unavailable')
+})
+
+it('the tip check has onboarding as soon as it is read, before startup shows onboarding', async () => {
+  await start()
+  // Startup has not delivered onboarding to the flow yet (it is parked at ui.get) ...
+  expect(gate?.onboarding).toBeNull()
+  // ... and the tip check waits only for its own remaining inputs.
+  expect(tipCheck()).toBe('pending')
+  act(() => useAppStore.setState({ persistedUIReady: true }))
+  await flush()
+  // The decision owner queues a tip with its answer before its host mounts.
+  expect(gate?.appOpenTipId).not.toBeNull()
+  expect(tipCheck()).toBe('ready')
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([
+    expect.objectContaining({ token: APP_OPEN_FEATURE_TIP_TOKEN })
+  ])
+})
+
+it('onboarding suppression remains terminal after onboarding finishes in the same session', async () => {
+  onboardingRead.get.mockResolvedValue(getDefaultOnboardingState())
+  await start()
+  act(() => useAppStore.setState({ persistedUIReady: true }))
+  await flush()
+  expect(tipCheck()).toBe('none')
+  act(() => gate?.applyStartupOnboardingState(existingUser))
+  await flush()
+  expect(tipCheck()).toBe('none')
+  expect(gate?.appOpenTipId).toBeNull()
+})
+
+it('losing a decided tip owner withdraws its candidate before the lazy host has mounted', async () => {
+  await start()
+  act(() => useAppStore.setState({ persistedUIReady: true }))
+  await flush()
+  expect(tipCheck()).toBe('ready')
+  await act(async () => root.render(null))
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+})
+
+it('late source failure cannot withdraw a tip that has already been decided', async () => {
+  await start()
+  act(() => useAppStore.setState({ persistedUIReady: true }))
+  await flush()
+  const tipId = gate?.appOpenTipId
+  act(() => gate?.applyStartupTipCheckInputs(null))
+  await flush()
+  expect(tipCheck()).toBe('ready')
+  expect(gate?.appOpenTipId).toBe(tipId)
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([
+    expect.objectContaining({ token: APP_OPEN_FEATURE_TIP_TOKEN })
+  ])
+})
+
+it('with every tip already seen it answers none without waiting for the CLI status', async () => {
+  const cliStatus = Promise.withResolvers<never>()
+  Object.assign(window.api.cli, { getInstallStatus: () => cliStatus.promise })
+  await start()
+  act(() =>
+    useAppStore.setState({
+      persistedUIReady: true,
+      featureTipsSeenIds: ['agent-session-search', 'orca-cli', 'cmd-j-palette', 'voice-dictation']
+    })
+  )
+  await flush()
+  expect(tipCheck()).toBe('none')
+})
+
+it('late onboarding must not open a tip after degraded startup answered unavailable', async () => {
+  const onboarding = Promise.withResolvers<OnboardingState>()
+  onboardingRead.get.mockReturnValue(onboarding.promise)
+  Object.assign(window.api.ui, {
+    get: vi.fn(async () => {
+      throw new Error('ui read unavailable')
+    })
+  })
+  const realRecovery = await vi.importActual<typeof DegradedRecovery>(
+    '../startup/startup-degraded-recovery'
+  )
+  startup.actions.hydratePersistedUI.mockImplementation((ui, source) => {
+    useAppStore.getState().hydratePersistedUI(ui, source)
+  })
+  startup.recover.mockImplementation(realRecovery.recoverFromDegradedStartup)
+  Object.assign(window.api, {
+    app: {
+      awaitFirstWindowStartupServices: vi.fn(async () => {}),
+      recoverLegacyWorkerTerminalsForRendererStartup: vi.fn(async () => {})
+    }
+  })
+  const silent = vi.spyOn(console, 'error').mockImplementation(() => {})
+  await start()
+  expect(startup.recover).toHaveBeenCalledTimes(1)
+  expect(tipCheck()).toBe('unavailable')
+  expect(gate?.appOpenTipId).toBeNull()
+  await act(async () => onboarding.resolve(existingUser))
+  await flush()
+  expect(tipCheck()).toBe('unavailable')
+  silent.mockRestore()
+  expect(gate?.appOpenTipId).toBeNull()
+})
+
+it.each(['settings', 'onboarding', 'ui', 'cli'] as const)(
+  'a never-answering %s read ends the tip discovery instead of holding later dialogs forever',
+  async (source) => {
+    vi.useFakeTimers()
+    try {
+      if (source === 'settings') {
+        startup.fetchSettings.mockReturnValue(new Promise(() => {}))
+      }
+      if (source === 'onboarding') {
+        onboardingRead.get.mockReturnValue(new Promise(() => {}))
+      }
+      if (source === 'cli') {
+        window.api.cli.getInstallStatus = () => new Promise(() => {})
+        useAppStore.setState({
+          persistedUIReady: true,
+          featureTipsSeenIds: ['agent-session-search']
+        })
+      }
+      await act(async () => root.render(<App onGate={(next) => (gate = next)} />))
+      expect(tipCheck()).toBe('pending')
+      await act(async () => vi.advanceTimersByTimeAsync(STARTUP_DISCOVERY_READ_TIMEOUT_MS))
+      expect(tipCheck()).toBe('unavailable')
+      expect(gate?.appOpenTipId).toBeNull()
+      if (source === 'settings') {
+        expect(useDialogRegistry.getState().startupSources['native-chat-resume']).toBe(
+          'unavailable'
+        )
+      }
+    } finally {
+      vi.useRealTimers()
+    }
+  }
+)
+
+it('losing the discovery owner answers unavailable', async () => {
+  await start()
+  expect(tipCheck()).toBe('pending')
+  await act(async () => root.render(null))
+  expect(tipCheck()).toBe('unavailable')
+})
diff --git a/src/renderer/src/app-shell/use-app-startup-hydration.ts b/src/renderer/src/app-shell/use-app-startup-hydration.ts
index 0c0ab0dd5436..0464c659f743 100644
--- a/src/renderer/src/app-shell/use-app-startup-hydration.ts
+++ b/src/renderer/src/app-shell/use-app-startup-hydration.ts
@@ -1,8 +1,10 @@
+import { readStartupDiscovery } from '../startup/startup-discovery-read'
 import { useEffect, useRef } from 'react'
 import { restoreLocalStructuredChatsAtStartup } from '@/runtime/local-structured-chats'
 import { syncZoomCSSVar } from '@/lib/ui-zoom'
 import { installCodexDetachedPaneRestartExecutor } from '@/components/terminal-pane/codex-detached-pane-restart-scheduler'
 import { useAppStore } from '../store'
+import { useDialogRegistry } from '../store/dialog-registry'
 import { reconcileHydratedWorkspaceTabModels } from './reconcile-hydrated-workspace-tab-models'
 import { useStartupActions } from './use-app-startup-actions'
 import { waitForNativeChatDraftsAtStartup } from './native-chat-draft-startup'
@@ -20,6 +22,7 @@ import {
   timeRendererStartupSyncStep
 } from '../startup/startup-diagnostics'
 import { recoverFromDegradedStartup } from '../startup/startup-degraded-recovery'
+import { refreshDeferredStartupCatalog } from '../startup/startup-deferred-catalog-refresh'
 import { restoreSshConnectionsForStartup } from '../startup/startup-ssh-connection-restore'
 import { collectActiveWorkspaceSshTargetIds } from '../startup/active-workspace-ssh-targets'
 import { publishTerminalViewAttributesAtAppStart } from '../components/terminal-pane/terminal-appearance'
@@ -31,39 +34,33 @@ import {
 import {
   getRepoExecutionHostId,
   isRuntimeOwnedSshTargetId,
-  parseExecutionHostId,
-  toRuntimeExecutionHostId,
-  type ExecutionHostId
+  parseExecutionHostId
 } from '../../../shared/execution-host'
 import { mapWithConcurrency } from '../../../shared/map-with-concurrency'
 import type { OnboardingState } from '../../../shared/onboarding-state-types'
 import { ensureLocalRuntimeCapabilities } from '../runtime/local-runtime-capabilities'
-
-async function listRuntimeSessionHostIdsForStartup(): Promise<ExecutionHostId[]> {
-  try {
-    return (await window.api.runtimeEnvironments.list()).map((environment) =>
-      toRuntimeExecutionHostId(environment.id)
-    )
-  } catch (err) {
-    console.warn('Failed to list runtime session hosts for startup:', err)
-    return []
-  }
-}
+import { listRuntimeSessionHostIdsForStartup } from '../startup/startup-runtime-session-hosts'
 
 /**
  * Runs the renderer's one-shot boot chain: settings, persisted UI, the local repo catalog,
  * the workspace session, SSH reconnect, and terminal restoration — then unlocks the session
  * writer. A failure anywhere leaves disk state untouched and boots in degraded no-save mode.
  */
-export function useAppStartupHydration(onOnboardingLoaded: (state: OnboardingState) => void): void {
+export function useAppStartupHydration(
+  onOnboardingLoaded: (state: OnboardingState) => void,
+  /** Once known: onboarding for the feature-tip check, or null when no tip can be decided. */
+  onTipCheckInputs: (onboarding: OnboardingState | null) => void
+): void {
   const actions = useStartupActions()
   // Why a ref: the boot chain must not restart if a caller passes a new callback identity.
   // Synced in an effect (declared before the chain below, so it lands first on mount) because
   // a render-phase write can leak from a render React discards.
   const onOnboardingLoadedRef = useRef(onOnboardingLoaded)
+  const onTipCheckInputsRef = useRef(onTipCheckInputs)
   useEffect(() => {
     onOnboardingLoadedRef.current = onOnboardingLoaded
-  }, [onOnboardingLoaded])
+    onTipCheckInputsRef.current = onTipCheckInputs
+  }, [onOnboardingLoaded, onTipCheckInputs])
 
   useEffect(() => installCodexDetachedPaneRestartExecutor(), [])
 
@@ -90,9 +87,16 @@ export function useAppStartupHydration(onOnboardingLoaded: (state: OnboardingSta
         // Why: nothing in the hydration chain reads profile state synchronously, so don't let it add a serial IPC round-trip before fetchSettings.
         void actions.fetchOrcaProfiles()
         // Why: publish local settings before persisted UI/catalog work; a saved remote owner's defaults can spend the full connect timeout.
-        await timeRendererStartupStep('fetch-settings', () =>
+        const settingsRead = timeRendererStartupStep('fetch-settings', () =>
           actions.fetchSettings({ deferOwnerWorktreeVisibilityDefaults: true })
         )
+        void readStartupDiscovery(settingsRead.then(() => true)).then((read) => {
+          if (!cancelled && (read === null || useAppStore.getState().settings === null)) {
+            onTipCheckInputsRef.current(null)
+            useDialogRegistry.getState().settleStartupSource('native-chat-resume', 'unavailable')
+          }
+        })
+        await settingsRead
         // Why: hidden-at-launch PTYs can query before any pane mounts; publish view attributes as soon as settings exist so every PTY owner answers from the composed theme.
         publishTerminalViewAttributesAtAppStart(
           useAppStore.getState().settings,
@@ -107,9 +111,21 @@ export function useAppStartupHydration(onOnboardingLoaded: (state: OnboardingSta
         const onboardingPromise = timeRendererStartupStep('onboarding-get', () =>
           window.api.onboarding.get()
         )
-        onboardingPromise.catch(() => {})
+        void readStartupDiscovery(onboardingPromise).then((onboarding) => {
+          if (!cancelled) {
+            onTipCheckInputsRef.current(
+              useAppStore.getState().settings === null ? null : onboarding
+            )
+          }
+        })
         // Why: await ui.get() (not overlap) so persisted view settings hydrate before the local catalog/session steps and first paint reflects them.
-        const persistedUI = await timeRendererStartupStep('ui-get', () => window.api.ui.get())
+        const uiRead = timeRendererStartupStep('ui-get', () => window.api.ui.get())
+        void readStartupDiscovery(uiRead).then((read) => {
+          if (read === null && !cancelled) {
+            onTipCheckInputsRef.current(null)
+          }
+        })
+        const persistedUI = await uiRead
         uiHydrated = timeRendererStartupSyncStep('hydrate-persisted-ui', () =>
           hydratePersistedUIAfterStartupRead({
             persistedUI,
@@ -309,44 +325,12 @@ export function useAppStartupHydration(onOnboardingLoaded: (state: OnboardingSta
           logRendererStartupDiagnostic('startup-hydration-done', {
             durationMs: Math.round(performance.now() - startupStartedAt)
           })
-          void (async () => {
-            try {
-              try {
-                // Why: remote rows must not render under a fallback visibility while their owner default is still loading.
-                await timeRendererStartupStep('owner-visibility-defaults', () =>
-                  actions.awaitOwnerWorktreeVisibilityDefaultsHydration()
-                )
-                await timeRendererStartupStep('remote-catalog-refresh', async () => {
-                  await actions.fetchReposForAllHosts()
-                  await actions.fetchProjectGroupsForAllHosts()
-                  await actions.fetchFolderWorkspacesForAllHosts()
-                })
-              } catch (err) {
-                console.warn('Remote startup catalog refresh failed:', err)
-              }
-              if (!cancelled) {
-                try {
-                  await timeRendererStartupStep('remote-worktree-refresh', async () => {
-                    // Why: the full scan is not required for session recovery, so keep it off the startup-critical path.
-                    await actions.fetchAllWorktrees()
-                    // Why: the startup prune only saw session-referenced repos; use the deferred scan's
-                    // authoritative results to drop deleted-worktree visit timestamps that would
-                    // otherwise accumulate unbounded (disconnected SSH stays non-authoritative and is kept).
-                    actions.pruneLastVisitedTimestamps()
-                    await actions.fetchWorktreeLineage()
-                  })
-                } catch (err) {
-                  console.warn('Deferred startup worktree refresh failed:', err)
-                }
-              }
-            } finally {
-              if (!cancelled) {
-                useAppStore.setState({ startupWorktreeRefreshCompleted: true })
-              }
-            }
-          })()
+          void refreshDeferredStartupCatalog(actions, () => cancelled)
         }
       } catch (error) {
+        if (!cancelled && useAppStore.getState().settings === null) {
+          useDialogRegistry.getState().settleStartupSource('native-chat-resume', 'unavailable')
+        }
         await recoverFromDegradedStartup({
           error,
           uiHydrated,
@@ -356,6 +340,10 @@ export function useAppStartupHydration(onOnboardingLoaded: (state: OnboardingSta
           reconnectPersistedTerminals: actions.reconnectPersistedTerminals,
           abortSignal: abortController.signal
         })
+        // Startup failed, possibly before onboarding was read: a tip check still open never answers.
+        if (!cancelled) {
+          onTipCheckInputsRef.current(null)
+        }
       }
       void actions.initGitHubCache()
     })()
diff --git a/src/renderer/src/app-shell/use-onboarding-and-feature-tips.ts b/src/renderer/src/app-shell/use-onboarding-and-feature-tips.ts
index a170bcce16f7..39f47ca66842 100644
--- a/src/renderer/src/app-shell/use-onboarding-and-feature-tips.ts
+++ b/src/renderer/src/app-shell/use-onboarding-and-feature-tips.ts
@@ -1,21 +1,27 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
-import { useShallow } from 'zustand/react/shallow'
+import { useCallback, useEffect, useLayoutEffect, useState } from 'react'
+import { readStartupDiscovery } from '../startup/startup-discovery-read'
+import { useDialogDisposal } from '../lib/dialog-registry-entry'
 import { onOnboardingReopened } from '../components/onboarding/show-onboarding-event'
 import { shouldShowOnboarding } from '../components/onboarding/should-show-onboarding'
 import {
+  APP_OPEN_FEATURE_TIP_TOKEN,
   getFeatureTipsAppOpenDecision,
   isCliFeatureTipCompleted
 } from '../components/feature-tips/feature-tip-startup-gate'
-import {
-  trackCmdJPaletteFeatureTipShown,
-  trackOrcaCliFeatureTipShown
-} from '../components/feature-tips/feature-tip-telemetry'
 import { useAppStore } from '../store'
+import { useDialogRegistry } from '../store/dialog-registry'
 import { isWebClientLocation } from '../lib/web-client-location'
 import type { OnboardingState } from '../../../shared/onboarding-state-types'
+import type { FeatureTipId } from '../../../shared/feature-tips'
 
 export type OnboardingGate = ReturnType<typeof useOnboardingAndFeatureTips>
 
+function disposeTip(): void {
+  const registry = useDialogRegistry.getState()
+  registry.endDialog(APP_OPEN_FEATURE_TIP_TOKEN)
+  registry.settleStartupSource('feature-tip', 'unavailable')
+}
+
 /**
  * Owns first-run education: the onboarding flow's visibility plus the one-per-session
  * feature-tip prompt, which stays suppressed until onboarding's state is known.
@@ -24,22 +30,24 @@ export function useOnboardingAndFeatureTips() {
   const [onboarding, setOnboarding] = useState<OnboardingState | null>(null)
   const [onboardingLoaded, setOnboardingLoaded] = useState(false)
   const [featureTipCliInstalled, setFeatureTipCliInstalled] = useState<boolean | null>(null)
-  const promptedThisSessionRef = useRef(false)
-  const suppressedByOnboardingThisSessionRef = useRef(false)
+  const [appOpenTipId, setAppOpenTipId] = useState<FeatureTipId | null>(null)
+  // Read early by startup for the tip check, before startup shows onboarding itself.
+  const [tipCheckOnboarding, setTipCheckOnboarding] = useState<OnboardingState | null>(null)
+
+  const tipSource = useDialogRegistry((s) => s.startupSources['feature-tip'])
+  const abandonTip = useCallback(() => {
+    useDialogRegistry.getState().settleStartupSource('feature-tip', 'unavailable')
+  }, [])
+  useDialogDisposal(APP_OPEN_FEATURE_TIP_TOKEN, disposeTip)
 
-  const activeModal = useAppStore((s) => s.activeModal)
   const settings = useAppStore((s) => s.settings)
   const persistedUIReady = useAppStore((s) => s.persistedUIReady)
   const featureTipsSeenIds = useAppStore((s) => s.featureTipsSeenIds)
   const featureInteractions = useAppStore((s) => s.featureInteractions)
   const contextualToursAutoEligible = useAppStore((s) => s.contextualToursAutoEligible)
-  const actions = useAppStore(
-    useShallow((s) => ({
-      openModal: s.openModal,
-      markFeatureTipsSeen: s.markFeatureTipsSeen,
-      setContextualToursAutoEligible: s.setContextualToursAutoEligible,
-      setContextualToursOnboardingVisible: s.setContextualToursOnboardingVisible
-    }))
+  const setContextualToursAutoEligible = useAppStore((s) => s.setContextualToursAutoEligible)
+  const setContextualToursAwaitingOnboarding = useAppStore(
+    (s) => s.setContextualToursAwaitingOnboarding
   )
 
   const applyStartupOnboardingState = useCallback((state: OnboardingState): void => {
@@ -47,23 +55,40 @@ export function useOnboardingAndFeatureTips() {
     setOnboardingLoaded(true)
   }, [])
 
+  const applyStartupTipCheckInputs = useCallback((state: OnboardingState | null): void => {
+    if (useDialogRegistry.getState().startupSources['feature-tip'] !== 'pending') {
+      return
+    }
+    if (state === null) {
+      // Settings or onboarding could not be read: no tip this launch, and nothing waits on one.
+      useDialogRegistry.getState().settleStartupSource('feature-tip', 'unavailable')
+      return
+    }
+    setTipCheckOnboarding(state)
+  }, [])
+
   useEffect(() => {
     return onOnboardingReopened(setOnboarding)
   }, [])
 
-  useEffect(() => {
-    // Why: suppress tours until onboarding state is known (null = loading) so a first-run user can't mark a tour seen before onboarding appears.
-    const suppressTours = !onboardingLoaded || shouldShowOnboarding(onboarding)
-    actions.setContextualToursOnboardingVisible(suppressTours)
-  }, [actions, onboarding, onboardingLoaded])
+  useLayoutEffect(() => {
+    // First-run policy applies before lazy onboarding has any committed content.
+    setContextualToursAwaitingOnboarding(!onboardingLoaded || shouldShowOnboarding(onboarding))
+  }, [onboarding, onboardingLoaded, setContextualToursAwaitingOnboarding])
 
   useEffect(() => {
     if (!persistedUIReady || !onboardingLoaded || contextualToursAutoEligible !== null) {
       return
     }
     // Why: rollout targets first-run onboarding users; existing profiles are classified once and never auto-toured.
-    actions.setContextualToursAutoEligible(shouldShowOnboarding(onboarding))
-  }, [actions, contextualToursAutoEligible, onboarding, onboardingLoaded, persistedUIReady])
+    setContextualToursAutoEligible(shouldShowOnboarding(onboarding))
+  }, [
+    contextualToursAutoEligible,
+    onboarding,
+    onboardingLoaded,
+    persistedUIReady,
+    setContextualToursAutoEligible
+  ])
 
   useEffect(() => {
     if (!persistedUIReady) {
@@ -71,74 +96,65 @@ export function useOnboardingAndFeatureTips() {
     }
 
     let cancelled = false
-    void window.api.cli
-      .getInstallStatus()
-      .then((status) => {
-        if (cancelled) {
-          return
-        }
+    void readStartupDiscovery(window.api.cli.getInstallStatus()).then((status) => {
+      if (cancelled) {
+        return
+      }
+      if (status === null) {
+        abandonTip()
+      } else {
         setFeatureTipCliInstalled(isCliFeatureTipCompleted(status))
-      })
-      .catch(() => {
-        if (!cancelled) {
-          setFeatureTipCliInstalled(true)
-        }
-      })
+      }
+    })
 
     return () => {
       cancelled = true
     }
-  }, [persistedUIReady])
+  }, [abandonTip, persistedUIReady])
 
   useEffect(() => {
+    if (tipSource !== 'pending') {
+      return
+    }
     const featureTipsDecision = getFeatureTipsAppOpenDecision({
-      activeModal,
       cliInstalled: featureTipCliInstalled,
       featureTipsSeenIds,
       featureInteractions,
-      onboarding,
+      onboarding: onboarding ?? tipCheckOnboarding,
       persistedUIReady,
-      promptedThisSession: promptedThisSessionRef.current,
       settings,
-      suppressedByOnboardingThisSession: suppressedByOnboardingThisSessionRef.current,
       webClient: isWebClientLocation()
     })
 
-    if (featureTipsDecision.kind === 'suppress-for-onboarding') {
-      // Why: first-run users should finish onboarding without a second education modal in the same session.
-      suppressedByOnboardingThisSessionRef.current = true
+    if (featureTipsDecision.kind === 'pending') {
       return
     }
 
     if (featureTipsDecision.kind !== 'open') {
+      useDialogRegistry.getState().settleStartupSource('feature-tip', 'none')
       return
     }
 
-    promptedThisSessionRef.current = true
-    if (featureTipsDecision.tipId === 'orca-cli') {
-      trackOrcaCliFeatureTipShown('app_open')
-    } else if (featureTipsDecision.tipId === 'cmd-j-palette') {
-      trackCmdJPaletteFeatureTipShown('app_open')
-    }
-    // Why: mark seen on show so a quit/crash before dismiss doesn't reappear it next launch.
-    actions.markFeatureTipsSeen([featureTipsDecision.tipId])
-    actions.openModal('feature-tips', {
-      source: 'app_open',
-      tipId: featureTipsDecision.tipId
-    })
+    // The owner queues its tip with the answer, even before its lazy host mounts.
+    useDialogRegistry
+      .getState()
+      .settleStartupSource('feature-tip', 'ready', APP_OPEN_FEATURE_TIP_TOKEN)
+    setAppOpenTipId(featureTipsDecision.tipId)
   }, [
-    activeModal,
-    actions,
     featureTipCliInstalled,
     featureInteractions,
     featureTipsSeenIds,
     onboarding,
     persistedUIReady,
-    settings
+    settings,
+    tipCheckOnboarding,
+    tipSource
   ])
 
   return {
     applyStartupOnboardingState,
+    applyStartupTipCheckInputs,
+    appOpenTipId,
     onboarding,
     setOnboarding,
     shouldRender: onboarding !== null && shouldShowOnboarding(onboarding)
diff --git a/src/renderer/src/components/NativeChatResumeOnRestartModal.list.test.tsx b/src/renderer/src/components/NativeChatResumeOnRestartModal.list.test.tsx
index bac1011793ed..962c8f7e69ee 100644
--- a/src/renderer/src/components/NativeChatResumeOnRestartModal.list.test.tsx
+++ b/src/renderer/src/components/NativeChatResumeOnRestartModal.list.test.tsx
@@ -18,9 +18,10 @@ import {
   offered
 } from './native-chat-resume-on-restart-modal.test-support'
 import {
-  consumeNativeChatResumeOnRestartDialogRequest,
+  _resetNativeChatResumeOnRestartDialog,
   requestNativeChatResumeOnRestartDialog
 } from './native-chat-resume-on-restart-dialog'
+import { resetDialogRegistryForTests } from '../store/dialog-registry-test-state'
 import { _resetNativeChatRestartOffer } from './native-chat-resume-on-restart-store'
 
 const rpc = vi.hoisted(() => vi.fn())
@@ -45,7 +46,9 @@ async function mount(node: React.ReactNode): Promise<void> {
 beforeEach(() => {
   rpc.mockReset()
   _resetNativeChatRestartOffer()
-  consumeNativeChatResumeOnRestartDialogRequest()
+  _resetNativeChatResumeOnRestartDialog()
+  // These cases are the offer alone, past the startup checks that go before it.
+  resetDialogRegistryForTests({ startupSettled: true })
   useAppStore.setState(useAppStore.getInitialState(), true)
   useAppStore.setState({
     settings: { ...getDefaultSettings(''), experimentalStructuredNativeChat: true }
@@ -60,7 +63,7 @@ afterEach(() => {
   container.remove()
   useAppStore.setState(useAppStore.getInitialState(), true)
   _resetNativeChatRestartOffer()
-  consumeNativeChatResumeOnRestartDialogRequest()
+  _resetNativeChatResumeOnRestartDialog()
 })
 
 // Left to the dialog, focus lands on the scrollable list and draws a ring around it.
@@ -127,7 +130,7 @@ it('folds the focused node with Left and opens it with Right, keeping focus and
 it('keeps initial focus inside the dialog with no resumable chats', async () => {
   rpc.mockResolvedValue({ sessions: [], failed: [failure('b')] })
   await mount(<NativeChatResumeOnRestartModal />)
-  await act(async () => requestNativeChatResumeOnRestartDialog())
+  await act(async () => requestNativeChatResumeOnRestartDialog('user'))
   const dialog = document.querySelector('[role="dialog"]')
   expect(button('Resume 0 chats').disabled).toBe(true)
   expect(dialog).not.toBeNull()
@@ -189,7 +192,7 @@ it('starts the list with a tri-state Select all that counts the selection', asyn
 it('leaves a failure a retry cannot fix out of Select all', async () => {
   rpc.mockResolvedValue({ sessions: [offered[0]], failed: [{ ...failure('b'), retryable: false }] })
   await mount(<NativeChatResumeOnRestartModal />)
-  await act(async () => requestNativeChatResumeOnRestartDialog())
+  await act(async () => requestNativeChatResumeOnRestartDialog('user'))
   const selectAll = namedBox('Select all chats')
   expect(selectAll.closest('label')?.textContent).toContain('1 of 1 selected')
 
diff --git a/src/renderer/src/components/NativeChatResumeOnRestartModal.test.tsx b/src/renderer/src/components/NativeChatResumeOnRestartModal.test.tsx
index 2ed87aa5f310..71eb6af6ab91 100644
--- a/src/renderer/src/components/NativeChatResumeOnRestartModal.test.tsx
+++ b/src/renderer/src/components/NativeChatResumeOnRestartModal.test.tsx
@@ -20,10 +20,11 @@ import {
   offered
 } from './native-chat-resume-on-restart-modal.test-support'
 import {
-  consumeNativeChatResumeOnRestartDialogRequest,
+  _resetNativeChatResumeOnRestartDialog,
   getNativeChatResumeOnRestartDialogRequest,
   requestNativeChatResumeOnRestartDialog
 } from './native-chat-resume-on-restart-dialog'
+import { resetDialogRegistryForTests } from '../store/dialog-registry-test-state'
 import {
   _resetNativeChatRestartOffer,
   getNativeChatRestartOffer,
@@ -67,7 +68,9 @@ function toasts(): unknown[][] {
 beforeEach(() => {
   rpc.mockReset()
   _resetNativeChatRestartOffer()
-  consumeNativeChatResumeOnRestartDialogRequest()
+  _resetNativeChatResumeOnRestartDialog()
+  // These cases are the offer alone, past the startup checks that go before it.
+  resetDialogRegistryForTests({ startupSettled: true })
   vi.mocked(toast).mockClear()
   useAppStore.setState(useAppStore.getInitialState(), true)
   useAppStore.setState({
@@ -88,7 +91,7 @@ afterEach(() => {
   container.remove()
   useAppStore.setState(useAppStore.getInitialState(), true)
   _resetNativeChatRestartOffer()
-  consumeNativeChatResumeOnRestartDialogRequest()
+  _resetNativeChatResumeOnRestartDialog()
 })
 
 it('keeps next-launch preference out of the current resume action', async () => {
@@ -281,7 +284,7 @@ it('closes on Resume and shows the resume in the status bar until the host answe
   expect(document.body.textContent).not.toContain('Resuming')
   expect(document.querySelector('[role="dialog"]')).toBeNull()
   // Nothing is left to show, so the reopen request is retired rather than left to latch.
-  expect(getNativeChatResumeOnRestartDialogRequest()).toBe(false)
+  expect(getNativeChatResumeOnRestartDialogRequest()).toBeNull()
   // The click is answered once, when the run settles, across chats that are off-screen.
   expect(toasts()).toEqual([['Resumed 2 chats']])
 })
@@ -338,7 +341,7 @@ it('starts each opening from the default ticks, not the ones left at the last cl
   await act(async () => button('Close').click())
   expect(document.querySelector('[role="dialog"]')).toBeNull()
 
-  await act(async () => requestNativeChatResumeOnRestartDialog())
+  await act(async () => requestNativeChatResumeOnRestartDialog('user'))
   expect(chatBox('b').getAttribute('data-state')).toBe('checked')
   expect(button('Resume 2 chats').disabled).toBe(false)
 })
@@ -654,7 +657,7 @@ it('keeps a lost resume request marked failed when its Dismiss fails', async ()
   expect(getNativeChatRestartOffer().failed.map((entry) => entry.sessionId)).toEqual(['a'])
   expect(toasts()).toEqual([['1 chat couldn’t be resumed']])
 
-  await act(async () => requestNativeChatResumeOnRestartDialog())
+  await act(async () => requestNativeChatResumeOnRestartDialog('user'))
   await act(async () => button('Dismiss "Prompt a" in workspace').click())
   expect(rpc.mock.calls.at(-2)?.slice(1)).toEqual([
     'agentSession.restartResumableDismiss',
@@ -698,7 +701,7 @@ it('lists a chat the resume could not carry on when the dialog reopens, with wha
   await act(async () => button('Resume 2 chats').click())
   // Resume hands off to the status bar; its failure entry reopens the list.
   expect(document.querySelector('[role="dialog"]')).toBeNull()
-  await act(async () => requestNativeChatResumeOnRestartDialog())
+  await act(async () => requestNativeChatResumeOnRestartDialog('user'))
   const dialog = document.querySelector('[role="dialog"]')
   expect(dialog).not.toBeNull()
   // Unchanged chrome: the title, the preference box, and the two footer actions.
@@ -751,7 +754,7 @@ it.each(['footer', 'row'] as const)(
     await mount(<NativeChatResumeOnRestartModal />)
     // Old failures never raise the launch dialog by themselves; the status entry does.
     expect(document.querySelector('[role="dialog"]')).toBeNull()
-    await act(async () => requestNativeChatResumeOnRestartDialog())
+    await act(async () => requestNativeChatResumeOnRestartDialog('user'))
     expect(document.querySelector('[role="dialog"]')?.textContent).toContain(
       'Close it there, then retry.'
     )
@@ -836,7 +839,7 @@ it('keeps a failure the host marks unretryable out of Resume, even after a tick'
   let failed: unknown[] = [failure('b')]
   rpc.mockImplementation(async () => ({ sessions: [], failed }))
   await mount(<NativeChatResumeOnRestartModal />)
-  await act(async () => requestNativeChatResumeOnRestartDialog())
+  await act(async () => requestNativeChatResumeOnRestartDialog('user'))
   // An older host sends no flag, and the row stays selectable as it always was.
   expect(chatBox('b').hasAttribute('disabled')).toBe(false)
   await act(async () => chatBox('b').click())
@@ -864,7 +867,7 @@ it('dismisses one failed chat by name, and every record through Dismiss all', as
         }
   )
   await mount(<NativeChatResumeOnRestartModal />)
-  await act(async () => requestNativeChatResumeOnRestartDialog())
+  await act(async () => requestNativeChatResumeOnRestartDialog('user'))
   expect(chatBoxes()).toHaveLength(2)
   await act(async () => button('Dismiss "Prompt a" in workspace').click())
   expect(rpc.mock.calls.at(-1)?.slice(1)).toEqual([
diff --git a/src/renderer/src/components/NativeChatResumeOnRestartModal.tsx b/src/renderer/src/components/NativeChatResumeOnRestartModal.tsx
index 640c62c9f3e4..ad82a2af6f66 100644
--- a/src/renderer/src/components/NativeChatResumeOnRestartModal.tsx
+++ b/src/renderer/src/components/NativeChatResumeOnRestartModal.tsx
@@ -30,8 +30,10 @@ import {
 import {
   consumeNativeChatResumeOnRestartDialogRequest,
   getNativeChatResumeOnRestartDialogRequest,
+  NATIVE_CHAT_RESUME_DIALOG_TOKEN,
   subscribeNativeChatResumeOnRestartDialog
 } from './native-chat-resume-on-restart-dialog'
+import { DialogEntryScope, useAutomaticDialogEntry } from '@/lib/dialog-registry-entry'
 import {
   continueNativeChatRestartOffer,
   dismissNativeChatRestartOffer,
@@ -122,7 +124,9 @@ function moveInTree(event: React.KeyboardEvent<HTMLElement>): void {
 
 export function NativeChatResumeOnRestartModal(): React.JSX.Element | null {
   const offerEnabled = useNativeChatRestartOfferEnabled()
-  const { candidates, failed, listedAt } = useNativeChatRestartOffer(offerEnabled)
+  const { candidates, failed, listedAt } = useNativeChatRestartOffer(offerEnabled, {
+    ownsStartupDiscovery: true
+  })
   const rows = useMemo<ResumeCandidate[]>(() => [...candidates, ...failed], [candidates, failed])
   const failureBySession = useMemo(
     () => new Map(failed.map((failure) => [failure.sessionId, failure])),
@@ -130,11 +134,23 @@ export function NativeChatResumeOnRestartModal(): React.JSX.Element | null {
   )
   // Open is an external one-shot request, never mirrored into local state: the launch load and the
   // status-bar entry both raise it, and a copy here would go stale against whichever raised it last.
-  const open = useSyncExternalStore(
+  const request = useSyncExternalStore(
     subscribeNativeChatResumeOnRestartDialog,
     getNativeChatResumeOnRestartDialogRequest,
     getNativeChatResumeOnRestartDialogRequest
   )
+  // Raised by the launch, it waits its turn among the dialogs that open by themselves; asked for by
+  // the user, it opens at once. Only one it can draw holds a place, so a hidden one holds nothing.
+  const phase = useAutomaticDialogEntry(
+    NATIVE_CHAT_RESUME_DIALOG_TOKEN,
+    'native-chat-resume',
+    !offerEnabled || rows.length === 0 || request === null
+      ? null
+      : request === 'user'
+        ? 'user'
+        : 'automatic'
+  )
+  const open = phase !== null && phase !== 'queued'
   const updateSettings = useAppStore((store) => store.updateSettings)
   const [dontAskAgain, setDontAskAgain] = useState(false)
   const resumeButtonRef = useRef<HTMLButtonElement>(null)
@@ -147,10 +163,12 @@ export function NativeChatResumeOnRestartModal(): React.JSX.Element | null {
   const [overrides, setOverrides] = useState<ReadonlyMap<string, boolean>>(() => new Map())
   // Each opening starts from the rows' defaults. This component never unmounts, so an untick made
   // before a close would otherwise greet a reopen, e.g. as "Resume 0 chats" over what a run left.
-  const [openedWith, setOpenedWith] = useState(open)
-  if (openedWith !== open) {
-    setOpenedWith(open)
-    if (open) {
+  // Keyed on the request, not the turn, so waiting for its turn never resets the ticks.
+  const requested = request !== null
+  const [openedWith, setOpenedWith] = useState(requested)
+  if (openedWith !== requested) {
+    setOpenedWith(requested)
+    if (requested) {
       setOverrides(new Map())
     }
   }
@@ -245,9 +263,9 @@ export function NativeChatResumeOnRestartModal(): React.JSX.Element | null {
     'Select all'
   )
 
-  return (
+  const dialog = (
     <Dialog
-      open
+      open={phase !== 'closing'}
       onOpenChange={(next) => {
         if (!next) {
           snooze()
@@ -402,4 +420,5 @@ export function NativeChatResumeOnRestartModal(): React.JSX.Element | null {
       </DialogContent>
     </Dialog>
   )
+  return <DialogEntryScope token={NATIVE_CHAT_RESUME_DIALOG_TOKEN}>{dialog}</DialogEntryScope>
 }
diff --git a/src/renderer/src/components/NewWorkspaceComposerModal.tsx b/src/renderer/src/components/NewWorkspaceComposerModal.tsx
index 71a33801d8dd..8745ec37ef4f 100644
--- a/src/renderer/src/components/NewWorkspaceComposerModal.tsx
+++ b/src/renderer/src/components/NewWorkspaceComposerModal.tsx
@@ -84,6 +84,7 @@ function ComposerModalBody({
   return (
     <Dialog open onOpenChange={(open) => !open && handleDismiss()}>
       <DialogContent
+        dialogKind="new-workspace-composer"
         ref={dialogRef}
         className="flex max-h-[calc(100vh-2rem)] flex-col overflow-hidden sm:max-w-lg"
         onEscapeKeyDown={(event) => {
diff --git a/src/renderer/src/components/WorktreeBaseFallbackDialog.test.tsx b/src/renderer/src/components/WorktreeBaseFallbackDialog.test.tsx
index 2016fa4072a9..f7f41420542e 100644
--- a/src/renderer/src/components/WorktreeBaseFallbackDialog.test.tsx
+++ b/src/renderer/src/components/WorktreeBaseFallbackDialog.test.tsx
@@ -2,7 +2,7 @@
 
 import { act } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import { useAppStore } from '@/store'
 import type { AppState } from '@/store/types'
 import WorktreeBaseFallbackDialog from './WorktreeBaseFallbackDialog'
@@ -16,8 +16,7 @@ let root: Root | null = null
 
 async function renderDialog(activeModal: AppState['activeModal'] = 'none'): Promise<void> {
   useAppStore.setState({
-    activeModal,
-    setContextualToursBlockingSurfaceVisible: vi.fn()
+    activeModal
   })
   const container = document.createElement('div')
   document.body.appendChild(container)
diff --git a/src/renderer/src/components/WorktreeBaseFallbackDialog.tsx b/src/renderer/src/components/WorktreeBaseFallbackDialog.tsx
index e64e59045119..17f97f59557c 100644
--- a/src/renderer/src/components/WorktreeBaseFallbackDialog.tsx
+++ b/src/renderer/src/components/WorktreeBaseFallbackDialog.tsx
@@ -24,9 +24,6 @@ export default function WorktreeBaseFallbackDialog(): React.JSX.Element {
     getWorktreeBaseFallbackNotice
   )
   const activeModal = useAppStore((state) => state.activeModal)
-  const setContextualToursBlockingSurfaceVisible = useAppStore(
-    (state) => state.setContextualToursBlockingSurfaceVisible
-  )
   const lastNoticeRef = useRef(notice)
   const displayedNotice = notice ?? lastNoticeRef.current
   const open = notice !== null && activeModal === 'none'
@@ -37,11 +34,6 @@ export default function WorktreeBaseFallbackDialog(): React.JSX.Element {
     }
   }, [notice])
 
-  useEffect(() => {
-    setContextualToursBlockingSurfaceVisible(open)
-    return () => setContextualToursBlockingSurfaceVisible(false)
-  }, [open, setContextualToursBlockingSurfaceVisible])
-
   return (
     <Dialog
       open={open}
diff --git a/src/renderer/src/components/browser-webauthn-account-dialog.test.tsx b/src/renderer/src/components/browser-webauthn-account-dialog.test.tsx
index 69120a437779..418739caf9c6 100644
--- a/src/renderer/src/components/browser-webauthn-account-dialog.test.tsx
+++ b/src/renderer/src/components/browser-webauthn-account-dialog.test.tsx
@@ -6,16 +6,11 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { BrowserWebAuthnAccountRequest } from '../../../shared/browser-webauthn-account'
 
-const { respondMock, setBlockingSurfaceMock } = vi.hoisted(() => ({
-  respondMock: vi.fn(),
-  setBlockingSurfaceMock: vi.fn()
+const { respondMock } = vi.hoisted(() => ({
+  respondMock: vi.fn()
 }))
 
 vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
-vi.mock('@/store', () => ({
-  useAppStore: (selector: (state: unknown) => unknown) =>
-    selector({ setContextualToursBlockingSurfaceVisible: setBlockingSurfaceMock })
-}))
 
 import { BrowserWebAuthnAccountDialog } from './browser-webauthn-account-dialog'
 
@@ -27,7 +22,6 @@ describe('BrowserWebAuthnAccountDialog', () => {
 
   beforeEach(() => {
     respondMock.mockReset().mockResolvedValue(true)
-    setBlockingSurfaceMock.mockReset()
     Object.defineProperty(window, 'api', {
       configurable: true,
       value: {
diff --git a/src/renderer/src/components/browser-webauthn-account-dialog.tsx b/src/renderer/src/components/browser-webauthn-account-dialog.tsx
index cb7bc9ff2c37..14a49d234370 100644
--- a/src/renderer/src/components/browser-webauthn-account-dialog.tsx
+++ b/src/renderer/src/components/browser-webauthn-account-dialog.tsx
@@ -11,7 +11,6 @@ import {
   DialogTitle
 } from '@/components/ui/dialog'
 import { translate } from '@/i18n/i18n'
-import { useAppStore } from '@/store'
 import type {
   BrowserWebAuthnAccount,
   BrowserWebAuthnAccountRequest
@@ -34,9 +33,6 @@ export function BrowserWebAuthnAccountDialog(): React.JSX.Element {
   const [respondingRequestId, setRespondingRequestId] = useState<string | null>(null)
   const requestsRef = useRef(requests)
   const firstAccountRef = useRef<HTMLButtonElement | null>(null)
-  const setContextualToursBlockingSurfaceVisible = useAppStore(
-    (state) => state.setContextualToursBlockingSurfaceVisible
-  )
   const activeRequest = requests[0] ?? null
   const lastRequestRef = useRef(activeRequest)
   const displayedRequest = activeRequest ?? lastRequestRef.current
@@ -74,11 +70,6 @@ export function BrowserWebAuthnAccountDialog(): React.JSX.Element {
     }
   }, [removeRequest])
 
-  useEffect(() => {
-    setContextualToursBlockingSurfaceVisible(activeRequest !== null)
-    return () => setContextualToursBlockingSurfaceVisible(false)
-  }, [activeRequest, setContextualToursBlockingSurfaceVisible])
-
   useEffect(() => {
     if (!activeRequest) {
       return
diff --git a/src/renderer/src/components/confirmation-dialog.test.tsx b/src/renderer/src/components/confirmation-dialog.test.tsx
index 5097a5d7786b..b4dde414c21b 100644
--- a/src/renderer/src/components/confirmation-dialog.test.tsx
+++ b/src/renderer/src/components/confirmation-dialog.test.tsx
@@ -5,11 +5,6 @@ import { cleanup, render, screen, waitFor } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
-vi.mock('@/store', () => ({
-  useAppStore: (selector: (state: Record<string, unknown>) => unknown) =>
-    selector({ setContextualToursBlockingSurfaceVisible: vi.fn() })
-}))
-
 import { ConfirmationDialogProvider } from './confirmation-dialog'
 import {
   useConfirmationDialog,
diff --git a/src/renderer/src/components/confirmation-dialog.tsx b/src/renderer/src/components/confirmation-dialog.tsx
index 615a2400bc65..fb77861c2b5d 100644
--- a/src/renderer/src/components/confirmation-dialog.tsx
+++ b/src/renderer/src/components/confirmation-dialog.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react'
+import React, { useCallback, useRef, useState } from 'react'
 
 import { Button } from '@/components/ui/button'
 import { Checkbox } from '@/components/ui/checkbox'
@@ -16,7 +16,6 @@ import {
   type ConfirmationDialogContextValue,
   type ConfirmationDialogOptions
 } from '@/components/confirmation-dialog-context'
-import { useAppStore } from '@/store'
 import { translate } from '@/i18n/i18n'
 import { cn } from '@/lib/utils'
 
@@ -37,9 +36,6 @@ export function ConfirmationDialogProvider({
   const [dontAskAgain, setDontAskAgain] = useState(false)
   const activeRequest = queue[0] ?? null
   const activeRequestRef = useRef<ConfirmationDialogRequest | null>(activeRequest)
-  const setContextualToursBlockingSurfaceVisible = useAppStore(
-    (s) => s.setContextualToursBlockingSurfaceVisible
-  )
   const lastDisplayedRequestRef = useRef<ConfirmationDialogRequest | null>(activeRequest)
   activeRequestRef.current = activeRequest
   if (activeRequest) {
@@ -49,13 +45,6 @@ export function ConfirmationDialogProvider({
   const displayedRequest = activeRequest ?? lastDisplayedRequestRef.current
   const Icon = displayedRequest?.options.icon
 
-  useEffect(() => {
-    // Why: this provider's dialog is not represented by activeModal. Block
-    // contextual tours so they cannot appear behind confirmation prompts.
-    setContextualToursBlockingSurfaceVisible(activeRequest !== null)
-    return () => setContextualToursBlockingSurfaceVisible(false)
-  }, [activeRequest, setContextualToursBlockingSurfaceVisible])
-
   const confirm = useCallback<ConfirmationDialogContextValue>((options) => {
     return new Promise((resolve) => {
       const request: ConfirmationDialogRequest = {
diff --git a/src/renderer/src/components/contextual-tours/ContextualTourOverlay.remeasure.test.tsx b/src/renderer/src/components/contextual-tours/ContextualTourOverlay.remeasure.test.tsx
index 31a9b55f7679..94e3b9710db9 100644
--- a/src/renderer/src/components/contextual-tours/ContextualTourOverlay.remeasure.test.tsx
+++ b/src/renderer/src/components/contextual-tours/ContextualTourOverlay.remeasure.test.tsx
@@ -88,8 +88,7 @@ describe('ContextualTourOverlay re-measure triggers', () => {
       activeContextualTourId: 'workspace-agent-sessions',
       activeContextualTourStepIndex: 1,
       activeModal: 'none',
-      contextualToursOnboardingVisible: false,
-      contextualToursBlockingSurfaceVisible: false,
+
       activeContextualTourSuppressed: false
     })
     await mountOverlay()
@@ -114,8 +113,7 @@ describe('ContextualTourOverlay re-measure triggers', () => {
       activeContextualTourId: 'workspace-agent-sessions',
       activeContextualTourStepIndex: 1,
       activeModal: 'none',
-      contextualToursOnboardingVisible: false,
-      contextualToursBlockingSurfaceVisible: false,
+
       activeContextualTourSuppressed: false
     })
     await mountOverlay()
diff --git a/src/renderer/src/components/contextual-tours/ContextualTourOverlay.tsx b/src/renderer/src/components/contextual-tours/ContextualTourOverlay.tsx
index 119ca73d451e..cf36818a87f6 100644
--- a/src/renderer/src/components/contextual-tours/ContextualTourOverlay.tsx
+++ b/src/renderer/src/components/contextual-tours/ContextualTourOverlay.tsx
@@ -1,5 +1,7 @@
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, type JSX } from 'react'
 import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectTourInterrupted, selectTourParentToken } from '@/store/dialog-registry-state'
 import {
   getContextualTour,
   type ContextualTourId,
@@ -10,7 +12,7 @@ import {
   trackContextualTourOutcome,
   trackContextualTourShown
 } from '@/lib/feature-education-telemetry'
-import { isContextualTourAllowedForModal } from './contextual-tour-gate'
+import { DialogEntryContent } from '@/lib/dialog-registry-entry'
 import {
   areContextualTourRenderStatesEqual,
   getContextualTourCleanupOutcome,
@@ -37,10 +39,17 @@ export function ContextualTourOverlay(): JSX.Element | null {
   const wasFeaturePreviouslyInteracted = useAppStore(
     (s) => s.activeContextualTourWasFeaturePreviouslyInteracted
   )
-  const activeModal = useAppStore((s) => s.activeModal)
-  const onboardingVisible = useAppStore((s) => s.contextualToursOnboardingVisible)
-  const blockingSurfaceVisible = useAppStore((s) => s.contextualToursBlockingSurfaceVisible)
+  const blockingSurfaceVisible = useDialogRegistry((s) =>
+    selectTourInterrupted(
+      s,
+      selectTourParentToken(
+        s,
+        activeTourId ? getContextualTour(activeTourId).allowedActiveModals : undefined
+      )
+    )
+  )
   const activeTourSuppressed = useAppStore((s) => s.activeContextualTourSuppressed)
+  const awaitingOnboarding = useAppStore((s) => s.contextualToursAwaitingOnboarding)
   const keybindings = useAppStore((s) => s.keybindings)
   const activeTabId = useAppStore((s) => s.activeTabId)
   const sidebarOpen = useAppStore((s) => s.sidebarOpen)
@@ -123,24 +132,18 @@ export function ContextualTourOverlay(): JSX.Element | null {
     if (!activeTour || !activeTourId) {
       return
     }
-    if (
-      onboardingVisible ||
-      blockingSurfaceVisible ||
-      activeTourSuppressed ||
-      !isContextualTourAllowedForModal(activeTour, activeModal)
-    ) {
+    if (awaitingOnboarding || blockingSurfaceVisible || activeTourSuppressed) {
       emitContextualTourOutcome('cancelled')
       cancelContextualTour(activeTourId)
     }
   }, [
-    activeModal,
     activeTourSuppressed,
     activeTour,
     activeTourId,
+    awaitingOnboarding,
     blockingSurfaceVisible,
     cancelContextualTour,
-    emitContextualTourOutcome,
-    onboardingVisible
+    emitContextualTourOutcome
   ])
 
   const measureTourOverlay = useCallback((): void => {
@@ -386,26 +389,28 @@ export function ContextualTourOverlay(): JSX.Element | null {
   }
 
   return (
-    <ContextualTourOverlaySurface
-      activeTourId={activeTourId}
-      renderState={renderState}
-      panelRef={panelRef}
-      panelHost={renderState.panelHost}
-      onSkip={(id) => {
-        emitContextualTourOutcome('skipped')
-        dismissContextualTour(id)
-      }}
-      onBack={regressContextualTour}
-      onNext={() => {
-        if (renderState.isLastStep) {
-          finishTour()
-        } else {
-          advanceContextualTour()
-        }
-      }}
-      onStepAction={handleStepAction}
-      onOverlayKeyDownCapture={handleContextualTourOverlayKeyDown}
-    />
+    <DialogEntryContent kind="tour" origin="tour">
+      <ContextualTourOverlaySurface
+        activeTourId={activeTourId}
+        renderState={renderState}
+        panelRef={panelRef}
+        panelHost={renderState.panelHost}
+        onSkip={(id) => {
+          emitContextualTourOutcome('skipped')
+          dismissContextualTour(id)
+        }}
+        onBack={regressContextualTour}
+        onNext={() => {
+          if (renderState.isLastStep) {
+            finishTour()
+          } else {
+            advanceContextualTour()
+          }
+        }}
+        onStepAction={handleStepAction}
+        onOverlayKeyDownCapture={handleContextualTourOverlayKeyDown}
+      />
+    </DialogEntryContent>
   )
 }
 
diff --git a/src/renderer/src/components/contextual-tours/ContextualTourOverlay.visibility.test.tsx b/src/renderer/src/components/contextual-tours/ContextualTourOverlay.visibility.test.tsx
index f8b6fe0094d1..1b0e37fab26b 100644
--- a/src/renderer/src/components/contextual-tours/ContextualTourOverlay.visibility.test.tsx
+++ b/src/renderer/src/components/contextual-tours/ContextualTourOverlay.visibility.test.tsx
@@ -78,8 +78,7 @@ describe('ContextualTourOverlay full-pass interval visibility gate', () => {
       activeContextualTourId: 'workspace-agent-sessions',
       activeContextualTourStepIndex: 1,
       activeModal: 'none',
-      contextualToursOnboardingVisible: false,
-      contextualToursBlockingSurfaceVisible: false,
+
       activeContextualTourSuppressed: false
     })
     await act(async () => {
diff --git a/src/renderer/src/components/contextual-tours/contextual-tour-gate.test.ts b/src/renderer/src/components/contextual-tours/contextual-tour-gate.test.ts
index f9f07a1817e4..3a1f03fb6f8a 100644
--- a/src/renderer/src/components/contextual-tours/contextual-tour-gate.test.ts
+++ b/src/renderer/src/components/contextual-tours/contextual-tour-gate.test.ts
@@ -7,32 +7,19 @@ import {
   getMeasurableContextualTourTarget,
   getNextVisibleContextualTourStepIndex,
   getPreviousVisibleContextualTourStepIndex,
-  getVisibleContextualTourStepIndexes,
-  isContextualTourAllowedForModal
+  getVisibleContextualTourStepIndexes
 } from './contextual-tour-gate'
 
 describe('contextual tour gate', () => {
-  it('allows only workspace creation over its workspace composer modal', () => {
-    const workspaceCreation = getContextualTour('workspace-creation')
-    const tasks = getContextualTour('tasks')
-
-    expect(isContextualTourAllowedForModal(workspaceCreation, 'new-workspace-composer')).toBe(true)
-    expect(isContextualTourAllowedForModal(workspaceCreation, 'add-repo')).toBe(false)
-    expect(isContextualTourAllowedForModal(tasks, 'none')).toBe(true)
-    expect(isContextualTourAllowedForModal(tasks, 'new-workspace-composer')).toBe(false)
-    expect(isContextualTourAllowedForModal(tasks, 'add-repo')).toBe(false)
-  })
-
   it('does not start when the required first target is missing', () => {
     const decision = getContextualTourRequestDecision({
       tour: getContextualTour('tasks'),
       persistedUIReady: true,
       autoEligible: true,
-      onboardingVisible: false,
+
       seenIds: [],
       sessionConsumed: false,
       activeTourId: null,
-      activeModal: 'none',
       blockingSurfaceVisible: false,
       targetExists: () => false
     })
@@ -48,11 +35,10 @@ describe('contextual tour gate', () => {
       tour,
       persistedUIReady: true,
       autoEligible: true,
-      onboardingVisible: false,
+
       seenIds: [],
       sessionConsumed: false,
       activeTourId: null,
-      activeModal: 'none',
       blockingSurfaceVisible: false,
       targetExists: (selector) => selector === fallbackSelector
     })
@@ -215,11 +201,10 @@ describe('contextual tour gate', () => {
         tour,
         persistedUIReady: true,
         autoEligible: true,
-        onboardingVisible: false,
+
         seenIds: [],
         sessionConsumed: false,
         activeTourId: null,
-        activeModal: 'none',
         blockingSurfaceVisible: false,
         targetExists: hasFirstTarget
       })
@@ -230,11 +215,10 @@ describe('contextual tour gate', () => {
         tour,
         persistedUIReady: false,
         autoEligible: true,
-        onboardingVisible: false,
+
         seenIds: [],
         sessionConsumed: false,
         activeTourId: null,
-        activeModal: 'none',
         blockingSurfaceVisible: false,
         targetExists: hasFirstTarget
       })
@@ -245,11 +229,10 @@ describe('contextual tour gate', () => {
         tour,
         persistedUIReady: true,
         autoEligible: false,
-        onboardingVisible: false,
+
         seenIds: [],
         sessionConsumed: false,
         activeTourId: null,
-        activeModal: 'none',
         blockingSurfaceVisible: false,
         targetExists: hasFirstTarget
       })
@@ -260,26 +243,23 @@ describe('contextual tour gate', () => {
         tour,
         persistedUIReady: true,
         autoEligible: true,
-        onboardingVisible: true,
         seenIds: [],
         sessionConsumed: false,
         activeTourId: null,
-        activeModal: 'none',
-        blockingSurfaceVisible: false,
+        blockingSurfaceVisible: true,
         targetExists: hasFirstTarget
       })
-    ).toEqual({ kind: 'blocked', reason: 'onboarding' })
+    ).toEqual({ kind: 'blocked', reason: 'blocking-surface' })
 
     expect(
       getContextualTourRequestDecision({
         tour,
         persistedUIReady: true,
         autoEligible: true,
-        onboardingVisible: false,
+
         seenIds: ['tasks'],
         sessionConsumed: false,
         activeTourId: null,
-        activeModal: 'none',
         blockingSurfaceVisible: false,
         targetExists: hasFirstTarget
       })
@@ -290,11 +270,10 @@ describe('contextual tour gate', () => {
         tour,
         persistedUIReady: true,
         autoEligible: true,
-        onboardingVisible: false,
+
         seenIds: [],
         sessionConsumed: false,
         activeTourId: null,
-        activeModal: 'none',
         blockingSurfaceVisible: true,
         targetExists: hasFirstTarget
       })
diff --git a/src/renderer/src/components/contextual-tours/contextual-tour-gate.ts b/src/renderer/src/components/contextual-tours/contextual-tour-gate.ts
index 155f2bfb5a81..88d113503a53 100644
--- a/src/renderer/src/components/contextual-tours/contextual-tour-gate.ts
+++ b/src/renderer/src/components/contextual-tours/contextual-tour-gate.ts
@@ -12,11 +12,9 @@ export type ContextualTourRequestDecision =
       reason:
         | 'persisted-ui-not-ready'
         | 'auto-disabled'
-        | 'onboarding'
         | 'seen'
         | 'session-consumed'
         | 'active-tour'
-        | 'modal'
         | 'blocking-surface'
         | 'missing-start-target'
     }
@@ -27,16 +25,6 @@ export function getContextualTourPanelHost(targetElement: Element): HTMLElement
   return targetElement.closest<HTMLElement>(PANEL_HOST_SELECTOR)
 }
 
-export function isContextualTourAllowedForModal(
-  tour: ContextualTour,
-  activeModal: string
-): boolean {
-  if (activeModal === 'none') {
-    return true
-  }
-  return tour.allowedActiveModals?.includes(activeModal) === true
-}
-
 export function getMeasurableContextualTourTarget(
   selector: string,
   root?: ParentNode
@@ -128,11 +116,9 @@ export function getContextualTourRequestDecision(args: {
   tour: ContextualTour
   persistedUIReady: boolean
   autoEligible: boolean
-  onboardingVisible: boolean
   seenIds: readonly string[]
   sessionConsumed: boolean
   activeTourId: string | null
-  activeModal: string
   blockingSurfaceVisible: boolean
   targetExists: (selector: string) => boolean
 }): ContextualTourRequestDecision {
@@ -142,9 +128,6 @@ export function getContextualTourRequestDecision(args: {
   if (!args.autoEligible) {
     return { kind: 'blocked', reason: 'auto-disabled' }
   }
-  if (args.onboardingVisible) {
-    return { kind: 'blocked', reason: 'onboarding' }
-  }
   if (args.seenIds.includes(args.tour.id)) {
     return { kind: 'blocked', reason: 'seen' }
   }
@@ -154,9 +137,6 @@ export function getContextualTourRequestDecision(args: {
   if (args.activeTourId !== null) {
     return { kind: 'blocked', reason: 'active-tour' }
   }
-  if (!isContextualTourAllowedForModal(args.tour, args.activeModal)) {
-    return { kind: 'blocked', reason: 'modal' }
-  }
   if (args.blockingSurfaceVisible) {
     return { kind: 'blocked', reason: 'blocking-surface' }
   }
diff --git a/src/renderer/src/components/contextual-tours/use-contextual-tour.ts b/src/renderer/src/components/contextual-tours/use-contextual-tour.ts
index a19c1623999e..e3b9a7c0d382 100644
--- a/src/renderer/src/components/contextual-tours/use-contextual-tour.ts
+++ b/src/renderer/src/components/contextual-tours/use-contextual-tour.ts
@@ -1,10 +1,12 @@
 import { useEffect, useRef } from 'react'
-import type { ContextualTourId } from '../../../../shared/contextual-tours'
+import { getContextualTour, type ContextualTourId } from '../../../../shared/contextual-tours'
 import {
   hasFeatureInteraction,
   type FeatureInteractionState
 } from '../../../../shared/feature-interactions'
 import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectTourBlocked, selectTourParentToken } from '@/store/dialog-registry-state'
 
 const TOUR_SOURCES = {
   'workspace-board': 'workspace_board_visible',
@@ -66,7 +68,6 @@ export function useContextualTour(
   const suppressContextualTour = useAppStore((s) => s.suppressContextualTour)
   const recordFeatureInteraction = useAppStore((s) => s.recordFeatureInteraction)
   const persistedUIReady = useAppStore((s) => s.persistedUIReady)
-  const activeModal = useAppStore((s) => s.activeModal)
   const activeContextualTourId = useAppStore((s) => s.activeContextualTourId)
   const activeContextualTourSource = useAppStore((s) => s.activeContextualTourSource)
   const activeContextualTourSourceDetached = useAppStore(
@@ -75,9 +76,9 @@ export function useContextualTour(
   const contextualToursSeenIds = useAppStore((s) => s.contextualToursSeenIds)
   const contextualToursAutoEligible = useAppStore((s) => s.contextualToursAutoEligible)
   const contextualTourShownThisSession = useAppStore((s) => s.contextualTourShownThisSession)
-  const contextualToursOnboardingVisible = useAppStore((s) => s.contextualToursOnboardingVisible)
-  const contextualToursBlockingSurfaceVisible = useAppStore(
-    (s) => s.contextualToursBlockingSurfaceVisible
+  const contextualToursAwaitingOnboarding = useAppStore((s) => s.contextualToursAwaitingOnboarding)
+  const contextualToursBlockingSurfaceVisible = useDialogRegistry((s) =>
+    selectTourBlocked(s, false, selectTourParentToken(s, getContextualTour(id).allowedActiveModals))
   )
   const enabledInteractionSnapshotRef = useRef<{
     id: ContextualTourId
@@ -167,7 +168,7 @@ export function useContextualTour(
       typeof document === 'undefined' ||
       !persistedUIReady ||
       contextualToursAutoEligible !== true ||
-      contextualToursOnboardingVisible ||
+      contextualToursAwaitingOnboarding ||
       contextualToursBlockingSurfaceVisible ||
       activeContextualTourId !== null ||
       contextualTourShownThisSession ||
@@ -250,10 +251,9 @@ export function useContextualTour(
   }, [
     activeContextualTourId,
     contextualToursBlockingSurfaceVisible,
-    activeModal,
     contextualToursAutoEligible,
+    contextualToursAwaitingOnboarding,
     contextualTourShownThisSession,
-    contextualToursOnboardingVisible,
     contextualToursSeenIds,
     enabled,
     id,
diff --git a/src/renderer/src/components/crash-report/CrashReportDialog.test.tsx b/src/renderer/src/components/crash-report/CrashReportDialog.test.tsx
new file mode 100644
index 000000000000..ff0459b4b490
--- /dev/null
+++ b/src/renderer/src/components/crash-report/CrashReportDialog.test.tsx
@@ -0,0 +1,296 @@
+// @vitest-environment happy-dom
+
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { resetDialogRegistryForTests } from '@/store/dialog-registry-test-state'
+import { getDefaultSettings } from '../../../../shared/constants'
+import type { CrashReportRecord } from '../../../../shared/crash-reporting'
+import { CrashReportDialog } from './CrashReportDialog'
+import { SshPassphraseDialog } from '../settings/SshPassphraseDialog'
+import { TooltipProvider } from '../ui/tooltip'
+
+vi.mock('sonner', () => ({
+  toast: Object.assign(vi.fn(), {
+    error: vi.fn(),
+    success: vi.fn(),
+    warning: vi.fn(),
+    dismiss: vi.fn()
+  })
+}))
+vi.mock('@/lib/telemetry', () => ({ track: vi.fn() }))
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+let root: Root
+let container: HTMLDivElement
+
+const pendingCrash: CrashReportRecord = {
+  id: 'crash-1',
+  createdAt: '2026-10-05T00:00:00.000Z',
+  status: 'pending',
+  source: 'renderer',
+  processType: 'renderer',
+  reason: 'crashed',
+  exitCode: 5,
+  appVersion: '1.0.0',
+  platform: 'darwin',
+  osRelease: 'test',
+  arch: 'arm64',
+  electronVersion: '1',
+  chromeVersion: '1',
+  details: {}
+}
+
+const newerCrash: CrashReportRecord = {
+  ...pendingCrash,
+  id: 'crash-2',
+  createdAt: '2026-10-05T01:00:00.000Z',
+  appVersion: '9.9.9'
+}
+
+let openCrashReportFromMenu: () => void = () => {}
+let resolveSubmit: (value: unknown) => void = () => {}
+const crashReports = {
+  getLatestPending: vi.fn(async (): Promise<CrashReportRecord | null> => pendingCrash),
+  getLatestReport: vi.fn(async (): Promise<CrashReportRecord | null> => null),
+  dismiss: vi.fn(async () => undefined),
+  submit: vi.fn(
+    () =>
+      new Promise((resolve) => {
+        resolveSubmit = resolve
+      })
+  )
+}
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 8; i += 1) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0))
+    })
+  }
+}
+
+function crashOnScreen(): boolean {
+  return document.body.textContent?.includes('Send Report') === true
+}
+
+function sshOnScreen(): boolean {
+  return document.body.textContent?.includes('SSH Key Passphrase') === true
+}
+
+function notes(): string {
+  return document.querySelector<HTMLTextAreaElement>('textarea')?.value ?? ''
+}
+
+function button(label: string): HTMLButtonElement {
+  const found = [...document.querySelectorAll('button')].find((b) =>
+    b.textContent?.trim().endsWith(label)
+  )
+  if (!found) {
+    throw new Error(`Missing button: ${label}`)
+  }
+  return found
+}
+
+function typeNotes(text: string): void {
+  const area = document.querySelector('textarea')
+  const setter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')?.set
+  if (!area || !setter) {
+    throw new Error('Missing notes field')
+  }
+  act(() => {
+    setter.call(area, text)
+    area.dispatchEvent(new Event('input', { bubbles: true }))
+  })
+}
+
+/** The SSH prompt as the app hosts it. */
+function SshHost(): React.JSX.Element | null {
+  const asked = useAppStore((s) => s.sshCredentialQueue.length > 0)
+  return asked ? <SshPassphraseDialog /> : null
+}
+
+beforeEach(() => {
+  crashReports.submit.mockClear()
+  crashReports.dismiss.mockClear()
+  crashReports.getLatestPending.mockReset().mockResolvedValue(pendingCrash)
+  crashReports.getLatestReport.mockReset().mockResolvedValue(null)
+  resetDialogRegistryForTests({ startupSettled: true })
+  useAppStore.setState(useAppStore.getInitialState(), true)
+  useAppStore.setState({ settings: getDefaultSettings('') })
+  Object.assign(window, {
+    api: {
+      crashReports,
+      ui: {
+        onOpenCrashReport: (cb: () => void) => {
+          openCrashReportFromMenu = cb
+          return () => {}
+        }
+      },
+      ssh: { submitCredential: vi.fn(async () => undefined) },
+      gh: { viewer: vi.fn(async () => null) }
+    }
+  })
+  container = document.createElement('div')
+  document.body.append(container)
+  root = createRoot(container)
+})
+
+afterEach(() => {
+  act(() => root.unmount())
+  container.remove()
+})
+
+async function mountBoth({ waitForCrash = true } = {}): Promise<void> {
+  await act(async () =>
+    root.render(
+      <TooltipProvider>
+        <CrashReportDialog />
+        <SshHost />
+      </TooltipProvider>
+    )
+  )
+  await flush()
+  if (waitForCrash) {
+    await vi.waitFor(() => expect(crashOnScreen()).toBe(true), { timeout: 5000 })
+  }
+}
+
+function raiseSsh(): void {
+  act(() => {
+    useAppStore.getState().enqueueSshCredentialRequest({
+      requestId: 'r1',
+      targetId: 't1',
+      kind: 'passphrase',
+      detail: '~/.ssh/id_ed25519'
+    })
+  })
+}
+
+async function openFromHelp(): Promise<void> {
+  await act(async () => openCrashReportFromMenu())
+  await flush()
+}
+
+it('an SSH prompt stacks over the launch crash report, which keeps its notes throughout', async () => {
+  await mountBoth()
+  typeNotes('it crashed when I opened the diff')
+  const area = document.querySelector('textarea')
+  raiseSsh()
+  await flush()
+  expect(sshOnScreen()).toBe(true)
+  expect(document.querySelector('textarea')).toBe(area)
+  expect(notes()).toBe('it crashed when I opened the diff')
+
+  await act(async () => useAppStore.getState().removeSshCredentialRequest('r1'))
+  await flush()
+  expect(document.querySelector('textarea')).toBe(area)
+  expect(notes()).toBe('it crashed when I opened the diff')
+})
+
+it('a report sent while an SSH prompt interrupts it is sent once and the dialog closes', async () => {
+  await mountBoth()
+  typeNotes('notes')
+  await act(async () => button('Send Report').click())
+  expect(crashReports.submit).toHaveBeenCalledTimes(1)
+  raiseSsh()
+  await flush()
+  await act(async () => {
+    resolveSubmit({ ok: true, report: { ...pendingCrash, status: 'submitted' } })
+  })
+  await flush()
+  await act(async () => useAppStore.getState().removeSshCredentialRequest('r1'))
+  await flush()
+  expect(crashOnScreen()).toBe(false)
+  expect(crashReports.submit).toHaveBeenCalledTimes(1)
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+})
+
+it('Help > Report Crash over the report on screen keeps that report, its dialog and its notes', async () => {
+  crashReports.getLatestReport.mockResolvedValue(newerCrash)
+  await mountBoth()
+  typeNotes('it crashed when I opened the diff')
+  const area = document.querySelector('textarea')
+  await openFromHelp()
+  expect(document.querySelector('textarea')).toBe(area)
+  expect(notes()).toBe('it crashed when I opened the diff')
+  // Never swapped for a different report under the user's notes.
+  expect(document.body.textContent).toContain('Orca 1.0.0')
+  expect(document.body.textContent).not.toContain('Orca 9.9.9')
+
+  await act(async () => button("Don't Send").click())
+  await flush()
+  // One report, one dialog: closing it does not bring the same report back.
+  expect(crashOnScreen()).toBe(false)
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+})
+
+it('a send in flight when Help > Report Crash opens is sent once and closes the dialog', async () => {
+  await mountBoth()
+  await act(async () => button('Send Report').click())
+  await openFromHelp()
+  await act(async () => {
+    resolveSubmit({ ok: true, report: { ...pendingCrash, status: 'submitted' } })
+  })
+  await flush()
+  expect(crashOnScreen()).toBe(false)
+  expect(crashReports.submit).toHaveBeenCalledTimes(1)
+})
+
+it('Help with nothing on screen opens at once and fills in the latest report', async () => {
+  crashReports.getLatestPending.mockResolvedValue(null)
+  const latest = Promise.withResolvers<CrashReportRecord | null>()
+  crashReports.getLatestReport.mockReturnValue(latest.promise)
+  await mountBoth({ waitForCrash: false })
+  await openFromHelp()
+  expect(crashOnScreen()).toBe(true)
+  typeNotes('typed while loading')
+  const area = document.querySelector('textarea')
+  await act(async () => latest.resolve(newerCrash))
+  await flush()
+  expect(document.body.textContent).toContain('Orca 9.9.9')
+  expect(document.querySelector('textarea')).toBe(area)
+  expect(notes()).toBe('typed while loading')
+})
+
+it('a latest-report load that lands after Help over a report on screen never swaps it', async () => {
+  const pending = Promise.withResolvers<CrashReportRecord | null>()
+  crashReports.getLatestPending.mockReturnValue(pending.promise)
+  const latest = Promise.withResolvers<CrashReportRecord | null>()
+  crashReports.getLatestReport.mockReturnValue(latest.promise)
+  await mountBoth({ waitForCrash: false })
+  await openFromHelp()
+  await act(async () => button("Don't Send").click())
+  await flush()
+  await act(async () => pending.resolve(pendingCrash))
+  await flush()
+  expect(document.body.textContent).toContain('Orca 1.0.0')
+  await openFromHelp()
+  await act(async () => latest.resolve(newerCrash))
+  await flush()
+  expect(document.body.textContent).toContain('Orca 1.0.0')
+  expect(document.body.textContent).not.toContain('Orca 9.9.9')
+})
+
+it('Help pressed again while its dialog is open keeps the same dialog and its notes', async () => {
+  crashReports.getLatestPending.mockResolvedValue(null)
+  crashReports.getLatestReport.mockResolvedValue(newerCrash)
+  await mountBoth({ waitForCrash: false })
+  await openFromHelp()
+  typeNotes('second help press')
+  await openFromHelp()
+  expect(notes()).toBe('second help press')
+  expect(crashReports.getLatestReport).toHaveBeenCalledTimes(1)
+})
+
+it('Help opens at once over a queued report, which then waits behind it', async () => {
+  crashReports.getLatestPending.mockResolvedValue(null)
+  await mountBoth({ waitForCrash: false })
+  raiseSsh()
+  await flush()
+  await openFromHelp()
+  expect(crashOnScreen()).toBe(true)
+  expect(sshOnScreen()).toBe(true)
+})
diff --git a/src/renderer/src/components/crash-report/CrashReportDialog.tsx b/src/renderer/src/components/crash-report/CrashReportDialog.tsx
index fe2ba9b90241..21995ec4166f 100644
--- a/src/renderer/src/components/crash-report/CrashReportDialog.tsx
+++ b/src/renderer/src/components/crash-report/CrashReportDialog.tsx
@@ -1,10 +1,16 @@
 import { Suspense, useCallback, useEffect, useRef, useState } from 'react'
 import { lazyWithRetry as lazy } from '@/lib/lazy-with-retry'
+import { readStartupDiscovery } from '@/startup/startup-discovery-read'
 import { useMountedRef } from '@/hooks/useMountedRef'
 import {
   REACT_ERROR_BOUNDARY_REPORT_AVAILABLE_EVENT,
-  takePendingReactErrorBoundaryReport
+  takePendingReactErrorBoundaryReports
 } from '@/lib/react-error-boundary-reporting'
+import { DialogEntryScope, useDialogDisposal } from '@/lib/dialog-registry-entry'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectAdmittedDialog } from '@/store/dialog-registry-state'
+import { RecoverableRenderErrorBoundary } from '../error-boundaries/RecoverableRenderErrorBoundary'
+import { useCrashReportSends } from './use-crash-report-sends'
 import type { CrashReportRecord } from '../../../../shared/crash-reporting'
 
 const CrashReportDialogSurface = lazy(() =>
@@ -13,53 +19,80 @@ const CrashReportDialogSurface = lazy(() =>
   }))
 )
 
+/** Help > Report Crash's own entry. */
+const USER_DIALOG_TOKEN = 'crash-report-dialog:user'
+
+function crashReportToken(reportId: string): string {
+  return `crash-report:${reportId}`
+}
+
+/** Help > Report Crash, opened over no report: the latest one, once loaded. */
+type UserDialog = { report: CrashReportRecord | null }
+
 export function CrashReportDialog(): React.JSX.Element | null {
   const promptedThisLaunch = useRef(false)
+  const pendingLaunchAckToken = useRef<string | null>(null)
   const mountedRef = useMountedRef()
-  const [open, setOpen] = useState(false)
-  const [report, setReport] = useState<CrashReportRecord | null>(null)
+  const [userDialog, setUserDialog] = useState<UserDialog | null>(null)
   const [loading, setLoading] = useState(false)
+  const [reports, setReports] = useState<ReadonlyMap<string, CrashReportRecord>>(() => new Map())
+  const admitted = useDialogRegistry((s) => selectAdmittedDialog(s, 'crash-report'))
+  const admittedReport = admitted ? reports.get(admitted.token) : undefined
+  const ownedTokens = useRef(new Set<string>())
+  const disposeReports = useCallback(() => {
+    pendingLaunchAckToken.current = null
+    const registry = useDialogRegistry.getState()
+    for (const token of ownedTokens.current) {
+      registry.endDialog(token)
+    }
+    registry.settleStartupSource('crash-report', 'unavailable')
+  }, [])
+  useDialogDisposal(USER_DIALOG_TOKEN, disposeReports)
 
-  const openCrashReport = useCallback((nextReport: CrashReportRecord): void => {
-    setReport(nextReport)
-    setOpen(true)
+  const raiseCrashReport = useCallback((report: CrashReportRecord) => {
+    const token = crashReportToken(report.id)
+    // Repeated delivery of an identical ID must not reopen a dismissed report.
+    if (ownedTokens.current.has(token)) {
+      return
+    }
+    ownedTokens.current.add(token)
+    setReports((current) => (current.has(token) ? current : new Map(current).set(token, report)))
+    useDialogRegistry.getState().enqueueAutomaticDialog(token, 'crash-report')
   }, [])
 
-  const loadCrashReport = useCallback(
-    async (promptIfPresent: boolean): Promise<void> => {
-      setLoading(true)
-      try {
-        const nextReport = promptIfPresent
-          ? await window.api.crashReports.getLatestPending()
-          : await window.api.crashReports.getLatestReport()
-        let displayedReport = nextReport
-        if (nextReport?.status === 'pending' && promptIfPresent) {
-          try {
-            // Why: startup crash prompts are one-shot. The lazy dialog keeps the
-            // report data locally if the user sends immediately, while Help >
-            // Report Crash can still reopen dismissed unsent reports.
-            await window.api.crashReports.dismiss({ reportId: nextReport.id })
-            displayedReport = { ...nextReport, status: 'dismissed' as const }
-          } catch (error) {
-            console.error('Failed to dismiss crash report after startup prompt:', error)
-          }
-        }
-        if (!mountedRef.current) {
-          return
-        }
-        setReport(displayedReport)
-        if (nextReport && promptIfPresent) {
-          setOpen(true)
-        }
-      } catch (error) {
-        console.error('Failed to load crash report:', error)
-      } finally {
-        if (mountedRef.current) {
-          setLoading(false)
-        }
-      }
-    },
-    [mountedRef]
+  // By id, not by who opened it: a send started before Help took the dialog over lands either way.
+  const changeReport = useCallback((report: CrashReportRecord | null) => {
+    if (!report) {
+      return
+    }
+    const token = crashReportToken(report.id)
+    setUserDialog((current) =>
+      current?.report?.id === report.id ? { ...current, report } : current
+    )
+    setReports((current) => {
+      return current.has(token) ? new Map(current).set(token, report) : current
+    })
+  }, [])
+
+  // Done with a report however it opened: one report, one dialog.
+  const closeReport = useCallback((reportId: string | null) => {
+    if (reportId === null) {
+      return
+    }
+    const token = crashReportToken(reportId)
+    useDialogRegistry.getState().closeDialog(token)
+  }, [])
+
+  const { send, isSending } = useCrashReportSends(
+    useCallback(
+      (reportId: string | null, sent: CrashReportRecord | null) => {
+        changeReport(sent)
+        // A dialog showing another report stays open.
+        setUserDialog((current) => ((current?.report?.id ?? null) === reportId ? null : current))
+        closeReport(reportId)
+      },
+      [changeReport, closeReport]
+    )
   )
 
   useEffect(() => {
@@ -67,52 +100,137 @@ export function CrashReportDialog(): React.JSX.Element | null {
       return
     }
     promptedThisLaunch.current = true
-    void loadCrashReport(true)
-  }, [loadCrashReport])
+    void readStartupDiscovery(
+      window.api.crashReports.getLatestPending().then((report) => ({ report }))
+    ).then((result) => {
+      if (!mountedRef.current) {
+        // No owner left to show it; later dialogs must not wait on it.
+        useDialogRegistry.getState().settleStartupSource('crash-report', 'unavailable')
+        return
+      }
+      const pending = result?.report
+      if (pending) {
+        pendingLaunchAckToken.current =
+          pending.status === 'pending' ? crashReportToken(pending.id) : null
+        raiseCrashReport(pending)
+      }
+      useDialogRegistry
+        .getState()
+        .settleStartupSource(
+          'crash-report',
+          result === null ? 'unavailable' : pending ? 'ready' : 'none'
+        )
+    })
+  }, [mountedRef, raiseCrashReport])
 
   useEffect(() => {
-    return window.api.ui.onOpenCrashReport(() => {
-      setReport(null)
-      setOpen(true)
-      void loadCrashReport(false)
-    })
-  }, [loadCrashReport])
+    const raisePending = (): void => {
+      for (const report of takePendingReactErrorBoundaryReports()) {
+        raiseCrashReport(report)
+      }
+    }
+    raisePending()
+    window.addEventListener(REACT_ERROR_BOUNDARY_REPORT_AVAILABLE_EVENT, raisePending)
+    return () =>
+      window.removeEventListener(REACT_ERROR_BOUNDARY_REPORT_AVAILABLE_EVENT, raisePending)
+  }, [raiseCrashReport])
 
+  // From the committed content: the lazy surface may load well after the turn is granted.
+  const visibleToken = admitted?.phase === 'visible' ? admitted.token : null
   useEffect(() => {
-    const pendingReport = takePendingReactErrorBoundaryReport()
-    if (pendingReport) {
-      openCrashReport(pendingReport)
+    const report = visibleToken === null ? undefined : reports.get(visibleToken)
+    if (!report || visibleToken !== pendingLaunchAckToken.current) {
+      return
     }
+    pendingLaunchAckToken.current = null
+    // Why: startup crash prompts are one-shot. Never awaited: a failed write must not hold the
+    // prompt back, and the dialog dismisses a still-pending report on close. Help > Report Crash
+    // can still reopen dismissed unsent reports.
+    void window.api.crashReports
+      .dismiss({ reportId: report.id })
+      .then(() => {
+        if (mountedRef.current) {
+          changeReport({ ...report, status: 'dismissed' as const })
+        }
+      })
+      .catch((error) => {
+        console.error('Failed to dismiss crash report after startup prompt:', error)
+      })
+  }, [changeReport, mountedRef, reports, visibleToken])
 
-    const onReactErrorBoundaryReport = (): void => {
-      const nextReport = takePendingReactErrorBoundaryReport()
-      if (nextReport) {
-        openCrashReport(nextReport)
+  const loadUserCrashReport = useCallback(async (): Promise<void> => {
+    setLoading(true)
+    try {
+      const latest = await window.api.crashReports.getLatestReport()
+      if (mountedRef.current && latest) {
+        // Only into a dialog still waiting for one; a report already shown is never swapped.
+        setUserDialog((current) =>
+          current && current.report === null ? { report: latest } : current
+        )
+      }
+    } catch (error) {
+      console.error('Failed to load crash report:', error)
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false)
       }
     }
+  }, [mountedRef])
 
-    window.addEventListener(REACT_ERROR_BOUNDARY_REPORT_AVAILABLE_EVENT, onReactErrorBoundaryReport)
-    return () => {
-      window.removeEventListener(
-        REACT_ERROR_BOUNDARY_REPORT_AVAILABLE_EVENT,
-        onReactErrorBoundaryReport
-      )
-    }
-  }, [openCrashReport])
+  const reportOnScreen = admitted?.phase === 'visible'
+  useEffect(() => {
+    return window.api.ui.onOpenCrashReport(() => {
+      // A report dialog already up is the one Help would show: it stays as it is, notes and all.
+      if (userDialog !== null || reportOnScreen) {
+        return
+      }
+      setUserDialog({ report: null })
+      void loadUserCrashReport()
+    })
+  }, [loadUserCrashReport, reportOnScreen, userDialog])
 
-  if (!open) {
+  if (userDialog === null && !admittedReport) {
     return null
   }
+  const report = userDialog ? userDialog.report : (admittedReport ?? null)
+  const surfaceKey = userDialog ? USER_DIALOG_TOKEN : admitted?.token
+  const open = userDialog !== null || admitted?.phase !== 'closing'
 
   return (
-    <Suspense fallback={null}>
-      <CrashReportDialogSurface
-        open={open}
-        report={report}
-        loading={loading}
-        onOpenChange={setOpen}
-        onReportChange={setReport}
-      />
-    </Suspense>
+    <DialogEntryScope
+      token={userDialog ? USER_DIALOG_TOKEN : (admitted?.token ?? USER_DIALOG_TOKEN)}
+    >
+      <RecoverableRenderErrorBoundary
+        boundaryId="modal.crash-report-content"
+        surface="modal"
+        reportAsCrash={false}
+        compact
+        key={surfaceKey}
+        onError={() => {
+          if (admitted && !userDialog) {
+            useDialogRegistry.getState().endDialog(admitted.token)
+          }
+          setUserDialog(null)
+        }}
+      >
+        <Suspense fallback={null}>
+          <CrashReportDialogSurface
+            key={surfaceKey}
+            open={open}
+            report={report}
+            loading={loading && report === null}
+            onOpenChange={(nextOpen) => {
+              if (!nextOpen) {
+                setUserDialog(null)
+                closeReport(report?.id ?? null)
+              }
+            }}
+            onReportChange={changeReport}
+            submitting={isSending(report)}
+            onSubmit={(request) => send(report, request)}
+          />
+        </Suspense>
+      </RecoverableRenderErrorBoundary>
+    </DialogEntryScope>
   )
 }
diff --git a/src/renderer/src/components/crash-report/CrashReportDialogSurface.overflow.test.tsx b/src/renderer/src/components/crash-report/CrashReportDialogSurface.overflow.test.tsx
index a26ff7b89428..6fd26d934fee 100644
--- a/src/renderer/src/components/crash-report/CrashReportDialogSurface.overflow.test.tsx
+++ b/src/renderer/src/components/crash-report/CrashReportDialogSurface.overflow.test.tsx
@@ -1,7 +1,7 @@
 // @vitest-environment happy-dom
 
 import type { ReactNode } from 'react'
-import { cleanup, render, waitFor } from '@testing-library/react'
+import { cleanup, fireEvent, render, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { CrashReportRecord } from '../../../../shared/crash-reporting'
 import { CrashReportDialogSurface } from './CrashReportDialogSurface'
@@ -65,6 +65,8 @@ describe('CrashReportDialogSurface overflow containment', () => {
         loading={false}
         onOpenChange={() => {}}
         onReportChange={() => {}}
+        submitting={false}
+        onSubmit={async () => ({ ok: true, report: null })}
       />
     )
     await waitFor(() => expect(viewer).toHaveBeenCalledOnce())
@@ -82,3 +84,31 @@ describe('CrashReportDialogSurface overflow containment', () => {
     expect(output?.parentElement?.className).toContain('min-w-0')
   })
 })
+
+it.each(['pending', 'rejected'] as const)(
+  "Don't Send closes immediately while dismissal is %s",
+  async (outcome) => {
+    const pending = Promise.withResolvers<void>()
+    Object.assign(window.api, { crashReports: { dismiss: () => pending.promise } })
+    const onOpenChange = vi.fn()
+    const silent = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const screen = render(
+      <CrashReportDialogSurface
+        open
+        report={crashReport('error')}
+        loading={false}
+        onOpenChange={onOpenChange}
+        onReportChange={() => {}}
+        submitting={false}
+        onSubmit={async () => ({ ok: true, report: null })}
+      />
+    )
+    fireEvent.click(screen.getByText("Don't Send"))
+    expect(onOpenChange).toHaveBeenCalledWith(false)
+    if (outcome === 'rejected') {
+      pending.reject(new Error('write failed'))
+      await waitFor(() => expect(silent).toHaveBeenCalled())
+    }
+    silent.mockRestore()
+  }
+)
diff --git a/src/renderer/src/components/crash-report/CrashReportDialogSurface.tsx b/src/renderer/src/components/crash-report/CrashReportDialogSurface.tsx
index 05ad8fff24e5..46d1276480af 100644
--- a/src/renderer/src/components/crash-report/CrashReportDialogSurface.tsx
+++ b/src/renderer/src/components/crash-report/CrashReportDialogSurface.tsx
@@ -18,17 +18,18 @@ import {
   isReactErrorBoundaryReport,
   MAX_USER_NOTES_LENGTH,
   type CrashReportDiagnosticBundle,
-  type CrashReportRecord
+  type CrashReportRecord,
+  type CrashReportSubmitResult
 } from '../../../../shared/crash-reporting'
 import type { GitHubViewer } from '../../../../shared/github/pull-request-types'
 import { translate } from '@/i18n/i18n'
 import {
   CRASH_REPORT_SUBMIT_FAILURE_TOAST_ID,
   getCrashReportCopySubmissionFailure,
-  getCrashReportSubmitFailureNotice,
-  getCrashReportSubmitWarningNotice
+  getCrashReportSubmitFailureNotice
 } from './crash-report-submit-notice'
 import { useCrashReportCopy } from './use-crash-report-copy'
+import type { CrashReportSendRequest } from './use-crash-report-sends'
 
 function formatSummary(report: CrashReportRecord): string {
   if (isReactErrorBoundaryReport(report)) {
@@ -73,6 +74,10 @@ type CrashReportDialogSurfaceProps = {
   loading: boolean
   onOpenChange: (open: boolean) => void
   onReportChange: (report: CrashReportRecord | null) => void
+  /** This report's send is in flight, wherever it was started. */
+  submitting: boolean
+  /** Sends through the owner, which settles the report even if this dialog is gone by then. */
+  onSubmit: (request: CrashReportSendRequest) => Promise<CrashReportSubmitResult>
 }
 
 export function CrashReportDialogSurface({
@@ -80,12 +85,13 @@ export function CrashReportDialogSurface({
   report,
   loading,
   onOpenChange,
-  onReportChange
+  onReportChange,
+  submitting,
+  onSubmit
 }: CrashReportDialogSurfaceProps): React.JSX.Element {
   const mountedRef = useMountedRef()
   const [notes, setNotes] = useState('')
   const [includeDiagnosticLogs, setIncludeDiagnosticLogs] = useState(true)
-  const [submitting, setSubmitting] = useState(false)
   const [viewer, setViewer] = useState<GitHubViewer | null>(null)
   // Why: account lookup can resolve after the dialog closes or reopens.
   // Sequence the request so a stale viewer is never used for submission.
@@ -161,18 +167,17 @@ export function CrashReportDialogSurface({
     }
   }
 
-  const handleDismiss = async (): Promise<void> => {
-    await dismissReportIfNeeded()
-    if (mountedRef.current) {
-      onOpenChange(false)
-    }
+  // Bookkeeping never holds a closing dialog open: it closes whatever the dismissal answers.
+  const closeAndDismiss = (): void => {
+    void dismissReportIfNeeded().catch((error) => {
+      console.error('Failed to dismiss crash report:', error)
+    })
+    onOpenChange(false)
   }
 
   const handleSubmit = async (): Promise<void> => {
-    setSubmitting(true)
     try {
-      const result = await window.api.crashReports.submit({
-        ...(report ? { reportId: report.id } : {}),
+      const result = await onSubmit({
         notes,
         includeDiagnosticLogs,
         // Why: crash reporting must degrade to anonymous if gh is unavailable;
@@ -186,31 +191,12 @@ export function CrashReportDialogSurface({
         console.error('Failed to submit crash report:', result.error)
         return
       }
-      if (!mountedRef.current) {
-        return
-      }
-      onReportChange(result.report)
-      setNotes('')
-      toast.dismiss(CRASH_REPORT_SUBMIT_FAILURE_TOAST_ID)
-      const warningNotice = getCrashReportSubmitWarningNotice(result, includeDiagnosticLogs)
-      if (warningNotice) {
-        toast.warning(warningNotice.title, { description: warningNotice.description })
-      } else {
-        toast.success(
-          translate(
-            'auto.components.crash.report.CrashReportDialog.8e24fe4f75',
-            'Crash report sent.'
-          )
-        )
+      if (mountedRef.current) {
+        setNotes('')
       }
-      onOpenChange(false)
     } catch (error) {
       showSubmitFailure(error)
       console.error('Failed to submit crash report:', error)
-    } finally {
-      if (mountedRef.current) {
-        setSubmitting(false)
-      }
     }
   }
 
@@ -223,11 +209,7 @@ export function CrashReportDialogSurface({
         }
         if (!nextOpen) {
           clearViewer()
-          void dismissReportIfNeeded().finally(() => {
-            if (mountedRef.current) {
-              onOpenChange(false)
-            }
-          })
+          closeAndDismiss()
           return
         }
         onOpenChange(true)
@@ -335,7 +317,7 @@ export function CrashReportDialogSurface({
             type="button"
             variant="ghost"
             size="sm"
-            onClick={handleDismiss}
+            onClick={closeAndDismiss}
             disabled={submitting}
           >
             {translate('auto.components.crash.report.CrashReportDialog.88fea8e84e', "Don't Send")}
diff --git a/src/renderer/src/components/crash-report/use-crash-report-sends.ts b/src/renderer/src/components/crash-report/use-crash-report-sends.ts
new file mode 100644
index 000000000000..343a51b8d5e6
--- /dev/null
+++ b/src/renderer/src/components/crash-report/use-crash-report-sends.ts
@@ -0,0 +1,82 @@
+import { useCallback, useState } from 'react'
+import { toast } from 'sonner'
+import { translate } from '@/i18n/i18n'
+import type {
+  CrashReportRecord,
+  CrashReportSubmitArgs,
+  CrashReportSubmitResult
+} from '../../../../shared/crash-reporting'
+import {
+  CRASH_REPORT_SUBMIT_FAILURE_TOAST_ID,
+  getCrashReportSubmitWarningNotice
+} from './crash-report-submit-notice'
+
+export type CrashReportSendRequest = Omit<CrashReportSubmitArgs, 'reportId'>
+
+/** The send key of a dialog opened from Help with no captured report. */
+const NO_REPORT = ''
+
+/**
+ * Crash report sends, owned by the dialog's owner and keyed by report id, so a send's result
+ * settles its report even when the dialog that started it was replaced or closed meanwhile, and a
+ * report already being sent can never be sent again.
+ */
+export function useCrashReportSends(
+  onSent: (reportId: string | null, sent: CrashReportRecord | null) => void
+): {
+  send: (
+    report: CrashReportRecord | null,
+    request: CrashReportSendRequest
+  ) => Promise<CrashReportSubmitResult>
+  isSending: (report: CrashReportRecord | null) => boolean
+} {
+  const [sending, setSending] = useState<ReadonlySet<string>>(() => new Set())
+
+  const send = useCallback(
+    async (
+      report: CrashReportRecord | null,
+      request: CrashReportSendRequest
+    ): Promise<CrashReportSubmitResult> => {
+      const key = report?.id ?? NO_REPORT
+      setSending((current) => new Set(current).add(key))
+      try {
+        const result = await window.api.crashReports.submit({
+          ...(report ? { reportId: report.id } : {}),
+          ...request
+        })
+        if (result.ok) {
+          onSent(report?.id ?? null, result.report)
+          toast.dismiss(CRASH_REPORT_SUBMIT_FAILURE_TOAST_ID)
+          const warningNotice = getCrashReportSubmitWarningNotice(
+            result,
+            request.includeDiagnosticLogs === true
+          )
+          if (warningNotice) {
+            toast.warning(warningNotice.title, { description: warningNotice.description })
+          } else {
+            toast.success(
+              translate(
+                'auto.components.crash.report.CrashReportDialog.8e24fe4f75',
+                'Crash report sent.'
+              )
+            )
+          }
+        }
+        return result
+      } finally {
+        setSending((current) => {
+          const next = new Set(current)
+          next.delete(key)
+          return next
+        })
+      }
+    },
+    [onSent]
+  )
+
+  const isSending = useCallback(
+    (report: CrashReportRecord | null) => sending.has(report?.id ?? NO_REPORT),
+    [sending]
+  )
+  return { send, isSending }
+}
diff --git a/src/renderer/src/components/error-boundaries/RecoverableRenderErrorBoundary.tsx b/src/renderer/src/components/error-boundaries/RecoverableRenderErrorBoundary.tsx
index e4c03e96aa0e..50266934dd10 100644
--- a/src/renderer/src/components/error-boundaries/RecoverableRenderErrorBoundary.tsx
+++ b/src/renderer/src/components/error-boundaries/RecoverableRenderErrorBoundary.tsx
@@ -19,6 +19,7 @@ type Props = {
   className?: string
   compact?: boolean
   reportAsCrash?: boolean
+  onError?: () => void
   resetKey?: string | number | boolean | null
   title?: string
   description?: string
@@ -45,6 +46,7 @@ export class RecoverableRenderErrorBoundary extends React.Component<Props, State
   }
 
   componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {
+    this.props.onError?.()
     console.error(`[${this.props.boundaryId}] render crash contained by boundary`, error, errorInfo)
     if (this.props.reportAsCrash === false) {
       return
@@ -69,9 +71,12 @@ export class RecoverableRenderErrorBoundary extends React.Component<Props, State
     if (!this.state.error) {
       return this.props.children
     }
+    return this.renderFallback(this.state.error)
+  }
 
+  private renderFallback(error: Error): React.ReactNode {
     if (this.props.fallback) {
-      return this.props.fallback({ error: this.state.error, reset: this.handleReset })
+      return this.props.fallback({ error, reset: this.handleReset })
     }
 
     return (
diff --git a/src/renderer/src/components/feature-tips/AppOpenFeatureTip.test.tsx b/src/renderer/src/components/feature-tips/AppOpenFeatureTip.test.tsx
new file mode 100644
index 000000000000..cfc085e5e3cb
--- /dev/null
+++ b/src/renderer/src/components/feature-tips/AppOpenFeatureTip.test.tsx
@@ -0,0 +1,177 @@
+// @vitest-environment happy-dom
+
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeAll, beforeEach, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectDialogPhase } from '@/store/dialog-registry-state'
+import { resetDialogRegistryForTests } from '@/store/dialog-registry-test-state'
+import { getDefaultSettings } from '../../../../shared/constants'
+import { AppOpenFeatureTip } from './AppOpenFeatureTip'
+import { APP_OPEN_FEATURE_TIP_TOKEN } from './feature-tip-startup-gate'
+import { SshPassphraseDialog } from '../settings/SshPassphraseDialog'
+import { TooltipProvider } from '../ui/tooltip'
+
+const terminal = vi.hoisted(() => ({ mounts: 0, unmounts: 0 }))
+vi.mock('./CliSkillSetupTerminal', async () => {
+  const { useEffect } = await import('react')
+  return {
+    // Stands in for the inline installer terminal, whose unmount closes its PTY tab.
+    CliSkillSetupTerminal: () => {
+      useEffect(() => {
+        terminal.mounts += 1
+        return () => {
+          terminal.unmounts += 1
+        }
+      }, [])
+      return <div data-testid="skill-terminal" />
+    }
+  }
+})
+vi.mock('./feature-tip-cli-install-action', () => ({
+  installCliFromFeatureTip: vi.fn(async () => ({
+    kind: 'installed',
+    status: { state: 'installed', pathConfigured: true }
+  }))
+}))
+vi.mock('./CliFeatureTipVisual', () => ({ CliFeatureTipVisual: () => null }))
+vi.mock('sonner', () => ({
+  toast: Object.assign(vi.fn(), { error: vi.fn(), success: vi.fn(), warning: vi.fn() })
+}))
+vi.mock('@/lib/telemetry', () => ({ track: vi.fn() }))
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+let root: Root
+let container: HTMLDivElement
+
+beforeAll(async () => {
+  // Transform the real content before testing its lifecycle; lazy admission is covered separately.
+  await import('./FeatureTipsModal')
+})
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 6; i += 1) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0))
+    })
+  }
+}
+
+/** The SSH prompt as the app hosts it. */
+function SshHost(): React.JSX.Element | null {
+  const asked = useAppStore((s) => s.sshCredentialQueue.length > 0)
+  return asked ? <SshPassphraseDialog /> : null
+}
+
+beforeEach(() => {
+  terminal.mounts = 0
+  terminal.unmounts = 0
+  resetDialogRegistryForTests({ startupSettled: true })
+  useAppStore.setState(useAppStore.getInitialState(), true)
+  useAppStore.setState({ settings: getDefaultSettings(''), persistedUIReady: true })
+  Object.assign(window, {
+    api: {
+      cli: { install: vi.fn(async () => ({})) },
+      ui: { set: vi.fn(async () => undefined) },
+      ssh: { submitCredential: vi.fn(async () => undefined) }
+    }
+  })
+  container = document.createElement('div')
+  document.body.append(container)
+  root = createRoot(container)
+})
+
+afterEach(() => {
+  act(() => root.unmount())
+  container.remove()
+  vi.restoreAllMocks()
+})
+
+it('closing keeps actual tip content until its exit ends and records seen only on commit', async () => {
+  const markSeen = vi.fn(useAppStore.getState().markFeatureTipsSeen)
+  useAppStore.setState({ markFeatureTipsSeen: markSeen })
+  await act(async () =>
+    root.render(
+      <TooltipProvider>
+        <AppOpenFeatureTip tipId="cmd-j-palette" />
+      </TooltipProvider>
+    )
+  )
+  await flush()
+  await vi.waitFor(() => expect(document.querySelector('[role="dialog"]')).not.toBeNull(), {
+    timeout: 10_000
+  })
+  const content = document.querySelector<HTMLElement>('[data-slot="dialog-content"]')
+  if (!content) {
+    throw new Error('Tip content did not mount')
+  }
+  content.style.animationName = 'fade-out'
+  act(() => useDialogRegistry.getState().enqueueAutomaticDialog('resume', 'native-chat-resume'))
+  const acknowledge = [...content.querySelectorAll('button')].find((button) =>
+    button.textContent?.includes('Got it')
+  )
+  await act(async () => acknowledge?.click())
+  await flush()
+  expect(content.isConnected).toBe(true)
+  expect(content.getAttribute('data-state')).toBe('closed')
+  expect(selectDialogPhase(useDialogRegistry.getState(), APP_OPEN_FEATURE_TIP_TOKEN)).toBe(
+    'closing'
+  )
+  expect(selectDialogPhase(useDialogRegistry.getState(), 'resume')).toBe('queued')
+  expect(markSeen).toHaveBeenCalledExactlyOnceWith(['cmd-j-palette'])
+  const ended = new Event('animationend', { bubbles: true })
+  Object.defineProperty(ended, 'animationName', { value: 'fade-out' })
+  await act(async () => content.dispatchEvent(ended))
+  expect(content.isConnected).toBe(false)
+  expect(selectDialogPhase(useDialogRegistry.getState(), 'resume')).toBe('opening')
+})
+
+it('an SSH prompt and a user modal stack over the app-open tip, which keeps its setup terminal', async () => {
+  await act(async () =>
+    root.render(
+      <TooltipProvider>
+        <AppOpenFeatureTip tipId="orca-cli" />
+        <SshHost />
+      </TooltipProvider>
+    )
+  )
+  await flush()
+  // Its code loads on first use.
+  await vi.waitFor(() => expect(document.querySelector('[role="dialog"]')).not.toBeNull(), {
+    timeout: 10_000
+  })
+  await flush()
+  expect(useAppStore.getState().featureTipsSeenIds).toEqual(['orca-cli'])
+  const install = [...document.querySelectorAll('button')].find((b) =>
+    b.textContent?.includes('Install CLI')
+  )
+  await act(async () => install?.click())
+  await flush()
+  expect(terminal).toEqual({ mounts: 1, unmounts: 0 })
+  const tipDialog = document
+    .querySelector('[data-testid="skill-terminal"]')
+    ?.closest('[role="dialog"]')
+  expect(tipDialog).toBeTruthy()
+
+  act(() => {
+    useAppStore.getState().enqueueSshCredentialRequest({
+      requestId: 'r1',
+      targetId: 't1',
+      kind: 'passphrase',
+      detail: '~/.ssh/id_ed25519'
+    })
+  })
+  await flush()
+  expect(document.body.textContent).toContain('SSH Key Passphrase')
+  expect(tipDialog?.isConnected).toBe(true)
+  await act(async () => useAppStore.getState().removeSshCredentialRequest('r1'))
+  await flush()
+
+  // Not in the modal slot, so a modal the user opens cannot replace it.
+  act(() => useAppStore.getState().openModal('add-repo'))
+  act(() => useAppStore.getState().closeModal())
+  await flush()
+  expect(tipDialog?.isConnected).toBe(true)
+  expect(terminal).toEqual({ mounts: 1, unmounts: 0 })
+})
diff --git a/src/renderer/src/components/feature-tips/AppOpenFeatureTip.tsx b/src/renderer/src/components/feature-tips/AppOpenFeatureTip.tsx
new file mode 100644
index 000000000000..f30e1f2ad4f0
--- /dev/null
+++ b/src/renderer/src/components/feature-tips/AppOpenFeatureTip.tsx
@@ -0,0 +1,69 @@
+import { Suspense, useEffect, useRef, useState } from 'react'
+import { lazyWithRetry as lazy } from '@/lib/lazy-with-retry'
+import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { DialogEntryScope, useAutomaticDialogEntry } from '@/lib/dialog-registry-entry'
+import { RecoverableRenderErrorBoundary } from '../error-boundaries/RecoverableRenderErrorBoundary'
+import type { FeatureTipId } from '../../../../shared/feature-tips'
+import { APP_OPEN_FEATURE_TIP_TOKEN } from './feature-tip-startup-gate'
+import {
+  trackCmdJPaletteFeatureTipShown,
+  trackOrcaCliFeatureTipShown
+} from './feature-tip-telemetry'
+
+const FeatureTipDialogs = lazy(() =>
+  import('./FeatureTipsModal').then((module) => ({ default: module.FeatureTipDialogs }))
+)
+
+/**
+ * The tip the app offers by itself at launch. It waits its turn among the dialogs that open by
+ * themselves and renders here, not in the modal slot, so a dialog the user opens stacks over it
+ * rather than replacing it.
+ */
+export function AppOpenFeatureTip({ tipId }: { tipId: FeatureTipId }): React.JSX.Element | null {
+  const [closed, setClosed] = useState(false)
+  const phase = useAutomaticDialogEntry(
+    APP_OPEN_FEATURE_TIP_TOKEN,
+    'feature-tip',
+    closed ? null : 'automatic'
+  )
+  const markFeatureTipsSeen = useAppStore((s) => s.markFeatureTipsSeen)
+
+  const shownRef = useRef(false)
+  useEffect(() => {
+    if (phase !== 'visible' || shownRef.current) {
+      return
+    }
+    shownRef.current = true
+    if (tipId === 'orca-cli') {
+      trackOrcaCliFeatureTipShown('app_open')
+    } else if (tipId === 'cmd-j-palette') {
+      trackCmdJPaletteFeatureTipShown('app_open')
+    }
+    // Why: marked seen once on screen, so a quit/crash before dismiss doesn't reappear it next
+    // launch, while one that never got its turn is still offered next time.
+    markFeatureTipsSeen([tipId])
+  }, [markFeatureTipsSeen, phase, tipId])
+
+  if (phase === null || phase === 'queued') {
+    return null
+  }
+  return (
+    <DialogEntryScope token={APP_OPEN_FEATURE_TIP_TOKEN}>
+      <RecoverableRenderErrorBoundary
+        boundaryId="modal.app-open-feature-tip"
+        surface="modal"
+        compact
+        onError={() => useDialogRegistry.getState().endDialog(APP_OPEN_FEATURE_TIP_TOKEN)}
+      >
+        <Suspense fallback={null}>
+          <FeatureTipDialogs
+            open={phase !== 'closing'}
+            tipId={tipId}
+            onClose={() => setClosed(true)}
+          />
+        </Suspense>
+      </RecoverableRenderErrorBoundary>
+    </DialogEntryScope>
+  )
+}
diff --git a/src/renderer/src/components/feature-tips/FeatureTipsModal.tsx b/src/renderer/src/components/feature-tips/FeatureTipsModal.tsx
index 631c121cc154..f861078c6488 100644
--- a/src/renderer/src/components/feature-tips/FeatureTipsModal.tsx
+++ b/src/renderer/src/components/feature-tips/FeatureTipsModal.tsx
@@ -1,6 +1,7 @@
 import { useEffect, useRef, useState, type JSX } from 'react'
 import { toast } from 'sonner'
 import { getDefaultVoiceSettings } from '../../../../shared/constants'
+import { FEATURE_TIPS, type FeatureTipId } from '../../../../shared/feature-tips'
 import {
   ORCHESTRATION_ENABLED_STORAGE_KEY,
   ORCHESTRATION_SETUP_DISMISSED_STORAGE_KEY,
@@ -10,78 +11,59 @@ import { useAppStore } from '@/store'
 import { CliSetupTipDialog } from './CliSetupTipDialog'
 import { CmdJPaletteTipDialog } from './CmdJPaletteTipDialog'
 import { installCliFromFeatureTip } from './feature-tip-cli-install-action'
-import { getFeatureTipForModal } from './feature-tip-modal-state'
 import {
-  getOrcaCliFeatureTipTelemetrySource,
   trackCmdJPaletteFeatureTipAcknowledged,
   trackOrcaCliFeatureTipSetupClicked,
   trackOrcaCliFeatureTipSetupResult
 } from './feature-tip-telemetry'
 import { useMountedRef } from '@/hooks/useMountedRef'
-import { isWebClientLocation } from '@/lib/web-client-location'
 import { translate } from '@/i18n/i18n'
 import { SessionSearchTipDialog } from './SessionSearchTipDialog'
 import { useSessionSearchTipSetup } from './use-session-search-tip-setup'
 import { VoiceDictationTipDialog } from './VoiceDictationTipDialog'
 
-export default function FeatureTipsModal(): JSX.Element | null {
-  const activeModal = useAppStore((s) => s.activeModal)
-  const closeModal = useAppStore((s) => s.closeModal)
+/** The tip the app offers at launch, controlled by its host (AppOpenFeatureTip). */
+export function FeatureTipDialogs({
+  open: isOpen,
+  tipId,
+  onClose: closeModal
+}: {
+  open: boolean
+  tipId: FeatureTipId
+  onClose: () => void
+}): JSX.Element | null {
   const openSettingsPage = useAppStore((s) => s.openSettingsPage)
   const openSettingsTarget = useAppStore((s) => s.openSettingsTarget)
   const settings = useAppStore((s) => s.settings)
   const updateSettings = useAppStore((s) => s.updateSettings)
-  const seenTipIds = useAppStore((s) => s.featureTipsSeenIds)
-  const featureInteractions = useAppStore((s) => s.featureInteractions)
-  const markFeatureTipsSeen = useAppStore((s) => s.markFeatureTipsSeen)
-  const modalData = useAppStore((s) => s.modalData)
   const showAiVaultSearch = useAppStore((s) => s.showAiVaultSearch)
   const mountedRef = useMountedRef()
-  const activeModalRef = useRef(activeModal)
+  const openRef = useRef(isOpen)
   const setupRequestIdRef = useRef(0)
   const [primaryBusy, setPrimaryBusy] = useState(false)
   const [skillTerminalOpen, setSkillTerminalOpen] = useState(false)
-  const isOpen = activeModal === 'feature-tips'
-  const currentTip = getFeatureTipForModal({
-    cliInstalled: true,
-    modalData,
-    seenTipIds,
-    featureInteractions,
-    settings,
-    webClient: isWebClientLocation()
-  })
+  const currentTip = FEATURE_TIPS.find((tip) => tip.id === tipId)
   const sessionSearchSetup = useSessionSearchTipSetup({
     dialogOpen: isOpen && currentTip?.id === 'agent-session-search'
   })
 
   useEffect(() => {
-    activeModalRef.current = activeModal
-  }, [activeModal])
-
-  const markCurrentTipSeen = (): void => {
-    if (currentTip) {
-      markFeatureTipsSeen([currentTip.id])
-    }
-  }
-
-  const handleOpenChange = (open: boolean): void => {
-    if (!open) {
-      setupRequestIdRef.current += 1
-      markCurrentTipSeen()
-      setSkillTerminalOpen(false)
-      setPrimaryBusy(false)
-      closeModal()
-    }
-  }
+    openRef.current = isOpen
+  }, [isOpen])
 
   const handleSkip = (): void => {
     setupRequestIdRef.current += 1
-    markCurrentTipSeen()
     setSkillTerminalOpen(false)
     setPrimaryBusy(false)
     closeModal()
   }
 
+  const handleOpenChange = (open: boolean): void => {
+    if (!open) {
+      handleSkip()
+    }
+  }
+
   const openCliSettings = (): void => {
     openSettingsTarget({ pane: 'general', repoId: null, sectionId: 'cli' })
     openSettingsPage()
@@ -91,21 +73,18 @@ export default function FeatureTipsModal(): JSX.Element | null {
     // Why: dismiss the tip when navigating away — the tip's job is done once
     // the user clicks through to rebind, and leaving it mounted behind the
     // settings page would re-appear on close.
-    markCurrentTipSeen()
     closeModal()
     openSettingsTarget({ pane: 'shortcuts', repoId: null })
     openSettingsPage()
   }
 
   const openVoiceSettings = (): void => {
-    markCurrentTipSeen()
     closeModal()
     openSettingsTarget({ pane: 'voice', repoId: null })
     openSettingsPage()
   }
 
   const openSessionSearchSettings = (): void => {
-    markCurrentTipSeen()
     closeModal()
     openSettingsTarget({ pane: 'session-history', repoId: null })
     openSettingsPage()
@@ -122,14 +101,11 @@ export default function FeatureTipsModal(): JSX.Element | null {
       return
     }
 
-    markFeatureTipsSeen([currentTip.id])
     switch (currentTip.action) {
       case 'learn-cmd-j-palette': {
         // Why: passive education tip — acknowledging just dismisses; the rebind
         // path lives in Settings and is reachable from the palette itself.
-        trackCmdJPaletteFeatureTipAcknowledged(
-          getOrcaCliFeatureTipTelemetrySource(modalData.source)
-        )
+        trackCmdJPaletteFeatureTipAcknowledged('app_open')
         closeModal()
         break
       }
@@ -166,16 +142,13 @@ export default function FeatureTipsModal(): JSX.Element | null {
         // Why: this modal is lazily mounted; closing it does not unmount the
         // component, so async install results must not reopen UI after dismissal.
         const canApplySetupResult = (): boolean =>
-          mountedRef.current &&
-          activeModalRef.current === 'feature-tips' &&
-          setupRequestIdRef.current === setupRequestId
-        const telemetrySource = getOrcaCliFeatureTipTelemetrySource(modalData.source)
-        trackOrcaCliFeatureTipSetupClicked(telemetrySource)
+          mountedRef.current && openRef.current && setupRequestIdRef.current === setupRequestId
+        trackOrcaCliFeatureTipSetupClicked('app_open')
         setPrimaryBusy(true)
         try {
           const result = await installCliFromFeatureTip(() => window.api.cli.install())
           if (result.kind === 'installed') {
-            trackOrcaCliFeatureTipSetupResult(telemetrySource, 'installed')
+            trackOrcaCliFeatureTipSetupResult('app_open', 'installed')
             if (!canApplySetupResult()) {
               return
             }
@@ -190,7 +163,7 @@ export default function FeatureTipsModal(): JSX.Element | null {
             return
           }
 
-          trackOrcaCliFeatureTipSetupResult(telemetrySource, 'needs_attention')
+          trackOrcaCliFeatureTipSetupResult('app_open', 'needs_attention')
           if (!canApplySetupResult()) {
             return
           }
@@ -216,7 +189,7 @@ export default function FeatureTipsModal(): JSX.Element | null {
             import.meta.env.DEV &&
             message.includes('Development mode uses a generated launcher for validation only')
           ) {
-            trackOrcaCliFeatureTipSetupResult(telemetrySource, 'dev_preview')
+            trackOrcaCliFeatureTipSetupResult('app_open', 'dev_preview')
             if (!canApplySetupResult()) {
               return
             }
@@ -231,7 +204,7 @@ export default function FeatureTipsModal(): JSX.Element | null {
             return
           }
 
-          trackOrcaCliFeatureTipSetupResult(telemetrySource, 'failed')
+          trackOrcaCliFeatureTipSetupResult('app_open', 'failed')
           if (canApplySetupResult()) {
             toast.error(message)
           }
@@ -244,7 +217,7 @@ export default function FeatureTipsModal(): JSX.Element | null {
     }
   }
 
-  if (!isOpen || !currentTip) {
+  if (!currentTip) {
     return null
   }
 
@@ -292,7 +265,7 @@ export default function FeatureTipsModal(): JSX.Element | null {
   }
 
   if (currentTip.action !== 'enable-voice') {
-    currentTip.action satisfies never
+    currentTip satisfies never
     return null
   }
 
diff --git a/src/renderer/src/components/feature-tips/feature-tip-modal-state.test.ts b/src/renderer/src/components/feature-tips/feature-tip-modal-state.test.ts
deleted file mode 100644
index d5e40c9c0514..000000000000
--- a/src/renderer/src/components/feature-tips/feature-tip-modal-state.test.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { getDefaultVoiceSettings } from '../../../../shared/constants'
-import type { GlobalSettings } from '../../../../shared/global-settings-types'
-import { getFeatureTipForModal } from './feature-tip-modal-state'
-
-// Session search defaults on so tests about the older tips don't see the session-search tip first.
-function makeSettings(
-  voiceEnabled = false,
-  sessionSearchEnabled = true
-): Pick<GlobalSettings, 'voice' | 'aiVaultSearch'> {
-  return {
-    voice: {
-      ...getDefaultVoiceSettings(),
-      enabled: voiceEnabled
-    },
-    aiVaultSearch: { enabled: sessionSearchEnabled, historyDays: null }
-  }
-}
-
-describe('feature tip modal state', () => {
-  it('keeps rendering the opened tip after app open has marked it seen', () => {
-    const tip = getFeatureTipForModal({
-      cliInstalled: false,
-      modalData: { tipId: 'voice-dictation' },
-      seenTipIds: ['voice-dictation'],
-      featureInteractions: {},
-      settings: makeSettings(),
-      webClient: false
-    })
-
-    expect(tip?.id).toBe('voice-dictation')
-  })
-
-  it('falls back to the CLI tip first when no modal tip id is pinned', () => {
-    const tip = getFeatureTipForModal({
-      cliInstalled: false,
-      modalData: {},
-      seenTipIds: [],
-      featureInteractions: {},
-      settings: makeSettings(),
-      webClient: false
-    })
-
-    expect(tip?.id).toBe('orca-cli')
-  })
-
-  it('falls back to the CLI tip when voice was already seen and the CLI is not installed', () => {
-    const tip = getFeatureTipForModal({
-      cliInstalled: false,
-      modalData: {},
-      seenTipIds: ['voice-dictation'],
-      featureInteractions: {},
-      settings: makeSettings(),
-      webClient: false
-    })
-
-    expect(tip?.id).toBe('orca-cli')
-  })
-
-  it('falls back to the command palette tip after the CLI tip is handled', () => {
-    const tip = getFeatureTipForModal({
-      cliInstalled: true,
-      modalData: {},
-      seenTipIds: ['orca-cli'],
-      featureInteractions: {},
-      settings: makeSettings(),
-      webClient: false
-    })
-
-    expect(tip?.id).toBe('cmd-j-palette')
-  })
-
-  it('returns no tip when every tip is already seen and no modal tip id is pinned', () => {
-    const tip = getFeatureTipForModal({
-      cliInstalled: false,
-      modalData: {},
-      seenTipIds: ['voice-dictation', 'orca-cli', 'cmd-j-palette'],
-      featureInteractions: {},
-      settings: makeSettings(),
-      webClient: false
-    })
-
-    expect(tip).toBeNull()
-  })
-
-  it('returns no CLI tip when the CLI is already installed', () => {
-    const tip = getFeatureTipForModal({
-      cliInstalled: true,
-      modalData: {},
-      seenTipIds: ['voice-dictation', 'cmd-j-palette'],
-      featureInteractions: {},
-      settings: makeSettings(),
-      webClient: false
-    })
-
-    expect(tip).toBeNull()
-  })
-
-  it('returns no unpinned tip after the user already interacted with the feature', () => {
-    const tip = getFeatureTipForModal({
-      cliInstalled: true,
-      modalData: {},
-      seenTipIds: ['cmd-j-palette'],
-      featureInteractions: {
-        'voice-dictation': { firstInteractedAt: 100, interactionCount: 1 }
-      },
-      settings: makeSettings(),
-      webClient: false
-    })
-
-    expect(tip).toBeNull()
-  })
-})
diff --git a/src/renderer/src/components/feature-tips/feature-tip-modal-state.ts b/src/renderer/src/components/feature-tips/feature-tip-modal-state.ts
deleted file mode 100644
index 8e38bcafaea8..000000000000
--- a/src/renderer/src/components/feature-tips/feature-tip-modal-state.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import type { FeatureInteractionState } from '../../../../shared/feature-interactions'
-import {
-  FEATURE_TIPS,
-  isFeatureTipId,
-  type FeatureTip,
-  type FeatureTipId
-} from '../../../../shared/feature-tips'
-import { getPendingFeatureTips, type FeatureTipSettings } from './feature-tip-startup-gate'
-
-export function getFeatureTipForModal(args: {
-  cliInstalled: boolean
-  modalData: Record<string, unknown>
-  seenTipIds: readonly FeatureTipId[]
-  featureInteractions: FeatureInteractionState
-  settings: FeatureTipSettings | null | undefined
-  webClient: boolean
-}): FeatureTip | null {
-  const modalTipId = isFeatureTipId(args.modalData.tipId) ? args.modalData.tipId : null
-  if (modalTipId) {
-    return FEATURE_TIPS.find((tip) => tip.id === modalTipId) ?? null
-  }
-
-  return getPendingFeatureTips(args)[0] ?? null
-}
diff --git a/src/renderer/src/components/feature-tips/feature-tip-startup-gate.test.ts b/src/renderer/src/components/feature-tips/feature-tip-startup-gate.test.ts
index 3de131fca5b1..385c2a4c425d 100644
--- a/src/renderer/src/components/feature-tips/feature-tip-startup-gate.test.ts
+++ b/src/renderer/src/components/feature-tips/feature-tip-startup-gate.test.ts
@@ -55,15 +55,12 @@ describe('feature tip startup gate', () => {
   it('opens the CLI feature tip first for an existing user on app open', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: false,
         featureTipsSeenIds: [],
         featureInteractions: {},
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
     ).toEqual({ kind: 'open', tipId: 'orca-cli' })
@@ -72,49 +69,26 @@ describe('feature tip startup gate', () => {
   it('suppresses feature tips for first-time users while onboarding is showing', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: false,
         featureTipsSeenIds: [],
         featureInteractions: {},
         onboarding: firstTimeOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
     ).toEqual({ kind: 'suppress-for-onboarding' })
   })
 
-  it('does not open later in the same session after onboarding suppressed it', () => {
-    expect(
-      getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
-        cliInstalled: false,
-        featureTipsSeenIds: [],
-        featureInteractions: {},
-        onboarding: existingUserOnboarding,
-        persistedUIReady: true,
-        promptedThisSession: false,
-        settings: makeSettings(),
-        suppressedByOnboardingThisSession: true,
-        webClient: false
-      })
-    ).toEqual({ kind: 'skip' })
-  })
-
   it('opens the CLI tip after the voice tip was marked seen', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: false,
         featureTipsSeenIds: ['voice-dictation'],
         featureInteractions: {},
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
     ).toEqual({ kind: 'open', tipId: 'orca-cli' })
@@ -123,15 +97,12 @@ describe('feature tip startup gate', () => {
   it('opens the CLI tip after voice dictation is already enabled', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: false,
         featureTipsSeenIds: [],
         featureInteractions: {},
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(true),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
     ).toEqual({ kind: 'open', tipId: 'orca-cli' })
@@ -140,15 +111,12 @@ describe('feature tip startup gate', () => {
   it('opens the command palette tip after the CLI tip was marked seen', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: true,
         featureTipsSeenIds: ['orca-cli'],
         featureInteractions: {},
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
     ).toEqual({ kind: 'open', tipId: 'cmd-j-palette' })
@@ -157,15 +125,12 @@ describe('feature tip startup gate', () => {
   it('does not open after every tip was marked seen', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: false,
         featureTipsSeenIds: ['voice-dictation', 'orca-cli', 'cmd-j-palette'],
         featureInteractions: {},
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
     ).toEqual({ kind: 'skip' })
@@ -174,15 +139,12 @@ describe('feature tip startup gate', () => {
   it('does not open the voice tip after Settings marked it seen and dictation is disabled', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: true,
         featureTipsSeenIds: ['voice-dictation', 'cmd-j-palette'],
         featureInteractions: {},
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(false),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
     ).toEqual({ kind: 'skip' })
@@ -191,15 +153,12 @@ describe('feature tip startup gate', () => {
   it('does not open the CLI tip after the CLI is installed', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: true,
         featureTipsSeenIds: ['voice-dictation', 'cmd-j-palette'],
         featureInteractions: {},
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
     ).toEqual({ kind: 'skip' })
@@ -208,32 +167,45 @@ describe('feature tip startup gate', () => {
   it('waits for CLI install status before opening the CLI tip', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: null,
         featureTipsSeenIds: ['voice-dictation'],
         featureInteractions: {},
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
-    ).toEqual({ kind: 'skip' })
+    ).toEqual({ kind: 'pending' })
   })
 
   it('waits for CLI install status before opening later tips', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: null,
         featureTipsSeenIds: [],
         featureInteractions: {},
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(),
-        suppressedByOnboardingThisSession: false,
+        webClient: false
+      })
+    ).toEqual({ kind: 'pending' })
+  })
+
+  it('answers without the CLI status when no tip is left either way', () => {
+    expect(
+      getFeatureTipsAppOpenDecision({
+        cliInstalled: null,
+        featureTipsSeenIds: [
+          'voice-dictation',
+          'orca-cli',
+          'cmd-j-palette',
+          'agent-session-search'
+        ],
+        featureInteractions: {},
+        onboarding: existingUserOnboarding,
+        persistedUIReady: true,
+        settings: makeSettings(),
         webClient: false
       })
     ).toEqual({ kind: 'skip' })
@@ -242,7 +214,6 @@ describe('feature tip startup gate', () => {
   it('does not open after the user already interacted with the feature', () => {
     expect(
       getFeatureTipsAppOpenDecision({
-        activeModal: 'none',
         cliInstalled: true,
         featureTipsSeenIds: ['cmd-j-palette'],
         featureInteractions: {
@@ -250,9 +221,7 @@ describe('feature tip startup gate', () => {
         },
         onboarding: existingUserOnboarding,
         persistedUIReady: true,
-        promptedThisSession: false,
         settings: makeSettings(),
-        suppressedByOnboardingThisSession: false,
         webClient: false
       })
     ).toEqual({ kind: 'skip' })
@@ -281,15 +250,12 @@ describe('feature tip startup gate', () => {
     featureTipsSeenIds?: ('agent-session-search' | 'orca-cli')[]
   }): ReturnType<typeof getFeatureTipsAppOpenDecision> {
     return getFeatureTipsAppOpenDecision({
-      activeModal: 'none',
       cliInstalled: false,
       featureTipsSeenIds: args.featureTipsSeenIds ?? [],
       featureInteractions: {},
       onboarding: existingUserOnboarding,
       persistedUIReady: true,
-      promptedThisSession: false,
       settings: makeSettings(false, args.sessionSearchEnabled),
-      suppressedByOnboardingThisSession: false,
       webClient: args.webClient
     })
   }
diff --git a/src/renderer/src/components/feature-tips/feature-tip-startup-gate.ts b/src/renderer/src/components/feature-tips/feature-tip-startup-gate.ts
index 973c61bb62dc..215b3c67e329 100644
--- a/src/renderer/src/components/feature-tips/feature-tip-startup-gate.ts
+++ b/src/renderer/src/components/feature-tips/feature-tip-startup-gate.ts
@@ -11,10 +11,14 @@ import type { GlobalSettings } from '../../../../shared/global-settings-types'
 import type { OnboardingState } from '../../../../shared/onboarding-state-types'
 import { shouldShowOnboarding } from '../onboarding/should-show-onboarding'
 
+export const APP_OPEN_FEATURE_TIP_TOKEN = 'feature-tip:app-open'
+
 export type FeatureTipsAppOpenDecision =
   | { kind: 'open'; tipId: FeatureTipId }
   | { kind: 'skip' }
   | { kind: 'suppress-for-onboarding' }
+  /** Something it depends on has not loaded yet. */
+  | { kind: 'pending' }
 
 export function isCliFeatureTipCompleted(status: CliInstallStatus): boolean {
   // Why: unsupported launch modes cannot complete setup, but an installed
@@ -55,40 +59,33 @@ export function getPendingFeatureTips(args: {
 }
 
 export function getFeatureTipsAppOpenDecision(args: {
-  activeModal: string
   cliInstalled: boolean | null
   featureTipsSeenIds: readonly FeatureTipId[]
   featureInteractions: FeatureInteractionState
   onboarding: OnboardingState | null
   persistedUIReady: boolean
-  promptedThisSession: boolean
   settings: FeatureTipSettings | null | undefined
-  suppressedByOnboardingThisSession: boolean
   webClient: boolean
 }): FeatureTipsAppOpenDecision {
   if (args.onboarding !== null && shouldShowOnboarding(args.onboarding)) {
     return { kind: 'suppress-for-onboarding' }
   }
 
-  if (
-    args.promptedThisSession ||
-    args.suppressedByOnboardingThisSession ||
-    !args.persistedUIReady ||
-    !args.settings ||
-    args.onboarding === null ||
-    args.activeModal !== 'none' ||
-    args.cliInstalled === null ||
-    shouldShowOnboarding(args.onboarding)
-  ) {
-    return { kind: 'skip' }
+  if (!args.persistedUIReady || !args.settings || args.onboarding === null) {
+    return { kind: 'pending' }
   }
 
+  // Without the CLI status, assume its tip is still open: if even then nothing is pending, the
+  // answer is known without waiting for that probe.
   const nextTip = getPendingFeatureTips({
     seenTipIds: args.featureTipsSeenIds,
-    cliInstalled: args.cliInstalled,
+    cliInstalled: args.cliInstalled ?? false,
     featureInteractions: args.featureInteractions,
     settings: args.settings,
     webClient: args.webClient
   })[0]
-  return nextTip ? { kind: 'open', tipId: nextTip.id } : { kind: 'skip' }
+  if (!nextTip) {
+    return { kind: 'skip' }
+  }
+  return args.cliInstalled === null ? { kind: 'pending' } : { kind: 'open', tipId: nextTip.id }
 }
diff --git a/src/renderer/src/components/feature-tips/feature-tip-telemetry.test.ts b/src/renderer/src/components/feature-tips/feature-tip-telemetry.test.ts
index efddbfcdd020..4ca681882056 100644
--- a/src/renderer/src/components/feature-tips/feature-tip-telemetry.test.ts
+++ b/src/renderer/src/components/feature-tips/feature-tip-telemetry.test.ts
@@ -7,7 +7,6 @@ vi.mock('@/lib/telemetry', () => ({
 }))
 
 import {
-  getOrcaCliFeatureTipTelemetrySource,
   trackCmdJPaletteFeatureTipAcknowledged,
   trackCmdJPaletteFeatureTipShown,
   trackOrcaCliFeatureTipSetupClicked,
@@ -20,12 +19,6 @@ describe('feature tip telemetry', () => {
     trackMock.mockClear()
   })
 
-  it('keeps feature tip sources low-cardinality', () => {
-    expect(getOrcaCliFeatureTipTelemetrySource('app_open')).toBe('app_open')
-    expect(getOrcaCliFeatureTipTelemetrySource('settings')).toBe('manual')
-    expect(getOrcaCliFeatureTipTelemetrySource(undefined)).toBe('manual')
-  })
-
   it('tracks CLI tip exposure once per explicit call', () => {
     trackOrcaCliFeatureTipShown('app_open')
 
diff --git a/src/renderer/src/components/feature-tips/feature-tip-telemetry.ts b/src/renderer/src/components/feature-tips/feature-tip-telemetry.ts
index 6853f5508967..757c0d902186 100644
--- a/src/renderer/src/components/feature-tips/feature-tip-telemetry.ts
+++ b/src/renderer/src/components/feature-tips/feature-tip-telemetry.ts
@@ -5,10 +5,6 @@ export type OrcaCliFeatureTipSource = EventProps<'orca_cli_feature_tip_shown'>['
 export type OrcaCliFeatureTipSetupResult = EventProps<'orca_cli_feature_tip_setup_result'>['result']
 export type CmdJPaletteFeatureTipSource = EventProps<'cmd_j_palette_feature_tip_shown'>['source']
 
-export function getOrcaCliFeatureTipTelemetrySource(value: unknown): OrcaCliFeatureTipSource {
-  return value === 'app_open' ? 'app_open' : 'manual'
-}
-
 export function trackOrcaCliFeatureTipShown(source: OrcaCliFeatureTipSource): void {
   track('orca_cli_feature_tip_shown', { source })
 }
diff --git a/src/renderer/src/components/link-routing-preference-dialog.tsx b/src/renderer/src/components/link-routing-preference-dialog.tsx
index cdf07d629625..6bdf4369fc7a 100644
--- a/src/renderer/src/components/link-routing-preference-dialog.tsx
+++ b/src/renderer/src/components/link-routing-preference-dialog.tsx
@@ -12,7 +12,6 @@ import {
 } from '@/components/ui/dialog'
 import { Badge } from '@/components/ui/badge'
 import { ShortcutKeyCombo } from '@/components/ShortcutKeyCombo'
-import { useAppStore } from '@/store'
 import { translate } from '@/i18n/i18n'
 
 type LinkRoutingPreferenceDialogOptions = {
@@ -56,9 +55,6 @@ export function LinkRoutingPreferenceDialogProvider({
   const [queue, setQueue] = useState<LinkRoutingPreferenceDialogRequest[]>([])
   const activeRequest = queue[0] ?? null
   const activeRequestRef = useRef<LinkRoutingPreferenceDialogRequest | null>(activeRequest)
-  const setContextualToursBlockingSurfaceVisible = useAppStore(
-    (s) => s.setContextualToursBlockingSurfaceVisible
-  )
   const lastDisplayedRequestRef = useRef<LinkRoutingPreferenceDialogRequest | null>(activeRequest)
   activeRequestRef.current = activeRequest
   if (activeRequest) {
@@ -71,11 +67,6 @@ export function LinkRoutingPreferenceDialogProvider({
   const isMac = navigator.userAgent.includes('Mac')
   const systemBrowserShortcutKeys = isMac ? ['⇧', '⌘'] : ['Shift', 'Ctrl']
 
-  useEffect(() => {
-    setContextualToursBlockingSurfaceVisible(activeRequest !== null)
-    return () => setContextualToursBlockingSurfaceVisible(false)
-  }, [activeRequest, setContextualToursBlockingSurfaceVisible])
-
   const requestPreference = useCallback<LinkRoutingPreferenceDialogContextValue>((options = {}) => {
     return new Promise((resolve) => {
       const request: LinkRoutingPreferenceDialogRequest = {
diff --git a/src/renderer/src/components/native-chat-resume-offer-activity-watch.ts b/src/renderer/src/components/native-chat-resume-offer-activity-watch.ts
new file mode 100644
index 000000000000..d5c5a52bd865
--- /dev/null
+++ b/src/renderer/src/components/native-chat-resume-offer-activity-watch.ts
@@ -0,0 +1,109 @@
+import {
+  getStructuredAgentSessionStatusFeed,
+  type StructuredAgentSessionStatusFeedOwner
+} from '@/runtime/structured-agent-session-status-feed'
+import type { AgentSessionStatusSummary } from '../../../shared/agent-session-wire'
+import type { NativeChatRestartOffer } from './native-chat-resume-on-restart-store'
+
+/**
+ * Re-reads the host once an offered or failed chat shows new activity, so a message the user sent
+ * there, or its agent starting, retires its entry here too. The host stays the judge; this only
+ * asks again.
+ *
+ * Held only while something is offered or failed. Keyed on status and prompt rather than every
+ * summary, so an agent streaming in such a chat costs one re-read, not one per tool call.
+ */
+const OFFERED_CHAT_REFRESH_DELAY_MS = 500
+let offeredChatWatch: {
+  feed: StructuredAgentSessionStatusFeedOwner
+  seen: Map<string, string>
+  release: () => void
+} | null = null
+let offeredChatRefresh: ReturnType<typeof setTimeout> | null = null
+
+function offeredChatIds(offer: NativeChatRestartOffer): Set<string> {
+  return new Set([...offer.candidates, ...offer.failed].map((entry) => entry.sessionId))
+}
+
+function offeredChatActivityKey(summary: AgentSessionStatusSummary): string {
+  return `${summary.status ?? ''}\u0000${summary.latestPrompt}`
+}
+
+export function syncNativeChatResumeOfferActivity(
+  readOffer: () => NativeChatRestartOffer,
+  refresh: () => void
+): void {
+  const offeredIds = offeredChatIds(readOffer())
+  if (offeredIds.size === 0) {
+    releaseNativeChatResumeOfferActivity()
+    return
+  }
+  if (!offeredChatWatch) {
+    const feed = getStructuredAgentSessionStatusFeed({ kind: 'local' })
+    const unsubscribe = feed.subscribe(() => noticeOfferedChatActivity(readOffer, refresh))
+    const deactivate = feed.activate()
+    offeredChatWatch = {
+      feed,
+      seen: new Map(),
+      release: () => {
+        unsubscribe()
+        deactivate()
+      }
+    }
+  }
+  const { feed, seen } = offeredChatWatch
+  for (const sessionId of seen.keys()) {
+    if (!offeredIds.has(sessionId)) {
+      seen.delete(sessionId)
+    }
+  }
+  // What the feed already holds is what this listing answered.
+  for (const sessionId of offeredIds) {
+    const summary = feed.getSnapshot().get(sessionId)
+    if (summary && !seen.has(sessionId)) {
+      seen.set(sessionId, offeredChatActivityKey(summary))
+    }
+  }
+}
+
+function noticeOfferedChatActivity(
+  readOffer: () => NativeChatRestartOffer,
+  refresh: () => void
+): void {
+  if (!offeredChatWatch) {
+    return
+  }
+  const { feed, seen } = offeredChatWatch
+  const snapshot = feed.getSnapshot()
+  const offer = readOffer()
+  let changed = false
+  for (const sessionId of offeredChatIds(offer)) {
+    const summary = snapshot.get(sessionId)
+    if (!summary) {
+      continue
+    }
+    const key = offeredChatActivityKey(summary)
+    const previous = seen.get(sessionId)
+    if (previous !== key) {
+      seen.set(sessionId, key)
+      // A first sighting is news only if newer than the list; a change to a known chat always is,
+      // since the host may have answered the list just before the change was delivered here.
+      changed ||= previous !== undefined || summary.updatedAt > offer.listedAt
+    }
+  }
+  if (changed && offeredChatRefresh === null) {
+    offeredChatRefresh = setTimeout(() => {
+      offeredChatRefresh = null
+      refresh()
+    }, OFFERED_CHAT_REFRESH_DELAY_MS)
+  }
+}
+
+export function releaseNativeChatResumeOfferActivity(): void {
+  if (offeredChatRefresh !== null) {
+    clearTimeout(offeredChatRefresh)
+    offeredChatRefresh = null
+  }
+  offeredChatWatch?.release()
+  offeredChatWatch = null
+}
diff --git a/src/renderer/src/components/native-chat-resume-on-restart-dialog.ts b/src/renderer/src/components/native-chat-resume-on-restart-dialog.ts
index 4b139d1c2a34..bd3e09746356 100644
--- a/src/renderer/src/components/native-chat-resume-on-restart-dialog.ts
+++ b/src/renderer/src/components/native-chat-resume-on-restart-dialog.ts
@@ -1,4 +1,11 @@
-let pendingOpen = false
+/** Who asked: the launch read raises it by itself and takes a turn; the user opens it at once. */
+export type NativeChatResumeDialogOrigin = 'launch' | 'user'
+
+/** The offer's one dialog entry, whoever asked: the user asking takes over a queued launch offer. */
+export const NATIVE_CHAT_RESUME_DIALOG_TOKEN = 'native-chat-resume'
+
+let pendingOpen: NativeChatResumeDialogOrigin | null = null
+let userAsked = false
 const listeners = new Set<() => void>()
 
 function notify(): void {
@@ -9,20 +16,30 @@ function notify(): void {
 
 // Why: the launch load and the status-bar entry both open this dialog, and either can fire before
 // it subscribes. Keeping the request as an external snapshot prevents mount ordering from losing it.
-export function requestNativeChatResumeOnRestartDialog(): void {
-  pendingOpen = true
+export function requestNativeChatResumeOnRestartDialog(origin: NativeChatResumeDialogOrigin): void {
+  // The user already has the offer in hand, so the launch's own ask would repeat it.
+  if (origin === 'launch' && userAsked) {
+    return
+  }
+  userAsked ||= origin === 'user'
+  // A user's request is never demoted to a scheduled one.
+  const next = pendingOpen === 'user' ? 'user' : origin
+  if (pendingOpen === next) {
+    return
+  }
+  pendingOpen = next
   notify()
 }
 
 export function consumeNativeChatResumeOnRestartDialogRequest(): void {
-  if (!pendingOpen) {
+  if (pendingOpen === null) {
     return
   }
-  pendingOpen = false
+  pendingOpen = null
   notify()
 }
 
-export function getNativeChatResumeOnRestartDialogRequest(): boolean {
+export function getNativeChatResumeOnRestartDialogRequest(): NativeChatResumeDialogOrigin | null {
   return pendingOpen
 }
 
@@ -32,3 +49,9 @@ export function subscribeNativeChatResumeOnRestartDialog(listener: () => void):
     listeners.delete(listener)
   }
 }
+
+/** @internal - tests need a clean module between cases. */
+export function _resetNativeChatResumeOnRestartDialog(): void {
+  pendingOpen = null
+  userAsked = false
+}
diff --git a/src/renderer/src/components/native-chat-resume-on-restart-outcome-toast.test.ts b/src/renderer/src/components/native-chat-resume-on-restart-outcome-toast.test.ts
index 9b8c90eb4333..6041cb59fb00 100644
--- a/src/renderer/src/components/native-chat-resume-on-restart-outcome-toast.test.ts
+++ b/src/renderer/src/components/native-chat-resume-on-restart-outcome-toast.test.ts
@@ -145,5 +145,5 @@ it('opens nothing from Show once the host no longer lists the chat', async () =>
   await new Promise((resolve) => setTimeout(resolve, 0))
   expect(rpc.mock.calls.at(-1)?.[1]).toBe('agentSession.restartResumable')
   expect(getNativeChatRestartOffer().failed).toEqual([])
-  expect(getNativeChatResumeOnRestartDialogRequest()).toBe(false)
+  expect(getNativeChatResumeOnRestartDialogRequest()).toBeNull()
 })
diff --git a/src/renderer/src/components/native-chat-resume-on-restart-store.ts b/src/renderer/src/components/native-chat-resume-on-restart-store.ts
index 9111eae70dbe..0fbb2918e204 100644
--- a/src/renderer/src/components/native-chat-resume-on-restart-store.ts
+++ b/src/renderer/src/components/native-chat-resume-on-restart-store.ts
@@ -1,10 +1,13 @@
-import { useEffect, useSyncExternalStore } from 'react'
+import { useCallback, useEffect, useSyncExternalStore } from 'react'
+import { readLocalStructuredAgentSessionsHeld } from '@/runtime/local-structured-chats'
+import { readStartupDiscovery } from '@/startup/startup-discovery-read'
+import { useDialogDisposal } from '@/lib/dialog-registry-entry'
+import { useDialogRegistry } from '@/store/dialog-registry'
 import { callStructuredAgentSession } from '@/runtime/structured-agent-session-client'
 import {
-  getStructuredAgentSessionStatusFeed,
-  type StructuredAgentSessionStatusFeedOwner
-} from '@/runtime/structured-agent-session-status-feed'
-import type { AgentSessionStatusSummary } from '../../../shared/agent-session-wire'
+  releaseNativeChatResumeOfferActivity,
+  syncNativeChatResumeOfferActivity
+} from './native-chat-resume-offer-activity-watch'
 import { useAppStore } from '../store'
 import { markNativeChatLaunchResumeDecided } from './native-chat-launch-resume-decision'
 import {
@@ -23,6 +26,8 @@ import {
 } from './native-chat-resume-unsent-requests'
 import {
   consumeNativeChatResumeOnRestartDialogRequest,
+  getNativeChatResumeOnRestartDialogRequest,
+  NATIVE_CHAT_RESUME_DIALOG_TOKEN,
   requestNativeChatResumeOnRestartDialog
 } from './native-chat-resume-on-restart-dialog'
 
@@ -76,7 +81,7 @@ function emit(): void {
  *  actually moves the offer. */
 function publish(next: NativeChatRestartOffer): void {
   offer = next
-  syncOfferedChatWatch()
+  syncNativeChatResumeOfferActivity(getNativeChatRestartOffer, refreshAfterOfferedChatActivity)
   emit()
 }
 
@@ -95,105 +100,13 @@ function syncResuming(): void {
   emit()
 }
 
-/**
- * Re-reads the host once an offered or failed chat shows new activity, so a message the user sent
- * there, or its agent starting, retires its entry here too. The host stays the judge; this only
- * asks again.
- *
- * Held only while something is offered or failed. Keyed on status and prompt rather than every
- * summary, so an agent streaming in such a chat costs one re-read, not one per tool call.
- */
-const OFFERED_CHAT_REFRESH_DELAY_MS = 500
-let offeredChatWatch: {
-  feed: StructuredAgentSessionStatusFeedOwner
-  seen: Map<string, string>
-  release: () => void
-} | null = null
-let offeredChatRefresh: ReturnType<typeof setTimeout> | null = null
-
-function offeredChatIds(): Set<string> {
-  return new Set([...offer.candidates, ...offer.failed].map((entry) => entry.sessionId))
-}
-
-function offeredChatActivityKey(summary: AgentSessionStatusSummary): string {
-  return `${summary.status ?? ''}\u0000${summary.latestPrompt}`
-}
-
-function syncOfferedChatWatch(): void {
-  const offeredIds = offeredChatIds()
-  if (offeredIds.size === 0) {
-    releaseOfferedChatWatch()
-    return
-  }
-  if (!offeredChatWatch) {
-    const feed = getStructuredAgentSessionStatusFeed(LOCAL)
-    const unsubscribe = feed.subscribe(noticeOfferedChatActivity)
-    const deactivate = feed.activate()
-    offeredChatWatch = {
-      feed,
-      seen: new Map(),
-      release: () => {
-        unsubscribe()
-        deactivate()
-      }
-    }
-  }
-  const { feed, seen } = offeredChatWatch
-  for (const sessionId of seen.keys()) {
-    if (!offeredIds.has(sessionId)) {
-      seen.delete(sessionId)
-    }
-  }
-  // What the feed already holds is what this listing answered.
-  for (const sessionId of offeredIds) {
-    const summary = feed.getSnapshot().get(sessionId)
-    if (summary && !seen.has(sessionId)) {
-      seen.set(sessionId, offeredChatActivityKey(summary))
-    }
-  }
-}
-
-function noticeOfferedChatActivity(): void {
-  if (!offeredChatWatch) {
-    return
-  }
-  const { feed, seen } = offeredChatWatch
-  const snapshot = feed.getSnapshot()
-  let changed = false
-  for (const sessionId of offeredChatIds()) {
-    const summary = snapshot.get(sessionId)
-    if (!summary) {
-      continue
-    }
-    const key = offeredChatActivityKey(summary)
-    const previous = seen.get(sessionId)
-    if (previous !== key) {
-      seen.set(sessionId, key)
-      // A first sighting is news only if newer than the list; a change to a known chat always is,
-      // since the host may have answered the list just before the change was delivered here.
-      changed ||= previous !== undefined || summary.updatedAt > offer.listedAt
-    }
-  }
-  if (changed && offeredChatRefresh === null) {
-    offeredChatRefresh = setTimeout(() => {
-      offeredChatRefresh = null
-      if (actionsBegun === actionsSettled) {
-        const issued = actionsBegun
-        void readNativeChatRestartOffer(() => actionsBegun === issued)
-      }
-    }, OFFERED_CHAT_REFRESH_DELAY_MS)
+function refreshAfterOfferedChatActivity(): void {
+  if (actionsBegun === actionsSettled) {
+    const issued = actionsBegun
+    void readNativeChatRestartOffer(() => actionsBegun === issued)
   }
 }
 
-function releaseOfferedChatWatch(): void {
-  if (offeredChatRefresh !== null) {
-    clearTimeout(offeredChatRefresh)
-    offeredChatRefresh = null
-  }
-  offeredChatWatch?.release()
-  offeredChatWatch = null
-}
-
 export function getNativeChatRestartOffer(): NativeChatRestartOffer {
   return offer
 }
@@ -267,7 +180,7 @@ export async function reopenNativeChatRestartOffer(): Promise<void> {
     await readNativeChatRestartOffer()
   }
   if (resuming.length > 0 || offer.candidates.length > 0 || offer.failed.length > 0) {
-    requestNativeChatResumeOnRestartDialog()
+    requestNativeChatResumeOnRestartDialog('user')
   }
 }
 
@@ -388,10 +301,11 @@ async function loadLaunchOffer(): Promise<void> {
     return
   }
   if (!autoResume) {
-    requestNativeChatResumeOnRestartDialog()
+    requestNativeChatResumeOnRestartDialog('launch')
     return
   }
-  await continueNativeChatRestartOffer(undefined, allResumeSessionIds(offered))
+  // Not awaited: nothing will ask, so other launch prompts need not wait for the resume to settle.
+  void continueNativeChatRestartOffer(undefined, allResumeSessionIds(offered))
 }
 
 /**
@@ -400,13 +314,55 @@ async function loadLaunchOffer(): Promise<void> {
  * `enabled` is a gate, not a trigger: settings arrive after the first render, so the fetch waits
  * for the flag rather than being lost when it was still undefined.
  */
-export function useNativeChatRestartOffer(enabled: boolean): NativeChatRestartOffer {
+export function useNativeChatRestartOffer(
+  enabled: boolean,
+  options?: { ownsStartupDiscovery: boolean }
+): NativeChatRestartOffer {
+  const ownsStartupDiscovery = options?.ownsStartupDiscovery === true
+  const settingsLoaded = useAppStore((store) => store.settings !== null)
+  const persistedUIReady = useAppStore((store) => store.persistedUIReady)
+  const abandonDiscovery = useCallback(() => {
+    if (ownsStartupDiscovery) {
+      useDialogRegistry.getState().settleStartupSource('native-chat-resume', 'unavailable')
+    }
+  }, [ownsStartupDiscovery])
+  useDialogDisposal('native-chat-resume-discovery', abandonDiscovery)
   useEffect(() => {
-    if (enabled) {
-      // Fetched after mount, never awaited by startup: the workspace is usable first.
-      launch ??= loadLaunchOffer().finally(markNativeChatLaunchResumeDecided)
+    const launchRead = enabled
+      ? (launch ??= loadLaunchOffer().finally(markNativeChatLaunchResumeDecided))
+      : null
+    if (!ownsStartupDiscovery) {
+      return
+    }
+    if (!settingsLoaded) {
+      if (persistedUIReady) {
+        abandonDiscovery()
+      }
+      return
+    }
+    let cancelled = false
+    const read = launchRead ? launchRead.then(() => true) : readLocalStructuredAgentSessionsHeld()
+    void readStartupDiscovery(read).then((holds) => {
+      if (cancelled) {
+        return
+      }
+      if (holds === null) {
+        abandonDiscovery()
+      } else if (enabled || !holds) {
+        const asked = getNativeChatResumeOnRestartDialogRequest() !== null
+        useDialogRegistry
+          .getState()
+          .settleStartupSource(
+            'native-chat-resume',
+            asked ? 'ready' : 'none',
+            asked ? NATIVE_CHAT_RESUME_DIALOG_TOKEN : undefined
+          )
+      }
+    })
+    return () => {
+      cancelled = true
     }
-  }, [enabled])
+  }, [abandonDiscovery, enabled, ownsStartupDiscovery, persistedUIReady, settingsLoaded])
   return useSyncExternalStore(subscribe, getNativeChatRestartOffer, getNativeChatRestartOffer)
 }
 
@@ -417,7 +373,7 @@ export function useNativeChatRestartResuming(): readonly string[] {
 
 /** @internal - tests need a clean module between cases. */
 export function _resetNativeChatRestartOffer(): void {
-  releaseOfferedChatWatch()
+  releaseNativeChatResumeOfferActivity()
   offer = EMPTY
   forgetUnsentResumes(undefined)
   resumeBatches.clear()
diff --git a/src/renderer/src/components/onboarding/OnboardingFlow.tsx b/src/renderer/src/components/onboarding/OnboardingFlow.tsx
index c57e25560149..4313dcef8e3f 100644
--- a/src/renderer/src/components/onboarding/OnboardingFlow.tsx
+++ b/src/renderer/src/components/onboarding/OnboardingFlow.tsx
@@ -1,3 +1,4 @@
+import { DialogEntryContent } from '@/lib/dialog-registry-entry'
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { cn } from '@/lib/utils'
 import { isEditableTarget } from '@/lib/editable-target'
@@ -224,6 +225,7 @@ export default function OnboardingFlow({
             'max-w-[1100px]'
           )}
         >
+          <DialogEntryContent kind="onboarding" />
           <div className="relative flex h-full min-h-0 flex-col px-6 pb-6 pt-8 sm:px-8 sm:pb-8 sm:pt-9">
             <div className="flex items-center gap-3 text-base font-semibold tracking-tight">
               <img
diff --git a/src/renderer/src/components/sidebar/ProjectAddedDialog.test.tsx b/src/renderer/src/components/sidebar/ProjectAddedDialog.test.tsx
deleted file mode 100644
index 8a9651aa6a83..000000000000
--- a/src/renderer/src/components/sidebar/ProjectAddedDialog.test.tsx
+++ /dev/null
@@ -1,195 +0,0 @@
-import { renderToStaticMarkup } from 'react-dom/server'
-import type * as ReactModule from 'react'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { Repo } from '../../../../shared/repo-types'
-
-const mocks = vi.hoisted(() => ({
-  state: {
-    activeModal: 'project-added',
-    modalData: {} as Record<string, unknown>,
-    closeModal: vi.fn(),
-    repos: [] as Repo[],
-    worktreesByRepo: {} as Record<string, unknown[]>,
-    fetchRepos: vi.fn(),
-    fetchWorktrees: vi.fn(),
-    setHideDefaultBranchWorkspace: vi.fn()
-  },
-  activateAndRevealWorktree: vi.fn(),
-  finishProjectAddWithDefaultCheckout: vi.fn()
-}))
-
-vi.mock('react', async (importOriginal) => {
-  const actual = await importOriginal<typeof ReactModule>()
-  return {
-    ...actual,
-    useEffect: (effect: () => void | (() => void)) => {
-      effect()
-    }
-  }
-})
-
-vi.mock('@/store', () => ({
-  useAppStore: Object.assign(
-    (selector: (state: typeof mocks.state) => unknown) => selector(mocks.state),
-    {
-      getState: () => mocks.state
-    }
-  )
-}))
-
-vi.mock('@/lib/worktree-activation', () => ({
-  activateAndRevealWorktree: mocks.activateAndRevealWorktree
-}))
-
-vi.mock('./project-added-default-checkout', () => ({
-  finishProjectAddWithDefaultCheckout: mocks.finishProjectAddWithDefaultCheckout
-}))
-
-function makeRepo(overrides: Partial<Repo> = {}): Repo {
-  return {
-    id: 'repo-1',
-    path: '/repo',
-    displayName: 'orca',
-    badgeColor: '#999999',
-    addedAt: 1,
-    ...overrides
-  }
-}
-
-async function flushPromises(): Promise<void> {
-  await Promise.resolve()
-  await Promise.resolve()
-}
-
-describe('ProjectAddedDialog', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mocks.state.activeModal = 'project-added'
-    mocks.state.modalData = { repoId: 'repo-1' }
-    mocks.state.repos = [makeRepo()]
-    mocks.state.worktreesByRepo = {}
-    mocks.state.fetchRepos.mockResolvedValue(undefined)
-    mocks.state.fetchWorktrees.mockResolvedValue(true)
-  })
-
-  it('fetches worktrees and finishes by opening the default checkout for Git repos', async () => {
-    const { default: ProjectAddedDialog } = await import('./ProjectAddedDialog')
-
-    const markup = renderToStaticMarkup(<ProjectAddedDialog />)
-    await flushPromises()
-
-    expect(markup).toBe('')
-    expect(mocks.state.fetchWorktrees).toHaveBeenCalledWith('repo-1')
-    expect(mocks.finishProjectAddWithDefaultCheckout).toHaveBeenCalledWith({
-      repoId: 'repo-1',
-      source: 'project_added_compat',
-      closeModal: mocks.state.closeModal,
-      setHideDefaultBranchWorkspace: mocks.state.setHideDefaultBranchWorkspace
-    })
-  })
-
-  it('does not block the compatibility handoff during StrictMode effect replay', async () => {
-    const cleanupFns: (() => void)[] = []
-    vi.doMock('react', async (importOriginal) => {
-      const actual = await importOriginal<typeof ReactModule>()
-      return {
-        ...actual,
-        useEffect: (effect: () => void | (() => void)) => {
-          const cleanup = effect()
-          if (cleanup) {
-            cleanupFns.push(cleanup)
-          }
-        }
-      }
-    })
-    vi.resetModules()
-    const { default: ProjectAddedDialog } = await import('./ProjectAddedDialog')
-
-    renderToStaticMarkup(<ProjectAddedDialog />)
-    cleanupFns.pop()?.()
-    renderToStaticMarkup(<ProjectAddedDialog />)
-    await flushPromises()
-
-    expect(mocks.state.fetchWorktrees).toHaveBeenCalledTimes(2)
-    expect(mocks.finishProjectAddWithDefaultCheckout).toHaveBeenCalledTimes(1)
-    expect(mocks.finishProjectAddWithDefaultCheckout).toHaveBeenCalledWith({
-      repoId: 'repo-1',
-      source: 'project_added_compat',
-      closeModal: mocks.state.closeModal,
-      setHideDefaultBranchWorkspace: mocks.state.setHideDefaultBranchWorkspace
-    })
-  })
-
-  it('accepts older onboarding modal data that uses projectId', async () => {
-    mocks.state.modalData = { projectId: 'repo-1' }
-    const { default: ProjectAddedDialog } = await import('./ProjectAddedDialog')
-
-    renderToStaticMarkup(<ProjectAddedDialog />)
-    await flushPromises()
-
-    expect(mocks.state.fetchWorktrees).toHaveBeenCalledWith('repo-1')
-    expect(mocks.finishProjectAddWithDefaultCheckout).toHaveBeenCalledWith(
-      expect.objectContaining({ repoId: 'repo-1' })
-    )
-  })
-
-  it('activates the synthetic folder workspace for folder repos', async () => {
-    mocks.state.repos = [makeRepo({ kind: 'folder' })]
-    mocks.state.worktreesByRepo = {
-      'repo-1': [{ id: 'repo-1::folder' }]
-    }
-    const { default: ProjectAddedDialog } = await import('./ProjectAddedDialog')
-
-    const markup = renderToStaticMarkup(<ProjectAddedDialog />)
-    await flushPromises()
-
-    expect(markup).toBe('')
-    expect(mocks.state.fetchWorktrees).toHaveBeenCalledWith('repo-1')
-    expect(mocks.activateAndRevealWorktree).toHaveBeenCalledWith('repo-1::folder', {
-      sidebarRevealBehavior: 'auto'
-    })
-    expect(mocks.state.closeModal).toHaveBeenCalledTimes(1)
-    expect(mocks.finishProjectAddWithDefaultCheckout).not.toHaveBeenCalled()
-  })
-
-  it('closes malformed modal data without blocking the app invisibly', async () => {
-    mocks.state.modalData = {}
-    const { default: ProjectAddedDialog } = await import('./ProjectAddedDialog')
-
-    const markup = renderToStaticMarkup(<ProjectAddedDialog />)
-    await flushPromises()
-
-    expect(markup).toBe('')
-    expect(mocks.state.closeModal).toHaveBeenCalledTimes(1)
-    expect(mocks.state.fetchWorktrees).not.toHaveBeenCalled()
-  })
-
-  it('refreshes repos before closing a stale repo id', async () => {
-    mocks.state.repos = []
-    mocks.state.fetchRepos.mockImplementation(async () => {
-      mocks.state.repos = []
-    })
-    const { default: ProjectAddedDialog } = await import('./ProjectAddedDialog')
-
-    renderToStaticMarkup(<ProjectAddedDialog />)
-    await flushPromises()
-
-    expect(mocks.state.fetchRepos).toHaveBeenCalledTimes(1)
-    expect(mocks.state.closeModal).toHaveBeenCalledTimes(1)
-  })
-
-  it('waits for repo hydration and does not close when fetchRepos supplies the repo', async () => {
-    mocks.state.repos = []
-    mocks.state.fetchRepos.mockImplementation(async () => {
-      mocks.state.repos = [makeRepo()]
-    })
-    const { default: ProjectAddedDialog } = await import('./ProjectAddedDialog')
-
-    renderToStaticMarkup(<ProjectAddedDialog />)
-    await flushPromises()
-
-    expect(mocks.state.fetchRepos).toHaveBeenCalledTimes(1)
-    expect(mocks.state.closeModal).not.toHaveBeenCalled()
-    expect(mocks.finishProjectAddWithDefaultCheckout).not.toHaveBeenCalled()
-  })
-})
diff --git a/src/renderer/src/components/sidebar/ProjectAddedDialog.tsx b/src/renderer/src/components/sidebar/ProjectAddedDialog.tsx
deleted file mode 100644
index 6532a39cae8e..000000000000
--- a/src/renderer/src/components/sidebar/ProjectAddedDialog.tsx
+++ /dev/null
@@ -1,123 +0,0 @@
-import { useEffect, useRef } from 'react'
-import { useAppStore } from '@/store'
-import { activateAndRevealWorktree } from '@/lib/worktree-activation'
-import { isFolderRepo } from '../../../../shared/repo-kind'
-import { finishProjectAddWithDefaultCheckout } from './project-added-default-checkout'
-
-type ProjectAddedModalData = {
-  repoId?: string
-  projectId?: string
-}
-
-export default function ProjectAddedDialog(): null {
-  const activeModal = useAppStore((s) => s.activeModal)
-  const modalData = useAppStore((s) => s.modalData as ProjectAddedModalData)
-  const closeModal = useAppStore((s) => s.closeModal)
-  const repos = useAppStore((s) => s.repos)
-  const fetchRepos = useAppStore((s) => s.fetchRepos)
-  const fetchWorktrees = useAppStore((s) => s.fetchWorktrees)
-  const setHideDefaultBranchWorkspace = useAppStore((s) => s.setHideDefaultBranchWorkspace)
-  const handoffRunRef = useRef(0)
-  const pendingRepoHydrationRef = useRef<string | null>(null)
-
-  // Why: older onboarding builds wrote `projectId`; accepting both prevents a
-  // stale project-added modal from blocking follow-up contextual tours.
-  const repoId =
-    typeof modalData?.repoId === 'string'
-      ? modalData.repoId
-      : typeof modalData?.projectId === 'string'
-        ? modalData.projectId
-        : ''
-  const repo = repos.find((candidate) => candidate.id === repoId) ?? null
-
-  useEffect(() => {
-    if (activeModal !== 'project-added') {
-      handoffRunRef.current++
-      pendingRepoHydrationRef.current = null
-      return
-    }
-    if (!repoId) {
-      closeModal()
-      return
-    }
-    if (!repo) {
-      if (pendingRepoHydrationRef.current === repoId) {
-        return
-      }
-      pendingRepoHydrationRef.current = repoId
-      let cancelled = false
-      void (async () => {
-        await fetchRepos()
-        if (cancelled) {
-          return
-        }
-        const hydratedRepo = useAppStore
-          .getState()
-          .repos.find((candidate) => candidate.id === repoId)
-        if (!hydratedRepo) {
-          closeModal()
-        }
-        pendingRepoHydrationRef.current = null
-      })()
-      return () => {
-        cancelled = true
-        pendingRepoHydrationRef.current = null
-      }
-    }
-    pendingRepoHydrationRef.current = null
-    const runId = ++handoffRunRef.current
-
-    let cancelled = false
-    if (isFolderRepo(repo)) {
-      void (async () => {
-        try {
-          await fetchWorktrees(repoId)
-        } catch {
-          // Why: folder compatibility exists to clear stale modal state; close
-          // even if the best-effort synthetic workspace refresh fails.
-        }
-        if (cancelled) {
-          return
-        }
-        const folderWorktree = useAppStore.getState().worktreesByRepo[repoId]?.[0]
-        if (folderWorktree) {
-          activateAndRevealWorktree(folderWorktree.id, { sidebarRevealBehavior: 'auto' })
-        }
-        closeModal()
-      })()
-      return () => {
-        cancelled = true
-      }
-    }
-
-    void (async () => {
-      try {
-        await fetchWorktrees(repoId)
-      } catch {
-        // Why: this is a compatibility handoff; fall back to whatever worktree
-        // state is already loaded rather than leaving a stale modal active.
-      }
-      if (!cancelled && handoffRunRef.current === runId) {
-        await finishProjectAddWithDefaultCheckout({
-          repoId,
-          source: 'project_added_compat',
-          closeModal,
-          setHideDefaultBranchWorkspace
-        })
-      }
-    })()
-    return () => {
-      cancelled = true
-    }
-  }, [
-    activeModal,
-    closeModal,
-    fetchRepos,
-    fetchWorktrees,
-    repo,
-    repoId,
-    setHideDefaultBranchWorkspace
-  ])
-
-  return null
-}
diff --git a/src/renderer/src/components/sidebar/hovered-workspace-delete.ts b/src/renderer/src/components/sidebar/hovered-workspace-delete.ts
index f1ecdc30d8b1..ae92c8b70afe 100644
--- a/src/renderer/src/components/sidebar/hovered-workspace-delete.ts
+++ b/src/renderer/src/components/sidebar/hovered-workspace-delete.ts
@@ -1,4 +1,6 @@
 import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectDialogOnScreen } from '@/store/dialog-registry-state'
 import { getAllWorktreesFromState } from '@/store/selectors'
 import type { AppState } from '@/store/types'
 import { isEditableTarget } from '@/lib/editable-target'
@@ -59,7 +61,11 @@ export function resolveHoveredWorkspaceDeleteTarget(
   state: HoveredWorkspaceDeleteState,
   doc: HoveredWorkspaceDocument = document
 ): HoveredWorkspaceDeleteTarget | null {
-  if (state.activeModal !== 'none' || (doc.activeElement && isEditableTarget(doc.activeElement))) {
+  if (
+    state.activeModal !== 'none' ||
+    selectDialogOnScreen(useDialogRegistry.getState()) ||
+    (doc.activeElement && isEditableTarget(doc.activeElement))
+  ) {
     return null
   }
   const hovered = getHoveredWorkspaceIdentity(doc)
diff --git a/src/renderer/src/components/sidebar/index.tsx b/src/renderer/src/components/sidebar/index.tsx
index 057c494c9179..bcc9cdfbf730 100644
--- a/src/renderer/src/components/sidebar/index.tsx
+++ b/src/renderer/src/components/sidebar/index.tsx
@@ -18,6 +18,7 @@ import { useWorkspaceRevealBodyRedirect } from './use-workspace-reveal-body-redi
 import { resolveLeftSidebarStyleVariables } from '@/lib/left-sidebar-appearance'
 import { useSystemPrefersDark } from '@/components/terminal-pane/use-system-prefers-dark'
 import { lazyWithRetry } from '@/lib/lazy-with-retry'
+import { RecoverableRenderErrorBoundary } from '../error-boundaries/RecoverableRenderErrorBoundary'
 import { LocalGitToolchainScanBanner } from './LocalGitToolchainScanBanner'
 
 // Why lazy: the Agents list pulls the whole activity pipeline (virtualizer, markdown
@@ -254,13 +255,20 @@ function Sidebar({
 
       {/* Dialogs render outside sidebar to avoid clipping. Lazy-load them only
       for the modal that needs their flow-specific hooks and UI. */}
-      <React.Suspense fallback={null}>
-        {activeModal === 'edit-meta' ? <WorktreeMetaDialog /> : null}
-        {activeModal === 'confirm-remove-folder' ? <RemoveFolderDialog /> : null}
-        {activeModal === 'worktree-visibility' ? <WorktreeVisibilityDialog /> : null}
-        {activeModal === 'confirm-orca-yaml-hooks' ? <OrcaYamlTrustDialog /> : null}
-        {activeModal === 'forget-ssh-workspace' ? <ForgetSshWorkspaceDialog /> : null}
-      </React.Suspense>
+      <RecoverableRenderErrorBoundary
+        boundaryId="modal.sidebar-dialogs"
+        surface="modal"
+        compact
+        resetKey={activeModal}
+      >
+        <React.Suspense fallback={null}>
+          {activeModal === 'edit-meta' ? <WorktreeMetaDialog /> : null}
+          {activeModal === 'confirm-remove-folder' ? <RemoveFolderDialog /> : null}
+          {activeModal === 'worktree-visibility' ? <WorktreeVisibilityDialog /> : null}
+          {activeModal === 'confirm-orca-yaml-hooks' ? <OrcaYamlTrustDialog /> : null}
+          {activeModal === 'forget-ssh-workspace' ? <ForgetSshWorkspaceDialog /> : null}
+        </React.Suspense>
+      </RecoverableRenderErrorBoundary>
       {sidebarOpen ? (
         <WorkspaceKanbanDrawer
           leftSidebarStyle={leftSidebarStyle}
diff --git a/src/renderer/src/components/sidebar/worktree-list/navigation/use-reveal-requests.test.tsx b/src/renderer/src/components/sidebar/worktree-list/navigation/use-reveal-requests.test.tsx
index da4d68e15345..963f1a9a56a6 100644
--- a/src/renderer/src/components/sidebar/worktree-list/navigation/use-reveal-requests.test.tsx
+++ b/src/renderer/src/components/sidebar/worktree-list/navigation/use-reveal-requests.test.tsx
@@ -17,8 +17,7 @@ const state = vi.hoisted(() => ({
   setGroupBy: vi.fn(),
   pendingRevealSidebarRow: null,
   revealSidebarRow: vi.fn(),
-  revealWorktreeInSidebar: vi.fn(),
-  setContextualToursBlockingSurfaceVisible: vi.fn()
+  revealWorktreeInSidebar: vi.fn()
 }))
 vi.mock('@/store', () => ({
   useAppStore: (selector: (value: typeof state) => unknown) => selector(state)
diff --git a/src/renderer/src/components/status-bar/NativeChatResumeStatusSegment.test.tsx b/src/renderer/src/components/status-bar/NativeChatResumeStatusSegment.test.tsx
index fc5fefce1505..7b612ec8605c 100644
--- a/src/renderer/src/components/status-bar/NativeChatResumeStatusSegment.test.tsx
+++ b/src/renderer/src/components/status-bar/NativeChatResumeStatusSegment.test.tsx
@@ -92,14 +92,14 @@ describe('NativeChatResumeStatusSegment', () => {
     expect(screen.getByRole('button', { name: '2 chats available to resume' })).toBeTruthy()
     expect(screen.getByText('2 chats to resume')).toBeTruthy()
 
-    expect(getNativeChatResumeOnRestartDialogRequest()).toBe(false)
+    expect(getNativeChatResumeOnRestartDialogRequest()).toBeNull()
     await act(async () => screen.getByRole('button').click())
     // The launch read, then a second one taken before the dialog is allowed to reopen.
     expect(rpc.mock.calls.map((call) => call[1])).toEqual([
       'agentSession.restartResumable',
       'agentSession.restartResumable'
     ])
-    expect(getNativeChatResumeOnRestartDialogRequest()).toBe(true)
+    expect(getNativeChatResumeOnRestartDialogRequest()).toBe('user')
   })
 
   // The offer is spent once acted on, so this entry is the one summary a failed resume leaves.
@@ -122,7 +122,7 @@ describe('NativeChatResumeStatusSegment', () => {
 
     rpc.mockResolvedValue({ sessions: [], failed: [failed] })
     await act(async () => entry.click())
-    expect(getNativeChatResumeOnRestartDialogRequest()).toBe(true)
+    expect(getNativeChatResumeOnRestartDialogRequest()).toBe('user')
     // With the offer gone, only the failure entry is left — and it stays.
     expect(screen.queryByText('1 chat to resume')).toBeNull()
     expect(screen.getByText('1 chat failed to resume')).toBeTruthy()
@@ -163,9 +163,9 @@ describe('NativeChatResumeStatusSegment', () => {
     rpc.mockResolvedValueOnce({ sessions: candidates }).mockResolvedValue({ sessions: [] })
     await mount()
 
-    expect(getNativeChatResumeOnRestartDialogRequest()).toBe(false)
+    expect(getNativeChatResumeOnRestartDialogRequest()).toBeNull()
     await act(async () => screen.getByRole('button').click())
-    expect(getNativeChatResumeOnRestartDialogRequest()).toBe(false)
+    expect(getNativeChatResumeOnRestartDialogRequest()).toBeNull()
     expect(screen.queryByRole('button')).toBeNull()
   })
 
diff --git a/src/renderer/src/components/status-bar/UsagePercentageDisplayChangeNotice.test.tsx b/src/renderer/src/components/status-bar/UsagePercentageDisplayChangeNotice.test.tsx
index a562d2768e47..64d7bfdead6c 100644
--- a/src/renderer/src/components/status-bar/UsagePercentageDisplayChangeNotice.test.tsx
+++ b/src/renderer/src/components/status-bar/UsagePercentageDisplayChangeNotice.test.tsx
@@ -151,7 +151,7 @@ describe('UsagePercentageDisplayChangeNotice', () => {
   })
 
   it('does not open while another modal is open', () => {
-    storeState.activeModal = 'feature-tips'
+    storeState.activeModal = 'add-repo'
     act(() => {
       root.render(
         <UsagePercentageDisplayChangeNotice hasVisibleUsageMeters>
diff --git a/src/renderer/src/components/status-bar/UsagePercentageDisplayChangeNotice.tsx b/src/renderer/src/components/status-bar/UsagePercentageDisplayChangeNotice.tsx
index 437afc314be4..8a01adeb17aa 100644
--- a/src/renderer/src/components/status-bar/UsagePercentageDisplayChangeNotice.tsx
+++ b/src/renderer/src/components/status-bar/UsagePercentageDisplayChangeNotice.tsx
@@ -4,6 +4,8 @@ import { BarChart3, X } from 'lucide-react'
 import { Button } from '@/components/ui/button'
 import { translate } from '@/i18n/i18n'
 import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectDialogOnScreen } from '@/store/dialog-registry-state'
 import { shouldShowUsagePercentageDisplayChangeNotice } from '../../../../shared/usage-percentage-display-change-notice'
 import { USAGE_PERCENTAGE_DISPLAY_SETTING_ID } from '../settings/appearance-usage-percentage-search'
 
@@ -62,6 +64,7 @@ export function UsagePercentageDisplayChangeNotice({
   const dismiss = useAppStore((s) => s.dismissUsagePercentageDisplayChangeNotice)
   const statusBarVisible = useAppStore((s) => s.statusBarVisible)
   const activeModal = useAppStore((s) => s.activeModal)
+  const dialogOnScreen = useDialogRegistry(selectDialogOnScreen)
   const [delayElapsed, setDelayElapsed] = useState(false)
   const anchorRef = useRef<HTMLDivElement>(null)
   const [anchorPosition, setAnchorPosition] = useState<AnchorPosition | null>(null)
@@ -71,7 +74,8 @@ export function UsagePercentageDisplayChangeNotice({
     usagePercentageDisplayChangeNoticeDismissed: dismissed,
     statusBarVisible,
     hasVisibleUsageMeters,
-    activeModal
+    activeModal,
+    dialogOnScreen
   })
 
   useEffect(() => {
diff --git a/src/renderer/src/components/ui/command.tsx b/src/renderer/src/components/ui/command.tsx
index 97237799c1f4..88238ae53b70 100644
--- a/src/renderer/src/components/ui/command.tsx
+++ b/src/renderer/src/components/ui/command.tsx
@@ -9,6 +9,7 @@ import * as DialogPrimitive from 'radix-ui/dialog'
 import { cn } from '@/lib/utils'
 import { handleImeOverlayEscape } from '@/lib/ime-overlay-escape'
 import { useImeTextFieldProps } from '@/lib/ime-text-field'
+import { DialogEntryContent } from '@/lib/dialog-registry-entry'
 
 const commandSurfaceVariants = cva('', {
   variants: {
@@ -87,20 +88,22 @@ function CommandDialog({
           onOpenAutoFocus={onOpenAutoFocus}
           onCloseAutoFocus={onCloseAutoFocus}
         >
-          <DialogPrimitive.Title className="sr-only">{title}</DialogPrimitive.Title>
-          <DialogPrimitive.Description className="sr-only">
-            {description}
-          </DialogPrimitive.Description>
-          <Command
-            shouldFilter={shouldFilter}
-            className={cn(
-              '[&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3',
-              commandClassName
-            )}
-            {...commandRootProps}
-          >
-            {children}
-          </Command>
+          <DialogEntryContent>
+            <DialogPrimitive.Title className="sr-only">{title}</DialogPrimitive.Title>
+            <DialogPrimitive.Description className="sr-only">
+              {description}
+            </DialogPrimitive.Description>
+            <Command
+              shouldFilter={shouldFilter}
+              className={cn(
+                '[&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3',
+                commandClassName
+              )}
+              {...commandRootProps}
+            >
+              {children}
+            </Command>
+          </DialogEntryContent>
         </DialogPrimitive.Content>
       </DialogPrimitive.Portal>
     </DialogPrimitive.Root>
diff --git a/src/renderer/src/components/ui/dialog.tsx b/src/renderer/src/components/ui/dialog.tsx
index 5a74593bda1d..4d651588df91 100644
--- a/src/renderer/src/components/ui/dialog.tsx
+++ b/src/renderer/src/components/ui/dialog.tsx
@@ -8,6 +8,7 @@ import { cn } from '@/lib/utils'
 import { handleImeOverlayEscape } from '@/lib/ime-overlay-escape'
 import { Button } from '@/components/ui/button'
 import { translate } from '@/i18n/i18n'
+import { DialogEntryContent } from '@/lib/dialog-registry-entry'
 
 function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>) {
   return <DialogPrimitive.Root data-slot="dialog" {...props} />
@@ -48,10 +49,12 @@ function DialogContent({
   className,
   children,
   overlayClassName,
+  dialogKind,
   showCloseButton = true,
   ...props
 }: React.ComponentProps<typeof DialogPrimitive.Content> & {
   overlayClassName?: string
+  dialogKind?: string
   showCloseButton?: boolean
 }) {
   return (
@@ -74,18 +77,20 @@ function DialogContent({
         {...props}
         onEscapeKeyDown={(event) => handleImeOverlayEscape(event, props.onEscapeKeyDown)}
       >
-        {children}
-        {showCloseButton && (
-          <DialogPrimitive.Close
-            data-slot="dialog-close"
-            className="absolute top-4 right-4 rounded-xs opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:ring-2 focus:ring-ring focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4"
-          >
-            <XIcon />
-            <span className="sr-only">
-              {translate('auto.components.ui.dialog.f26c4baeda', 'Close')}
-            </span>
-          </DialogPrimitive.Close>
-        )}
+        <DialogEntryContent kind={dialogKind}>
+          {children}
+          {showCloseButton && (
+            <DialogPrimitive.Close
+              data-slot="dialog-close"
+              className="absolute top-4 right-4 rounded-xs opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:ring-2 focus:ring-ring focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4"
+            >
+              <XIcon />
+              <span className="sr-only">
+                {translate('auto.components.ui.dialog.f26c4baeda', 'Close')}
+              </span>
+            </DialogPrimitive.Close>
+          )}
+        </DialogEntryContent>
       </DialogPrimitive.Content>
     </DialogPortal>
   )
diff --git a/src/renderer/src/components/use-task-page-global-effects.dialogs.test.tsx b/src/renderer/src/components/use-task-page-global-effects.dialogs.test.tsx
new file mode 100644
index 000000000000..76c00987c463
--- /dev/null
+++ b/src/renderer/src/components/use-task-page-global-effects.dialogs.test.tsx
@@ -0,0 +1,97 @@
+// @vitest-environment happy-dom
+
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import { resetDialogRegistryForTests } from '@/store/dialog-registry-test-state'
+import { AppOpenFeatureTip } from './feature-tips/AppOpenFeatureTip'
+import { useTaskPageGlobalEffects } from './use-task-page-global-effects'
+
+vi.mock('@/lib/telemetry', () => ({ track: vi.fn() }))
+vi.mock('./feature-tips/FeatureTipsModal', async () => {
+  const ui = await import('./ui/dialog')
+  return {
+    FeatureTipDialogs: ({ open, onClose }: { open: boolean; onClose: () => void }) => (
+      <ui.Dialog open={open} onOpenChange={(next) => !next && onClose()}>
+        <ui.DialogContent data-testid="feature-tip">
+          <ui.DialogTitle>Tip</ui.DialogTitle>
+          <button type="button">Got it</button>
+        </ui.DialogContent>
+      </ui.Dialog>
+    )
+  }
+})
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+let root: Root
+let container: HTMLDivElement
+const closeTaskPage = vi.fn()
+
+/** The Tasks page's Escape handling, as the page wires it. */
+function TasksPage(): null {
+  const activeModal = useAppStore((s) => s.activeModal)
+  const noop = (): void => {}
+  const model = {
+    closeTaskPage,
+    activeModal,
+    preflightStatusChecked: true,
+    preflightStatusCurrent: true,
+    linearStatusReady: true,
+    jiraStatusReady: true,
+    checkLinearConnection: noop,
+    checkJiraConnection: noop,
+    refreshPreflightStatus: noop
+  }
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the page model is large; these are the only fields the Escape and preflight effects read when nothing else is open.
+  useTaskPageGlobalEffects(model as unknown as Parameters<typeof useTaskPageGlobalEffects>[0])
+  return null
+}
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 40; i += 1) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10))
+    })
+  }
+}
+
+beforeEach(() => {
+  resetDialogRegistryForTests({ startupSettled: true })
+  useAppStore.setState(useAppStore.getInitialState(), true)
+  useAppStore.setState({ markFeatureTipsSeen: vi.fn() })
+  closeTaskPage.mockReset()
+  container = document.createElement('div')
+  document.body.append(container)
+  root = createRoot(container)
+})
+
+afterEach(() => {
+  act(() => root.unmount())
+  container.remove()
+})
+
+it('Escape over the launch tip on the Tasks page goes to the tip, not the page', async () => {
+  await act(async () =>
+    root.render(
+      <>
+        <TasksPage />
+        <AppOpenFeatureTip tipId="orca-cli" />
+      </>
+    )
+  )
+  await flush()
+  expect(document.querySelector('[data-testid="feature-tip"]')).not.toBeNull()
+  // The tip is not in the modal slot; the page still knows a dialog is up.
+  expect(useAppStore.getState().activeModal).toBe('none')
+  const button = [...document.querySelectorAll('button')].find((b) => b.textContent === 'Got it')!
+  button.focus()
+  act(() => {
+    button.dispatchEvent(
+      new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true })
+    )
+  })
+  await flush()
+  expect(closeTaskPage).not.toHaveBeenCalled()
+  expect(document.querySelector('[data-testid="feature-tip"]')).toBeNull()
+})
diff --git a/src/renderer/src/components/use-task-page-global-effects.ts b/src/renderer/src/components/use-task-page-global-effects.ts
index 395f92e7842e..08398c703868 100644
--- a/src/renderer/src/components/use-task-page-global-effects.ts
+++ b/src/renderer/src/components/use-task-page-global-effects.ts
@@ -1,5 +1,7 @@
 import type { TaskPageJiraIssueCreationModel } from './use-task-page-jira-issue-creation'
 import { useEffect } from 'react'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectDialogOnScreen } from '@/store/dialog-registry-state'
 export function useTaskPageGlobalEffects(model: TaskPageJiraIssueCreationModel) {
   const {
     closeTaskPage,
@@ -27,6 +29,8 @@ export function useTaskPageGlobalEffects(model: TaskPageJiraIssueCreationModel)
     newJiraIssueOpen
   } = model
   const githubTasksBusy = tasksLoading || tasksRefreshing || tasksFiltering
+  // Dialogs outside the modal slot too, such as the tip the app shows at launch.
+  const dialogOnScreen = useDialogRegistry(selectDialogOnScreen)
   useEffect(() => {
     // Why: when a modal is open, let it own Esc dismissal.
     if (
@@ -36,7 +40,8 @@ export function useTaskPageGlobalEffects(model: TaskPageJiraIssueCreationModel)
       newIssueOpen ||
       newLinearIssueOpen ||
       newJiraIssueOpen ||
-      activeModal !== 'none'
+      activeModal !== 'none' ||
+      dialogOnScreen
     ) {
       return
     }
@@ -82,6 +87,7 @@ export function useTaskPageGlobalEffects(model: TaskPageJiraIssueCreationModel)
   }, [
     activeModal,
     closeTaskPage,
+    dialogOnScreen,
     dialogWorkItem,
     newIssueOpen,
     newLinearIssueOpen,
diff --git a/src/renderer/src/components/use-task-page-search-actions.ts b/src/renderer/src/components/use-task-page-search-actions.ts
index f9a07140003d..963761b4948d 100644
--- a/src/renderer/src/components/use-task-page-search-actions.ts
+++ b/src/renderer/src/components/use-task-page-search-actions.ts
@@ -12,6 +12,8 @@ import { translate } from '@/i18n/i18n'
 import type { GitHubTaskKind } from '@/components/task-page-localized-options'
 import { getTaskPresetQuery } from '../../../shared/task-preset-query'
 import { shouldSuppressEnterSubmit } from '@/lib/new-workspace-enter-guard'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectDialogOnScreen } from '@/store/dialog-registry-state'
 export function useTaskPageSearchActions(model: TaskPageGitHubQuietRefreshModel) {
   const {
     setTaskResumeState,
@@ -180,6 +182,7 @@ export function useTaskPageSearchActions(model: TaskPageGitHubQuietRefreshModel)
     },
     [handleApplyTaskSearch]
   )
+  const dialogOnScreen = useDialogRegistry(selectDialogOnScreen)
   useEffect(() => {
     if (
       taskSource !== 'github' ||
@@ -189,7 +192,8 @@ export function useTaskPageSearchActions(model: TaskPageGitHubQuietRefreshModel)
       newLinearProjectOpen ||
       newLinearIssueOpen ||
       newJiraIssueOpen ||
-      activeModal !== 'none'
+      activeModal !== 'none' ||
+      dialogOnScreen
     ) {
       return
     }
@@ -227,6 +231,7 @@ export function useTaskPageSearchActions(model: TaskPageGitHubQuietRefreshModel)
       })
   }, [
     activeModal,
+    dialogOnScreen,
     dialogWorkItem,
     githubMode,
     newIssueOpen,
diff --git a/src/renderer/src/lazy-modal-mount-state.test.ts b/src/renderer/src/lazy-modal-mount-state.test.ts
index ba3faeab212e..1f95f0caea53 100644
--- a/src/renderer/src/lazy-modal-mount-state.test.ts
+++ b/src/renderer/src/lazy-modal-mount-state.test.ts
@@ -8,7 +8,7 @@ import {
 describe('isLazyModalId', () => {
   it('recognizes only lazily retained root modal ids', () => {
     expect(isLazyModalId('quick-open')).toBe(true)
-    expect(isLazyModalId('feature-tips')).toBe(true)
+    expect(isLazyModalId('feature-wall')).toBe(true)
     expect(isLazyModalId('new-workspace-composer')).toBe(false)
     expect(isLazyModalId('delete-worktree')).toBe(false)
     expect(isLazyModalId('none')).toBe(false)
diff --git a/src/renderer/src/lazy-modal-mount-state.ts b/src/renderer/src/lazy-modal-mount-state.ts
index a94b036b6874..2d9d01b521a6 100644
--- a/src/renderer/src/lazy-modal-mount-state.ts
+++ b/src/renderer/src/lazy-modal-mount-state.ts
@@ -3,8 +3,7 @@ const LAZY_MODAL_IDS = [
   'worktree-palette',
   'workspace-cleanup',
   'setup-guide',
-  'feature-wall',
-  'feature-tips'
+  'feature-wall'
 ] as const
 
 export type LazyModalId = (typeof LAZY_MODAL_IDS)[number]
diff --git a/src/renderer/src/lib/dialog-registry-entry.test.tsx b/src/renderer/src/lib/dialog-registry-entry.test.tsx
new file mode 100644
index 000000000000..8c036f7b2129
--- /dev/null
+++ b/src/renderer/src/lib/dialog-registry-entry.test.tsx
@@ -0,0 +1,128 @@
+// @vitest-environment happy-dom
+import { act, StrictMode, Suspense } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { Dialog, DialogContent, DialogTitle } from '@/components/ui/dialog'
+import { CommandDialog } from '@/components/ui/command'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { resetDialogRegistryForTests } from '@/store/dialog-registry-test-state'
+import { selectDialogOnScreen } from '@/store/dialog-registry-state'
+import { DialogEntryContent, DialogEntryScope } from './dialog-registry-entry'
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+let root: Root
+let container: HTMLDivElement
+beforeEach(() => {
+  resetDialogRegistryForTests({ startupSettled: true })
+  container = document.createElement('div')
+  document.body.append(container)
+  root = createRoot(container)
+})
+afterEach(async () => {
+  await act(async () => root.unmount())
+  container.remove()
+  vi.restoreAllMocks()
+})
+const onScreen = (): boolean => selectDialogOnScreen(useDialogRegistry.getState())
+
+it('an open root with absent or suspended content counts nothing', async () => {
+  const pending = new Promise<void>(() => {})
+  const Loading = (): never => {
+    throw pending
+  }
+  await act(async () =>
+    root.render(
+      <Dialog open>
+        <Suspense fallback={null}>
+          <Loading />
+        </Suspense>
+      </Dialog>
+    )
+  )
+  expect(onScreen()).toBe(false)
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([])
+})
+
+it('ordinary content counts through the closing animation, ending only at content unmount', async () => {
+  const render = (open: boolean): React.JSX.Element => (
+    <Dialog open={open}>
+      <DialogContent
+        style={{ animationName: open ? 'fade-in' : 'fade-out' }}
+        aria-describedby={undefined}
+      >
+        <DialogTitle>User dialog</DialogTitle>
+      </DialogContent>
+    </Dialog>
+  )
+  await act(async () => root.render(render(true)))
+  expect(onScreen()).toBe(true)
+  const token = useDialogRegistry.getState().dialogEntries[0]?.token
+  await act(async () => root.render(render(false)))
+  const content = document.querySelector('[data-slot="dialog-content"]')
+  expect(content?.getAttribute('data-state')).toBe('closed')
+  expect(onScreen()).toBe(true)
+  expect(useDialogRegistry.getState().dialogEntries[0]?.token).toBe(token)
+  const event = new Event('animationend', { bubbles: true })
+  Object.defineProperty(event, 'animationName', { value: 'fade-out' })
+  await act(async () => {
+    content?.dispatchEvent(event)
+  })
+  expect(onScreen()).toBe(false)
+})
+
+it('uncontrolled dialog and command content register without mirroring their root state', async () => {
+  await act(async () =>
+    root.render(
+      <>
+        <Dialog defaultOpen>
+          <DialogContent aria-describedby={undefined}>
+            <DialogTitle>User</DialogTitle>
+          </DialogContent>
+        </Dialog>
+        <CommandDialog defaultOpen />
+      </>
+    )
+  )
+  expect(useDialogRegistry.getState().dialogEntries).toHaveLength(2)
+})
+
+it('a nested dialog does not reuse the automatic parent token', async () => {
+  useDialogRegistry.getState().enqueueAutomaticDialog('tip', 'feature-tip')
+  await act(async () =>
+    root.render(
+      <DialogEntryScope token="tip">
+        <Dialog open>
+          <DialogContent aria-describedby={undefined}>
+            <DialogTitle>Tip</DialogTitle>
+            <Dialog open>
+              <DialogContent aria-describedby={undefined}>
+                <DialogTitle>Nested</DialogTitle>
+              </DialogContent>
+            </Dialog>
+          </DialogContent>
+        </Dialog>
+      </DialogEntryScope>
+    )
+  )
+  const entries = useDialogRegistry.getState().dialogEntries
+  expect(entries).toHaveLength(2)
+  expect(entries.find((entry) => entry.token === 'tip')?.origin).toBe('automatic')
+  expect(entries.find((entry) => entry.token !== 'tip')?.origin).toBe('user')
+})
+
+it('custom onboarding content counts only while mounted, including StrictMode replay', async () => {
+  await act(async () =>
+    root.render(
+      <StrictMode>
+        <section role="dialog">
+          <DialogEntryContent kind="onboarding" />
+        </section>
+      </StrictMode>
+    )
+  )
+  expect(useDialogRegistry.getState().dialogEntries).toEqual([
+    expect.objectContaining({ kind: 'onboarding', phase: 'visible' })
+  ])
+  await act(async () => root.render(null))
+  expect(onScreen()).toBe(false)
+})
diff --git a/src/renderer/src/lib/dialog-registry-entry.tsx b/src/renderer/src/lib/dialog-registry-entry.tsx
new file mode 100644
index 000000000000..d0343dee293d
--- /dev/null
+++ b/src/renderer/src/lib/dialog-registry-entry.tsx
@@ -0,0 +1,75 @@
+import { createContext, useContext, useId, useLayoutEffect, useRef } from 'react'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import {
+  selectDialogPhase,
+  type AutomaticDialogKind,
+  type DialogOrigin,
+  type DialogPhase
+} from '@/store/dialog-registry-state'
+
+const DialogTokenContext = createContext<string | null>(null)
+
+export function DialogEntryScope({
+  token,
+  children
+}: {
+  token: string
+  children: React.ReactNode
+}): React.JSX.Element {
+  return <DialogTokenContext.Provider value={token}>{children}</DialogTokenContext.Provider>
+}
+
+// React's effect replay keeps the same token; real disposal settles after the commit finishes.
+export function useDialogDisposal(token: string, dispose: (token: string) => void): void {
+  const current = useRef<{ token: string } | null>(null)
+  useLayoutEffect(() => {
+    const lifetime = { token }
+    current.current = lifetime
+    return () => {
+      queueMicrotask(() => {
+        if (current.current === lifetime || current.current?.token !== token) {
+          dispose(token)
+        }
+      })
+    }
+  }, [dispose, token])
+}
+
+// Lives inside portaled content, through its exit animation. Nested dialogs get their own token.
+export function DialogEntryContent({
+  kind = 'dialog',
+  origin = 'user',
+  children
+}: {
+  kind?: string
+  origin?: Exclude<DialogOrigin, 'automatic'>
+  children?: React.ReactNode
+}): React.JSX.Element {
+  const scopedToken = useContext(DialogTokenContext)
+  const ownToken = `dialog:${useId()}`
+  const token = scopedToken ?? ownToken
+  useLayoutEffect(() => {
+    useDialogRegistry.getState().dialogContentMounted(token, kind, origin)
+  }, [kind, origin, token])
+  useDialogDisposal(token, useDialogRegistry.getState().dialogContentUnmounted)
+  return <DialogTokenContext.Provider value={null}>{children}</DialogTokenContext.Provider>
+}
+
+export function useAutomaticDialogEntry(
+  token: string,
+  kind: AutomaticDialogKind,
+  request: 'automatic' | 'user' | null
+): DialogPhase | null {
+  useLayoutEffect(() => {
+    const registry = useDialogRegistry.getState()
+    if (request === 'automatic') {
+      registry.enqueueAutomaticDialog(token, kind)
+    } else if (request === 'user') {
+      registry.openDialog({ token, kind, origin: 'user' })
+    } else {
+      registry.closeDialog(token)
+    }
+  }, [kind, request, token])
+  useDialogDisposal(token, useDialogRegistry.getState().closeDialog)
+  return useDialogRegistry((s) => selectDialogPhase(s, token))
+}
diff --git a/src/renderer/src/lib/react-error-boundary-reporting.ts b/src/renderer/src/lib/react-error-boundary-reporting.ts
index f7aa47095ec1..5666daffe01d 100644
--- a/src/renderer/src/lib/react-error-boundary-reporting.ts
+++ b/src/renderer/src/lib/react-error-boundary-reporting.ts
@@ -21,7 +21,8 @@ type BuildReportArgsInput = {
 const reportedRendererErrorKeys: string[] = []
 const reportedRendererErrorKeySet = new Set<string>()
 const MAX_REPORTED_RENDERER_ERROR_KEYS = 50
-let pendingReactErrorBoundaryReport: CrashReportRecord | null = null
+// Every report not yet taken: two boundaries failing before the dialog listens are two reports.
+let pendingReactErrorBoundaryReports: CrashReportRecord[] = []
 
 export const REACT_ERROR_BOUNDARY_REPORT_AVAILABLE_EVENT =
   'orca:react-error-boundary-report-available'
@@ -113,14 +114,14 @@ function getRendererErrorKey(args: ReactErrorBoundaryReportArgs): string {
   })
 }
 
-export function takePendingReactErrorBoundaryReport(): CrashReportRecord | null {
-  const report = pendingReactErrorBoundaryReport
-  pendingReactErrorBoundaryReport = null
-  return report
+export function takePendingReactErrorBoundaryReports(): CrashReportRecord[] {
+  const reports = pendingReactErrorBoundaryReports
+  pendingReactErrorBoundaryReports = []
+  return reports
 }
 
 function notifyReactErrorBoundaryReportAvailable(report: CrashReportRecord): void {
-  pendingReactErrorBoundaryReport = report
+  pendingReactErrorBoundaryReports.push(report)
   window.dispatchEvent(new CustomEvent(REACT_ERROR_BOUNDARY_REPORT_AVAILABLE_EVENT))
 }
 
@@ -150,5 +151,5 @@ export async function reportReactErrorBoundaryCrash(
 export function clearReactErrorBoundaryReportingForTest(): void {
   reportedRendererErrorKeys.length = 0
   reportedRendererErrorKeySet.clear()
-  pendingReactErrorBoundaryReport = null
+  pendingReactErrorBoundaryReports = []
 }
diff --git a/src/renderer/src/lib/workspace-activation-terminal-focus.test.ts b/src/renderer/src/lib/workspace-activation-terminal-focus.test.ts
index e87fc615042e..4b2127117e33 100644
--- a/src/renderer/src/lib/workspace-activation-terminal-focus.test.ts
+++ b/src/renderer/src/lib/workspace-activation-terminal-focus.test.ts
@@ -1,3 +1,5 @@
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { resetDialogRegistryForTests } from '@/store/dialog-registry-test-state'
 // @vitest-environment happy-dom
 import type { AppState } from '@/store/types'
 import { act, createElement } from 'react'
@@ -41,6 +43,7 @@ function flushFrame(): void {
 }
 
 beforeEach(() => {
+  resetDialogRegistryForTests({ startupSettled: true })
   vi.clearAllMocks()
   vi.useFakeTimers()
   frame = null
@@ -126,8 +129,7 @@ describe('workspace activation focus', () => {
     { activeWorkspaceExecutionHostId: 'ssh:second-host' },
     { activeView: 'settings' },
     { activeTabType: 'browser' },
-    { activeTabId: 'tab-2' },
-    { activeModal: 'worktree-palette' }
+    { activeTabId: 'tab-2' }
   ] as const)('cancels when selection changes to %j during restoration', (change) => {
     queueWorkspaceActivationTerminalFocus('wt-1', { primaryTabId: 'tab-1' })
     flushFrame()
@@ -233,3 +235,30 @@ describe('workspace activation focus', () => {
     expect(mocks.subscribe).not.toHaveBeenCalled()
   })
 })
+
+it('a closing palette keeps its selected terminal focus request until content leaves', () => {
+  const registry = useDialogRegistry.getState()
+  registry.dialogContentMounted('palette')
+  registry.closeDialog('palette')
+  queueWorkspaceActivationTerminalFocus('wt-1', { primaryTabId: 'tab-1' })
+  flushFrame()
+  expect(mocks.focus).not.toHaveBeenCalled()
+  expect(unsubscribe).not.toHaveBeenCalled()
+  registry.dialogContentUnmounted('palette')
+  mocks.focus.mockReturnValue(true)
+  notifyMount()
+  flushFrame()
+  expect(mocks.focus).toHaveBeenCalledWith('tab-1', null, 'wt-1')
+})
+
+it('a live dialog prevents terminal focus while preserving the request', () => {
+  useDialogRegistry.getState().dialogContentMounted('tip')
+  queueWorkspaceActivationTerminalFocus('wt-1', { primaryTabId: 'tab-1' })
+  flushFrame()
+  expect(mocks.focus).not.toHaveBeenCalled()
+  document.dispatchEvent(new Event('pointerdown'))
+  useDialogRegistry.getState().dialogContentUnmounted('tip')
+  notifyMount()
+  flushFrame()
+  expect(mocks.focus).not.toHaveBeenCalled()
+})
diff --git a/src/renderer/src/lib/workspace-activation-terminal-focus.ts b/src/renderer/src/lib/workspace-activation-terminal-focus.ts
index 7b36867461bf..761bb93183ef 100644
--- a/src/renderer/src/lib/workspace-activation-terminal-focus.ts
+++ b/src/renderer/src/lib/workspace-activation-terminal-focus.ts
@@ -1,5 +1,7 @@
 import { shouldPreserveEditableFocus } from '@/components/terminal-pane/pane-helpers'
 import { useAppStore } from '@/store'
+import { useDialogRegistry } from '@/store/dialog-registry'
+import { selectDialogOnScreen } from '@/store/dialog-registry-state'
 import { focusRuntimeTerminalSurface } from '@/runtime/sync-runtime-graph'
 import type { ActivateAndRevealResult } from '@/lib/worktree-activation'
 
@@ -51,12 +53,15 @@ export function queueWorkspaceActivationTerminalFocus(
       state.activeWorkspaceExecutionHostId !== executionHostId ||
       state.activeView !== 'terminal' ||
       state.activeTabType !== 'terminal' ||
-      (tabId !== null && state.activeTabId !== tabId) ||
-      state.activeModal !== 'none'
+      (tabId !== null && state.activeTabId !== tabId)
     ) {
       cancel()
       return
     }
+    // The selecting palette can still be finishing its exit animation; keep this action pending.
+    if (state.activeModal !== 'none' || selectDialogOnScreen(useDialogRegistry.getState())) {
+      return
+    }
     tabId ??= state.activeTabId
     if (tabId && focusRuntimeTerminalSurface(tabId, null, worktreeId)) {
       cancel()
diff --git a/src/renderer/src/startup/startup-deferred-catalog-refresh.test.ts b/src/renderer/src/startup/startup-deferred-catalog-refresh.test.ts
new file mode 100644
index 000000000000..55fb81b72f7a
--- /dev/null
+++ b/src/renderer/src/startup/startup-deferred-catalog-refresh.test.ts
@@ -0,0 +1,88 @@
+// @vitest-environment happy-dom
+import { beforeEach, expect, it, vi } from 'vitest'
+import { selectStartupActions } from '../app-shell/startup-actions-selector'
+import { useAppStore } from '../store'
+import { refreshDeferredStartupCatalog } from './startup-deferred-catalog-refresh'
+
+function createCatalogActions() {
+  return {
+    ...selectStartupActions(useAppStore.getState()),
+    awaitOwnerWorktreeVisibilityDefaultsHydration: vi.fn(async () => {}),
+    fetchReposForAllHosts: vi.fn(async () => {}),
+    fetchProjectGroupsForAllHosts: vi.fn(async () => {}),
+    fetchFolderWorkspacesForAllHosts: vi.fn(async () => {}),
+    fetchAllWorktrees: vi.fn(async () => {}),
+    pruneLastVisitedTimestamps: vi.fn(),
+    fetchWorktreeLineage: vi.fn(async () => {})
+  }
+}
+
+beforeEach(() => useAppStore.setState({ startupWorktreeRefreshCompleted: false }))
+
+it('waits for owner visibility before refreshing git and folder catalogs, then releases the refresh gate', async () => {
+  const defaults = Promise.withResolvers<void>()
+  const actions = createCatalogActions()
+  actions.awaitOwnerWorktreeVisibilityDefaultsHydration.mockReturnValue(defaults.promise)
+  const refresh = refreshDeferredStartupCatalog(actions, () => false)
+  expect(actions.fetchReposForAllHosts).not.toHaveBeenCalled()
+  expect(actions.fetchFolderWorkspacesForAllHosts).not.toHaveBeenCalled()
+  expect(useAppStore.getState().startupWorktreeRefreshCompleted).toBe(false)
+  defaults.resolve()
+  await refresh
+  expect(actions.fetchReposForAllHosts).toHaveBeenCalledBefore(
+    actions.fetchProjectGroupsForAllHosts
+  )
+  expect(actions.fetchProjectGroupsForAllHosts).toHaveBeenCalledBefore(
+    actions.fetchFolderWorkspacesForAllHosts
+  )
+  expect(actions.fetchFolderWorkspacesForAllHosts).toHaveBeenCalledBefore(actions.fetchAllWorktrees)
+  expect(actions.fetchAllWorktrees).toHaveBeenCalledBefore(actions.pruneLastVisitedTimestamps)
+  expect(actions.pruneLastVisitedTimestamps).toHaveBeenCalledBefore(actions.fetchWorktreeLineage)
+  expect(useAppStore.getState().startupWorktreeRefreshCompleted).toBe(true)
+})
+
+it.each(['visibility', 'worktrees'] as const)(
+  'cancellation during %s leaves refresh completion to the next startup owner',
+  async (phase) => {
+    const pending = Promise.withResolvers<void>()
+    const actions = createCatalogActions()
+    let cancelled = false
+    if (phase === 'visibility') {
+      actions.awaitOwnerWorktreeVisibilityDefaultsHydration.mockReturnValue(pending.promise)
+    } else {
+      actions.fetchAllWorktrees.mockImplementation(() => {
+        cancelled = true
+        return pending.promise
+      })
+    }
+    const refresh = refreshDeferredStartupCatalog(actions, () => cancelled)
+    cancelled = phase === 'visibility'
+    pending.resolve()
+    await refresh
+    expect(actions.fetchReposForAllHosts).toHaveBeenCalledTimes(1)
+    expect(actions.fetchAllWorktrees).toHaveBeenCalledTimes(phase === 'visibility' ? 0 : 1)
+    expect(useAppStore.getState().startupWorktreeRefreshCompleted).toBe(false)
+  }
+)
+
+it.each(['catalog', 'worktrees'] as const)(
+  'a failed %s refresh reports the failure and releases the gate',
+  async (phase) => {
+    const actions = createCatalogActions()
+    const failure = new Error('host unavailable')
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    if (phase === 'catalog') {
+      actions.fetchReposForAllHosts.mockRejectedValue(failure)
+    } else {
+      actions.fetchAllWorktrees.mockRejectedValue(failure)
+    }
+    try {
+      await refreshDeferredStartupCatalog(actions, () => false)
+      expect(actions.fetchAllWorktrees).toHaveBeenCalledTimes(1)
+      expect(warn).toHaveBeenCalledWith(expect.any(String), failure)
+      expect(useAppStore.getState().startupWorktreeRefreshCompleted).toBe(true)
+    } finally {
+      warn.mockRestore()
+    }
+  }
+)
diff --git a/src/renderer/src/startup/startup-deferred-catalog-refresh.ts b/src/renderer/src/startup/startup-deferred-catalog-refresh.ts
new file mode 100644
index 000000000000..9ec149e4251e
--- /dev/null
+++ b/src/renderer/src/startup/startup-deferred-catalog-refresh.ts
@@ -0,0 +1,43 @@
+import type { StartupActions } from '../app-shell/startup-actions-selector'
+import { useAppStore } from '../store'
+import { timeRendererStartupStep } from './startup-diagnostics'
+
+export async function refreshDeferredStartupCatalog(
+  actions: StartupActions,
+  isCancelled: () => boolean
+): Promise<void> {
+  try {
+    try {
+      // Why: remote rows must not render under a fallback visibility while their owner default is still loading.
+      await timeRendererStartupStep('owner-visibility-defaults', () =>
+        actions.awaitOwnerWorktreeVisibilityDefaultsHydration()
+      )
+      await timeRendererStartupStep('remote-catalog-refresh', async () => {
+        await actions.fetchReposForAllHosts()
+        await actions.fetchProjectGroupsForAllHosts()
+        await actions.fetchFolderWorkspacesForAllHosts()
+      })
+    } catch (err) {
+      console.warn('Remote startup catalog refresh failed:', err)
+    }
+    if (!isCancelled()) {
+      try {
+        await timeRendererStartupStep('remote-worktree-refresh', async () => {
+          // Why: the full scan is not required for session recovery, so keep it off the startup-critical path.
+          await actions.fetchAllWorktrees()
+          // Why: the startup prune only saw session-referenced repos; use the deferred scan's
+          // authoritative results to drop deleted-worktree visit timestamps that would
+          // otherwise accumulate unbounded (disconnected SSH stays non-authoritative and is kept).
+          actions.pruneLastVisitedTimestamps()
+          await actions.fetchWorktreeLineage()
+        })
+      } catch (err) {
+        console.warn('Deferred startup worktree refresh failed:', err)
+      }
+    }
+  } finally {
+    if (!isCancelled()) {
+      useAppStore.setState({ startupWorktreeRefreshCompleted: true })
+    }
+  }
+}
diff --git a/src/renderer/src/startup/startup-discovery-read.ts b/src/renderer/src/startup/startup-discovery-read.ts
new file mode 100644
index 000000000000..bd0828380607
--- /dev/null
+++ b/src/renderer/src/startup/startup-discovery-read.ts
@@ -0,0 +1,15 @@
+import { withTimeout } from '../../../shared/promise-timeout-fallback'
+
+// Local preload IPC has no deadline; match the remote-runtime read budget to abandon this launch check.
+export const STARTUP_DISCOVERY_READ_TIMEOUT_MS = 15_000
+
+export function readStartupDiscovery<T>(pending: Promise<T>): Promise<T | null> {
+  return withTimeout<T | null>(
+    pending.catch((error) => {
+      console.error('Startup discovery read failed:', error)
+      return null
+    }),
+    STARTUP_DISCOVERY_READ_TIMEOUT_MS,
+    null
+  )
+}
diff --git a/src/renderer/src/startup/startup-runtime-session-hosts.ts b/src/renderer/src/startup/startup-runtime-session-hosts.ts
new file mode 100644
index 000000000000..dc071166e050
--- /dev/null
+++ b/src/renderer/src/startup/startup-runtime-session-hosts.ts
@@ -0,0 +1,12 @@
+import { toRuntimeExecutionHostId, type ExecutionHostId } from '../../../shared/execution-host'
+
+export async function listRuntimeSessionHostIdsForStartup(): Promise<ExecutionHostId[]> {
+  try {
+    return (await window.api.runtimeEnvironments.list()).map((environment) =>
+      toRuntimeExecutionHostId(environment.id)
+    )
+  } catch (err) {
+    console.warn('Failed to list runtime session hosts for startup:', err)
+    return []
+  }
+}
diff --git a/src/renderer/src/store/dialog-registry-state.test.ts b/src/renderer/src/store/dialog-registry-state.test.ts
new file mode 100644
index 000000000000..6a6381e8db6d
--- /dev/null
+++ b/src/renderer/src/store/dialog-registry-state.test.ts
@@ -0,0 +1,314 @@
+import { describe, expect, it } from 'vitest'
+import {
+  AUTOMATIC_DIALOG_ORDER,
+  closeDialogEntry,
+  dialogContentMounted,
+  dialogContentUnmounted,
+  endDialogEntry,
+  enqueueAutomaticDialog,
+  INITIAL_DIALOG_REGISTRY,
+  openDialogEntry,
+  selectDialogPhase,
+  selectTourBlocked,
+  selectTourParentToken,
+  selectDialogOnScreen,
+  selectTourInterrupted,
+  settleStartupSource,
+  type AutomaticDialogKind,
+  type DialogRegistry
+} from './dialog-registry-state'
+
+const settled: DialogRegistry = {
+  ...INITIAL_DIALOG_REGISTRY,
+  startupSources: { 'crash-report': 'none', 'feature-tip': 'none', 'native-chat-resume': 'none' }
+}
+
+function phase(registry: DialogRegistry, token: string): string | null {
+  return selectDialogPhase(registry, token)
+}
+
+/** What the dialog's content does: mounts once admitted, unmounts once closed. */
+function show(registry: DialogRegistry, token: string): DialogRegistry {
+  return dialogContentMounted(registry, token)
+}
+
+function dismiss(registry: DialogRegistry, token: string): DialogRegistry {
+  return dialogContentUnmounted(closeDialogEntry(registry, token), token)
+}
+
+describe('self-opening dialogs take turns', () => {
+  const pairs = AUTOMATIC_DIALOG_ORDER.flatMap((first, i) =>
+    AUTOMATIC_DIALOG_ORDER.slice(i + 1).map((second) => [first, second] as const)
+  )
+
+  it.each(pairs)('%s goes before %s, whichever was queued first', (first, second) => {
+    let registry = enqueueAutomaticDialog(settled, 'later', second)
+    // The later kind took the turn at once: nothing else was waiting.
+    expect(phase(registry, 'later')).toBe('opening')
+    registry = dismiss(show(registry, 'later'), 'later')
+
+    // Both queued while a dialog is up: the earlier kind is admitted next, not the earlier arrival.
+    registry = dialogContentMounted(registry, 'user')
+    registry = enqueueAutomaticDialog(registry, 'b', second)
+    registry = enqueueAutomaticDialog(registry, 'a', first)
+    expect(phase(registry, 'b')).toBe('queued')
+    registry = dialogContentUnmounted(registry, 'user')
+    expect(phase(registry, 'a')).toBe('opening')
+    expect(phase(registry, 'b')).toBe('queued')
+    registry = dismiss(show(registry, 'a'), 'a')
+    expect(phase(registry, 'b')).toBe('opening')
+  })
+
+  it.each(pairs)('%s goes before %s even when the later check answers first', (first, second) => {
+    let registry: DialogRegistry = {
+      ...INITIAL_DIALOG_REGISTRY,
+      startupSources: { ...settled.startupSources, [first]: 'pending' }
+    }
+    registry = settleStartupSource(registry, second, 'ready', 'b')
+    expect(phase(registry, 'b')).toBe('queued')
+    // The earlier check answers with its own dialog, which goes first.
+    registry = settleStartupSource(registry, first, 'ready', 'a')
+    expect(phase(registry, 'a')).toBe('opening')
+    expect(phase(registry, 'b')).toBe('queued')
+  })
+
+  it.each(['none', 'unavailable'] as const)(
+    'an earlier check answering %s lets the later kind show',
+    (answer) => {
+      let registry = settleStartupSource(INITIAL_DIALOG_REGISTRY, 'native-chat-resume', 'ready')
+      registry = enqueueAutomaticDialog(registry, 'resume', 'native-chat-resume')
+      registry = settleStartupSource(registry, 'crash-report', answer)
+      expect(phase(registry, 'resume')).toBe('queued')
+      registry = settleStartupSource(registry, 'feature-tip', answer)
+      expect(phase(registry, 'resume')).toBe('opening')
+    }
+  )
+
+  it('a crash report never waits for a startup check', () => {
+    const registry = enqueueAutomaticDialog(INITIAL_DIALOG_REGISTRY, 'crash', 'crash-report')
+    expect(phase(registry, 'crash')).toBe('opening')
+  })
+
+  it('a check answers once; its item is queued in the same step', () => {
+    let registry = settleStartupSource(INITIAL_DIALOG_REGISTRY, 'crash-report', 'ready', 'crash')
+    expect(registry.startupSources['crash-report']).toBe('ready')
+    expect(phase(registry, 'crash')).toBe('opening')
+    registry = settleStartupSource(registry, 'crash-report', 'unavailable')
+    expect(registry.startupSources['crash-report']).toBe('ready')
+  })
+
+  it('queues each item of a kind in arrival order; the same token is one item', () => {
+    let registry = dialogContentMounted(settled, 'user')
+    registry = enqueueAutomaticDialog(registry, 'crash:1', 'crash-report')
+    registry = enqueueAutomaticDialog(registry, 'crash:2', 'crash-report')
+    registry = enqueueAutomaticDialog(registry, 'crash:1', 'crash-report')
+    expect(registry.dialogEntries.filter((entry) => entry.kind === 'crash-report')).toHaveLength(2)
+    registry = dialogContentUnmounted(registry, 'user')
+    expect(phase(registry, 'crash:1')).toBe('opening')
+    registry = dismiss(show(registry, 'crash:1'), 'crash:1')
+    // The second report is its own dialog; the first never replaced it.
+    expect(phase(registry, 'crash:2')).toBe('opening')
+  })
+})
+
+describe('dialogs opened over a self-opening one', () => {
+  it.each(AUTOMATIC_DIALOG_ORDER)(
+    'a user dialog stacks over a shown %s, which stays; the next waits for both',
+    (kind: AutomaticDialogKind) => {
+      let registry = enqueueAutomaticDialog(settled, 'shown', kind)
+      registry = show(registry, 'shown')
+      registry = enqueueAutomaticDialog(registry, 'next', 'native-chat-resume')
+      registry = show(dialogContentMounted(registry, 'user'), 'user')
+      expect(phase(registry, 'shown')).toBe('visible')
+      expect(phase(registry, 'user')).toBe('visible')
+      registry = dismiss(registry, 'user')
+      expect(phase(registry, 'shown')).toBe('visible')
+      expect(phase(registry, 'next')).toBe('queued')
+      registry = dismiss(registry, 'shown')
+      expect(phase(registry, 'next')).toBe('opening')
+    }
+  )
+
+  it('a response dialog opens at once, even before every check has answered', () => {
+    let registry = show(
+      enqueueAutomaticDialog(INITIAL_DIALOG_REGISTRY, 'crash', 'crash-report'),
+      'crash'
+    )
+    registry = openDialogEntry(registry, {
+      token: 'ssh',
+      kind: 'ssh-credential',
+      origin: 'response'
+    })
+    expect(phase(registry, 'ssh')).toBe('opening')
+    expect(phase(registry, 'crash')).toBe('visible')
+  })
+
+  it.each(['user', 'response'] as const)(
+    'a %s dialog opened while an admitted one has not painted yet sends it back to its place',
+    (origin) => {
+      let registry = enqueueAutomaticDialog(settled, 'crash', 'crash-report')
+      const tokens = registry.dialogEntries.map((entry) => entry.token)
+      expect(phase(registry, 'crash')).toBe('opening')
+      registry = dialogContentMounted(registry, 'top', 'dialog', origin)
+      // Its code was still loading: it waits under nothing, and the dialog opened now stays on top.
+      expect(registry.dialogEntries.find((entry) => entry.token === 'crash')).toEqual(
+        expect.objectContaining({ phase: 'queued' })
+      )
+      expect(
+        registry.dialogEntries
+          .filter((entry) => tokens.includes(entry.token))
+          .map((entry) => entry.token)
+      ).toEqual(tokens)
+      registry = dismiss(show(registry, 'top'), 'top')
+      expect(phase(registry, 'crash')).toBe('opening')
+    }
+  )
+
+  it('an earlier kind queued before the admitted one painted goes first', () => {
+    let registry = enqueueAutomaticDialog(settled, 'resume', 'native-chat-resume')
+    expect(phase(registry, 'resume')).toBe('opening')
+    registry = enqueueAutomaticDialog(registry, 'tip', 'feature-tip')
+    expect(phase(registry, 'tip')).toBe('opening')
+    expect(phase(registry, 'resume')).toBe('queued')
+    // Once painted it keeps its turn.
+    registry = enqueueAutomaticDialog(show(registry, 'tip'), 'crash', 'crash-report')
+    expect(phase(registry, 'tip')).toBe('visible')
+    expect(phase(registry, 'crash')).toBe('queued')
+  })
+
+  it('the next is admitted only once the previous one finished closing', () => {
+    let registry = show(enqueueAutomaticDialog(settled, 'crash', 'crash-report'), 'crash')
+    registry = enqueueAutomaticDialog(registry, 'tip', 'feature-tip')
+    registry = closeDialogEntry(registry, 'crash')
+    // Its exit animation is still on screen.
+    expect(phase(registry, 'crash')).toBe('closing')
+    expect(phase(registry, 'tip')).toBe('queued')
+    registry = dialogContentUnmounted(registry, 'crash')
+    expect(phase(registry, 'crash')).toBeNull()
+    expect(phase(registry, 'tip')).toBe('opening')
+  })
+
+  it('a dialog reopened while closing is back on screen, not a second entry', () => {
+    let registry = show(
+      openDialogEntry(settled, { token: 'd', kind: 'dialog', origin: 'user' }),
+      'd'
+    )
+    registry = closeDialogEntry(registry, 'd')
+    registry = openDialogEntry(registry, { token: 'd', kind: 'dialog', origin: 'user' })
+    expect(registry.dialogEntries).toEqual([expect.objectContaining({ phase: 'visible' })])
+  })
+
+  it('a failed surface ends only its own entry', () => {
+    let registry = dialogContentMounted(settled, 'a')
+    registry = dialogContentMounted(registry, 'b')
+    registry = enqueueAutomaticDialog(registry, 'crash', 'crash-report')
+    registry = endDialogEntry(registry, 'a')
+    expect(phase(registry, 'a')).toBeNull()
+    expect(phase(registry, 'b')).toBe('visible')
+    expect(phase(registry, 'crash')).toBe('queued')
+  })
+
+  it('withdrawing a queued one gives its place to the next', () => {
+    let registry = dialogContentMounted(settled, 'user')
+    registry = enqueueAutomaticDialog(registry, 'crash', 'crash-report')
+    registry = enqueueAutomaticDialog(registry, 'tip', 'feature-tip')
+    registry = closeDialogEntry(registry, 'crash')
+    registry = dialogContentUnmounted(registry, 'user')
+    expect(phase(registry, 'crash')).toBeNull()
+    expect(phase(registry, 'tip')).toBe('opening')
+  })
+
+  it('the user opening a queued one opens it at once, in place', () => {
+    let registry = show(enqueueAutomaticDialog(settled, 'crash', 'crash-report'), 'crash')
+    registry = enqueueAutomaticDialog(registry, 'resume', 'native-chat-resume')
+    registry = openDialogEntry(registry, {
+      token: 'resume',
+      kind: 'native-chat-resume',
+      origin: 'user'
+    })
+    expect(registry.dialogEntries.filter((entry) => entry.token === 'resume')).toEqual([
+      expect.objectContaining({ origin: 'user', phase: 'opening' })
+    ])
+    // A later launch request for it is the same entry.
+    registry = enqueueAutomaticDialog(registry, 'resume', 'native-chat-resume')
+    expect(registry.dialogEntries.filter((entry) => entry.token === 'resume')).toHaveLength(1)
+  })
+})
+
+describe('tours', () => {
+  it('one started by the app goes after every startup check and self-opening dialog', () => {
+    expect(selectTourBlocked(INITIAL_DIALOG_REGISTRY, false)).toBe(true)
+    expect(selectTourBlocked(settled, false)).toBe(false)
+    const queued = enqueueAutomaticDialog(dialogContentMounted(settled, 'u'), 'tip', 'feature-tip')
+    expect(selectTourBlocked(dialogContentUnmounted(queued, 'u'), false)).toBe(true)
+  })
+
+  it('one the user asked for yields only to what is on screen', () => {
+    expect(selectTourBlocked(INITIAL_DIALOG_REGISTRY, true)).toBe(false)
+    const user = dialogContentMounted(settled, 'u')
+    expect(selectTourBlocked(user, true)).toBe(true)
+    expect(selectTourInterrupted(user)).toBe(true)
+  })
+
+  it('runs inside the modal it is written for, but not inside a dialog opened from it', () => {
+    let registry = dialogContentMounted(settled, 'composer', 'new-workspace-composer')
+    const parent = selectTourParentToken(registry, ['new-workspace-composer'])
+    expect(parent).toBe('composer')
+    expect(selectTourBlocked(registry, true, parent)).toBe(false)
+    expect(selectTourBlocked(registry, true)).toBe(true)
+    registry = dialogContentMounted(registry, 'nested')
+    expect(selectTourInterrupted(registry, parent)).toBe(true)
+  })
+
+  it('a running tour holds self-opening dialogs back until it ends', () => {
+    let registry = dialogContentMounted(settled, 'tour:browser', 'tour', 'tour')
+    registry = enqueueAutomaticDialog(registry, 'crash', 'crash-report')
+    expect(phase(registry, 'crash')).toBe('queued')
+    // The tour itself never counts as something a tour must give way to.
+    expect(selectTourInterrupted(registry)).toBe(false)
+    registry = dialogContentUnmounted(registry, 'tour:browser')
+    expect(phase(registry, 'crash')).toBe('opening')
+  })
+})
+
+it('user opening intent and an empty host count nothing; committed content alone blocks admission', () => {
+  let registry = openDialogEntry(settled, { token: 'user', kind: 'dialog', origin: 'user' })
+  expect(selectDialogOnScreen(registry)).toBe(false)
+  registry = enqueueAutomaticDialog(registry, 'crash', 'crash-report')
+  expect(phase(registry, 'crash')).toBe('opening')
+  registry = dialogContentMounted(registry, 'user')
+  expect(selectDialogOnScreen(registry)).toBe(true)
+  expect(phase(registry, 'crash')).toBe('queued')
+  registry = dialogContentUnmounted(registry, 'user')
+  expect(phase(registry, 'crash')).toBe('opening')
+})
+
+it('a stale content commit cannot acknowledge an automatic dialog returned to its queue', () => {
+  let registry = enqueueAutomaticDialog(settled, 'crash', 'crash-report')
+  registry = dialogContentMounted(registry, 'user')
+  registry = dialogContentMounted(registry, 'crash')
+  expect(phase(registry, 'crash')).toBe('queued')
+})
+
+it('composer allowance comes only from its mounted content, and closes with it', () => {
+  let registry = openDialogEntry(settled, {
+    token: 'composer',
+    kind: 'new-workspace-composer',
+    origin: 'user'
+  })
+  expect(selectTourParentToken(registry, ['new-workspace-composer'])).toBeNull()
+  registry = dialogContentMounted(registry, 'composer')
+  expect(selectTourParentToken(registry, ['new-workspace-composer'])).toBe('composer')
+  registry = closeDialogEntry(registry, 'composer')
+  expect(selectTourParentToken(registry, ['new-workspace-composer'])).toBeNull()
+  expect(selectTourBlocked(registry, true)).toBe(true)
+})
+
+it('onboarding content blocks automatic prompts and forced tours, without a separate visibility flag', () => {
+  let registry = dialogContentMounted(settled, 'onboarding', 'onboarding')
+  registry = enqueueAutomaticDialog(registry, 'crash', 'crash-report')
+  expect(phase(registry, 'crash')).toBe('queued')
+  expect(selectTourBlocked(registry, true)).toBe(true)
+  registry = dialogContentUnmounted(registry, 'onboarding')
+  expect(phase(registry, 'crash')).toBe('opening')
+})
diff --git a/src/renderer/src/store/dialog-registry-state.ts b/src/renderer/src/store/dialog-registry-state.ts
new file mode 100644
index 000000000000..cd22e016a7b9
--- /dev/null
+++ b/src/renderer/src/store/dialog-registry-state.ts
@@ -0,0 +1,179 @@
+export type DialogOrigin = 'automatic' | 'user' | 'response' | 'tour'
+export type DialogPhase = 'queued' | 'opening' | 'visible' | 'closing'
+export const AUTOMATIC_DIALOG_ORDER = ['crash-report', 'feature-tip', 'native-chat-resume'] as const
+export type AutomaticDialogKind = (typeof AUTOMATIC_DIALOG_ORDER)[number]
+export type StartupSourceAnswer = 'pending' | 'ready' | 'none' | 'unavailable'
+export type DialogEntry = Readonly<{
+  token: string
+  kind: string
+  origin: DialogOrigin
+  phase: DialogPhase
+}>
+export type DialogRegistry = Readonly<{
+  dialogEntries: readonly DialogEntry[]
+  startupSources: Readonly<Record<AutomaticDialogKind, StartupSourceAnswer>>
+}>
+
+export const INITIAL_DIALOG_REGISTRY: DialogRegistry = {
+  dialogEntries: [],
+  startupSources: {
+    'crash-report': 'pending',
+    'feature-tip': 'pending',
+    'native-chat-resume': 'pending'
+  }
+}
+
+function onScreen(entry: DialogEntry): boolean {
+  return entry.phase === 'visible' || entry.phase === 'closing'
+}
+
+// Uncommitted requests retain FIFO position; only their permission to render is derived.
+function nextAutomaticDialog(registry: DialogRegistry): DialogEntry | undefined {
+  if (registry.dialogEntries.some(onScreen)) {
+    return undefined
+  }
+  for (const kind of AUTOMATIC_DIALOG_ORDER) {
+    const next = registry.dialogEntries.find(
+      (entry) => entry.origin === 'automatic' && entry.kind === kind
+    )
+    if (next || registry.startupSources[kind] === 'pending') {
+      return next
+    }
+  }
+  return undefined
+}
+
+function putEntry(registry: DialogRegistry, entry: DialogEntry): DialogRegistry {
+  const existing = registry.dialogEntries.find((item) => item.token === entry.token)
+  return {
+    ...registry,
+    dialogEntries: existing
+      ? registry.dialogEntries.map((item) => (item === existing ? entry : item))
+      : [...registry.dialogEntries, entry]
+  }
+}
+
+export function enqueueAutomaticDialog(
+  registry: DialogRegistry,
+  token: string,
+  kind: AutomaticDialogKind
+): DialogRegistry {
+  return registry.dialogEntries.some((entry) => entry.token === token)
+    ? registry
+    : putEntry(registry, { token, kind, origin: 'automatic', phase: 'queued' })
+}
+
+// User-requested automatic content opens immediately, reusing its queued or shown entry.
+export function openDialogEntry(
+  registry: DialogRegistry,
+  opened: { token: string; kind: string; origin: Exclude<DialogOrigin, 'automatic'> }
+): DialogRegistry {
+  const existing = registry.dialogEntries.find((entry) => entry.token === opened.token)
+  return putEntry(registry, {
+    ...opened,
+    phase: existing && onScreen(existing) ? 'visible' : 'opening'
+  })
+}
+
+export function endDialogEntry(registry: DialogRegistry, token: string): DialogRegistry {
+  return {
+    ...registry,
+    dialogEntries: registry.dialogEntries.filter((entry) => entry.token !== token)
+  }
+}
+
+export function closeDialogEntry(registry: DialogRegistry, token: string): DialogRegistry {
+  const entry = registry.dialogEntries.find((item) => item.token === token)
+  return entry?.phase === 'visible'
+    ? putEntry(registry, { ...entry, phase: 'closing' })
+    : entry?.phase === 'closing'
+      ? registry
+      : endDialogEntry(registry, token)
+}
+
+// Ordinary dialogs exist only for their mounted content, including the exit animation.
+export function dialogContentMounted(
+  registry: DialogRegistry,
+  token: string,
+  kind = 'dialog',
+  origin: Exclude<DialogOrigin, 'automatic'> = 'user'
+): DialogRegistry {
+  const entry = registry.dialogEntries.find((item) => item.token === token)
+  if (selectDialogPhase(registry, token) === 'queued' || (entry && onScreen(entry))) {
+    return registry
+  }
+  return putEntry(registry, { token, kind, origin, ...entry, phase: 'visible' })
+}
+
+export function dialogContentUnmounted(registry: DialogRegistry, token: string): DialogRegistry {
+  const entry = registry.dialogEntries.find((item) => item.token === token)
+  return entry?.origin === 'automatic' && entry.phase === 'visible'
+    ? putEntry(registry, { ...entry, phase: 'queued' })
+    : endDialogEntry(registry, token)
+}
+
+// The answer and its item enter together, leaving no gap for a later startup kind.
+export function settleStartupSource(
+  registry: DialogRegistry,
+  kind: AutomaticDialogKind,
+  answer: Exclude<StartupSourceAnswer, 'pending'>,
+  itemToken?: string
+): DialogRegistry {
+  const next = itemToken ? enqueueAutomaticDialog(registry, itemToken, kind) : registry
+  return next.startupSources[kind] !== 'pending'
+    ? next
+    : { ...next, startupSources: { ...next.startupSources, [kind]: answer } }
+}
+
+export function selectDialogOnScreen(registry: DialogRegistry): boolean {
+  return registry.dialogEntries.some((entry) => onScreen(entry) && entry.origin !== 'tour')
+}
+
+export function selectDialogPhase(registry: DialogRegistry, token: string): DialogPhase | null {
+  const entry = registry.dialogEntries.find((item) => item.token === token)
+  return entry?.phase === 'queued' && nextAutomaticDialog(registry) === entry
+    ? 'opening'
+    : (entry?.phase ?? null)
+}
+
+export function selectAdmittedDialog(
+  registry: DialogRegistry,
+  kind: AutomaticDialogKind
+): DialogEntry | undefined {
+  return registry.dialogEntries.find(
+    (entry) => entry.kind === kind && selectDialogPhase(registry, entry.token) !== 'queued'
+  )
+}
+
+export function selectTourParentToken(
+  registry: DialogRegistry,
+  allowedModals: readonly string[] = []
+): string | null {
+  return (
+    registry.dialogEntries.find(
+      (entry) => entry.phase === 'visible' && allowedModals.includes(entry.kind)
+    )?.token ?? null
+  )
+}
+
+export function selectTourInterrupted(
+  registry: DialogRegistry,
+  parentToken?: string | null
+): boolean {
+  return registry.dialogEntries.some(
+    (entry) => onScreen(entry) && entry.origin !== 'tour' && entry.token !== parentToken
+  )
+}
+
+export function selectTourBlocked(
+  registry: DialogRegistry,
+  forced: boolean,
+  parentToken?: string | null
+): boolean {
+  return (
+    selectTourInterrupted(registry, parentToken) ||
+    (!forced &&
+      (registry.dialogEntries.some((entry) => entry.origin === 'automatic') ||
+        Object.values(registry.startupSources).includes('pending')))
+  )
+}
diff --git a/src/renderer/src/store/dialog-registry-test-state.ts b/src/renderer/src/store/dialog-registry-test-state.ts
new file mode 100644
index 000000000000..d7266cbe225c
--- /dev/null
+++ b/src/renderer/src/store/dialog-registry-test-state.ts
@@ -0,0 +1,18 @@
+import { useDialogRegistry } from './dialog-registry'
+import { INITIAL_DIALOG_REGISTRY } from './dialog-registry-state'
+
+/** @internal - tests start from an empty registry; `startupSettled` models a running app. */
+export function resetDialogRegistryForTests(options: { startupSettled?: boolean } = {}): void {
+  useDialogRegistry.setState({
+    ...INITIAL_DIALOG_REGISTRY,
+    ...(options.startupSettled
+      ? {
+          startupSources: {
+            'crash-report': 'none',
+            'feature-tip': 'none',
+            'native-chat-resume': 'none'
+          }
+        }
+      : {})
+  })
+}
diff --git a/src/renderer/src/store/dialog-registry.ts b/src/renderer/src/store/dialog-registry.ts
new file mode 100644
index 000000000000..f1c5e65c042e
--- /dev/null
+++ b/src/renderer/src/store/dialog-registry.ts
@@ -0,0 +1,38 @@
+import { create } from 'zustand'
+import {
+  closeDialogEntry,
+  dialogContentMounted,
+  dialogContentUnmounted,
+  endDialogEntry,
+  enqueueAutomaticDialog,
+  INITIAL_DIALOG_REGISTRY,
+  openDialogEntry,
+  settleStartupSource,
+  type DialogRegistry
+} from './dialog-registry-state'
+
+type DialogRegistryActions = {
+  openDialog: (...args: DropFirst<Parameters<typeof openDialogEntry>>) => void
+  enqueueAutomaticDialog: (...args: DropFirst<Parameters<typeof enqueueAutomaticDialog>>) => void
+  closeDialog: (token: string) => void
+  endDialog: (token: string) => void
+  dialogContentMounted: (...args: DropFirst<Parameters<typeof dialogContentMounted>>) => void
+  dialogContentUnmounted: (token: string) => void
+  settleStartupSource: (...args: DropFirst<Parameters<typeof settleStartupSource>>) => void
+}
+
+type DropFirst<T extends unknown[]> = T extends [unknown, ...infer Rest] ? Rest : never
+
+export type DialogRegistryStore = DialogRegistry & DialogRegistryActions
+
+// Window-scoped presentation state stays separate from persisted app data.
+export const useDialogRegistry = create<DialogRegistryStore>()((set) => ({
+  ...INITIAL_DIALOG_REGISTRY,
+  openDialog: (...args) => set((s) => openDialogEntry(s, ...args)),
+  enqueueAutomaticDialog: (...args) => set((s) => enqueueAutomaticDialog(s, ...args)),
+  closeDialog: (token) => set((s) => closeDialogEntry(s, token)),
+  endDialog: (token) => set((s) => endDialogEntry(s, token)),
+  dialogContentMounted: (...args) => set((s) => dialogContentMounted(s, ...args)),
+  dialogContentUnmounted: (token) => set((s) => dialogContentUnmounted(s, token)),
+  settleStartupSource: (...args) => set((s) => settleStartupSource(s, ...args))
+}))
diff --git a/src/renderer/src/store/slices/ui-contextual-tours.test.ts b/src/renderer/src/store/slices/ui-contextual-tours.test.ts
index 3db02f6e587f..06ea67a083dc 100644
--- a/src/renderer/src/store/slices/ui-contextual-tours.test.ts
+++ b/src/renderer/src/store/slices/ui-contextual-tours.test.ts
@@ -2,6 +2,9 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { PersistedUIState } from '../../../../shared/persisted-ui-state-types'
 import type { ContextualTourId } from '../../../../shared/contextual-tours'
 import { createUIStore, makePersistedUI } from './ui-slice-test-harness'
+import { useDialogRegistry } from '../dialog-registry'
+import { selectDialogPhase } from '../dialog-registry-state'
+import { resetDialogRegistryForTests } from '../dialog-registry-test-state'
 
 const mocks = vi.hoisted(() => ({
   sendNotesToActiveAgentSession: vi.fn(),
@@ -225,13 +228,60 @@ describe('createUISlice contextual tours', () => {
     stubContextualTourTargets(['[data-contextual-tour-target="tasks-source-filters"]'])
     store.getState().hydratePersistedUI(makeAutoTourEligibleUI())
 
-    store.getState().setContextualToursBlockingSurfaceVisible(true)
+    useDialogRegistry.getState().dialogContentMounted('confirmation')
     store.getState().requestContextualTour('tasks', 'tasks_open')
 
     expect(store.getState().activeContextualTourId).toBeNull()
     expect(store.getState().contextualTourShownThisSession).toBe(false)
   })
 
+  it('runs the composer tour inside the composer, but not over a dialog opened from it', () => {
+    const store = createUIStore()
+    stubContextualTourTargets(['[data-contextual-tour-target="workspace-creation-project"]'])
+    store.getState().hydratePersistedUI(makeAutoTourEligibleUI())
+    store.getState().openModal('new-workspace-composer')
+    useDialogRegistry.getState().dialogContentMounted('composer', 'new-workspace-composer')
+    useDialogRegistry.getState().dialogContentMounted('nested')
+    const request = (): void =>
+      store
+        .getState()
+        .requestContextualTour('workspace-creation', 'workspace_creation_modal', false, {
+          force: true
+        })
+
+    request()
+    expect(store.getState().activeContextualTourId).toBeNull()
+    useDialogRegistry.getState().dialogContentUnmounted('nested')
+    request()
+    expect(store.getState().activeContextualTourId).toBe('workspace-creation')
+  })
+
+  it('goes after every startup check and dialog the app opens by itself', () => {
+    const store = createUIStore()
+    resetDialogRegistryForTests()
+    stubContextualTourTargets(['[data-contextual-tour-target="tasks-source-filters"]'])
+    store.getState().hydratePersistedUI(makeAutoTourEligibleUI())
+    const registry = useDialogRegistry.getState
+
+    registry().settleStartupSource('crash-report', 'none')
+    registry().settleStartupSource('native-chat-resume', 'none')
+    registry().settleStartupSource('feature-tip', 'ready')
+    registry().enqueueAutomaticDialog('tip', 'feature-tip')
+    store.getState().requestContextualTour('tasks', 'tasks_open')
+    expect(store.getState().activeContextualTourId).toBeNull()
+
+    registry().closeDialog('tip')
+    store.getState().requestContextualTour('tasks', 'tasks_open')
+    expect(store.getState().activeContextualTourId).toBe('tasks')
+    // The rendered overlay owns occupancy; an unrendered tour request counts nothing.
+    registry().dialogContentMounted('tour:tasks', 'tour', 'tour')
+    registry().enqueueAutomaticDialog('crash', 'crash-report')
+    expect(selectDialogPhase(registry(), 'crash')).toBe('queued')
+    store.getState().dismissContextualTour('tasks')
+    registry().dialogContentUnmounted('tour:tasks')
+    expect(selectDialogPhase(registry(), 'crash')).toBe('opening')
+  })
+
   it('does not auto-start tours for profiles that are not eligible', () => {
     const store = createUIStore()
     stubContextualTourTargets(['[data-contextual-tour-target="tasks-source-filters"]'])
@@ -297,6 +347,7 @@ describe('createUISlice contextual tours', () => {
     store.getState().hydratePersistedUI(makeAutoTourEligibleUI())
 
     store.getState().openModal('new-workspace-composer')
+    useDialogRegistry.getState().dialogContentMounted('composer', 'new-workspace-composer')
     store.getState().requestContextualTour('tasks', 'tasks_open')
     expect(store.getState().activeContextualTourId).toBeNull()
 
diff --git a/src/renderer/src/store/slices/ui-slice-test-harness.ts b/src/renderer/src/store/slices/ui-slice-test-harness.ts
index b8bbcf24b855..6322c8bf3d2e 100644
--- a/src/renderer/src/store/slices/ui-slice-test-harness.ts
+++ b/src/renderer/src/store/slices/ui-slice-test-harness.ts
@@ -5,8 +5,11 @@ import type { AppState } from '../types'
 import { createUISlice } from './ui'
 import { createWorktreeNavHistorySlice } from './worktree-nav-history'
 import { createSettingsSearchState } from './settings-search-state'
+import { resetDialogRegistryForTests } from '../dialog-registry-test-state'
 
 export function createUIStore(): StoreApi<AppState> {
+  // Why: the registry is per window, not per store; these cases model a running app past startup.
+  resetDialogRegistryForTests({ startupSettled: true })
   // Only the UI slice, repo/worktree ids, and right sidebar width fallback are
   // needed for these tests. The worktree-nav-history slice is also included
   // because page opens record view visits.
diff --git a/src/renderer/src/store/slices/ui/ui-slice-contract-contextual.ts b/src/renderer/src/store/slices/ui/ui-slice-contract-contextual.ts
index d8ea7fe00046..5b1541510a37 100644
--- a/src/renderer/src/store/slices/ui/ui-slice-contract-contextual.ts
+++ b/src/renderer/src/store/slices/ui/ui-slice-contract-contextual.ts
@@ -31,7 +31,6 @@ export type UISliceContextual = {
   clearAppearanceAccordionDeepLink: () => void
   activeModal:
     | 'none'
-    | 'create-worktree'
     | 'edit-meta'
     | 'delete-worktree'
     | 'preserved-branch-review'
@@ -43,11 +42,9 @@ export type UISliceContextual = {
     | 'quick-open'
     | 'worktree-palette'
     | 'workspace-cleanup'
-    | 'project-added'
     | 'worktree-visibility'
     | 'setup-guide'
     | 'feature-wall'
-    | 'feature-tips'
     | 'new-workspace-composer'
     | 'confirm-orca-yaml-hooks'
   modalData: Record<string, unknown>
@@ -59,6 +56,7 @@ export type UISliceContextual = {
   recordFeatureInteraction: (id: FeatureInteractionId) => Promise<void>
   contextualToursSeenIds: ContextualTourId[]
   contextualToursAutoEligible: boolean | null
+  contextualToursAwaitingOnboarding: boolean
   activeContextualTourId: ContextualTourId | null
   activeContextualTourStepIndex: number
   activeContextualTourSource: string | null
@@ -67,12 +65,9 @@ export type UISliceContextual = {
   contextualTourNavigationInteractionSnapshot: Partial<Record<ContextualTourId, boolean>>
   activeContextualTourSuppressed: boolean
   contextualTourShownThisSession: boolean
-  contextualToursOnboardingVisible: boolean
-  contextualToursBlockingSurfaceVisible: boolean
   lastCompletedContextualTourId: ContextualTourId | null
   setContextualToursAutoEligible: (eligible: boolean) => void
-  setContextualToursOnboardingVisible: (visible: boolean) => void
-  setContextualToursBlockingSurfaceVisible: (visible: boolean) => void
+  setContextualToursAwaitingOnboarding: (awaiting: boolean) => void
   requestContextualTour: (
     id: ContextualTourId,
     source: string,
diff --git a/src/renderer/src/store/slices/ui/ui-slice-modal-actions.ts b/src/renderer/src/store/slices/ui/ui-slice-modal-actions.ts
index 278aefd58030..44776a21117a 100644
--- a/src/renderer/src/store/slices/ui/ui-slice-modal-actions.ts
+++ b/src/renderer/src/store/slices/ui/ui-slice-modal-actions.ts
@@ -6,7 +6,7 @@ export function createUiModalActions(set: UISliceSet, get: UISliceGet): Partial<
     activeModal: 'none',
     modalData: {},
     openModal: (modal, data = {}) => {
-      if (modal === 'add-repo' || modal === 'create-worktree') {
+      if (modal === 'add-repo') {
         get().recordFeatureInteraction?.('workspace-creation')
       }
       const evicted = get().modalData
diff --git a/src/renderer/src/store/slices/ui/ui-slice-tour-actions.ts b/src/renderer/src/store/slices/ui/ui-slice-tour-actions.ts
index 9f26a4092603..3a4c7007dcb6 100644
--- a/src/renderer/src/store/slices/ui/ui-slice-tour-actions.ts
+++ b/src/renderer/src/store/slices/ui/ui-slice-tour-actions.ts
@@ -7,11 +7,14 @@ import {
   getPreviousVisibleContextualTourStepIndex
 } from '../../../components/contextual-tours/contextual-tour-gate'
 import { hasFeatureInteraction } from '../../../../../shared/feature-interactions'
+import { useDialogRegistry } from '../../dialog-registry'
+import { selectTourBlocked, selectTourParentToken } from '../../dialog-registry-state'
 
 export function createUiTourActions(set: UISliceSet, get: UISliceGet): Partial<UISlice> {
   return {
     contextualToursSeenIds: [],
     contextualToursAutoEligible: null,
+    contextualToursAwaitingOnboarding: false,
     activeContextualTourId: null,
     activeContextualTourStepIndex: 0,
     activeContextualTourSource: null,
@@ -20,8 +23,6 @@ export function createUiTourActions(set: UISliceSet, get: UISliceGet): Partial<U
     contextualTourNavigationInteractionSnapshot: {},
     activeContextualTourSuppressed: false,
     contextualTourShownThisSession: false,
-    contextualToursOnboardingVisible: false,
-    contextualToursBlockingSurfaceVisible: false,
     lastCompletedContextualTourId: null,
     setContextualToursAutoEligible: (eligible) =>
       set((s) => {
@@ -33,17 +34,11 @@ export function createUiTourActions(set: UISliceSet, get: UISliceGet): Partial<U
         }
         return { contextualToursAutoEligible: eligible }
       }),
-    setContextualToursOnboardingVisible: (visible) =>
+    setContextualToursAwaitingOnboarding: (awaiting) =>
       set((s) =>
-        s.contextualToursOnboardingVisible === visible
+        s.contextualToursAwaitingOnboarding === awaiting
           ? s
-          : { contextualToursOnboardingVisible: visible }
-      ),
-    setContextualToursBlockingSurfaceVisible: (visible) =>
-      set((s) =>
-        s.contextualToursBlockingSurfaceVisible === visible
-          ? s
-          : { contextualToursBlockingSurfaceVisible: visible }
+          : { contextualToursAwaitingOnboarding: awaiting }
       ),
     requestContextualTour: (id, source, wasFeaturePreviouslyInteracted, options) =>
       set((s) => {
@@ -52,12 +47,16 @@ export function createUiTourActions(set: UISliceSet, get: UISliceGet): Partial<U
           tour,
           persistedUIReady: s.persistedUIReady,
           autoEligible: options?.force === true || s.contextualToursAutoEligible === true,
-          onboardingVisible: s.contextualToursOnboardingVisible,
           seenIds: options?.force === true ? [] : s.contextualToursSeenIds,
           sessionConsumed: options?.force === true ? false : s.contextualTourShownThisSession,
           activeTourId: s.activeContextualTourId,
-          activeModal: s.activeModal,
-          blockingSurfaceVisible: s.contextualToursBlockingSurfaceVisible,
+          blockingSurfaceVisible:
+            s.contextualToursAwaitingOnboarding ||
+            selectTourBlocked(
+              useDialogRegistry.getState(),
+              options?.force === true,
+              selectTourParentToken(useDialogRegistry.getState(), tour.allowedActiveModals)
+            ),
           targetExists: hasContextualTourTarget
         })
         if (decision.kind !== 'start') {
diff --git a/src/shared/usage-percentage-display-change-notice.test.ts b/src/shared/usage-percentage-display-change-notice.test.ts
index 4942aefe9006..c0edd53908c9 100644
--- a/src/shared/usage-percentage-display-change-notice.test.ts
+++ b/src/shared/usage-percentage-display-change-notice.test.ts
@@ -61,7 +61,8 @@ describe('shouldShowUsagePercentageDisplayChangeNotice', () => {
         usagePercentageDisplayChangeNoticeDismissed: false,
         statusBarVisible: true,
         hasVisibleUsageMeters: true,
-        activeModal: 'none'
+        activeModal: 'none',
+        dialogOnScreen: false
       })
     ).toBe(true)
 
@@ -71,7 +72,8 @@ describe('shouldShowUsagePercentageDisplayChangeNotice', () => {
         usagePercentageDisplayChangeNoticeDismissed: false,
         statusBarVisible: true,
         hasVisibleUsageMeters: true,
-        activeModal: 'none'
+        activeModal: 'none',
+        dialogOnScreen: false
       })
     ).toBe(false)
 
@@ -81,7 +83,8 @@ describe('shouldShowUsagePercentageDisplayChangeNotice', () => {
         usagePercentageDisplayChangeNoticeDismissed: true,
         statusBarVisible: true,
         hasVisibleUsageMeters: true,
-        activeModal: 'none'
+        activeModal: 'none',
+        dialogOnScreen: false
       })
     ).toBe(false)
 
@@ -91,7 +94,8 @@ describe('shouldShowUsagePercentageDisplayChangeNotice', () => {
         usagePercentageDisplayChangeNoticeDismissed: false,
         statusBarVisible: false,
         hasVisibleUsageMeters: true,
-        activeModal: 'none'
+        activeModal: 'none',
+        dialogOnScreen: false
       })
     ).toBe(false)
 
@@ -101,7 +105,8 @@ describe('shouldShowUsagePercentageDisplayChangeNotice', () => {
         usagePercentageDisplayChangeNoticeDismissed: false,
         statusBarVisible: true,
         hasVisibleUsageMeters: false,
-        activeModal: 'none'
+        activeModal: 'none',
+        dialogOnScreen: false
       })
     ).toBe(false)
 
@@ -111,7 +116,20 @@ describe('shouldShowUsagePercentageDisplayChangeNotice', () => {
         usagePercentageDisplayChangeNoticeDismissed: false,
         statusBarVisible: true,
         hasVisibleUsageMeters: true,
-        activeModal: 'feature-tips'
+        activeModal: 'add-repo',
+        dialogOnScreen: false
+      })
+    ).toBe(false)
+
+    // A dialog outside the modal slot, such as the tip the app shows at launch, holds it too.
+    expect(
+      shouldShowUsagePercentageDisplayChangeNotice({
+        persistedUIReady: true,
+        usagePercentageDisplayChangeNoticeDismissed: false,
+        statusBarVisible: true,
+        hasVisibleUsageMeters: true,
+        activeModal: 'none',
+        dialogOnScreen: true
       })
     ).toBe(false)
   })
diff --git a/src/shared/usage-percentage-display-change-notice.ts b/src/shared/usage-percentage-display-change-notice.ts
index caeaa6ccfb67..007fbf293964 100644
--- a/src/shared/usage-percentage-display-change-notice.ts
+++ b/src/shared/usage-percentage-display-change-notice.ts
@@ -34,12 +34,15 @@ export function shouldShowUsagePercentageDisplayChangeNotice(args: {
   statusBarVisible: boolean
   hasVisibleUsageMeters: boolean
   activeModal: string
+  /** Any dialog up, including the ones the app opens by itself outside the modal slot. */
+  dialogOnScreen: boolean
 }): boolean {
   return (
     args.persistedUIReady &&
     !args.usagePercentageDisplayChangeNoticeDismissed &&
     args.statusBarVisible &&
     args.hasVisibleUsageMeters &&
-    args.activeModal === 'none'
+    args.activeModal === 'none' &&
+    !args.dialogOnScreen
   )
 }
diff --git a/tests/e2e/add-project-default-checkout.spec.ts b/tests/e2e/add-project-default-checkout.spec.ts
index 6a678c0bf9ab..4aa5bcdd7c76 100644
--- a/tests/e2e/add-project-default-checkout.spec.ts
+++ b/tests/e2e/add-project-default-checkout.spec.ts
@@ -120,8 +120,7 @@ test.describe('Add project default checkout', () => {
             return {
               activeCheckoutIsDefault: state.activeWorktreeId === defaultCheckout?.id,
               defaultCheckoutLooksCloned:
-                normalizedDefaultCheckoutPath?.endsWith(`/clones/${cloneName}`) ?? false,
-              oldSetupModalOpen: state.activeModal === 'project-added'
+                normalizedDefaultCheckoutPath?.endsWith(`/clones/${cloneName}`) ?? false
             }
           }, path.basename(fixture.sourcePath)),
         {
@@ -131,8 +130,7 @@ test.describe('Add project default checkout', () => {
       )
       .toEqual({
         activeCheckoutIsDefault: true,
-        defaultCheckoutLooksCloned: true,
-        oldSetupModalOpen: false
+        defaultCheckoutLooksCloned: true
       })
   })