Performance optimization, applicant portal, and missing DB migration

Performance:
- Convert admin dashboard from SSR to client-side tRPC (fixes 503/ChunkLoadError)
- New dashboard.getStats tRPC endpoint batches 16 queries into single response
- Parallelize jury dashboard queries (assignments + gracePeriods via Promise.all)
- Add project.getFullDetail combined endpoint (project + assignments + stats)
- Configure Prisma connection pool (connection_limit=20, pool_timeout=10)
- Add optimizePackageImports for lucide-react tree-shaking
- Increase React Query staleTime from 1min to 5min

Applicant portal:
- Add applicant layout, nav, dashboard, documents, team, and mentor pages
- Add applicant router with document and team management endpoints
- Add chunk error recovery utility
- Update role nav and auth redirect for applicant role

Database:
- Add migration for missing schema elements (SpecialAward job tracking
  columns, WizardTemplate table, missing indexes)

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

src/server/routers/applicant.ts

@@ -1030,4 +1030,186 @@ export const applicantRouter = router({
 
       return messages
     }),
+
+  /**
+   * Get the applicant's dashboard data: their project (latest edition),
+   * team members, open rounds for document submission, and status timeline.
+   */
+  getMyDashboard: protectedProcedure.query(async ({ ctx }) => {
+    if (ctx.user.role !== 'APPLICANT') {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: 'Only applicants can access this',
+      })
+    }
+
+    // Find the applicant's project (most recent, from active edition if possible)
+    const project = await ctx.prisma.project.findFirst({
+      where: {
+        OR: [
+          { submittedByUserId: ctx.user.id },
+          { teamMembers: { some: { userId: ctx.user.id } } },
+        ],
+      },
+      include: {
+        round: {
+          include: {
+            program: { select: { id: true, name: true, year: true, status: true } },
+          },
+        },
+        files: {
+          orderBy: { createdAt: 'desc' },
+        },
+        teamMembers: {
+          include: {
+            user: {
+              select: { id: true, name: true, email: true, status: true },
+            },
+          },
+          orderBy: { joinedAt: 'asc' },
+        },
+        submittedBy: {
+          select: { id: true, name: true, email: true },
+        },
+        mentorAssignment: {
+          include: {
+            mentor: {
+              select: { id: true, name: true, email: true },
+            },
+          },
+        },
+        wonAwards: {
+          select: { id: true, name: true },
+        },
+      },
+      orderBy: { createdAt: 'desc' },
+    })
+
+    if (!project) {
+      return { project: null, openRounds: [], timeline: [], currentStatus: null }
+    }
+
+    const currentStatus = project.status ?? 'SUBMITTED'
+
+    // Fetch status history
+    const statusHistory = await ctx.prisma.projectStatusHistory.findMany({
+      where: { projectId: project.id },
+      orderBy: { changedAt: 'asc' },
+      select: { status: true, changedAt: true },
+    })
+
+    const statusDateMap = new Map<string, Date>()
+    for (const entry of statusHistory) {
+      if (!statusDateMap.has(entry.status)) {
+        statusDateMap.set(entry.status, entry.changedAt)
+      }
+    }
+
+    const isRejected = currentStatus === 'REJECTED'
+    const hasWonAward = project.wonAwards.length > 0
+
+    // Build timeline
+    const timeline = [
+      {
+        status: 'CREATED',
+        label: 'Application Started',
+        date: project.createdAt,
+        completed: true,
+        isTerminal: false,
+      },
+      {
+        status: 'SUBMITTED',
+        label: 'Application Submitted',
+        date: project.submittedAt || statusDateMap.get('SUBMITTED') || null,
+        completed: !!project.submittedAt || statusDateMap.has('SUBMITTED'),
+        isTerminal: false,
+      },
+      {
+        status: 'UNDER_REVIEW',
+        label: 'Under Review',
+        date: statusDateMap.get('ELIGIBLE') || statusDateMap.get('ASSIGNED') ||
+          (currentStatus !== 'SUBMITTED' && project.submittedAt ? project.submittedAt : null),
+        completed: ['ELIGIBLE', 'ASSIGNED', 'SEMIFINALIST', 'FINALIST', 'REJECTED'].includes(currentStatus),
+        isTerminal: false,
+      },
+    ]
+
+    if (isRejected) {
+      timeline.push({
+        status: 'REJECTED',
+        label: 'Not Selected',
+        date: statusDateMap.get('REJECTED') || null,
+        completed: true,
+        isTerminal: true,
+      })
+    } else {
+      timeline.push(
+        {
+          status: 'SEMIFINALIST',
+          label: 'Semi-finalist',
+          date: statusDateMap.get('SEMIFINALIST') || null,
+          completed: ['SEMIFINALIST', 'FINALIST'].includes(currentStatus) || hasWonAward,
+          isTerminal: false,
+        },
+        {
+          status: 'FINALIST',
+          label: 'Finalist',
+          date: statusDateMap.get('FINALIST') || null,
+          completed: currentStatus === 'FINALIST' || hasWonAward,
+          isTerminal: false,
+        },
+      )
+
+      if (hasWonAward) {
+        timeline.push({
+          status: 'WINNER',
+          label: `Winner${project.wonAwards.length > 0 ? ` - ${project.wonAwards[0].name}` : ''}`,
+          date: null,
+          completed: true,
+          isTerminal: false,
+        })
+      }
+    }
+
+    // Find open rounds in the same program where documents can be submitted
+    const programId = project.round?.programId || project.programId
+    const now = new Date()
+
+    const openRounds = programId
+      ? await ctx.prisma.round.findMany({
+          where: {
+            programId,
+            status: 'ACTIVE',
+          },
+          orderBy: { sortOrder: 'asc' },
+        })
+      : []
+
+    // Filter: only rounds that still accept uploads
+    const uploadableRounds = openRounds.filter((round) => {
+      const settings = round.settingsJson as Record<string, unknown> | null
+      const uploadPolicy = settings?.uploadDeadlinePolicy as string | undefined
+      const roundStarted = round.votingStartAt && now > round.votingStartAt
+
+      // If deadline passed and policy is BLOCK, skip
+      if (roundStarted && uploadPolicy === 'BLOCK') return false
+
+      return true
+    })
+
+    // Determine user's role in the project
+    const userMembership = project.teamMembers.find((tm) => tm.userId === ctx.user.id)
+    const isTeamLead = project.submittedByUserId === ctx.user.id || userMembership?.role === 'LEAD'
+
+    return {
+      project: {
+        ...project,
+        isTeamLead,
+        userRole: userMembership?.role || (project.submittedByUserId === ctx.user.id ? 'LEAD' : null),
+      },
+      openRounds: uploadableRounds,
+      timeline,
+      currentStatus,
+    }
+  }),
 })