Round system redesign: Phases 1-7 complete

Full pipeline/track/stage architecture replacing the legacy round system.

Schema: 11 new models (Pipeline, Track, Stage, StageTransition,
ProjectStageState, RoutingRule, Cohort, CohortProject, LiveProgressCursor,
OverrideAction, AudienceVoter) + 8 new enums.

Backend: 9 new routers (pipeline, stage, routing, stageFiltering,
stageAssignment, cohort, live, decision, award) + 6 new services
(stage-engine, routing-engine, stage-filtering, stage-assignment,
stage-notifications, live-control).

Frontend: Pipeline wizard (17 components), jury stage pages (7),
applicant pipeline pages (3), public stage pages (2), admin pipeline
pages (5), shared stage components (3), SSE route, live hook.

Phase 6 refit: 23 routers/services migrated from roundId to stageId,
all frontend components refitted. Deleted round.ts (985 lines),
roundTemplate.ts, round-helpers.ts, round-settings.ts, round-type-settings.tsx,
10 legacy admin pages, 7 legacy jury pages, 3 legacy dialogs.

Phase 7 validation: 36 tests (10 unit + 8 integration files) all passing,
TypeScript 0 errors, Next.js build succeeds, 13 integrity checks,
legacy symbol sweep clean, auto-seed on first Docker startup.

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

tests/unit/routing-engine.test.ts

@@ -0,0 +1,128 @@
+/**
+ * U-003: Routing — Multiple Rule Match (highest priority wins)
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { prisma } from '../setup'
+import {
+  createTestUser,
+  createTestProgram,
+  createTestPipeline,
+  createTestTrack,
+  createTestStage,
+  createTestProject,
+  createTestPSS,
+  createTestRoutingRule,
+  cleanupTestData,
+} from '../helpers'
+import { evaluateRoutingRules } from '@/server/services/routing-engine'
+
+let programId: string
+let userIds: string[] = []
+
+beforeAll(async () => {
+  const program = await createTestProgram({ name: 'Routing Test' })
+  programId = program.id
+})
+
+afterAll(async () => {
+  await cleanupTestData(programId, userIds)
+})
+
+describe('U-003: Multiple Rule Match — Highest Priority Wins', () => {
+  it('returns the lowest-priority-number rule when multiple rules match', async () => {
+    const pipeline = await createTestPipeline(programId)
+    const mainTrack = await createTestTrack(pipeline.id, {
+      name: 'Main',
+      kind: 'MAIN',
+      sortOrder: 0,
+    })
+    const awardTrackA = await createTestTrack(pipeline.id, {
+      name: 'Award A',
+      kind: 'AWARD',
+      sortOrder: 1,
+      routingMode: 'PARALLEL',
+    })
+    const awardTrackB = await createTestTrack(pipeline.id, {
+      name: 'Award B',
+      kind: 'AWARD',
+      sortOrder: 2,
+      routingMode: 'PARALLEL',
+    })
+    const awardTrackC = await createTestTrack(pipeline.id, {
+      name: 'Award C',
+      kind: 'AWARD',
+      sortOrder: 3,
+      routingMode: 'PARALLEL',
+    })
+
+    const stage = await createTestStage(mainTrack.id, {
+      name: 'Eval',
+      stageType: 'EVALUATION',
+      status: 'STAGE_ACTIVE',
+    })
+
+    // Create destination stages
+    await createTestStage(awardTrackA.id, { name: 'A-Eval', sortOrder: 0 })
+    await createTestStage(awardTrackB.id, { name: 'B-Eval', sortOrder: 0 })
+    await createTestStage(awardTrackC.id, { name: 'C-Eval', sortOrder: 0 })
+
+    // Project from France — all 3 rules match since country=France
+    const project = await createTestProject(programId, { country: 'France' })
+    await createTestPSS(project.id, mainTrack.id, stage.id, { state: 'PENDING' })
+
+    // Rule 1: priority 10 (lowest = wins)
+    await createTestRoutingRule(pipeline.id, awardTrackA.id, {
+      name: 'Award A Rule',
+      priority: 10,
+      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
+    })
+
+    // Rule 2: priority 20
+    await createTestRoutingRule(pipeline.id, awardTrackB.id, {
+      name: 'Award B Rule',
+      priority: 20,
+      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
+    })
+
+    // Rule 3: priority 30
+    await createTestRoutingRule(pipeline.id, awardTrackC.id, {
+      name: 'Award C Rule',
+      priority: 30,
+      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
+    })
+
+    const matched = await evaluateRoutingRules(project.id, stage.id, pipeline.id, prisma)
+
+    expect(matched).not.toBeNull()
+    expect(matched!.destinationTrackId).toBe(awardTrackA.id)
+    expect(matched!.priority).toBe(10)
+    expect(matched!.ruleName).toBe('Award A Rule')
+  })
+
+  it('returns null when no rules match', async () => {
+    const pipeline = await createTestPipeline(programId)
+    const mainTrack = await createTestTrack(pipeline.id, { kind: 'MAIN', sortOrder: 0 })
+    const awardTrack = await createTestTrack(pipeline.id, { kind: 'AWARD', sortOrder: 1 })
+
+    const stage = await createTestStage(mainTrack.id, {
+      name: 'Eval',
+      status: 'STAGE_ACTIVE',
+    })
+
+    await createTestStage(awardTrack.id, { name: 'A-Eval', sortOrder: 0 })
+
+    // Project from Germany, but rule matches only France
+    const project = await createTestProject(programId, { country: 'Germany' })
+    await createTestPSS(project.id, mainTrack.id, stage.id, { state: 'PENDING' })
+
+    await createTestRoutingRule(pipeline.id, awardTrack.id, {
+      name: 'France Only Rule',
+      priority: 0,
+      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
+    })
+
+    const matched = await evaluateRoutingRules(project.id, stage.id, pipeline.id, prisma)
+    expect(matched).toBeNull()
+  })
+})