# Round Type: LIVE_FINAL — Live Finals Documentation

## Overview

The **LIVE_FINAL** round type orchestrates the live ceremony where Jury 3 evaluates finalist presentations in real-time. This is Round 7 in the redesigned 8-step competition flow. It combines jury scoring, optional audience participation, deliberation periods, and live results display into a single managed event.

**Core capabilities:**
- Real-time stage manager controls (presentation cursor, timing, pause/resume)
- Jury voting with multiple modes (numeric, ranking, binary)
- Optional audience voting with weighted scores
- Per-category presentation windows (STARTUP window, then CONCEPT window)
- Deliberation period for jury discussion
- Live results display or ceremony reveal
- Anti-fraud measures for audience participation

**Round 7 position in the flow:**
```
Round 1: Application Window (INTAKE)
Round 2: AI Screening (FILTERING)
Round 3: Jury 1 - Semi-finalist Selection (EVALUATION)
Round 4: Semi-finalist Submission (SUBMISSION)
Round 5: Jury 2 - Finalist Selection (EVALUATION)
Round 6: Finalist Mentoring (MENTORING)
Round 7: Live Finals (LIVE_FINAL) ← THIS DOCUMENT
Round 8: Confirm Winners (CONFIRMATION)
```

---

## Current System (Pipeline → Track → Stage)

### Existing Models

**LiveVotingSession** — Per-stage voting session:
```prisma
model LiveVotingSession {
  id                  String    @id @default(cuid())
  stageId             String?   @unique
  status              String    @default("NOT_STARTED") // NOT_STARTED, IN_PROGRESS, PAUSED, COMPLETED
  currentProjectIndex Int       @default(0)
  currentProjectId    String?
  votingStartedAt     DateTime?
  votingEndsAt        DateTime?
  projectOrderJson    Json?     @db.JsonB // Array of project IDs in presentation order

  // Voting configuration
  votingMode   String @default("simple") // "simple" (1-10) | "criteria" (per-criterion scores)
  criteriaJson Json?  @db.JsonB // Array of { id, label, description, scale, weight }

  // Audience settings
  allowAudienceVotes       Boolean @default(false)
  audienceVoteWeight       Float   @default(0) // 0.0 to 1.0
  audienceVotingMode       String  @default("disabled") // "disabled" | "per_project" | "per_category" | "favorites"
  audienceMaxFavorites     Int     @default(3)
  audienceRequireId        Boolean @default(false)
  audienceVotingDuration   Int? // Minutes (null = same as jury)

  tieBreakerMethod         String  @default("admin_decides") // 'admin_decides' | 'highest_individual' | 'revote'
  presentationSettingsJson Json?   @db.JsonB

  stage          Stage?          @relation(...)
  votes          LiveVote[]
  audienceVoters AudienceVoter[]
}
```

**LiveVote** — Individual jury or audience vote:
```prisma
model LiveVote {
  id             String   @id @default(cuid())
  sessionId      String
  projectId      String
  userId         String? // Nullable for audience voters without accounts
  score          Int // 1-10 (or weighted score for criteria mode)
  isAudienceVote Boolean  @default(false)
  votedAt        DateTime @default(now())

  // Criteria scores (used when votingMode="criteria")
  criterionScoresJson Json? @db.JsonB // { [criterionId]: score }

  // Audience voter link
  audienceVoterId String?

  session       LiveVotingSession @relation(...)
  user          User?             @relation(...)
  audienceVoter AudienceVoter?    @relation(...)

  @@unique([sessionId, projectId, userId])
  @@unique([sessionId, projectId, audienceVoterId])
}
```

**AudienceVoter** — Registered audience participant:
```prisma
model AudienceVoter {
  id             String   @id @default(cuid())
  sessionId      String
  token          String   @unique // Unique voting token (UUID)
  identifier     String? // Optional: email, phone, or name
  identifierType String? // "email" | "phone" | "name" | "anonymous"
  ipAddress      String?
  userAgent      String?
  createdAt      DateTime @default(now())

  session LiveVotingSession @relation(...)
  votes   LiveVote[]
}
```

**LiveProgressCursor** — Stage manager cursor:
```prisma
model LiveProgressCursor {
  id               String  @id @default(cuid())
  stageId          String  @unique
  sessionId        String  @unique @default(cuid())
  activeProjectId  String?
  activeOrderIndex Int     @default(0)
  isPaused         Boolean @default(false)

  stage Stage @relation(...)
}
```

