Fix jury reminders, add notify jurors button, fix checkbox borders, widen assignment modal

- Send Reminders button now works: added sendManualReminders() that bypasses
  cron-specific window/deadline/dedup guards so admin can send immediately
- Added Notify Jurors button that sends direct BATCH_ASSIGNED emails to all
  jurors with assignments (not dependent on NotificationEmailSetting config)
- Fixed checkbox component: default border is now neutral grey (border-input),
  red border (border-primary) only applied when checked
- Widened Add Assignment dialog from max-w-2xl to max-w-3xl to prevent overflow

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

src/server/routers/assignment.ts

@@ -16,6 +16,7 @@ import {
   NotificationTypes,
 } from '../services/in-app-notification'
 import { logAudit } from '@/server/utils/audit'
+import { sendStyledNotificationEmail } from '@/lib/email'
 
 async function runAIAssignmentJob(jobId: string, roundId: string, userId: string) {
   try {
@@ -1357,4 +1358,115 @@ export const assignmentRouter = router({
         createdAt: job.createdAt,
       }
     }),
+
+  /**
+   * Notify all jurors of their current assignments for a round (admin only).
+   * Sends both in-app notifications AND direct emails to each juror.
+   */
+  notifyJurorsOfAssignments: adminProcedure
+    .input(z.object({ roundId: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      const round = await ctx.prisma.round.findUniqueOrThrow({
+        where: { id: input.roundId },
+        select: { name: true, windowCloseAt: true },
+      })
+
+      // Get all assignments grouped by user
+      const assignments = await ctx.prisma.assignment.findMany({
+        where: { roundId: input.roundId },
+        select: { userId: true },
+      })
+
+      if (assignments.length === 0) {
+        return { sent: 0, jurorCount: 0, emailsSent: 0 }
+      }
+
+      // Count assignments per user
+      const userCounts: Record<string, number> = {}
+      for (const a of assignments) {
+        userCounts[a.userId] = (userCounts[a.userId] || 0) + 1
+      }
+
+      const deadline = round.windowCloseAt
+        ? new Date(round.windowCloseAt).toLocaleDateString('en-US', {
+            weekday: 'long',
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+          })
+        : undefined
+
+      // Create in-app notifications grouped by project count
+      const usersByProjectCount = new Map<number, string[]>()
+      for (const [userId, projectCount] of Object.entries(userCounts)) {
+        const existing = usersByProjectCount.get(projectCount) || []
+        existing.push(userId)
+        usersByProjectCount.set(projectCount, existing)
+      }
+
+      let totalSent = 0
+      for (const [projectCount, userIds] of usersByProjectCount) {
+        if (userIds.length === 0) continue
+        await createBulkNotifications({
+          userIds,
+          type: NotificationTypes.BATCH_ASSIGNED,
+          title: `${projectCount} Projects Assigned`,
+          message: `You have been assigned ${projectCount} project${projectCount > 1 ? 's' : ''} to evaluate for ${round.name || 'this round'}.`,
+          linkUrl: `/jury/competitions`,
+          linkLabel: 'View Assignments',
+          metadata: { projectCount, stageName: round.name, deadline },
+        })
+        totalSent += userIds.length
+      }
+
+      // Send direct emails to every juror (regardless of notification email settings)
+      const allUserIds = Object.keys(userCounts)
+      const users = await ctx.prisma.user.findMany({
+        where: { id: { in: allUserIds } },
+        select: { id: true, name: true, email: true },
+      })
+
+      const baseUrl = process.env.NEXTAUTH_URL || 'https://monaco-opc.com'
+      let emailsSent = 0
+
+      for (const user of users) {
+        const projectCount = userCounts[user.id] || 0
+        if (projectCount === 0) continue
+
+        try {
+          await sendStyledNotificationEmail(
+            user.email,
+            user.name || '',
+            'BATCH_ASSIGNED',
+            {
+              name: user.name || undefined,
+              title: `Projects Assigned - ${round.name}`,
+              message: `You have been assigned ${projectCount} project${projectCount > 1 ? 's' : ''} to evaluate for ${round.name}.`,
+              linkUrl: `${baseUrl}/jury/competitions`,
+              metadata: { projectCount, roundName: round.name, deadline },
+            }
+          )
+          emailsSent++
+        } catch (error) {
+          console.error(`Failed to send assignment email to ${user.email}:`, error)
+        }
+      }
+
+      await logAudit({
+        prisma: ctx.prisma,
+        userId: ctx.user.id,
+        action: 'NOTIFY_JURORS_OF_ASSIGNMENTS',
+        entityType: 'Round',
+        entityId: input.roundId,
+        detailsJson: {
+          jurorCount: Object.keys(userCounts).length,
+          totalAssignments: assignments.length,
+          emailsSent,
+        },
+        ipAddress: ctx.ip,
+        userAgent: ctx.userAgent,
+      })
+
+      return { sent: totalSent, jurorCount: Object.keys(userCounts).length, emailsSent }
+    }),
 })

