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>

src/lib/pipeline-defaults.ts

@@ -0,0 +1,143 @@
+import type {
+  IntakeConfig,
+  FilterConfig,
+  EvaluationConfig,
+  SelectionConfig,
+  LiveFinalConfig,
+  ResultsConfig,
+  WizardStageConfig,
+  WizardTrackConfig,
+  WizardState,
+} from '@/types/pipeline-wizard'
+
+export function defaultIntakeConfig(): IntakeConfig {
+  return {
+    submissionWindowEnabled: true,
+    lateSubmissionPolicy: 'flag',
+    lateGraceHours: 24,
+    fileRequirements: [
+      {
+        name: 'Executive Summary',
+        description: 'A PDF executive summary of your project',
+        acceptedMimeTypes: ['application/pdf'],
+        maxSizeMB: 50,
+        isRequired: true,
+      },
+    ],
+  }
+}
+
+export function defaultFilterConfig(): FilterConfig {
+  return {
+    rules: [],
+    aiRubricEnabled: false,
+    aiConfidenceThresholds: { high: 0.85, medium: 0.6, low: 0.4 },
+    manualQueueEnabled: true,
+  }
+}
+
+export function defaultEvaluationConfig(): EvaluationConfig {
+  return {
+    requiredReviews: 3,
+    maxLoadPerJuror: 20,
+    minLoadPerJuror: 5,
+    availabilityWeighting: true,
+    overflowPolicy: 'queue',
+  }
+}
+
+export function defaultSelectionConfig(): SelectionConfig {
+  return {
+    finalistCount: undefined,
+    rankingMethod: 'score_average',
+    tieBreaker: 'admin_decides',
+  }
+}
+
+export function defaultLiveConfig(): LiveFinalConfig {
+  return {
+    juryVotingEnabled: true,
+    audienceVotingEnabled: false,
+    audienceVoteWeight: 0,
+    cohortSetupMode: 'manual',
+    revealPolicy: 'ceremony',
+  }
+}
+
+export function defaultResultsConfig(): ResultsConfig {
+  return {
+    publicationMode: 'manual',
+    showDetailedScores: false,
+    showRankings: true,
+  }
+}
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+}
+
+export function defaultMainTrackStages(): WizardStageConfig[] {
+  return [
+    { name: 'Intake', slug: 'intake', stageType: 'INTAKE', sortOrder: 0, configJson: defaultIntakeConfig() as unknown as Record<string, unknown> },
+    { name: 'Filtering', slug: 'filtering', stageType: 'FILTER', sortOrder: 1, configJson: defaultFilterConfig() as unknown as Record<string, unknown> },
+    { name: 'Evaluation', slug: 'evaluation', stageType: 'EVALUATION', sortOrder: 2, configJson: defaultEvaluationConfig() as unknown as Record<string, unknown> },
+    { name: 'Selection', slug: 'selection', stageType: 'SELECTION', sortOrder: 3, configJson: defaultSelectionConfig() as unknown as Record<string, unknown> },
+    { name: 'Live Finals', slug: 'live-finals', stageType: 'LIVE_FINAL', sortOrder: 4, configJson: defaultLiveConfig() as unknown as Record<string, unknown> },
+    { name: 'Results', slug: 'results', stageType: 'RESULTS', sortOrder: 5, configJson: defaultResultsConfig() as unknown as Record<string, unknown> },
+  ]
+}
+
+export function defaultMainTrack(): WizardTrackConfig {
+  return {
+    name: 'Main Competition',
+    slug: 'main-competition',
+    kind: 'MAIN',
+    sortOrder: 0,
+    stages: defaultMainTrackStages(),
+  }
+}
+
+export function defaultAwardTrack(index: number): WizardTrackConfig {
+  const name = `Award ${index + 1}`
+  return {
+    name,
+    slug: slugify(name),
+    kind: 'AWARD',
+    sortOrder: index + 1,
+    routingModeDefault: 'PARALLEL',
+    decisionMode: 'JURY_VOTE',
+    stages: [
+      { name: 'Evaluation', slug: 'evaluation', stageType: 'EVALUATION', sortOrder: 0, configJson: defaultEvaluationConfig() as unknown as Record<string, unknown> },
+      { name: 'Results', slug: 'results', stageType: 'RESULTS', sortOrder: 1, configJson: defaultResultsConfig() as unknown as Record<string, unknown> },
+    ],
+    awardConfig: { name, scoringMode: 'PICK_WINNER' },
+  }
+}
+
+export function defaultNotificationConfig(): Record<string, boolean> {
+  return {
+    'stage.transitioned': true,
+    'filtering.completed': true,
+    'assignment.generated': true,
+    'routing.executed': true,
+    'live.cursor.updated': true,
+    'cohort.window.changed': true,
+    'decision.overridden': true,
+    'award.winner.finalized': true,
+  }
+}
+
+export function defaultWizardState(programId: string): WizardState {
+  return {
+    name: '',
+    slug: '',
+    programId,
+    settingsJson: {},
+    tracks: [defaultMainTrack()],
+    notificationConfig: defaultNotificationConfig(),
+    overridePolicy: { allowedRoles: ['SUPER_ADMIN', 'PROGRAM_ADMIN'] },
+  }
+}

