feat(01-04): add auto-trigger hook + triggerAutoRank + retroactiveScan

- evaluation.ts: add triggerAutoRankIfComplete (module-level, not exported)
  - Checks total/completed required assignments for round
  - Reads autoRankOnComplete + rankingCriteria from round configJson
  - 5-minute cooldown guard on AUTO snapshots
  - Fire-and-forget via void call after isCompleted=true (never awaited)
  - Notifies admins via AI_RANKING_COMPLETE / AI_RANKING_FAILED
- ranking.ts: add triggerAutoRank procedure (RANK-09)
  - Admin manual trigger reading criteria from round configJson
  - Creates MANUAL snapshot with QUICK mode
- ranking.ts: add retroactiveScan procedure (RANK-10)
  - Scans ROUND_ACTIVE / ROUND_CLOSED rounds for auto-rank configured
  - Skips rounds with existing RETROACTIVE snapshots
  - Runs sequentially to avoid rate limits
- ranking.ts: router now has 7 total procedures

src/server/routers/ranking.ts

@@ -10,6 +10,7 @@ import {
   type ParsedRankingRule,
 } from '../services/ai-ranking'
 import { logAudit } from '../utils/audit'
+import type { EvaluationConfig } from '@/types/competition-configs'
 
 // ─── Zod Schemas ──────────────────────────────────────────────────────────────
 
@@ -202,4 +203,147 @@ export const rankingRouter = router({
 
       return snapshot
     }),
+
+  /**
+   * RANK-09 — Manual trigger for auto-rank (admin button on round detail page).
+   * Reads ranking criteria from round configJson and executes quickRank.
+   */
+  triggerAutoRank: adminProcedure
+    .input(z.object({ roundId: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      const { roundId } = input
+
+      const round = await ctx.prisma.round.findUniqueOrThrow({
+        where: { id: roundId },
+        select: { id: true, name: true, configJson: true, competition: { select: { id: true } } },
+      })
+
+      const config = (round.configJson as EvaluationConfig | null) ?? ({} as EvaluationConfig)
+      const criteriaText = config?.rankingCriteria ?? null
+
+      if (!criteriaText) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'No ranking criteria configured for this round. Add criteria in round settings first.',
+        })
+      }
+
+      const result = await aiQuickRank(criteriaText, roundId, ctx.prisma, ctx.user.id)
+
+      const snapshot = await ctx.prisma.rankingSnapshot.create({
+        data: {
+          roundId,
+          triggeredById: ctx.user.id,
+          triggerType: 'MANUAL',
+          criteriaText,
+          parsedRulesJson: result.parsedRules as unknown as Prisma.InputJsonValue,
+          startupRankingJson: result.startup.rankedProjects as unknown as Prisma.InputJsonValue,
+          conceptRankingJson: result.concept.rankedProjects as unknown as Prisma.InputJsonValue,
+          mode: 'QUICK',
+          status: 'COMPLETED',
+        },
+      })
+
+      await logAudit({
+        prisma: ctx.prisma,
+        userId: ctx.user.id,
+        action: 'RANKING_MANUAL_TRIGGERED',
+        entityType: 'RankingSnapshot',
+        entityId: snapshot.id,
+        detailsJson: { roundId },
+        ipAddress: ctx.ip,
+        userAgent: ctx.userAgent,
+      })
+
+      return { snapshotId: snapshot.id, startup: result.startup, concept: result.concept }
+    }),
+
+  /**
+   * RANK-10 — Retroactive scan: finds all active/closed rounds with autoRankOnComplete
+   * configured but no RETROACTIVE snapshot yet, then executes ranking for each.
+   * Runs sequentially to avoid hammering OpenAI.
+   */
+  retroactiveScan: adminProcedure
+    .input(z.object({}))
+    .mutation(async ({ ctx }) => {
+      const rounds = await ctx.prisma.round.findMany({
+        where: { status: { in: ['ROUND_ACTIVE', 'ROUND_CLOSED'] } },
+        select: { id: true, name: true, configJson: true },
+      })
+
+      const results: Array<{ roundId: string; triggered: boolean; reason?: string }> = []
+
+      for (const round of rounds) {
+        const config = (round.configJson as EvaluationConfig | null) ?? ({} as EvaluationConfig)
+        const autoRankEnabled = config?.autoRankOnComplete ?? false
+        const criteriaText = config?.rankingCriteria ?? null
+
+        if (!autoRankEnabled || !criteriaText) {
+          results.push({ roundId: round.id, triggered: false, reason: 'auto-rank not configured' })
+          continue
+        }
+
+        // Check if fully evaluated
+        const [total, completed] = await Promise.all([
+          ctx.prisma.assignment.count({ where: { roundId: round.id, isRequired: true } }),
+          ctx.prisma.assignment.count({ where: { roundId: round.id, isRequired: true, isCompleted: true } }),
+        ])
+
+        if (total === 0 || total !== completed) {
+          results.push({
+            roundId: round.id,
+            triggered: false,
+            reason: `${completed}/${total} assignments complete`,
+          })
+          continue
+        }
+
+        // Check if a RETROACTIVE snapshot already exists
+        const existing = await ctx.prisma.rankingSnapshot.findFirst({
+          where: { roundId: round.id, triggerType: 'RETROACTIVE' },
+          select: { id: true },
+        })
+        if (existing) {
+          results.push({ roundId: round.id, triggered: false, reason: 'retroactive snapshot already exists' })
+          continue
+        }
+
+        // Execute ranking sequentially to avoid rate limits
+        try {
+          const result = await aiQuickRank(criteriaText, round.id, ctx.prisma, ctx.user.id)
+          await ctx.prisma.rankingSnapshot.create({
+            data: {
+              roundId: round.id,
+              triggeredById: ctx.user.id,
+              triggerType: 'RETROACTIVE',
+              criteriaText,
+              parsedRulesJson: result.parsedRules as unknown as Prisma.InputJsonValue,
+              startupRankingJson: result.startup.rankedProjects as unknown as Prisma.InputJsonValue,
+              conceptRankingJson: result.concept.rankedProjects as unknown as Prisma.InputJsonValue,
+              mode: 'QUICK',
+              status: 'COMPLETED',
+            },
+          })
+          results.push({ roundId: round.id, triggered: true })
+        } catch (err) {
+          results.push({ roundId: round.id, triggered: false, reason: String(err) })
+        }
+      }
+
+      await logAudit({
+        prisma: ctx.prisma,
+        userId: ctx.user.id,
+        action: 'RANKING_RETROACTIVE_SCAN',
+        entityType: 'Round',
+        detailsJson: { results },
+        ipAddress: ctx.ip,
+        userAgent: ctx.userAgent,
+      })
+
+      return {
+        results,
+        total: results.length,
+        triggered: results.filter((r) => r.triggered).length,
+      }
+    }),
 })