Load/render workspace alignment (#182)

* docs: plan load render workspace alignment

* fix: normalize workspace status hydration

* fix: avoid duplicate backlog hydration load

* refactor: use sprint store active story

* refactor: migrate solo to workspace store

* chore: stabilize verification ignores

lib/insights/agent-throughput.ts

@@ -22,8 +22,6 @@ export interface JobsPerDayResult {
   kpi: ThroughputKpi
 }
 
-const STATUSES = ['queued', 'claimed', 'running', 'done', 'failed', 'cancelled', 'skipped'] as const
-
 type RawDayRow = { day: Date; status: string; count: bigint }
 type RawKpiRow = { today_count: bigint; done_7d: bigint; terminal_7d: bigint; avg_seconds: number | null }
 

lib/realtime/use-solo-realtime.ts

@@ -7,11 +7,9 @@
 //   productId niet null is; sluit de stream als productId null wordt.
 // - Reconnect met exponential backoff (1s → 30s, reset bij ready).
 // - PBI-74: stream blijft open op tab hidden (geen close meer). Bij
-//   hidden→visible en bij window 'online' triggeren we router.refresh()
-//   zodat gemiste events alsnog binnenkomen via een verse server-render
-//   (re-fetcht initialTasks → initTasks reset solo-store). Postgres NOTIFY
-//   heeft geen replay, dus zonder deze resync zouden hidden-tab events
-//   permanent verloren zijn — zelfde fix als Story 5 voor backlog-realtime.
+//   hidden→visible en bij window 'online' triggeren we een directe
+//   workspace-store resync. Postgres NOTIFY heeft geen replay, dus zonder deze
+//   resync zouden hidden-tab events permanent verloren zijn.
 // - Cleanup op unmount.
 // - Connection-status (status, showConnectingIndicator) wordt naar de
 //   solo-store geschreven; UI-componenten lezen daar uit.
@@ -24,7 +22,6 @@
 
 import { useEffect, useRef } from 'react'
 import { flushSync } from 'react-dom'
-import { useRouter } from 'next/navigation'
 import { useSoloStore } from '@/stores/solo-store'
 import type { ClaudeJobEvent, JobState, RealtimeEvent, RealtimeStatus } from '@/stores/solo-store'
 
@@ -33,7 +30,6 @@ const BACKOFF_MAX_MS = 30_000
 const CONNECTING_INDICATOR_DELAY_MS = 4_000
 
 export function useSoloRealtime(productId: string | null) {
-  const router = useRouter()
   const sourceRef = useRef<EventSource | null>(null)
   const backoffRef = useRef<number>(BACKOFF_START_MS)
   const reconnectTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
@@ -97,10 +93,9 @@ export function useSoloRealtime(productId: string | null) {
         backoffRef.current = BACKOFF_START_MS
         scheduleIndicator('open')
         readyCountRef.current += 1
-        // PBI-74: latere ready = post-reconnect → resync via router.refresh()
-        // zodat gemiste tasks-state via re-render initial-prop binnenkomt.
+        // PBI-74: latere ready = post-reconnect → directe workspace-resync.
         if (readyCountRef.current > 1) {
-          router.refresh()
+          void useSoloStore.getState().resyncActiveScopes('reconnect')
         }
       })
 
@@ -189,19 +184,19 @@ export function useSoloRealtime(productId: string | null) {
 
     // PBI-74: stream blijft open op hidden. Reconnect alleen als de stream
     // door netwerkfout/server-close weg is en de tab visible is. Bij iedere
-    // visible-overgang triggeren we router.refresh() — gemiste events tijdens
-    // throttling/freeze worden via een verse server-render alsnog opgepakt.
+    // visible-overgang triggeren we een store-resync — gemiste events tijdens
+    // throttling/freeze worden via de solo-workspace route alsnog opgepakt.
     const onVisibility = () => {
       if (document.visibilityState !== 'visible') return
       if (sourceRef.current === null) {
         backoffRef.current = BACKOFF_START_MS
         connect()
       }
-      router.refresh()
+      void useSoloStore.getState().resyncActiveScopes('visible')
     }
 
     const onOnline = () => {
-      router.refresh()
+      void useSoloStore.getState().resyncActiveScopes('reconnect')
     }
 
     connect()
@@ -215,5 +210,5 @@ export function useSoloRealtime(productId: string | null) {
       close()
       readyCountRef.current = 0
     }
-  }, [productId, router])
+  }, [productId])
 }

