feat(ST-006): voeg restartClaudeJobAction toe aan actions/claude-jobs.ts

- Exporteert restartClaudeJobAction(jobId) die FAILED/CANCELLED/SKIPPED jobs atomair reset naar QUEUED
- Valideert auth, demo-blokkade, ownership en restartbare status
- Gebruikt prisma.$transaction: claudeJob.updateMany + conditionale sprintTaskExecution.updateMany reset
- Verstuurt pg_notify claude_job_status zodat Jobs-pagina via SSE ververst
- Unit-tests: happy-path (FAILED/CANCELLED/SKIPPED), demo-blokkade, not-found, niet-restartbare status, race-conditie en sprint sub-task reset

__tests__/actions/claude-jobs.test.ts

@@ -8,13 +8,24 @@ const {
   mockGetSession,
   mockFindFirstJob,
   mockUpdateJob,
+  mockUpdateManyJob,
+  mockUpdateManySprintTaskExecution,
+  mockTransaction,
   mockExecuteRaw,
-} = vi.hoisted(() => ({
+} = vi.hoisted(() => {
-  mockGetSession: vi.fn(),
+  const mockUpdateManyJob = vi.fn()
-  mockFindFirstJob: vi.fn(),
+  const mockUpdateManySprintTaskExecution = vi.fn()
-  mockUpdateJob: vi.fn(),
+  const mockTransaction = vi.fn()
-  mockExecuteRaw: vi.fn().mockResolvedValue(undefined),
+  return {
-}))
+    mockGetSession: vi.fn(),
+    mockFindFirstJob: vi.fn(),
+    mockUpdateJob: vi.fn(),
+    mockUpdateManyJob,
+    mockUpdateManySprintTaskExecution,
+    mockTransaction,
+    mockExecuteRaw: vi.fn().mockResolvedValue(undefined),
+  }
+})
 
 vi.mock('next/cache', () => ({ revalidatePath: vi.fn() }))
 vi.mock('@/lib/auth', () => ({ getSession: mockGetSession }))
@@ -23,7 +34,12 @@ vi.mock('@/lib/prisma', () => ({
     claudeJob: {
       findFirst: mockFindFirstJob,
       update: mockUpdateJob,
+      updateMany: mockUpdateManyJob,
     },
+    sprintTaskExecution: {
+      updateMany: mockUpdateManySprintTaskExecution,
+    },
+    $transaction: mockTransaction,
     $executeRaw: mockExecuteRaw,
   },
 }))
@@ -32,6 +48,7 @@ import {
   enqueueClaudeJobAction,
   enqueueAllTodoJobsAction,
   cancelClaudeJobAction,
+  restartClaudeJobAction,
 } from '@/actions/claude-jobs'
 
 const SESSION_USER = { userId: 'user-1', isDemo: false }
@@ -39,6 +56,12 @@ const SESSION_USER = { userId: 'user-1', isDemo: false }
 beforeEach(() => {
   vi.clearAllMocks()
   mockExecuteRaw.mockResolvedValue(undefined)
+  mockTransaction.mockImplementation(async (fn: (tx: unknown) => Promise<unknown>) =>
+    fn({
+      claudeJob: { updateMany: mockUpdateManyJob },
+      sprintTaskExecution: { updateMany: mockUpdateManySprintTaskExecution },
+    })
+  )
 })
 
 describe('enqueueClaudeJobAction (deprecated)', () => {
@@ -104,3 +127,115 @@ describe('cancelClaudeJobAction', () => {
     expect(result).toMatchObject({ error: expect.stringContaining('actieve') })
   })
 })
