diff --git a/src/components/sidebar/tabs/modelLibrary/DownloadItem.vue b/src/components/sidebar/tabs/modelLibrary/DownloadItem.vue
index 6f855ede17..a121b5d8f5 100644
--- a/src/components/sidebar/tabs/modelLibrary/DownloadItem.vue
+++ b/src/components/sidebar/tabs/modelLibrary/DownloadItem.vue
@@ -3,7 +3,7 @@
     <div>
       {{ getDownloadLabel(download.savePath ?? '') }}
     </div>
-    <div v-if="['cancelled', 'error'].includes(download.status ?? '')">
+    <div v-if="['cancelled', 'failed'].includes(download.status)">
       <Chip
         class="mt-2 h-6 bg-red-700 text-sm font-light"
         removable
@@ -14,7 +14,7 @@
     </div>
     <div
       v-if="
-        ['in_progress', 'paused', 'completed'].includes(download.status ?? '')
+        ['created', 'running', 'paused', 'completed'].includes(download.status)
       "
       class="mt-2 flex flex-row items-center gap-2"
     >
@@ -28,7 +28,7 @@
       />
 
       <Button
-        v-if="download.status === 'in_progress'"
+        v-if="download.status === 'running'"
         v-tooltip.top="t('electronFileDownload.pause')"
         class="size-[22px] rounded-full"
         variant="secondary"
@@ -52,7 +52,7 @@
       </Button>
 
       <Button
-        v-if="['in_progress', 'paused'].includes(download.status ?? '')"
+        v-if="['running', 'paused'].includes(download.status)"
         v-tooltip.top="t('electronFileDownload.cancel')"
         class="size-[22px] rounded-full"
         variant="destructive"
