feat(PBI-79): Product Backlog sprint-membership via vinkjes (#190)

* feat(PBI-79/ST-1333): active-sprint null-contract + clearActiveSprintAction

- lib/user-settings.ts: activeSprints values nullable in Zod-schema.
  Key-aanwezigheid heeft nu betekenis (key+null = bewust geen sprint;
  key ontbreekt = fallback-cascade).
- lib/active-sprint.ts: nieuwe readStoredActiveSprintState helper +
  resolveActiveSprint respecteert expliciet 'cleared' state zonder fallback.
  clearActiveSprintInSettings schrijft null i.p.v. de key te verwijderen.
- actions/active-sprint.ts: nieuwe clearActiveSprintAction met auth +
  membership-check.
- components/shared/sprint-switcher.tsx: '— Geen actieve sprint —'-optie
  in dropdown, disabled wanneer er geen actieve sprint is.
- Tests: nieuwe active-sprint.test.ts (resolver-paden + clear),
  active-sprint-action.test.ts (action-laag), uitbreiding user-settings.test.ts.

Plan: docs/plans/PBI-79-backlog-sprint-workflow.md

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

* feat(PBI-79/ST-1334): user-settings pendingSprintDraft-slot

- lib/user-settings.ts: nieuw workflow.pendingSprintDraft veld met
  compacte intent-shape (pbiIntent + per-PBI storyOverrides).
- actions/sprint-draft.ts: setPendingSprintDraftAction +
  clearPendingSprintDraftAction met product-membership-check + Zod-validatie.
- stores/user-settings/store.ts: setPendingSprintDraft / clearPendingSprintDraft
  optimistic acties + fine-grained mutators upsertPbiIntent / upsertStoryOverride.
  Sprint-draft actions worden dynamisch geïmporteerd zodat jsdom-tests
  zonder DATABASE_URL niet falen.
- Tests: nieuwe sprint-draft.test.ts (action-laag), uitbreiding
  user-settings store-tests (5 nieuwe cases) en schema-tests (4 cases).

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

* feat(PBI-79/ST-1343): sprint-conflicts helper-library

- lib/sprint-conflicts.ts: drie pure/server-side helpers voor eligibility
  + cross-sprint detectie.
  - isEligibleForSprint(story): sprint_id IS NULL en status != DONE
  - partitionByEligibility(prisma, storyIds, excludeSprintId): split in
    eligible / notEligible / crossSprint met reden per story
  - getBlockingSprintMap(prisma, productId, storyIds, excludeSprintId):
    map storyId → { sprintId, sprintName } voor stories in andere OPEN sprint
- Tests: __tests__/lib/sprint-conflicts.test.ts (16 cases) — alle eligibility
  paden + cross-sprint scoping + CLOSED-sprint filtering.

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

* feat(PBI-79/ST-1335): sprint-membership-summary + cross-sprint-blocks endpoints

Twee nieuwe GET-route handlers, beide verplicht gescoped op pbiIds (geen
product-brede aanroepen).

- app/api/products/[id]/sprint-membership-summary/route.ts
  Response: { [pbiId]: { total, inSprint } } via twee prisma.groupBy calls
  (totaal + binnen actieve sprint). Voor state-B tri-state.

- app/api/products/[id]/cross-sprint-blocks/route.ts
  Response: { [storyId]: { sprintId, sprintName } } voor stories in andere
  OPEN sprints. UX-hint voor disabled-vinkjes; commit-acties blijven
  autoritatief.

Tests: 13 cases dekken happy path, 400 zonder pbiIds, 400 zonder sprintId,
404 zonder product-access, auth-fail, en NOT-clause voor excludeSprintId.

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

* feat(PBI-79/ST-1336): product-workspace sprint-membership slice + selectors

Datalaag voor de vinkje-UI van state A′ en state B.

types.ts:
- PbiSummaryEntry, CrossSprintBlock, SprintMembershipSlice toegevoegd.

store.ts:
- Nieuwe slice `sprintMembership` met pbiSummary, crossSprintBlocks,
  pending: { adds[], removes[] }, loadedSummaryForSprintId.
- Acties: setPbiSummary, setCrossSprintBlocks, toggleStorySprintMembership
  (cancel-out logic), resetSprintMembershipPending, fetchSprintMembershipSummary,
  fetchCrossSprintBlocks.
- hydrateSnapshot reset óók de membership-slice.

selectors.ts:
- selectPbiTriState (aggregate-only zolang stories niet geladen; rekent
  pending mee bij loaded PBI's).
- selectStoryEffectiveInSprint (DB ⊕ pending).
- selectStoryIsBlocked (cross-sprint hint).
- selectIsDirty, selectPendingCount.

Tests: 25 cases in nieuwe sprint-membership.test.ts dekken alle selector-
paden, toggle-cancel-out, fetch-helpers, en pbiId-scoping.

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

* feat(PBI-79/ST-1337): state A′ UI — metadata dialog + sticky banner + PbiList ombouw

UI-laag voor de sprint-definitie-flow (state A′).

Nieuw:
- NewSprintMetadataDialog (stap 1): sprint_goal + optionele dates;
  'Verder' schrijft via useUserSettingsStore.setPendingSprintDraft.
- SprintDefinitionBanner (sticky): toont doel + X PBI's / Y stories teller;
  'Annuleren' → AlertDialog confirm → clearPendingSprintDraft;
  'Sprint aanmaken' nog niet aangesloten (wacht op ST-1339).
- NewSprintTrigger: button in page header die de metadata-dialog opent;
  verbergt zichzelf zolang er al een draft loopt.
- SprintDraftBanner: client-wrapper, rendert banner alleen als draft bestaat.

Wijzigingen:
- lib/user-settings.ts: pendingSprintDraft startAt/endAt → z.string().date().
- PbiList: oude selectionMode + selectedIds + NewSprintDialog vervangen door
  hasDraft-afgeleide A′-mode met tri-state vinkjes; togglen muteert
  upsertPbiIntent('all'|'none') en wist storyOverrides per PBI.
- StoryPanel: in A′-mode toont elke story een cherrypick-checkbox die
  upsertStoryOverride('add'/'remove'/'clear') aanroept; cross-sprint-blocked
  stories krijgen disabled-icoon met sprint-naam tooltip.
- app/(app)/products/[id]/page.tsx: StartSprintButton vervangen door
  NewSprintTrigger; SprintDraftBanner gepositioneerd boven split-pane.

Tests: bestaande tests blijven groen (806 cases) — UI-specifieke component
tests volgen later. ST-1339 sluit createSprintWithSelectionAction aan.

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

* feat(PBI-79/ST-1339): createSprintWithSelectionAction + banner wire-up

actions/sprints.ts:
- Nieuwe createSprintWithSelectionAction(productId, metadata, pbiIntent,
  storyOverrides).
- Server-side intent-resolve:
  1. Voor elke PBI met intent='all': fetch child-story-IDs minus
     storyOverrides[pbi].remove.
  2. Plus storyOverrides[*].add (cross-PBI cherrypick toegestaan).
- Eligibility-filter via partitionByEligibility (sprint_id IS NULL + status
  != DONE; stories in andere OPEN sprint → conflicts.crossSprint).
- Transactie wrapt sprint.create + story.updateMany (status='IN_SPRINT') +
  task.updateMany (sprint_id cascade) — alles atomair.
- setActiveSprintInSettings na success.
- Return: { success, sprintId, affectedStoryIds, affectedPbiIds,
  affectedTaskIds, conflicts: { notEligible, crossSprint } } of error.

components/backlog/sprint-definition-banner.tsx:
- 'Sprint aanmaken'-knop sluit aan op createSprintWithSelectionAction;
  toast bij conflicts, success-toast anders, router.refresh() voor SSR
  cycle. Pending draft wordt door de action zelf nog niet expliciet gewist
  — dat gebeurt via revalidatePath en kan in ST-1340 finetuned worden.

Tests: __tests__/actions/create-sprint-with-selection.test.ts (6 cases)
dekken intent-resolve, override-respect, cross-sprint conflict, transactie-
binding van story.status + task.sprint_id, return-shape, en error-pad.

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

* feat(PBI-79/ST-1340): commitSprintMembershipAction + gerichte client-store patches

actions/sprints.ts:
- Nieuwe commitSprintMembershipAction(activeSprintId, adds[], removes[]).
- Eligibility-filter voor adds via partitionByEligibility (sprint_id IS NULL
  en niet DONE; cross-sprint conflicts → notEligible).
- Race-safety voor removes: alleen stories met huidige sprint_id ==
  activeSprintId; rest → conflicts.alreadyRemoved.
- Transactie wrapt twee updateMany-paren (story status mee, task.sprint_id
  cascade). Update-paren overgeslagen wanneer leeg.
- Return: { success, affectedStoryIds, affectedPbiIds, affectedTaskIds,
  conflicts: { notEligible, alreadyRemoved } }.

stores/product-workspace/store.ts:
- applyMembershipCommitResult({ activeSprintId, addedStoryIds,
  removedStoryIds }) patcht entities.storiesById met juiste sprint_id +
  status; ledigt sprintMembership.pending. Geen task-veld omdat
  BacklogTask geen sprint_id-kolom heeft in de store.

Tests: __tests__/actions/commit-sprint-membership.test.ts (8 cases) — happy
path, DONE-conflict, cross-sprint, race-safety voor removes, transactie-
inhoud (status='IN_SPRINT'/'OPEN'), task-cascade, return-shape, auth-fail.

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

* feat(PBI-79/ST-1338): state B vinkjes-UI + 'Sprint opslaan'-knop met teller

State B (actieve sprint geselecteerd, geen draft) hangt nu aan dezelfde
vinkje-UI als state A′, maar muteert de transient pending-buffer in plaats
van de draft.

- PbiList: nieuwe prop activeSprintId. selectionMode = hasDraft ||
  stateBMode. togglePbiInDraft routeert naar upsertPbiIntent (A′) of bulk-
  toggleStorySprintMembership over eligible child-stories (B, skip blocked).
- StoryPanel: idem prop activeSprintId. StoryBlockWithCherrypick muteert
  draft via upsertStoryOverride in A′ of pending buffer via
  toggleStorySprintMembership in B (cross-sprint blocked = disabled).
- SaveSprintButton (nieuw): client component in page header, alleen
  zichtbaar als er een actieve sprint is. Disabled bij clean buffer,
  enabled met teller bij dirty. Klikken calls commitSprintMembershipAction
  → applyMembershipCommitResult gericht in store + toast bij conflicts.
- page.tsx: activeSprintItem.id wordt doorgegeven aan PbiList, StoryPanel
  en SaveSprintButton.

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

* feat(PBI-79/ST-1341+ST-1342): SprintEditDialog metadata-edit + multi-OPEN sprints

ST-1341 (T-946):
- actions/sprints.ts: nieuwe updateSprintAction(sprintId, fields) — JSON
  input, accepteert optionele goal/startAt/endAt; auth + product-access
  check, prisma.sprint.update, revalidatePath. Type-safe return.
- components/backlog/sprint-edit-dialog.tsx: Entity-Dialog-pattern voor
  metadata-edit van een sprint. Velden: sprint_goal, start_date, end_date.
  Link 'Sprint afronden… →' naar bestaande /products/[id]/sprint/[sprintId]
  zodat de completion-flow (per-story DONE/OPEN beslissing + PBI-promotie)
  niet wordt geduplicereerd. useDirtyCloseGuard.

ST-1342 (T-947):
- actions/sprints.ts: OPEN-uniqueness check in createSprintAction
  verwijderd. Een product mag nu meerdere OPEN sprints tegelijk hebben;
  cross-sprint-conflicts per story worden afgevangen door
  partitionByEligibility in de membership-commit-flow.

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

* test(PBI-79/ST-1344): updateSprintAction regression coverage

Audits van de geplande non-regressie-tests laten zien dat alle invarianten
uit het ST-1344 plan reeds gedekt zijn door eerder toegevoegde tests:

- clearActiveSprintAction null-not-delete → __tests__/lib/active-sprint.test.ts
  + __tests__/actions/active-sprint-action.test.ts
- Endpoints rejecten zonder pbiIds (400) → __tests__/api/sprint-membership-summary.test.ts
  + __tests__/api/cross-sprint-blocks.test.ts
- Status-mutaties story.status=IN_SPRINT/OPEN met task.sprint_id cascade
  in dezelfde transactie → __tests__/actions/create-sprint-with-selection.test.ts
  + __tests__/actions/commit-sprint-membership.test.ts
- Cross-sprint conflicts + DONE-eligibility → __tests__/lib/sprint-conflicts.test.ts

Nieuw: __tests__/actions/update-sprint.test.ts (6 cases) dekt
updateSprintAction die nog geen tests had — goal alleen, dates alleen,
null-clear, 403 zonder access, lege goal weigering, leeg fields-object
weigering.

Handmatige E2E checklist (T-949) blijft staan voor menselijke browser-
validatie tijdens PR-review.

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

* fix(PBI-79): PBI-rij selecteert weer in A′/B-modus; vinkje is aparte trigger

Voor PBI-79 maakte het hele PBI-kaartje in selectionMode (state A′ én B)
de toggle. Daardoor:
- klik op rij = bulk-toggle stories (teller liep op);
- geen setActivePbi, dus StoryPanel kreeg geen content.

Fix: in selectionMode wordt onClick = onSelect (PBI activeren → stories
laden) en de tri-state-iconen verhuizen naar een eigen <button> in de
actions-slot met stopPropagation. Toggle gedrag (bulk add/remove in B,
upsertPbiIntent in A′) blijft ongewijzigd via die knop.

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

* fix(PBI-79): cascade-restore alleen als hint-story bij nieuwe PBI hoort

Bug: setActivePbi reset activeStoryId/activeTaskId, maar het cascade-
restore-pad zette daarna een hint-story actief zonder te valideren of die
story bij de nieuw-geselecteerde PBI hoort. Bij PBI-switch bleef daardoor
de task-kolom de taken van de vorige story tonen.

Fix: alleen setActiveStory(hint) als entities.storiesById[hint].pbi_id ===
pbiId. Bij mismatch blijft activeStoryId null en is de task-kolom leeg
totdat de gebruiker een story uit de nieuwe PBI kiest.

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

* feat(PBI-79): sprint-switch auto-select PBI/story + user-settings persist

Bij sprint-switch wordt de sprint-content server-side opgevraagd. Wanneer
de sprint precies één PBI (en die PBI exact één story binnen de sprint)
heeft, worden PBI en story automatisch geselecteerd. Alle drie keuzes
(sprint, pbi, story) worden atomair in user-settings opgeslagen zodat ze
cross-device blijven hangen.

- lib/user-settings.ts: layout krijgt nullable activePbis +
  activeStories per product.
- lib/active-sprint.ts: setActiveSelectionInSettings schrijft de drie
  keys atomair + notify pg_notify.
- actions/active-sprint.ts: switchActiveSprintAction(productId, sprintId)
  doet de server-side auto-select-resolutie (single PBI → single story)
  en returnt { sprintId, pbiId, storyId }.
- components/shared/sprint-switcher.tsx: handleSwitchSprint roept de
  nieuwe action aan en synchroniseert de workspace-store gelijk zodat
  de UI geen flash krijgt voor de SSR-refresh.
- components/backlog/active-selection-hydrator.tsx (nieuw): client-side
  effect dat user-settings.activePbis/activeStories naar workspace-store
  spiegelt; wint van de localStorage hint-restore.
- app/(app)/products/[id]/page.tsx: ActiveSelectionHydrator gemount
  binnen BacklogHydrationWrapper.

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

* docs(PBI-79): plan-update met implementatie-stand + scope-aanpassing

Documenteert wat er sinds de eerste implementatie-pass is gebeurd:
- Tabel van 14 commits met hun rol.
- Twee bugs die tijdens testen boven kwamen (PBI-rij-klik, cascade-restore).
- Nieuwe feature sprint-switch auto-select (server resolveert single-PBI/
  single-story; user-settings persist).

En kondigt scope-aanpassing aan voor de volgende implementatie-ronde:
- pendingSprintDraft wordt session-only (geen server-persist meer).
- useDirtyCloseGuard wist draft op leave-with-confirm.
- Sprint-switcher krijgt concept-entry zolang er een draft loopt.

De rest van het plan beneden blijft van kracht behalve waar deze sectie
het overruled.

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

* feat(PBI-79): pendingSprintDraft session-only + concept-entry + leave-guard

Scope-aanpassing uit plan-revisie: drafts persisten niet meer server-side.

Wijzigingen:
- stores/user-settings/store.ts:
  - hydrate() strip nu workflow.pendingSprintDraft uit serverstate
    (legacy DB-entries blijven harmless aanwezig maar worden niet
    gehydreerd → effectief unreachable voor de UI).
  - setPendingSprintDraft / clearPendingSprintDraft worden lokale-only;
    geen import van sprint-draft-actions, geen server-roundtrip.
  - upsertPbiIntent / upsertStoryOverride blijven via setPendingSprintDraft
    routeren → ook session-only.
- components/shared/sprint-switcher.tsx: leest draft-goal uit user-settings
  store en toont '⚙ Concept — [goal]' als niet-selecteerbare entry
  bovenaan de dropdown zolang er een draft loopt.
- components/backlog/sprint-draft-leave-guard.tsx (nieuw): registreert
  een beforeunload-listener zolang er een draft is. Browser-refresh,
  tab-close en back-navigatie tonen daarmee de standaard confirm. In-app
  route-changes blijven via de banner-Annuleren-knop lopen.
- app/(app)/products/[id]/page.tsx: SprintDraftLeaveGuard gemount naast
  de banner.
- Tests: user-settings store-tests aangepast (geen server-call assert
  meer, hydrate strip-assert toegevoegd; upsert-tests seed nu via
  setPendingSprintDraft i.p.v. legacy hydrate).

setPendingSprintDraftAction + clearPendingSprintDraftAction blijven bestaan
voor eventuele toekomstige opruim-flows, maar worden niet meer aangeroepen
vanuit de UI.

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

* docs(PBI-79): mark scope-aanpassing afgerond + localStorage overzicht

- Drie open punten uit plan-revisie afgevinkt (commit 2a4ee6a).
- Sectie 'Bewust niet geïmplementeerd': server-persist van manuele
  PBI/story-klikken — op vraag van user nu out-of-scope voor deze PR.
- Tabel localStorage-gebruik in de codebase voor toekomstige referentie.

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

---------

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

__tests__/lib/active-sprint.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('@/lib/prisma', () => ({
+  prisma: {
+    sprint: { findFirst: vi.fn() },
+    user: {
+      findUnique: vi.fn(),
+      update: vi.fn().mockResolvedValue({}),
+    },
+    $executeRaw: vi.fn().mockResolvedValue(1),
+  },
+}))
+
+import { prisma } from '@/lib/prisma'
+import type { UserSettings } from '@/lib/user-settings'
+import {
+  clearActiveSprintInSettings,
+  readStoredActiveSprintState,
+  resolveActiveSprint,
+} from '@/lib/active-sprint'
+
+const mockPrisma = prisma as unknown as {
+  sprint: { findFirst: ReturnType<typeof vi.fn> }
+  user: {
+    findUnique: ReturnType<typeof vi.fn>
+    update: ReturnType<typeof vi.fn>
+  }
+  $executeRaw: ReturnType<typeof vi.fn>
+}
+
+function withSettings(settings: UserSettings) {
+  mockPrisma.user.findUnique.mockResolvedValueOnce({ settings })
+}
+
+describe('readStoredActiveSprintState', () => {
+  it('returns unset when activeSprints map is absent', () => {
+    expect(readStoredActiveSprintState({}, 'p1')).toEqual({ kind: 'unset' })
+  })
+
+  it('returns unset when productId key is absent', () => {
+    const settings: UserSettings = {
+      layout: { activeSprints: { p2: 'sprint-2' } },
+    }
+    expect(readStoredActiveSprintState(settings, 'p1')).toEqual({
+      kind: 'unset',
+    })
+  })
+
+  it('returns cleared when key is present with null value', () => {
+    const settings: UserSettings = {
+      layout: { activeSprints: { p1: null } },
+    }
+    expect(readStoredActiveSprintState(settings, 'p1')).toEqual({
+      kind: 'cleared',
+    })
+  })
+
+  it('returns set when key is present with string value', () => {
+    const settings: UserSettings = {
+      layout: { activeSprints: { p1: 'sprint-1' } },
+    }
+    expect(readStoredActiveSprintState(settings, 'p1')).toEqual({
+      kind: 'set',
+      sprintId: 'sprint-1',
+    })
+  })
+})
+
+describe('resolveActiveSprint', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('returns null without fallback when key is explicitly null (cleared)', async () => {
+    withSettings({ layout: { activeSprints: { p1: null } } })
+
+    const result = await resolveActiveSprint('p1', 'user-1')
+
+    expect(result).toBeNull()
+    expect(mockPrisma.sprint.findFirst).not.toHaveBeenCalled()
+  })
+
+  it('returns the stored sprint when key is set and sprint exists', async () => {
+    withSettings({ layout: { activeSprints: { p1: 'sprint-1' } } })
+    mockPrisma.sprint.findFirst.mockResolvedValueOnce({
+      id: 'sprint-1',
+      code: 'SP-1',
+      status: 'OPEN',
+    })
+
+    const result = await resolveActiveSprint('p1', 'user-1')
+
+    expect(result).toEqual({ id: 'sprint-1', code: 'SP-1', status: 'OPEN' })
+    expect(mockPrisma.sprint.findFirst).toHaveBeenCalledTimes(1)
+  })
+
+  it('falls back when stored sprint is not found in DB', async () => {
+    withSettings({ layout: { activeSprints: { p1: 'stale-id' } } })
+    mockPrisma.sprint.findFirst
+      .mockResolvedValueOnce(null) // stored lookup misses
+      .mockResolvedValueOnce({ id: 'sprint-open', code: 'SP-O', status: 'OPEN' })
+
+    const result = await resolveActiveSprint('p1', 'user-1')
+
+    expect(result).toEqual({
+      id: 'sprint-open',
+      code: 'SP-O',
+      status: 'OPEN',
+    })
+  })
+
+  it('falls back to first OPEN sprint when key is absent', async () => {
+    withSettings({})
+    mockPrisma.sprint.findFirst.mockResolvedValueOnce({
+      id: 'sprint-open',
+      code: 'SP-O',
+      status: 'OPEN',
+    })
+
+    const result = await resolveActiveSprint('p1', 'user-1')
+
+    expect(result).toEqual({
+      id: 'sprint-open',
+      code: 'SP-O',
+      status: 'OPEN',
+    })
+  })
+
+  it('falls back to recent CLOSED sprint when no OPEN exists', async () => {
+    withSettings({})
+    mockPrisma.sprint.findFirst
+      .mockResolvedValueOnce(null) // no OPEN
+      .mockResolvedValueOnce({
+        id: 'sprint-closed',
+        code: 'SP-C',
+        status: 'CLOSED',
+      })
+
+    const result = await resolveActiveSprint('p1', 'user-1')
+
+    expect(result).toEqual({
+      id: 'sprint-closed',
+      code: 'SP-C',
+      status: 'CLOSED',
+    })
+  })
+
+  it('returns null when key absent and no sprints exist', async () => {
+    withSettings({})
+    mockPrisma.sprint.findFirst.mockResolvedValue(null)
+
+    const result = await resolveActiveSprint('p1', 'user-1')
+
+    expect(result).toBeNull()
+  })
+})
+
+describe('clearActiveSprintInSettings', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('writes null instead of deleting the key', async () => {
+    withSettings({
+      layout: { activeSprints: { p1: 'sprint-1', p2: 'sprint-2' } },
+    })
+
+    await clearActiveSprintInSettings('user-1', 'p1')
+
+    expect(mockPrisma.user.update).toHaveBeenCalledTimes(1)
+    const updateArg = mockPrisma.user.update.mock.calls[0][0] as {
+      data: { settings: UserSettings }
+    }
+    expect(updateArg.data.settings.layout?.activeSprints).toEqual({
+      p1: null,
+      p2: 'sprint-2',
+    })
+  })
+
+  it('adds the key with null when previously unset', async () => {
+    withSettings({})
+
+    await clearActiveSprintInSettings('user-1', 'p1')
+
+    const updateArg = mockPrisma.user.update.mock.calls[0][0] as {
+      data: { settings: UserSettings }
+    }
+    expect(updateArg.data.settings.layout?.activeSprints).toEqual({ p1: null })
+  })
+})