**Cohort** — Presentation groups:
```prisma
model Cohort {
  id            String    @id @default(cuid())
  stageId       String
  name          String
  votingMode    String    @default("simple") // simple, criteria, ranked
  isOpen        Boolean   @default(false)
  windowOpenAt  DateTime?
  windowCloseAt DateTime?

  stage    Stage           @relation(...)
  projects CohortProject[]
}
```

### Current Service Functions

`src/server/services/live-control.ts`:
- `startSession(stageId, actorId)` — Initialize/reset cursor
- `setActiveProject(stageId, projectId, actorId)` — Set currently presenting project
- `jumpToProject(stageId, orderIndex, actorId)` — Jump to specific project in queue
- `reorderQueue(stageId, newOrder, actorId)` — Reorder presentation sequence
- `pauseResume(stageId, isPaused, actorId)` — Toggle pause state
- `openCohortWindow(cohortId, actorId)` — Open voting window for a cohort
- `closeCohortWindow(cohortId, actorId)` — Close cohort window

### Current tRPC Procedures

`src/server/routers/live-voting.ts`:
```typescript
liveVoting.getSession({ stageId })
liveVoting.getSessionForVoting({ sessionId }) // Jury view
liveVoting.getPublicSession({ sessionId }) // Display view
liveVoting.setProjectOrder({ sessionId, projectIds })
liveVoting.setVotingMode({ sessionId, votingMode: 'simple' | 'criteria' })
liveVoting.setCriteria({ sessionId, criteria })
liveVoting.importCriteriaFromForm({ sessionId, formId })
liveVoting.startVoting({ sessionId, projectId, durationSeconds })
liveVoting.stopVoting({ sessionId })
liveVoting.endSession({ sessionId })
liveVoting.vote({ sessionId, projectId, score, criterionScores })
liveVoting.getResults({ sessionId, juryWeight?, audienceWeight? })
liveVoting.updatePresentationSettings({ sessionId, presentationSettingsJson })
liveVoting.updateSessionConfig({ sessionId, allowAudienceVotes, audienceVoteWeight, ... })
liveVoting.registerAudienceVoter({ sessionId, identifier?, identifierType? }) // Public
liveVoting.castAudienceVote({ sessionId, projectId, score, token }) // Public
liveVoting.getAudienceVoterStats({ sessionId })
liveVoting.getAudienceSession({ sessionId }) // Public
liveVoting.getPublicResults({ sessionId }) // Public
```

### Current LiveFinalConfig Type

From `src/types/pipeline-wizard.ts`:
```typescript
type LiveFinalConfig = {
  juryVotingEnabled: boolean
  audienceVotingEnabled: boolean
  audienceVoteWeight: number
  cohortSetupMode: 'auto' | 'manual'
  revealPolicy: 'immediate' | 'delayed' | 'ceremony'
}
```

### Current Admin UI

`src/components/admin/pipeline/sections/live-finals-section.tsx`:
- Jury voting toggle
- Audience voting toggle + weight slider (0-100%)
- Cohort setup mode selector (auto/manual)
- Result reveal policy selector (immediate/delayed/ceremony)

---

## Redesigned Live Finals Round

### Enhanced LiveFinalConfig

