[feat] Migrate to Jobs API (PR 2 of 3)

This PR switches the frontend from legacy /history and /queue endpoints
to the unified /jobs API.

Key changes:
- Rewrite TaskItemImpl in queueStore.ts to wrap JobListItem
- Update api.ts getQueue()/getHistory() to use Jobs API
- Update all queue composables (useJobList, useJobMenu, useResultGallery)
- Update useJobErrorReporting to use execution_error.exception_message
- Update JobGroupsList.vue workflowId access
- Update reconciliation.ts to work with JobListItem
- Update all related tests

Breaking changes:
- getQueue() now returns JobListItem[] instead of legacy tuple format
- getHistory() now returns JobListItem[] instead of HistoryTaskItem[]
- TaskItemImpl.outputs now lazily loads via loadFullOutputs()

Part of Jobs API migration. Depends on PR 1 (jobs-api-pr1-infrastructure).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

tests-ui/tests/store/queueStore.test.ts

@@ -1,34 +1,39 @@
 import { createPinia, setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-import type {
-  HistoryTaskItem,
-  PendingTaskItem,
-  RunningTaskItem,
-  TaskOutput,
-  TaskPrompt,
-  TaskStatus
-} from '@/schemas/apiSchema'
+import type { JobListItem } from '@/platform/remote/comfyui/jobs/jobTypes'
+import type { TaskOutput } from '@/schemas/apiSchema'
 import { api } from '@/scripts/api'
 import { TaskItemImpl, useQueueStore } from '@/stores/queueStore'
 
-// Fixture factories
-const createTaskPrompt = (
-  queueIndex: number,
-  promptId: string,
-  inputs: Record<string, any> = {},
-  extraData: Record<string, any> = {},
-  outputsToExecute: any[] = []
-): TaskPrompt => [queueIndex, promptId, inputs, extraData, outputsToExecute]
+// Fixture factory for JobListItem
+function createJob(
+  id: string,
+  status: JobListItem['status'],
+  createTime: number = Date.now(),
+  priority?: number
+): JobListItem {
+  return {
+    id,
+    status,
+    create_time: createTime,
+    update_time: createTime,
+    last_state_update: createTime,
+    priority: priority ?? createTime
+  }
+}
 
-const createTaskStatus = (
-  statusStr: 'success' | 'error' = 'success',
-  messages: any[] = []
-): TaskStatus => ({
-  status_str: statusStr,
-  completed: true,
-  messages
-})
+function createRunningJob(createTime: number, id: string): JobListItem {
+  return createJob(id, 'in_progress', createTime)
+}
+
+function createPendingJob(createTime: number, id: string): JobListItem {
+  return createJob(id, 'pending', createTime)
+}
+
+function createHistoryJob(createTime: number, id: string): JobListItem {
+  return createJob(id, 'completed', createTime)
+}
 
 const createTaskOutput = (
   nodeId: string = 'node-1',
@@ -39,35 +44,6 @@ const createTaskOutput = (
   }
 })
 