__tests__/lib/sprint-conflicts.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, vi } from 'vitest'
+import type { StoryStatus } from '@prisma/client'
+
+import {
+  getBlockingSprintMap,
+  isEligibleForSprint,
+  partitionByEligibility,
+} from '@/lib/sprint-conflicts'
+
+function mockPrisma(stories: Array<Record<string, unknown>>) {
+  return {
+    story: {
+      findMany: vi.fn().mockResolvedValue(stories),
+    },
+  } as unknown as Parameters<typeof partitionByEligibility>[0]
+}
+
+describe('isEligibleForSprint', () => {
+  it('returns true for OPEN story without sprint', () => {
+    expect(
+      isEligibleForSprint({ sprint_id: null, status: 'OPEN' as StoryStatus }),
+    ).toBe(true)
+  })
+
+  it('returns true for IN_SPRINT story without sprint_id (edge: restoration)', () => {
+    expect(
+      isEligibleForSprint({
+        sprint_id: null,
+        status: 'IN_SPRINT' as StoryStatus,
+      }),
+    ).toBe(true)
+  })
+
+  it('returns false for DONE story without sprint', () => {
+    expect(
+      isEligibleForSprint({ sprint_id: null, status: 'DONE' as StoryStatus }),
+    ).toBe(false)
+  })
+
+  it('returns false when story is in any sprint (open status)', () => {
+    expect(
+      isEligibleForSprint({
+        sprint_id: 'abc',
+        status: 'OPEN' as StoryStatus,
+      }),
+    ).toBe(false)
+  })
+
+  it('returns false when story is in any sprint (done status)', () => {
+    expect(
+      isEligibleForSprint({
+        sprint_id: 'abc',
+        status: 'DONE' as StoryStatus,
+      }),
+    ).toBe(false)
+  })
+})
+
+describe('partitionByEligibility', () => {
+  it('returns empty partition for empty input', async () => {
+    const prisma = mockPrisma([])
+    const result = await partitionByEligibility(prisma, [])
+    expect(result).toEqual({ eligible: [], notEligible: [], crossSprint: [] })
+  })
+
+  it('classifies all eligible when stories are free + OPEN', async () => {
+    const prisma = mockPrisma([
+      { id: 's1', sprint_id: null, status: 'OPEN', sprint: null },
+      { id: 's2', sprint_id: null, status: 'IN_SPRINT', sprint: null },
+    ])
+    const result = await partitionByEligibility(prisma, ['s1', 's2'])
+    expect(result.eligible).toEqual(['s1', 's2'])
+    expect(result.notEligible).toEqual([])
+    expect(result.crossSprint).toEqual([])
+  })
+
+  it('marks DONE stories as notEligible with reason=DONE', async () => {
+    const prisma = mockPrisma([
+      { id: 's1', sprint_id: null, status: 'DONE', sprint: null },
+    ])
+    const result = await partitionByEligibility(prisma, ['s1'])
+    expect(result.eligible).toEqual([])
+    expect(result.notEligible).toEqual([{ storyId: 's1', reason: 'DONE' }])
+  })
+
+  it('marks stories in other OPEN sprint as crossSprint + notEligible', async () => {
+    const prisma = mockPrisma([
+      {
+        id: 's1',
+        sprint_id: 'sprint-other',
+        status: 'IN_SPRINT',
+        sprint: { id: 'sprint-other', code: 'SP-2', status: 'OPEN' },
+      },
+    ])
+    const result = await partitionByEligibility(prisma, ['s1'])
+    expect(result.crossSprint).toEqual([
+      { storyId: 's1', sprintId: 'sprint-other', sprintName: 'SP-2' },
+    ])
+    expect(result.notEligible).toEqual([
+      { storyId: 's1', reason: 'IN_OTHER_SPRINT' },
+    ])
+    expect(result.eligible).toEqual([])
+  })
+
+  it('classifies story in CLOSED sprint with status=OPEN as eligible (status reset already happened)', async () => {
+    const prisma = mockPrisma([
+      {
+        id: 's1',
+        sprint_id: null,
+        status: 'OPEN',
+        sprint: null,
+      },
+    ])
+    const result = await partitionByEligibility(prisma, ['s1'])
+    expect(result.eligible).toEqual(['s1'])
+  })
+
+  it('does NOT mark crossSprint for stories in CLOSED other sprint', async () => {
+    const prisma = mockPrisma([
+      {
+        id: 's1',
+        sprint_id: 'sprint-closed',
+        status: 'DONE',
+        sprint: { id: 'sprint-closed', code: 'SP-C', status: 'CLOSED' },
+      },
+    ])
+    const result = await partitionByEligibility(prisma, ['s1'])
+    expect(result.crossSprint).toEqual([])
+    expect(result.notEligible).toEqual([
+      { storyId: 's1', reason: 'IN_OTHER_SPRINT' },
+    ])
+  })
+
+  it('respects excludeSprintId — story in same sprint is eligible', async () => {
+    const prisma = mockPrisma([
+      {
+        id: 's1',
+        sprint_id: 'sprint-active',
+        status: 'IN_SPRINT',
+        sprint: { id: 'sprint-active', code: 'SP-A', status: 'OPEN' },
+      },
+    ])
+    const result = await partitionByEligibility(prisma, ['s1'], 'sprint-active')
+    expect(result.eligible).toEqual(['s1'])
+    expect(result.crossSprint).toEqual([])
+  })
+})
+
+describe('getBlockingSprintMap', () => {
+  it('returns empty map for empty input', async () => {
+    const prisma = mockPrisma([])
+    const result = await getBlockingSprintMap(prisma, 'p1', [])
+    expect(result.size).toBe(0)
+  })
+
+  it('returns blocking sprint info for stories in OPEN sprints', async () => {
+    const prisma = mockPrisma([
+      {
+        id: 's1',
+        sprint_id: 'sprint-x',
+        sprint: { id: 'sprint-x', code: 'SP-X', status: 'OPEN' },
+      },
+    ])
+    const result = await getBlockingSprintMap(prisma, 'p1', ['s1'])
+    expect(result.get('s1')).toEqual({
+      sprintId: 'sprint-x',
+      sprintName: 'SP-X',
+    })
+  })
+
+  it('excludes the active sprint from blocking', async () => {
+    const prisma = mockPrisma([
+      {
+        id: 's1',
+        sprint_id: 'sprint-active',
+        sprint: { id: 'sprint-active', code: 'SP-A', status: 'OPEN' },
+      },
+    ])
+    const result = await getBlockingSprintMap(
+      prisma,
+      'p1',
+      ['s1'],
+      'sprint-active',
+    )
+    expect(result.size).toBe(0)
+  })
+
+  it('does not include CLOSED sprints (filtered at DB query level)', async () => {
+    // The prisma mock receives WHERE sprint.status='OPEN' so CLOSED stories
+    // are already filtered out before reaching this function's mapping logic.
+    const prisma = mockPrisma([])
+    const result = await getBlockingSprintMap(prisma, 'p1', ['s1'])
+    expect(result.size).toBe(0)
+  })
+})

