Simplify routing to award assignment, seed all CSV entries, fix category mapping

- Remove RoutingRule model and routing engine (replaced by direct award assignment)
- Simplify RoutingMode enum: PARALLEL/POST_MAIN → SHARED, keep EXCLUSIVE
- Remove routing router, routing-rules-editor, and related tests
- Update pipeline, award, and notification code to remove routing references
- Seed: include all CSV entries (no filtering/dedup), AI screening handles duplicates
- Seed: fix non-breaking space (U+00A0) bug in category/issue mapping
- Stage filtering: add duplicate detection that flags projects for admin review

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

tests/integration/award-exclusive.test.ts

@@ -1,99 +0,0 @@
-/**
- * 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')
-  })
-})

tests/integration/transition-routing.test.ts

@@ -1,117 +0,0 @@
-/**
- * I-003: Transition + Routing — Filter Pass → Main + Award Parallel
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { prisma } from '../setup'
-import {
-  createTestUser,
-  createTestProgram,
-  createTestPipeline,
-  createTestTrack,
-  createTestStage,
-  createTestTransition,
-  createTestProject,
-  createTestPSS,
-  createTestRoutingRule,
-  cleanupTestData,
-} from '../helpers'
-import { executeTransition } from '@/server/services/stage-engine'
-import { evaluateRoutingRules, executeRouting } from '@/server/services/routing-engine'
-
-let programId: string
-let userIds: string[] = []
-
-beforeAll(async () => {
-  const program = await createTestProgram({ name: 'Transition+Routing Test' })
-  programId = program.id
-})
-
-afterAll(async () => {
-  await cleanupTestData(programId, userIds)
-})
-
-describe('I-003: Transition + Routing — Parallel Award Track', () => {
-  it('transitions a project then routes it to a parallel award track', async () => {
-    const admin = await createTestUser('SUPER_ADMIN')
-    userIds.push(admin.id)
-
-    const pipeline = await createTestPipeline(programId)
-
-    // Main track: FILTER → EVALUATION
-    const mainTrack = await createTestTrack(pipeline.id, {
-      name: 'Main',
-      kind: 'MAIN',
-      sortOrder: 0,
-    })
-    const filterStage = await createTestStage(mainTrack.id, {
-      name: 'Filter',
-      stageType: 'FILTER',
-      status: 'STAGE_ACTIVE',
-      sortOrder: 0,
-    })
-    const evalStage = await createTestStage(mainTrack.id, {
-      name: 'Evaluation',
-      stageType: 'EVALUATION',
-      status: 'STAGE_ACTIVE',
-      sortOrder: 1,
-    })
-    await createTestTransition(filterStage.id, evalStage.id)
-
-    // Award track (PARALLEL)
-    const awardTrack = await createTestTrack(pipeline.id, {
-      name: 'Innovation Award',
-      kind: 'AWARD',
-      sortOrder: 1,
-      routingMode: 'PARALLEL',
-    })
-    const awardEvalStage = await createTestStage(awardTrack.id, {
-      name: 'Award Eval',
-      stageType: 'EVALUATION',
-      status: 'STAGE_ACTIVE',
-      sortOrder: 0,
-    })
-
-    // Routing rule: projects from France → Award track (parallel)
-    await createTestRoutingRule(pipeline.id, awardTrack.id, {
-      name: 'France → Innovation Award',
-      priority: 0,
-      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
-    })
-
-    // Create project in filter stage
-    const project = await createTestProject(programId, { country: 'France' })
-    await createTestPSS(project.id, mainTrack.id, filterStage.id, { state: 'PENDING' })
-
-    // Step 1: Transition from filter → evaluation
-    const transResult = await executeTransition(
-      project.id, mainTrack.id, filterStage.id, evalStage.id,
-      'PENDING', admin.id, prisma
-    )
-    expect(transResult.success).toBe(true)
-
-    // Step 2: Evaluate routing rules
-    const matchedRule = await evaluateRoutingRules(
-      project.id, evalStage.id, pipeline.id, prisma
-    )
-    expect(matchedRule).not.toBeNull()
-    expect(matchedRule!.destinationTrackId).toBe(awardTrack.id)
-    expect(matchedRule!.routingMode).toBe('PARALLEL')
-
-    // Step 3: Execute routing
-    const routeResult = await executeRouting(project.id, matchedRule!, admin.id, prisma)
-    expect(routeResult.success).toBe(true)
-
-    // Verify: Project should be in BOTH main eval stage AND award eval stage
-    const mainPSS = await prisma.projectStageState.findFirst({
-      where: { projectId: project.id, stageId: evalStage.id, exitedAt: null },
-    })
-    expect(mainPSS).not.toBeNull() // Still in main track
-
-    const awardPSS = await prisma.projectStageState.findFirst({
-      where: { projectId: project.id, stageId: awardEvalStage.id, exitedAt: null },
-    })
-    expect(awardPSS).not.toBeNull() // Also in award track
-    expect(awardPSS!.state).toBe('PENDING')
-  })
-})