-const createRunningTask = (
-  queueIndex: number,
-  promptId: string
-): RunningTaskItem => ({
-  taskType: 'Running',
-  prompt: createTaskPrompt(queueIndex, promptId),
-  remove: { name: 'Cancel', cb: () => {} }
-})
-
-const createPendingTask = (
-  queueIndex: number,
-  promptId: string
-): PendingTaskItem => ({
-  taskType: 'Pending',
-  prompt: createTaskPrompt(queueIndex, promptId)
-})
-
-const createHistoryTask = (
-  queueIndex: number,
-  promptId: string,
-  outputs: TaskOutput = createTaskOutput(),
-  status: TaskStatus = createTaskStatus()
-): HistoryTaskItem => ({
-  taskType: 'History',
-  prompt: createTaskPrompt(queueIndex, promptId),
-  status,
-  outputs
-})
-
 // Mock API
 vi.mock('@/scripts/api', () => ({
   api: {
@@ -83,17 +59,13 @@ vi.mock('@/scripts/api', () => ({
 
 describe('TaskItemImpl', () => {
   it('should remove animated property from outputs during construction', () => {
-    const taskItem = new TaskItemImpl(
-      'History',
-      [0, 'prompt-id', {}, { client_id: 'client-id' }, []],
-      { status_str: 'success', messages: [], completed: true },
-      {
-        'node-1': {
-          images: [{ filename: 'test.png', type: 'output', subfolder: '' }],
-          animated: [false]
-        }
+    const job = createHistoryJob(0, 'prompt-id')
+    const taskItem = new TaskItemImpl(job, {
+      'node-1': {
+        images: [{ filename: 'test.png', type: 'output', subfolder: '' }],
+        animated: [false]
       }
-    )
+    })
 
     // Check that animated property was removed
     expect('animated' in taskItem.outputs['node-1']).toBe(false)
@@ -103,90 +75,72 @@ describe('TaskItemImpl', () => {
   })
 
   it('should handle outputs without animated property', () => {
-    const taskItem = new TaskItemImpl(
-      'History',
-      [0, 'prompt-id', {}, { client_id: 'client-id' }, []],
-      { status_str: 'success', messages: [], completed: true },
-      {
-        'node-1': {
-          images: [{ filename: 'test.png', type: 'output', subfolder: '' }]
-        }
+    const job = createHistoryJob(0, 'prompt-id')
+    const taskItem = new TaskItemImpl(job, {
+      'node-1': {
+        images: [{ filename: 'test.png', type: 'output', subfolder: '' }]
       }
-    )
+    })
 
     expect(taskItem.outputs['node-1'].images).toBeDefined()
     expect(taskItem.outputs['node-1'].images?.[0]?.filename).toBe('test.png')
   })
 
   it('should recognize webm video from core', () => {
-    const taskItem = new TaskItemImpl(
-      'History',
-      [0, 'prompt-id', {}, { client_id: 'client-id' }, []],
-      { status_str: 'success', messages: [], completed: true },
-      {
-        'node-1': {
-          video: [{ filename: 'test.webm', type: 'output', subfolder: '' }]
-        }
+    const job = createHistoryJob(0, 'prompt-id')
+    const taskItem = new TaskItemImpl(job, {
+      'node-1': {
+        video: [{ filename: 'test.webm', type: 'output', subfolder: '' }]
       }
-    )
+    })
 
     const output = taskItem.flatOutputs[0]
 
     expect(output.htmlVideoType).toBe('video/webm')
     expect(output.isVideo).toBe(true)
-    expect(output.isWebm).toBe(true)
     expect(output.isVhsFormat).toBe(false)
     expect(output.isImage).toBe(false)
   })
 
   // https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite/blob/0a75c7958fe320efcb052f1d9f8451fd20c730a8/videohelpersuite/nodes.py#L578-L590
   it('should recognize webm video from VHS', () => {
-    const taskItem = new TaskItemImpl(
-      'History',
-      [0, 'prompt-id', {}, { client_id: 'client-id' }, []],
-      { status_str: 'success', messages: [], completed: true },
-      {
-        'node-1': {
-          gifs: [
-            {
-              filename: 'test.webm',
-              type: 'output',
-              subfolder: '',
-              format: 'video/webm',
-              frame_rate: 30
-            }
-          ]
-        }
+    const job = createHistoryJob(0, 'prompt-id')
+    const taskItem = new TaskItemImpl(job, {
+      'node-1': {
+        gifs: [
+          {
+            filename: 'test.webm',
+            type: 'output',
+            subfolder: '',
+            format: 'video/webm',
+            frame_rate: 30
+          }
+        ]
       }
-    )
+    })
 
     const output = taskItem.flatOutputs[0]
 
     expect(output.htmlVideoType).toBe('video/webm')
     expect(output.isVideo).toBe(true)
-    expect(output.isWebm).toBe(true)
     expect(output.isVhsFormat).toBe(true)
     expect(output.isImage).toBe(false)
   })
 
   it('should recognize mp4 video from core', () => {
-    const taskItem = new TaskItemImpl(
-      'History',
-      [0, 'prompt-id', {}, { client_id: 'client-id' }, []],
-      { status_str: 'success', messages: [], completed: true },
-      {
-        'node-1': {
-          images: [
-            {
-              filename: 'test.mp4',
-              type: 'output',
-              subfolder: ''
-            }
-          ],
-          animated: [true]
-        }
+    const job = createHistoryJob(0, 'prompt-id')
+    const taskItem = new TaskItemImpl(job, {
+      'node-1': {
+        images: [
+          {
+            filename: 'test.mp4',
+            type: 'output',
+            subfolder: ''
+          }
+        ],
+        animated: [true]
       }
-    )
+    })
 
     const output = taskItem.flatOutputs[0]
 
@@ -205,22 +159,18 @@ describe('TaskItemImpl', () => {
 
     audioFormats.forEach(({ extension, mimeType }) => {
       it(`should recognize ${extension} audio`, () => {
-        const taskItem = new TaskItemImpl(
-          'History',
-          [0, 'prompt-id', {}, { client_id: 'client-id' }, []],
-          { status_str: 'success', messages: [], completed: true },
-          {
-            'node-1': {
-              audio: [
-                {
-                  filename: `test.${extension}`,
-                  type: 'output',
-                  subfolder: ''
-                }
-              ]
-            }
+        const job = createHistoryJob(0, 'prompt-id')
+        const taskItem = new TaskItemImpl(job, {
+          'node-1': {
+            audio: [
+              {
+                filename: `test.${extension}`,
+                type: 'output',
+                subfolder: ''
+              }
+            ]
           }
-        )
+        })
 
         const output = taskItem.flatOutputs[0]
 
@@ -267,15 +217,16 @@ describe('useQueueStore', () => {
 
   describe('update() - basic functionality', () => {
     it('should load running and pending tasks from API', async () => {
-      const runningTask = createRunningTask(1, 'run-1')
-      const pendingTask1 = createPendingTask(2, 'pend-1')
-      const pendingTask2 = createPendingTask(3, 'pend-2')
+      const runningJob = createRunningJob(1, 'run-1')
+      const pendingJob1 = createPendingJob(2, 'pend-1')
+      const pendingJob2 = createPendingJob(3, 'pend-2')
 
+      // API returns pre-sorted data (newest first)
       mockGetQueue.mockResolvedValue({
-        Running: [runningTask],
-        Pending: [pendingTask1, pendingTask2]
+        Running: [runningJob],
+        Pending: [pendingJob2, pendingJob1] // Pre-sorted by create_time desc
       })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.update()
 
@@ -287,13 +238,11 @@ describe('useQueueStore', () => {
     })
 
     it('should load history tasks from API', async () => {
-      const historyTask1 = createHistoryTask(5, 'hist-1')
-      const historyTask2 = createHistoryTask(4, 'hist-2')
+      const historyJob1 = createHistoryJob(5, 'hist-1')
+      const historyJob2 = createHistoryJob(4, 'hist-2')
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({
-        History: [historyTask1, historyTask2]
-      })
+      mockGetHistory.mockResolvedValue([historyJob1, historyJob2])
 
       await store.update()
 
@@ -304,7 +253,7 @@ describe('useQueueStore', () => {
 
     it('should set loading state correctly', async () => {
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       expect(store.isLoading).toBe(false)
 
@@ -317,7 +266,7 @@ describe('useQueueStore', () => {
 
     it('should clear loading state even if API fails', async () => {
       mockGetQueue.mockRejectedValue(new Error('API error'))
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await expect(store.update()).rejects.toThrow('API error')
       expect(store.isLoading).toBe(false)
@@ -326,14 +275,12 @@ describe('useQueueStore', () => {
 
   describe('update() - sorting', () => {
     it('should sort tasks by queueIndex descending', async () => {
-      const task1 = createHistoryTask(1, 'hist-1')
-      const task2 = createHistoryTask(5, 'hist-2')
-      const task3 = createHistoryTask(3, 'hist-3')
+      const job1 = createHistoryJob(1, 'hist-1')
+      const job2 = createHistoryJob(5, 'hist-2')
+      const job3 = createHistoryJob(3, 'hist-3')
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({
-        History: [task1, task2, task3]
-      })
+      mockGetHistory.mockResolvedValue([job1, job2, job3])
 
       await store.update()
 
@@ -342,16 +289,17 @@ describe('useQueueStore', () => {
       expect(store.historyTasks[2].queueIndex).toBe(1)
     })
 
-    it('should sort pending tasks by queueIndex descending', async () => {
-      const pend1 = createPendingTask(10, 'pend-1')
-      const pend2 = createPendingTask(15, 'pend-2')
-      const pend3 = createPendingTask(12, 'pend-3')
+    it('should preserve API sort order for pending tasks', async () => {
+      const pend1 = createPendingJob(10, 'pend-1')
+      const pend2 = createPendingJob(15, 'pend-2')
+      const pend3 = createPendingJob(12, 'pend-3')
 
+      // API returns pre-sorted data (newest first)
       mockGetQueue.mockResolvedValue({
         Running: [],
-        Pending: [pend1, pend2, pend3]
+        Pending: [pend2, pend3, pend1] // Pre-sorted by create_time desc
       })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.update()
 
@@ -363,19 +311,17 @@ describe('useQueueStore', () => {
 
   describe('update() - queue index collision (THE BUG FIX)', () => {
     it('should NOT confuse different prompts with same queueIndex', async () => {
-      const hist1 = createHistoryTask(50, 'prompt-uuid-aaa')
+      const hist1 = createHistoryJob(50, 'prompt-uuid-aaa')
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [hist1] })
+      mockGetHistory.mockResolvedValue([hist1])
 
       await store.update()
       expect(store.historyTasks).toHaveLength(1)
       expect(store.historyTasks[0].promptId).toBe('prompt-uuid-aaa')
 
-      const hist2 = createHistoryTask(51, 'prompt-uuid-bbb')
-      mockGetHistory.mockResolvedValue({
-        History: [hist2]
-      })
+      const hist2 = createHistoryJob(51, 'prompt-uuid-bbb')
+      mockGetHistory.mockResolvedValue([hist2])
 
       await store.update()
 
@@ -385,19 +331,17 @@ describe('useQueueStore', () => {
     })
 
     it('should correctly reconcile when queueIndex is reused', async () => {
-      const hist1 = createHistoryTask(100, 'first-prompt-at-100')
-      const hist2 = createHistoryTask(99, 'prompt-at-99')
+      const hist1 = createHistoryJob(100, 'first-prompt-at-100')
+      const hist2 = createHistoryJob(99, 'prompt-at-99')
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [hist1, hist2] })
+      mockGetHistory.mockResolvedValue([hist1, hist2])
 
       await store.update()
       expect(store.historyTasks).toHaveLength(2)
 
-      const hist3 = createHistoryTask(101, 'second-prompt-at-101')
-      mockGetHistory.mockResolvedValue({
-        History: [hist3, hist2]
-      })
+      const hist3 = createHistoryJob(101, 'second-prompt-at-101')
+      mockGetHistory.mockResolvedValue([hist3, hist2])
 
       await store.update()
 
@@ -409,23 +353,19 @@ describe('useQueueStore', () => {
     })
 
     it('should handle multiple queueIndex collisions simultaneously', async () => {
-      const hist1 = createHistoryTask(10, 'old-at-10')
-      const hist2 = createHistoryTask(20, 'old-at-20')
-      const hist3 = createHistoryTask(30, 'keep-at-30')
+      const hist1 = createHistoryJob(10, 'old-at-10')
+      const hist2 = createHistoryJob(20, 'old-at-20')
+      const hist3 = createHistoryJob(30, 'keep-at-30')
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({
-        History: [hist3, hist2, hist1]
-      })
+      mockGetHistory.mockResolvedValue([hist3, hist2, hist1])
 
       await store.update()
       expect(store.historyTasks).toHaveLength(3)
 
-      const newHist1 = createHistoryTask(31, 'new-at-31')
-      const newHist2 = createHistoryTask(32, 'new-at-32')
-      mockGetHistory.mockResolvedValue({
-        History: [newHist2, newHist1, hist3]
-      })
+      const newHist1 = createHistoryJob(31, 'new-at-31')
+      const newHist2 = createHistoryJob(32, 'new-at-32')
+      mockGetHistory.mockResolvedValue([newHist2, newHist1, hist3])
 
       await store.update()
 
@@ -437,19 +377,17 @@ describe('useQueueStore', () => {
 
   describe('update() - history reconciliation', () => {
     it('should keep existing items still on server (by promptId)', async () => {
-      const hist1 = createHistoryTask(10, 'existing-1')
-      const hist2 = createHistoryTask(9, 'existing-2')
+      const hist1 = createHistoryJob(10, 'existing-1')
+      const hist2 = createHistoryJob(9, 'existing-2')
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [hist1, hist2] })
+      mockGetHistory.mockResolvedValue([hist1, hist2])
 
       await store.update()
       expect(store.historyTasks).toHaveLength(2)
 
-      const hist3 = createHistoryTask(11, 'new-1')
-      mockGetHistory.mockResolvedValue({
-        History: [hist3, hist1, hist2]
-      })
+      const hist3 = createHistoryJob(11, 'new-1')
+      mockGetHistory.mockResolvedValue([hist3, hist1, hist2])
 
       await store.update()
 
@@ -460,16 +398,16 @@ describe('useQueueStore', () => {
     })
 
     it('should remove items no longer on server', async () => {
-      const hist1 = createHistoryTask(10, 'remove-me')
-      const hist2 = createHistoryTask(9, 'keep-me')
+      const hist1 = createHistoryJob(10, 'remove-me')
+      const hist2 = createHistoryJob(9, 'keep-me')
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [hist1, hist2] })
+      mockGetHistory.mockResolvedValue([hist1, hist2])
 
       await store.update()
       expect(store.historyTasks).toHaveLength(2)
 
-      mockGetHistory.mockResolvedValue({ History: [hist2] })
+      mockGetHistory.mockResolvedValue([hist2])
 
       await store.update()
 
@@ -478,18 +416,16 @@ describe('useQueueStore', () => {
     })
 
     it('should add new items from server', async () => {
-      const hist1 = createHistoryTask(5, 'old-1')
+      const hist1 = createHistoryJob(5, 'old-1')
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [hist1] })
+      mockGetHistory.mockResolvedValue([hist1])
 
       await store.update()
 
-      const hist2 = createHistoryTask(6, 'new-1')
-      const hist3 = createHistoryTask(7, 'new-2')
-      mockGetHistory.mockResolvedValue({
-        History: [hist3, hist2, hist1]
-      })
+      const hist2 = createHistoryJob(6, 'new-1')
+      const hist3 = createHistoryJob(7, 'new-2')
+      mockGetHistory.mockResolvedValue([hist3, hist2, hist1])
 
       await store.update()
 
@@ -503,12 +439,12 @@ describe('useQueueStore', () => {
     it('should enforce maxHistoryItems limit', async () => {
       store.maxHistoryItems = 3
 
-      const tasks = Array.from({ length: 5 }, (_, i) =>
-        createHistoryTask(10 - i, `hist-${i}`)
+      const jobs = Array.from({ length: 5 }, (_, i) =>
+        createHistoryJob(10 - i, `hist-${i}`)
       )
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: tasks })
+      mockGetHistory.mockResolvedValue(jobs)
 
       await store.update()
 
@@ -522,21 +458,19 @@ describe('useQueueStore', () => {
       store.maxHistoryItems = 5
 
       const initial = Array.from({ length: 3 }, (_, i) =>
-        createHistoryTask(10 + i, `existing-${i}`)
+        createHistoryJob(10 + i, `existing-${i}`)
       )
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: initial })
+      mockGetHistory.mockResolvedValue(initial)
 
       await store.update()
       expect(store.historyTasks).toHaveLength(3)
 
-      const newTasks = Array.from({ length: 4 }, (_, i) =>
-        createHistoryTask(20 + i, `new-${i}`)
+      const newJobs = Array.from({ length: 4 }, (_, i) =>
+        createHistoryJob(20 + i, `new-${i}`)
       )
-      mockGetHistory.mockResolvedValue({
-        History: [...newTasks, ...initial]
-      })
+      mockGetHistory.mockResolvedValue([...newJobs, ...initial])
 
       await store.update()
 
@@ -547,10 +481,10 @@ describe('useQueueStore', () => {
     it('should handle maxHistoryItems = 0', async () => {
       store.maxHistoryItems = 0
 
-      const tasks = [createHistoryTask(10, 'hist-1')]
+      const jobs = [createHistoryJob(10, 'hist-1')]
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: tasks })
+      mockGetHistory.mockResolvedValue(jobs)
 
       await store.update()
 
@@ -560,13 +494,13 @@ describe('useQueueStore', () => {
     it('should handle maxHistoryItems = 1', async () => {
       store.maxHistoryItems = 1
 
-      const tasks = [
-        createHistoryTask(10, 'hist-1'),
-        createHistoryTask(9, 'hist-2')
+      const jobs = [
+        createHistoryJob(10, 'hist-1'),
+        createHistoryJob(9, 'hist-2')
       ]
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: tasks })
+      mockGetHistory.mockResolvedValue(jobs)
 
       await store.update()
 
@@ -577,18 +511,18 @@ describe('useQueueStore', () => {
     it('should dynamically adjust when maxHistoryItems changes', async () => {
       store.maxHistoryItems = 10
 
-      const tasks = Array.from({ length: 15 }, (_, i) =>
-        createHistoryTask(20 - i, `hist-${i}`)
+      const jobs = Array.from({ length: 15 }, (_, i) =>
+        createHistoryJob(20 - i, `hist-${i}`)
       )
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: tasks })
+      mockGetHistory.mockResolvedValue(jobs)
 
       await store.update()
       expect(store.historyTasks).toHaveLength(10)
 
       store.maxHistoryItems = 5
-      mockGetHistory.mockResolvedValue({ History: tasks })
+      mockGetHistory.mockResolvedValue(jobs)
 
       await store.update()
       expect(store.historyTasks).toHaveLength(5)
@@ -597,19 +531,17 @@ describe('useQueueStore', () => {
 
   describe('computed properties', () => {
     it('tasks should combine pending, running, and history in correct order', async () => {
-      const running = createRunningTask(5, 'run-1')
-      const pending1 = createPendingTask(6, 'pend-1')
-      const pending2 = createPendingTask(7, 'pend-2')
-      const hist1 = createHistoryTask(3, 'hist-1')
-      const hist2 = createHistoryTask(4, 'hist-2')
+      const running = createRunningJob(5, 'run-1')
+      const pending1 = createPendingJob(6, 'pend-1')
+      const pending2 = createPendingJob(7, 'pend-2')
+      const hist1 = createHistoryJob(3, 'hist-1')
+      const hist2 = createHistoryJob(4, 'hist-2')
 
       mockGetQueue.mockResolvedValue({
         Running: [running],
         Pending: [pending1, pending2]
       })
-      mockGetHistory.mockResolvedValue({
-        History: [hist2, hist1]
-      })
+      mockGetHistory.mockResolvedValue([hist2, hist1])
 
       await store.update()
 
@@ -624,9 +556,9 @@ describe('useQueueStore', () => {
     it('hasPendingTasks should be true when pending tasks exist', async () => {
       mockGetQueue.mockResolvedValue({
         Running: [],
-        Pending: [createPendingTask(1, 'pend-1')]
+        Pending: [createPendingJob(1, 'pend-1')]
       })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.update()
       expect(store.hasPendingTasks).toBe(true)
@@ -634,21 +566,19 @@ describe('useQueueStore', () => {
 
     it('hasPendingTasks should be false when no pending tasks', async () => {
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.update()
       expect(store.hasPendingTasks).toBe(false)
     })
 
     it('lastHistoryQueueIndex should return highest queue index', async () => {
-      const hist1 = createHistoryTask(10, 'hist-1')
-      const hist2 = createHistoryTask(25, 'hist-2')
-      const hist3 = createHistoryTask(15, 'hist-3')
+      const hist1 = createHistoryJob(10, 'hist-1')
+      const hist2 = createHistoryJob(25, 'hist-2')
+      const hist3 = createHistoryJob(15, 'hist-3')
 
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({
-        History: [hist1, hist2, hist3]
-      })
+      mockGetHistory.mockResolvedValue([hist1, hist2, hist3])
 
       await store.update()
       expect(store.lastHistoryQueueIndex).toBe(25)
@@ -656,7 +586,7 @@ describe('useQueueStore', () => {
 
     it('lastHistoryQueueIndex should be -1 when no history', async () => {
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.update()
       expect(store.lastHistoryQueueIndex).toBe(-1)
@@ -666,19 +596,17 @@ describe('useQueueStore', () => {
   describe('clear()', () => {
     beforeEach(async () => {
       mockGetQueue.mockResolvedValue({
-        Running: [createRunningTask(1, 'run-1')],
-        Pending: [createPendingTask(2, 'pend-1')]
-      })
-      mockGetHistory.mockResolvedValue({
-        History: [createHistoryTask(3, 'hist-1')]
+        Running: [createRunningJob(1, 'run-1')],
+        Pending: [createPendingJob(2, 'pend-1')]
       })
+      mockGetHistory.mockResolvedValue([createHistoryJob(3, 'hist-1')])
       await store.update()
     })
 
     it('should clear both queue and history by default', async () => {
       mockClearItems.mockResolvedValue(undefined)
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.clear()
 
@@ -693,9 +621,7 @@ describe('useQueueStore', () => {
     it('should clear only queue when specified', async () => {
       mockClearItems.mockResolvedValue(undefined)
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({
-        History: [createHistoryTask(3, 'hist-1')]
-      })
+      mockGetHistory.mockResolvedValue([createHistoryJob(3, 'hist-1')])
 
       await store.clear(['queue'])
 
@@ -707,10 +633,10 @@ describe('useQueueStore', () => {
     it('should clear only history when specified', async () => {
       mockClearItems.mockResolvedValue(undefined)
       mockGetQueue.mockResolvedValue({
-        Running: [createRunningTask(1, 'run-1')],
-        Pending: [createPendingTask(2, 'pend-1')]
+        Running: [createRunningJob(1, 'run-1')],
+        Pending: [createPendingJob(2, 'pend-1')]
       })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.clear(['history'])
 
@@ -729,11 +655,12 @@ describe('useQueueStore', () => {
 
   describe('delete()', () => {
     it('should delete task from queue', async () => {
-      const task = new TaskItemImpl('Pending', createTaskPrompt(1, 'pend-1'))
+      const job = createPendingJob(1, 'pend-1')
+      const task = new TaskItemImpl(job)
 
       mockDeleteItem.mockResolvedValue(undefined)
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.delete(task)
 
@@ -741,16 +668,12 @@ describe('useQueueStore', () => {
     })
 
     it('should delete task from history', async () => {
-      const task = new TaskItemImpl(
-        'History',
-        createTaskPrompt(1, 'hist-1'),
-        createTaskStatus(),
-        createTaskOutput()
-      )
+      const job = createHistoryJob(1, 'hist-1')
+      const task = new TaskItemImpl(job, createTaskOutput())
 
       mockDeleteItem.mockResolvedValue(undefined)
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.delete(task)
 
@@ -758,11 +681,12 @@ describe('useQueueStore', () => {
     })
 
     it('should refresh store after deletion', async () => {
-      const task = new TaskItemImpl('Pending', createTaskPrompt(1, 'pend-1'))
+      const job = createPendingJob(1, 'pend-1')
+      const task = new TaskItemImpl(job)
 
       mockDeleteItem.mockResolvedValue(undefined)
       mockGetQueue.mockResolvedValue({ Running: [], Pending: [] })
-      mockGetHistory.mockResolvedValue({ History: [] })
+      mockGetHistory.mockResolvedValue([])
 
       await store.delete(task)