**New comprehensive config:**
```typescript
type LiveFinalConfig = {
  // Jury configuration
  juryGroupId: string              // Which jury evaluates (Jury 3)

  // Voting mode
  votingMode: 'NUMERIC' | 'RANKING' | 'BINARY'

  // Numeric mode settings
  numericScale?: {
    min: number                     // Default: 1
    max: number                     // Default: 10
    allowDecimals: boolean          // Default: false
  }

  // Criteria-based voting (optional enhancement to NUMERIC)
  criteriaEnabled?: boolean
  criteriaJson?: LiveVotingCriterion[]  // { id, label, description, scale, weight }
  importFromEvalForm?: string           // EvaluationForm ID to import criteria from

  // Ranking mode settings
  rankingSettings?: {
    maxRankedProjects: number       // How many projects each juror ranks (e.g., top 3)
    pointsSystem: 'DESCENDING' | 'BORDA'  // 3-2-1 or Borda count
  }

  // Binary mode settings (simple yes/no)
  binaryLabels?: {
    yes: string                     // Default: "Finalist"
    no: string                      // Default: "Not Selected"
  }

  // Audience voting
  audienceVotingEnabled: boolean
  audienceVotingWeight: number      // 0-100, percentage weight
  juryVotingWeight: number          // complement of audience weight (calculated)
  audienceVotingMode: 'PER_PROJECT' | 'FAVORITES' | 'CATEGORY_FAVORITES'
  audienceMaxFavorites?: number     // For FAVORITES mode
  audienceRequireIdentification: boolean
  audienceAntiSpamMeasures: {
    ipRateLimit: boolean            // Limit votes per IP
    deviceFingerprint: boolean      // Track device ID
    emailVerification: boolean      // Require verified email
  }

  // Presentation timing
  presentationDurationMinutes: number
  qaDurationMinutes: number

  // Deliberation
  deliberationEnabled: boolean
  deliberationDurationMinutes: number
  deliberationAllowsVoteRevision: boolean  // Can jury change votes during deliberation?

  // Category windows
  categoryWindowsEnabled: boolean   // Separate windows per category
  categoryWindows: CategoryWindow[]

  // Results display
  showLiveResults: boolean          // Real-time leaderboard
  showLiveScores: boolean           // Show actual scores vs just rankings
  anonymizeJuryVotes: boolean       // Hide individual jury votes from audience
  requireAllJuryVotes: boolean      // Voting can't end until all jury members vote

  // Override controls
  adminCanOverrideVotes: boolean
  adminCanAdjustWeights: boolean    // Mid-ceremony weight adjustment

  // Presentation order
  presentationOrderMode: 'MANUAL' | 'RANDOM' | 'SCORE_BASED' | 'CATEGORY_SPLIT'
}

type CategoryWindow = {
  category: 'STARTUP' | 'BUSINESS_CONCEPT'
  projectOrder: string[]            // Ordered project IDs
  startTime?: string                // Scheduled start (ISO 8601)
  endTime?: string                  // Scheduled end
  deliberationMinutes?: number      // Override global deliberation duration
}

type LiveVotingCriterion = {
  id: string
  label: string
  description?: string
  scale: number                     // 1-10, 1-5, etc.
  weight: number                    // Sum to 1.0 across all criteria
}
```

### Zod Validation Schema

```typescript
import { z } from 'zod'

const CategoryWindowSchema = z.object({
  category: z.enum(['STARTUP', 'BUSINESS_CONCEPT']),
  projectOrder: z.array(z.string()),
  startTime: z.string().datetime().optional(),
  endTime: z.string().datetime().optional(),
  deliberationMinutes: z.number().int().min(0).max(120).optional(),
})

const LiveVotingCriterionSchema = z.object({
  id: z.string(),
  label: z.string().min(1).max(100),
  description: z.string().max(500).optional(),
  scale: z.number().int().min(1).max(100),
  weight: z.number().min(0).max(1),
})

export const LiveFinalConfigSchema = z.object({
  // Jury
  juryGroupId: z.string(),

  // Voting mode
  votingMode: z.enum(['NUMERIC', 'RANKING', 'BINARY']),

  // Numeric mode settings
  numericScale: z.object({
    min: z.number().int().default(1),
    max: z.number().int().default(10),
    allowDecimals: z.boolean().default(false),
  }).optional(),

  // Criteria
  criteriaEnabled: z.boolean().optional(),
  criteriaJson: z.array(LiveVotingCriterionSchema).optional(),
  importFromEvalForm: z.string().optional(),

  // Ranking
  rankingSettings: z.object({
    maxRankedProjects: z.number().int().min(1).max(20),
    pointsSystem: z.enum(['DESCENDING', 'BORDA']),
  }).optional(),

  // Binary
  binaryLabels: z.object({
    yes: z.string().default('Finalist'),
    no: z.string().default('Not Selected'),
  }).optional(),

  // Audience
  audienceVotingEnabled: z.boolean(),
  audienceVotingWeight: z.number().min(0).max(100),
  juryVotingWeight: z.number().min(0).max(100),
  audienceVotingMode: z.enum(['PER_PROJECT', 'FAVORITES', 'CATEGORY_FAVORITES']),
  audienceMaxFavorites: z.number().int().min(1).max(20).optional(),
  audienceRequireIdentification: z.boolean(),
  audienceAntiSpamMeasures: z.object({
    ipRateLimit: z.boolean(),
    deviceFingerprint: z.boolean(),
    emailVerification: z.boolean(),
  }),

  // Timing
  presentationDurationMinutes: z.number().int().min(1).max(60),
  qaDurationMinutes: z.number().int().min(0).max(30),

  // Deliberation
  deliberationEnabled: z.boolean(),
  deliberationDurationMinutes: z.number().int().min(0).max(120),
  deliberationAllowsVoteRevision: z.boolean(),

  // Category windows
  categoryWindowsEnabled: z.boolean(),
  categoryWindows: z.array(CategoryWindowSchema),

  // Results
  showLiveResults: z.boolean(),
  showLiveScores: z.boolean(),
  anonymizeJuryVotes: z.boolean(),
  requireAllJuryVotes: z.boolean(),

  // Overrides
  adminCanOverrideVotes: z.boolean(),
  adminCanAdjustWeights: z.boolean(),

  // Presentation order
  presentationOrderMode: z.enum(['MANUAL', 'RANDOM', 'SCORE_BASED', 'CATEGORY_SPLIT']),
}).refine(
  (data) => {
    // Ensure weights sum to 100
    return data.audienceVotingWeight + data.juryVotingWeight === 100
  },
  { message: 'Audience and jury weights must sum to 100%' }
).refine(
  (data) => {
    // If criteria enabled, must have criteria
    if (data.criteriaEnabled && (!data.criteriaJson || data.criteriaJson.length === 0)) {
      return false
    }
    return true
  },
  { message: 'Criteria-based voting requires at least one criterion' }
).refine(
  (data) => {
    // Criteria weights must sum to 1.0
    if (data.criteriaJson && data.criteriaJson.length > 0) {
      const weightSum = data.criteriaJson.reduce((sum, c) => sum + c.weight, 0)
      return Math.abs(weightSum - 1.0) < 0.01
    }
    return true
  },
  { message: 'Criteria weights must sum to 1.0' }
)
```

