AP2.2f: Scrum Sprint-Review, Reaktivierung und Carryover beim Abschluss.
Deploy Development / deploy (push) Successful in 47s
Test Suite / pytest-backend (push) Successful in 2m58s
Test Suite / lint-backend (push) Successful in 4s
Test Suite / compose-smoke (push) Has been skipped
Test Suite / k6 /api/health Baseline (push) Successful in 19s
Test Suite / playwright-smoke (push) Successful in 1m1s

Offene APs können beim Abschluss in den Eingang oder einen anderen Sprint überführt werden; abgeschlossene Sprints sind reaktivierbar.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
LarsandCursor committed 2026-07-24 17:40:59 +02:00
1 parent e65838118c
commit 04d1dbf1f9
14 files changed
+719 -31

No files matched your search

+3 -2
View File
@@ -22,8 +22,9 @@ export function deleteAction(id) {
return apiFetch(`/api/actions/${id}`, { method: 'DELETE' })
}
export function unplanActionToBacklog(id) {
return apiFetch(`/api/actions/${id}/unplan-to-backlog`, { method: 'POST' })
export function unplanActionToBacklog(id, { carryover = false } = {}) {
const query = carryover ? '?carryover=true' : ''
return apiFetch(`/api/actions/${id}/unplan-to-backlog${query}`, { method: 'POST' })
}
export function listMyOpenActions() {
+6
View File
@@ -26,3 +26,9 @@ export function activateWorkCycle(initiativeId, workCycleId) {
method: 'POST',
})
}
export function reactivateWorkCycle(initiativeId, workCycleId) {
return apiFetch(`/api/initiatives/${initiativeId}/work-cycles/${workCycleId}/reactivate`, {
method: 'POST',
})
}
@@ -0,0 +1,258 @@
import { useEffect, useMemo, useState } from 'react'
import { Modal } from './Modal.jsx'
import { StatusBadge } from './StatusBadge.jsx'
import { listCarryoverTargetSprints } from '../utils/workCycleActions.js'
const DISPOSITION = {
BACKLOG: 'backlog',
MOVE: 'move',
KEEP: 'keep',
}
/**
* Sprint Review & Abschluss — offene APs vor Complete behandeln (Scrum Carryover).
*/
export function SprintCompleteDialog({
open,
cycle,
openActions = [],
workCycles = [],
busy = false,
onClose,
onConfirm,
}) {
const targetSprints = useMemo(
() => listCarryoverTargetSprints(workCycles, cycle?.id),
[workCycles, cycle?.id],
)
const [dispositions, setDispositions] = useState({})
const [bulkTargetCycleId, setBulkTargetCycleId] = useState('')
const [validationError, setValidationError] = useState('')
useEffect(() => {
if (!open || !openActions.length) return
const initial = {}
for (const action of openActions) {
initial[action.id] = {
disposition: DISPOSITION.BACKLOG,
targetCycleId: targetSprints[0]?.id || '',
}
}
setDispositions(initial)
setBulkTargetCycleId(targetSprints[0]?.id || '')
setValidationError('')
}, [open, openActions, targetSprints])
function setDisposition(actionId, patch) {
setDispositions((prev) => ({
...prev,
[actionId]: { ...prev[actionId], ...patch },
}))
setValidationError('')
}
function applyBulkBacklog() {
setDispositions((prev) => {
const next = { ...prev }
for (const action of openActions) {
next[action.id] = { disposition: DISPOSITION.BACKLOG, targetCycleId: '' }
}
return next
})
}
function applyBulkMove() {
if (!bulkTargetCycleId) {
setValidationError('Bitte einen Ziel-Sprint für die Sammel-Verschiebung wählen.')
return
}
setDispositions((prev) => {
const next = { ...prev }
for (const action of openActions) {
next[action.id] = {
disposition: DISPOSITION.MOVE,
targetCycleId: bulkTargetCycleId,
}
}
return next
})
setValidationError('')
}
async function handleSubmit(e) {
e.preventDefault()
const keepCount = openActions.filter(
(a) => dispositions[a.id]?.disposition === DISPOSITION.KEEP,
).length
const moveMissing = openActions.some(
(a) =>
dispositions[a.id]?.disposition === DISPOSITION.MOVE &&
!dispositions[a.id]?.targetCycleId,
)
if (moveMissing) {
setValidationError('Für „Anderer Sprint" muss ein Ziel-Sprint gewählt sein.')
return
}
if (keepCount > 0) {
const ok = window.confirm(
`${keepCount} Arbeitspaket${keepCount === 1 ? '' : 'e'} bleiben am abgeschlossenen Sprint. ` +
'Das entspricht nicht dem üblichen Scrum-Carryover. Trotzdem abschließen?',
)
if (!ok) return
}
await onConfirm(dispositions)
}
if (!cycle) return null
return (
<Modal
open={open}
title={`Sprint Review & Abschluss — ${cycle.title}`}
onClose={onClose}
size="lg"
>
<form className="form sprint-complete-dialog" onSubmit={handleSubmit}>
<p className="section-lead muted">
Sprint Review (Scrum): Inkrement prüfen und offene Arbeitspakete vor dem Abschluss
in den Eingang oder einen anderen Sprint überführen.
</p>
{openActions.length === 0 ? (
<p className="muted">Alle Arbeitspakete sind erledigt — Sprint kann abgeschlossen werden.</p>
) : (
<>
<div className="sprint-complete-dialog__warning card-list-item">
<strong>
{openActions.length} offene Arbeitspaket
{openActions.length === 1 ? '' : 'e'}
</strong>
<p className="muted">
Nicht erledigte APs sollten vor dem Abschluss umgeplant werden.
</p>
</div>
<div className="sprint-complete-dialog__bulk">
<button
type="button"
className="btn btn-secondary btn-sm"
disabled={busy}
onClick={applyBulkBacklog}
>
Alle → Eingang
</button>
<label className="sprint-complete-dialog__bulk-move">
<span className="muted">Alle → Sprint</span>
<select
value={bulkTargetCycleId}
onChange={(e) => setBulkTargetCycleId(e.target.value)}
disabled={busy || targetSprints.length === 0}
>
<option value="">— Sprint wählen —</option>
{targetSprints.map((s) => (
<option key={s.id} value={s.id}>
{s.title}
{s.status === 'active' ? ' (aktiv)' : ''}
</option>
))}
</select>
<button
type="button"
className="btn btn-secondary btn-sm"
disabled={busy || !bulkTargetCycleId}
onClick={applyBulkMove}
>
Anwenden
</button>
</label>
</div>
<ul className="item-list sprint-complete-dialog__list">
{openActions.map((action) => {
const row = dispositions[action.id] || {}
return (
<li key={action.id} className="list-item card-list-item sprint-complete-row">
<div className="sprint-complete-row__main">
<strong>{action.title}</strong>
<StatusBadge status={action.status} />
</div>
<div className="sprint-complete-row__choices">
<label className="radio-label">
<input
type="radio"
name={`disp-${action.id}`}
checked={row.disposition === DISPOSITION.BACKLOG}
onChange={() =>
setDisposition(action.id, { disposition: DISPOSITION.BACKLOG })
}
disabled={busy}
/>
In Eingang
</label>
<label className="radio-label">
<input
type="radio"
name={`disp-${action.id}`}
checked={row.disposition === DISPOSITION.MOVE}
onChange={() =>
setDisposition(action.id, {
disposition: DISPOSITION.MOVE,
targetCycleId: row.targetCycleId || bulkTargetCycleId,
})
}
disabled={busy || targetSprints.length === 0}
/>
Anderer Sprint
</label>
{row.disposition === DISPOSITION.MOVE && (
<select
value={row.targetCycleId || ''}
onChange={(e) =>
setDisposition(action.id, { targetCycleId: e.target.value })
}
disabled={busy}
aria-label={`Ziel-Sprint für ${action.title}`}
>
<option value="">— Sprint —</option>
{targetSprints.map((s) => (
<option key={s.id} value={s.id}>
{s.title}
</option>
))}
</select>
)}
<label className="radio-label">
<input
type="radio"
name={`disp-${action.id}`}
checked={row.disposition === DISPOSITION.KEEP}
onChange={() =>
setDisposition(action.id, { disposition: DISPOSITION.KEEP })
}
disabled={busy}
/>
Am Sprint belassen
</label>
</div>
</li>
)
})}
</ul>
</>
)}
{validationError && <p className="error">{validationError}</p>}
<div className="form-actions">
<button type="submit" className="btn btn-primary" disabled={busy}>
{busy ? 'Abschließen …' : 'Sprint abschließen'}
</button>
<button type="button" className="btn btn-secondary" onClick={onClose} disabled={busy}>
Abbrechen
</button>
</div>
</form>
</Modal>
)
}
+73 -23
View File
@@ -1,15 +1,19 @@
import { useState } from 'react'
import { StatusBadge } from './StatusBadge.jsx'
import { EmptyState } from './EmptyState.jsx'
import { SprintCompleteDialog } from './SprintCompleteDialog.jsx'
import { listOpenActionsForWorkCycle } from '../utils/workCycleActions.js'
const SPRINT_LIFECYCLE = [
{ key: 'planned', label: 'Planung' },
{ key: 'active', label: 'Ausführung' },
{ key: 'reached', label: 'Abgeschlossen' },
/** Scrum Sprint-Phasen (UI — mapped auf work_cycle-Status). */
const SCRUM_SPRINT_PHASES = [
{ key: 'planning', label: 'Sprint Planning', hint: 'Backlog & Ziel' },
{ key: 'execution', label: 'Sprint', hint: 'Daily / Ausführung' },
{ key: 'review', label: 'Sprint Review', hint: 'Inkrement prüfen' },
{ key: 'done', label: 'Retro & Done', hint: 'Abschluss' },
]
function lifecycleStepIndex(status) {
if (status === 'reached') return 2
if (status === 'reached') return 3
if (status === 'active' || status === 'at_risk') return 1
return 0
}
@@ -18,17 +22,25 @@ export function WorkCyclesPanel({
workCycles = [],
activeWorkCycle = null,
selectedSprintId = '',
actions = [],
actionCountByCycleId = {},
canManage,
onCreate,
onActivate,
onComplete,
onCompleteWithCarryover,
onReactivate,
onSelectSprint,
busy = false,
}) {
const [title, setTitle] = useState('')
const [goal, setGoal] = useState('')
const [activateOnCreate, setActivateOnCreate] = useState(true)
const [completeTarget, setCompleteTarget] = useState(null)
const completeOpenActions = completeTarget
? listOpenActionsForWorkCycle(actions, completeTarget.id)
: []
async function handleSubmit(e) {
e.preventDefault()
@@ -43,16 +55,30 @@ export function WorkCyclesPanel({
setGoal('')
}
async function handleComplete(cycle) {
const openCount = actionCountByCycleId[cycle.id] || 0
if (openCount > 0) {
const ok = window.confirm(
`Sprint „${cycle.title}" hat noch ${openCount} offene Arbeitspaket${openCount === 1 ? '' : 'e'}. ` +
'Trotzdem abschließen? Offene APs bleiben dem Sprint zugeordnet und können in den Eingang zurückgeschoben werden.',
)
if (!ok) return
function openCompleteDialog(cycle) {
setCompleteTarget(cycle)
}
function closeCompleteDialog() {
if (!busy) setCompleteTarget(null)
}
async function handleCompleteConfirm(dispositions) {
if (!completeTarget) return
if (typeof onCompleteWithCarryover === 'function') {
await onCompleteWithCarryover(completeTarget.id, dispositions)
} else {
await onComplete(completeTarget.id)
}
await onComplete(cycle.id)
setCompleteTarget(null)
}
async function handleReactivate(cycleId) {
const ok = window.confirm(
'Sprint wieder aktivieren? Der Sprint wird erneut als laufend markiert (versehentlicher Abschluss).',
)
if (!ok) return
await onReactivate(cycleId)
}
return (
@@ -61,9 +87,9 @@ export function WorkCyclesPanel({
<div>
<h2>Sprint</h2>
<p className="section-lead muted">
Sprint anklicken, um den geplanten Sprint-Backlog zu sehen — aktiv oder geplant.
Committete Arbeitspakete aus dem Eingang erscheinen beim gewählten Sprint.
Lebenszyklus: Planung → Ausführung → Abschluss (Scrum).
Scrum-Lebenszyklus: Sprint Planning → Sprint → Sprint Review → Retro & Done.
Beim Abschluss werden offene Arbeitspakete in den Eingang oder einen anderen Sprint
überführt.
</p>
</div>
</div>
@@ -139,8 +165,11 @@ export function WorkCyclesPanel({
<span className="muted work-cycle-row__count">
{apCount} AP{apCount === 1 ? '' : 's'}
</span>
<div className="work-cycle-lifecycle muted" aria-label="Sprint-Lebenszyklus">
{SPRINT_LIFECYCLE.map((phase, index) => (
<div
className="work-cycle-lifecycle"
aria-label="Scrum Sprint-Lebenszyklus"
>
{SCRUM_SPRINT_PHASES.map((phase, index) => (
<span
key={phase.key}
className={
@@ -148,9 +177,10 @@ export function WorkCyclesPanel({
(index === step ? ' work-cycle-lifecycle__step--current' : '') +
(index < step ? ' work-cycle-lifecycle__step--done' : '')
}
title={phase.hint}
>
{phase.label}
{index < SPRINT_LIFECYCLE.length - 1 && (
<span className="work-cycle-lifecycle__label">{phase.label}</span>
{index < SCRUM_SPRINT_PHASES.length - 1 && (
<span className="work-cycle-lifecycle__sep" aria-hidden="true">
→
</span>
@@ -168,9 +198,9 @@ export function WorkCyclesPanel({
type="button"
className="btn btn-secondary btn-sm"
disabled={busy}
onClick={() => handleComplete(cycle)}
onClick={() => openCompleteDialog(cycle)}
>
Abschließen
Review & Abschließen
</button>
)}
{canManage && cycle.status !== 'active' && cycle.status !== 'reached' && (
@@ -183,12 +213,32 @@ export function WorkCyclesPanel({
Aktivieren
</button>
)}
{canManage && cycle.status === 'reached' && typeof onReactivate === 'function' && (
<button
type="button"
className="btn btn-secondary btn-sm"
disabled={busy}
onClick={() => handleReactivate(cycle.id)}
>
Reaktivieren
</button>
)}
</div>
</li>
)
})}
</ul>
)}
<SprintCompleteDialog
open={Boolean(completeTarget)}
cycle={completeTarget}
openActions={completeOpenActions}
workCycles={workCycles}
busy={busy}
onClose={closeCompleteDialog}
onConfirm={handleCompleteConfirm}
/>
</section>
)
}
@@ -77,6 +77,7 @@ import {
createWorkCycle,
activateWorkCycle,
completeWorkCycle,
reactivateWorkCycle,
} from '../api/workCycles.js'
import { useCapabilities } from '../hooks/useCapabilities.js'
import { useActors } from '../hooks/useActors.js'
@@ -587,6 +588,42 @@ export function InitiativeOperationsProvider({ children, initiativeId: initiativ
}
}
async function handleCompleteWorkCycleWithCarryover(workCycleId, dispositions) {
setFormBusy(true)
setError(null)
try {
for (const [actionId, item] of Object.entries(dispositions || {})) {
if (item.disposition === 'backlog') {
const result = await unplanActionToBacklog(actionId, { carryover: true })
applyUnplanResult(result)
} else if (item.disposition === 'move' && item.targetCycleId) {
const updated = await updateAction(actionId, { work_cycle_id: item.targetCycleId })
setActions((prev) => prev.map((a) => (a.id === actionId ? updated : a)))
}
}
await completeWorkCycle(id, workCycleId)
await load({ silent: true })
} catch (err) {
setError(err.message)
throw err
} finally {
setFormBusy(false)
}
}
async function handleReactivateWorkCycle(workCycleId) {
setFormBusy(true)
try {
await reactivateWorkCycle(id, workCycleId)
await load({ silent: true })
setSelectedWorkCycleId(workCycleId)
} catch (err) {
setError(err.message)
} finally {
setFormBusy(false)
}
}
async function handleDeleteBacklog(itemId) {
try {
await deleteBacklogItem(itemId)
@@ -962,6 +999,8 @@ export function InitiativeOperationsProvider({ children, initiativeId: initiativ
handleCreateWorkCycle,
handleActivateWorkCycle,
handleCompleteWorkCycle,
handleCompleteWorkCycleWithCarryover,
handleReactivateWorkCycle,
handleDeleteBacklog,
handleCreateRoadmapItem,
handleRoadmapItemStatus,
@@ -39,6 +39,8 @@ function PlanSprintInner() {
handleCreateWorkCycle,
handleActivateWorkCycle,
handleCompleteWorkCycle,
handleCompleteWorkCycleWithCarryover,
handleReactivateWorkCycle,
handleCreateAction,
handleUpdateAction,
handleQuickStatus,
@@ -78,11 +80,14 @@ function PlanSprintInner() {
workCycles={workCycles}
activeWorkCycle={activeWorkCycle}
selectedSprintId={selectedWorkCycleId}
actions={actions}
actionCountByCycleId={actionCountByCycleId}
canManage={capabilities.has('kairo.milestone.manage')}
onCreate={handleCreateWorkCycle}
onActivate={handleActivateWorkCycle}
onComplete={handleCompleteWorkCycle}
onCompleteWithCarryover={handleCompleteWorkCycleWithCarryover}
onReactivate={handleReactivateWorkCycle}
onSelectSprint={setSelectedWorkCycleId}
busy={formBusy}
/>
+81
View File
@@ -707,6 +707,87 @@
gap: 6px;
}
.work-cycle-lifecycle {
display: flex;
flex-wrap: wrap;
gap: 4px 2px;
margin-top: 6px;
font-size: 11px;
}
.work-cycle-lifecycle__step {
opacity: 0.45;
}
.work-cycle-lifecycle__step--current {
opacity: 1;
font-weight: 600;
color: var(--jk-primary);
}
.work-cycle-lifecycle__step--done {
opacity: 0.75;
}
.work-cycle-lifecycle__sep {
margin: 0 4px;
opacity: 0.5;
}
.sprint-complete-dialog__warning {
margin: 12px 0;
padding: 12px;
border-left: 3px solid var(--jk-warning, #c98200);
background: var(--jk-surface-muted, rgba(0, 0, 0, 0.03));
}
.sprint-complete-dialog__bulk {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 10px;
margin-bottom: 12px;
}
.sprint-complete-dialog__bulk-move {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 8px;
}
.sprint-complete-dialog__list {
margin: 0 0 16px;
}
.sprint-complete-row {
display: flex;
flex-direction: column;
gap: 8px;
}
.sprint-complete-row__main {
display: flex;
align-items: center;
gap: 8px;
flex-wrap: wrap;
}
.sprint-complete-row__choices {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 10px 14px;
font-size: 13px;
}
.radio-label {
display: inline-flex;
align-items: center;
gap: 6px;
cursor: pointer;
}
.backlog-sprint-setup {
margin-bottom: 16px;
padding: 12px;
+20
View File
@@ -25,3 +25,23 @@ export function countActionsByWorkCycle(actions, { hideDone = true } = {}) {
}
return counts
}
export const PLANNING_SPRINT_STATUSES = new Set(['planned', 'active', 'at_risk'])
/**
* @param {Array<{ id: string, status?: string }>} workCycles
* @param {string | undefined} excludeCycleId
*/
export function listCarryoverTargetSprints(workCycles, excludeCycleId) {
return (workCycles || []).filter(
(cycle) => cycle.id !== excludeCycleId && PLANNING_SPRINT_STATUSES.has(cycle.status),
)
}
/**
* @param {Array<{ id: string, work_cycle_id?: string, status?: string }>} actions
* @param {string | undefined} cycleId
*/
export function listOpenActionsForWorkCycle(actions, cycleId) {
return filterActionsForWorkCycle(actions, cycleId, { hideDone: true })
}
+16 -1
View File
@@ -1,5 +1,10 @@
import { describe, expect, it } from 'vitest'
import { countActionsByWorkCycle, filterActionsForWorkCycle } from './workCycleActions.js'
import {
countActionsByWorkCycle,
filterActionsForWorkCycle,
listCarryoverTargetSprints,
listOpenActionsForWorkCycle,
} from './workCycleActions.js'
describe('workCycleActions', () => {
const actions = [
@@ -18,4 +23,14 @@ describe('workCycleActions', () => {
it('counts actions per sprint', () => {
expect(countActionsByWorkCycle(actions)).toEqual({ s1: 1, s2: 1 })
})
it('lists open actions and carryover targets', () => {
expect(listOpenActionsForWorkCycle(actions, 's1').map((a) => a.id)).toEqual(['a1'])
const cycles = [
{ id: 's1', status: 'active' },
{ id: 's2', status: 'planned' },
{ id: 's3', status: 'reached' },
]
expect(listCarryoverTargetSprints(cycles, 's1').map((c) => c.id)).toEqual(['s2'])
})
})