+
+describe('restartClaudeJobAction', () => {
+  const FAILED_JOB = {
+    id: 'job-1',
+    status: 'FAILED',
+    kind: 'TASK_IMPLEMENTATION',
+    task_id: 'task-1',
+    idea_id: null,
+    sprint_run_id: null,
+    product_id: 'prod-1',
+  }
+
+  it('reset een FAILED job naar QUEUED (happy path)', async () => {
+    mockGetSession.mockResolvedValue(SESSION_USER)
+    mockFindFirstJob.mockResolvedValue(FAILED_JOB)
+    mockUpdateManyJob.mockResolvedValue({ count: 1 })
+
+    const result = await restartClaudeJobAction('job-1')
+
+    expect(result).toEqual({ success: true })
+    expect(mockUpdateManyJob).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ id: 'job-1', status: { in: ['FAILED', 'CANCELLED', 'SKIPPED'] } }),
+        data: expect.objectContaining({ status: 'QUEUED' }),
+      })
+    )
+    expect(mockExecuteRaw).toHaveBeenCalled()
+  })
+
+  it('reset een CANCELLED job naar QUEUED', async () => {
+    mockGetSession.mockResolvedValue(SESSION_USER)
+    mockFindFirstJob.mockResolvedValue({ ...FAILED_JOB, status: 'CANCELLED' })
+    mockUpdateManyJob.mockResolvedValue({ count: 1 })
+
+    const result = await restartClaudeJobAction('job-1')
+    expect(result).toEqual({ success: true })
+  })
+
+  it('reset een SKIPPED job naar QUEUED', async () => {
+    mockGetSession.mockResolvedValue(SESSION_USER)
+    mockFindFirstJob.mockResolvedValue({ ...FAILED_JOB, status: 'SKIPPED' })
+    mockUpdateManyJob.mockResolvedValue({ count: 1 })
+
+    const result = await restartClaudeJobAction('job-1')
+    expect(result).toEqual({ success: true })
+  })
+
+  it('weigert demo-sessie', async () => {
+    mockGetSession.mockResolvedValue({ userId: 'demo', isDemo: true })
+
+    const result = await restartClaudeJobAction('job-1')
+    expect(result).toMatchObject({ error: expect.stringContaining('demo') })
+    expect(mockUpdateManyJob).not.toHaveBeenCalled()
+  })
+
+  it('retourneert error als job niet gevonden', async () => {
+    mockGetSession.mockResolvedValue(SESSION_USER)
+    mockFindFirstJob.mockResolvedValue(null)
+
+    const result = await restartClaudeJobAction('job-1')
+    expect(result).toMatchObject({ error: expect.stringContaining('niet gevonden') })
+  })
+
+  it('weigert wanneer job een niet-restartbare status heeft', async () => {
+    mockGetSession.mockResolvedValue(SESSION_USER)
+    mockFindFirstJob.mockResolvedValue({ ...FAILED_JOB, status: 'DONE' })
+
+    const result = await restartClaudeJobAction('job-1')
+    expect(result).toMatchObject({ error: expect.stringContaining('mislukte') })
+    expect(mockUpdateManyJob).not.toHaveBeenCalled()
+  })
+
+  it('retourneert error bij race-conditie (updateMany count === 0)', async () => {
+    mockGetSession.mockResolvedValue(SESSION_USER)
+    mockFindFirstJob.mockResolvedValue(FAILED_JOB)
+    mockUpdateManyJob.mockResolvedValue({ count: 0 })
+
+    const result = await restartClaudeJobAction('job-1')
+    expect(result).toMatchObject({ error: expect.stringContaining('gewijzigd') })
+  })
+
+  it('reset ook SprintTaskExecution-rows bij SPRINT_IMPLEMENTATION', async () => {
+    mockGetSession.mockResolvedValue(SESSION_USER)
+    mockFindFirstJob.mockResolvedValue({
+      ...FAILED_JOB,
+      kind: 'SPRINT_IMPLEMENTATION',
+      sprint_run_id: 'run-1',
+    })
+    mockUpdateManyJob.mockResolvedValue({ count: 1 })
+    mockUpdateManySprintTaskExecution.mockResolvedValue({ count: 3 })
+
+    const result = await restartClaudeJobAction('job-1')
+
+    expect(result).toEqual({ success: true })
+    expect(mockUpdateManySprintTaskExecution).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { sprint_job_id: 'job-1' },
+        data: expect.objectContaining({ status: 'PENDING' }),
+      })
+    )
+  })
+
+  it('reset geen SprintTaskExecution-rows bij TASK_IMPLEMENTATION', async () => {
+    mockGetSession.mockResolvedValue(SESSION_USER)
+    mockFindFirstJob.mockResolvedValue(FAILED_JOB)
+    mockUpdateManyJob.mockResolvedValue({ count: 1 })
+
+    await restartClaudeJobAction('job-1')
+
+    expect(mockUpdateManySprintTaskExecution).not.toHaveBeenCalled()
+  })
+})