diff --git a/src/platform/downloads/types.ts b/src/platform/downloads/types.ts
new file mode 100644
index 0000000000..8bee4bb14a
--- /dev/null
+++ b/src/platform/downloads/types.ts
@@ -0,0 +1,13 @@
+export type DownloadLifecycleStatus =
+  | 'created'
+  | 'running'
+  | 'paused'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+
+export interface DownloadLifecycleState {
+  progress: number
+  status: DownloadLifecycleStatus
+  error?: string
+}
diff --git a/src/platform/missingModel/components/MissingModelRow.test.ts b/src/platform/missingModel/components/MissingModelRow.test.ts
new file mode 100644
index 0000000000..d62756ba1e
--- /dev/null
+++ b/src/platform/missingModel/components/MissingModelRow.test.ts
@@ -0,0 +1,246 @@
+import { render, screen } from '@testing-library/vue'
+import userEvent from '@testing-library/user-event'
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createI18n } from 'vue-i18n'
+
+import type { MissingModelViewModel } from '@/platform/missingModel/types'
+import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
+
+const mockDownloadModel = vi.hoisted(() => vi.fn())
+const mockFetchModelMetadata = vi.hoisted(() => vi.fn())
+const mockCopyToClipboard = vi.hoisted(() => vi.fn())
+
+vi.mock('@/platform/distribution/types', () => ({
+  isCloud: false
+}))
+
+vi.mock('@/scripts/app', () => ({
+  app: {
+    rootGraph: null
+  }
+}))
+
+vi.mock('@/renderer/core/canvas/canvasStore', () => ({
+  useCanvasStore: () => ({})
+}))
+
+vi.mock('@/composables/useCopyToClipboard', () => ({
+  useCopyToClipboard: () => ({
+    copyToClipboard: mockCopyToClipboard
+  })
+}))
+
+vi.mock('@/components/rightSidePanel/layout/TransitionCollapse.vue', () => ({
+  default: {
+    name: 'TransitionCollapse',
+    template: '<div><slot /></div>'
+  }
+}))
+
+vi.mock(
+  '@/platform/missingModel/components/MissingModelStatusCard.vue',
+  () => ({
+    default: {
+      name: 'MissingModelStatusCard',
+      props: ['downloadStatus'],
+      template:
+        '<div data-testid="missing-model-status-card">{{ downloadStatus?.status ?? "none" }}</div>'
+    }
+  })
+)
+
+vi.mock('@/platform/missingModel/components/MissingModelUrlInput.vue', () => ({
+  default: {
+    name: 'MissingModelUrlInput',
+    template: '<div data-testid="missing-model-url-input" />'
+  }
+}))
+
+vi.mock(
+  '@/platform/missingModel/components/MissingModelLibrarySelect.vue',
+  () => ({
+    default: {
+      name: 'MissingModelLibrarySelect',
+      emits: ['select'],
+      template:
+        '<button data-testid="missing-model-library-select" @click="$emit(\'select\', \'library-model.safetensors\')">Select</button>'
+    }
+  })
+)
+
+vi.mock(
+  '@/platform/missingModel/composables/useMissingModelInteractions',
+  () => ({
+    getModelStateKey: (
+      modelName: string,
+      directory: string | null,
+      isAssetSupported: boolean
+    ) =>
+      `${isAssetSupported ? 'supported' : 'unsupported'}::${directory ?? ''}::${modelName}`,
+    getNodeDisplayLabel: (nodeId: string | number) => `Node ${nodeId}`,
+    getComboValue: () => undefined,
+    useMissingModelInteractions: () => {
+      const store = useMissingModelStore()
+
+      return {
+        toggleModelExpand: vi.fn(),
+        isModelExpanded: () => false,
+        getComboOptions: () => [],
+        handleComboSelect: (key: string, value: string | undefined) => {
+          if (value) {
+            store.selectedLibraryModel[key] = value
+          }
+        },
+        isSelectionConfirmable: () => false,
+        cancelLibrarySelect: vi.fn(),
+        confirmLibrarySelect: vi.fn(),
+        getTypeMismatch: () => null,
+        getDownloadStatus: (key: string) =>
+          store.downloadRefs[key]?.kind === 'electron-download'
+            ? { progress: 0, status: 'created' as const }
+            : null
+      }
+    }
+  })
+)
+
+vi.mock('@/platform/missingModel/missingModelDownload', () => ({
+  downloadModel: (...args: unknown[]) => mockDownloadModel(...args),
+  fetchModelMetadata: (...args: unknown[]) => mockFetchModelMetadata(...args),
+  isModelDownloadable: () => true,
+  toBrowsableUrl: (url: string) => url
+}))
+
+import MissingModelRow from './MissingModelRow.vue'
+
+const i18n = createI18n({
+  legacy: false,
+  locale: 'en',
+  messages: {
+    en: {
+      g: {
+        download: 'Download'
+      },
+      rightSidePanel: {
+        missingModels: {
+          copyModelName: 'Copy model name',
+          copyUrl: 'Copy URL',
+          confirmSelection: 'Confirm selection',
+          collapseNodes: 'Collapse nodes',
+          expandNodes: 'Expand nodes'
+        }
+      }
+    }
+  },
+  missingWarn: false,
+  fallbackWarn: false
+})
+
+const model: MissingModelViewModel = {
+  name: 'z_image_turbo_bf16.safetensors',
+  representative: {
+    name: 'z_image_turbo_bf16.safetensors',
+    url: 'https://example.com/z_image_turbo_bf16.safetensors',
+    directory: 'checkpoints',
+    nodeId: '1',
+    nodeType: 'CheckpointLoaderSimple',
+    widgetName: 'ckpt_name',
+    isAssetSupported: false,
+    isMissing: true
+  },
+  referencingNodes: [{ nodeId: '1', widgetName: 'ckpt_name' }]
+}
+
+const modelKey = 'unsupported::checkpoints::z_image_turbo_bf16.safetensors'
+
+function renderComponent() {
+  return render(MissingModelRow, {
+    props: {
+      model,
+      directory: 'checkpoints',
+      showNodeIdBadge: false,
+      isAssetSupported: false
+    },
+    global: {
+      plugins: [i18n]
+    }
+  })
+}
+
+describe('MissingModelRow', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    mockDownloadModel.mockReset()
+    mockDownloadModel.mockResolvedValue(true)
+    mockFetchModelMetadata.mockReset()
+    mockFetchModelMetadata.mockResolvedValue({
+      fileSize: null,
+      gatedRepoUrl: null
+    })
+    mockCopyToClipboard.mockReset()
+
+    const store = useMissingModelStore()
+    store.folderPaths = {
+      checkpoints: ['/models/checkpoints']
+    }
+  })
+
+  it('tracks and surfaces direct Electron downloads immediately after the button is clicked', async () => {
+    const user = userEvent.setup()
+    const store = useMissingModelStore()
+    renderComponent()
+
+    await user.click(screen.getByTestId('missing-model-download'))
+
+    expect(mockDownloadModel).toHaveBeenCalledWith(
+      {
+        name: model.representative.name,
+        url: model.representative.url,
+        directory: model.representative.directory
+      },
+      store.folderPaths
+    )
+    expect(store.downloadRefs[modelKey]).toEqual({
+      kind: 'electron-download',
+      url: model.representative.url
+    })
+    expect(store.selectedLibraryModel[modelKey]).toBe(model.representative.name)
+    expect(screen.getByTestId('missing-model-status-card')).toHaveTextContent(
+      'created'
+    )
+  })
+
+  it('does not create UI state when the Electron download does not start', async () => {
+    mockDownloadModel.mockResolvedValue(false)
+    const user = userEvent.setup()
+    const store = useMissingModelStore()
+    renderComponent()
+
+    await user.click(screen.getByTestId('missing-model-download'))
+
+    expect(store.downloadRefs[modelKey]).toBeUndefined()
+    expect(store.selectedLibraryModel[modelKey]).toBeUndefined()
+    expect(
+      screen.queryByTestId('missing-model-status-card')
+    ).not.toBeInTheDocument()
+  })
+
+  it('clears stale download refs when the user picks a library alternative', async () => {
+    const user = userEvent.setup()
+    const store = useMissingModelStore()
+    store.downloadRefs[modelKey] = {
+      kind: 'electron-download',
+      url: model.representative.url!
+    }
+
+    renderComponent()
+
+    await user.click(screen.getByTestId('missing-model-library-select'))
+
+    expect(store.downloadRefs[modelKey]).toBeUndefined()
+    expect(store.selectedLibraryModel[modelKey]).toBe(
+      'library-model.safetensors'
+    )
+  })
+})
diff --git a/src/platform/missingModel/components/MissingModelRow.vue b/src/platform/missingModel/components/MissingModelRow.vue
index a39e92652d..f941725776 100644
--- a/src/platform/missingModel/components/MissingModelRow.vue
+++ b/src/platform/missingModel/components/MissingModelRow.vue
@@ -175,7 +175,7 @@
             :model-value="getComboValue(model.representative)"
             :options="comboOptions"
             :show-divider="isAssetSupported || downloadable"
-            @select="handleComboSelect(modelKey, $event)"
+            @select="handleLibraryModelSelect"
           />
         </TransitionCollapse>
       </div>
@@ -284,18 +284,31 @@ const downloadLabel = computed(() => {
   return size ? `${base} (${formatSize(size)})` : base
 })
 
