Round system redesign: Phases 1-7 complete

Full pipeline/track/stage architecture replacing the legacy round system.

Schema: 11 new models (Pipeline, Track, Stage, StageTransition,
ProjectStageState, RoutingRule, Cohort, CohortProject, LiveProgressCursor,
OverrideAction, AudienceVoter) + 8 new enums.

Backend: 9 new routers (pipeline, stage, routing, stageFiltering,
stageAssignment, cohort, live, decision, award) + 6 new services
(stage-engine, routing-engine, stage-filtering, stage-assignment,
stage-notifications, live-control).

Frontend: Pipeline wizard (17 components), jury stage pages (7),
applicant pipeline pages (3), public stage pages (2), admin pipeline
pages (5), shared stage components (3), SSE route, live hook.

Phase 6 refit: 23 routers/services migrated from roundId to stageId,
all frontend components refitted. Deleted round.ts (985 lines),
roundTemplate.ts, round-helpers.ts, round-settings.ts, round-type-settings.tsx,
10 legacy admin pages, 7 legacy jury pages, 3 legacy dialogs.

Phase 7 validation: 36 tests (10 unit + 8 integration files) all passing,
TypeScript 0 errors, Next.js build succeeds, 13 integrity checks,
legacy symbol sweep clean, auto-seed on first Docker startup.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/server/routers/program.ts

@@ -7,54 +7,138 @@ import { parseWizardConfig } from '@/lib/wizard-config'
 
 export const programRouter = router({
   /**
-   * List all programs with optional filtering
+   * List all programs with optional filtering.
+   * When includeStages is true, returns stages nested under
+   * pipelines -> tracks -> stages, flattened as `stages` for convenience.
    */
   list: protectedProcedure
     .input(
       z.object({
         status: z.enum(['DRAFT', 'ACTIVE', 'ARCHIVED']).optional(),
-        includeRounds: z.boolean().optional(),
+        includeStages: z.boolean().optional(),
       }).optional()
     )
     .query(async ({ ctx, input }) => {
-      return ctx.prisma.program.findMany({
+      const includeStages = input?.includeStages || false
+
+      const programs = await ctx.prisma.program.findMany({
         where: input?.status ? { status: input.status } : undefined,
         orderBy: { year: 'desc' },
-        include: {
-          _count: {
-            select: { rounds: true },
-          },
-          rounds: {
-            orderBy: { createdAt: 'asc' },
-            include: {
-              _count: {
-                select: { projects: true, assignments: true },
+        include: includeStages
+          ? {
+              pipelines: {
+                include: {
+                  tracks: {
+                    include: {
+                      stages: {
+                        orderBy: { sortOrder: 'asc' },
+                        include: {
+                          _count: {
+                            select: { assignments: true, projectStageStates: true },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
               },
-            },
-          },
-        },
+            }
+          : undefined,
       })
+
+      // Flatten stages into a rounds-compatible shape for backward compatibility
+      return programs.map((p) => ({
+        ...p,
+        // Provide a flat `stages` array for convenience
+        stages: (p as any).pipelines?.flatMap((pipeline: any) =>
+          pipeline.tracks?.flatMap((track: any) =>
+            (track.stages || []).map((stage: any) => ({
+              ...stage,
+              pipelineName: pipeline.name,
+              trackName: track.name,
+              // Backward-compatible _count shape
+              _count: {
+                projects: stage._count?.projectStageStates || 0,
+                assignments: stage._count?.assignments || 0,
+              },
+            }))
+          ) || []
+        ) || [],
+        // Legacy alias
+        rounds: (p as any).pipelines?.flatMap((pipeline: any) =>
+          pipeline.tracks?.flatMap((track: any) =>
+            (track.stages || []).map((stage: any) => ({
+              id: stage.id,
+              name: stage.name,
+              status: stage.status === 'STAGE_ACTIVE' ? 'ACTIVE'
+                : stage.status === 'STAGE_CLOSED' ? 'CLOSED'
+                : stage.status,
+              votingEndAt: stage.windowCloseAt,
+              _count: {
+                projects: stage._count?.projectStageStates || 0,
+                assignments: stage._count?.assignments || 0,
+              },
+            }))
+          ) || []
+        ) || [],
+      }))
     }),
 
   /**
-   * Get a single program with its rounds
+   * Get a single program with its stages (via pipelines)
    */
   get: protectedProcedure
     .input(z.object({ id: z.string() }))
     .query(async ({ ctx, input }) => {
-      return ctx.prisma.program.findUniqueOrThrow({
+      const program = await ctx.prisma.program.findUniqueOrThrow({
         where: { id: input.id },
         include: {
-          rounds: {
-            orderBy: { createdAt: 'asc' },
+          pipelines: {
             include: {
-              _count: {
-                select: { projects: true, assignments: true },
+              tracks: {
+                include: {
+                  stages: {
+                    orderBy: { sortOrder: 'asc' },
+                    include: {
+                      _count: {
+                        select: { assignments: true, projectStageStates: true },
+                      },
+                    },
+                  },
+                },
               },
             },
           },
         },
       })
+
+      // Flatten stages for convenience
+      const stages = (program as any).pipelines?.flatMap((pipeline: any) =>
+        pipeline.tracks?.flatMap((track: any) =>
+          (track.stages || []).map((stage: any) => ({
+            ...stage,
+            _count: {
+              projects: stage._count?.projectStageStates || 0,
+              assignments: stage._count?.assignments || 0,
+            },
+          }))
+        ) || []
+      ) || []
+
+      return {
+        ...program,
+        stages,
+        // Legacy alias
+        rounds: stages.map((s: any) => ({
+          id: s.id,
+          name: s.name,
+          status: s.status === 'STAGE_ACTIVE' ? 'ACTIVE'
+            : s.status === 'STAGE_CLOSED' ? 'CLOSED'
+            : s.status,
+          votingEndAt: s.windowCloseAt,
+          _count: s._count,
+        })),
+      }
     }),
 
   /**