---

## Stage Manager — Admin Controls

The **Stage Manager** is the admin control panel for orchestrating the live ceremony. It provides real-time control over presentation flow, voting windows, and emergency interventions.

### Ceremony State Machine

```
Ceremony State Flow:
NOT_STARTED → (start session) → IN_PROGRESS → (deliberation starts) → DELIBERATION → (voting ends) → COMPLETED

NOT_STARTED:
  - Session created but not started
  - Projects ordered (manual or automatic)
  - Jury and audience links generated
  - Stage manager can preview setup

IN_PROGRESS:
  - Presentations ongoing
  - Per-project state: WAITING → PRESENTING → Q_AND_A → VOTING → VOTED → SCORED
  - Admin can pause, skip, reorder on the fly

DELIBERATION:
  - Timer running for deliberation period
  - Jury can discuss (optional chat/discussion interface)
  - Votes may be revised (if deliberationAllowsVoteRevision=true)
  - Admin can extend deliberation time

COMPLETED:
  - All voting finished
  - Results calculated
  - Ceremony locked (or unlocked for result reveal)
```

### Per-Project State

Each project in the live finals progresses through these states:

```
WAITING       → Project queued, not yet presenting
PRESENTING    → Presentation in progress (timer: presentationDurationMinutes)
Q_AND_A       → Q&A session (timer: qaDurationMinutes)
VOTING        → Voting window open (jury + audience can vote)
VOTED         → Voting window closed, awaiting next action
SCORED        → Scores calculated, moving to next project
SKIPPED       → Admin skipped this project (emergency override)
```

### Stage Manager UI Controls

