diff --git a/web/__test__/components/ChangelogModal.test.ts b/web/__test__/components/ChangelogModal.test.ts
index 6c6772405e..2e0603a378 100644
--- a/web/__test__/components/ChangelogModal.test.ts
+++ b/web/__test__/components/ChangelogModal.test.ts
@@ -11,13 +11,14 @@ vi.mock('@unraid/ui', () => ({
   BrandButton: { template: '<button><slot /></button>' },
   BrandLoading: { template: '<div class="brand-loading" />' },
   cn: (...classes: string[]) => classes.filter(Boolean).join(' '),
-  ResponsiveModal: { template: '<div><slot /></div>', props: ['open'] },
+  ResponsiveModal: { template: '<div class="responsive-modal"><slot /></div>', props: ['open'] },
   ResponsiveModalFooter: { template: '<div><slot /></div>' },
-  ResponsiveModalHeader: { template: '<div><slot /></div>' },
-  ResponsiveModalTitle: { template: '<div><slot /></div>' },
+  ResponsiveModalHeader: { template: '<div class="responsive-modal-header"><slot /></div>' },
+  ResponsiveModalTitle: { template: '<h2><slot /></h2>' },
 }));
 
 vi.mock('@heroicons/vue/24/solid', () => ({
+  ArrowPathIcon: { template: '<svg />' },
   ArrowRightIcon: { template: '<svg />' },
   ArrowTopRightOnSquareIcon: { template: '<svg />' },
   KeyIcon: { template: '<svg />' },
@@ -109,6 +110,18 @@ describe('ChangelogModal iframeSrc', () => {
       },
     });
 
+  it('keeps its title in the header and exposes a loading status', () => {
+    const wrapper = mount(ChangelogModal, {
+      props: { open: true, release: { version: '7.3.0' } },
+      global: { plugins: [createTestI18n()] },
+    });
+    expect(wrapper.find('.responsive-modal > .responsive-modal-header h2').text()).toBe(
+      'Unraid 7.3.0 release notes'
+    );
+    expect(wrapper.find('[role="status"]').text()).toBe('Loading release notes');
+    expect(wrapper.find('[role="status"] .brand-loading').exists()).toBe(true);
+  });
+
   beforeEach(() => {
     mockRenew.mockClear();
     mockAvailableWithRenewal.value = false;
diff --git a/web/__test__/components/CheckUpdateResponseModal.test.ts b/web/__test__/components/CheckUpdateResponseModal.test.ts
index 0f768c07ac..4edeeb1c2e 100644
--- a/web/__test__/components/CheckUpdateResponseModal.test.ts
+++ b/web/__test__/components/CheckUpdateResponseModal.test.ts
@@ -1,11 +1,13 @@
 import { nextTick, ref } from 'vue';
-import { mount } from '@vue/test-utils';
+import { enableAutoUnmount, flushPromises, mount } from '@vue/test-utils';
 
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import CheckUpdateResponseModal from '~/components/UpdateOs/CheckUpdateResponseModal.vue';
 import { createTestI18n, testTranslate } from '../utils/i18n';
 
+enableAutoUnmount(afterEach);
+
 vi.mock('@unraid/ui', () => ({
   BrandButton: {
     name: 'BrandButton',
@@ -18,6 +20,7 @@ vi.mock('@unraid/ui', () => ({
     emits: ['click'],
     template: '<button class="brand-button" @click="$emit(\'click\')"><slot>{{ text }}</slot></button>',
   },
+  CardWrapper: { template: '<section class="card-wrapper"><slot /></section>' },
   BrandLoading: { template: '<div class="brand-loading" />' },
   Button: { template: '<button class="ui-button"><slot /></button>' },
   cn: (...classes: string[]) => classes.filter(Boolean).join(' '),
@@ -31,7 +34,13 @@ vi.mock('@unraid/ui', () => ({
   ResponsiveModalFooter: { template: '<div class="responsive-modal-footer"><slot /></div>' },
   ResponsiveModalHeader: { template: '<div class="responsive-modal-header"><slot /></div>' },
   ResponsiveModalTitle: { template: '<div class="responsive-modal-title"><slot /></div>' },
-  Switch: { name: 'Switch', props: ['modelValue'], template: '<div class="switch" />' },
+  Switch: {
+    name: 'Switch',
+    props: ['modelValue'],
+    emits: ['update:modelValue'],
+    template:
+      '<button role="switch" :aria-checked="modelValue" @click="$emit(\'update:modelValue\', !modelValue)" />',
+  },
   Tooltip: { template: '<div class="tooltip"><slot /></div>' },
   TooltipTrigger: { template: '<div class="tooltip-trigger"><slot /></div>' },
   TooltipContent: { template: '<div class="tooltip-content"><slot /></div>' },
@@ -45,10 +54,13 @@ vi.mock('@heroicons/vue/24/solid', () => ({
   EyeIcon: { template: '<svg />' },
   IdentificationIcon: { template: '<svg />' },
   KeyIcon: { template: '<svg />' },
+  ArrowPathIcon: { template: '<svg />' },
+  XCircleIcon: { template: '<svg />' },
 }));
 
 vi.mock('@heroicons/vue/24/outline', () => ({
-  ArrowDownTrayIcon: { template: '<svg />' },
+  ArrowLongRightIcon: { template: '<svg />' },
+  XMarkIcon: { template: '<svg />' },
 }));
 
 vi.mock('~/components/UpdateOs/IgnoredRelease.vue', () => ({
@@ -56,8 +68,8 @@ vi.mock('~/components/UpdateOs/IgnoredRelease.vue', () => ({
 }));
 
 vi.mock('~/composables/dateTime', () => ({
-  default: () => ({
-    outputDateTimeFormatted: ref('2024-01-01'),
+  default: (_format: unknown, _t: unknown, _local: boolean, timestamp: number) => ({
+    outputDateTimeFormatted: ref(new Date(timestamp * 1000).toISOString().slice(0, 10)),
     outputDateTimeReadableDiff: ref('today'),
   }),
 }));
@@ -117,6 +129,15 @@ const availableWithRenewal = ref<string | null>(null);
 const availableReleaseDate = ref<number | null>(null);
 const availableRequiresAuth = ref(false);
 const checkForUpdatesLoading = ref(false);
+const checkForUpdatesFailed = ref(false);
+const mockLocalCheckForUpdate = vi.fn().mockResolvedValue(undefined);
+const mockRebootServer = vi.fn();
+const mockCancelUpdate = vi.fn();
+const rebootType = ref('');
+const rebootVersion = ref('');
+vi.mock('~/store/updateOsActions', () => ({
+  useUpdateOsActionsStore: () => ({ rebootTypeText: 'Reboot required', rebootServer: mockRebootServer }),
+}));
 
 vi.mock('~/store/updateOs', () => ({
   useUpdateOsStore: () => ({
@@ -125,6 +146,9 @@ vi.mock('~/store/updateOs', () => ({
     availableReleaseDate,
     availableRequiresAuth,
     checkForUpdatesLoading,
+    checkForUpdatesFailed,
+    localCheckForUpdate: mockLocalCheckForUpdate,
+    cancelUpdate: mockCancelUpdate,
     setReleaseForUpdate: mockSetReleaseForUpdate,
     setModalOpen: mockSetModalOpen,
     fetchAndConfirmInstall: mockFetchAndConfirmInstall,
@@ -150,27 +174,39 @@ vi.mock('~/store/server', () => ({
     updateOsIgnoredReleases,
     updateOsNotificationsEnabled,
     updateOsResponse,
+    rebootType,
+    rebootVersion,
     updateOsIgnoreRelease: mockUpdateOsIgnoreRelease,
   }),
 }));
 
-const mountModal = () =>
+const mountModal = (embedded = false, open = true) =>
   mount(CheckUpdateResponseModal, {
     props: {
-      open: true,
+      open,
+      embedded,
     },
     global: {
       plugins: [createTestI18n()],
     },
   });
 
-describe('CheckUpdateResponseModal', () => {
+describe.each([false, true])('CheckUpdateResponseModal (embedded=%s)', (embedded) => {
+  const renderModal = () => mountModal(embedded);
+  const titleSelector = embedded ? 'h2' : '.responsive-modal-title';
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
   beforeEach(() => {
     available.value = null;
     availableWithRenewal.value = null;
     availableReleaseDate.value = null;
     availableRequiresAuth.value = false;
     checkForUpdatesLoading.value = false;
+    checkForUpdatesFailed.value = false;
+    rebootType.value = '';
+    rebootVersion.value = '';
     regExp.value = null;
     regUpdatesExpired.value = false;
     osVersion.value = null;
@@ -184,35 +220,129 @@ describe('CheckUpdateResponseModal', () => {
     mockSetReleaseForUpdate.mockClear();
     mockFetchAndConfirmInstall.mockClear();
     mockUpdateOsIgnoreRelease.mockClear();
+    mockRebootServer.mockClear();
+    mockCancelUpdate.mockClear();
+    mockLocalCheckForUpdate.mockClear();
+  });
+
+  it('places the heading and footer directly in the modal shell', () => {
+    if (embedded) return;
+    available.value = '7.3.0';
+    const wrapper = renderModal();
+    expect(
+      wrapper.find('.responsive-modal > .responsive-modal-header .responsive-modal-title').exists()
+    ).toBe(true);
+    expect(wrapper.find('.responsive-modal > .responsive-modal-footer').exists()).toBe(true);
   });
 
   it('renders loading state while checking for updates', () => {
     expect(testTranslate('updateOs.checkUpdateResponseModal.checkingForOsUpdates')).toBe(
-      'Checking for OS updates...'
+      'Checking for updates'
     );
     checkForUpdatesLoading.value = true;
 
-    const wrapper = mountModal();
+    const wrapper = renderModal();
 
-    expect(wrapper.find('.responsive-modal-title').text()).toBe('Checking for OS updates...');
-    expect(wrapper.find('.brand-loading').exists()).toBe(true);
-    expect(wrapper.find('.ui-button').text()).toBe('More Options');
+    expect(wrapper.find(titleSelector).text()).toBe('Checking for updates');
+    expect(wrapper.find('[role="status"]').exists()).toBe(true);
+    expect(wrapper.find('[role="status"] .brand-loading').exists()).toBe(true);
+    expect(wrapper.findAll('button').some((button) => button.text() === 'More options')).toBe(true);
   });
 
+  it('shows a failed check with no stale release action', async () => {
+    available.value = '7.3.0';
+    updateOsResponse.value = { changelog: 'release' };
+    checkForUpdatesFailed.value = true;
+    const wrapper = renderModal();
+    expect(wrapper.text()).toContain('Unable to check for updates');
+    expect(wrapper.find('[role="alert"]').exists()).toBe(true);
+    expect(wrapper.text()).not.toContain('Review update');
+    if (embedded) {
+      await wrapper
+        .findAll('button')
+        .find((button) => button.text() === 'Retry')!
+        .trigger('click');
+      expect(mockLocalCheckForUpdate).toHaveBeenCalledTimes(1);
+    }
+  });
+
+  it('keeps the error and retry action available when retry fails', async () => {
+    checkForUpdatesFailed.value = true;
+    mockLocalCheckForUpdate.mockRejectedValueOnce(new Error('Offline'));
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    const wrapper = renderModal();
+    await wrapper
+      .findAll('button')
+      .find((button) => button.text() === 'Retry')!
+      .trigger('click');
+    await flushPromises();
+    expect(mockLocalCheckForUpdate).toHaveBeenCalledTimes(1);
+    expect(wrapper.find('[role="alert"]').exists()).toBe(true);
+    expect(wrapper.findAll('button').some((button) => button.text() === 'Retry')).toBe(true);
+  });
+
+  it.each([true, false])(
+    'shows the manual check result while drivers prepare, newer=%s',
+    async (newer) => {
+      if (!embedded) return;
+      rebootType.value = 'thirdPartyDriversDownloading';
+      rebootVersion.value = '7.3.0';
+      available.value = newer ? '7.3.0' : null;
+      const wrapper = renderModal();
+      expect(wrapper.find('[role="status"] p').exists()).toBe(false);
+      await wrapper
+        .findAll('button')
+        .find((button) => button.text() === 'Check for updates')!
+        .trigger('click');
+      await flushPromises();
+      expect(wrapper.find('[role="status"] p').text()).toContain(
+        newer ? '7.3.0' : testTranslate('updateOs.status.upToDate')
+      );
+    }
+  );
+
+  it.each(['update', 'downgrade', 'thirdPartyDriversDownloading'])(
+    'keeps %s actions inside the embedded card',
+    async (kind) => {
+      if (!embedded) return;
+      rebootType.value = kind;
+      rebootVersion.value = '7.3.0';
+      available.value = '7.3.0';
+      const wrapper = renderModal();
+      expect(wrapper.find('.card-wrapper').exists()).toBe(true);
+      expect(wrapper.text()).toContain(
+        kind === 'thirdPartyDriversDownloading' ? 'Preparing drivers' : 'Reboot required'
+      );
+      expect(wrapper.text()).toContain(kind === 'downgrade' ? 'Downgrading to' : 'Updating to');
+      expect(wrapper.text()).not.toContain('Available version');
+      expect(wrapper.find('[role="switch"]').exists()).toBe(false);
+      expect(wrapper.text()).not.toContain('Review update');
+      if (kind !== 'thirdPartyDriversDownloading') {
+        await wrapper
+          .findAll('button')
+          .find((button) => button.text() === 'Reboot now')!
+          .trigger('click');
+        expect(mockRebootServer).toHaveBeenCalledTimes(1);
+      } else {
+        expect(wrapper.text()).toContain('Check for updates');
+      }
+    }
+  );
+
   it('shows up-to-date messaging when no updates are available', async () => {
     osVersion.value = '6.12.3';
     updateOsNotificationsEnabled.value = false;
 
-    const wrapper = mountModal();
+    const wrapper = renderModal();
     await nextTick();
 
-    expect(wrapper.find('.responsive-modal-title').text()).toBe('Unraid OS is up-to-date');
+    expect(wrapper.find(titleSelector).text()).toBe('Up to date');
     expect(wrapper.text()).toContain('Current Version 6.12.3');
     expect(wrapper.text()).toContain(
       'Go to Settings > Notifications to enable automatic OS update notifications for future releases.'
     );
 
-    expect(wrapper.find('.ui-button').text()).toBe('More Options');
+    expect(wrapper.findAll('button').some((button) => button.text() === 'More options')).toBe(true);
     expect(wrapper.text()).toContain('Enable update notifications');
   });
 
@@ -221,33 +351,144 @@ describe('CheckUpdateResponseModal', () => {
     osVersion.value = '6.12.3';
     updateOsResponse.value = { changelog: '### New release' };
 
-    const wrapper = mountModal();
+    const wrapper = renderModal();
     await nextTick();
 
     const actionButtons = wrapper.findAll('.brand-button');
-    const viewChangelogButton = actionButtons.find((button) =>
-      button.text().includes('View Changelog to Start Update')
-    );
+    const viewChangelogButton = actionButtons.find((button) => button.text().includes('Review update'));
     expect(viewChangelogButton).toBeDefined();
 
     await viewChangelogButton!.trigger('click');
     expect(mockSetReleaseForUpdate).toHaveBeenCalledWith({ changelog: '### New release' });
   });
 
+  it('shares the current-to-target version summary in card and dialog layouts', async () => {
+    osVersion.value = '7.2.0';
+    available.value = '7.3.0';
+    const wrapper = renderModal();
+    expect(wrapper.findAll('dt').map((term) => term.text())).toEqual([
+      'Current version',
+      'Available version',
+    ]);
+    expect(wrapper.findAll('dd').map((value) => value.text())).toEqual(['7.2.0', '7.3.0']);
+    expect(wrapper.text().match(/7\.2\.0/g)).toHaveLength(1);
+    expect(wrapper.text().match(/7\.3\.0/g)).toHaveLength(1);
+    osVersion.value = null;
+    await nextTick();
+    expect(wrapper.findAll('dt').map((term) => term.text())).toEqual(['Available version']);
+    expect(wrapper.find('[aria-hidden="true"]').exists()).toBe(false);
+    checkForUpdatesLoading.value = true;
+    await nextTick();
+    expect(wrapper.find('dl').exists()).toBe(false);
+  });
+
   it('includes renew option when update requires license renewal', async () => {
     available.value = '6.14.0';
     availableWithRenewal.value = '6.14.0';
     updateOsResponse.value = { changelog: '### Renewal release' };
 
-    const wrapper = mountModal();
+    const wrapper = renderModal();
     await nextTick();
 
     const actionButtons = wrapper.findAll('.brand-button');
     const labels = actionButtons.map((button) => button.text());
-    expect(labels).toContain('View Changelog');
+    expect(labels).toContain('Review release notes');
     expect(labels).toContain('Extend License');
 
     await actionButtons.find((btn) => btn.text() === 'Extend License')?.trigger('click');
     expect(mockRenew).toHaveBeenCalled();
   });
+
+  it('keeps the selected container and content hidden when closed', () => {
+    const wrapper = mountModal(embedded, false);
+    if (embedded) {
+      expect(wrapper.find('.card-wrapper').exists()).toBe(false);
+      expect(wrapper.find('.responsive-modal').exists()).toBe(false);
+    } else {
+      expect(wrapper.findComponent({ name: 'ResponsiveModal' }).props('open')).toBe(false);
+    }
+  });
+
+  it('routes verification and more options through the account updater', async () => {
+    available.value = '7.3.0-beta.1';
+    availableRequiresAuth.value = true;
+    const wrapper = renderModal();
+    expect(wrapper.text()).toContain('7.3.0-beta.1');
+    await wrapper
+      .findAll('button')
+      .find((button) => button.text() === 'Verify to Update')!
+      .trigger('click');
+    expect(mockAccountUpdateOs).toHaveBeenCalledTimes(1);
+    expect(mockSetReleaseForUpdate).not.toHaveBeenCalled();
+    await wrapper
+      .findAll('button')
+      .find((button) => button.text() === 'More options')!
+      .trigger('click');
+    expect(mockAccountUpdateOs).toHaveBeenCalledTimes(2);
+  });
+
+  it('shows the release date and updates it after a new check', async () => {
+    available.value = '7.3.0';
+    availableReleaseDate.value = 1704067200;
+    const wrapper = renderModal();
+    expect(wrapper.text()).toContain('Released on 2024-01-01');
+    availableReleaseDate.value = 1704153600;
+    await nextTick();
+    expect(wrapper.text()).toContain('Released on 2024-01-02');
+  });
+
+  it.each([false, true])('shows license eligibility when expired=%s', async (expired) => {
+    availableWithRenewal.value = '7.3.0';
+    regUpdatesExpired.value = expired;
+    regExp.value = 1704067200;
+    const wrapper = renderModal();
+    expect(wrapper.text()).toContain('2024-01-01');
+    regExp.value = 1704153600;
+    await nextTick();
+    expect(wrapper.text()).toContain('2024-01-02');
+    expect(wrapper.text()).toContain('Extend License');
+  });
+
+  it('shows ignored releases and the notifications settings link', () => {
+    updateOsIgnoredReleases.value = ['7.2.0', '7.2.1'];
+    updateOsNotificationsEnabled.value = false;
+    const wrapper = renderModal();
+    expect(wrapper.findAll('.ignored-release')).toHaveLength(2);
+    expect(wrapper.text()).toContain('Ignored Releases');
+    expect(wrapper.find('[href="/Settings/Notifications"]').exists()).toBe(true);
+  });
+
+  it.each(['available', 'renewal'])(
+    'explains ignore and ignores the %s release only after close',
+    async (kind) => {
+      vi.useFakeTimers();
+      if (kind === 'renewal') availableWithRenewal.value = '7.3.0';
+      else available.value = '7.3.0';
+      const wrapper = renderModal();
+      await wrapper.find('[role="switch"]').trigger('click');
+      const tooltip = wrapper.findAll('.tooltip').find((item) => item.text().includes('Close'))!;
+      expect(tooltip.find('.tooltip-content').text()).toBe(
+        testTranslate('updateOs.checkUpdateResponseModal.youCanOptBackInTo')
+      );
+      expect(mockUpdateOsIgnoreRelease).not.toHaveBeenCalled();
+      await tooltip.find('button').trigger('click');
+      expect(mockSetModalOpen).toHaveBeenCalledWith(false);
+      expect(mockUpdateOsIgnoreRelease).not.toHaveBeenCalled();
+      await vi.advanceTimersByTimeAsync(500);
+      expect(mockUpdateOsIgnoreRelease).toHaveBeenCalledWith('7.3.0');
+    }
+  );
+
+  it('restores update actions when ignored releases are cleared', async () => {
+    available.value = '7.3.0';
+    updateOsResponse.value = { changelog: 'release' };
+    updateOsIgnoredReleases.value = ['7.2.0'];
+    const wrapper = renderModal();
+    await wrapper.find('[role="switch"]').trigger('click');
+    expect(wrapper.text()).toContain('Close');
+    updateOsIgnoredReleases.value = [];
+    await nextTick();
+    expect(wrapper.find('[role="switch"]').attributes('aria-checked')).toBe('false');
+    expect(wrapper.text()).toContain('Review update');
+  });
 });
diff --git a/web/__test__/components/Modals.test.ts b/web/__test__/components/Modals.test.ts
index 8ceab35d34..519127bec1 100644
--- a/web/__test__/components/Modals.test.ts
+++ b/web/__test__/components/Modals.test.ts
@@ -9,6 +9,7 @@ import type { Pinia } from 'pinia';
 
 import Modals from '~/components/Modals.standalone.vue';
 import { useCallbackActionsStore } from '~/store/callbackActions';
+import { useServerStore } from '~/store/server';
 import { useUpdateOsStore } from '~/store/updateOs';
 
 // Mock child components
@@ -70,6 +71,53 @@ describe('Modals.standalone.vue', () => {
     vi.clearAllMocks();
   });
 
+  it('leaves update and changelog rendering to the Tools page', async () => {
+    wrapper.unmount();
+    window.history.replaceState({}, '', '/Tools/Update');
+    try {
+      wrapper = mount(Modals, { global: { plugins: [pinia] } });
+      const update = useUpdateOsStore();
+      update.setModalOpen(true);
+      update.setReleaseForUpdate({
+        version: '7.3.0',
+        name: 'Unraid 7.3.0',
+        date: '2026-10-23',
+        isNewer: true,
+        isEligible: true,
+        changelog: null,
+        sha256: null,
+      });
+      await nextTick();
+      expect(wrapper.findComponent({ name: 'UpdateOsCheckUpdateResponseModal' }).exists()).toBe(false);
+      expect(wrapper.findComponent({ name: 'UpdateOsChangelogModal' }).exists()).toBe(false);
+      expect(wrapper.findComponent({ name: 'OnboardingModal' }).exists()).toBe(true);
+      expect(wrapper.findComponent({ name: 'UpcCallbackFeedback' }).exists()).toBe(true);
+    } finally {
+      window.history.replaceState({}, '', '/');
+    }
+  });
+
+  it('leaves driver-reboot responses and changelogs to the Tools card', async () => {
+    wrapper.unmount();
+    window.history.replaceState({}, '', '/Tools/Update');
+    try {
+      wrapper = mount(Modals, { global: { plugins: [pinia] } });
+      const server = useServerStore();
+      const update = useUpdateOsStore();
+      server.rebootType = 'thirdPartyDriversDownloading';
+      update.setModalOpen(true);
+      await nextTick();
+      expect(wrapper.findComponent({ name: 'UpdateOsCheckUpdateResponseModal' }).exists()).toBe(false);
+      expect(wrapper.findComponent({ name: 'UpdateOsChangelogModal' }).exists()).toBe(false);
+
+      server.rebootType = '';
+      await nextTick();
+      expect(wrapper.findComponent({ name: 'UpdateOsCheckUpdateResponseModal' }).exists()).toBe(false);
+    } finally {
+      window.history.replaceState({}, '', '/');
+    }
+  });
+
   it('should render modals container with correct id and ref', () => {
     const modalsDiv = wrapper.find('#modals');
     expect(modalsDiv.exists()).toBe(true);
diff --git a/web/__test__/components/RawChangelogRenderer.test.ts b/web/__test__/components/RawChangelogRenderer.test.ts
new file mode 100644
index 0000000000..2b13c5f74a
--- /dev/null
+++ b/web/__test__/components/RawChangelogRenderer.test.ts
@@ -0,0 +1,58 @@
+import { flushPromises, mount } from '@vue/test-utils';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import RawChangelogRenderer from '~/components/UpdateOs/RawChangelogRenderer.vue';
+import { createTestI18n, testTranslate } from '../utils/i18n';
+
+vi.mock('@unraid/ui', () => ({
+  BrandButton: { template: '<a><slot /></a>' },
+  BrandLoading: { template: '<svg aria-label="Unraid loader" />' },
+}));
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe('RawChangelogRenderer', () => {
+  it('leaves the loading state when no release-note content is returned', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockImplementation(async () => new Response(''))
+    );
+    const wrapper = mount(RawChangelogRenderer, {
+      props: { changelog: '/empty.md', version: '7.3.0' },
+      global: { plugins: [createTestI18n()] },
+    });
+    await flushPromises();
+    expect(wrapper.find('[role="status"]').exists()).toBe(false);
+    expect(wrapper.text()).toContain(
+      testTranslate('updateOs.rawChangelogRenderer.noChangelogContentAvailable')
+    );
+    wrapper.unmount();
+  });
+
+  it('shows the Unraid loader, then release sections without duplicating the modal title', async () => {
+    let finish: (response: Response) => void = () => {};
+    const pending = new Promise<Response>((resolve) => {
+      finish = resolve;
+    });
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockImplementation(() => pending.then((response) => response.clone()))
+    );
+    const wrapper = mount(RawChangelogRenderer, {
+      props: { changelog: '/release.md', version: '7.3.0', date: '2026-10-23' },
+      global: { plugins: [createTestI18n()] },
+    });
+    expect(wrapper.find('[role="status"]').text()).toBe('Loading release notes');
+    expect(wrapper.find('[aria-label="Unraid loader"]').exists()).toBe(true);
+
+    finish(new Response('# Unraid 7.3.0\n\n## Changes\n\n- Fixed an update issue.'));
+    await flushPromises();
+    expect(wrapper.find('[role="status"]').exists()).toBe(false);
+    expect(wrapper.find('h1').exists()).toBe(false);
+    expect(wrapper.find('h2').text()).toBe('Changes');
+    expect(wrapper.text()).toContain('2026-10-23');
+    expect(wrapper.text()).toContain('Fixed an update issue.');
+    wrapper.unmount();
+  });
+});
diff --git a/web/__test__/components/UpdateOs.test.ts b/web/__test__/components/UpdateOs.test.ts
index 83e15aa4ce..f0c45c7de1 100644
--- a/web/__test__/components/UpdateOs.test.ts
+++ b/web/__test__/components/UpdateOs.test.ts
@@ -3,26 +3,18 @@
  */
 
 import { nextTick, ref } from 'vue';
-import { mount } from '@vue/test-utils';
+import { enableAutoUnmount, flushPromises, mount } from '@vue/test-utils';
 
 import { createTestingPinia } from '@pinia/testing';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import UpdateOs from '~/components/UpdateOs.standalone.vue';
 import { createTestI18n } from '../utils/i18n';
 
+enableAutoUnmount(afterEach);
+
 vi.mock('@unraid/ui', () => ({
   PageContainer: { template: '<div><slot /></div>' },
-  BrandButton: {
-    template: '<button v-bind="$attrs" @click="$emit(\'click\')"><slot /></button>',
-  },
-}));
-
-const mockAccountStore = {
-  updateOs: vi.fn(),
-};
-vi.mock('~/store/account', () => ({
-  useAccountStore: () => mockAccountStore,
 }));
 
 const mockRebootType = ref('');
@@ -35,6 +27,17 @@ vi.mock('~/store/server', () => ({
   useServerStore: () => mockServerStore,
 }));
 
+const mockUpdateOsStore = {
+  available: undefined as string | undefined,
+  availableWithRenewal: undefined as string | undefined,
+  localCheckForUpdate: vi.fn().mockResolvedValue(undefined),
+  setModalOpen: vi.fn(),
+  updateOsModalVisible: false,
+};
+vi.mock('~/store/updateOs', () => ({
+  useUpdateOsStore: () => mockUpdateOsStore,
+}));
+
 // Mock window.location
 Object.defineProperty(window, 'location', {
   value: {
@@ -44,25 +47,31 @@ Object.defineProperty(window, 'location', {
   configurable: true,
 });
 
-vi.mock('~/helpers/urls', () => ({
-  WEBGUI_TOOLS_UPDATE: '/Tools/Update',
-}));
-
 const UpdateOsStatusStub = {
   template: '<div data-testid="update-os-status">Status</div>',
-  props: ['showUpdateCheck', 'title', 'subtitle', 't'],
+  props: ['title', 'subtitle', 't'],
 };
 const UpdateOsThirdPartyDriversStub = {
   template: '<div data-testid="third-party-drivers">Third Party</div>',
   props: ['t'],
 };
+const UpdateOsCheckUpdateResponseModalStub = {
+  template: '<div v-if="open" data-testid="update-os-check-response">Check Response</div>',
+  props: ['open', 'embedded'],
+};
+const UpdateOsChangelogModalStub = {
+  template: '<div data-testid="update-os-changelog">Changelog</div>',
+};
 
 describe('UpdateOs.standalone.vue', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockRebootType.value = '';
     mockSetRebootVersion.mockClear();
-    mockAccountStore.updateOs.mockClear();
+    mockUpdateOsStore.available = undefined;
+    mockUpdateOsStore.availableWithRenewal = undefined;
+    mockUpdateOsStore.localCheckForUpdate.mockResolvedValue(undefined);
+    mockUpdateOsStore.updateOsModalVisible = false;
     window.location.pathname = '/some/other/path';
   });
 
@@ -99,7 +108,30 @@ describe('UpdateOs.standalone.vue', () => {
   });
 
   describe('Initial Rendering and onBeforeMount Logic', () => {
-    it('shows account button and does not auto-redirect when path matches and rebootType is empty', async () => {
+    it.each(['', 'update', 'downgrade', 'thirdPartyDriversDownloading'])(
+      'uses only the card on Tools with reboot=%s',
+      async (reboot) => {
+        window.location.pathname = '/Tools/Update';
+        mockRebootType.value = reboot;
+        const wrapper = mount(UpdateOs, {
+          global: {
+            plugins: [createTestingPinia({ createSpy: vi.fn }), createTestI18n()],
+            stubs: {
+              UpdateOsStatus: UpdateOsStatusStub,
+              UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+              UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+              UpdateOsChangelogModal: UpdateOsChangelogModalStub,
+            },
+          },
+        });
+        await nextTick();
+        expect(wrapper.find('[data-testid="update-os-status"]').exists()).toBe(false);
+        expect(wrapper.find('[data-testid="third-party-drivers"]').exists()).toBe(false);
+        expect(wrapper.find('[data-testid="update-os-check-response"]').exists()).toBe(true);
+      }
+    );
+
+    it('checks for updates on the Tools page when no reboot is pending', async () => {
       window.location.pathname = '/Tools/Update';
       mockRebootType.value = '';
 
@@ -107,21 +139,21 @@ describe('UpdateOs.standalone.vue', () => {
         global: {
           plugins: [createTestingPinia({ createSpy: vi.fn }), createTestI18n()],
           stubs: {
-            // Rely on @unraid/ui mock for PageContainer & BrandButton
             UpdateOsStatus: UpdateOsStatusStub,
             UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+            UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+            UpdateOsChangelogModal: UpdateOsChangelogModalStub,
           },
         },
       });
 
       await nextTick();
 
-      expect(mockAccountStore.updateOs).not.toHaveBeenCalled();
-      expect(wrapper.find('[data-testid="update-os-account-button"]').exists()).toBe(true);
       expect(wrapper.find('[data-testid="update-os-status"]').exists()).toBe(false);
+      expect(mockUpdateOsStore.localCheckForUpdate).toHaveBeenCalledTimes(1);
     });
 
-    it('shows status and does not call updateOs when path does not match', async () => {
+    it('renders status without checking for updates on other pages', async () => {
       window.location.pathname = '/some/other/path';
       mockRebootType.value = '';
 
@@ -129,21 +161,22 @@ describe('UpdateOs.standalone.vue', () => {
         global: {
           plugins: [createTestingPinia({ createSpy: vi.fn }), createTestI18n()],
           stubs: {
-            // Rely on @unraid/ui mock for PageContainer & BrandLoading
             UpdateOsStatus: UpdateOsStatusStub,
             UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+            UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+            UpdateOsChangelogModal: UpdateOsChangelogModalStub,
           },
         },
       });
 
       await nextTick();
 
-      expect(mockAccountStore.updateOs).not.toHaveBeenCalled();
-      expect(wrapper.find('[data-testid="update-os-account-button"]').exists()).toBe(false);
       expect(wrapper.find('[data-testid="update-os-status"]').exists()).toBe(true);
+      expect(mockUpdateOsStore.localCheckForUpdate).not.toHaveBeenCalled();
+      expect(mockUpdateOsStore.setModalOpen).not.toHaveBeenCalled();
     });
 
-    it('shows status and does not call updateOs when rebootType is not empty', async () => {
+    it('renders status without checking for updates while a reboot is pending', async () => {
       window.location.pathname = '/Tools/Update';
       mockRebootType.value = 'downgrade';
 
@@ -151,39 +184,111 @@ describe('UpdateOs.standalone.vue', () => {
         global: {
           plugins: [createTestingPinia({ createSpy: vi.fn }), createTestI18n()],
           stubs: {
-            // Rely on @unraid/ui mock for PageContainer & BrandLoading
             UpdateOsStatus: UpdateOsStatusStub,
             UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+            UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+            UpdateOsChangelogModal: UpdateOsChangelogModalStub,
           },
         },
       });
 
       await nextTick();
 
-      expect(mockAccountStore.updateOs).not.toHaveBeenCalled();
-      expect(wrapper.find('[data-testid="update-os-account-button"]').exists()).toBe(false);
-      expect(wrapper.find('[data-testid="update-os-status"]').exists()).toBe(true);
+      expect(wrapper.find('[data-testid="update-os-status"]').exists()).toBe(false);
+      expect(mockUpdateOsStore.localCheckForUpdate).not.toHaveBeenCalled();
+      expect(mockUpdateOsStore.setModalOpen).not.toHaveBeenCalled();
     });
 
-    it('navigates to account update when the button is clicked', async () => {
+    it('opens the update modal when an update is already available', async () => {
       window.location.pathname = '/Tools/Update';
       mockRebootType.value = '';
+      mockUpdateOsStore.available = '6.12.5';
 
-      const wrapper = mount(UpdateOs, {
+      mount(UpdateOs, {
         global: {
           plugins: [createTestingPinia({ createSpy: vi.fn }), createTestI18n()],
           stubs: {
             UpdateOsStatus: UpdateOsStatusStub,
             UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+            UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+            UpdateOsChangelogModal: UpdateOsChangelogModalStub,
           },
         },
       });
 
       await nextTick();
 
-      await wrapper.find('[data-testid="update-os-account-button"]').trigger('click');
+      expect(mockUpdateOsStore.setModalOpen).toHaveBeenCalledWith(true);
+      expect(mockUpdateOsStore.localCheckForUpdate).not.toHaveBeenCalled();
+    });
+
+    it('opens the known renewal release without another check', async () => {
+      window.location.pathname = '/Tools/Update';
+      mockUpdateOsStore.availableWithRenewal = '7.3.0';
+      mount(UpdateOs, {
+        global: {
+          plugins: [createTestingPinia({ createSpy: vi.fn }), createTestI18n()],
+          stubs: {
+            UpdateOsStatus: UpdateOsStatusStub,
+            UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+            UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+            UpdateOsChangelogModal: UpdateOsChangelogModalStub,
+          },
+        },
+      });
+      await flushPromises();
+      expect(mockUpdateOsStore.setModalOpen).toHaveBeenCalledWith(true);
+      expect(mockUpdateOsStore.localCheckForUpdate).not.toHaveBeenCalled();
+    });
+
+    it('handles a rejected initial check without an unhandled rejection', async () => {
+      window.location.pathname = '/Tools/Update';
+      const error = new Error('update check unavailable');
+      mockUpdateOsStore.localCheckForUpdate.mockRejectedValueOnce(error);
+      const logged = vi.spyOn(console, 'error').mockImplementation(() => {});
+      try {
+        mount(UpdateOs, {
+          global: {
+            plugins: [createTestingPinia({ createSpy: vi.fn }), createTestI18n()],
+            stubs: {
+              UpdateOsStatus: UpdateOsStatusStub,
+              UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+              UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+              UpdateOsChangelogModal: UpdateOsChangelogModalStub,
+            },
+          },
+        });
+        await flushPromises();
+        expect(logged).toHaveBeenCalledWith(error);
+      } finally {
+        logged.mockRestore();
+      }
+    });
+
+    it('embeds the update response on the Tools update page', async () => {
+      window.location.pathname = '/Tools/Update';
+      mockRebootType.value = '';
+      mockUpdateOsStore.updateOsModalVisible = true;
+
+      const wrapper = mount(UpdateOs, {
+        global: {
+          plugins: [createTestingPinia({ createSpy: vi.fn }), createTestI18n()],
+          stubs: {
+            UpdateOsStatus: UpdateOsStatusStub,
+            UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+            UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+            UpdateOsChangelogModal: UpdateOsChangelogModalStub,
+          },
+        },
+      });
+
+      await nextTick();
 
-      expect(mockAccountStore.updateOs).toHaveBeenCalledWith(true);
+      const checkResponse = wrapper.findComponent(UpdateOsCheckUpdateResponseModalStub);
+      expect(checkResponse.exists()).toBe(true);
+      expect(checkResponse.props('embedded')).not.toBe(false);
+      expect(wrapper.find('[data-testid="update-os-check-response"]').exists()).toBe(true);
+      expect(wrapper.find('[data-testid="update-os-changelog"]').exists()).toBe(true);
     });
   });
 
@@ -196,6 +301,8 @@ describe('UpdateOs.standalone.vue', () => {
           stubs: {
             UpdateOsStatus: UpdateOsStatusStub,
             UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+            UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+            UpdateOsChangelogModal: UpdateOsChangelogModalStub,
           },
         },
       });
@@ -216,6 +323,8 @@ describe('UpdateOs.standalone.vue', () => {
           stubs: {
             UpdateOsStatus: UpdateOsStatusStub,
             UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+            UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+            UpdateOsChangelogModal: UpdateOsChangelogModalStub,
           },
         },
       });
@@ -233,6 +342,8 @@ describe('UpdateOs.standalone.vue', () => {
           stubs: {
             UpdateOsStatus: UpdateOsStatusStub,
             UpdateOsThirdPartyDrivers: UpdateOsThirdPartyDriversStub,
+            UpdateOsCheckUpdateResponseModal: UpdateOsCheckUpdateResponseModalStub,
+            UpdateOsChangelogModal: UpdateOsChangelogModalStub,
           },
         },
       });
diff --git a/web/__test__/components/UpdateOsStatus.test.ts b/web/__test__/components/UpdateOsStatus.test.ts
new file mode 100644
index 0000000000..2c09c0ff35
--- /dev/null
+++ b/web/__test__/components/UpdateOsStatus.test.ts
@@ -0,0 +1,130 @@
+import { defineStore } from 'pinia';
+import { enableAutoUnmount, mount } from '@vue/test-utils';
+
+import { createTestingPinia } from '@pinia/testing';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import UpdateOsStatus from '~/components/UpdateOs/Status.vue';
+import { createTestI18n } from '../utils/i18n';
+
+enableAutoUnmount(afterEach);
+
+vi.mock('@unraid/ui', () => ({
+  Badge: { template: '<span><slot /></span>' },
+  BrandLoading: { template: '<span />' },
+  Button: { template: '<button><slot /></button>' },
+}));
+
+const useServerStore = defineStore('server', {
+  state: () => ({
+    rebootType: '',
+    rebootVersion: '',
+    osVersion: '7.2.0',
+    dateTimeFormat: {},
+    regExp: 0,
+    regUpdatesExpired: false,
+  }),
+});
+const useUpdateOsStore = defineStore('updateOs', {
+  state: () => ({
+    available: undefined as string | undefined,
+    availableWithRenewal: undefined as string | undefined,
+    checkForUpdatesLoading: false,
+  }),
+  actions: { localCheckForUpdate: vi.fn(), setModalOpen: vi.fn(), cancelUpdate: vi.fn() },
+});
+const useUpdateOsActionsStore = defineStore('updateOsActions', {
+  state: () => ({ status: 'ready', ineligibleText: '', rebootTypeText: '' }),
+  actions: { viewReleaseNotes: vi.fn(), rebootServer: vi.fn() },
+});
+vi.mock('~/store/server', () => ({ useServerStore: () => useServerStore() }));
+vi.mock('~/store/updateOs', () => ({ useUpdateOsStore: () => useUpdateOsStore() }));
+vi.mock('~/store/updateOsActions', () => ({ useUpdateOsActionsStore: () => useUpdateOsActionsStore() }));
+vi.mock('~/store/account', () => ({
+  useAccountStore: () => ({ updateOs: vi.fn(), downgradeOs: vi.fn() }),
+}));
+
+const mountStatus = (props = {}) => {
+  const pinia = createTestingPinia({ createSpy: vi.fn });
+  const server = useServerStore(pinia);
+  server.rebootType = '';
+  server.osVersion = '7.2.0';
+  const update = useUpdateOsStore(pinia);
+  const actions = useUpdateOsActionsStore(pinia);
+  actions.status = 'ready';
+  const wrapper = mount(UpdateOsStatus, {
+    props,
+    global: { plugins: [pinia, createTestI18n()] },
+  });
+  return { wrapper, server, update, actions };
+};
+
+describe('Update OS status actions', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('checks for updates when no release is available', async () => {
+    const { wrapper, update } = mountStatus();
+    const check = wrapper.findAll('button').filter((button) => button.text() === 'Check for Update');
+    expect(check).toHaveLength(1);
+    await check[0].trigger('click');
+    expect(update.localCheckForUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it.each(['available', 'availableWithRenewal'] as const)(
+    'keeps refresh beside the %s action',
+    async (field) => {
+      const { wrapper, update } = mountStatus();
+      update[field] = '7.3.0';
+      await wrapper.vm.$nextTick();
+      const check = wrapper.findAll('button').find((button) => button.text() === 'Check for Update')!;
+      const release = wrapper.findAll('button').find((button) => button.text().includes('7.3.0'))!;
+      expect(check.exists()).toBe(true);
+      expect(release.exists()).toBe(true);
+      await release.trigger('click');
+      expect(update.setModalOpen).toHaveBeenCalledWith(true);
+      await check.trigger('click');
+      expect(update.localCheckForUpdate).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  it.each(['action', 'local'])(
+    'disables refresh and release actions during a %s check',
+    async (source) => {
+      const { wrapper, update, actions } = mountStatus();
+      update.available = '7.3.0';
+      if (source === 'action') actions.status = 'checking';
+      else update.checkForUpdatesLoading = true;
+      await wrapper.vm.$nextTick();
+      const buttons = wrapper
+        .findAll('button')
+        .filter((button) => button.text() === 'Check for Update' || button.text().includes('7.3.0'));
+      expect(buttons).toHaveLength(2);
+      for (const button of buttons) {
+        expect(button.attributes('disabled')).toBeDefined();
+        await button.trigger('click');
+      }
+      expect(update.localCheckForUpdate).not.toHaveBeenCalled();
+      expect(update.setModalOpen).not.toHaveBeenCalled();
+    }
+  );
+
+  it.each(['update', 'downgrade'] as const)(
+    'hides refresh while a %s reboot is pending',
+    async (rebootType) => {
+      const { wrapper, update, server } = mountStatus();
+      update.available = '7.3.0';
+      server.rebootType = rebootType;
+      await wrapper.vm.$nextTick();
+      expect(wrapper.findAll('button').some((button) => button.text() === 'Check for Update')).toBe(
+        false
+      );
+    }
+  );
+
+  it('hides refresh on the external downgrade flow', async () => {
+    const { wrapper, update } = mountStatus({ showExternalDowngrade: true });
+    update.available = '7.3.0';
+    await wrapper.vm.$nextTick();
+    expect(wrapper.findAll('button').some((button) => button.text() === 'Check for Update')).toBe(false);
+  });
+});
diff --git a/web/__test__/store/updateOs.test.ts b/web/__test__/store/updateOs.test.ts
index 80134313c4..195f67a0af 100644
--- a/web/__test__/store/updateOs.test.ts
+++ b/web/__test__/store/updateOs.test.ts
@@ -175,6 +175,10 @@ describe('UpdateOs Store', () => {
       );
 
       expect(WebguiCheckForUpdate).toHaveBeenCalled();
+      expect(store.checkForUpdatesLoading).toBe(false);
+      expect(store.checkForUpdatesFailed).toBe(true);
+      await store.localCheckForUpdate();
+      expect(store.checkForUpdatesFailed).toBe(false);
     });
 
     it('should successfully cancel an update', async () => {
diff --git a/web/__test__/store/updateOs.transport.test.ts b/web/__test__/store/updateOs.transport.test.ts
new file mode 100644
index 0000000000..44d7d7715c
--- /dev/null
+++ b/web/__test__/store/updateOs.transport.test.ts
@@ -0,0 +1,108 @@
+import { createPinia, setActivePinia } from 'pinia';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { useUpdateOsStore } from '~/store/updateOs';
+
+const { setUpdateOsResponse } = vi.hoisted(() => ({ setUpdateOsResponse: vi.fn() }));
+
+vi.mock('~/store/callbackActions', () => ({
+  useCallbackActionsStore: () => ({ send: vi.fn() }),
+}));
+
+vi.mock('~/store/server', () => ({
+  useServerStore: () => ({
+    regExp: '',
+    regUpdatesExpired: false,
+    updateOsIgnoredReleases: [],
+    updateOsResponse: { version: '7.3.4', isNewer: true },
+    setUpdateOsResponse,
+  }),
+}));
+
+const updateResponse = (isNewer = true) => ({ version: '7.3.4', isNewer, isEligible: true });
+const jsonResponse = (data: unknown) =>
+  new Response(JSON.stringify(data), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+describe('OS update check transport', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+    vi.clearAllMocks();
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'debug').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it('preserves the last result on network failure and recovers on retry', async () => {
+    const fetch = vi
+      .fn()
+      .mockRejectedValueOnce(new TypeError('Failed to fetch'))
+      .mockResolvedValueOnce(jsonResponse(updateResponse()));
+    vi.stubGlobal('fetch', fetch);
+    const store = useUpdateOsStore();
+
+    await expect(store.localCheckForUpdate()).rejects.toThrow();
+    expect(store.checkForUpdatesFailed).toBe(true);
+    expect(store.checkForUpdatesLoading).toBe(false);
+    expect(store.available).toBe('7.3.4');
+    expect(setUpdateOsResponse).not.toHaveBeenCalled();
+
+    await store.localCheckForUpdate();
+    expect(store.checkForUpdatesFailed).toBe(false);
+    expect(store.checkForUpdatesLoading).toBe(false);
+    expect(setUpdateOsResponse).toHaveBeenCalledWith(updateResponse());
+  });
+
+  it.each([
+    undefined,
+    null,
+    42,
+    {},
+    { error: 'Upstream unavailable' },
+    { version: '7.3.4' },
+    { version: '', isNewer: false },
+    { version: '7.3.4', isNewer: 'false' },
+  ])('rejects an invalid native result: %j', async (result) => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(jsonResponse(result)));
+    const store = useUpdateOsStore();
+
+    await expect(store.localCheckForUpdate()).rejects.toThrow();
+    expect(store.checkForUpdatesFailed).toBe(true);
+    expect(store.checkForUpdatesLoading).toBe(false);
+    expect(setUpdateOsResponse).not.toHaveBeenCalled();
+  });
+
+  it('rejects an HTTP failure instead of clearing the last release', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValue(
+        new Response(JSON.stringify({ error: 'Unavailable' }), {
+          status: 503,
+          headers: { 'Content-Type': 'application/json' },
+        })
+      )
+    );
+    const store = useUpdateOsStore();
+
+    await expect(store.localCheckForUpdate()).rejects.toThrow();
+    expect(store.checkForUpdatesFailed).toBe(true);
+    expect(store.checkForUpdatesLoading).toBe(false);
+    expect(setUpdateOsResponse).not.toHaveBeenCalled();
+  });
+
+  it('accepts a successful native result with no newer release', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(jsonResponse(updateResponse(false))));
+    const store = useUpdateOsStore();
+
+    await store.localCheckForUpdate();
+    expect(store.checkForUpdatesFailed).toBe(false);
+    expect(setUpdateOsResponse).toHaveBeenCalledWith(updateResponse(false));
+  });
+});
diff --git a/web/src/components/Modals.standalone.vue b/web/src/components/Modals.standalone.vue
index 5d13abe84f..9d6b70cf5f 100644
--- a/web/src/components/Modals.standalone.vue
+++ b/web/src/components/Modals.standalone.vue
@@ -1,6 +1,8 @@
 <script setup lang="ts">
 import { computed } from 'vue';
 
+import { WEBGUI_TOOLS_UPDATE } from '~/helpers/urls';
+
 import OnboardingModal from '~/components/Onboarding/OnboardingModal.vue';
 import UpdateOsChangelogModal from '~/components/UpdateOs/ChangelogModal.vue';
 import UpdateOsCheckUpdateResponseModal from '~/components/UpdateOs/CheckUpdateResponseModal.vue';
@@ -13,6 +15,10 @@ import { useUpdateOsStore } from '~/store/updateOs';
 const callbackStore = useCallbackActionsStore();
 const updateOsStore = useUpdateOsStore();
 
+const isToolsUpdatePage = computed(
+  () => typeof window !== 'undefined' && window.location.pathname === WEBGUI_TOOLS_UPDATE
+);
+
 const callbackStatus = computed(() => callbackStore.callbackStatus);
 const updateOsModalVisible = computed(() => updateOsStore.updateOsModalVisible);
 const changelogModalVisible = computed(() => updateOsStore.changelogModalVisible);
@@ -21,8 +27,8 @@ const changelogModalVisible = computed(() => updateOsStore.changelogModalVisible
 <template>
   <div id="modals" ref="modals" class="relative z-[999999]">
     <UpcCallbackFeedback :open="callbackStatus !== 'ready'" />
-    <UpdateOsCheckUpdateResponseModal :open="updateOsModalVisible" />
-    <UpdateOsChangelogModal :open="changelogModalVisible" />
+    <UpdateOsCheckUpdateResponseModal v-if="!isToolsUpdatePage" :open="updateOsModalVisible" />
+    <UpdateOsChangelogModal v-if="!isToolsUpdatePage" :open="changelogModalVisible" />
     <OnboardingModal />
   </div>
 </template>
diff --git a/web/src/components/UpdateOs.standalone.vue b/web/src/components/UpdateOs.standalone.vue
index 7fd17ab354..0ffd0eb4b3 100644
--- a/web/src/components/UpdateOs.standalone.vue
+++ b/web/src/components/UpdateOs.standalone.vue
@@ -15,18 +15,19 @@ else
   echo "Third party plugins found - PLEASE CHECK YOUR UNRAID NOTIFICATIONS AND WAIT FOR THE MESSAGE THAT IT IS SAFE TO REBOOT!"
 fi
  */
-import { computed, onBeforeMount } from 'vue';
+import { computed, onBeforeMount, onMounted } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { storeToRefs } from 'pinia';
 
-import { ArrowTopRightOnSquareIcon } from '@heroicons/vue/24/solid';
-import { BrandButton, PageContainer } from '@unraid/ui';
+import { PageContainer } from '@unraid/ui';
 import { WEBGUI_TOOLS_UPDATE } from '~/helpers/urls';
 
+import UpdateOsChangelogModal from '~/components/UpdateOs/ChangelogModal.vue';
+import UpdateOsCheckUpdateResponseModal from '~/components/UpdateOs/CheckUpdateResponseModal.vue';
 import UpdateOsStatus from '~/components/UpdateOs/Status.vue';
 import UpdateOsThirdPartyDrivers from '~/components/UpdateOs/ThirdPartyDrivers.vue';
-import { useAccountStore } from '~/store/account';
 import { useServerStore } from '~/store/server';
+import { useUpdateOsStore } from '~/store/updateOs';
 
 const { t } = useI18n();
 
@@ -37,10 +38,14 @@ const props = withDefaults(defineProps<Props>(), {
   rebootVersion: '',
 });
 
-const accountStore = useAccountStore();
 const serverStore = useServerStore();
+const updateOsStore = useUpdateOsStore();
 const { rebootType } = storeToRefs(serverStore);
 
+const isToolsUpdatePage = computed(
+  () => typeof window !== 'undefined' && window.location.pathname === WEBGUI_TOOLS_UPDATE
+);
+
 const subtitle = computed(() => {
   if (rebootType.value === 'downgrade') {
     return t('updateOs.pleaseFinishTheInitiatedDowngradeTo');
@@ -48,48 +53,41 @@ const subtitle = computed(() => {
   return '';
 });
 
-// Show a prompt to continue in the Account app when no reboot is pending.
-const showRedirectPrompt = computed(
-  () =>
-    typeof window !== 'undefined' &&
-    window.location.pathname === WEBGUI_TOOLS_UPDATE &&
-    rebootType.value === ''
-);
-
-const openAccountUpdate = () => {
-  accountStore.updateOs(true);
-};
-
 onBeforeMount(() => {
   serverStore.setRebootVersion(props.rebootVersion);
 });
+
+onMounted(() => {
+  if (
+    typeof window === 'undefined' ||
+    window.location.pathname !== WEBGUI_TOOLS_UPDATE ||
+    rebootType.value !== ''
+  ) {
+    return;
+  }
+
+  if (updateOsStore.available || updateOsStore.availableWithRenewal) {
+    updateOsStore.setModalOpen(true);
+    return;
+  }
+
+  void updateOsStore.localCheckForUpdate().catch((error: unknown) => {
+    console.error(error);
+  });
+});
 </script>
 
 <template>
   <PageContainer>
-    <div
-      v-if="showRedirectPrompt"
-      class="mx-auto flex max-w-[720px] flex-col items-center gap-4 py-8 text-center"
-    >
-      <h1 class="text-2xl font-semibold">{{ t('updateOs.updateUnraidOs') }}</h1>
-      <p class="text-base leading-relaxed opacity-75">
-        {{ t('updateOs.update.receiveTheLatestAndGreatestFor') }}
-      </p>
-      <BrandButton
-        data-testid="update-os-account-button"
-        :icon-right="ArrowTopRightOnSquareIcon"
-        @click="openAccountUpdate"
-      >
-        {{ t('updateOs.update.viewAvailableUpdates') }}
-      </BrandButton>
-    </div>
-    <div v-else>
-      <UpdateOsStatus
-        :show-update-check="true"
-        :title="t('updateOs.updateUnraidOs')"
-        :subtitle="subtitle"
-      />
-      <UpdateOsThirdPartyDrivers v-if="rebootType === 'thirdPartyDriversDownloading'" />
-    </div>
+    <UpdateOsStatus
+      v-if="!isToolsUpdatePage"
+      :title="t('updateOs.updateUnraidOs')"
+      :subtitle="subtitle"
+    />
+    <UpdateOsCheckUpdateResponseModal v-if="isToolsUpdatePage" :open="true" embedded />
+    <UpdateOsChangelogModal v-if="isToolsUpdatePage" />
+    <UpdateOsThirdPartyDrivers
+      v-if="!isToolsUpdatePage && rebootType === 'thirdPartyDriversDownloading'"
+    />
   </PageContainer>
 </template>
diff --git a/web/src/components/UpdateOs/ChangelogModal.vue b/web/src/components/UpdateOs/ChangelogModal.vue
index daef6f203b..645b51b5e2 100644
--- a/web/src/components/UpdateOs/ChangelogModal.vue
+++ b/web/src/components/UpdateOs/ChangelogModal.vue
@@ -143,18 +143,19 @@ const showRawChangelog = computed<boolean>(() => {
     :open="modalVisible"
     sheet-side="bottom"
     sheet-padding="none"
-    :dialog-class="'max-w-[80rem] p-0'"
+    :dialog-class="'max-h-[90dvh] max-w-[80rem] p-0'"
+    sheet-class="h-full gap-6"
     :show-close-button="true"
     @update:open="(value: boolean) => !value && handleClose()"
   >
-    <ResponsiveModalHeader>
-      <ResponsiveModalTitle>
+    <ResponsiveModalHeader class="pr-16 text-left!">
+      <ResponsiveModalTitle class="text-xl font-semibold">
         {{ t('updateOs.changelogModal.unraidOsChangelog', [currentRelease.version]) }}
       </ResponsiveModalTitle>
     </ResponsiveModalHeader>
 
-    <div class="flex-1 px-3">
-      <div class="flex flex-col gap-4 sm:min-w-[40rem]">
+    <div class="min-h-0 flex-1 overflow-y-auto px-6">
+      <div class="flex min-w-0 flex-col gap-4">
         <!-- iframe for changelog if available -->
         <div v-if="iframeSrc" class="h-[calc(100vh-15rem)] w-full overflow-hidden sm:h-[45rem]">
           <iframe
@@ -180,16 +181,19 @@ const showRawChangelog = computed<boolean>(() => {
         <!-- Loading state -->
         <div
           v-else
-          class="flex min-h-[25rem] w-full flex-col justify-center text-center sm:min-w-[40rem]"
+          role="status"
+          class="flex min-h-32 w-full flex-col items-center justify-center gap-3 text-center"
         >
-          <BrandLoading class="mx-auto mt-6 w-[15rem]" />
-          <p>{{ t('updateOs.changelogModal.loadingChangelog') }}</p>
+          <BrandLoading aria-hidden="true" class="mx-auto w-24" />
+          <p class="text-muted-foreground text-sm">
+            {{ t('updateOs.changelogModal.loadingChangelog') }}
+          </p>
         </div>
       </div>
     </div>
 
-    <ResponsiveModalFooter>
-      <div :class="cn('flex w-full flex-wrap justify-between gap-3 md:gap-4')">
+    <ResponsiveModalFooter class="px-6 pb-6">
+      <div :class="cn('xs:!flex-row flex w-full flex-col justify-between gap-3')">
         <div :class="cn('flex flex-wrap justify-start gap-3 md:gap-4')">
           <!-- View on docs button -->
           <BrandButton
diff --git a/web/src/components/UpdateOs/CheckUpdateResponseModal.vue b/web/src/components/UpdateOs/CheckUpdateResponseModal.vue
index c4719571d6..a04d39e9b2 100644
--- a/web/src/components/UpdateOs/CheckUpdateResponseModal.vue
+++ b/web/src/components/UpdateOs/CheckUpdateResponseModal.vue
@@ -3,19 +3,22 @@ import { computed, onBeforeMount, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { storeToRefs } from 'pinia';
 
-import { ArrowDownTrayIcon } from '@heroicons/vue/24/outline';
+import { ArrowLongRightIcon, XMarkIcon } from '@heroicons/vue/24/outline';
 import {
+  ArrowPathIcon,
   ArrowTopRightOnSquareIcon,
   CheckCircleIcon,
   CogIcon,
   EyeIcon,
   IdentificationIcon,
   KeyIcon,
+  XCircleIcon,
 } from '@heroicons/vue/24/solid';
 import {
   BrandButton,
   BrandLoading,
   Button,
+  CardWrapper,
   cn,
   DialogDescription,
   Label,
@@ -38,12 +41,15 @@ import { useAccountStore } from '~/store/account';
 import { usePurchaseStore } from '~/store/purchase';
 import { useServerStore } from '~/store/server';
 import { useUpdateOsStore } from '~/store/updateOs';
+import { useUpdateOsActionsStore } from '~/store/updateOsActions';
 
 export interface Props {
+  embedded?: boolean;
   open?: boolean;
 }
 
-withDefaults(defineProps<Props>(), {
+const props = withDefaults(defineProps<Props>(), {
+  embedded: false,
   open: false,
 });
 const { t } = useI18n();
@@ -52,6 +58,7 @@ const accountStore = useAccountStore();
 const purchaseStore = usePurchaseStore();
 const serverStore = useServerStore();
 const updateOsStore = useUpdateOsStore();
+const updateOsActionsStore = useUpdateOsActionsStore();
 
 const {
   regExp,
@@ -61,6 +68,8 @@ const {
   updateOsIgnoredReleases,
   updateOsNotificationsEnabled,
   updateOsResponse,
+  rebootType,
+  rebootVersion,
 } = storeToRefs(serverStore);
 const {
   available,
@@ -68,7 +77,32 @@ const {
   availableReleaseDate,
   availableRequiresAuth,
   checkForUpdatesLoading,
+  checkForUpdatesFailed,
 } = storeToRefs(updateOsStore);
+const pendingReboot = computed(() => props.embedded && !!rebootType.value);
+const waitingForDrivers = computed(() => rebootType.value === 'thirdPartyDriversDownloading');
+const targetVersion = computed(() =>
+  pendingReboot.value ? rebootVersion.value : availableWithRenewal.value || available.value
+);
+const targetVersionLabel = computed(() => {
+  if (!pendingReboot.value) return t('updateOs.checkUpdateResponseModal.availableVersionLabel');
+  return rebootType.value === 'downgrade'
+    ? t('updateOs.checkUpdateResponseModal.downgradingTo')
+    : t('updateOs.checkUpdateResponseModal.updatingTo');
+});
+const showVersionTransition = computed(
+  () => !checkForUpdatesLoading.value && !checkForUpdatesFailed.value && !!targetVersion.value
+);
+const checkedWhileWaiting = ref(false);
+const checkForUpdates = async () => {
+  checkedWhileWaiting.value = false;
+  try {
+    await updateOsStore.localCheckForUpdate();
+    checkedWhileWaiting.value = true;
+  } catch (error) {
+    console.error(error);
+  }
+};
 
 /**
  * regExp may not have a value until we get a response from the refreshServerState action
@@ -116,6 +150,24 @@ const modalCopy = computed((): ModalCopy | null => {
     };
   }
 
+  if (checkForUpdatesFailed.value) {
+    return {
+      title: t('updateOs.checkUpdateResponseModal.checkFailed'),
+      description: t('updateOs.checkUpdateResponseModal.checkFailedDescription'),
+    };
+  }
+
+  if (pendingReboot.value) {
+    return {
+      title: waitingForDrivers.value
+        ? t('updateOs.checkUpdateResponseModal.preparingDrivers')
+        : t('updateOs.checkUpdateResponseModal.rebootRequired'),
+      description: waitingForDrivers.value
+        ? t('updateOs.thirdPartyDrivers.duringTheUnraidOsUpdateProcess')
+        : undefined,
+    };
+  }
+
   if (availableWithRenewal.value) {
     const description = regUpdatesExpired.value
       ? `${t('registration.updateExpirationAction.eligibleForUpdatesReleasedOnOr', [formattedRegExp.value])} ${t('registration.updateExpirationAction.extendYourLicenseToAccessThe')}`
@@ -123,12 +175,12 @@ const modalCopy = computed((): ModalCopy | null => {
           formattedRegExp.value,
         ]);
     return {
-      title: t('headerOsVersion.updateAvailable2'),
+      title: t('updateOs.checkUpdateResponseModal.updateAvailable'),
       description: description,
     };
   } else if (available.value) {
     return {
-      title: t('headerOsVersion.updateAvailable2'),
+      title: t('updateOs.checkUpdateResponseModal.updateAvailable'),
       description: undefined,
     };
   } else if (!available.value && !availableWithRenewal.value) {
@@ -160,6 +212,26 @@ const extraLinks = computed((): BrandButtonProps[] => {
 });
 
 const actionButtons = computed((): BrandButtonProps[] => {
+  if (checkForUpdatesLoading.value) return [];
+  if (checkForUpdatesFailed.value)
+    return [
+      {
+        click: checkForUpdates,
+        icon: ArrowPathIcon,
+        text: t('common.retry'),
+      },
+    ];
+  if (pendingReboot.value) {
+    return waitingForDrivers.value
+      ? []
+      : [
+          {
+            click: () => updateOsActionsStore.rebootServer(),
+            icon: ArrowPathIcon,
+            text: t('updateOs.checkUpdateResponseModal.rebootNow'),
+          },
+        ];
+  }
   // If ignoring release, show close button as primary action
   if (ignoreThisRelease.value && (available.value || availableWithRenewal.value)) {
     return [
@@ -196,7 +268,7 @@ const actionButtons = computed((): BrandButtonProps[] => {
       click: async () => await updateOsStore.setReleaseForUpdate(updateOsResponse.value ?? null),
       icon: EyeIcon,
       text: availableWithRenewal.value
-        ? t('updateOs.updateIneligible.viewChangelog')
+        ? t('updateOs.checkUpdateResponseModal.reviewReleaseNotes')
         : t('updateOs.checkUpdateResponseModal.viewChangelogToStartUpdate'),
     });
   }
@@ -217,7 +289,13 @@ const actionButtons = computed((): BrandButtonProps[] => {
 });
 
 const showNoUpdateContent = computed(() => {
-  return !checkForUpdatesLoading.value && !available.value && !availableWithRenewal.value;
+  return (
+    !pendingReboot.value &&
+    !checkForUpdatesFailed.value &&
+    !checkForUpdatesLoading.value &&
+    !available.value &&
+    !availableWithRenewal.value
+  );
 });
 
 const close = () => {
@@ -235,6 +313,8 @@ const renderMainSlot = computed(() => {
   return (
     !!(
       checkForUpdatesLoading.value ||
+      checkForUpdatesFailed.value ||
+      pendingReboot.value ||
       available.value ||
       availableWithRenewal.value ||
       extraLinks.value?.length > 0 ||
@@ -281,183 +361,251 @@ const modalWidth = computed(() => {
 </script>
 
 <template>
-  <ResponsiveModal
-    :open="open"
-    :dialog-class="modalWidth"
-    :sheet-class="'h-full'"
-    :show-close-button="!checkForUpdatesLoading"
-    @update:open="(value) => !value && close()"
+  <component
+    :is="embedded ? CardWrapper : ResponsiveModal"
+    v-if="!embedded || open"
+    v-bind="
+      embedded
+        ? { increasedPadding: true, class: '@container gap-6' }
+        : {
+            open,
+            dialogClass: cn(modalWidth, 'max-h-[90dvh] p-0'),
+            sheetClass: 'h-full gap-6',
+          }
+    "
+    @update:open="(value: boolean) => !value && close()"
   >
-    <div class="flex h-full flex-col">
-      <ResponsiveModalHeader v-if="modalCopy?.title">
-        <ResponsiveModalTitle>
-          {{ modalCopy.title }}
-        </ResponsiveModalTitle>
-        <DialogDescription v-if="modalCopy?.description">
-          <span v-html="modalCopy.description" />
-        </DialogDescription>
-      </ResponsiveModalHeader>
-
-      <div v-if="renderMainSlot" class="flex flex-1 flex-col gap-6 overflow-y-auto px-6">
-        <BrandLoading v-if="checkForUpdatesLoading" class="mx-auto w-[150px]" />
-        <div v-else class="flex flex-col gap-y-6">
-          <!-- OS Update highlight section -->
-          <div v-if="available || availableWithRenewal" class="flex flex-col items-center gap-4 py-4">
-            <div class="bg-primary/10 flex items-center justify-center rounded-full p-4">
-              <ArrowDownTrayIcon class="text-primary h-8 w-8" />
-            </div>
-            <div class="text-center">
-              <h2 class="text-foreground text-3xl font-bold">
-                {{ availableWithRenewal || available }}
-              </h2>
-              <p v-if="userFormattedReleaseDate" class="text-muted-foreground mt-2 text-center text-sm">
-                Released on {{ userFormattedReleaseDate }}
-              </p>
-              <p
-                v-if="availableRequiresAuth && !availableWithRenewal"
-                class="mt-2 text-center text-sm text-amber-500"
-              >
-                {{ t('updateOs.checkUpdateResponseModal.requiresVerificationToUpdate') }}
-              </p>
-            </div>
-            <div class="mt-4">
-              <div
-                class="hover:bg-muted/50 flex cursor-pointer items-center gap-3 rounded-lg p-2 transition-colors"
-                @click="ignoreThisRelease = !ignoreThisRelease"
-              >
-                <Switch v-model="ignoreThisRelease" @click.stop />
-                <Label class="text-muted-foreground cursor-pointer text-sm">
-                  {{ t('updateOs.checkUpdateResponseModal.ignoreThisReleaseUntilNextReboot') }}
-                </Label>
-              </div>
-            </div>
+    <component
+      :is="embedded ? 'div' : ResponsiveModalHeader"
+      v-if="modalCopy?.title"
+      :class="embedded ? 'grid gap-y-2' : 'pr-16 text-left!'"
+    >
+      <component :is="embedded ? 'h2' : ResponsiveModalTitle" class="text-xl font-semibold">
+        {{ modalCopy.title }}
+      </component>
+      <component
+        :is="embedded ? 'p' : DialogDescription"
+        v-if="modalCopy?.description"
+        :class="embedded ? 'text-muted-foreground text-sm' : undefined"
+      >
+        <span v-html="modalCopy.description" />
+      </component>
+    </component>
+
+    <div
+      v-if="renderMainSlot"
+      :class="cn('flex min-h-0 flex-1 flex-col gap-6 overflow-y-auto', !embedded && 'px-6')"
+    >
+      <div
+        v-if="showVersionTransition"
+        class="mx-auto flex w-full flex-col items-center gap-2 text-center"
+      >
+        <dl v-if="osVersion" class="flex! items-baseline justify-center gap-2 p-0! text-sm">
+          <dt class="text-muted-foreground text-left! text-sm font-normal!">
+            {{ t('updateOs.checkUpdateResponseModal.currentVersionLabel') }}
+          </dt>
+          <dd class="text-muted-foreground m-0! font-medium break-all">{{ osVersion }}</dd>
+        </dl>
+        <ArrowLongRightIcon
+          v-if="osVersion"
+          aria-hidden="true"
+          class="text-muted-foreground h-4 w-4 shrink-0 rotate-90"
+        />
+        <dl class="block! p-0! text-center">
+          <dt class="text-muted-foreground text-center! text-sm font-normal!">
+            {{ targetVersionLabel }}
+          </dt>
+          <dd class="text-foreground mt-1 block! text-3xl font-bold break-all">{{ targetVersion }}</dd>
+        </dl>
+      </div>
+      <div v-if="checkForUpdatesLoading" role="status" class="flex min-h-32 items-center justify-center">
+        <BrandLoading aria-hidden="true" class="mx-auto w-24" />
+        <span class="sr-only">{{ modalCopy?.title }}</span>
+      </div>
+      <div v-else-if="checkForUpdatesFailed" role="alert" class="flex justify-center py-6">
+        <span class="sr-only">{{ modalCopy?.title }}. {{ modalCopy?.description }}</span>
+        <XCircleIcon class="text-destructive h-12 w-12" />
+      </div>
+      <template v-else-if="pendingReboot">
+        <div v-if="waitingForDrivers" role="status" class="flex flex-col items-center gap-3">
+          <BrandLoading aria-hidden="true" class="mx-auto w-24" />
+          <span class="sr-only">{{ modalCopy?.title }}</span>
+          <p v-if="checkedWhileWaiting" class="text-muted-foreground text-sm">
+            {{
+              available || availableWithRenewal
+                ? t('updateOs.status.unraidAvailable', [available || availableWithRenewal])
+                : t('updateOs.status.upToDate')
+            }}
+          </p>
+        </div>
+      </template>
+      <div v-else class="flex flex-col gap-y-6">
+        <div v-if="available || availableWithRenewal" class="flex flex-col items-center gap-3">
+          <div class="text-center">
+            <p v-if="userFormattedReleaseDate" class="text-muted-foreground mt-2 text-center text-sm">
+              Released on {{ userFormattedReleaseDate }}
+            </p>
+            <p
+              v-if="availableRequiresAuth && !availableWithRenewal"
+              class="mt-2 text-center text-sm text-amber-500"
+            >
+              {{ t('updateOs.checkUpdateResponseModal.requiresVerificationToUpdate') }}
+            </p>
           </div>
-
-          <div v-if="showNoUpdateContent" class="flex flex-col items-center gap-4 py-6 text-center">
-            <div class="bg-primary/10 flex items-center justify-center rounded-full p-4">
-              <CheckCircleIcon class="text-primary h-10 w-10" />
-            </div>
-            <div class="space-y-2">
-              <p v-if="osVersion" class="text-muted-foreground text-center text-sm font-semibold">
-                {{ t('updateOs.checkUpdateResponseModal.currentVersion', [osVersion]) }}
-              </p>
-              <p
-                v-if="modalCopy?.description"
-                class="text-muted-foreground text-xs sm:text-sm"
-                v-html="modalCopy.description"
-              />
+          <div>
+            <div
+              class="hover:bg-muted/50 flex cursor-pointer items-center gap-3 rounded-lg p-2 transition-colors"
+              @click="ignoreThisRelease = !ignoreThisRelease"
+            >
+              <Switch v-model="ignoreThisRelease" @click.stop />
+              <Label class="text-muted-foreground cursor-pointer text-sm">
+                {{ t('updateOs.checkUpdateResponseModal.ignoreThisReleaseUntilNextReboot') }}
+              </Label>
             </div>
           </div>
+        </div>
 
-          <div
-            v-if="extraLinks.length > 0"
-            :class="cn('xs:!flex-row flex flex-col justify-center gap-2')"
-          >
-            <BrandButton
-              v-for="item in extraLinks"
-              :key="item.text"
-              :variant="item.variant ?? undefined"
-              :href="item.href ?? undefined"
-              :icon="item.icon"
-              :icon-right="item.iconRight"
-              :icon-right-hover-display="item.iconRightHoverDisplay"
-              :text="t(item.text ?? '')"
-              :title="item.title ? t(item.title) : undefined"
-              @click="item.click?.()"
-            />
+        <div v-if="showNoUpdateContent" class="flex flex-col items-center gap-4 py-6 text-center">
+          <div class="bg-primary/10 flex items-center justify-center rounded-full p-4">
+            <CheckCircleIcon class="text-primary h-10 w-10" />
           </div>
-
-          <div
-            v-if="updateOsIgnoredReleases.length > 0 && !(available || availableWithRenewal)"
-            class="mx-auto flex w-full max-w-[640px] flex-col gap-2"
-          >
-            <h3 class="text-left text-base font-semibold italic">
-              {{ t('updateOs.checkUpdateResponseModal.ignoredReleases') }}
-            </h3>
-            <UpdateOsIgnoredRelease
-              v-for="ignoredRelease in updateOsIgnoredReleases"
-              :key="ignoredRelease"
-              :label="ignoredRelease"
-              :t="t"
-            />
+          <div class="space-y-2">
+            <p v-if="osVersion" class="text-muted-foreground text-center text-sm font-semibold">
+              {{ t('updateOs.checkUpdateResponseModal.currentVersion', [osVersion]) }}
+            </p>
           </div>
         </div>
+
+        <div v-if="extraLinks.length > 0" :class="cn('xs:!flex-row flex flex-col justify-center gap-2')">
+          <BrandButton
+            v-for="item in extraLinks"
+            :key="item.text"
+            :variant="item.variant ?? undefined"
+            :href="item.href ?? undefined"
+            :icon="item.icon"
+            :icon-right="item.iconRight"
+            :icon-right-hover-display="item.iconRightHoverDisplay"
+            :text="t(item.text ?? '')"
+            :title="item.title ? t(item.title) : undefined"
+            @click="item.click?.()"
+          />
+        </div>
+
+        <div
+          v-if="updateOsIgnoredReleases.length > 0 && !(available || availableWithRenewal)"
+          class="mx-auto flex w-full max-w-[640px] flex-col gap-2"
+        >
+          <h3 class="text-left text-base font-semibold italic">
+            {{ t('updateOs.checkUpdateResponseModal.ignoredReleases') }}
+          </h3>
+          <UpdateOsIgnoredRelease
+            v-for="ignoredRelease in updateOsIgnoredReleases"
+            :key="ignoredRelease"
+            :label="ignoredRelease"
+            :t="t"
+          />
+        </div>
       </div>
+    </div>
 
-      <ResponsiveModalFooter>
+    <component
+      :is="embedded ? 'div' : ResponsiveModalFooter"
+      :class="cn('@container', !embedded && 'px-6 pb-6')"
+    >
+      <div
+        class="mx-auto flex w-full flex-col gap-3 @min-[512px]:flex-row @min-[512px]:items-center @min-[512px]:justify-between"
+      >
         <div
-          :class="
-            cn(
-              'mx-auto flex w-full gap-2',
-              actionButtons.length > 0
-                ? 'xs:!flex-row flex-col-reverse justify-between'
-                : 'justify-center'
-            )
-          "
+          class="flex w-full flex-wrap items-stretch gap-2 @min-[512px]:w-auto @min-[512px]:flex-nowrap @min-[512px]:gap-3"
         >
-          <div :class="cn('xs:!flex-row mt-2 flex flex-col-reverse justify-start gap-3')">
-            <TooltipProvider>
-              <Tooltip :delay-duration="0">
+          <Button
+            v-if="embedded && !checkForUpdatesFailed && (!pendingReboot || waitingForDrivers)"
+            variant="outline"
+            class="h-auto min-h-10 min-w-0 flex-1 basis-[calc((100%_-_8px)/2)] justify-center px-2 text-sm @min-[512px]:h-10 @min-[512px]:flex-none @min-[512px]:basis-auto @min-[512px]:px-4 @min-[512px]:text-base"
+            :disabled="checkForUpdatesLoading"
+            @click="checkForUpdates"
+          >
+            <ArrowPathIcon class="mr-2 hidden h-4 w-4 @min-[512px]:block" />
+            {{ t('updateOs.checkUpdateResponseModal.checkForUpdatesAction') }}
+          </Button>
+          <Button
+            v-if="pendingReboot"
+            variant="outline"
+            class="h-auto min-h-10 min-w-0 flex-1 basis-[calc((100%_-_8px)/2)] justify-center px-2 text-sm @min-[512px]:h-10 @min-[512px]:flex-none @min-[512px]:basis-auto @min-[512px]:px-4 @min-[512px]:text-base"
+            @click="updateOsStore.cancelUpdate()"
+          >
+            <XMarkIcon class="mr-2 hidden h-4 w-4 @min-[512px]:block" />
+            {{
+              rebootType === 'downgrade'
+                ? t('updateOs.checkUpdateResponseModal.cancelDowngrade')
+                : t('updateOs.checkUpdateResponseModal.cancelUpdate')
+            }}
+          </Button>
+          <TooltipProvider>
+            <Tooltip :delay-duration="0">
+              <TooltipTrigger as-child>
+                <Button
+                  variant="outline"
+                  class="h-auto min-h-10 min-w-0 flex-1 basis-[calc((100%_-_8px)/2)] justify-center px-2 text-sm @min-[512px]:h-10 @min-[512px]:flex-none @min-[512px]:basis-auto @min-[512px]:px-4 @min-[512px]:text-base"
+                  @click="accountStore.updateOs()"
+                >
+                  <ArrowTopRightOnSquareIcon class="mr-2 hidden h-4 w-4 @min-[512px]:block" />
+                  {{ t('updateOs.checkUpdateResponseModal.moreOptions') }}
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent class="max-w-xs">
+                <div class="flex items-start gap-2">
+                  <ArrowTopRightOnSquareIcon
+                    class="text-muted-foreground mt-0.5 h-4 w-4 flex-shrink-0"
+                  />
+                  <p class="text-left text-sm">
+                    {{
+                      t('updateOs.checkUpdateResponseModal.manageUpdatePreferencesIncludingBetaAccess')
+                    }}
+                  </p>
+                </div>
+              </TooltipContent>
+            </Tooltip>
+          </TooltipProvider>
+        </div>
+        <div
+          v-if="actionButtons.length > 0"
+          class="flex w-full flex-col justify-end gap-3 @min-[512px]:w-auto @min-[512px]:flex-row"
+        >
+          <template v-for="item in actionButtons" :key="item.text">
+            <TooltipProvider v-if="ignoreThisRelease && item.text === localizedCloseText">
+              <Tooltip :delay-duration="300">
                 <TooltipTrigger as-child>
-                  <Button variant="ghost" @click="accountStore.updateOs()">
-                    <ArrowTopRightOnSquareIcon class="mr-2 h-4 w-4" />
-                    {{ t('updateOs.checkUpdateResponseModal.moreOptions') }}
-                  </Button>
+                  <BrandButton
+                    :variant="item.variant ?? undefined"
+                    :icon="item.icon"
+                    :icon-right="item.iconRight"
+                    :icon-right-hover-display="item.iconRightHoverDisplay"
+                    :text="item.text ?? ''"
+                    :title="item.title ? item.title : undefined"
+                    @click="item.click?.()"
+                  />
                 </TooltipTrigger>
-                <TooltipContent class="max-w-xs">
-                  <div class="flex items-start gap-2">
-                    <ArrowTopRightOnSquareIcon
-                      class="text-muted-foreground mt-0.5 h-4 w-4 flex-shrink-0"
-                    />
-                    <p class="text-left text-sm">
-                      {{
-                        t('updateOs.checkUpdateResponseModal.manageUpdatePreferencesIncludingBetaAccess')
-                      }}
-                    </p>
-                  </div>
+                <TooltipContent>
+                  <p>
+                    {{ t('updateOs.checkUpdateResponseModal.youCanOptBackInTo') }}
+                  </p>
                 </TooltipContent>
               </Tooltip>
             </TooltipProvider>
-          </div>
-          <div
-            v-if="actionButtons.length > 0"
-            :class="cn('xs:!flex-row flex flex-col justify-end gap-3')"
-          >
-            <template v-for="item in actionButtons" :key="item.text">
-              <TooltipProvider v-if="ignoreThisRelease && item.text === localizedCloseText">
-                <Tooltip :delay-duration="300">
-                  <TooltipTrigger as-child>
-                    <BrandButton
-                      :variant="item.variant ?? undefined"
-                      :icon="item.icon"
-                      :icon-right="item.iconRight"
-                      :icon-right-hover-display="item.iconRightHoverDisplay"
-                      :text="item.text ?? ''"
-                      :title="item.title ? item.title : undefined"
-                      @click="item.click?.()"
-                    />
-                  </TooltipTrigger>
-                  <TooltipContent>
-                    <p>
-                      {{ t('updateOs.checkUpdateResponseModal.youCanOptBackInTo') }}
-                    </p>
-                  </TooltipContent>
-                </Tooltip>
-              </TooltipProvider>
-              <BrandButton
-                v-else
-                :variant="item.variant ?? undefined"
-                :icon="item.icon"
-                :icon-right="item.iconRight"
-                :icon-right-hover-display="item.iconRightHoverDisplay"
-                :text="item.text ?? ''"
-                :title="item.title ? item.title : undefined"
-                @click="item.click?.()"
-              />
-            </template>
-          </div>
+            <BrandButton
+              v-else
+              :variant="item.variant ?? undefined"
+              :icon="item.icon"
+              :icon-right="item.iconRight"
+              :icon-right-hover-display="item.iconRightHoverDisplay"
+              :text="item.text ?? ''"
+              :title="item.title ? item.title : undefined"
+              @click="item.click?.()"
+            />
+          </template>
         </div>
-      </ResponsiveModalFooter>
-    </div>
-  </ResponsiveModal>
+      </div>
+    </component>
+  </component>
 </template>
diff --git a/web/src/components/UpdateOs/RawChangelogRenderer.vue b/web/src/components/UpdateOs/RawChangelogRenderer.vue
index 83b3ab0a82..c07ed11519 100644
--- a/web/src/components/UpdateOs/RawChangelogRenderer.vue
+++ b/web/src/components/UpdateOs/RawChangelogRenderer.vue
@@ -3,7 +3,7 @@ import { computed, onMounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 
 import { ArrowTopRightOnSquareIcon } from '@heroicons/vue/24/solid';
-import { BrandButton } from '@unraid/ui';
+import { BrandButton, BrandLoading } from '@unraid/ui';
 import { Markdown } from '@/helpers/markdown';
 
 const props = defineProps<{
@@ -15,7 +15,6 @@ const props = defineProps<{
 const { t } = useI18n();
 
 const parsedChangelog = ref<string>('');
-const parsedChangelogTitle = ref<string>('');
 const parseChangelogFailed = ref<string>('');
 const isLoading = ref<boolean>(false);
 
@@ -59,11 +58,10 @@ const fetchAndParseChangelog = async () => {
     };
     // Add heading renderer
     renderer.heading = ({ text, depth }) => {
-      // Capture the first h1 title
+      // The modal header already identifies the release.
       if (depth === 1 && firstHeading) {
         firstHeading = false;
-        parsedChangelogTitle.value = `Version ${props.version} ${props.date ? `(${props.date})` : ''}`;
-        return `<br />`;
+        return '';
       }
       // Only add IDs for h2 and above (depth > 1)
       if (depth > 1) {
@@ -105,7 +103,7 @@ const mutatedParsedChangelog = computed(() => {
 
 <template>
   <div
-    class="prose prose-sm dark:prose-invert max-w-none overflow-auto p-4 [&_.grid]:!flex [&_.grid]:!flex-wrap [&_.grid]:!gap-8 [&_.grid>*]:!flex-1 [&_.grid>*]:!basis-full md:[&_.grid>*]:!basis-[calc(50%-1rem)]"
+    class="prose prose-sm dark:prose-invert max-w-none overflow-auto [&_.grid]:!flex [&_.grid]:!flex-wrap [&_.grid]:!gap-8 [&_.grid>*]:!flex-1 [&_.grid>*]:!basis-full md:[&_.grid>*]:!basis-[calc(50%-1rem)]"
   >
     <div v-if="parseChangelogFailed" class="prose flex flex-col gap-4 text-center">
       <h2 class="text-unraid-red text-lg font-semibold italic">
@@ -125,15 +123,17 @@ const mutatedParsedChangelog = computed(() => {
         </BrandButton>
       </div>
     </div>
-    <div v-else-if="parsedChangelogTitle" class="mb-4">
-      <h1>{{ parsedChangelogTitle }}</h1>
-    </div>
+    <p v-else-if="props.date && !isLoading" class="text-muted-foreground text-sm">{{ props.date }}</p>
     <div v-if="mutatedParsedChangelog" v-html="mutatedParsedChangelog" />
-    <div v-else-if="isLoading" class="flex flex-col items-center justify-center py-8">
-      <span
-        class="border-t-unraid-red mx-auto h-8 w-8 animate-spin rounded-full border-2 border-gray-300"
-      />
-      <p class="ml-2">{{ t('updateOs.rawChangelogRenderer.loadingChangelog') }}</p>
+    <div
+      v-else-if="isLoading"
+      role="status"
+      class="flex min-h-32 flex-col items-center justify-center gap-3"
+    >
+      <BrandLoading aria-hidden="true" class="mx-auto w-24" />
+      <p class="text-muted-foreground text-sm">
+        {{ t('updateOs.rawChangelogRenderer.loadingChangelog') }}
+      </p>
     </div>
     <div v-else class="py-8 text-center">
       <p>{{ t('updateOs.rawChangelogRenderer.noChangelogContentAvailable') }}</p>
diff --git a/web/src/components/UpdateOs/Status.vue b/web/src/components/UpdateOs/Status.vue
index f148099524..30639cade3 100644
--- a/web/src/components/UpdateOs/Status.vue
+++ b/web/src/components/UpdateOs/Status.vue
@@ -44,10 +44,11 @@ const LoadingIcon = () => h(BrandLoading, { variant: 'white', style: 'width: 16p
 
 const { dateTimeFormat, osVersion, rebootType, rebootVersion, regExp, regUpdatesExpired } =
   storeToRefs(serverStore);
-const { available, availableWithRenewal } = storeToRefs(updateOsStore);
+const { available, availableWithRenewal, checkForUpdatesLoading } = storeToRefs(updateOsStore);
 const { ineligibleText, rebootTypeText, status } = storeToRefs(updateOsActionsStore);
 
 const updateAvailable = computed(() => available.value || availableWithRenewal.value);
+const checkingForUpdates = computed(() => checkForUpdatesLoading.value || status.value === 'checking');
 
 const { outputDateTimeReadableDiff: readableDiffRegExp, outputDateTimeFormatted: formattedRegExp } =
   useDateTimeHelper(dateTimeFormat.value, t, true, regExp.value);
@@ -74,6 +75,14 @@ const showRebootButton = computed(
   () => rebootType.value === 'downgrade' || rebootType.value === 'update'
 );
 
+const checkForUpdates = () => {
+  updateOsStore.localCheckForUpdate();
+};
+
+const showRefreshButton = computed(
+  () => updateAvailable.value && !showRebootButton.value && !props.showExternalDowngrade
+);
+
 const checkButton = computed(() => {
   if (showRebootButton.value || props.showExternalDowngrade) {
     return {
@@ -91,9 +100,7 @@ const checkButton = computed(() => {
 
   if (!updateAvailable.value) {
     return {
-      click: () => {
-        updateOsStore.localCheckForUpdate();
-      },
+      click: checkForUpdates,
       icon: () => h(ArrowPathIcon, { style: 'width: 16px; height: 16px;' }),
       text: t('userProfile.dropdownContent.checkForUpdate'),
     };
@@ -230,10 +237,21 @@ const navigateToRegistration = () => {
           }}
         </Button>
 
+        <Button
+          v-if="showRefreshButton"
+          variant="pill-gray"
+          :title="t('userProfile.dropdownContent.checkForUpdate')"
+          :disabled="checkingForUpdates"
+          @click="checkForUpdates"
+        >
+          <ArrowPathIcon class="shrink-0" style="width: 16px; height: 16px" />
+          {{ t('userProfile.dropdownContent.checkForUpdate') }}
+        </Button>
+
         <Button
           :variant="checkButton.variant === 'fill' ? 'pill-orange' : 'pill-gray'"
           :title="checkButton.text"
-          :disabled="status === 'checking'"
+          :disabled="checkingForUpdates"
           @click="checkButton.click"
         >
           <component :is="checkButton.icon" class="shrink-0" style="width: 16px; height: 16px" />
diff --git a/web/src/composables/services/webgui.ts b/web/src/composables/services/webgui.ts
index 8d0344d9c7..74d31a682a 100644
--- a/web/src/composables/services/webgui.ts
+++ b/web/src/composables/services/webgui.ts
@@ -119,13 +119,22 @@ export const WebguiCheckForUpdate = async (): Promise<ServerUpdateOsResponse | u
       .url('/plugins/dynamix.plugin.manager/include/UnraidCheckExec.php')
       .query(params)
       .get()
-      .json((json) => {
-        return json as ServerUpdateOsResponse;
-      })
+      .json<unknown>()
       .catch((error) => {
         console.error('[WebguiCheckForUpdate] catch failed to execute UpdateCheck', error);
         throw new Error('Error checking for updates');
       });
+    if (
+      !response ||
+      typeof response !== 'object' ||
+      !('version' in response) ||
+      typeof response.version !== 'string' ||
+      !response.version ||
+      !('isNewer' in response) ||
+      typeof response.isNewer !== 'boolean'
+    ) {
+      throw new Error('Invalid update check response');
+    }
     return response as ServerUpdateOsResponse;
   } catch (error) {
     console.error('[WebguiCheckForUpdate] catch failed to execute UpdateCheck', error);
diff --git a/web/src/locales/en.json b/web/src/locales/en.json
index d27caecf56..63168ab2a5 100644
--- a/web/src/locales/en.json
+++ b/web/src/locales/en.json
@@ -820,20 +820,34 @@
   "sso.useSsoAuth.invalidCallbackParameters": "Invalid callback parameters",
   "updateOs.callbackButton.checkForOsUpdates": "Check for OS Updates",
   "updateOs.changelogModal.extendLicenseToUpdate": "Extend License to Update",
-  "updateOs.changelogModal.loadingChangelog": "Loading changelog…",
-  "updateOs.changelogModal.unraidOsChangelog": "Unraid OS {0} Changelog",
-  "updateOs.checkUpdateResponseModal.checkingForOsUpdates": "Checking for OS updates...",
+  "updateOs.changelogModal.loadingChangelog": "Loading release notes",
+  "updateOs.changelogModal.unraidOsChangelog": "Unraid {0} release notes",
+  "updateOs.checkUpdateResponseModal.updateAvailable": "Update available",
+  "updateOs.checkUpdateResponseModal.rebootNow": "Reboot now",
+  "updateOs.checkUpdateResponseModal.cancelUpdate": "Cancel update",
+  "updateOs.checkUpdateResponseModal.cancelDowngrade": "Cancel downgrade",
+  "updateOs.checkUpdateResponseModal.rebootRequired": "Reboot required",
+  "updateOs.checkUpdateResponseModal.preparingDrivers": "Preparing drivers",
+  "updateOs.checkUpdateResponseModal.reviewReleaseNotes": "Review release notes",
+  "updateOs.checkUpdateResponseModal.checkForUpdatesAction": "Check for updates",
+  "updateOs.checkUpdateResponseModal.checkingForOsUpdates": "Checking for updates",
+  "updateOs.checkUpdateResponseModal.checkFailed": "Unable to check for updates",
+  "updateOs.checkUpdateResponseModal.checkFailedDescription": "Check your connection and try again.",
   "updateOs.checkUpdateResponseModal.currentVersion": "Current Version {0}",
+  "updateOs.checkUpdateResponseModal.currentVersionLabel": "Current version",
+  "updateOs.checkUpdateResponseModal.availableVersionLabel": "Available version",
+  "updateOs.checkUpdateResponseModal.updatingTo": "Updating to",
+  "updateOs.checkUpdateResponseModal.downgradingTo": "Downgrading to",
   "updateOs.checkUpdateResponseModal.enableUpdateNotifications": "Enable update notifications",
   "updateOs.checkUpdateResponseModal.goToSettingsNotificationsToEnable": "Go to Settings > Notifications to enable automatic OS update notifications for future releases.",
   "updateOs.checkUpdateResponseModal.ignoredReleases": "Ignored Releases",
   "updateOs.checkUpdateResponseModal.ignoreThisReleaseUntilNextReboot": "Ignore this release until next reboot",
   "updateOs.checkUpdateResponseModal.manageUpdatePreferencesIncludingBetaAccess": "Manage update preferences including beta access and version selection at account.unraid.net",
-  "updateOs.checkUpdateResponseModal.moreOptions": "More Options",
+  "updateOs.checkUpdateResponseModal.moreOptions": "More options",
   "updateOs.checkUpdateResponseModal.requiresVerificationToUpdate": "Requires verification to update",
-  "updateOs.checkUpdateResponseModal.unraidOsIsUpToDate": "Unraid OS is up-to-date",
+  "updateOs.checkUpdateResponseModal.unraidOsIsUpToDate": "Up to date",
   "updateOs.checkUpdateResponseModal.verifyToUpdate": "Verify to Update",
-  "updateOs.checkUpdateResponseModal.viewChangelogToStartUpdate": "View Changelog to Start Update",
+  "updateOs.checkUpdateResponseModal.viewChangelogToStartUpdate": "Review update",
   "updateOs.checkUpdateResponseModal.youCanOptBackInTo": "You can opt back in to an ignored release by clicking on the Check for Updates button in the header anytime",
   "updateOs.downgrade.beginDowngradeTo": "Begin downgrade to {0}",
   "updateOs.downgrade.downgradesAreOnlyRecommendedIfYou": "Downgrades are only recommended if you're unable to solve a critical issue.",
@@ -854,7 +868,7 @@
   "updateOs.pleaseFinishTheInitiatedDowngradeTo": "Please finish the initiated downgrade to enable updates.",
   "updateOs.rawChangelogRenderer.errorParsingChangelog": "Error Parsing Changelog • {0}",
   "updateOs.rawChangelogRenderer.itSHighlyRecommendedToReview": "It's highly recommended to review the changelog before continuing your update",
-  "updateOs.rawChangelogRenderer.loadingChangelog": "Loading changelog...",
+  "updateOs.rawChangelogRenderer.loadingChangelog": "Loading release notes",
   "updateOs.rawChangelogRenderer.noChangelogContentAvailable": "No changelog content available",
   "updateOs.rawChangelogRenderer.viewChangelogOnDocs": "View Changelog on Docs",
   "updateOs.reboot.downgrade": "Reboot Required for Downgrade",
diff --git a/web/src/store/updateOs.ts b/web/src/store/updateOs.ts
index 39402f682e..4f6af83742 100644
--- a/web/src/store/updateOs.ts
+++ b/web/src/store/updateOs.ts
@@ -20,6 +20,7 @@ extend(relativeTime);
 export const useUpdateOsStore = defineStore('updateOs', () => {
   // state
   const checkForUpdatesLoading = ref<boolean>(false);
+  const checkForUpdatesFailed = ref(false);
   const updateOsModalVisible = ref<boolean>(false);
   const releaseForUpdate = ref<ServerUpdateOsResponse | null>(null);
   const changelogModalVisible = computed(() => !!releaseForUpdate.value);
@@ -89,14 +90,17 @@ export const useUpdateOsStore = defineStore('updateOs', () => {
   // actions
   const localCheckForUpdate = async (): Promise<void> => {
     checkForUpdatesLoading.value = true;
+    checkForUpdatesFailed.value = false;
     setModalOpen(true);
     try {
       const response = await WebguiCheckForUpdate();
       console.debug('[localCheckForUpdate] response', response);
       serverStore.setUpdateOsResponse(response as ServerUpdateOsResponse);
-      checkForUpdatesLoading.value = false;
     } catch (error) {
+      checkForUpdatesFailed.value = true;
       throw new Error('[localCheckForUpdate] Error checking for updates\n' + JSON.stringify(error));
+    } finally {
+      checkForUpdatesLoading.value = false;
     }
   };
 
@@ -130,6 +134,7 @@ export const useUpdateOsStore = defineStore('updateOs', () => {
     available,
     availableWithRenewal,
     checkForUpdatesLoading,
+    checkForUpdatesFailed,
     updateOsModalVisible,
     changelogModalVisible,
     releaseForUpdate,