-function handleDownload() {
+async function handleDownload() {
   const rep = model.representative
   if (rep.url && rep.directory) {
-    downloadModel(
+    const started = await downloadModel(
       { name: rep.name, url: rep.url, directory: rep.directory },
       store.folderPaths
     )
+
+    if (started) {
+      store.downloadRefs[modelKey.value] = {
+        kind: 'electron-download',
+        url: rep.url
+      }
+      handleComboSelect(modelKey.value, rep.name)
+    }
   } else {
     console.warn('[MissingModelRow] Cannot download: missing url or directory')
   }
 }
 
+function handleLibraryModelSelect(value: string | undefined) {
+  delete store.downloadRefs[modelKey.value]
+  handleComboSelect(modelKey.value, value)
+}
+
 const {
   toggleModelExpand,
   isModelExpanded,
diff --git a/src/platform/missingModel/components/MissingModelStatusCard.vue b/src/platform/missingModel/components/MissingModelStatusCard.vue
index 7c41445675..8b89001dd3 100644
--- a/src/platform/missingModel/components/MissingModelStatusCard.vue
+++ b/src/platform/missingModel/components/MissingModelStatusCard.vue
@@ -22,11 +22,21 @@
           aria-hidden="true"
           class="icon-[lucide--circle-alert] size-5 text-destructive-background"
         />
+        <i
+          v-else-if="downloadStatus?.status === 'cancelled'"
+          aria-hidden="true"
+          class="icon-[lucide--circle-x] size-5 text-destructive-background"
+        />
         <i
           v-else-if="downloadStatus?.status === 'completed'"
           aria-hidden="true"
           class="icon-[lucide--check-circle] size-5 text-success-background"
         />
+        <i
+          v-else-if="downloadStatus?.status === 'paused'"
+          aria-hidden="true"
+          class="icon-[lucide--pause-circle] size-5 text-muted-foreground"
+        />
         <i
           v-else-if="isDownloadActive"
           aria-hidden="true"
@@ -58,6 +68,13 @@
           <template v-else-if="downloadStatus?.status === 'completed'">
             {{ t('rightSidePanel.missingModels.imported') }}
           </template>
+          <template v-else-if="downloadStatus?.status === 'paused'">
+            {{ t('electronFileDownload.paused') }}
+            {{ Math.round((downloadStatus?.progress ?? 0) * 100) }}%
+          </template>
+          <template v-else-if="downloadStatus?.status === 'cancelled'">
+            {{ t('electronFileDownload.cancelled') }}
+          </template>
           <template v-else-if="downloadStatus?.status === 'failed'">
             {{
               downloadStatus?.error ||
@@ -86,7 +103,7 @@
 <script setup lang="ts">
 import { useI18n } from 'vue-i18n'
 import Button from '@/components/ui/button/Button.vue'
-import type { AssetDownload } from '@/stores/assetDownloadStore'
+import type { MissingModelDownloadStatus } from '@/platform/missingModel/types'
 
 const {
   modelName,
@@ -96,7 +113,7 @@ const {
 } = defineProps<{
   modelName: string
   isDownloadActive: boolean
-  downloadStatus?: AssetDownload | null
+  downloadStatus?: MissingModelDownloadStatus | null
   categoryMismatch?: string | null
 }>()
 
diff --git a/src/platform/missingModel/composables/useMissingModelInteractions.test.ts b/src/platform/missingModel/composables/useMissingModelInteractions.test.ts
index 2a614751ba..05dcf13991 100644
--- a/src/platform/missingModel/composables/useMissingModelInteractions.test.ts
+++ b/src/platform/missingModel/composables/useMissingModelInteractions.test.ts
@@ -15,8 +15,14 @@ const mockGetAssetFilename = vi.fn((a: { name: string }) => a.name)
 const mockGetAssets = vi.fn()
 const mockUpdateModelsForNodeType = vi.fn()
 const mockGetAllNodeProviders = vi.fn()
+const mockFindElectronDownloadByUrl = vi.fn()
 const mockDownloadList = vi.fn(
-  (): Array<{ taskId: string; status: string }> => []
+  (): Array<{
+    taskId: string
+    status: string
+    progress?: number
+    error?: string
+  }> => []
 )
 
 vi.mock('@/i18n', () => ({
@@ -24,7 +30,8 @@ vi.mock('@/i18n', () => ({
 }))
 
 vi.mock('@/platform/distribution/types', () => ({
-  isCloud: false
+  isCloud: false,
+  isDesktop: false
 }))
 
 vi.mock('vue-i18n', () => ({
@@ -71,6 +78,12 @@ vi.mock('@/stores/assetDownloadStore', () => ({
   })
 }))
 
+vi.mock('@/stores/electronDownloadStore', () => ({
+  useElectronDownloadStore: () => ({
+    findByUrl: (...args: unknown[]) => mockFindElectronDownloadByUrl(...args)
+  })
+}))
+
 vi.mock('@/stores/modelToNodeStore', () => ({
   useModelToNodeStore: () => ({
     getAllNodeProviders: mockGetAllNodeProviders
@@ -141,6 +154,8 @@ describe('useMissingModelInteractions', () => {
     mockDownloadList.mockImplementation(
       (): Array<{ taskId: string; status: string }> => []
     )
+    mockFindElectronDownloadByUrl.mockReset()
+    mockFindElectronDownloadByUrl.mockReturnValue(null)
     ;(app as { rootGraph: unknown }).rootGraph = null
   })
 
@@ -285,7 +300,7 @@ describe('useMissingModelInteractions', () => {
     it('returns false when download is running', () => {
       const store = useMissingModelStore()
       store.selectedLibraryModel['key1'] = 'model.safetensors'
-      store.importTaskIds['key1'] = 'task-123'
+      store.downloadRefs['key1'] = { kind: 'asset-import', taskId: 'task-123' }
       mockDownloadList.mockReturnValue([
         { taskId: 'task-123', status: 'running' }
       ])
@@ -311,19 +326,103 @@ describe('useMissingModelInteractions', () => {
       const { isSelectionConfirmable } = useMissingModelInteractions()
       expect(isSelectionConfirmable('key1')).toBe(true)
     })
+
+    it('returns true when a tracked download is completed', () => {
+      const store = useMissingModelStore()
+      store.selectedLibraryModel['key1'] = 'model.safetensors'
+      store.downloadRefs['key1'] = {
+        kind: 'electron-download',
+        url: 'https://example.com/model.safetensors'
+      }
+      mockFindElectronDownloadByUrl.mockReturnValue({
+        progress: 1,
+        status: 'completed'
+      })
+
+      const { isSelectionConfirmable } = useMissingModelInteractions()
+      expect(isSelectionConfirmable('key1')).toBe(true)
+    })
+
+    it('returns false when a tracked download failed', () => {
+      const store = useMissingModelStore()
+      store.selectedLibraryModel['key1'] = 'model.safetensors'
+      store.downloadRefs['key1'] = {
+        kind: 'electron-download',
+        url: 'https://example.com/model.safetensors'
+      }
+      mockFindElectronDownloadByUrl.mockReturnValue({
+        progress: 0.3,
+        status: 'failed'
+      })
+
+      const { isSelectionConfirmable } = useMissingModelInteractions()
+      expect(isSelectionConfirmable('key1')).toBe(false)
+    })
+  })
+
+  describe('getDownloadStatus', () => {
+    it('returns the tracked asset import status for asset-import refs', () => {
+      const store = useMissingModelStore()
+      store.downloadRefs['key1'] = { kind: 'asset-import', taskId: 'task-123' }
+      mockDownloadList.mockReturnValue([
+        {
+          taskId: 'task-123',
+          status: 'running',
+          progress: 0.5,
+          error: undefined
+        }
+      ])
+
+      const { getDownloadStatus } = useMissingModelInteractions()
+      expect(getDownloadStatus('key1')).toEqual({
+        progress: 0.5,
+        status: 'running',
+        error: undefined
+      })
+    })
+
+    it('returns the tracked Electron download status for electron refs', () => {
+      const store = useMissingModelStore()
+      store.downloadRefs['key1'] = {
+        kind: 'electron-download',
+        url: 'https://example.com/model.safetensors'
+      }
+      mockFindElectronDownloadByUrl.mockReturnValue({
+        progress: 0.4,
+        status: 'paused',
+        error: 'network stalled'
+      })
+
+      const { getDownloadStatus } = useMissingModelInteractions()
+      expect(getDownloadStatus('key1')).toEqual({
+        progress: 0.4,
+        status: 'paused',
+        error: 'network stalled'
+      })
+    })
+
+    it('returns null when no tracked download ref exists', () => {
+      const { getDownloadStatus } = useMissingModelInteractions()
+      expect(getDownloadStatus('key1')).toBeNull()
+    })
   })
 
   describe('cancelLibrarySelect', () => {
-    it('clears selectedLibraryModel and importCategoryMismatch', () => {
+    it('clears selectedLibraryModel, importCategoryMismatch, and download refs', () => {
       const store = useMissingModelStore()
       store.selectedLibraryModel['key1'] = 'model.safetensors'
       store.importCategoryMismatch['key1'] = 'loras'
+      store.downloadRefs['key1'] = {
+        kind: 'electron-download',
+        url: 'https://example.com/model.safetensors'
+      }
 
       const { cancelLibrarySelect } = useMissingModelInteractions()
       cancelLibrarySelect('key1')
 
       expect(store.selectedLibraryModel['key1']).toBeUndefined()
       expect(store.importCategoryMismatch['key1']).toBeUndefined()
+      expect(store.downloadRefs['key1']).toBeUndefined()
     })
   })
 
@@ -347,6 +446,10 @@ describe('useMissingModelInteractions', () => {
 
       const store = useMissingModelStore()
       store.selectedLibraryModel['key1'] = 'new_model.safetensors'
+      store.downloadRefs['key1'] = {
+        kind: 'electron-download',
+        url: 'https://example.com/old_model.safetensors'
+      }
       store.setMissingModels([
         makeCandidate({ name: 'old_model.safetensors', nodeId: '10' }),
         makeCandidate({ name: 'old_model.safetensors', nodeId: '20' })
@@ -371,6 +474,7 @@ describe('useMissingModelInteractions', () => {
         'old_model.safetensors',
         new Set(['10', '20'])
       )
+      expect(store.downloadRefs['key1']).toBeUndefined()
       expect(store.selectedLibraryModel['key1']).toBeUndefined()
     })
 
@@ -568,14 +672,14 @@ describe('useMissingModelInteractions', () => {
   })
 
   describe('getDownloadStatus', () => {
-    it('returns null when no taskId is tracked for the key', () => {
+    it('returns null when no download ref is tracked for the key', () => {
       const { getDownloadStatus } = useMissingModelInteractions()
       expect(getDownloadStatus('key1')).toBeNull()
     })
 
-    it('returns the matching download record when a taskId is tracked', () => {
+    it('returns the matching download record when an asset import ref is tracked', () => {
       const store = useMissingModelStore()
-      store.importTaskIds['key1'] = 'task-42'
+      store.downloadRefs['key1'] = { kind: 'asset-import', taskId: 'task-42' }
       mockDownloadList.mockReturnValue([
         { taskId: 'task-other', status: 'running' },
         { taskId: 'task-42', status: 'created' }
@@ -583,7 +687,6 @@ describe('useMissingModelInteractions', () => {
 
       const { getDownloadStatus } = useMissingModelInteractions()
       expect(getDownloadStatus('key1')).toEqual({
-        taskId: 'task-42',
         status: 'created'
       })
     })
@@ -601,7 +704,7 @@ describe('useMissingModelInteractions', () => {
       return store
     }
 
-    it('tracks an async-pending result via importTaskIds and trackDownload', async () => {
+    it('tracks an async-pending result via download refs and trackDownload', async () => {
       const store = setupImportableState('key1')
       mockUploadAssetAsync.mockResolvedValueOnce({
         type: 'async',
@@ -611,7 +714,10 @@ describe('useMissingModelInteractions', () => {
       const { handleImport } = useMissingModelInteractions()
       await handleImport('key1', 'checkpoints')
 
-      expect(store.importTaskIds['key1']).toBe('task-99')
+      expect(store.downloadRefs['key1']).toEqual({
+        kind: 'asset-import',
+        taskId: 'task-99'
+      })
       expect(mockTrackDownload).toHaveBeenCalledWith(
         'task-99',
         'checkpoints',
diff --git a/src/platform/missingModel/composables/useMissingModelInteractions.ts b/src/platform/missingModel/composables/useMissingModelInteractions.ts
index 237c68aecd..12ada18389 100644
--- a/src/platform/missingModel/composables/useMissingModelInteractions.ts
+++ b/src/platform/missingModel/composables/useMissingModelInteractions.ts
@@ -13,11 +13,13 @@ import { validateSourceUrl } from '@/platform/assets/utils/importSourceUtil'
 import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
 import { useAssetsStore } from '@/stores/assetsStore'
 import { useAssetDownloadStore } from '@/stores/assetDownloadStore'
+import { useElectronDownloadStore } from '@/stores/electronDownloadStore'
 import { useModelToNodeStore } from '@/stores/modelToNodeStore'
 import { app } from '@/scripts/app'
 import { getNodeByExecutionId } from '@/utils/graphTraversalUtil'
 import type {
   MissingModelCandidate,
+  MissingModelDownloadStatus,
   MissingModelViewModel
 } from '@/platform/missingModel/types'
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
@@ -90,6 +92,7 @@ export function useMissingModelInteractions() {
   const store = useMissingModelStore()
   const assetsStore = useAssetsStore()
   const assetDownloadStore = useAssetDownloadStore()
+  const electronDownloadStore = useElectronDownloadStore()
   const modelToNodeStore = useModelToNodeStore()
 
   const _requestTokens: Record<string, symbol> = {}
@@ -131,18 +134,13 @@ export function useMissingModelInteractions() {
     if (store.importCategoryMismatch[key]) return false
 
     const status = getDownloadStatus(key)
-    if (
-      status &&
-      (status.status === 'running' || status.status === 'created')
-    ) {
-      return false
-    }
-    return true
+    return !status || status.status === 'completed'
   }
 
   function cancelLibrarySelect(key: string) {
     delete store.selectedLibraryModel[key]
     delete store.importCategoryMismatch[key]
+    delete store.downloadRefs[key]
   }
 
   /** Apply selected model to referencing nodes, removing only that model from the error list. */
@@ -189,6 +187,7 @@ export function useMissingModelInteractions() {
     }
 
     delete store.selectedLibraryModel[key]
+    delete store.downloadRefs[key]
     const nodeIdSet = new Set(referencingNodes.map((ref) => String(ref.nodeId)))
     store.removeMissingModelByNameOnNodes(modelName, nodeIdSet)
   }
@@ -280,12 +279,25 @@ export function useMissingModelInteractions() {
     return null
   }
 
-  function getDownloadStatus(key: string) {
-    const taskId = store.importTaskIds[key]
-    if (!taskId) return null
-    return (
-      assetDownloadStore.downloadList.find((d) => d.taskId === taskId) ?? null
-    )
+  function getDownloadStatus(key: string): MissingModelDownloadStatus | null {
+    const downloadRef = store.downloadRefs[key]
+    if (!downloadRef) return null
+
+    if (downloadRef.kind === 'asset-import') {
+      const assetDownload = assetDownloadStore.downloadList.find(
+        (download) => download.taskId === downloadRef.taskId
+      )
+
+      return assetDownload
+        ? {
+            progress: assetDownload.progress,
+            status: assetDownload.status,
+            error: assetDownload.error
+          }
+        : null
+    }
+
+    return electronDownloadStore.findByUrl(downloadRef.url) ?? null
   }
 
   function handleAsyncPending(
@@ -294,7 +306,7 @@ export function useMissingModelInteractions() {
     modelType: string | undefined,
     filename: string
   ) {
-    store.importTaskIds[key] = taskId
+    store.downloadRefs[key] = { kind: 'asset-import', taskId }
     if (modelType) {
       assetDownloadStore.trackDownload(taskId, modelType, filename)
     }
diff --git a/src/platform/missingModel/missingModelDownload.test.ts b/src/platform/missingModel/missingModelDownload.test.ts
index 4b68ea8efa..100f3dc0b5 100644
--- a/src/platform/missingModel/missingModelDownload.test.ts
+++ b/src/platform/missingModel/missingModelDownload.test.ts
@@ -1,6 +1,10 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockIsDesktop = vi.hoisted(() => ({ value: false }))
+const mockStartElectronDownload = vi.hoisted(() => vi.fn())
 
 import {
+  downloadModel,
   fetchModelMetadata,
   isModelDownloadable,
   toBrowsableUrl
@@ -9,14 +13,24 @@ import {
 const fetchMock = vi.fn()
 vi.stubGlobal('fetch', fetchMock)
 
-vi.mock('@/platform/distribution/types', () => ({ isDesktop: false }))
-vi.mock('@/stores/electronDownloadStore', () => ({}))
+vi.mock('@/platform/distribution/types', () => ({
+  get isDesktop() {
+    return mockIsDesktop.value
+  }
+}))
+vi.mock('@/stores/electronDownloadStore', () => ({
+  useElectronDownloadStore: () => ({
+    start: (...args: unknown[]) => mockStartElectronDownload(...args)
+  })
+}))
 
 let testId = 0
 
 describe('fetchModelMetadata', () => {
   beforeEach(() => {
     fetchMock.mockReset()
+    mockIsDesktop.value = false
+    mockStartElectronDownload.mockReset()
     testId++
   })
 
@@ -213,3 +227,75 @@ describe('isModelDownloadable', () => {
     ).toBe(false)
   })
 })
+
+describe('downloadModel', () => {
+  beforeEach(() => {
+    mockIsDesktop.value = false
+    mockStartElectronDownload.mockReset()
+  })
+
+  it('opens the source URL directly outside desktop builds', async () => {
+    const click = vi.fn()
+    const createElementSpy = vi
+      .spyOn(document, 'createElement')
+      .mockReturnValue({
+        click,
+        download: '',
+        href: '',
+        rel: '',
+        target: ''
+      } as unknown as HTMLAnchorElement)
+
+    const started = await downloadModel(
+      {
+        name: 'model.safetensors',
+        url: 'https://example.com/model.safetensors',
+        directory: 'checkpoints'
+      },
+      { checkpoints: ['/models/checkpoints'] }
+    )
+
+    expect(started).toBe(true)
+    expect(click).toHaveBeenCalledOnce()
+
+    createElementSpy.mockRestore()
+  })
+
+  it('starts an Electron download when a desktop save path exists', async () => {
+    mockIsDesktop.value = true
+    mockStartElectronDownload.mockResolvedValue(true)
+
+    const started = await downloadModel(
+      {
+        name: 'model.safetensors',
+        url: 'https://example.com/model.safetensors',
+        directory: 'checkpoints'
+      },
+      { checkpoints: ['/models/checkpoints'] }
+    )
+
+    expect(started).toBe(true)
+    expect(mockStartElectronDownload).toHaveBeenCalledWith({
+      url: 'https://example.com/model.safetensors',
+      savePath: '/models/checkpoints',
+      filename: 'model.safetensors'
+    })
+  })
+
+  it('returns false on desktop when no save path exists for the model directory', async () => {
+    mockIsDesktop.value = true
+
+    await expect(
+      downloadModel(
+        {
+          name: 'model.safetensors',
+          url: 'https://example.com/model.safetensors',
+          directory: 'checkpoints'
+        },
+        {}
+      )
+    ).resolves.toBe(false)
+
+    expect(mockStartElectronDownload).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/platform/missingModel/missingModelDownload.ts b/src/platform/missingModel/missingModelDownload.ts
index efbf0241f7..10e7f50a3e 100644
--- a/src/platform/missingModel/missingModelDownload.ts
+++ b/src/platform/missingModel/missingModelDownload.ts
@@ -59,7 +59,7 @@ export function isModelDownloadable(model: ModelWithUrl): boolean {
 export function downloadModel(
   model: ModelWithUrl,
   paths: Record<string, string[]>
-): void {
+): Promise<boolean> {
   if (!isDesktop) {
     const link = document.createElement('a')
     link.href = model.url
@@ -67,17 +67,19 @@ export function downloadModel(
     link.target = '_blank'
     link.rel = 'noopener noreferrer'
     link.click()
-    return
+    return Promise.resolve(true)
   }
 
   const modelPaths = paths[model.directory]
   if (modelPaths?.[0]) {
-    void useElectronDownloadStore().start({
+    return useElectronDownloadStore().start({
       url: model.url,
       savePath: modelPaths[0],
       filename: model.name
     })
   }
+
+  return Promise.resolve(false)
 }
 
 interface ModelMetadata {
diff --git a/src/platform/missingModel/missingModelStore.ts b/src/platform/missingModel/missingModelStore.ts
index 3f37deb835..0ca859374b 100644
--- a/src/platform/missingModel/missingModelStore.ts
+++ b/src/platform/missingModel/missingModelStore.ts
@@ -6,7 +6,10 @@ import { t } from '@/i18n'
 import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import { app } from '@/scripts/app'
 import { useToastStore } from '@/platform/updates/common/toastStore'
-import type { MissingModelCandidate } from '@/platform/missingModel/types'
+import type {
+  MissingModelCandidate,
+  MissingModelDownloadRef
+} from '@/platform/missingModel/types'
 import type { AssetMetadata } from '@/platform/assets/schemas/assetSchema'
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { getAncestorExecutionIds } from '@/types/nodeIdentification'
@@ -82,7 +85,7 @@ export const useMissingModelStore = defineStore('missingModel', () => {
   const modelExpandState = ref<Record<string, boolean>>({})
   const selectedLibraryModel = ref<Record<string, string>>({})
   const importCategoryMismatch = ref<Record<string, string>>({})
-  const importTaskIds = ref<Record<string, string>>({})
+  const downloadRefs = ref<Record<string, MissingModelDownloadRef>>({})
   const urlInputs = ref<Record<string, string>>({})
   const urlMetadata = ref<Record<string, AssetMetadata | null>>({})
   const urlFetching = ref<Record<string, boolean>>({})
@@ -135,7 +138,7 @@ export const useMissingModelStore = defineStore('missingModel', () => {
     delete modelExpandState.value[name]
     delete selectedLibraryModel.value[name]
     delete importCategoryMismatch.value[name]
-    delete importTaskIds.value[name]
+    delete downloadRefs.value[name]
     delete urlInputs.value[name]
     delete urlMetadata.value[name]
     delete urlFetching.value[name]
@@ -263,7 +266,7 @@ export const useMissingModelStore = defineStore('missingModel', () => {
     modelExpandState.value = {}
     selectedLibraryModel.value = {}
     importCategoryMismatch.value = {}
-    importTaskIds.value = {}
+    downloadRefs.value = {}
     urlInputs.value = {}
     urlMetadata.value = {}
     urlFetching.value = {}
@@ -322,7 +325,7 @@ export const useMissingModelStore = defineStore('missingModel', () => {
 
     modelExpandState,
     selectedLibraryModel,
-    importTaskIds,
+    downloadRefs,
     importCategoryMismatch,
     urlInputs,
     urlMetadata,
diff --git a/src/platform/missingModel/types.ts b/src/platform/missingModel/types.ts
index dd0b863127..b07c8a7416 100644
--- a/src/platform/missingModel/types.ts
+++ b/src/platform/missingModel/types.ts
@@ -2,6 +2,7 @@ import type {
   ModelFile,
   NodeId
 } from '@/platform/workflow/validation/schemas/workflowSchema'
+import type { DownloadLifecycleState } from '@/platform/downloads/types'
 
 /**
  * A single (node, widget, model) binding detected by the missing model pipeline.
@@ -51,3 +52,15 @@ export interface MissingModelGroup {
   models: MissingModelViewModel[]
   isAssetSupported: boolean
 }
+
+export type MissingModelDownloadRef =
+  | {
+      kind: 'asset-import'
+      taskId: string
+    }
+  | {
+      kind: 'electron-download'
+      url: string
+    }
+
+export type MissingModelDownloadStatus = DownloadLifecycleState
diff --git a/src/stores/electronDownloadStore.test.ts b/src/stores/electronDownloadStore.test.ts
new file mode 100644
index 0000000000..09192f54a4
--- /dev/null
+++ b/src/stores/electronDownloadStore.test.ts
@@ -0,0 +1,148 @@
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { DownloadStatus } from '@comfyorg/comfyui-electron-types'
+
+const mockGetAllDownloads = vi.fn()
+const mockStartDownload = vi.fn()
+const mockPauseDownload = vi.fn()
+const mockResumeDownload = vi.fn()
+const mockCancelDownload = vi.fn()
+
+let downloadProgressHandler:
+  | ((download: {
+      url: string
+      filename: string
+      savePath?: string
+      progress?: number
+      status?: DownloadStatus
+      state?: DownloadStatus
+      receivedBytes?: number
+      totalBytes?: number
+      isPaused?: boolean
+      message?: string
+    }) => void)
+  | undefined
+
+vi.mock('@/platform/distribution/types', () => ({
+  isDesktop: true
+}))
+
+vi.mock('@/utils/envUtil', () => ({
+  electronAPI: () => ({
+    DownloadManager: {
+      getAllDownloads: mockGetAllDownloads,
+      onDownloadProgress: (callback: typeof downloadProgressHandler) => {
+        downloadProgressHandler = callback
+      },
+      startDownload: mockStartDownload,
+      pauseDownload: mockPauseDownload,
+      resumeDownload: mockResumeDownload,
+      cancelDownload: mockCancelDownload
+    }
+  })
+}))
+
+import { useElectronDownloadStore } from './electronDownloadStore'
+
+async function flushStoreSetup() {
+  await Promise.resolve()
+  await Promise.resolve()
+}
+
+describe('electronDownloadStore', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    vi.clearAllMocks()
+    downloadProgressHandler = undefined
+    mockGetAllDownloads.mockResolvedValue([])
+  })
+
+  it('normalizes canonical desktop snapshots during initialization', async () => {
+    mockGetAllDownloads.mockResolvedValue([
+      {
+        url: 'https://example.com/model.safetensors',
+        filename: 'model.safetensors',
+        savePath: '/models/checkpoints/model.safetensors',
+        progress: 0.25,
+        status: DownloadStatus.IN_PROGRESS,
+        state: DownloadStatus.IN_PROGRESS,
+        receivedBytes: 25,
+        totalBytes: 100,
+        isPaused: false
+      }
+    ])
+
+    const store = useElectronDownloadStore()
+    await flushStoreSetup()
+
+    expect(store.downloads).toEqual([
+      {
+        url: 'https://example.com/model.safetensors',
+        filename: 'model.safetensors',
+        savePath: '/models/checkpoints/model.safetensors',
+        progress: 0.25,
+        status: 'running',
+        error: undefined
+      }
+    ])
+  })
+
+  it('normalizes legacy desktop snapshots without canonical fields', async () => {
+    mockGetAllDownloads.mockResolvedValue([
+      {
+        url: 'https://example.com/model.safetensors',
+        filename: 'model.safetensors',
+        state: DownloadStatus.PAUSED,
+        receivedBytes: 5,
+        totalBytes: 10,
+        isPaused: true
+      }
+    ])
+
+    const store = useElectronDownloadStore()
+    await flushStoreSetup()
+
+    expect(store.downloads).toEqual([
+      {
+        url: 'https://example.com/model.safetensors',
+        filename: 'model.safetensors',
+        savePath: '',
+        progress: 0.5,
+        status: 'paused',
+        error: undefined
+      }
+    ])
+  })
+
+  it('upserts progress updates into the normalized store shape', async () => {
+    const store = useElectronDownloadStore()
+    await flushStoreSetup()
+
+    downloadProgressHandler?.({
+      url: 'https://example.com/model.safetensors',
+      filename: 'model.safetensors',
+      savePath: '/models/checkpoints/model.safetensors',
+      progress: 0,
+      status: DownloadStatus.PENDING
+    })
+    downloadProgressHandler?.({
+      url: 'https://example.com/model.safetensors',
+      filename: 'model.safetensors',
+      savePath: '/models/checkpoints/model.safetensors',
+      progress: 0.6,
+      status: DownloadStatus.IN_PROGRESS
+    })
+
+    expect(store.downloads).toEqual([
+      {
+        url: 'https://example.com/model.safetensors',
+        filename: 'model.safetensors',
+        savePath: '/models/checkpoints/model.safetensors',
+        progress: 0.6,
+        status: 'running',
+        error: undefined
+      }
+    ])
+  })
+})
diff --git a/src/stores/electronDownloadStore.ts b/src/stores/electronDownloadStore.ts
index fbf2965534..2cec474165 100644
--- a/src/stores/electronDownloadStore.ts
+++ b/src/stores/electronDownloadStore.ts
@@ -1,20 +1,40 @@
 import { DownloadStatus } from '@comfyorg/comfyui-electron-types'
-import type { DownloadState } from '@comfyorg/comfyui-electron-types'
+import type {
+  DownloadProgressUpdate,
+  DownloadState
+} from '@comfyorg/comfyui-electron-types'
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 
+import type {
+  DownloadLifecycleState,
+  DownloadLifecycleStatus
+} from '@/platform/downloads/types'
 import { isDesktop } from '@/platform/distribution/types'
 import { electronAPI } from '@/utils/envUtil'
 
-export interface ElectronDownload extends Pick<
-  DownloadState,
+type DesktopDownloadSnapshot = Pick<
+  DownloadProgressUpdate,
   'url' | 'filename'
-> {
-  progress?: number
-  savePath?: string
-  status?: DownloadStatus
+> &
+  Partial<DownloadState> &
+  Partial<DownloadProgressUpdate>
+
+export interface ElectronDownload extends DownloadLifecycleState {
+  url: string
+  filename: string
+  savePath: string
 }
 
+const desktopStatusToLifecycleStatus = {
+  [DownloadStatus.PENDING]: 'created',
+  [DownloadStatus.IN_PROGRESS]: 'running',
+  [DownloadStatus.PAUSED]: 'paused',
+  [DownloadStatus.COMPLETED]: 'completed',
+  [DownloadStatus.CANCELLED]: 'cancelled',
+  [DownloadStatus.ERROR]: 'failed'
+} satisfies Record<DownloadStatus, DownloadLifecycleStatus>
+
 /** Electron downloads store handler */
 export const useElectronDownloadStore = defineStore('downloads', () => {
   const downloads = ref<ElectronDownload[]>([])
@@ -23,28 +43,79 @@ export const useElectronDownloadStore = defineStore('downloads', () => {
   const findByUrl = (url: string) =>
     downloads.value.find((download) => url === download.url)
 
+  function normalizeStatus(
+    status?: DownloadStatus,
+    isPaused?: boolean
+  ): ElectronDownload['status'] {
+    if (isPaused || status === DownloadStatus.PAUSED) {
+      return 'paused'
+    }
+
+    if (!status) return 'failed'
+
+    return desktopStatusToLifecycleStatus[status]
+  }
+
+  function normalizeProgress(
+    download: DesktopDownloadSnapshot,
+    status: ElectronDownload['status']
+  ): number {
+    if (typeof download.progress === 'number') {
+      return download.progress
+    }
+
+    if (
+      typeof download.receivedBytes === 'number' &&
+      typeof download.totalBytes === 'number' &&
+      download.totalBytes > 0
+    ) {
+      return download.receivedBytes / download.totalBytes
+    }
+
+    return status === 'completed' ? 1 : 0
+  }
+
+  function normalizeDownload(
+    download: DesktopDownloadSnapshot
+  ): ElectronDownload {
+    const status = normalizeStatus(
+      download.status ?? download.state,
+      download.isPaused
+    )
+
+    return {
+      url: download.url,
+      filename: download.filename,
+      savePath: download.savePath ?? '',
+      progress: normalizeProgress(download, status),
+      status,
+      error: download.message
+    }
+  }
+
+  function upsertDownload(download: DesktopDownloadSnapshot) {
+    const normalizedDownload = normalizeDownload(download)
+    const existingDownload = findByUrl(normalizedDownload.url)
+
+    if (existingDownload) {
+      Object.assign(existingDownload, normalizedDownload)
+      return
+    }
+
+    downloads.value.push(normalizedDownload)
+  }
+
   const initialize = async () => {
     if (!isDesktop || !DownloadManager) return
 
     const allDownloads = await DownloadManager.getAllDownloads()
 
     for (const download of allDownloads) {
-      downloads.value.push(download)
+      upsertDownload(download)
     }
 
     DownloadManager.onDownloadProgress((data) => {
-      if (!findByUrl(data.url)) {
-        downloads.value.push(data)
-      }
-
-      const download = findByUrl(data.url)
-
-      if (download) {
-        download.progress = data.progress
-        download.status = data.status
-        download.filename = data.filename
-        download.savePath = data.savePath
-      }
+      upsertDownload(data)
     })
   }
 
@@ -58,7 +129,8 @@ export const useElectronDownloadStore = defineStore('downloads', () => {
     url: string
     savePath: string
     filename: string
-  }) => DownloadManager!.startDownload(url, savePath, filename)
+  }): Promise<boolean> =>
+    DownloadManager!.startDownload(url, savePath, filename)
   const pause = (url: string) => DownloadManager!.pauseDownload(url)
   const resume = (url: string) => DownloadManager!.resumeDownload(url)
   const cancel = (url: string) => DownloadManager!.cancelDownload(url)
@@ -72,9 +144,7 @@ export const useElectronDownloadStore = defineStore('downloads', () => {
     findByUrl,
     initialize,
     inProgressDownloads: computed(() =>
-      downloads.value.filter(
-        ({ status }) => status !== DownloadStatus.COMPLETED
-      )
+      downloads.value.filter(({ status }) => status !== 'completed')
     )
   }
 })
diff --git a/src/stores/executionErrorStore.ts b/src/stores/executionErrorStore.ts
index 31c884d563..7c5e8b450d 100644
--- a/src/stores/executionErrorStore.ts
+++ b/src/stores/executionErrorStore.ts
@@ -54,7 +54,7 @@ export const useExecutionErrorStore = defineStore('executionError', () => {
 
   /** Clear all error state. Called at execution start and workflow changes.
    *  Missing model state is intentionally preserved here to avoid wiping
-   *  in-progress model repairs (importTaskIds, URL inputs, etc.).
+   *  in-progress model repairs (download refs, URL inputs, etc.).
    *  Missing models are cleared separately during workflow load/clean paths. */
   function clearAllErrors() {
     lastExecutionError.value = null