AI category-aware evaluation: per-round config, file parsing, shortlist, advance flow

- Per-juror cap mode (HARD/SOFT/NONE) in add-member dialog and members table
- Jury invite flow: create user + add to group + send invitation from dialog
- Per-round config: notifyOnAdvance, aiParseFiles, startupAdvanceCount, conceptAdvanceCount
- Moved notify-on-advance from competition-level to per-round setting
- AI filtering: round-tagged files with newest-first sorting, optional file content extraction
- File content extractor service (pdf-parse for PDF, utf-8 for text files)
- AI shortlist runs independently per category (STARTUP / BUSINESS_CONCEPT)
- generateAIRecommendations tRPC endpoint with per-round config integration
- AI recommendations UI: trigger button, confirmation dialog, per-category results display
- Category-aware advance dialog: select/deselect projects by category with target caps
- STAGE_ACTIVE bug fix in assignment router

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

src/server/routers/file.ts

@@ -1206,4 +1206,285 @@ export const fileRouter = router({
         orderBy: [{ competition: { program: { year: 'desc' } } }, { sortOrder: 'asc' }],
       })
     }),
+
+  /**
+   * List rounds with their file requirement counts (for bulk upload round selector)
+   */
+  listRoundsForBulkUpload: adminProcedure
+    .query(async ({ ctx }) => {
+      return ctx.prisma.round.findMany({
+        where: {
+          fileRequirements: { some: {} },
+        },
+        select: {
+          id: true,
+          name: true,
+          roundType: true,
+          sortOrder: true,
+          competition: {
+            select: { id: true, name: true, program: { select: { name: true, year: true } } },
+          },
+          fileRequirements: {
+            select: { id: true },
+          },
+        },
+        orderBy: [
+          { competition: { program: { year: 'desc' } } },
+          { sortOrder: 'asc' },
+        ],
+      })
+    }),
+
+  /**
+   * List projects with upload status against a round's FileRequirements (for bulk upload)
+   */
+  listProjectsByRoundRequirements: adminProcedure
+    .input(
+      z.object({
+        roundId: z.string(),
+        search: z.string().optional(),
+        status: z.enum(['all', 'missing', 'complete']).default('all'),
+        page: z.number().int().min(1).default(1),
+        pageSize: z.number().int().min(1).max(100).default(50),
+      })
+    )
+    .query(async ({ ctx, input }) => {
+      const round = await ctx.prisma.round.findUniqueOrThrow({
+        where: { id: input.roundId },
+        include: {
+          competition: { select: { id: true, programId: true, name: true } },
+          fileRequirements: { orderBy: { sortOrder: 'asc' } },
+        },
+      })
+
+      // Normalize requirements to a common shape
+      const requirements = round.fileRequirements.map((req) => ({
+        id: req.id,
+        label: req.name,
+        mimeTypes: req.acceptedMimeTypes,
+        required: req.isRequired,
+        maxSizeMb: req.maxSizeMB,
+        description: req.description,
+      }))
+
+      // Build project filter
+      const projectWhere: Record<string, unknown> = {
+        programId: round.competition.programId,
+      }
+      if (input.search) {
+        projectWhere.OR = [
+          { title: { contains: input.search, mode: 'insensitive' } },
+          { teamName: { contains: input.search, mode: 'insensitive' } },
+        ]
+      }
+
+      const allProjects = await ctx.prisma.project.findMany({
+        where: projectWhere,
+        select: {
+          id: true,
+          title: true,
+          teamName: true,
+          submittedByUserId: true,
+          submittedBy: { select: { id: true, name: true, email: true } },
+          files: {
+            where: { roundId: input.roundId, requirementId: { not: null } },
+            select: {
+              id: true,
+              fileName: true,
+              mimeType: true,
+              size: true,
+              createdAt: true,
+              requirementId: true,
+            },
+          },
+        },
+        orderBy: { title: 'asc' },
+      })
+
+      // Map projects with their requirement status
+      const mapped = allProjects.map((project) => {
+        const reqStatus = requirements.map((req) => {
+          const file = project.files.find(
+            (f) => f.requirementId === req.id
+          )
+          return {
+            requirementId: req.id,
+            label: req.label,
+            mimeTypes: req.mimeTypes,
+            required: req.required,
+            file: file ?? null,
+          }
+        })
+
+        const totalRequired = reqStatus.filter((r) => r.required).length
+        const filledRequired = reqStatus.filter(
+          (r) => r.required && r.file
+        ).length
+
+        return {
+          project: {
+            id: project.id,
+            title: project.title,
+            teamName: project.teamName,
+            submittedBy: project.submittedBy,
+          },
+          requirements: reqStatus,
+          isComplete: totalRequired > 0 ? filledRequired >= totalRequired : reqStatus.every((r) => r.file),
+          filledCount: reqStatus.filter((r) => r.file).length,
+          totalCount: reqStatus.length,
+        }
+      })
+
+      // Apply status filter
+      const filtered =
+        input.status === 'missing'
+          ? mapped.filter((p) => !p.isComplete)
+          : input.status === 'complete'
+            ? mapped.filter((p) => p.isComplete)
+            : mapped
+
+      // Paginate
+      const total = filtered.length
+      const totalPages = Math.ceil(total / input.pageSize)
+      const page = Math.min(input.page, Math.max(totalPages, 1))
+      const projects = filtered.slice(
+        (page - 1) * input.pageSize,
+        page * input.pageSize
+      )
+
+      const completeCount = mapped.filter((p) => p.isComplete).length
+
+      return {
+        projects,
+        requirements,
+        total,
+        page,
+        totalPages,
+        completeCount,
+        totalProjects: mapped.length,
+        competition: round.competition,
+      }
+    }),
+
+  /**
+   * Upload a file for a round's FileRequirement (admin bulk upload)
+   */
+  adminUploadForRoundRequirement: adminProcedure
+    .input(
+      z.object({
+        projectId: z.string(),
+        fileName: z.string(),
+        mimeType: z.string(),
+        size: z.number().int().positive(),
+        roundId: z.string(),
+        requirementId: z.string(),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      // Block dangerous file extensions
+      const dangerousExtensions = ['.exe', '.sh', '.bat', '.cmd', '.ps1', '.php', '.jsp', '.cgi', '.dll', '.msi']
+      const ext = input.fileName.toLowerCase().slice(input.fileName.lastIndexOf('.'))
+      if (dangerousExtensions.includes(ext)) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: `File type "${ext}" is not allowed`,
+        })
+      }
+
+      // Validate requirement exists and belongs to the round
+      const requirement = await ctx.prisma.fileRequirement.findFirst({
+        where: {
+          id: input.requirementId,
+          roundId: input.roundId,
+        },
+      })
+      if (!requirement) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Requirement not found for this round',
+        })
+      }
+
+      // Validate MIME type if requirement specifies allowed types
+      if (requirement.acceptedMimeTypes.length > 0) {
+        const isAllowed = requirement.acceptedMimeTypes.some((allowed) => {
+          if (allowed.endsWith('/*')) {
+            return input.mimeType.startsWith(allowed.replace('/*', '/'))
+          }
+          return input.mimeType === allowed
+        })
+        if (!isAllowed) {
+          throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: `File type "${input.mimeType}" is not allowed for this requirement. Accepted: ${requirement.acceptedMimeTypes.join(', ')}`,
+          })
+        }
+      }
+
+      // Infer fileType from mimeType
+      let fileType: 'EXEC_SUMMARY' | 'PRESENTATION' | 'VIDEO' | 'OTHER' = 'OTHER'
+      if (input.mimeType.startsWith('video/')) fileType = 'VIDEO'
+      else if (input.mimeType === 'application/pdf') fileType = 'EXEC_SUMMARY'
+      else if (input.mimeType.includes('presentation') || input.mimeType.includes('powerpoint'))
+        fileType = 'PRESENTATION'
+
+      // Fetch project title and round name for storage path
+      const [project, round] = await Promise.all([
+        ctx.prisma.project.findUniqueOrThrow({
+          where: { id: input.projectId },
+          select: { title: true },
+        }),
+        ctx.prisma.round.findUniqueOrThrow({
+          where: { id: input.roundId },
+          select: { name: true },
+        }),
+      ])
+
+      const bucket = BUCKET_NAME
+      const objectKey = generateObjectKey(project.title, input.fileName, round.name)
+      const uploadUrl = await getPresignedUrl(bucket, objectKey, 'PUT', 3600)
+
+      // Remove any existing file for this project+requirement combo (replace)
+      await ctx.prisma.projectFile.deleteMany({
+        where: {
+          projectId: input.projectId,
+          roundId: input.roundId,
+          requirementId: input.requirementId,
+        },
+      })
+
+      // Create file record
+      const file = await ctx.prisma.projectFile.create({
+        data: {
+          projectId: input.projectId,
+          fileType,
+          fileName: input.fileName,
+          mimeType: input.mimeType,
+          size: input.size,
+          bucket,
+          objectKey,
+          roundId: input.roundId,
+          requirementId: input.requirementId,
+        },
+      })
+
+      await logAudit({
+        prisma: ctx.prisma,
+        userId: ctx.user.id,
+        action: 'UPLOAD_FILE',
+        entityType: 'ProjectFile',
+        entityId: file.id,
+        detailsJson: {
+          projectId: input.projectId,
+          fileName: input.fileName,
+          roundId: input.roundId,
+          requirementId: input.requirementId,
+          bulkUpload: true,
+        },
+        ipAddress: ctx.ip,
+        userAgent: ctx.userAgent,
+      })
+
+      return { uploadUrl, file }
+    }),
 })