lib/solo-workspace-server.ts

@@ -0,0 +1,107 @@
+import 'server-only'
+
+import { prisma } from '@/lib/prisma'
+import { getAccessibleProduct } from '@/lib/product-access'
+import { resolveActiveSprint } from '@/lib/active-sprint'
+import type {
+  SoloTask,
+  SoloUnassignedStory,
+  SoloWorkspaceSnapshot,
+} from '@/stores/solo-workspace/types'
+
+export async function getSoloWorkspaceSnapshot(
+  productId: string,
+  userId: string,
+  sprintId?: string | null,
+): Promise<SoloWorkspaceSnapshot | null> {
+  const product = await getAccessibleProduct(productId, userId)
+  if (!product) return null
+
+  const active = sprintId ? { id: sprintId } : await resolveActiveSprint(productId)
+  const sprint = active
+    ? await prisma.sprint.findFirst({ where: { id: active.id, product_id: productId } })
+    : null
+  if (!sprint) return null
+
+  const [rawTasks, rawUnassigned] = await Promise.all([
+    prisma.task.findMany({
+      where: {
+        story: {
+          sprint_id: sprint.id,
+          assignee_id: userId,
+        },
+      },
+      include: {
+        story: {
+          select: {
+            id: true,
+            code: true,
+            title: true,
+            tasks: { select: { id: true }, orderBy: { sort_order: 'asc' } },
+            pbi: { select: { code: true, title: true, description: true } },
+          },
+        },
+      },
+      orderBy: [
+        { story: { pbi: { priority: 'asc' } } },
+        { story: { pbi: { sort_order: 'asc' } } },
+        { story: { sort_order: 'asc' } },
+        { priority: 'asc' },
+        { sort_order: 'asc' },
+      ],
+    }),
+    prisma.story.findMany({
+      where: { sprint_id: sprint.id, assignee_id: null },
+      select: {
+        id: true,
+        code: true,
+        title: true,
+        tasks: {
+          select: { id: true, title: true, description: true, priority: true, status: true },
+          orderBy: [{ priority: 'asc' }, { sort_order: 'asc' }],
+        },
+      },
+      orderBy: { sort_order: 'asc' },
+    }),
+  ])
+
+  const tasks: SoloTask[] = rawTasks.map((task) => ({
+    id: task.id,
+    title: task.title,
+    description: task.description,
+    implementation_plan: task.implementation_plan,
+    priority: task.priority,
+    sort_order: task.sort_order,
+    status: task.status as SoloTask['status'],
+    verify_only: task.verify_only,
+    verify_required: task.verify_required as SoloTask['verify_required'],
+    story_id: task.story.id,
+    story_code: task.story.code,
+    story_title: task.story.title,
+    task_code: task.code,
+    pbi_code: task.story.pbi?.code ?? null,
+    pbi_title: task.story.pbi?.title ?? null,
+    pbi_description: task.story.pbi?.description ?? null,
+  }))
+
+  const unassignedStories: SoloUnassignedStory[] = rawUnassigned.map((story) => ({
+    id: story.id,
+    code: story.code,
+    title: story.title,
+    tasks: story.tasks.map((task) => ({
+      id: task.id,
+      title: task.title,
+      description: task.description,
+      priority: task.priority,
+      status: task.status,
+    })),
+  }))
+
+  return {
+    product: { id: product.id, name: product.name, repo_url: product.repo_url },
+    sprint: { id: sprint.id, sprint_goal: sprint.sprint_goal },
+    activeUserId: userId,
+    tasks,
+    unassignedStories,
+  }
+}