src/server/routers/evaluation.ts

@@ -3,7 +3,7 @@ import { TRPCError } from '@trpc/server'
 import { router, protectedProcedure, adminProcedure, juryProcedure } from '../trpc'
 import { logAudit } from '@/server/utils/audit'
 import { notifyAdmins, NotificationTypes } from '../services/in-app-notification'
-import { processEvaluationReminders } from '../services/evaluation-reminders'
+import { sendManualReminders } from '../services/evaluation-reminders'
 import { generateSummary } from '@/server/services/ai-evaluation-summary'
 
 export const evaluationRouter = router({
@@ -564,7 +564,7 @@ export const evaluationRouter = router({
   triggerReminders: adminProcedure
     .input(z.object({ roundId: z.string() }))
     .mutation(async ({ ctx, input }) => {
-      const result = await processEvaluationReminders(input.roundId)
+      const result = await sendManualReminders(input.roundId)
 
       await logAudit({
         prisma: ctx.prisma,

src/server/services/evaluation-reminders.ts

@@ -14,9 +14,113 @@ interface ReminderResult {
   errors: number
 }
 
+/**
+ * Manually send reminders to all jurors with incomplete assignments for a round.
+ * Bypasses window/deadline checks — the admin explicitly chose to send now.
+ * Uses 'MANUAL' type so it doesn't interfere with automated cron deduplication,
+ * but still deduplicates within manual sends (one manual reminder per juror per round).
+ */
+export async function sendManualReminders(roundId: string): Promise<ReminderResult> {
+  let sent = 0
+  let errors = 0
+
+  const round = await prisma.round.findUnique({
+    where: { id: roundId },
+    select: {
+      id: true,
+      name: true,
+      windowCloseAt: true,
+      competition: { select: { name: true } },
+    },
+  })
+
+  if (!round) return { sent, errors }
+
+  // Find jurors with incomplete assignments
+  const incompleteAssignments = await prisma.assignment.findMany({
+    where: { roundId, isCompleted: false },
+    select: { userId: true },
+  })
+
+  const userIds = [...new Set(incompleteAssignments.map((a) => a.userId))]
+  if (userIds.length === 0) return { sent, errors }
+
+  // Deduplicate: only one MANUAL reminder per juror per round
+  const existingManual = await prisma.reminderLog.findMany({
+    where: { roundId, type: 'MANUAL', userId: { in: userIds } },
+    select: { userId: true },
+  })
+  const alreadySent = new Set(existingManual.map((r) => r.userId))
+  const usersToNotify = userIds.filter((id) => !alreadySent.has(id))
+
+  if (usersToNotify.length === 0) return { sent, errors }
+
+  const users = await prisma.user.findMany({
+    where: { id: { in: usersToNotify } },
+    select: { id: true, name: true, email: true },
+  })
+
+  const baseUrl = process.env.NEXTAUTH_URL || 'https://monaco-opc.com'
+  const deadlineStr = round.windowCloseAt
+    ? round.windowCloseAt.toLocaleDateString('en-US', {
+        weekday: 'long',
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+        timeZoneName: 'short',
+      })
+    : undefined
+
+  const pendingCounts = new Map<string, number>()
+  for (const a of incompleteAssignments) {
+    pendingCounts.set(a.userId, (pendingCounts.get(a.userId) || 0) + 1)
+  }
+
+  for (const user of users) {
+    const pendingCount = pendingCounts.get(user.id) || 0
+    if (pendingCount === 0) continue
+
+    try {
+      const deadlineNote = deadlineStr ? ` The deadline is ${deadlineStr}.` : ''
+      await sendStyledNotificationEmail(
+        user.email,
+        user.name || '',
+        'REMINDER_24H',
+        {
+          name: user.name || undefined,
+          title: `Evaluation Reminder - ${round.name}`,
+          message: `You have ${pendingCount} pending evaluation${pendingCount !== 1 ? 's' : ''} for ${round.name}.${deadlineNote}`,
+          linkUrl: `${baseUrl}/jury/rounds/${round.id}/assignments`,
+          metadata: {
+            pendingCount,
+            roundName: round.name,
+            ...(deadlineStr && { deadline: deadlineStr }),
+          },
+        }
+      )
+
+      await prisma.reminderLog.create({
+        data: { roundId, userId: user.id, type: 'MANUAL' },
+      })
+
+      sent++
+    } catch (error) {
+      console.error(
+        `Failed to send manual reminder to ${user.email} for round ${round.name}:`,
+        error
+      )
+      errors++
+    }
+  }
+
+  return { sent, errors }
+}
+
 /**
  * Find active stages with approaching deadlines and send reminders
- * to jurors who have incomplete assignments.
+ * to jurors who have incomplete assignments. (Used by cron job)
  */
 export async function processEvaluationReminders(roundId?: string): Promise<ReminderResult> {
   const now = new Date()