PBI-46: Sprint-niveau jobflow met cascade-FAIL (F1/F2/F4 Scrum4Me) (#136)

* ST-1243: F1 schema + propagateStatusUpwards-helper voor sprint-flow

Schema-uitbreidingen voor de sprint-niveau jobflow (PBI-46):
- TaskStatus, StoryStatus, PbiStatus, SprintStatus krijgen FAILED
- Nieuwe enums: SprintRunStatus, PrStrategy
- Nieuw SprintRun-model dat per-task ClaudeJobs groepeert
- ClaudeJob.sprint_run_id koppeling + index
- Product.pr_strategy (default SPRINT)
- Bijhorende Prisma-migratie

propagateStatusUpwards vervangt updateTaskStatusWithStoryPromotion en
herevalueert de keten Task → Story → PBI → Sprint → SprintRun bij elke
task-statuswijziging. Bij FAILED cancelt het sibling-jobs in dezelfde
SprintRun. PBI-status BLOCKED blijft handmatig en wordt niet overschreven.

Status-mappers + theme krijgen failed-token + label-uitbreidingen.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* ST-1244: F2 sprint-runs actions + deprecate per-task enqueues

actions/sprint-runs.ts (nieuw):
- startSprintRunAction met pre-flight (impl_plan / open ClaudeQuestion / PBI BLOCKED|FAILED)
- Maakt SprintRun + ClaudeJobs in PBI→Story→Task volgorde
- resumeSprintAction zet FAILED tasks/stories/PBIs terug en start nieuwe SprintRun
- cancelSprintRunAction breekt lopende SprintRun af zonder cascade

actions/claude-jobs.ts:
- enqueueClaudeJobAction, enqueueAllTodoJobsAction, previewEnqueueAllAction,
  enqueueClaudeJobsBatchAction nu deprecation-stubs (UI-cleanup volgt in F4)
- cancelClaudeJobAction blijft beschikbaar voor losse jobs

Tests bijgewerkt: 11 nieuwe sprint-runs tests, claude-jobs(-batch) tests
herzien naar deprecation-asserties.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* ST-1246: F4 UI Start/Resume/Cancel sprint + pr_strategy dropdown

- components/sprint/sprint-run-controls.tsx: knoppen Start Sprint
  (sprintStatus=ACTIVE), Hervat sprint (sprintStatus=FAILED) en
  Annuleer sprint-run (lopende run). Pre-flight blocker-modal toont
  blockers met directe links naar de relevante pagina's.
- components/products/pr-strategy-select.tsx: dropdown SPRINT|STORY in
  product-settings, met optimistic update + sonner-toast op fail.
- actions/products.ts: updatePrStrategyAction (eigenaar-only, demo-block).
- Sprint-page: query op actieve SprintRun + tonen van controls-balk.

Live cascade-visualisatie (T-634) staat als follow-up genoteerd —
huidige sprint-board statusbadges volstaan voor MVP. De Solo-board
"Voer uit"-knoppen zijn niet expliciet verwijderd; ze tonen nu de
deprecation-error van de gestubde actions tot de Solo-flow opnieuw
ontworpen wordt.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Janpeter Visser 2026-05-06 16:43:57 +02:00 committed by GitHub
parent ab8c3dca3f
commit 77617e89ac
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
25 changed files with 1798 additions and 1014 deletions

View file

@ -30,273 +30,49 @@ type PreflightResult =
| { error: string }
| { tasks: PreviewTask[]; blockerIndex: number | null; blockerReason: 'task-review' | 'pbi-blocked' | null }
export async function enqueueClaudeJobAction(taskId: string): Promise<EnqueueResult> {
const session = await getSession()
if (!session.userId) return { error: 'Niet ingelogd' }
if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }
const limited = enforceUserRateLimit('enqueue-job', session.userId)
if (limited) return { error: limited.error }
if (!taskId) return { error: 'task_id is verplicht' }
// Resolve task + product access in one query
const task = await prisma.task.findFirst({
where: {
id: taskId,
story: { product: productAccessFilter(session.userId) },
},
select: { id: true, story: { select: { product_id: true } } },
})
if (!task) return { error: 'Task niet gevonden' }
const productId = task.story.product_id
// Idempotency: weiger als er al een actieve job voor deze task bestaat
const existing = await prisma.claudeJob.findFirst({
where: { task_id: taskId, status: { in: ACTIVE_JOB_STATUSES } },
select: { id: true },
})
if (existing) {
return { error: 'Er loopt al een agent voor deze task', jobId: existing.id }
/**
* @deprecated Vervangen door startSprintRunAction in actions/sprint-runs.ts.
* Per-task starts zijn niet meer toegestaan een sprint draait nu als geheel.
* Wordt verwijderd zodra de UI is omgebouwd (F4).
*/
export async function enqueueClaudeJobAction(_taskId: string): Promise<EnqueueResult> {
return {
error:
'Per-task starten is niet meer mogelijk. Gebruik "Start Sprint" voor de hele actieve sprint.',
}
const job = await prisma.claudeJob.create({
data: { user_id: session.userId, product_id: productId, task_id: taskId, status: 'QUEUED' },
})
await prisma.$executeRaw`
SELECT pg_notify('scrum4me_changes', ${JSON.stringify({
type: 'claude_job_enqueued',
job_id: job.id,
task_id: taskId,
user_id: session.userId,
product_id: productId,
status: 'queued',
})}::text)
`
revalidatePath(`/products/${productId}/solo`)
return { success: true, jobId: job.id }
}
export async function enqueueAllTodoJobsAction(productId: string): Promise<EnqueueAllResult> {
const session = await getSession()
if (!session.userId) return { error: 'Niet ingelogd' }
if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }
if (!productId) return { error: 'product_id is verplicht' }
const product = await prisma.product.findFirst({
where: { id: productId, ...productAccessFilter(session.userId) },
select: { id: true },
})
if (!product) return { error: 'Geen toegang tot dit product' }
const userId = session.userId
// Match het scope dat de gebruiker op het Solo Paneel ziet:
// alleen TO_DO-taken in de actieve sprint, in stories die aan deze
// gebruiker zijn toegewezen. Anders queue je per ongeluk taken die
// niet in de huidige sprint zitten of aan iemand anders toebehoren.
const sprint = await prisma.sprint.findFirst({
where: { product_id: productId, status: 'ACTIVE' },
select: { id: true },
})
if (!sprint) return { success: true, count: 0 }
const tasks = await prisma.task.findMany({
where: {
status: 'TO_DO',
story: { sprint_id: sprint.id, assignee_id: userId },
claude_jobs: { none: { status: { in: ACTIVE_JOB_STATUSES } } },
},
select: { id: true },
})
if (tasks.length === 0) return { success: true, count: 0 }
const created = await prisma.$transaction(
tasks.map(t =>
prisma.claudeJob.create({
data: { user_id: userId, product_id: productId, task_id: t.id, status: 'QUEUED' },
select: { id: true, task_id: true },
})
)
)
for (const job of created) {
await prisma.$executeRaw`
SELECT pg_notify('scrum4me_changes', ${JSON.stringify({
type: 'claude_job_enqueued',
job_id: job.id,
task_id: job.task_id,
user_id: userId,
product_id: productId,
status: 'queued',
})}::text)
`
/**
* @deprecated Vervangen door startSprintRunAction in actions/sprint-runs.ts.
*/
export async function enqueueAllTodoJobsAction(_productId: string): Promise<EnqueueAllResult> {
return {
error:
'"Alle TO_DO als jobs queueen" is vervangen door "Start Sprint". Gebruik startSprintRunAction.',
}
revalidatePath(`/products/${productId}/solo`)
return { success: true, count: created.length }
}
export async function previewEnqueueAllAction(productId: string): Promise<PreflightResult> {
const session = await getSession()
if (!session.userId) return { error: 'Niet ingelogd' }
if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }
if (!productId) return { error: 'product_id is verplicht' }
const product = await prisma.product.findFirst({
where: { id: productId, ...productAccessFilter(session.userId) },
select: { id: true },
})
if (!product) return { error: 'Geen toegang tot dit product' }
const userId = session.userId
const sprint = await prisma.sprint.findFirst({
where: { product_id: productId, status: 'ACTIVE' },
select: { id: true },
})
if (!sprint) return { tasks: [], blockerIndex: null, blockerReason: null }
const rawTasks = await prisma.task.findMany({
where: {
story: { sprint_id: sprint.id, assignee_id: userId },
claude_jobs: { none: { status: { in: ACTIVE_JOB_STATUSES } } },
},
select: {
id: true,
title: true,
status: true,
story: {
select: {
id: true,
title: true,
code: true,
pbi: { select: { id: true, status: true, priority: true, sort_order: true } },
},
},
},
orderBy: [
{ story: { pbi: { priority: 'asc' } } },
{ story: { pbi: { sort_order: 'asc' } } },
{ story: { sort_order: 'asc' } },
{ priority: 'asc' },
{ sort_order: 'asc' },
],
})
let blockerIndex: number | null = null
let blockerReason: 'task-review' | 'pbi-blocked' | null = null
for (let i = 0; i < rawTasks.length; i++) {
const t = rawTasks[i]
if (t.status === 'REVIEW') {
blockerIndex = i
blockerReason = 'task-review'
break
}
if (t.story.pbi.status === 'BLOCKED') {
blockerIndex = i
blockerReason = 'pbi-blocked'
break
}
/**
* @deprecated Vervangen door pre-flight in startSprintRunAction (actions/sprint-runs.ts).
*/
export async function previewEnqueueAllAction(_productId: string): Promise<PreflightResult> {
return {
error:
'Per-product preview is vervangen door de pre-flight check in startSprintRunAction.',
}
const displayTasks = blockerIndex !== null ? rawTasks.slice(0, blockerIndex + 1) : rawTasks
const tasks: PreviewTask[] = displayTasks.map(t => ({
id: t.id,
title: t.title,
status: t.status,
story_title: t.story.title,
pbi_id: t.story.pbi.id,
pbi_status: t.story.pbi.status,
}))
return { tasks, blockerIndex, blockerReason }
}
/**
* @deprecated Vervangen door startSprintRunAction in actions/sprint-runs.ts.
*/
export async function enqueueClaudeJobsBatchAction(
productId: string,
taskIds: string[]
_productId: string,
_taskIds: string[]
): Promise<EnqueueAllResult> {
const session = await getSession()
if (!session.userId) return { error: 'Niet ingelogd' }
if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }
const limited = enforceUserRateLimit('enqueue-job', session.userId)
if (limited) return { error: limited.error }
if (!productId) return { error: 'product_id is verplicht' }
if (!taskIds.length) return { success: true, count: 0 }
const product = await prisma.product.findFirst({
where: { id: productId, ...productAccessFilter(session.userId) },
select: { id: true },
})
if (!product) return { error: 'Geen toegang tot dit product' }
const userId = session.userId
const sprint = await prisma.sprint.findFirst({
where: { product_id: productId, status: 'ACTIVE' },
select: { id: true },
})
if (!sprint) return { error: 'Geen actieve sprint gevonden' }
const authorizedTasks = await prisma.task.findMany({
where: {
id: { in: taskIds },
story: { sprint_id: sprint.id, assignee_id: userId },
},
select: {
id: true,
claude_jobs: {
where: { status: { in: ACTIVE_JOB_STATUSES } },
select: { id: true },
},
},
})
if (authorizedTasks.length !== taskIds.length) {
return { error: 'Een of meer taken zijn niet toegankelijk voor deze gebruiker' }
return {
error:
'Batch-queue per task is vervangen door "Start Sprint". Gebruik startSprintRunAction.',
}
const queueable = authorizedTasks.filter(t => t.claude_jobs.length === 0)
if (queueable.length === 0) return { success: true, count: 0 }
const queueableIds = new Set(queueable.map(t => t.id))
const orderedQueueable = taskIds.filter(id => queueableIds.has(id))
const created = await prisma.$transaction(
orderedQueueable.map(taskId =>
prisma.claudeJob.create({
data: { user_id: userId, product_id: productId, task_id: taskId, status: 'QUEUED' },
select: { id: true, task_id: true },
})
)
)
for (const job of created) {
await prisma.$executeRaw`
SELECT pg_notify('scrum4me_changes', ${JSON.stringify({
type: 'claude_job_enqueued',
job_id: job.id,
task_id: job.task_id,
user_id: userId,
product_id: productId,
status: 'queued',
})}::text)
`
}
revalidatePath(`/products/${productId}/solo`)
return { success: true, count: created.length }
}
export async function cancelClaudeJobAction(jobId: string): Promise<CancelResult> {