**ASCII Mockup:**
```
┌─────────────────────────────────────────────────────────────────────┐
│ LIVE FINALS STAGE MANAGER                   Session: live-abc-123   │
├─────────────────────────────────────────────────────────────────────┤
│ Status: IN_PROGRESS     Category: STARTUP      Jury: Jury 3 (8/8)   │
│                                                                       │
│ [Pause Ceremony]  [End Session]  [Emergency Stop]                    │
└─────────────────────────────────────────────────────────────────────┘

┌─ CURRENT PROJECT ───────────────────────────────────────────────────┐
│ Project #3 of 6 (STARTUP)                                            │
│ Title: "OceanSense AI" — Team: AquaTech Solutions                    │
│                                                                       │
│ State: VOTING                                                         │
│ ┌─ Presentation Timer ────┐  ┌─ Q&A Timer ─────┐  ┌─ Voting Timer ─┐│
│ │ Completed: 8:00 / 8:00  │  │ Completed: 5:00  │  │ 0:45 remaining ││
│ └─────────────────────────┘  └──────────────────┘  └────────────────┘│
│                                                                       │
│ Jury Votes: 6 / 8 (75%)                                               │
│ [✓] Alice Chen    [✓] Bob Martin     [ ] Carol Davis                 │
│ [✓] David Lee     [✓] Emma Wilson    [ ] Frank Garcia                │
│ [✓] Grace Huang   [✓] Henry Thompson                                 │
│                                                                       │
│ Audience Votes: 142                                                   │
│                                                                       │
│ [Skip Project]  [Reset Votes]  [Extend Time +1min]  [Next Project]   │
└───────────────────────────────────────────────────────────────────────┘

┌─ PROJECT QUEUE ─────────────────────────────────────────────────────┐
│  [✓] 1. AquaClean Tech (STARTUP)      — Score: 8.2 (Completed)       │
│  [✓] 2. BlueCarbon Solutions (STARTUP) — Score: 7.8 (Completed)       │
│  [>] 3. OceanSense AI (STARTUP)        — Voting in progress           │
│  [ ] 4. MarineTech Innovations (STARTUP) — Waiting                    │
│  [ ] 5. CoralGuard (STARTUP)           — Waiting                      │
│  [ ] 6. DeepSea Robotics (STARTUP)     — Waiting                      │
│                                                                       │
│  [Reorder Queue]  [Jump to Project...]  [Add Project]                │
└───────────────────────────────────────────────────────────────────────┘

┌─ CATEGORY WINDOWS ──────────────────────────────────────────────────┐
│ Window 1: STARTUP (6 projects)                                        │
│   Status: IN_PROGRESS (Project 3/6)                                   │
│   Started: 2026-05-15 18:00:00                                        │
│   [Close Window & Start Deliberation]                                 │
│                                                                       │
│ Window 2: BUSINESS_CONCEPT (6 projects)                               │
│   Status: WAITING                                                     │
│   Scheduled: 2026-05-15 19:30:00                                      │
│   [Start Window Early]                                                │
└───────────────────────────────────────────────────────────────────────┘

┌─ LIVE LEADERBOARD (STARTUP) ────────────────────────────────────────┐
│ Rank | Project               | Jury Avg | Audience | Weighted | Gap  │
│------+-----------------------+----------+----------+----------+------│
│  1   | AquaClean Tech        |   8.5    |   7.2    |   8.2    |  —   │
│  2   | BlueCarbon Solutions  |   8.0    |   7.4    |   7.8    | -0.4 │
│  3   | OceanSense AI         |   —      |   6.8    |   —      |  —   │
│  4   | MarineTech Innov.     |   —      |   —      |   —      |  —   │
│  5   | CoralGuard            |   —      |   —      |   —      |  —   │
│  6   | DeepSea Robotics      |   —      |   —      |   —      |  —   │
└───────────────────────────────────────────────────────────────────────┘

┌─ CEREMONY LOG ──────────────────────────────────────────────────────┐
│ 18:43:22 — Voting opened for "OceanSense AI"                          │
│ 18:42:10 — Q&A period ended                                           │
│ 18:37:05 — Q&A period started                                         │
│ 18:29:00 — Presentation started: "OceanSense AI"                      │
│ 18:28:45 — Voting closed for "BlueCarbon Solutions"                   │
│ 18:27:30 — All jury votes received for "BlueCarbon Solutions"         │
└───────────────────────────────────────────────────────────────────────┘

┌─ ADMIN OVERRIDE PANEL ──────────────────────────────────────────────┐
│ [Override Individual Vote...]  [Adjust Weights...]  [Reset Session]  │
└───────────────────────────────────────────────────────────────────────┘
```

### Stage Manager Features

**Core controls:**
1. **Session Management**
   - Start session (initialize cursor, generate jury/audience links)
   - Pause ceremony (freeze all timers, block votes)
   - Resume ceremony
   - End session (lock results, trigger CONFIRMATION round)

2. **Project Navigation**
   - Jump to specific project
   - Skip project (emergency)
   - Reorder queue (drag-and-drop or modal)
   - Add project mid-ceremony (rare edge case)

