diff --git a/desktop/src/main/__tests__/ipc-provider-jobs.test.ts b/desktop/src/main/__tests__/ipc-provider-jobs.test.ts
index 72af015e0..dfeda0a99 100644
--- a/desktop/src/main/__tests__/ipc-provider-jobs.test.ts
+++ b/desktop/src/main/__tests__/ipc-provider-jobs.test.ts
@@ -64,6 +64,7 @@ function setup(
     ),
     cancelFor: vi.fn(async () => undefined),
   }
+  const send = vi.fn()
   const deps = {
     cli,
     state: { workspaceContext: () => "ctx", providerList: () => [] },
@@ -74,12 +75,12 @@ function setup(
       onDrain: async () => undefined,
     },
     pty: { cancelFor: vi.fn(async () => undefined) },
-    getMainWindow: () => null,
+    getMainWindow: () => ({ webContents: { send } }),
     providerJobs,
   }
   // biome-ignore lint/suspicious/noExplicitAny: partial test doubles
   registerIpcHandlers(deps as any)
-  return { providerJobs, cli }
+  return { providerJobs, cli, send }
 }
 
 function invoke(channel: string, args: Record<string, unknown>) {
@@ -154,7 +155,7 @@ describe("provider job lifecycle over IPC", () => {
 
   it("runs set-source then init on update, clearing the job once", async () => {
     const seen: string[][] = []
-    const { providerJobs } = setup((cliArgs) => {
+    const { providerJobs, send } = setup((cliArgs) => {
       seen.push(cliArgs)
       return { lines: [], code: 0 }
     })
@@ -178,6 +179,53 @@ describe("provider job lifecycle over IPC", () => {
     expect(providerJobs.get("docker")?.error).toBeTruthy()
   })
 
+
+  it("streams update phases and completes the provider job", async () => {
+    const seen: string[][] = []
+    const { providerJobs, send } = setup((cliArgs) => {
+      seen.push(cliArgs)
+      return { lines: [statusLine(cliArgs[1] === "init" ? "running_init" : "downloading")], code: 0 }
+    })
+
+    const commandId = await invoke("provider_update_streaming", { name: "docker" })
+    expect(commandId).toEqual(expect.any(String))
+    expect(providerJobs.get("docker")?.activity).toBe("updating")
+
+    await vi.waitFor(() => expect(providerJobs.get("docker")).toBeUndefined())
+    expect(seen.map((args) => args[1])).toEqual(["set-source", "init"])
+    expect(send).toHaveBeenCalledWith(
+      "command-progress",
+      expect.objectContaining({ commandId, success: true, done: true }),
+    )
+  })
+
+  it("retains update failure details after a streaming update", async () => {
+    const { providerJobs } = setup((cliArgs) => ({
+      lines: [],
+      code: cliArgs[1] === "init" ? 1 : 0,
+    }))
+
+    await invoke("provider_update_streaming", { name: "docker" })
+    await vi.waitFor(() => expect(providerJobs.get("docker")?.error).toBeTruthy())
+  })
+
+
+  it("terminates a streaming update when provider refresh fails", async () => {
+    const { providerJobs, send } = setup(() => ({ lines: [], code: 0 }))
+    providerJobs.setRefresh(() => Promise.reject(new Error("refresh boom")))
+
+    const commandId = await invoke("provider_update_streaming", { name: "docker" })
+
+    await vi.waitFor(() =>
+      expect(providerJobs.get("docker")?.errorCode).toBe("provider_refresh_failed"),
+    )
+    expect(send).toHaveBeenCalledWith(
+      "command-progress",
+      expect.objectContaining({ commandId, success: false, done: true }),
+    )
+  })
+
+
   it("does not blame a successful init for a refresh failure afterward", async () => {
     const { providerJobs } = setup(() => ({
       lines: [statusLine("running_init"), statusLine("ready")],
@@ -189,4 +237,37 @@ describe("provider job lifecycle over IPC", () => {
 
     expect(providerJobs.get("docker")?.error).not.toBe("refresh boom")
   })
+
+  it("refreshes and clears a retained provider refresh failure", async () => {
+    const { providerJobs } = setup(() => ({ lines: [], code: 0 }))
+    const refresh = vi.fn().mockResolvedValue(undefined)
+    providerJobs.setRefresh(refresh)
+    providerJobs.start("docker", "updating")
+    await providerJobs.finish("docker", {
+      code: "provider_refresh_failed",
+      message: "status unavailable",
+    })
+
+    const result = await invoke("provider_refresh_state", { name: "docker" })
+
+    expect(result).toEqual({ ok: true })
+    expect(refresh).toHaveBeenCalledOnce()
+    expect(providerJobs.get("docker")).toBeUndefined()
+  })
+
+  it("returns failure and retains recovery when provider refresh still fails", async () => {
+    const { providerJobs } = setup(() => ({ lines: [], code: 0 }))
+    providerJobs.setRefresh(() => Promise.reject(new Error("still unavailable")))
+    providerJobs.start("docker", "updating")
+    await providerJobs.finish("docker", {
+      code: "provider_refresh_failed",
+      message: "status unavailable",
+    })
+
+    const result = await invoke("provider_refresh_state", { name: "docker" })
+
+    expect(result).toEqual({ ok: false, message: "still unavailable" })
+    expect(providerJobs.get("docker")?.errorCode).toBe("provider_refresh_failed")
+  })
+
 })
diff --git a/desktop/src/main/__tests__/provider-jobs.test.ts b/desktop/src/main/__tests__/provider-jobs.test.ts
index 0acf8444e..e427bfe59 100644
--- a/desktop/src/main/__tests__/provider-jobs.test.ts
+++ b/desktop/src/main/__tests__/provider-jobs.test.ts
@@ -194,4 +194,32 @@ describe("ProviderJobs", () => {
 
     expect(jobs.get("docker")).toBeUndefined()
   })
+
+  it("retries refresh for a retained refresh failure", async () => {
+    const refresh = vi.fn().mockResolvedValue(undefined)
+    jobs.setRefresh(refresh)
+    jobs.start("docker", "updating")
+    await jobs.finish("docker", {
+      code: "provider_refresh_failed",
+      message: "status unavailable",
+    })
+
+    await jobs.retryRefresh("docker")
+
+    expect(refresh).toHaveBeenCalledOnce()
+    expect(jobs.get("docker")).toBeUndefined()
+  })
+
+  it("keeps a refresh recovery job when retry fails", async () => {
+    jobs.setRefresh(() => Promise.reject(new Error("still unavailable")))
+    jobs.start("docker", "updating")
+    await jobs.finish("docker", {
+      code: "provider_refresh_failed",
+      message: "status unavailable",
+    })
+
+    await expect(jobs.retryRefresh("docker")).rejects.toThrow("still unavailable")
+    expect(jobs.get("docker")?.errorCode).toBe("provider_refresh_failed")
+  })
+
 })
diff --git a/desktop/src/main/ipc.ts b/desktop/src/main/ipc.ts
index 16a6e2f56..9c92432fa 100644
--- a/desktop/src/main/ipc.ts
+++ b/desktop/src/main/ipc.ts
@@ -71,6 +71,7 @@ type UpdateInfo = {
 }
 
 let providerUpdateCache: Record<string, UpdateInfo> = {}
+let providerUpdateCacheCheckedAt: string | null = null
 
 const IMAGE_CATALOG_URL =
   process.env.DEVSY_IMAGE_CATALOG_URL ??
@@ -751,6 +752,113 @@ export function registerIpcHandlers(deps: IpcDependencies): {
     })
   })
 
+  ipcMain.handle(
+    "provider_update_streaming",
+    async (_event, args: { name: string }) => {
+      const cmdId = crypto.randomUUID()
+      const win = deps.getMainWindow()
+      providerJobs.start(args.name, "updating")
+
+      const sendProgress = (message: string, level?: string) => {
+        const formatted = redactSensitiveText(formatLogLine(message))
+        providerJobs.appendLog(args.name, formatted)
+        win?.webContents.send("command-progress", {
+          commandId: cmdId,
+          message: formatted,
+          level,
+          done: false,
+        })
+      }
+
+      const runStep = (cliArgs: string[]): Promise<void> =>
+        new Promise((resolve, reject) => {
+          cli.runStreaming(
+            cliArgs,
+            (line, stream, meta) => {
+              if (stream === "stdout") {
+                const envelope = parseCliEnvelope(line)
+                if (envelope?.kind === "status") {
+                  providerJobs.reportStatus(
+                    args.name,
+                    redactOperationStatus(normalizeOperationStatus(envelope)),
+                  )
+                  return
+                }
+              }
+              sendProgress(line, meta?.level)
+            },
+            (code, cliError) => {
+              if (code === 0) {
+                resolve()
+                return
+              }
+              reject(
+                Object.assign(
+                  new Error(
+                    cliError?.message ?? `${cliArgs.join(" ")} exited with ${code}`,
+                  ),
+                  { cliError },
+                ),
+              )
+            },
+          ).catch(reject)
+        })
+
+      void (async () => {
+        let failure: CLIError | undefined
+        try {
+          sendProgress("Downloading provider update", "info")
+          await runStep(["provider", "set-source", args.name, "--use=false"])
+          sendProgress("Initializing updated provider", "info")
+          await runStep(["provider", "init", args.name])
+        } catch (error) {
+          failure = (error as { cliError?: CLIError }).cliError ?? {
+            code: "provider_update_failed",
+            message: errorMessage(error),
+          }
+        }
+        try {
+          await providerJobs.finish(
+            args.name,
+            failure ? redactCLIError(failure) : undefined,
+          )
+        } catch (error) {
+          failure = {
+            code: "provider_refresh_failed",
+            message: "The provider updated, but its current state could not be refreshed.",
+            hint: "Refresh provider status to try again.",
+            context: { cause: errorMessage(error) },
+          }
+          await providerJobs.finish(args.name, redactCLIError(failure))
+        }
+        win?.webContents.send("command-progress", {
+          commandId: cmdId,
+          message: redactSensitiveText(
+            formatLogLine(
+              failure ? "Provider update failed" : "Provider update complete",
+              failure ? "ERROR" : "INFO",
+            ),
+          ),
+          level: failure ? "error" : "info",
+          success: !failure,
+          cliError: failure ? redactCLIError(failure) : undefined,
+          done: true,
+        })
+      })()
+
+      return cmdId
+    },
+  )
+
+  ipcMain.handle("provider_refresh_state", async (_event, args: { name: string }) => {
+    try {
+      await providerJobs.retryRefresh(args.name)
+      return { ok: true } as const
+    } catch (error) {
+      return { ok: false, message: errorMessage(error) } as const
+    }
+  })
+
   ipcMain.handle("provider_options", async (_event, args: { name: string }) => {
     return cli.run(["provider", "get", args.name])
   })
@@ -825,12 +933,14 @@ export function registerIpcHandlers(deps: IpcDependencies): {
   ipcMain.handle("provider_check_updates", async () => {
     const out = await computeUpdateChecks()
     providerUpdateCache = out
+    providerUpdateCacheCheckedAt = new Date().toISOString()
     return out
   })
 
-  ipcMain.handle("provider_get_update_cache", async () => {
-    return providerUpdateCache
-  })
+  ipcMain.handle("provider_get_update_cache", async () => ({
+    updates: providerUpdateCache,
+    lastCheckedAt: providerUpdateCacheCheckedAt,
+  }))
 
   ipcMain.handle("image_catalog_get", async () => {
     const { cachePath, seedPath } = imageCatalogPaths()
@@ -1856,6 +1966,7 @@ export function registerIpcHandlers(deps: IpcDependencies): {
     void (async () => {
       try {
         providerUpdateCache = await computeUpdateChecks()
+        providerUpdateCacheCheckedAt = new Date().toISOString()
       } catch {
         // Silently swallow background errors.
       }
diff --git a/desktop/src/main/provider-jobs.ts b/desktop/src/main/provider-jobs.ts
index 72147d1b6..f0d051ebe 100644
--- a/desktop/src/main/provider-jobs.ts
+++ b/desktop/src/main/provider-jobs.ts
@@ -35,6 +35,7 @@ export interface ProviderJob {
   errorCode?: string
   errorHint?: string
   errorContext?: Record<string, string>
+  logs?: string[]
 }
 
 export class ProviderJobs {
@@ -64,6 +65,15 @@ export class ProviderJobs {
     this.emit()
   }
 
+
+  /** Retain recent operation output so failures remain diagnosable after navigation. */
+  appendLog(name: string, line: string): void {
+    const job = this.jobs.get(name)
+    if (!job) return
+    this.jobs.set(name, { ...job, logs: [...(job.logs ?? []), line].slice(-500) })
+    this.emit()
+  }
+
   /** Record the complete current-protocol status event without losing metadata. */
   reportStatus(name: string, status: OperationStatus): void {
     const job = this.jobs.get(name)
@@ -140,6 +150,19 @@ export class ProviderJobs {
     this.emit()
   }
 
+
+  /** Retry only the authoritative provider-state refresh after a completed operation. */
+  async retryRefresh(name: string): Promise<void> {
+    const job = this.jobs.get(name)
+    if (!job || job.errorCode !== "provider_refresh_failed") return
+    const generation = this.generations.get(name)
+    await this.refresh?.()
+    if (this.generations.get(name) !== generation) return
+    this.jobs.delete(name)
+    this.generations.delete(name)
+    this.emit()
+  }
+
   /**
    * Supplies a way to re-read provider state from disk, so a finished job
    * isn't cleared before the list reflects what the command just wrote.
diff --git a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte
index bc0e34c28..5db6f8274 100644
--- a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte
+++ b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-import { onMount } from "svelte"
+import { onDestroy, onMount } from "svelte"
 import { Star } from "@lucide/svelte"
 import { Button } from "$lib/components/ui/button/index.js"
 import { Input } from "$lib/components/ui/input/index.js"
@@ -14,20 +14,23 @@ import * as ButtonGroup from "$lib/components/ui/button-group/index.js"
 import { Spinner } from "$lib/components/ui/spinner/index.js"
 import ConfirmDialog from "$lib/components/layout/ConfirmDialog.svelte"
 import ErrorCard from "$lib/components/ErrorCard.svelte"
+import LogTable from "$lib/components/log/LogTable.svelte"
 import UpdateConfirmDialog from "./UpdateConfirmDialog.svelte"
 import type { CLIError } from "$shared/cli-error.js"
 import {
   providerUse,
-  providerUpdate,
+  providerUpdateStreaming,
   providerDelete,
   providerInit,
   providerList,
   providerOptions,
+  providerRefreshState,
   providerSetOptions,
   providerSetSingleMachine,
   providerRename,
   providerSetVersion,
 } from "$lib/ipc/commands.js"
+import { onCommandProgress } from "$lib/ipc/events.js"
 import { providers, providerJobs } from "$lib/stores/providers.js"
 import {
   providerVersions,
@@ -36,8 +39,9 @@ import {
 } from "$lib/stores/providerVersions.js"
 import { toasts } from "$lib/stores/toasts.js"
 import { extractErrorMessage } from "$lib/utils/error.js"
+import { isCommandSuccess } from "$lib/utils/log-parser.js"
 import { providerStatus } from "$lib/utils/provider-status.js"
-import type { Provider, ProviderOption } from "$lib/types/index.js"
+import type { CommandProgress, Provider, ProviderOption } from "$lib/types/index.js"
 
 let {
   provider,
@@ -64,14 +68,81 @@ let initError = $state<CLIError | null>(null)
 let loadedFor = $state<string | null>(null)
 let confirmUpdateOpen = $state(false)
 let updating = $state(false)
+let updateCommandId = $state<string | null>(null)
+let updateProviderName = $state<string | null>(null)
+let updateLines = $state<string[]>([])
+let updateError = $state<CLIError | null>(null)
+let updateStartError = $state("")
+let recoveredUpdateState = $state(false)
+let unlistenProgress: (() => void) | undefined
+let pendingUpdateProgress: CommandProgress[] = []
 let confirmSwitchOpen = $state(false)
 let targetTag = $state("")
 let switching = $state(false)
+let providerJob = $derived(provider ? $providerJobs[provider.name] : undefined)
 let status = $derived(
   provider
-    ? providerStatus(provider, $providerJobs[provider.name])
+    ? providerStatus(provider, providerJob)
     : { kind: "uninitialized" as const, label: "" },
 )
+let persistedUpdateError = $derived.by((): CLIError | null => {
+  if (recoveredUpdateState || providerJob?.activity !== "updating" || !providerJob.error) return null
+  return {
+    code: providerJob.errorCode ?? "provider_update_failed",
+    message: providerJob.error,
+    hint: providerJob.errorHint,
+    context: providerJob.errorContext,
+  }
+})
+let visibleUpdateError = $derived(updateError ?? persistedUpdateError)
+let refreshRecovery = $derived(visibleUpdateError?.code === "provider_refresh_failed")
+let visibleUpdateLines = $derived(updateLines.length > 0 ? updateLines : providerJob?.logs ?? [])
+let refreshingProviderState = $state(false)
+let showingLocalUpdate = $derived(updateProviderName === provider.name)
+
+let updatePhase = $derived.by(() => {
+  if (!updating || !showingLocalUpdate) return ""
+  const phase = providerJob?.phase ?? ""
+  if (phase.includes("init")) return "Initializing provider"
+  return "Downloading provider"
+})
+
+function handleUpdateProgress(progress: CommandProgress) {
+  const targetName = updateProviderName
+  if (progress.message && targetName === provider.name) {
+    updateLines = [...updateLines, progress.message]
+  }
+  if (!progress.done) return
+  updating = false
+  if (isCommandSuccess(progress.success) && targetName) {
+    void finishUpdate(targetName).catch((error) => {
+      if (targetName !== provider.name) return
+      updateError = {
+        code: "provider_refresh_failed",
+        message: `The update completed, but DevSy could not refresh ${targetName}: ${extractErrorMessage(error)}`,
+      }
+    })
+  } else if (targetName === provider.name) {
+    updateError = progress.cliError ?? {
+      code: "provider_update_failed",
+      message: "Provider update failed.",
+    }
+  }
+}
+
+onMount(async () => {
+  unlistenProgress = await onCommandProgress((progress) => {
+    if (updating && !updateCommandId) {
+      pendingUpdateProgress = [...pendingUpdateProgress, progress]
+      return
+    }
+    if (progress.commandId === updateCommandId) handleUpdateProgress(progress)
+  })
+})
+
+onDestroy(() => {
+  unlistenProgress?.()
+})
 
 function openVersionSwitch(tag: string) {
   targetTag = tag
@@ -186,22 +257,58 @@ function handleUpdate() {
 async function runUpdate() {
   const name = provider.name
   updating = true
+  updateProviderName = name
+  updateCommandId = null
+  pendingUpdateProgress = []
+  updateError = null
+  updateStartError = ""
+  recoveredUpdateState = false
+  updateLines = []
+  confirmUpdateOpen = false
   try {
-    // Also re-initializes: the new binaries have not run their init, and
-    // set-source clears the initialized flag accordingly.
-    await providerUpdate(name)
-    toasts.success(`Updated ${name}`)
-    providers.set(await providerList())
-    await loadVersionsFor(name)
-    await refreshUpdates()
+    updateCommandId = await providerUpdateStreaming(name)
+    const matching = pendingUpdateProgress.filter(
+      (progress) => progress.commandId === updateCommandId,
+    )
+    pendingUpdateProgress = []
+    for (const progress of matching) handleUpdateProgress(progress)
   } catch (err) {
-    toasts.error(`Failed to update: ${extractErrorMessage(err)}`)
-  } finally {
     updating = false
-    confirmUpdateOpen = false
+    updateStartError = `Failed to start update: ${extractErrorMessage(err)}`
   }
 }
 
+
+async function synchronizeProviderAfterUpdate(name: string) {
+  providers.set(await providerList())
+  await loadVersionsFor(name)
+  await refreshUpdates()
+}
+
+async function retryProviderStateRefresh() {
+  const name = provider.name
+  refreshingProviderState = true
+  updateStartError = ""
+  try {
+    await providerRefreshState(name)
+    await synchronizeProviderAfterUpdate(name)
+    updateError = null
+    recoveredUpdateState = true
+  } catch (error) {
+    updateError = {
+      code: "provider_refresh_failed",
+      message: `DevSy could not refresh ${name}: ${extractErrorMessage(error)}`,
+    }
+  } finally {
+    refreshingProviderState = false
+  }
+}
+
+async function finishUpdate(name: string) {
+  await synchronizeProviderAfterUpdate(name)
+  toasts.success(`Updated ${name}`)
+}
+
 async function runSwitch() {
   const name = provider.name
   switching = true
@@ -453,6 +560,53 @@ async function handleSaveOptions() {
       </div>
     {/if}
 
+    {#if (showingLocalUpdate && (updating || updateError || updateStartError || updateLines.length > 0)) || persistedUpdateError || providerJob?.logs?.length}
+      <div class="space-y-3 px-6 pt-4">
+        <div
+          class="min-h-12 rounded-md border bg-muted/20 px-3 py-2"
+          role="status"
+          aria-live="polite"
+          aria-busy={updating}
+        >
+          <div class="flex items-center gap-2 text-sm font-semibold">
+            {#if updating}<Spinner class="size-4" aria-hidden="true" />{/if}
+            {updating ? "Updating" : refreshRecovery ? "Status may be out of date" : visibleUpdateError || updateStartError ? "Update failed" : "Updated"}
+          </div>
+          <p class="text-sm text-muted-foreground">
+            {#if updating}
+              {updatePhase}
+            {:else if refreshRecovery}
+              The update completed, but DevSy could not refresh the provider's current state.
+            {:else if visibleUpdateError || updateStartError}
+              The update did not complete. Review the error and try again.
+            {:else}
+              {provider.name} is ready to use.
+            {/if}
+          </p>
+        </div>
+        {#if visibleUpdateError}
+          <ErrorCard cliError={visibleUpdateError} />
+        {:else if updateStartError}
+          <Alert.Root variant="destructive"><Alert.Description>{updateStartError}</Alert.Description></Alert.Root>
+        {/if}
+        {#if visibleUpdateLines.length > 0}
+          <details open={updating} class="rounded-md border bg-muted/30">
+            <summary class="cursor-pointer select-none px-3 py-2 text-sm font-medium text-muted-foreground hover:text-foreground">
+              {updating ? "Update logs" : "Show logs"}
+            </summary>
+            <LogTable lines={visibleUpdateLines} maxHeightClass="max-h-48" follow={updating} class="border-x-0 border-b-0 rounded-none" />
+          </details>
+        {/if}
+        {#if refreshRecovery}
+          <Button variant="outline" size="sm" onclick={retryProviderStateRefresh} disabled={refreshingProviderState}>
+            {refreshingProviderState ? "Refreshing..." : "Refresh status"}
+          </Button>
+        {:else if visibleUpdateError || updateStartError}
+          <Button variant="outline" size="sm" onclick={runUpdate}>Retry update</Button>
+        {/if}
+      </div>
+    {/if}
+
     <div class="flex-1 overflow-y-auto space-y-4 px-6 pb-6">
       {#if loading}
         <p class="text-sm text-muted-foreground">Loading options...</p>
@@ -544,7 +698,7 @@ async function handleSaveOptions() {
 <ConfirmDialog
   bind:open={confirmSwitchOpen}
   title={`Switch '${provider.name}' from ${provider.version ?? ""} to ${targetTag}`}
-  description={`Workspaces created with ${provider.version ?? ""} may behave differently after this change. Existing workspaces will run against ${targetTag} the next time they're used.`}
+  description={`Workspaces created with ${provider.version ?? ""} may behave differently after this change. Existing workspaces will run against ${targetTag} the next time DevSy uses them.`}
   confirmLabel="Switch"
   loading={switching}
   onconfirm={runSwitch}
diff --git a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.test.ts b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.test.ts
index e252c9833..506e0447f 100644
--- a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.test.ts
+++ b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.test.ts
@@ -1,37 +1,51 @@
 import { render } from "@testing-library/svelte"
 import { tick } from "svelte"
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import type { Provider } from "$lib/types/index.js"
+import type { CommandProgress, Provider, ProviderJob } from "$lib/types/index.js"
 
 const providerOptions = vi.fn()
 const providerUse = vi.fn()
-const providerUpdate = vi.fn()
+const providerUpdateStreaming = vi.fn()
 const providerDelete = vi.fn()
 const providerInit = vi.fn()
 const providerList = vi.fn()
+const providerRefreshState = vi.fn()
 const providerSetOptions = vi.fn()
 const providerRename = vi.fn()
 const providerSetVersion = vi.fn()
 const loadVersionsFor = vi.fn()
 const refreshUpdates = vi.fn()
+const providerJobsBox = vi.hoisted(() => ({
+  store: undefined as unknown as import("svelte/store").Writable<Record<string, ProviderJob>>,
+}))
+let progressCallback: ((progress: CommandProgress) => void) | null = null
 
 vi.mock("$lib/ipc/commands.js", () => ({
   providerOptions: (...args: unknown[]) => providerOptions(...args),
   providerUse: (...args: unknown[]) => providerUse(...args),
-  providerUpdate: (...args: unknown[]) => providerUpdate(...args),
+  providerUpdateStreaming: (...args: unknown[]) => providerUpdateStreaming(...args),
   providerDelete: (...args: unknown[]) => providerDelete(...args),
   providerInit: (...args: unknown[]) => providerInit(...args),
   providerList: (...args: unknown[]) => providerList(...args),
+  providerRefreshState: (...args: unknown[]) => providerRefreshState(...args),
   providerSetOptions: (...args: unknown[]) => providerSetOptions(...args),
   providerRename: (...args: unknown[]) => providerRename(...args),
   providerSetVersion: (...args: unknown[]) => providerSetVersion(...args),
 }))
 
+vi.mock("$lib/ipc/events.js", () => ({
+  onCommandProgress: vi.fn(async (callback: (progress: CommandProgress) => void) => {
+    progressCallback = callback
+    return () => { progressCallback = null }
+  }),
+}))
+
 vi.mock("$lib/stores/providers.js", async () => {
   const { writable } = await import("svelte/store")
+  providerJobsBox.store = writable({})
   return {
     providers: writable([]),
-    providerJobs: writable({}),
+    providerJobs: providerJobsBox.store,
   }
 })
 
@@ -89,6 +103,8 @@ async function flushAsync() {
 
 describe("ProviderSheet", () => {
   beforeEach(() => {
+    progressCallback = null
+    providerJobsBox.store.set({})
     providerOptions.mockReset()
     providerOptions.mockImplementation(async (name: string) => {
       await new Promise((r) => setTimeout(r, MOCK_IPC_DELAY_MS))
@@ -102,10 +118,11 @@ describe("ProviderSheet", () => {
       }
     })
     providerUse.mockResolvedValue(undefined)
-    providerUpdate.mockResolvedValue(undefined)
+    providerUpdateStreaming.mockResolvedValue("update-command-1")
     providerDelete.mockResolvedValue(undefined)
     providerInit.mockResolvedValue(undefined)
     providerList.mockResolvedValue([])
+    providerRefreshState.mockResolvedValue(undefined)
     providerSetOptions.mockResolvedValue(undefined)
     providerRename.mockResolvedValue(undefined)
     providerSetVersion.mockResolvedValue(undefined)
@@ -268,11 +285,11 @@ describe("ProviderSheet", () => {
       d.textContent?.includes("Update 'ssh' to 0.2.0"),
     )
     expect(confirmDialog).toBeDefined()
-    expect(providerUpdate).not.toHaveBeenCalled()
+    expect(providerUpdateStreaming).not.toHaveBeenCalled()
     unmount()
   })
 
-  it("confirming the update dialog calls providerUpdate exactly once", async () => {
+  it("confirming the update dialog starts one streaming provider update", async () => {
     const { unmount } = render(ProviderSheet, {
       props: { provider: makeProvider("ssh"), open: true },
     })
@@ -295,8 +312,236 @@ describe("ProviderSheet", () => {
     confirmBtn?.click()
     await flushAsync()
 
-    expect(providerUpdate).toHaveBeenCalledTimes(1)
-    expect(providerUpdate).toHaveBeenCalledWith("ssh")
+    expect(providerUpdateStreaming).toHaveBeenCalledTimes(1)
+    expect(providerUpdateStreaming).toHaveBeenCalledWith("ssh")
     unmount()
   })
+
+  it("keeps a failed update in the sheet and retries it", async () => {
+    const { unmount } = render(ProviderSheet, {
+      props: { provider: makeProvider("ssh"), open: true },
+    })
+    await flushAsync()
+
+    const updateBtn = Array.from(document.querySelectorAll("button")).find(
+      (button) => button.textContent?.trim() === "Update",
+    )
+    updateBtn?.click()
+    await tick()
+    const confirmDialog = Array.from(document.querySelectorAll("[role='dialog']")).find(
+      (dialog) => dialog.textContent?.includes("Update 'ssh' to 0.2.0"),
+    )
+    Array.from(confirmDialog?.querySelectorAll("button") ?? [])
+      .find((button) => button.textContent?.trim() === "Update")
+      ?.click()
+    await flushAsync()
+
+    progressCallback?.({
+      commandId: "update-command-1",
+      message: "download timed out",
+      success: false,
+      done: true,
+      cliError: { code: "NETWORK", message: "The download timed out." },
+    })
+    await tick()
+
+    expect(document.body.textContent).toContain("Update failed")
+    expect(document.body.textContent).toContain("The download timed out.")
+    const retry = Array.from(document.querySelectorAll("button")).find(
+      (button) => button.textContent?.trim() === "Retry update",
+    )
+    retry?.click()
+    await tick()
+    expect(providerUpdateStreaming).toHaveBeenCalledTimes(2)
+    unmount()
+  })
+
+
+  it("captures terminal progress emitted before a retry returns", async () => {
+    providerUpdateStreaming
+      .mockResolvedValueOnce("update-command-1")
+      .mockImplementationOnce(async () => {
+        progressCallback?.({
+          commandId: "update-command-2",
+          success: true,
+          done: true,
+        })
+        return "update-command-2"
+      })
+    const { unmount } = render(ProviderSheet, {
+      props: { provider: makeProvider("ssh"), open: true },
+    })
+    await flushAsync()
+    const updateBtn = Array.from(document.querySelectorAll("button")).find(
+      (button) => button.textContent?.trim() === "Update",
+    )
+    updateBtn?.click()
+    await tick()
+    const dialog = Array.from(document.querySelectorAll("[role='dialog']")).find(
+      (node) => node.textContent?.includes("Update 'ssh' to 0.2.0"),
+    )
+    Array.from(dialog?.querySelectorAll("button") ?? [])
+      .find((button) => button.textContent?.trim() === "Update")?.click()
+    await flushAsync()
+    progressCallback?.({
+      commandId: "update-command-1",
+      success: false,
+      done: true,
+      cliError: { code: "NETWORK", message: "Network unavailable." },
+    })
+    await tick()
+    Array.from(document.querySelectorAll("button"))
+      .find((button) => button.textContent?.trim() === "Retry update")?.click()
+    await flushAsync()
+
+    expect(providerUpdateStreaming).toHaveBeenCalledTimes(2)
+    expect(providerList).toHaveBeenCalled()
+    expect(document.body.textContent).not.toContain("Update failed")
+    unmount()
+  })
+
+  it("finishes the provider that started the update after navigation", async () => {
+    const { rerender, unmount } = render(ProviderSheet, {
+      props: { provider: makeProvider("ssh"), open: true },
+    })
+    await flushAsync()
+    Array.from(document.querySelectorAll("button"))
+      .find((button) => button.textContent?.trim() === "Update")?.click()
+    await tick()
+    const dialog = Array.from(document.querySelectorAll("[role='dialog']")).find(
+      (node) => node.textContent?.includes("Update 'ssh' to 0.2.0"),
+    )
+    Array.from(dialog?.querySelectorAll("button") ?? [])
+      .find((button) => button.textContent?.trim() === "Update")?.click()
+    await flushAsync()
+
+    await rerender({ provider: makeProvider("docker"), open: true })
+    await flushAsync()
+    progressCallback?.({
+      commandId: "update-command-1",
+      message: "ssh update complete",
+      success: true,
+      done: true,
+    })
+    await flushAsync()
+
+    expect(loadVersionsFor).toHaveBeenCalledWith("ssh")
+    expect(document.body.textContent).not.toContain("ssh update complete")
+    expect(document.body.textContent).not.toContain("Updated docker")
+    unmount()
+  })
+
+  it("shows refresh recovery when post-update synchronization fails", async () => {
+    providerList.mockRejectedValueOnce(new Error("list unavailable"))
+    const { unmount } = render(ProviderSheet, {
+      props: { provider: makeProvider("ssh"), open: true },
+    })
+    await flushAsync()
+    Array.from(document.querySelectorAll("button"))
+      .find((button) => button.textContent?.trim() === "Update")?.click()
+    await tick()
+    const dialog = Array.from(document.querySelectorAll("[role='dialog']")).find(
+      (node) => node.textContent?.includes("Update 'ssh' to 0.2.0"),
+    )
+    Array.from(dialog?.querySelectorAll("button") ?? [])
+      .find((button) => button.textContent?.trim() === "Update")?.click()
+    await flushAsync()
+    progressCallback?.({
+      commandId: "update-command-1",
+      success: true,
+      done: true,
+    })
+    await flushAsync()
+
+    expect(document.body.textContent).toContain("Status may be out of date")
+    expect(document.body.textContent).toContain("list unavailable")
+    expect(document.body.textContent).toContain("Refresh status")
+    expect(document.body.textContent).not.toContain("ssh is ready to use")
+    unmount()
+  })
+
+  it("hydrates update failure recovery from the provider job store", async () => {
+    providerJobsBox.store.set({
+      ssh: {
+        activity: "updating",
+        phase: "failed",
+        state: "failed",
+        error: "The download timed out.",
+        errorCode: "NETWORK",
+        logs: ["download: connection timed out"],
+      },
+    })
+    const { unmount } = render(ProviderSheet, {
+      props: { provider: makeProvider("ssh"), open: true },
+    })
+    await flushAsync()
+
+    expect(document.body.textContent).toContain("Update failed")
+    expect(document.body.textContent).toContain("The download timed out.")
+    expect(document.body.textContent).toContain("Retry update")
+    expect(document.body.textContent).toContain("download: connection timed out")
+    unmount()
+  })
+
+
+  it("refreshes provider state without repeating a completed update", async () => {
+    providerJobsBox.store.set({
+      ssh: {
+        activity: "updating",
+        phase: "failed",
+        state: "failed",
+        error: "The provider updated, but its current state could not be refreshed.",
+        errorCode: "provider_refresh_failed",
+        logs: ["Provider update complete"],
+      },
+    })
+    const { unmount } = render(ProviderSheet, {
+      props: { provider: makeProvider("ssh"), open: true },
+    })
+    await flushAsync()
+
+    expect(document.body.textContent).toContain("Status may be out of date")
+    expect(document.body.textContent).toContain("Provider update complete")
+    expect(document.body.textContent).not.toContain("Retry update")
+    Array.from(document.querySelectorAll("button"))
+      .find((button) => button.textContent?.trim() === "Refresh status")?.click()
+    await flushAsync()
+    expect(providerRefreshState).toHaveBeenCalledWith("ssh")
+    expect(providerList).toHaveBeenCalled()
+    expect(loadVersionsFor).toHaveBeenCalledWith("ssh")
+    expect(refreshUpdates).toHaveBeenCalled()
+    expect(providerUpdateStreaming).not.toHaveBeenCalled()
+    expect(document.body.textContent).not.toContain("Status may be out of date")
+    unmount()
+  })
+
+  it("keeps refresh recovery visible when version synchronization still fails", async () => {
+    providerJobsBox.store.set({
+      ssh: {
+        activity: "updating",
+        phase: "failed",
+        state: "failed",
+        error: "The provider updated, but its current state could not be refreshed.",
+        errorCode: "provider_refresh_failed",
+        logs: ["Provider update complete"],
+      },
+    })
+    const { unmount } = render(ProviderSheet, {
+      props: { provider: makeProvider("ssh"), open: true },
+    })
+    await flushAsync()
+    loadVersionsFor.mockRejectedValueOnce(new Error("versions unavailable"))
+
+    Array.from(document.querySelectorAll("button"))
+      .find((button) => button.textContent?.trim() === "Refresh status")?.click()
+    await flushAsync()
+
+    expect(providerRefreshState).toHaveBeenCalledWith("ssh")
+    expect(loadVersionsFor).toHaveBeenCalledWith("ssh")
+    expect(document.body.textContent).toContain("Status may be out of date")
+    expect(document.body.textContent).toContain("versions unavailable")
+    expect(document.body.textContent).toContain("Refresh status")
+    unmount()
+  })
+
 })
diff --git a/desktop/src/renderer/src/lib/components/provider/UpdateConfirmDialog.svelte b/desktop/src/renderer/src/lib/components/provider/UpdateConfirmDialog.svelte
index 2e24dcd89..5fe4c6012 100644
--- a/desktop/src/renderer/src/lib/components/provider/UpdateConfirmDialog.svelte
+++ b/desktop/src/renderer/src/lib/components/provider/UpdateConfirmDialog.svelte
@@ -30,15 +30,15 @@ let title = $derived.by(() => {
 
 let description = $derived.by(() => {
   if (alreadyLatest) {
-    return `${providerName} is already on ${currentVersion}. Updating will re-fetch the same version.`
+    return `${providerName} is already on ${currentVersion}. Updating will re-fetch and re-initialize the same version.`
   }
   if (currentVersion && latestVersion) {
-    return `This will update ${providerName} from ${currentVersion} to ${latestVersion}.`
+    return `This will update ${providerName} from ${currentVersion} to ${latestVersion}, then re-initialize it.`
   }
   if (currentVersion) {
-    return `Currently on ${currentVersion}. The latest version isn't available — this will run the provider's update command.`
+    return `Currently on ${currentVersion}. DevSy could not determine the latest version. This update will re-fetch and re-initialize the provider.`
   }
-  return "Check for and install the latest version."
+  return "Check for and install the latest version, then re-initialize the provider."
 })
 </script>
 
diff --git a/desktop/src/renderer/src/lib/ipc/commands.ts b/desktop/src/renderer/src/lib/ipc/commands.ts
index d735341f1..24cd60ff4 100644
--- a/desktop/src/renderer/src/lib/ipc/commands.ts
+++ b/desktop/src/renderer/src/lib/ipc/commands.ts
@@ -166,8 +166,12 @@ export async function providerReleaseJob(name: string): Promise<void> {
   return invoke<void>("provider_release_job", { name })
 }
 
-export async function providerUpdate(name: string): Promise<void> {
-  return invoke("provider_update", { name })
+export async function providerUpdateStreaming(name: string): Promise<string> {
+  return invoke<string>("provider_update_streaming", { name })
+}
+
+export async function providerRefreshState(name: string): Promise<void> {
+  unwrapEnvelope(await invoke<CommandEnvelope>("provider_refresh_state", { name }))
 }
 
 export async function providerOptions(
@@ -208,6 +212,13 @@ export async function providerCheckUpdates() {
   return invoke<Record<string, ProviderVersionCheckResult>>("provider_check_updates")
 }
 
+export async function providerGetUpdateCache() {
+  return invoke<{
+    updates: Record<string, ProviderVersionCheckResult>
+    lastCheckedAt: string | null
+  }>("provider_get_update_cache")
+}
+
 // Image catalog commands
 export async function imageCatalogGet(): Promise<LoadCatalogResult> {
   return invoke<LoadCatalogResult>("image_catalog_get")
diff --git a/desktop/src/renderer/src/lib/ipc/mock.ts b/desktop/src/renderer/src/lib/ipc/mock.ts
index aebe97087..e2f6ab33b 100644
--- a/desktop/src/renderer/src/lib/ipc/mock.ts
+++ b/desktop/src/renderer/src/lib/ipc/mock.ts
@@ -196,6 +196,9 @@ const COMMANDS: Record<string, Handler> = {
   provider_delete: () => undefined,
   provider_use: () => undefined,
   provider_update: () => undefined,
+  provider_update_streaming: () => `mock-provider-update-${Date.now()}`,
+  provider_refresh_state: () => ({ ok: true }),
+  provider_get_update_cache: () => ({ updates: {}, lastCheckedAt: hourAgo }),
   provider_options: () => PROVIDER_OPTIONS,
   provider_set_options: () => undefined,
   provider_release_job: () => undefined,
diff --git a/desktop/src/renderer/src/lib/stores/providerVersions.test.ts b/desktop/src/renderer/src/lib/stores/providerVersions.test.ts
index de6587dd3..b7e8818e9 100644
--- a/desktop/src/renderer/src/lib/stores/providerVersions.test.ts
+++ b/desktop/src/renderer/src/lib/stores/providerVersions.test.ts
@@ -3,14 +3,17 @@ import { beforeEach, describe, expect, it, vi } from "vitest"
 
 vi.mock("$lib/ipc/commands.js", () => ({
   providerListVersions: vi.fn(),
+  providerGetUpdateCache: vi.fn(),
   providerCheckUpdates: vi.fn(),
 }))
 
 import {
   providerCheckUpdates,
+  providerGetUpdateCache,
   providerListVersions,
 } from "$lib/ipc/commands.js"
 import {
+  loadCachedUpdates,
   loadVersionsFor,
   providerVersions,
   refreshUpdates,
@@ -38,6 +41,59 @@ describe("providerVersions store", () => {
     expect(state.lastCheckedAt).not.toBeNull()
   })
 
+  it("renders cached results before a live refresh", async () => {
+    vi.mocked(providerGetUpdateCache).mockResolvedValue({
+      updates: {
+        docker: {
+          current: "v1.0",
+          latest: "v1.1",
+          updateAvailable: true,
+          unsupported: false,
+        },
+      },
+      lastCheckedAt: "2026-09-21T17:00:00.000Z",
+    })
+
+    await loadCachedUpdates()
+
+    const state = get(providerVersions)
+    expect(state.updates.docker.latest).toBe("v1.1")
+    expect(state.lastCheckedAt?.toISOString()).toBe("2026-09-21T17:00:00.000Z")
+  })
+
+  it("keeps cached results and exposes partial check failures", async () => {
+    vi.mocked(providerGetUpdateCache).mockResolvedValue({
+      updates: {
+        docker: {
+          current: "v1.0",
+          latest: "v1.1",
+          updateAvailable: true,
+          unsupported: false,
+        },
+      },
+      lastCheckedAt: "2026-09-21T17:00:00.000Z",
+    })
+    await loadCachedUpdates()
+    vi.mocked(providerCheckUpdates).mockResolvedValue({
+      docker: {
+        current: "v1.0",
+        latest: "",
+        updateAvailable: false,
+        unsupported: false,
+        error: "network unavailable",
+      },
+    })
+
+    await refreshUpdates()
+
+    const state = get(providerVersions)
+    expect(state.updates.docker.latest).toBe("v1.1")
+    expect(state.updates.docker.updateAvailable).toBe(true)
+    expect(state.updates.docker.error).toBe("network unavailable")
+    expect(state.refreshError).toBe("One provider update check failed.")
+    expect(state.refreshing).toBe(false)
+  })
+
   it("populates byProvider via loadVersionsFor", async () => {
     vi.mocked(providerListVersions).mockResolvedValue({
       versions: [
diff --git a/desktop/src/renderer/src/lib/stores/providerVersions.ts b/desktop/src/renderer/src/lib/stores/providerVersions.ts
index 4279f237a..b040163d0 100644
--- a/desktop/src/renderer/src/lib/stores/providerVersions.ts
+++ b/desktop/src/renderer/src/lib/stores/providerVersions.ts
@@ -1,6 +1,7 @@
 import { writable } from "svelte/store"
 import {
   providerCheckUpdates,
+  providerGetUpdateCache,
   providerListVersions,
 } from "$lib/ipc/commands.js"
 import type {
@@ -15,21 +16,64 @@ type State = {
   >
   updates: Record<string, ProviderVersionCheckResult>
   lastCheckedAt: Date | null
+  refreshing: boolean
+  refreshError: string | null
 }
 
 const initial: State = {
   byProvider: {},
   updates: {},
   lastCheckedAt: null,
+  refreshing: false,
+  refreshError: null,
 }
 
 const internal = writable<State>(initial)
 
 export const providerVersions = { subscribe: internal.subscribe }
 
+export async function loadCachedUpdates(): Promise<void> {
+  const cached = await providerGetUpdateCache()
+  internal.update((s) => ({
+    ...s,
+    updates: cached.updates,
+    lastCheckedAt: cached.lastCheckedAt ? new Date(cached.lastCheckedAt) : null,
+  }))
+}
+
 export async function refreshUpdates(): Promise<void> {
-  const updates = await providerCheckUpdates()
-  internal.update((s) => ({ ...s, updates, lastCheckedAt: new Date() }))
+  internal.update((s) => ({ ...s, refreshing: true, refreshError: null }))
+  try {
+    const updates = await providerCheckUpdates()
+    const failed = Object.values(updates).filter((result) => result.error).length
+    internal.update((s) => {
+      const merged = { ...s.updates }
+      for (const [name, result] of Object.entries(updates)) {
+        merged[name] = result.error && s.updates[name]
+          ? { ...s.updates[name], error: result.error }
+          : result
+      }
+      return {
+        ...s,
+        updates: merged,
+        lastCheckedAt: new Date(),
+        refreshing: false,
+        refreshError:
+          failed === 0
+            ? null
+            : failed === 1
+              ? "One provider update check failed."
+              : `${failed} provider update checks failed.`,
+      }
+    })
+  } catch (error) {
+    internal.update((s) => ({
+      ...s,
+      refreshing: false,
+      refreshError: error instanceof Error ? error.message : String(error),
+    }))
+    throw error
+  }
 }
 
 export async function loadVersionsFor(name: string): Promise<void> {
diff --git a/desktop/src/renderer/src/lib/types/index.ts b/desktop/src/renderer/src/lib/types/index.ts
index 1e7efd3bf..5f1341a75 100644
--- a/desktop/src/renderer/src/lib/types/index.ts
+++ b/desktop/src/renderer/src/lib/types/index.ts
@@ -104,6 +104,7 @@ export interface ProviderJob {
   errorCode?: string
   errorHint?: string
   errorContext?: Record<string, string>
+  logs?: string[]
 }
 
 export type { WorkspaceJob } from "$shared/workspace-operation.js"
diff --git a/desktop/src/renderer/src/pages/ProvidersPage.svelte b/desktop/src/renderer/src/pages/ProvidersPage.svelte
index b087234c7..30b195d24 100644
--- a/desktop/src/renderer/src/pages/ProvidersPage.svelte
+++ b/desktop/src/renderer/src/pages/ProvidersPage.svelte
@@ -1,9 +1,11 @@
 <script lang="ts">
 import {
+  AlertCircle,
   ArrowDownAZ,
   ChevronsUpDown,
   Hash,
   Plug,
+  RefreshCw,
   SearchX,
 } from "@lucide/svelte"
 import { onMount } from "svelte"
@@ -15,7 +17,11 @@ import CardSkeleton from "$lib/components/ui/skeleton/CardSkeleton.svelte"
 import ProviderCard from "$lib/components/provider/ProviderCard.svelte"
 import ProviderSheet from "$lib/components/provider/ProviderSheet.svelte"
 import { providers, providersLoading } from "$lib/stores/providers.js"
-import { refreshUpdates } from "$lib/stores/providerVersions.js"
+import {
+  loadCachedUpdates,
+  providerVersions,
+  refreshUpdates,
+} from "$lib/stores/providerVersions.js"
 
 let { params = {} }: { params?: Record<string, string> } = $props()
 
@@ -34,10 +40,19 @@ function closeSheet() {
   if (activeId) goto("/providers")
 }
 
-onMount(() => {
-  refreshUpdates().catch(() => {})
+onMount(async () => {
+  await loadCachedUpdates().catch(() => undefined)
+  await refreshUpdates().catch(() => undefined)
 })
 
+function checkedLabel(checkedAt: Date | null): string {
+  if (!checkedAt) return "Updates not checked yet"
+  return `Last checked ${checkedAt.toLocaleTimeString([], {
+    hour: "numeric",
+    minute: "2-digit",
+  })}`
+}
+
 let filtered = $derived.by(() => {
   const q = search.toLowerCase()
   let list = $providers.filter((p) => {
@@ -65,6 +80,27 @@ let filtered = $derived.by(() => {
     <Button onclick={() => goto("/providers/add")}>Add Provider</Button>
   </div>
 
+  <div class="flex flex-wrap items-center gap-2 rounded-md border bg-muted/20 px-3 py-2" role="status">
+    <div class="min-w-0 flex-1 text-sm">
+      <div class="text-muted-foreground">{checkedLabel($providerVersions.lastCheckedAt)}</div>
+      {#if $providerVersions.refreshError}
+        <div class="mt-0.5 flex items-center gap-1 text-destructive">
+          <AlertCircle class="size-3.5 shrink-0" />
+          <span>DevSy could not check for updates. Cached results may be out of date.</span>
+        </div>
+      {/if}
+    </div>
+    <Button
+      variant="outline"
+      size="sm"
+      onclick={() => refreshUpdates().catch(() => undefined)}
+      disabled={$providerVersions.refreshing}
+    >
+      <RefreshCw class={$providerVersions.refreshing ? "mr-2 size-4 animate-spin" : "mr-2 size-4"} />
+      {$providerVersions.refreshing ? "Checking..." : "Check now"}
+    </Button>
+  </div>
+
   <div class="flex gap-2">
     <Input
       placeholder="Search by name, description, version..."