Comprehensive platform audit: security, UX, performance, and visual polish

Phase 1: Security - status transition validation, Zod tightening, DB indexes, transactions

Phase 2: Admin UX - search/filter for awards, learning, partners pages

Phase 3: Dashboard - Recent Activity feed, Pending Actions card, quick actions

Phase 4: Jury - assignments progress/urgency, autosave indicator, divergence highlighting

Phase 5: Portals - observer charts, mentor search, login/onboarding polish

Phase 6: Messages preview dialog, CsvExportDialog with column selection

Phase 7: Performance - query optimizations, loading skeletons, useDebounce hook

Phase 8: Visual - AnimatedCard, hover effects, StatusBadge, empty state CTAs

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

src/server/services/award-eligibility-job.ts

@@ -0,0 +1,184 @@
+import { prisma } from '@/lib/prisma'
+import {
+  applyAutoTagRules,
+  aiInterpretCriteria,
+  type AutoTagRule,
+} from './ai-award-eligibility'
+
+const BATCH_SIZE = 20
+
+/**
+ * Process eligibility for an award in the background.
+ * Updates progress in the database as it goes so the frontend can poll.
+ */
+export async function processEligibilityJob(
+  awardId: string,
+  includeSubmitted: boolean,
+  userId: string
+): Promise<void> {
+  try {
+    // Mark job as PROCESSING
+    const award = await prisma.specialAward.findUniqueOrThrow({
+      where: { id: awardId },
+      include: { program: true },
+    })
+
+    // Get projects
+    const statusFilter = includeSubmitted
+      ? (['SUBMITTED', 'ELIGIBLE', 'ASSIGNED', 'SEMIFINALIST', 'FINALIST'] as const)
+      : (['ELIGIBLE', 'ASSIGNED', 'SEMIFINALIST', 'FINALIST'] as const)
+
+    const projects = await prisma.project.findMany({
+      where: {
+        round: { programId: award.programId },
+        status: { in: [...statusFilter] },
+      },
+      select: {
+        id: true,
+        title: true,
+        description: true,
+        competitionCategory: true,
+        country: true,
+        geographicZone: true,
+        tags: true,
+        oceanIssue: true,
+      },
+    })
+
+    if (projects.length === 0) {
+      await prisma.specialAward.update({
+        where: { id: awardId },
+        data: {
+          eligibilityJobStatus: 'COMPLETED',
+          eligibilityJobTotal: 0,
+          eligibilityJobDone: 0,
+        },
+      })
+      return
+    }
+
+    await prisma.specialAward.update({
+      where: { id: awardId },
+      data: {
+        eligibilityJobStatus: 'PROCESSING',
+        eligibilityJobTotal: projects.length,
+        eligibilityJobDone: 0,
+        eligibilityJobError: null,
+        eligibilityJobStarted: new Date(),
+      },
+    })
+
+    // Phase 1: Auto-tag rules (deterministic, fast)
+    const autoTagRules = award.autoTagRulesJson as unknown as AutoTagRule[] | null
+    let autoResults: Map<string, boolean> | undefined
+    if (autoTagRules && Array.isArray(autoTagRules) && autoTagRules.length > 0) {
+      autoResults = applyAutoTagRules(autoTagRules, projects)
+    }
+
+    // Phase 2: AI interpretation (if criteria text exists AND AI eligibility is enabled)
+    // Process in batches to avoid timeouts
+    let aiResults: Map<string, { eligible: boolean; confidence: number; reasoning: string }> | undefined
+
+    if (award.criteriaText && award.useAiEligibility) {
+      aiResults = new Map()
+
+      for (let i = 0; i < projects.length; i += BATCH_SIZE) {
+        const batch = projects.slice(i, i + BATCH_SIZE)
+        const aiEvals = await aiInterpretCriteria(award.criteriaText, batch)
+
+        for (const e of aiEvals) {
+          aiResults.set(e.projectId, {
+            eligible: e.eligible,
+            confidence: e.confidence,
+            reasoning: e.reasoning,
+          })
+        }
+
+        // Update progress
+        await prisma.specialAward.update({
+          where: { id: awardId },
+          data: {
+            eligibilityJobDone: Math.min(i + BATCH_SIZE, projects.length),
+          },
+        })
+      }
+    } else {
+      // No AI needed, mark all as done
+      await prisma.specialAward.update({
+        where: { id: awardId },
+        data: { eligibilityJobDone: projects.length },
+      })
+    }
+
+    // Combine results: auto-tag AND AI must agree (or just one if only one configured)
+    const eligibilities = projects.map((project) => {
+      const autoEligible = autoResults?.get(project.id) ?? true
+      const aiEval = aiResults?.get(project.id)
+      const aiEligible = aiEval?.eligible ?? true
+
+      const eligible = autoEligible && aiEligible
+      const method = autoResults && aiResults ? 'AUTO' : autoResults ? 'AUTO' : 'MANUAL'
+
+      return {
+        projectId: project.id,
+        eligible,
+        method,
+        aiReasoningJson: aiEval
+          ? { confidence: aiEval.confidence, reasoning: aiEval.reasoning }
+          : null,
+      }
+    })
+
+    // Upsert eligibilities
+    await prisma.$transaction(
+      eligibilities.map((e) =>
+        prisma.awardEligibility.upsert({
+          where: {
+            awardId_projectId: {
+              awardId,
+              projectId: e.projectId,
+            },
+          },
+          create: {
+            awardId,
+            projectId: e.projectId,
+            eligible: e.eligible,
+            method: e.method as 'AUTO' | 'MANUAL',
+            aiReasoningJson: e.aiReasoningJson ?? undefined,
+          },
+          update: {
+            eligible: e.eligible,
+            method: e.method as 'AUTO' | 'MANUAL',
+            aiReasoningJson: e.aiReasoningJson ?? undefined,
+            overriddenBy: null,
+            overriddenAt: null,
+          },
+        })
+      )
+    )
+
+    // Mark as completed
+    await prisma.specialAward.update({
+      where: { id: awardId },
+      data: {
+        eligibilityJobStatus: 'COMPLETED',
+        eligibilityJobDone: projects.length,
+      },
+    })
+  } catch (error) {
+    // Mark as failed
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    try {
+      await prisma.specialAward.update({
+        where: { id: awardId },
+        data: {
+          eligibilityJobStatus: 'FAILED',
+          eligibilityJobError: errorMessage,
+        },
+      })
+    } catch {
+      // If we can't even update the status, log and give up
+      console.error('Failed to update eligibility job status:', error)
+    }
+  }
+}