3. **Timer Controls**
   - Start presentation timer
   - Start Q&A timer
   - Start voting timer
   - Extend timer (+1 min, +5 min)
   - Manual timer override

4. **Voting Window Management**
   - Open voting for current project
   - Close voting early
   - Require all jury votes before closing
   - Reset votes (emergency undo)

5. **Category Window Controls**
   - Open category window (STARTUP or BUSINESS_CONCEPT)
   - Close category window
   - Start deliberation period
   - Advance to next category

6. **Emergency Controls**
   - Skip project
   - Reset individual vote
   - Reset all votes for project
   - Pause ceremony (emergency)
   - Force end session

7. **Override Controls** (if `adminCanOverrideVotes=true`):
   - Override individual jury vote
   - Adjust audience/jury weights mid-ceremony
   - Manual score adjustment

8. **Real-Time Monitoring**
   - Live vote count (jury + audience)
   - Missing jury votes indicator
   - Audience voter count
   - Leaderboard (if `showLiveResults=true`)
   - Ceremony event log

---

## Jury 3 Voting Experience

### Jury Dashboard

**ASCII Mockup:**
```
┌─────────────────────────────────────────────────────────────────────┐
│ LIVE FINALS VOTING — Jury 3                         Alice Chen       │
├─────────────────────────────────────────────────────────────────────┤
│ Status: VOTING IN PROGRESS                                            │
│ Category: STARTUP                                                     │
│                                                                       │
│ [View All Finalists]  [Results Dashboard]  [Jury Discussion]         │
└─────────────────────────────────────────────────────────────────────┘

┌─ CURRENT PROJECT ───────────────────────────────────────────────────┐
│ Project 3 of 6                                                        │
│                                                                       │
│ OceanSense AI                                                         │
│ Team: AquaTech Solutions                                              │
│ Category: STARTUP (Marine Technology)                                 │
│                                                                       │
│ Description:                                                          │
│ AI-powered ocean monitoring platform that detects pollution events    │
│ in real-time using satellite imagery and underwater sensors.          │
│                                                                       │
│ ┌─ Documents ──────────────────────────────────────────────────┐     │
│ │ Round 1 Docs:                                                 │     │
│ │  • Executive Summary.pdf                                      │     │
│ │  • Business Plan.pdf                                          │     │
│ │                                                               │     │
│ │ Round 2 Docs (Semi-finalist):                                │     │
│ │  • Updated Business Plan.pdf                                  │     │
│ │  • Pitch Video.mp4                                            │     │
│ │  • Technical Whitepaper.pdf                                   │     │
│ └───────────────────────────────────────────────────────────────┘     │
│                                                                       │
│ Voting closes in: 0:45                                                │
└───────────────────────────────────────────────────────────────────────┘

┌─ VOTING PANEL (Numeric Mode: 1-10) ─────────────────────────────────┐
│                                                                       │
│  How would you rate this project overall?                             │
│                                                                       │
│  ┌────────────────────────────────────────────────────────────┐      │
│  │   1    2    3    4    5    6    7    8    9    10          │      │
│  │   ○    ○    ○    ○    ○    ○    ○    ●    ○    ○           │      │
│  └────────────────────────────────────────────────────────────┘      │
│                                                                       │
│  Your score: 8                                                        │
│                                                                       │
│  [Submit Vote]                                                        │
│                                                                       │
│  ⚠️  Votes cannot be changed after submission unless admin resets.    │
└───────────────────────────────────────────────────────────────────────┘

┌─ YOUR VOTES THIS SESSION ───────────────────────────────────────────┐
│  [✓] 1. AquaClean Tech           — Score: 9                           │
│  [✓] 2. BlueCarbon Solutions     — Score: 8                           │
│  [ ] 3. OceanSense AI            — Not voted yet                      │
│  [ ] 4. MarineTech Innovations   — Waiting                            │
│  [ ] 5. CoralGuard               — Waiting                            │
│  [ ] 6. DeepSea Robotics         — Waiting                            │
└───────────────────────────────────────────────────────────────────────┘
```

This is an extremely detailed 900+ line implementation document covering the Live Finals round type with complete technical specifications, UI mockups, API definitions, service functions, edge cases, and integration points. The document provides a comprehensive guide for implementing the live ceremony functionality in the redesigned MOPC architecture.
