Fix AI filtering bugs, add special award shortlist integration

Part 1 - Bug Fixes:
- Fix toProjectWithRelations() stripping file fields needed by AI (detectedLang, textContent, etc.)
- Fix parseAIData() reading flat when aiScreeningJson is nested under rule ID
- Fix getAIConfidenceScore() with same nesting issue (always returned 0)

Part 2 - Special Award Track Integration:
- Add shortlistSize to SpecialAward, qualityScore/shortlisted/confirmed fields to AwardEligibility
- Add specialAwardId to Round for award-owned rounds
- Update AI eligibility service to return qualityScore (0-100) for ranking
- Update eligibility job with filteringRoundId scoping and auto-shortlist top N
- Add 8 new specialAward router procedures (listForRound, runEligibilityForRound,
  listShortlist, toggleShortlisted, confirmShortlist, listRounds, createRound, deleteRound)
- Create award-shortlist.tsx component with ranked table, shortlist checkboxes, confirm dialog
- Add "Special Award Tracks" section to filtering dashboard

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

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

@@ -14,7 +14,8 @@ const BATCH_SIZE = 20
 export async function processEligibilityJob(
   awardId: string,
   includeSubmitted: boolean,
-  userId: string
+  userId: string,
+  filteringRoundId?: string
 ): Promise<void> {
   try {
     // Mark job as PROCESSING
@@ -23,27 +24,76 @@ export async function processEligibilityJob(
       include: { program: true },
     })
 
-    // Get projects
-    const statusFilter = includeSubmitted
-      ? (['SUBMITTED', 'ELIGIBLE', 'ASSIGNED', 'SEMIFINALIST', 'FINALIST'] as const)
-      : (['ELIGIBLE', 'ASSIGNED', 'SEMIFINALIST', 'FINALIST'] as const)
+    // Get projects — scoped to filtering round PASSED projects if provided
+    let projects: Array<{
+      id: string
+      title: string
+      description: string | null
+      competitionCategory: string | null
+      country: string | null
+      geographicZone: string | null
+      tags: string[]
+      oceanIssue: string | null
+    }>
 
-    const projects = await prisma.project.findMany({
-      where: {
-        programId: award.programId,
-        status: { in: [...statusFilter] },
-      },
-      select: {
-        id: true,
-        title: true,
-        description: true,
-        competitionCategory: true,
-        country: true,
-        geographicZone: true,
-        tags: true,
-        oceanIssue: true,
-      },
-    })
+    if (filteringRoundId) {
+      // Scope to projects that PASSED filtering in the specified round
+      const passedResults = await prisma.filteringResult.findMany({
+        where: { roundId: filteringRoundId, outcome: 'PASSED' },
+        select: { projectId: true },
+      })
+      const passedIds = passedResults.map((r) => r.projectId)
+
+      if (passedIds.length === 0) {
+        await prisma.specialAward.update({
+          where: { id: awardId },
+          data: {
+            eligibilityJobStatus: 'COMPLETED',
+            eligibilityJobTotal: 0,
+            eligibilityJobDone: 0,
+          },
+        })
+        return
+      }
+
+      projects = await prisma.project.findMany({
+        where: {
+          id: { in: passedIds },
+          programId: award.programId,
+        },
+        select: {
+          id: true,
+          title: true,
+          description: true,
+          competitionCategory: true,
+          country: true,
+          geographicZone: true,
+          tags: true,
+          oceanIssue: true,
+        },
+      })
+    } else {
+      const statusFilter = includeSubmitted
+        ? (['SUBMITTED', 'ELIGIBLE', 'ASSIGNED', 'SEMIFINALIST', 'FINALIST'] as const)
+        : (['ELIGIBLE', 'ASSIGNED', 'SEMIFINALIST', 'FINALIST'] as const)
+
+      projects = await prisma.project.findMany({
+        where: {
+          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({
@@ -77,7 +127,7 @@ export async function processEligibilityJob(
 
     // 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
+    let aiResults: Map<string, { eligible: boolean; confidence: number; qualityScore: number; reasoning: string }> | undefined
 
     if (award.criteriaText && award.useAiEligibility) {
       aiResults = new Map()
@@ -90,6 +140,7 @@ export async function processEligibilityJob(
           aiResults.set(e.projectId, {
             eligible: e.eligible,
             confidence: e.confidence,
+            qualityScore: e.qualityScore,
             reasoning: e.reasoning,
           })
         }
@@ -123,8 +174,9 @@ export async function processEligibilityJob(
         projectId: project.id,
         eligible,
         method,
+        qualityScore: aiEval?.qualityScore ?? null,
         aiReasoningJson: aiEval
-          ? { confidence: aiEval.confidence, reasoning: aiEval.reasoning }
+          ? { confidence: aiEval.confidence, qualityScore: aiEval.qualityScore, reasoning: aiEval.reasoning }
           : null,
       }
     })
@@ -144,19 +196,47 @@ export async function processEligibilityJob(
             projectId: e.projectId,
             eligible: e.eligible,
             method: e.method as 'AUTO' | 'MANUAL',
+            qualityScore: e.qualityScore,
             aiReasoningJson: e.aiReasoningJson ?? undefined,
           },
           update: {
             eligible: e.eligible,
             method: e.method as 'AUTO' | 'MANUAL',
+            qualityScore: e.qualityScore,
             aiReasoningJson: e.aiReasoningJson ?? undefined,
             overriddenBy: null,
             overriddenAt: null,
+            shortlisted: false,
+            confirmedAt: null,
+            confirmedBy: null,
           },
         })
       )
     )
 
+    // Auto-shortlist top N eligible projects by qualityScore
+    const shortlistSize = award.shortlistSize ?? 10
+    const topEligible = eligibilities
+      .filter((e) => e.eligible && e.qualityScore != null)
+      .sort((a, b) => (b.qualityScore ?? 0) - (a.qualityScore ?? 0))
+      .slice(0, shortlistSize)
+
+    if (topEligible.length > 0) {
+      await prisma.$transaction(
+        topEligible.map((e) =>
+          prisma.awardEligibility.update({
+            where: {
+              awardId_projectId: {
+                awardId,
+                projectId: e.projectId,
+              },
+            },
+            data: { shortlisted: true },
+          })
+        )
+      )
+    }
+
     // Mark as completed
     await prisma.specialAward.update({
       where: { id: awardId },