__tests__/lib/user-settings.test.ts

@@ -122,4 +122,65 @@ describe('UserSettingsSchema', () => {
       layout: { splitPanePositions: { x: [50, 50] }, activeSprints: { p: 's' } },
     }).success).toBe(true)
   })
+
+  it('accepts null values in activeSprints (explicit "no active sprint")', () => {
+    const result = UserSettingsSchema.safeParse({
+      layout: { activeSprints: { 'product-1': null, 'product-2': 'sprint-2' } },
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.layout?.activeSprints).toEqual({
+        'product-1': null,
+        'product-2': 'sprint-2',
+      })
+    }
+  })
+
+  it('accepts pendingSprintDraft with per-PBI intent and overrides', () => {
+    const result = UserSettingsSchema.safeParse({
+      workflow: {
+        pendingSprintDraft: {
+          'product-1': {
+            goal: 'Sprint goal',
+            pbiIntent: { pbiA: 'all', pbiB: 'none' },
+            storyOverrides: {
+              pbiA: { add: [], remove: ['story-1'] },
+              pbiB: { add: ['story-2'], remove: [] },
+            },
+          },
+        },
+      },
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('fills empty defaults for pbiIntent and storyOverrides in draft', () => {
+    const result = UserSettingsSchema.safeParse({
+      workflow: { pendingSprintDraft: { 'product-1': { goal: 'g' } } },
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      const draft = result.data.workflow?.pendingSprintDraft?.['product-1']
+      expect(draft?.pbiIntent).toEqual({})
+      expect(draft?.storyOverrides).toEqual({})
+    }
+  })
+
+  it('rejects pendingSprintDraft with empty goal', () => {
+    const result = UserSettingsSchema.safeParse({
+      workflow: { pendingSprintDraft: { 'p': { goal: '' } } },
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects unknown intent value', () => {
+    const result = UserSettingsSchema.safeParse({
+      workflow: {
+        pendingSprintDraft: {
+          p: { goal: 'x', pbiIntent: { a: 'partial' } },
+        },
+      },
+    })
+    expect(result.success).toBe(false)
+  })
 })