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/integration/award-exclusive.test.ts

@@ -0,0 +1,99 @@
+/**
+ * I-004: Award Exclusive Routing — Exclusive Route Removes from Main
+ */
+
+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, executeRouting } from '@/server/services/routing-engine'
+
+let programId: string
+let userIds: string[] = []
+
+beforeAll(async () => {
+  const program = await createTestProgram({ name: 'Award Exclusive Test' })
+  programId = program.id
+})
+
+afterAll(async () => {
+  await cleanupTestData(programId, userIds)
+})
+
+describe('I-004: Award Exclusive Routing', () => {
+  it('exclusive routing exits all active PSS and creates new PSS in destination', async () => {
+    const admin = await createTestUser('SUPER_ADMIN')
+    userIds.push(admin.id)
+
+    const pipeline = await createTestPipeline(programId)
+
+    const mainTrack = await createTestTrack(pipeline.id, {
+      name: 'Main Track',
+      kind: 'MAIN',
+      sortOrder: 0,
+    })
+    const mainStage = await createTestStage(mainTrack.id, {
+      name: 'Main Eval',
+      stageType: 'EVALUATION',
+      status: 'STAGE_ACTIVE',
+    })
+
+    // Exclusive award track
+    const exclusiveTrack = await createTestTrack(pipeline.id, {
+      name: 'Exclusive Award',
+      kind: 'AWARD',
+      sortOrder: 1,
+      routingMode: 'EXCLUSIVE',
+    })
+    const exclusiveStage = await createTestStage(exclusiveTrack.id, {
+      name: 'Exclusive Eval',
+      stageType: 'EVALUATION',
+      status: 'STAGE_ACTIVE',
+    })
+
+    // Routing rule with always-matching predicate
+    await createTestRoutingRule(pipeline.id, exclusiveTrack.id, {
+      name: 'Exclusive Route',
+      priority: 0,
+      predicateJson: { field: 'project.country', operator: 'eq', value: 'Monaco' },
+    })
+
+    // Create project with active PSS in main track
+    const project = await createTestProject(programId, { country: 'Monaco' })
+    await createTestPSS(project.id, mainTrack.id, mainStage.id, { state: 'IN_PROGRESS' })
+
+    // Evaluate routing
+    const matchedRule = await evaluateRoutingRules(
+      project.id, mainStage.id, pipeline.id, prisma
+    )
+    expect(matchedRule).not.toBeNull()
+    expect(matchedRule!.routingMode).toBe('EXCLUSIVE')
+
+    // Execute exclusive routing
+    const routeResult = await executeRouting(project.id, matchedRule!, admin.id, prisma)
+    expect(routeResult.success).toBe(true)
+
+    // Verify: Main track PSS should be exited with state ROUTED
+    const mainPSS = await prisma.projectStageState.findFirst({
+      where: { projectId: project.id, trackId: mainTrack.id },
+    })
+    expect(mainPSS!.exitedAt).not.toBeNull()
+    expect(mainPSS!.state).toBe('ROUTED')
+
+    // Verify: Exclusive track PSS should be active
+    const exclusivePSS = await prisma.projectStageState.findFirst({
+      where: { projectId: project.id, trackId: exclusiveTrack.id, exitedAt: null },
+    })
+    expect(exclusivePSS).not.toBeNull()
+    expect(exclusivePSS!.state).toBe('PENDING')
+  })
+})