actions/claude-jobs.ts

@@ -1,6 +1,7 @@
 'use server'
 
 import { revalidatePath } from 'next/cache'
+import { type ClaudeJobStatus } from '@prisma/client'
 import { prisma } from '@/lib/prisma'
 import { getSession } from '@/lib/auth'
 import { ACTIVE_JOB_STATUSES, jobStatusToApi } from '@/lib/job-status'
@@ -15,6 +16,9 @@ type EnqueueAllResult =
 
 type CancelResult = { success: true } | { error: string }
 
+type RestartResult = { success: true } | { error: string }
+const RESTARTABLE_STATUSES: ClaudeJobStatus[] = ['FAILED', 'CANCELLED', 'SKIPPED']
+
 export type PreviewTask = {
   id: string
   title: string
@@ -109,3 +113,76 @@ export async function cancelClaudeJobAction(jobId: string): Promise<CancelResult
   revalidatePath(`/products/${job.product_id}/solo`)
   return { success: true }
 }
+
+export async function restartClaudeJobAction(jobId: string): Promise<RestartResult> {
+  const session = await getSession()
+  if (!session.userId) return { error: 'Niet ingelogd' }
+  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }
+  if (!jobId) return { error: 'job_id is verplicht' }
+
+  const job = await prisma.claudeJob.findFirst({
+    where: { id: jobId, user_id: session.userId },
+    select: { id: true, status: true, kind: true, task_id: true, idea_id: true, sprint_run_id: true, product_id: true },
+  })
+  if (!job) return { error: 'Job niet gevonden' }
+  if (!RESTARTABLE_STATUSES.includes(job.status)) {
+    return { error: 'Alleen mislukte, geannuleerde of overgeslagen jobs kunnen opnieuw gestart worden' }
+  }
+
+  const updated = await prisma.$transaction(async (tx) => {
+    const result = await tx.claudeJob.updateMany({
+      where: { id: jobId, status: { in: RESTARTABLE_STATUSES } },
+      data: {
+        status: 'QUEUED',
+        retry_count: { increment: 1 },
+        claimed_by_token_id: null,
+        claimed_at: null,
+        started_at: null,
+        finished_at: null,
+        pushed_at: null,
+        verify_result: null,
+        error: null,
+        summary: null,
+        branch: null,
+        head_sha: null,
+        lease_until: null,
+      },
+    })
+    if (result.count === 0) return 0
+    if (job.kind === 'SPRINT_IMPLEMENTATION') {
+      await tx.sprintTaskExecution.updateMany({
+        where: { sprint_job_id: jobId },
+        data: {
+          status: 'PENDING',
+          verify_result: null,
+          verify_summary: null,
+          skip_reason: null,
+          head_sha: null,
+          started_at: null,
+          finished_at: null,
+        },
+      })
+    }
+    return result.count
+  })
+  if (updated === 0) {
+    return { error: 'Job-status is gewijzigd; herlaad en probeer opnieuw' }
+  }
+
+  await prisma.$executeRaw`
+    SELECT pg_notify('scrum4me_changes', ${JSON.stringify({
+      type: 'claude_job_status',
+      job_id: jobId,
+      kind: job.kind,
+      task_id: job.task_id,
+      idea_id: job.idea_id,
+      sprint_run_id: job.sprint_run_id,
+      user_id: session.userId,
+      product_id: job.product_id,
+      status: jobStatusToApi('QUEUED'),
+    })}::text)
+  `
+
+  revalidatePath('/jobs')
+  return { success: true }
+}