src/lib/pipeline-validation.ts

@@ -0,0 +1,112 @@
+import type { ValidationResult, WizardState, WizardTrackConfig, WizardStageConfig } from '@/types/pipeline-wizard'
+
+function ok(): ValidationResult {
+  return { valid: true, errors: [], warnings: [] }
+}
+
+function fail(errors: string[], warnings: string[] = []): ValidationResult {
+  return { valid: false, errors, warnings }
+}
+
+export function validateBasics(state: WizardState): ValidationResult {
+  const errors: string[] = []
+  if (!state.name.trim()) errors.push('Pipeline name is required')
+  if (!state.slug.trim()) errors.push('Pipeline slug is required')
+  else if (!/^[a-z0-9-]+$/.test(state.slug)) errors.push('Slug must be lowercase alphanumeric with hyphens only')
+  if (!state.programId) errors.push('Program must be selected')
+  return errors.length ? fail(errors) : ok()
+}
+
+export function validateStage(stage: WizardStageConfig): ValidationResult {
+  const errors: string[] = []
+  if (!stage.name.trim()) errors.push(`Stage name is required`)
+  if (!stage.slug.trim()) errors.push(`Stage slug is required`)
+  else if (!/^[a-z0-9-]+$/.test(stage.slug)) errors.push(`Stage slug "${stage.slug}" is invalid`)
+  return errors.length ? fail(errors) : ok()
+}
+
+export function validateTrack(track: WizardTrackConfig): ValidationResult {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (!track.name.trim()) errors.push('Track name is required')
+  if (!track.slug.trim()) errors.push('Track slug is required')
+  if (track.stages.length === 0) errors.push(`Track "${track.name}" must have at least one stage`)
+
+  // Check for duplicate slugs within track
+  const slugs = new Set<string>()
+  for (const stage of track.stages) {
+    if (slugs.has(stage.slug)) {
+      errors.push(`Duplicate stage slug "${stage.slug}" in track "${track.name}"`)
+    }
+    slugs.add(stage.slug)
+    const stageResult = validateStage(stage)
+    errors.push(...stageResult.errors)
+  }
+
+  // MAIN track should ideally have at least INTAKE and one other stage
+  if (track.kind === 'MAIN' && track.stages.length < 2) {
+    warnings.push('Main track should have at least 2 stages')
+  }
+
+  // AWARD tracks need awardConfig
+  if (track.kind === 'AWARD' && !track.awardConfig?.name) {
+    errors.push(`Award track "${track.name}" requires an award name`)
+  }
+
+  return errors.length ? fail(errors, warnings) : { valid: true, errors: [], warnings }
+}
+
+export function validateTracks(tracks: WizardTrackConfig[]): ValidationResult {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (tracks.length === 0) {
+    errors.push('At least one track is required')
+    return fail(errors)
+  }
+
+  const mainTracks = tracks.filter((t) => t.kind === 'MAIN')
+  if (mainTracks.length === 0) {
+    errors.push('At least one MAIN track is required')
+  } else if (mainTracks.length > 1) {
+    warnings.push('Multiple MAIN tracks detected — typically only one is needed')
+  }
+
+  // Check for duplicate track slugs
+  const trackSlugs = new Set<string>()
+  for (const track of tracks) {
+    if (trackSlugs.has(track.slug)) {
+      errors.push(`Duplicate track slug "${track.slug}"`)
+    }
+    trackSlugs.add(track.slug)
+    const trackResult = validateTrack(track)
+    errors.push(...trackResult.errors)
+    warnings.push(...trackResult.warnings)
+  }
+
+  return errors.length ? fail(errors, warnings) : { valid: true, errors: [], warnings }
+}
+
+export function validateNotifications(config: Record<string, boolean>): ValidationResult {
+  // Notifications are optional — just validate structure
+  return ok()
+}
+
+export function validateAll(state: WizardState): {
+  valid: boolean
+  sections: {
+    basics: ValidationResult
+    tracks: ValidationResult
+    notifications: ValidationResult
+  }
+} {
+  const basics = validateBasics(state)
+  const tracks = validateTracks(state.tracks)
+  const notifications = validateNotifications(state.notificationConfig)
+
+  return {
+    valid: basics.valid && tracks.valid && notifications.valid,
+    sections: { basics, tracks, notifications },
+  }
+}