diff --git a/app/models/cs2-major-stage.ts b/app/models/cs2-major-stage.ts
new file mode 100644
index 0000000..4875178
--- /dev/null
+++ b/app/models/cs2-major-stage.ts
@@ -0,0 +1,193 @@
+/**
+ * Model for CS2 Major Stage Results
+ *
+ * Tracks the 3-stage Swiss format of CS2 Majors:
+ *   Stage 1 (Opening Stage):   16 teams, lowest-seeded, Swiss Bo1/Bo3
+ *   Stage 2 (Elimination Stage): 16 teams (8 direct Challengers + 8 from Stage 1), Swiss Bo1/Bo3
+ *   Stage 3 (Decider Stage):   16 teams (8 direct Legends + 8 from Stage 2), Swiss all Bo3
+ *   Champions Stage:           8 teams, single-elimination (uses simple_8 bracket template)
+ *
+ * One row per (scoringEventId, participantId) — tracks which stage they enter,
+ * where they were eliminated, their W-L record at elimination (for QP sub-ranking
+ * within placements 9–16), and final placement after the event completes.
+ */
+
+import { database } from "~/database/context";
+import { cs2MajorStageResults, participants } from "~/database/schema";
+import { eq, inArray, sql } from "drizzle-orm";
+
+export interface Cs2StageResult {
+  id: string;
+  scoringEventId: string;
+  participantId: string;
+  stageEntry: number;              // 1, 2, or 3
+  stageEliminated: number | null;  // null = made Champions Stage
+  stageEliminatedWins: number | null; // 0, 1, or 2 wins at time of elimination
+  finalPlacement: number | null;   // 1–32, set after event completes
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface Cs2StageResultWithName extends Cs2StageResult {
+  participantName: string;
+}
+
+export interface Cs2StageAssignmentInput {
+  scoringEventId: string;
+  participantId: string;
+  stageEntry: number;
+}
+
+/**
+ * Get all stage results for a CS2 Major event, joined with participant names.
+ */
+export async function getCs2StageResultsForEvent(
+  scoringEventId: string
+): Promise<Cs2StageResultWithName[]> {
+  const db = database();
+  const rows = await db
+    .select({
+      id: cs2MajorStageResults.id,
+      scoringEventId: cs2MajorStageResults.scoringEventId,
+      participantId: cs2MajorStageResults.participantId,
+      stageEntry: cs2MajorStageResults.stageEntry,
+      stageEliminated: cs2MajorStageResults.stageEliminated,
+      stageEliminatedWins: cs2MajorStageResults.stageEliminatedWins,
+      finalPlacement: cs2MajorStageResults.finalPlacement,
+      createdAt: cs2MajorStageResults.createdAt,
+      updatedAt: cs2MajorStageResults.updatedAt,
+      participantName: participants.name,
+    })
+    .from(cs2MajorStageResults)
+    .innerJoin(participants, eq(cs2MajorStageResults.participantId, participants.id))
+    .where(eq(cs2MajorStageResults.scoringEventId, scoringEventId))
+    .orderBy(cs2MajorStageResults.stageEntry, participants.name);
+
+  return rows;
+}
+
+/**
+ * Get raw stage results for a CS2 Major event (without participant names).
+ * Used by the simulator.
+ */
+export async function getCs2StageResultsMapForEvent(
+  scoringEventId: string
+): Promise<Map<string, Cs2StageResult>> {
+  const db = database();
+  const rows = await db
+    .select()
+    .from(cs2MajorStageResults)
+    .where(eq(cs2MajorStageResults.scoringEventId, scoringEventId));
+
+  return new Map(rows.map((r) => [r.participantId, r]));
+}
+
+/**
+ * Upsert stage assignments for a CS2 Major event.
+ * Sets stageEntry for each participant; resets stageEliminated/stageEliminatedWins
+ * so that re-assigning a team's stage also clears any previously recorded results.
+ */
+export async function upsertCs2StageAssignments(
+  inputs: Cs2StageAssignmentInput[]
+): Promise<void> {
+  if (inputs.length === 0) return;
+  const db = database();
+  const now = new Date();
+
+  await db
+    .insert(cs2MajorStageResults)
+    .values(
+      inputs.map(({ scoringEventId, participantId, stageEntry }) => ({
+        scoringEventId,
+        participantId,
+        stageEntry,
+        stageEliminated: null,
+        stageEliminatedWins: null,
+        finalPlacement: null,
+        createdAt: now,
+        updatedAt: now,
+      }))
+    )
+    .onConflictDoUpdate({
+      target: [cs2MajorStageResults.scoringEventId, cs2MajorStageResults.participantId],
+      set: {
+        stageEntry: sql`excluded.stage_entry`,
+        stageEliminated: null,
+        stageEliminatedWins: null,
+        finalPlacement: null,
+        updatedAt: sql`excluded.updated_at`,
+      },
+    });
+}
+
+/**
+ * Remove all stage assignments for a CS2 Major event.
+ * Called when the admin resets the event setup.
+ */
+export async function clearCs2StageAssignments(
+  scoringEventId: string
+): Promise<void> {
+  const db = database();
+  await db
+    .delete(cs2MajorStageResults)
+    .where(eq(cs2MajorStageResults.scoringEventId, scoringEventId));
+}
+
+/**
+ * Mark teams as eliminated from a specific stage.
+ * Records stageEliminated and stageEliminatedWins for the specified participants.
+ * Teams NOT in eliminatedEntries that are in this stage are implicitly considered
+ * to have advanced (stageEliminated remains null).
+ */
+export async function markCs2StageEliminations(
+  scoringEventId: string,
+  eliminations: Array<{ participantId: string; winsAtElimination: number }>
+): Promise<void> {
+  if (eliminations.length === 0) return;
+  const db = database();
+  const now = new Date();
+
+  // Use individual upserts for each eliminated team to set their specific win count
+  await Promise.all(
+    eliminations.map(({ participantId, winsAtElimination }) =>
+      db
+        .update(cs2MajorStageResults)
+        .set({
+          stageEliminated: sql`stage_entry`,  // eliminated at their current stage
+          stageEliminatedWins: winsAtElimination,
+          updatedAt: now,
+        })
+        .where(
+          eq(cs2MajorStageResults.scoringEventId, scoringEventId) &&
+          eq(cs2MajorStageResults.participantId, participantId)
+        )
+    )
+  );
+}
+
+/**
+ * Set final placements for all participants in a CS2 Major event.
+ * Called after the Champions Stage is complete.
+ * placements: Map from participantId to final placement (1–32)
+ */
+export async function setCs2FinalPlacements(
+  scoringEventId: string,
+  placements: Record<string, number>
+): Promise<void> {
+  const db = database();
+  const now = new Date();
+  const participantIds = Object.keys(placements);
+  if (participantIds.length === 0) return;
+
+  await Promise.all(
+    participantIds.map((participantId) =>
+      db
+        .update(cs2MajorStageResults)
+        .set({ finalPlacement: placements[participantId], updatedAt: now })
+        .where(
+          eq(cs2MajorStageResults.scoringEventId, scoringEventId) &&
+          eq(cs2MajorStageResults.participantId, participantId)
+        )
+    )
+  );
+}
diff --git a/app/routes.ts b/app/routes.ts
index cf108fa..158fcd4 100644
--- a/app/routes.ts
+++ b/app/routes.ts
@@ -79,6 +79,10 @@ export default [
       "sports-seasons/:id/events/:eventId/bracket",
       "routes/admin.sports-seasons.$id.events.$eventId.bracket.tsx"
     ),
+    route(
+      "sports-seasons/:id/events/:eventId/cs2-setup",
+      "routes/admin.sports-seasons.$id.events.$eventId.cs2-setup.tsx"
+    ),
     route(
       "sports-seasons/:id/expected-values",
       "routes/admin.sports-seasons.$id.expected-values.tsx"
@@ -99,6 +103,10 @@ export default [
       "sports-seasons/:id/darts-elo",
       "routes/admin.sports-seasons.$id.darts-elo.tsx"
     ),
+    route(
+      "sports-seasons/:id/cs-elo",
+      "routes/admin.sports-seasons.$id.cs-elo.tsx"
+    ),
     route(
       "sports-seasons/:id/golf-skills",
       "routes/admin.sports-seasons.$id.golf-skills.tsx"
diff --git a/app/routes/admin.sports-seasons.$id.cs-elo.tsx b/app/routes/admin.sports-seasons.$id.cs-elo.tsx
new file mode 100644
index 0000000..7b6a226
--- /dev/null
+++ b/app/routes/admin.sports-seasons.$id.cs-elo.tsx
@@ -0,0 +1,457 @@
+import { Form, redirect, useLoaderData, useActionData, useNavigation } from 'react-router';
+import type { Route } from './+types/admin.sports-seasons.$id.cs-elo';
+
+import { logger } from '~/lib/logger';
+import { findSportsSeasonById, updateSportsSeason } from '~/models/sports-season';
+import { findParticipantsBySportsSeasonId } from '~/models/participant';
+import {
+  getAllParticipantEVsForSeason,
+  batchSaveSourceElos,
+  batchUpsertParticipantEVs,
+} from '~/models/participant-expected-value';
+import { batchUpsertParticipantEvSnapshots } from '~/models/ev-snapshot';
+import { getSimulator, type SimulatorType } from '~/services/simulations/registry';
+import { calculateEV } from '~/services/ev-calculator';
+import { DEFAULT_SCORING_RULES } from '~/lib/scoring-types';
+import { recalculateStandings } from '~/models/scoring-calculator';
+import { database } from '~/database/context';
+import * as schema from '~/database/schema';
+import { eq } from 'drizzle-orm';
+import { Button } from '~/components/ui/button';
+import { Input } from '~/components/ui/input';
+import { Label } from '~/components/ui/label';
+import { Textarea } from '~/components/ui/textarea';
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '~/components/ui/card';
+import { useState } from 'react';
+import { Loader2, CheckCircle2, AlertCircle } from 'lucide-react';
+import { normalizeName } from '~/lib/fuzzy-match';
+
+export function meta({ data }: Route.MetaArgs): Route.MetaDescriptors {
+  return [{ title: `CS2 Elo & HLTV Rankings — ${data?.sportsSeason?.name ?? "Sports Season"} - Brackt Admin` }];
+}
+
+export async function loader({ params }: Route.LoaderArgs) {
+  const sportsSeasonId = params.id;
+
+  const sportsSeason = await findSportsSeasonById(sportsSeasonId);
+  if (!sportsSeason) {
+    throw new Response('Sports season not found', { status: 404 });
+  }
+
+  const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);
+  const existingEVs = await getAllParticipantEVsForSeason(sportsSeasonId);
+
+  const existingData: Record<string, { elo: number | null; ranking: number | null }> = {};
+  for (const ev of existingEVs) {
+    existingData[ev.participantId] = {
+      elo: ev.sourceElo ?? null,
+      ranking: ev.worldRanking ?? null,
+    };
+  }
+
+  return { sportsSeason, participants, existingData };
+}
+
+interface ActionData {
+  success?: boolean;
+  message?: string;
+}
+
+export async function action({ request, params }: Route.ActionArgs) {
+  const sportsSeasonId = params.id;
+  const formData = await request.formData();
+
+  const sportsSeason = await findSportsSeasonById(sportsSeasonId);
+  if (!sportsSeason) {
+    return { success: false, message: 'Sports season not found' };
+  }
+
+  const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);
+
+  const eloInputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number; worldRanking?: number | null }> = [];
+  for (const participant of participants) {
+    const eloVal = formData.get(`elo_${participant.id}`) as string;
+    const rankVal = formData.get(`rank_${participant.id}`) as string;
+
+    if (eloVal && eloVal.trim() !== '') {
+      const elo = Number(eloVal);
+      if (!isNaN(elo) && elo > 0) {
+        const ranking = rankVal && rankVal.trim() !== '' ? Number(rankVal) : null;
+        eloInputs.push({
+          participantId: participant.id,
+          sportsSeasonId,
+          sourceElo: elo,
+          worldRanking: ranking && !isNaN(ranking) && ranking > 0 ? ranking : null,
+        });
+      }
+    }
+  }
+
+  if (eloInputs.length === 0) {
+    return { success: false, message: 'Please enter an Elo rating for at least one team' };
+  }
+
+  if (!sportsSeason.sport?.simulatorType) {
+    return { success: false, message: 'This sport has no simulator type configured. Set one on the sport in the admin panel.' };
+  }
+
+  if (sportsSeason.simulationStatus === 'running') {
+    return { success: false, message: 'A simulation is already running. Please wait.' };
+  }
+
+  await batchSaveSourceElos(eloInputs);
+
+  await updateSportsSeason(sportsSeasonId, { simulationStatus: 'running' });
+
+  try {
+    const simulator = getSimulator(sportsSeason.sport.simulatorType as SimulatorType);
+    const results = await simulator.simulate(sportsSeasonId);
+
+    if (results.length === 0) {
+      throw new Error('Simulation returned no results.');
+    }
+
+    const simulatedIds = new Set(results.map(r => r.participantId));
+    const ZERO_PROBS = {
+      probFirst: 0, probSecond: 0, probThird: 0, probFourth: 0,
+      probFifth: 0, probSixth: 0, probSeventh: 0, probEighth: 0,
+    };
+    const evInputs = [
+      ...results.map(r => ({
+        participantId: r.participantId,
+        sportsSeasonId,
+        probabilities: r.probabilities,
+        scoringRules: DEFAULT_SCORING_RULES,
+        source: 'elo_simulation' as const,
+      })),
+      ...participants
+        .filter(p => !simulatedIds.has(p.id))
+        .map(p => ({
+          participantId: p.id,
+          sportsSeasonId,
+          probabilities: ZERO_PROBS,
+          scoringRules: DEFAULT_SCORING_RULES,
+          source: 'elo_simulation' as const,
+        })),
+    ];
+
+    await batchUpsertParticipantEVs(evInputs);
+
+    const seasonSports = await database().query.seasonSports.findMany({
+      where: eq(schema.seasonSports.sportsSeasonId, sportsSeasonId),
+    });
+    await Promise.all(seasonSports.map(({ seasonId }) => recalculateStandings(seasonId)));
+
+    const today = new Date().toISOString().slice(0, 10);
+    await batchUpsertParticipantEvSnapshots(
+      results.map(r => ({
+        participantId: r.participantId,
+        sportsSeasonId,
+        snapshotDate: today,
+        probFirst: r.probabilities.probFirst,
+        probSecond: r.probabilities.probSecond,
+        probThird: r.probabilities.probThird,
+        probFourth: r.probabilities.probFourth,
+        probFifth: r.probabilities.probFifth,
+        probSixth: r.probabilities.probSixth,
+        probSeventh: r.probabilities.probSeventh,
+        probEighth: r.probabilities.probEighth,
+        calculatedEV: calculateEV(r.probabilities, DEFAULT_SCORING_RULES),
+        source: r.source,
+      }))
+    );
+
+    await updateSportsSeason(sportsSeasonId, { simulationStatus: 'idle' });
+  } catch (error) {
+    await updateSportsSeason(sportsSeasonId, { simulationStatus: 'failed' });
+    logger.error('Error running CS2 major simulation:', error);
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : 'Simulation failed',
+    };
+  }
+
+  return redirect(`/admin/sports-seasons/${sportsSeasonId}/expected-values`);
+}
+
+export default function AdminSportsSeasonCsElo() {
+  const { sportsSeason, participants, existingData } = useLoaderData<typeof loader>();
+  const actionData = useActionData<ActionData>();
+  const navigation = useNavigation();
+
+  const [eloValues, setEloValues] = useState<Record<string, string>>(() => {
+    const initial: Record<string, string> = {};
+    participants.forEach(p => {
+      const d = existingData[p.id];
+      if (d?.elo !== null && d?.elo !== undefined) initial[p.id] = d.elo.toString();
+    });
+    return initial;
+  });
+
+  const [rankValues, setRankValues] = useState<Record<string, string>>(() => {
+    const initial: Record<string, string> = {};
+    participants.forEach(p => {
+      const d = existingData[p.id];
+      if (d?.ranking !== null && d?.ranking !== undefined) initial[p.id] = d.ranking.toString();
+    });
+    return initial;
+  });
+
+  const [bulkText, setBulkText] = useState('');
+  const [parseResults, setParseResults] = useState<{
+    matched: Array<{ participantId: string; name: string; elo: number; ranking: number | null; inputName: string }>;
+    unmatched: Array<{ inputName: string; elo: number; ranking: number | null }>;
+  } | null>(null);
+
+  function findParticipantMatch(inputName: string) {
+    const normalizedInput = normalizeName(inputName);
+    const normalized = participants.map(p => ({ p, n: normalizeName(p.name) }));
+
+    const exact = normalized.find(({ n }) => n === normalizedInput);
+    if (exact) return exact.p;
+
+    const contains = normalized.find(({ n }) => n.includes(normalizedInput) || normalizedInput.includes(n));
+    if (contains) return contains.p;
+
+    const inputWords = normalizedInput.split(' ').filter(w => w.length > 2);
+    const overlap = normalized.find(({ n }) => {
+      const pWords = n.split(' ').filter(w => w.length > 2);
+      const shared = inputWords.filter(w => pWords.includes(w));
+      return shared.length > 0 && shared.length >= Math.min(inputWords.length, pWords.length) * 0.5;
+    });
+
+    return overlap?.p ?? null;
+  }
+
+  function parseBulkText() {
+    const lines = bulkText.split('\n');
+    const matched: typeof parseResults extends null ? never : NonNullable<typeof parseResults>['matched'] = [];
+    const unmatched: typeof parseResults extends null ? never : NonNullable<typeof parseResults>['unmatched'] = [];
+    const seen = new Set<string>();
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      const match = /^(.+?)[\s,:\t]+(\d{3,5})(?:[\s,:\t]+(\d{1,3}))?\s*$/.exec(trimmed);
+      if (!match) continue;
+
+      const inputName = match[1].trim();
+      const elo = parseInt(match[2], 10);
+      const ranking = match[3] ? parseInt(match[3], 10) : null;
+
+      if (isNaN(elo) || elo < 500 || elo > 5000) continue;
+      if (ranking !== null && (isNaN(ranking) || ranking < 1 || ranking > 256)) continue;
+
+      const participant = findParticipantMatch(inputName);
+      if (participant && !seen.has(participant.id)) {
+        seen.add(participant.id);
+        matched.push({ participantId: participant.id, name: participant.name, elo, ranking, inputName });
+      } else if (!participant) {
+        unmatched.push({ inputName, elo, ranking });
+      }
+    }
+
+    setParseResults({ matched, unmatched });
+  }
+
+  function applyMatches() {
+    if (!parseResults) return;
+    const newElos = { ...eloValues };
+    const newRanks = { ...rankValues };
+    for (const m of parseResults.matched) {
+      newElos[m.participantId] = m.elo.toString();
+      if (m.ranking !== null) {
+        newRanks[m.participantId] = m.ranking.toString();
+      }
+    }
+    setEloValues(newElos);
+    setRankValues(newRanks);
+    setParseResults(null);
+    setBulkText('');
+  }
+
+  const isSubmitting = navigation.state === 'submitting';
+
+  const sortedParticipants = [...participants].toSorted((a, b) => {
+    const rankA = rankValues[a.id] ? parseInt(rankValues[a.id], 10) : null;
+    const rankB = rankValues[b.id] ? parseInt(rankValues[b.id], 10) : null;
+    if (rankA !== null && rankB !== null) return rankA - rankB;
+    if (rankA !== null) return -1;
+    if (rankB !== null) return 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  return (
+    <div className="container mx-auto py-8">
+      <div className="mb-8">
+        <h1 className="text-3xl font-bold mb-2">CS2 Team Elo &amp; HLTV Rankings</h1>
+        <p className="text-muted-foreground">
+          {sportsSeason.sport.name} — {sportsSeason.name}
+        </p>
+      </div>
+
+      <Card className="mb-6">
+        <CardHeader>
+          <CardTitle>Bulk Import</CardTitle>
+          <CardDescription>
+            Paste one team per line. Format:{' '}
+            <code>Team Name, 1850, 5</code> (name, Elo, HLTV ranking).
+            HLTV ranking is optional — omit it and the simulator will use Elo order for stage seeding.
+            Team names are fuzzy-matched to participants.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <Textarea
+            placeholder={`Natus Vincere, 1850, 1\nFaZe Clan, 1820, 2\nVitality, 1800, 3`}
+            value={bulkText}
+            onChange={e => { setBulkText(e.target.value); setParseResults(null); }}
+            rows={10}
+            className="font-mono text-sm"
+          />
+          <Button type="button" variant="outline" onClick={parseBulkText} disabled={!bulkText.trim()}>
+            Parse
+          </Button>
+
+          {parseResults && (
+            <div className="space-y-3">
+              {parseResults.matched.length > 0 && (
+                <div>
+                  <div className="flex items-center gap-2 text-sm font-medium text-emerald-400 mb-2">
+                    <CheckCircle2 className="h-4 w-4" />
+                    Matched ({parseResults.matched.length})
+                  </div>
+                  <div className="rounded-md border border-emerald-500/30 bg-emerald-500/10 divide-y divide-emerald-500/20 text-sm">
+                    {parseResults.matched.map(m => (
+                      <div key={m.participantId} className="flex justify-between px-3 py-1.5">
+                        <span className="text-muted-foreground">{m.inputName}</span>
+                        <span className="font-medium">
+                          {m.name} &rarr; Elo {m.elo}{m.ranking !== null ? `, Rank #${m.ranking}` : ''}
+                        </span>
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              )}
+
+              {parseResults.unmatched.length > 0 && (
+                <div>
+                  <div className="flex items-center gap-2 text-sm font-medium text-amber-700 mb-2">
+                    <AlertCircle className="h-4 w-4" />
+                    Not matched ({parseResults.unmatched.length}) — enter manually below
+                  </div>
+                  <div className="rounded-md border border-amber-200 bg-amber-50 divide-y divide-amber-100 text-sm">
+                    {parseResults.unmatched.map(u => (
+                      <div key={u.inputName} className="flex justify-between px-3 py-1.5">
+                        <span>{u.inputName}</span>
+                        <span className="font-medium">
+                          Elo {u.elo}{u.ranking !== null ? `, Rank #${u.ranking}` : ''}
+                        </span>
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              )}
+
+              {parseResults.matched.length > 0 && (
+                <Button type="button" onClick={applyMatches}>
+                  Apply {parseResults.matched.length} matched entries to form
+                </Button>
+              )}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+
+      <div className="grid gap-6 lg:grid-cols-2">
+        <Card>
+          <CardHeader>
+            <CardTitle>Team Elo &amp; HLTV Rankings</CardTitle>
+            <CardDescription>
+              Enter each team&apos;s Elo rating and HLTV world ranking. Rankings determine which
+              Swiss stage a team enters (1–8 = Stage 3/Legends, 9–16 = Stage 2/Challengers,
+              17–32 = Stage 1/Opening). Saving will automatically run the simulation and update
+              expected values.
+            </CardDescription>
+          </CardHeader>
+          <CardContent>
+            <Form method="post" className="space-y-4">
+              <div className="grid grid-cols-[1fr_100px_80px] gap-x-3 gap-y-2 items-center text-xs font-medium text-muted-foreground mb-1">
+                <span>Team</span>
+                <span>Elo</span>
+                <span>HLTV #</span>
+              </div>
+              <div className="space-y-2">
+                {sortedParticipants.map(participant => (
+                  <div key={participant.id} className="grid grid-cols-[1fr_100px_80px] gap-x-3 items-center">
+                    <Label htmlFor={`elo_${participant.id}`} className="truncate text-sm">
+                      {participant.name}
+                    </Label>
+                    <Input
+                      type="number"
+                      id={`elo_${participant.id}`}
+                      name={`elo_${participant.id}`}
+                      placeholder="1800"
+                      value={eloValues[participant.id] ?? ''}
+                      onChange={e =>
+                        setEloValues(prev => ({ ...prev, [participant.id]: e.target.value }))
+                      }
+                      className="h-8 text-sm"
+                    />
+                    <Input
+                      type="number"
+                      name={`rank_${participant.id}`}
+                      placeholder="—"
+                      value={rankValues[participant.id] ?? ''}
+                      onChange={e =>
+                        setRankValues(prev => ({ ...prev, [participant.id]: e.target.value }))
+                      }
+                      className="h-8 text-sm"
+                    />
+                  </div>
+                ))}
+              </div>
+
+              {actionData && !actionData.success && actionData.message && (
+                <div className="text-sm text-destructive">{actionData.message}</div>
+              )}
+
+              <Button type="submit" disabled={isSubmitting}>
+                {isSubmitting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
+                {isSubmitting ? 'Saving & Running Simulation...' : 'Save & Run Simulation'}
+              </Button>
+            </Form>
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader>
+            <CardTitle>How It Works</CardTitle>
+          </CardHeader>
+          <CardContent className="text-sm space-y-2">
+            <ol className="list-decimal list-inside space-y-2">
+              <li>Save Elo ratings and HLTV rankings for all teams</li>
+              <li>Rankings determine stage entry (1–8 = Stage 3 Legends, 9–16 = Stage 2 Challengers, 17–32 = Stage 1 Opening)</li>
+              <li>Per-game win probability: p = 1 / (1 + 10^(−ΔElo/400))</li>
+              <li>Swiss stages use Bernoulli series model (Bo1 for Stages 1–2, Bo3 for Stage 3)</li>
+              <li>Champions Stage: 8-team single-elimination (QF Bo3, SF Bo3, GF Bo5)</li>
+              <li>Run 10,000 Monte Carlo simulations of the full major</li>
+              <li>Stage 3 exits ranked by W-L record for QP sub-placement (2-3 &gt; 1-3 &gt; 0-3)</li>
+              <li>QP accumulates across both majors; teams ranked 1st–8th by total QP</li>
+            </ol>
+            <div className="mt-4 text-muted-foreground text-xs space-y-1">
+              <div>Stage assignments from event setup override rank-based inference.</div>
+              <div>Once the official field is announced, assign teams to stages in the event setup page.</div>
+            </div>
+          </CardContent>
+        </Card>
+      </div>
+    </div>
+  );
+}
diff --git a/app/routes/admin.sports-seasons.$id.events.$eventId.cs2-setup.tsx b/app/routes/admin.sports-seasons.$id.events.$eventId.cs2-setup.tsx
new file mode 100644
index 0000000..a9ba635
--- /dev/null
+++ b/app/routes/admin.sports-seasons.$id.events.$eventId.cs2-setup.tsx
@@ -0,0 +1,337 @@
+import { Form, useLoaderData, useActionData, useNavigation, Link } from 'react-router';
+import type { Route } from './+types/admin.sports-seasons.$id.events.$eventId.cs2-setup';
+
+import { findSportsSeasonById } from '~/models/sports-season';
+import { getScoringEventById } from '~/models/scoring-event';
+import { findParticipantsBySportsSeasonId } from '~/models/participant';
+import {
+  getCs2StageResultsForEvent,
+  upsertCs2StageAssignments,
+  markCs2StageEliminations,
+  clearCs2StageAssignments,
+} from '~/models/cs2-major-stage';
+import { Button } from '~/components/ui/button';
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '~/components/ui/card';
+import { Badge } from '~/components/ui/badge';
+import { ArrowLeft, Save, Trash2, CheckCircle2 } from 'lucide-react';
+import { useState } from 'react';
+
+export function meta({ data }: Route.MetaArgs): Route.MetaDescriptors {
+  return [{ title: `CS2 Stage Setup — ${data?.event?.name ?? "Event"} - Brackt Admin` }];
+}
+
+export async function loader({ params }: Route.LoaderArgs) {
+  const sportsSeasonId = params.id;
+  const eventId = params.eventId;
+
+  const [sportsSeason, event] = await Promise.all([
+    findSportsSeasonById(sportsSeasonId),
+    getScoringEventById(eventId),
+  ]);
+
+  if (!sportsSeason) throw new Response('Sports season not found', { status: 404 });
+  if (!event) throw new Response('Event not found', { status: 404 });
+
+  const [participants, stageResults] = await Promise.all([
+    findParticipantsBySportsSeasonId(sportsSeasonId),
+    getCs2StageResultsForEvent(eventId),
+  ]);
+
+  return { sportsSeason, event, participants, stageResults };
+}
+
+interface ActionData {
+  success?: boolean;
+  message?: string;
+}
+
+export async function action({ request, params }: Route.ActionArgs) {
+  const eventId = params.eventId;
+  const formData = await request.formData();
+  const intent = formData.get('intent') as string;
+
+  if (intent === 'reset') {
+    await clearCs2StageAssignments(eventId);
+    return { success: true, message: 'Stage assignments cleared.' };
+  }
+
+  if (intent === 'assign') {
+    const assignments: Array<{ scoringEventId: string; participantId: string; stageEntry: number }> = [];
+    for (const [key, value] of formData.entries()) {
+      if (key.startsWith('stage_')) {
+        const participantId = key.slice('stage_'.length);
+        const stageEntry = parseInt(value as string, 10);
+        if (!isNaN(stageEntry) && stageEntry >= 1 && stageEntry <= 3) {
+          assignments.push({ scoringEventId: eventId, participantId, stageEntry });
+        }
+      }
+    }
+
+    if (assignments.length === 0) {
+      return { success: false, message: 'No stage assignments submitted.' };
+    }
+
+    await upsertCs2StageAssignments(assignments);
+    return { success: true, message: `Saved ${assignments.length} stage assignments.` };
+  }
+
+  if (intent === 'mark-eliminations') {
+    // Parse elimination data: elim_{participantId} = winsAtElimination (0, 1, or 2)
+    const eliminations: Array<{ participantId: string; winsAtElimination: number }> = [];
+    for (const [key, value] of formData.entries()) {
+      if (key.startsWith('elim_')) {
+        const participantId = key.slice('elim_'.length);
+        const wins = parseInt(value as string, 10);
+        if (!isNaN(wins) && wins >= 0 && wins <= 2) {
+          eliminations.push({ participantId, winsAtElimination: wins });
+        }
+      }
+    }
+
+    await markCs2StageEliminations(eventId, eliminations);
+    return { success: true, message: `Marked ${eliminations.length} eliminations.` };
+  }
+
+  return { success: false, message: 'Unknown action.' };
+}
+
+const STAGE_LABELS: Record<number, { label: string; description: string; maxTeams: number; badgeVariant: 'default' | 'secondary' | 'outline' }> = {
+  1: { label: 'Stage 1', description: 'Opening Stage (16 teams, Bo1 Swiss)', maxTeams: 16, badgeVariant: 'outline' },
+  2: { label: 'Stage 2', description: 'Elimination Stage (8 Challengers, Bo1/Bo3 Swiss)', maxTeams: 8, badgeVariant: 'secondary' },
+  3: { label: 'Stage 3', description: 'Decider Stage (8 Legends, all Bo3 Swiss)', maxTeams: 8, badgeVariant: 'default' },
+};
+
+const RECORD_OPTIONS = [
+  { value: '2', label: '2-3 (advanced furthest)' },
+  { value: '1', label: '1-3' },
+  { value: '0', label: '0-3 (earliest exit)' },
+];
+
+export default function AdminCs2Setup() {
+  const { sportsSeason, event, participants, stageResults } = useLoaderData<typeof loader>();
+  const actionData = useActionData<ActionData>();
+  const navigation = useNavigation();
+  const isSubmitting = navigation.state === 'submitting';
+
+  // Build maps from existing stage results
+  const stageMap = new Map(stageResults.map(r => [r.participantId, r]));
+  const assignedIds = new Set(stageResults.map(r => r.participantId));
+  const unassignedParticipants = participants.filter(p => !assignedIds.has(p.id));
+
+  // Stage assignment state (local, submitted via form)
+  const [stageSelections, setStageSelections] = useState<Record<string, string>>(() => {
+    const initial: Record<string, string> = {};
+    stageResults.forEach(r => { initial[r.participantId] = r.stageEntry.toString(); });
+    return initial;
+  });
+
+  // Group participants by stage for display
+  const byStage: Record<number, typeof stageResults> = { 1: [], 2: [], 3: [] };
+  for (const r of stageResults) {
+    byStage[r.stageEntry]?.push(r);
+  }
+
+  const stageCounts = Object.fromEntries(
+    Object.entries(byStage).map(([k, v]) => [k, v.length])
+  );
+
+  return (
+    <div className="container mx-auto py-8">
+      <div className="mb-6">
+        <Link
+          to={`/admin/sports-seasons/${sportsSeason.id}/events/${event.id}`}
+          className="flex items-center gap-2 text-sm text-muted-foreground hover:text-foreground mb-4"
+        >
+          <ArrowLeft className="h-4 w-4" />
+          Back to event
+        </Link>
+        <h1 className="text-3xl font-bold mb-1">CS2 Stage Setup</h1>
+        <p className="text-muted-foreground">{event.name} — {sportsSeason.name}</p>
+      </div>
+
+      {actionData?.message && (
+        <div className={`mb-4 p-3 rounded-md text-sm ${actionData.success ? 'bg-emerald-500/10 text-emerald-400 border border-emerald-500/30' : 'bg-destructive/10 text-destructive border border-destructive/30'}`}>
+          {actionData.message}
+        </div>
+      )}
+
+      {/* Stage Assignment */}
+      <Card className="mb-6">
+        <CardHeader>
+          <CardTitle className="flex items-center justify-between">
+            Stage Assignments
+            {stageResults.length > 0 && (
+              <Form method="post">
+                <input type="hidden" name="intent" value="reset" />
+                <Button type="submit" variant="ghost" size="sm" className="text-destructive">
+                  <Trash2 className="h-4 w-4 mr-1" />
+                  Reset all
+                </Button>
+              </Form>
+            )}
+          </CardTitle>
+          <CardDescription>
+            Assign each team to their starting stage. Stage 1 = 16 Opening Stage teams,
+            Stage 2 = 8 Challengers (skip Stage 1), Stage 3 = 8 Legends (skip Stages 1 and 2).
+            Total: 32 teams across all three stages.
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <Form method="post" className="space-y-6">
+            <input type="hidden" name="intent" value="assign" />
+
+            {/* Stage summary badges */}
+            <div className="flex gap-3 flex-wrap">
+              {[1, 2, 3].map(stage => (
+                <div key={stage} className="flex items-center gap-2 text-sm">
+                  <Badge variant={STAGE_LABELS[stage].badgeVariant}>{STAGE_LABELS[stage].label}</Badge>
+                  <span className="text-muted-foreground">
+                    {stageCounts[stage] ?? 0}/{STAGE_LABELS[stage].maxTeams} teams
+                  </span>
+                </div>
+              ))}
+            </div>
+
+            {/* Teams listed with stage selectors */}
+            <div className="space-y-1">
+              <div className="grid grid-cols-[1fr_160px] gap-x-3 text-xs font-medium text-muted-foreground px-1 mb-2">
+                <span>Team</span>
+                <span>Starting Stage</span>
+              </div>
+              {participants.map(participant => (
+                <div key={participant.id} className="grid grid-cols-[1fr_160px] gap-x-3 items-center py-1 border-b border-border/40 last:border-0">
+                  <span className="text-sm">{participant.name}</span>
+                  <select
+                    name={`stage_${participant.id}`}
+                    value={stageSelections[participant.id] ?? ''}
+                    onChange={e => setStageSelections(prev => ({ ...prev, [participant.id]: e.target.value }))}
+                    className="h-8 text-sm rounded-md border border-input bg-background px-2"
+                  >
+                    <option value="">— not assigned —</option>
+                    <option value="1">Stage 1 (Opening)</option>
+                    <option value="2">Stage 2 (Elimination)</option>
+                    <option value="3">Stage 3 (Decider)</option>
+                  </select>
+                </div>
+              ))}
+            </div>
+
+            <Button type="submit" disabled={isSubmitting}>
+              <Save className="h-4 w-4 mr-2" />
+              {isSubmitting ? 'Saving...' : 'Save Stage Assignments'}
+            </Button>
+          </Form>
+        </CardContent>
+      </Card>
+
+      {/* Advancement Tracking (only shown when stage assignments exist) */}
+      {stageResults.length > 0 && (
+        <Card className="mb-6">
+          <CardHeader>
+            <CardTitle>Stage Advancement Tracking</CardTitle>
+            <CardDescription>
+              Record which teams were eliminated and their W-L record at elimination.
+              Teams not listed as eliminated are assumed to have advanced (or are still playing).
+              Stage 3 W-L records determine QP sub-placements (9–16).
+            </CardDescription>
+          </CardHeader>
+          <CardContent>
+            <Form method="post" className="space-y-6">
+              <input type="hidden" name="intent" value="mark-eliminations" />
+
+              {[1, 2, 3].map(stage => {
+                const teamsInStage = byStage[stage];
+                if (teamsInStage.length === 0) return null;
+
+                return (
+                  <div key={stage}>
+                    <h3 className="text-sm font-semibold mb-3 flex items-center gap-2">
+                      <Badge variant={STAGE_LABELS[stage].badgeVariant}>{STAGE_LABELS[stage].label}</Badge>
+                      {STAGE_LABELS[stage].description}
+                    </h3>
+                    <div className="space-y-1">
+                      {teamsInStage.map(r => {
+                        const isEliminated = r.stageEliminated !== null;
+                        return (
+                          <div key={r.participantId} className="grid grid-cols-[1fr_auto_200px] gap-x-3 items-center py-1 border-b border-border/40 last:border-0">
+                            <span className="text-sm flex items-center gap-2">
+                              {r.participantName}
+                              {isEliminated && (
+                                <Badge variant="outline" className="text-xs">
+                                  eliminated {r.stageEliminatedWins}-3
+                                </Badge>
+                              )}
+                            </span>
+                            <label className="flex items-center gap-2 text-sm cursor-pointer">
+                              <input
+                                type="checkbox"
+                                defaultChecked={isEliminated}
+                                onChange={e => {
+                                  // Show/hide the wins selector
+                                  const winsEl = document.getElementById(`wins_${r.participantId}`);
+                                  if (winsEl) winsEl.style.display = e.target.checked ? 'block' : 'none';
+                                  // Also show/hide the hidden input
+                                  const hiddenEl = document.getElementById(`elim_hidden_${r.participantId}`) as HTMLInputElement | null;
+                                  if (hiddenEl) hiddenEl.disabled = !e.target.checked;
+                                }}
+                                className="rounded"
+                              />
+                              Eliminated
+                            </label>
+                            <div id={`wins_${r.participantId}`} style={{ display: isEliminated ? 'block' : 'none' }}>
+                              <select
+                                name={`elim_${r.participantId}`}
+                                id={`elim_hidden_${r.participantId}`}
+                                defaultValue={r.stageEliminatedWins?.toString() ?? '0'}
+                                className="h-8 w-full text-sm rounded-md border border-input bg-background px-2"
+                              >
+                                {RECORD_OPTIONS.map(opt => (
+                                  <option key={opt.value} value={opt.value}>{opt.label}</option>
+                                ))}
+                              </select>
+                            </div>
+                          </div>
+                        );
+                      })}
+                    </div>
+                  </div>
+                );
+              })}
+
+              <Button type="submit" disabled={isSubmitting}>
+                <CheckCircle2 className="h-4 w-4 mr-2" />
+                {isSubmitting ? 'Saving...' : 'Save Eliminations'}
+              </Button>
+            </Form>
+          </CardContent>
+        </Card>
+      )}
+
+      {/* Champions Stage link */}
+      {stageResults.length > 0 && (
+        <Card>
+          <CardHeader>
+            <CardTitle>Champions Stage (Playoffs)</CardTitle>
+            <CardDescription>
+              The 8-team single-elimination bracket. Use the bracket admin to track
+              Quarterfinals, Semifinals, and Grand Final results.
+            </CardDescription>
+          </CardHeader>
+          <CardContent>
+            <Link to={`/admin/sports-seasons/${sportsSeason.id}/events/${event.id}/bracket`}>
+              <Button variant="outline">
+                Open Bracket Admin →
+              </Button>
+            </Link>
+          </CardContent>
+        </Card>
+      )}
+    </div>
+  );
+}
diff --git a/app/services/simulations/__tests__/cs-major-simulator.test.ts b/app/services/simulations/__tests__/cs-major-simulator.test.ts
new file mode 100644
index 0000000..2006438
--- /dev/null
+++ b/app/services/simulations/__tests__/cs-major-simulator.test.ts
@@ -0,0 +1,230 @@
+import { describe, it, expect } from "vitest";
+import {
+  gameWinProb,
+  seriesWinProb,
+  sampleField,
+  simulateSwiss,
+  simulateChampionsStage,
+} from "../cs-major-simulator";
+
+// Helper to build a pool of teams
+function makeTeams(n: number, baseElo = 1800, baseRank = 1) {
+  return Array.from({ length: n }, (_, i) => ({
+    id: `team-${i}`,
+    elo: baseElo - i * 10,
+    rank: baseRank + i,
+  }));
+}
+
+// ─── gameWinProb ──────────────────────────────────────────────────────────────
+
+describe("gameWinProb", () => {
+  it("returns 0.5 for equal Elo", () => {
+    expect(gameWinProb(1800, 1800)).toBeCloseTo(0.5, 5);
+    expect(gameWinProb(2000, 2000)).toBeCloseTo(0.5, 5);
+  });
+
+  it("returns > 0.5 for positive advantage, < 0.5 for negative", () => {
+    expect(gameWinProb(2000, 1700)).toBeGreaterThan(0.5);
+    expect(gameWinProb(1700, 2000)).toBeLessThan(0.5);
+  });
+
+  it("is symmetric: p(a,b) + p(b,a) = 1", () => {
+    expect(gameWinProb(2000, 1700) + gameWinProb(1700, 2000)).toBeCloseTo(1.0, 5);
+  });
+
+  it("stays strictly in (0, 1)", () => {
+    const p = gameWinProb(3000, 1000);
+    expect(p).toBeLessThan(1);
+    expect(p).toBeGreaterThan(0);
+  });
+});
+
+// ─── seriesWinProb ────────────────────────────────────────────────────────────
+
+describe("seriesWinProb", () => {
+  it("returns 0.5 for equal players (p=0.5) in any format", () => {
+    expect(seriesWinProb(0.5, 2)).toBeCloseTo(0.5, 5);  // Bo3
+    expect(seriesWinProb(0.5, 3)).toBeCloseTo(0.5, 5);  // Bo5
+    expect(seriesWinProb(0.5, 4)).toBeCloseTo(0.5, 5);  // Bo7
+  });
+
+  it("amplifies better team advantage in longer formats", () => {
+    const bo3 = seriesWinProb(0.6, 2);
+    const bo5 = seriesWinProb(0.6, 3);
+    expect(bo5).toBeGreaterThan(bo3);
+  });
+
+  it("approaches 1.0 as p → 1.0", () => {
+    expect(seriesWinProb(0.9999, 2)).toBeCloseTo(1.0, 3);
+    expect(seriesWinProb(0.9999, 3)).toBeCloseTo(1.0, 3);
+  });
+
+  it("sums to 1 with complement", () => {
+    const p = 0.63;
+    expect(seriesWinProb(p, 2) + seriesWinProb(1 - p, 2)).toBeCloseTo(1.0, 5);
+    expect(seriesWinProb(p, 3) + seriesWinProb(1 - p, 3)).toBeCloseTo(1.0, 5);
+  });
+
+  it("Bo3 win prob with p=0.6 is in expected range", () => {
+    // P(2-0) + P(2-1) = 0.36 + 2*0.36*0.4 = 0.36 + 0.288 = 0.648
+    expect(seriesWinProb(0.6, 2)).toBeCloseTo(0.648, 3);
+  });
+});
+
+// ─── sampleField ──────────────────────────────────────────────────────────────
+
+describe("sampleField", () => {
+  it("returns all teams when pool <= fieldSize", () => {
+    const pool = makeTeams(20);
+    const field = sampleField(pool, 32);
+    expect(field).toHaveLength(20);
+  });
+
+  it("returns fieldSize teams when pool > fieldSize", () => {
+    const pool = makeTeams(50);
+    const field = sampleField(pool, 32);
+    expect(field).toHaveLength(32);
+  });
+
+  it("always includes the top 12 ranked teams", () => {
+    const pool = makeTeams(50);
+    const top12Ids = new Set(pool.slice(0, 12).map((t) => t.id));
+
+    for (let i = 0; i < 20; i++) {
+      const field = sampleField(pool, 32);
+      const fieldIds = new Set(field.map((t) => t.id));
+      for (const id of top12Ids) {
+        expect(fieldIds.has(id)).toBe(true);
+      }
+    }
+  });
+
+  it("never includes more teams than fieldSize", () => {
+    const pool = makeTeams(100);
+    for (let i = 0; i < 10; i++) {
+      expect(sampleField(pool, 32)).toHaveLength(32);
+    }
+  });
+
+  it("returns unique teams", () => {
+    const pool = makeTeams(50);
+    const field = sampleField(pool, 32);
+    const ids = field.map((t) => t.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+});
+
+// ─── simulateSwiss ────────────────────────────────────────────────────────────
+
+describe("simulateSwiss", () => {
+  it("returns exactly 8 advanced and 8 eliminated from 16 teams", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, false);
+    expect(result.advanced).toHaveLength(8);
+    expect(result.eliminated).toHaveLength(8);
+  });
+
+  it("all advanced teams have 3 wins (implicit by advancement threshold)", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, false);
+    // Advanced teams reached 3 wins — we can't directly check wins here,
+    // but we verify each participant appears in exactly one group
+    const allIds = new Set([
+      ...result.advanced.map((t) => t.id),
+      ...result.eliminated.map((t) => t.id),
+    ]);
+    expect(allIds.size).toBe(16);
+    for (const team of teams) {
+      expect(allIds.has(team.id)).toBe(true);
+    }
+  });
+
+  it("eliminated teams have wins 0, 1, or 2", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, false);
+    for (const t of result.eliminated) {
+      expect(t.wins).toBeGreaterThanOrEqual(0);
+      expect(t.wins).toBeLessThanOrEqual(2);
+    }
+  });
+
+  it("total wins + losses = total matches played (conservation check)", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, false);
+    // Eliminated teams have exactly 3 losses
+    // Total losses = 8 * 3 = 24
+    // Total wins = sum of wins for all eliminated + 8 * 3 for advanced = ?
+    // Each win by advanced team = 1 loss for an eliminated team
+    const totalLossesEliminated = result.eliminated.length * 3; // 24
+    expect(totalLossesEliminated).toBe(24);
+  });
+
+  it("works with Bo3 format (Swiss all Bo3)", () => {
+    const teams = makeTeams(16);
+    const result = simulateSwiss(teams, true);
+    expect(result.advanced).toHaveLength(8);
+    expect(result.eliminated).toHaveLength(8);
+  });
+
+  it("teams with much higher Elo advance more often (stochastic check)", () => {
+    // Top 8 teams have Elo 2000+, bottom 8 have Elo 1000
+    const teams = [
+      ...Array.from({ length: 8 }, (_, i) => ({ id: `top-${i}`, elo: 2000, rank: i + 1 })),
+      ...Array.from({ length: 8 }, (_, i) => ({ id: `bot-${i}`, elo: 1000, rank: i + 9 })),
+    ];
+
+    let topAdvances = 0;
+    const runs = 100;
+    for (let i = 0; i < runs; i++) {
+      const result = simulateSwiss(teams, false);
+      for (const t of result.advanced) {
+        if (t.id.startsWith("top-")) topAdvances++;
+      }
+    }
+
+    // Top teams should advance much more than half the time across runs
+    // Expected: ~7-8 top teams advance per run → topAdvances should be >> 400 (50%)
+    expect(topAdvances / runs).toBeGreaterThan(6);
+  });
+});
+
+// ─── simulateChampionsStage ───────────────────────────────────────────────────
+
+describe("simulateChampionsStage", () => {
+  it("throws if not exactly 8 teams", () => {
+    expect(() => simulateChampionsStage(makeTeams(7))).toThrow();
+    expect(() => simulateChampionsStage(makeTeams(9))).toThrow();
+  });
+
+  it("assigns placements to all 8 teams", () => {
+    const teams = makeTeams(8);
+    const result = simulateChampionsStage(teams);
+    expect(result.placements.size).toBe(8);
+    for (const team of teams) {
+      expect(result.placements.has(team.id)).toBe(true);
+    }
+  });
+
+  it("has exactly one 1st, one 2nd, two 3rd/4th, four 5th-8th", () => {
+    const teams = makeTeams(8);
+    const result = simulateChampionsStage(teams);
+    const placements = [...result.placements.values()];
+    expect(placements.filter(p => p === 1)).toHaveLength(1);
+    expect(placements.filter(p => p === 2)).toHaveLength(1);
+    expect(placements.filter(p => p >= 3 && p <= 4)).toHaveLength(2);
+    expect(placements.filter(p => p >= 5 && p <= 8)).toHaveLength(4);
+  });
+
+  it("top Elo team wins more often than last (stochastic)", () => {
+    const teams = makeTeams(8);
+    // team-0 has highest Elo, team-7 has lowest
+    let wins = 0;
+    for (let i = 0; i < 200; i++) {
+      const result = simulateChampionsStage(teams);
+      if (result.placements.get("team-0") === 1) wins++;
+    }
+    // Should win significantly more than 12.5% of the time (1/8 random)
+    expect(wins / 200).toBeGreaterThan(0.2);
+  });
+});
diff --git a/app/services/simulations/cs-major-simulator.ts b/app/services/simulations/cs-major-simulator.ts
new file mode 100644
index 0000000..351baf7
--- /dev/null
+++ b/app/services/simulations/cs-major-simulator.ts
@@ -0,0 +1,606 @@
+/**
+ * CS2 Major Qualifying Points Simulator
+ *
+ * Monte Carlo simulation of the 2 CS2 Majors per year. Qualifying points (QP)
+ * accumulate across both majors; final QP totals determine fantasy placements (1st–8th).
+ *
+ * CS2 Major format (32 teams, 3 Swiss stages + playoffs):
+ *   Stage 1 (Opening Stage):     16 teams, Swiss, Bo1 matches
+ *   Stage 2 (Elimination Stage): 16 teams (8 Challengers + 8 from Stage 1), Swiss, Bo1/Bo3
+ *   Stage 3 (Decider Stage):     16 teams (8 Legends + 8 from Stage 2), Swiss, all Bo3
+ *   Champions Stage:              8 teams, single-elimination (QF Bo3, SF Bo3, GF Bo5)
+ *
+ * Field selection (per iteration):
+ *   - Top 12 participants by world ranking are always in the simulated field.
+ *   - Remaining spots (up to 32 total) are sampled from the rest of the pool,
+ *     weighted by 1/rank (lower rank = higher inclusion probability).
+ *   - If cs2MajorStageResults records exist for an event, those explicit
+ *     stage assignments are used instead of sampling/rank inference.
+ *
+ * Stage assignment within the 32-team field:
+ *   - With explicit stage data: use stageEntry from cs2MajorStageResults
+ *   - Without: top 8 by world ranking → Stage 3, next 8 → Stage 2, bottom 16 → Stage 1
+ *
+ * QP for Stage 3 exits (placements 9–16) is sub-ranked by W-L record:
+ *   - 2-3 teams → higher placements within 9–16
+ *   - 1-3 teams → middle placements
+ *   - 0-3 teams → lowest placements within 9–16
+ *   QP is tie-split (averaged) within each W-L group.
+ *
+ * Stages 1 and 2 exits (placements 17–32) earn 0 QP.
+ */
+
+import { database } from "~/database/context";
+import { eq, and, inArray } from "drizzle-orm";
+import * as schema from "~/database/schema";
+import { getQPConfig } from "~/models/qualifying-points";
+import { getCs2StageResultsMapForEvent } from "~/models/cs2-major-stage";
+import type { Simulator, SimulationResult } from "./types";
+
+// ─── Simulation parameters ────────────────────────────────────────────────────
+
+const NUM_SIMULATIONS = 10_000;
+
+/** Total field size per CS2 Major. */
+const FIELD_SIZE = 32;
+
+/** Number of teams guaranteed in the simulated field (always included). */
+const GUARANTEED_COUNT = 12;
+
+/**
+ * Elo divisor for per-game win probability.
+ * Standard chess Elo uses 400. CS2 maps well to single-game level.
+ * 200-pt gap ≈ 76% win probability; 400-pt gap ≈ 91%.
+ */
+const ELO_DIVISOR = 400;
+
+/** Fallback Elo for teams with no stored rating. */
+const FALLBACK_ELO = 1500;
+
+// ─── Math helpers ─────────────────────────────────────────────────────────────
+
+/**
+ * Per-game win probability for team 1 vs team 2.
+ * Exported for unit testing.
+ */
+export function gameWinProb(elo1: number, elo2: number): number {
+  return 1 / (1 + Math.pow(10, (elo2 - elo1) / ELO_DIVISOR));
+}
+
+/**
+ * Match win probability using the Bernoulli series model.
+ * For a best-of-(2S-1) match (first to S wins):
+ *   P(win) = Σ_{k=0}^{S-1} C(S-1+k, k) × p^S × (1-p)^k
+ * Exported for unit testing.
+ */
+export function seriesWinProb(p: number, winsNeeded: number): number {
+  let prob = 0;
+  for (let k = 0; k < winsNeeded; k++) {
+    prob += binomialCoeff(winsNeeded - 1 + k, k) * Math.pow(p, winsNeeded) * Math.pow(1 - p, k);
+  }
+  return prob;
+}
+
+/** Binomial coefficient C(n, k). */
+function binomialCoeff(n: number, k: number): number {
+  if (k === 0) return 1;
+  if (k > n - k) k = n - k;
+  let result = 1;
+  for (let i = 0; i < k; i++) {
+    result = (result * (n - i)) / (i + 1);
+  }
+  return result;
+}
+
+/** Fisher-Yates in-place shuffle. Returns the array for chaining. */
+function shuffle<T>(arr: T[]): T[] {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+
+// ─── Field selection ──────────────────────────────────────────────────────────
+
+interface TeamWithElo {
+  id: string;
+  elo: number;
+  rank: number;  // HLTV world ranking (lower = better)
+}
+
+/**
+ * Sample a 32-team field from the pool.
+ * - Top GUARANTEED_COUNT (12) by rank are always included.
+ * - Remaining spots are weighted-randomly sampled from the rest, weight = 1/rank.
+ * - If pool.length <= FIELD_SIZE, returns all teams.
+ * Exported for unit testing.
+ */
+export function sampleField(
+  pool: TeamWithElo[],
+  fieldSize: number = FIELD_SIZE
+): TeamWithElo[] {
+  const sorted = [...pool].sort((a, b) => a.rank - b.rank);
+
+  if (sorted.length <= fieldSize) return sorted;
+
+  const guaranteed = sorted.slice(0, GUARANTEED_COUNT);
+  const rest = sorted.slice(GUARANTEED_COUNT);
+  const needed = fieldSize - guaranteed.length;
+
+  if (needed <= 0) return guaranteed;
+  if (rest.length <= needed) return [...guaranteed, ...rest];
+
+  // Weighted sample without replacement, weight = 1/rank
+  const weights = rest.map((t) => 1 / t.rank);
+  const sampled = weightedSampleWithoutReplacement(rest, weights, needed);
+
+  return [...guaranteed, ...sampled];
+}
+
+/** Weighted sampling without replacement using the Gumbel-max trick. */
+function weightedSampleWithoutReplacement<T>(
+  items: T[],
+  weights: number[],
+  count: number
+): T[] {
+  const keys = weights.map((w) => -Math.log(Math.random()) / w);
+  const indexed = items.map((item, i) => ({ item, key: keys[i] }));
+  indexed.sort((a, b) => a.key - b.key);
+  return indexed.slice(0, count).map((x) => x.item);
+}
+
+// ─── Swiss stage simulation ───────────────────────────────────────────────────
+
+interface SwissResult {
+  /** Teams that advanced (3 wins). */
+  advanced: Array<{ id: string; elo: number; rank: number }>;
+  /** Teams eliminated, with their win count at time of elimination. */
+  eliminated: Array<{ id: string; elo: number; rank: number; wins: number }>;
+}
+
+/**
+ * Simulate one Swiss-format stage.
+ * Teams are grouped by their (wins, losses) record each round. Teams are paired
+ * randomly within each record group. First to 3 wins advances; first to 3 losses
+ * is eliminated.
+ *
+ * @param teams - Teams entering this stage.
+ * @param bo3   - If true, use Bo3 series win probability; otherwise Bo1 (single game).
+ * @returns advanced and eliminated arrays.
+ *
+ * Exported for unit testing.
+ */
+export function simulateSwiss(teams: TeamWithElo[], bo3: boolean): SwissResult {
+  const wins = new Map<string, number>(teams.map((t) => [t.id, 0]));
+  const losses = new Map<string, number>(teams.map((t) => [t.id, 0]));
+  const eloMap = new Map<string, number>(teams.map((t) => [t.id, t.elo]));
+
+  const advanced: SwissResult["advanced"] = [];
+  const eliminated: SwissResult["eliminated"] = [];
+  const advancedIds = new Set<string>();
+  const eliminatedIds = new Set<string>();
+
+  const teamById = new Map<string, TeamWithElo>(teams.map((t) => [t.id, t]));
+
+  // Run rounds until every team has reached 3W or 3L
+  while (advancedIds.size + eliminatedIds.size < teams.length) {
+    // Collect active teams grouped by (W, L) record
+    const active = teams.filter((t) => !advancedIds.has(t.id) && !eliminatedIds.has(t.id));
+    const groups = groupByRecord(active, wins, losses);
+
+    // If a group has an odd number, move one team to the nearest adjacent group
+    // (simplified: skip teams that can't be paired — they sit out this round)
+    const pairs = pairGroups(groups);
+
+    for (const [t1, t2] of pairs) {
+      const e1 = eloMap.get(t1.id) ?? FALLBACK_ELO;
+      const e2 = eloMap.get(t2.id) ?? FALLBACK_ELO;
+      const p = bo3
+        ? seriesWinProb(gameWinProb(e1, e2), 2)  // Bo3: first to 2
+        : gameWinProb(e1, e2);                     // Bo1: single game
+
+      const t1Wins = Math.random() < p;
+      const winnerId = t1Wins ? t1.id : t2.id;
+      const loserId = t1Wins ? t2.id : t1.id;
+
+      wins.set(winnerId, (wins.get(winnerId) ?? 0) + 1);
+      losses.set(loserId, (losses.get(loserId) ?? 0) + 1);
+
+      if ((wins.get(winnerId) ?? 0) >= 3) {
+        advancedIds.add(winnerId);
+        const t = teamById.get(winnerId)!;
+        advanced.push({ id: t.id, elo: t.elo, rank: t.rank });
+      }
+      if ((losses.get(loserId) ?? 0) >= 3) {
+        eliminatedIds.add(loserId);
+        const t = teamById.get(loserId)!;
+        eliminated.push({ id: t.id, elo: t.elo, rank: t.rank, wins: wins.get(loserId) ?? 0 });
+      }
+    }
+  }
+
+  return { advanced, eliminated };
+}
+
+/** Group active teams by (wins, losses) record key. */
+function groupByRecord(
+  active: TeamWithElo[],
+  wins: Map<string, number>,
+  losses: Map<string, number>
+): Map<string, TeamWithElo[]> {
+  const groups = new Map<string, TeamWithElo[]>();
+  for (const t of active) {
+    const key = `${wins.get(t.id) ?? 0}-${losses.get(t.id) ?? 0}`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key)!.push(t);
+  }
+  return groups;
+}
+
+/**
+ * Pair teams within each record group. Teams in groups with an odd count
+ * are handled by merging the leftover into an adjacent group (simpler: skip
+ * them for this round — they sit out and play next round).
+ */
+function pairGroups(groups: Map<string, TeamWithElo[]>): Array<[TeamWithElo, TeamWithElo]> {
+  const pairs: Array<[TeamWithElo, TeamWithElo]> = [];
+  const leftover: TeamWithElo[] = [];
+
+  for (const group of groups.values()) {
+    const shuffled = shuffle([...group]);
+    for (let i = 0; i + 1 < shuffled.length; i += 2) {
+      pairs.push([shuffled[i], shuffled[i + 1]]);
+    }
+    if (shuffled.length % 2 !== 0) {
+      leftover.push(shuffled[shuffled.length - 1]);
+    }
+  }
+
+  // Pair leftover teams with each other (different records, cross-group match)
+  for (let i = 0; i + 1 < leftover.length; i += 2) {
+    pairs.push([leftover[i], leftover[i + 1]]);
+  }
+
+  return pairs;
+}
+
+// ─── Champions Stage (8-team single-elimination bracket) ─────────────────────
+
+interface ChampionsResult {
+  placements: Map<string, number>;  // participantId → placement (1–8)
+}
+
+/**
+ * Simulate the Champions Stage 8-team single-elimination bracket.
+ * Seeds are assigned by rank within the 8 advancing teams.
+ * Rounds: QF (Bo3), SF (Bo3), GF (Bo5).
+ * Exported for unit testing.
+ */
+export function simulateChampionsStage(teams: TeamWithElo[]): ChampionsResult {
+  if (teams.length !== 8) {
+    throw new Error(`simulateChampionsStage expects exactly 8 teams, got ${teams.length}`);
+  }
+
+  // Seed by rank ascending
+  const seeded = [...teams].sort((a, b) => a.rank - b.rank);
+  // Standard 8-team seeding: 1v8, 4v5, 3v6, 2v7
+  const bracket: [TeamWithElo, TeamWithElo][] = [
+    [seeded[0], seeded[7]],
+    [seeded[3], seeded[4]],
+    [seeded[2], seeded[5]],
+    [seeded[1], seeded[6]],
+  ];
+
+  const placements = new Map<string, number>();
+
+  const simMatch = (t1: TeamWithElo, t2: TeamWithElo, winsNeeded: number): TeamWithElo => {
+    const p = seriesWinProb(gameWinProb(t1.elo, t2.elo), winsNeeded);
+    return Math.random() < p ? t1 : t2;
+  };
+
+  // Quarterfinals (Bo3 = first to 2)
+  const sfTeams: TeamWithElo[] = [];
+  for (const [t1, t2] of bracket) {
+    const winner = simMatch(t1, t2, 2);
+    const loser = winner.id === t1.id ? t2 : t1;
+    sfTeams.push(winner);
+    placements.set(loser.id, 7);  // QF losers: 5th–8th (averaged to 6.5, use 7 for counting)
+  }
+  // Assign QF losers to placements 5–8
+  const qfLosers = [...placements.keys()];
+  qfLosers.forEach((id, i) => placements.set(id, 5 + i));
+
+  // Semifinals (Bo3 = first to 2)
+  const finalTeams: TeamWithElo[] = [];
+  const sfLosers: TeamWithElo[] = [];
+  for (let i = 0; i < sfTeams.length; i += 2) {
+    const winner = simMatch(sfTeams[i], sfTeams[i + 1], 2);
+    const loser = winner.id === sfTeams[i].id ? sfTeams[i + 1] : sfTeams[i];
+    finalTeams.push(winner);
+    sfLosers.push(loser);
+  }
+  sfLosers.forEach((t, i) => placements.set(t.id, 3 + i));
+
+  // Grand Final (Bo5 = first to 3)
+  const champion = simMatch(finalTeams[0], finalTeams[1], 3);
+  const finalist = champion.id === finalTeams[0].id ? finalTeams[1] : finalTeams[0];
+  placements.set(champion.id, 1);
+  placements.set(finalist.id, 2);
+
+  return { placements };
+}
+
+// ─── QP helpers ───────────────────────────────────────────────────────────────
+
+/**
+ * Calculate QP for Stage 3 exits based on their W-L record.
+ * Teams are ranked within 9–16 by wins (2-3 > 1-3 > 0-3).
+ * Within the same wins count, QP is tie-split (averaged) across placement slots.
+ *
+ * qpConfig: array indexed by placement (1-indexed), qpConfig[placement] = QP value.
+ *           Placements 9–16 correspond to indices 9–16.
+ */
+function calcStage3ExitQP(
+  elimTeams: Array<{ id: string; wins: number }>,
+  qpConfig: Map<number, number>
+): Map<string, number> {
+  // Group teams by wins count (0, 1, 2)
+  const byWins = new Map<number, string[]>();
+  for (const t of elimTeams) {
+    if (!byWins.has(t.wins)) byWins.set(t.wins, []);
+    byWins.get(t.wins)!.push(t.id);
+  }
+
+  // Assign placement slots 9–16 from highest wins first
+  const result = new Map<string, number>();
+  const winsGroups = [...byWins.entries()].sort((a, b) => b[0] - a[0]);  // descending wins
+
+  let slotStart = 9;
+  for (const [, ids] of winsGroups) {
+    const slots = Array.from({ length: ids.length }, (_, i) => slotStart + i);
+    const avgQP = slots.reduce((sum, s) => sum + (qpConfig.get(s) ?? 0), 0) / slots.length;
+    for (const id of ids) {
+      result.set(id, avgQP);
+    }
+    slotStart += ids.length;
+  }
+
+  return result;
+}
+
+// ─── Simulator ────────────────────────────────────────────────────────────────
+
+export class CSMajorSimulator implements Simulator {
+  async simulate(sportsSeasonId: string): Promise<SimulationResult[]> {
+    const db = database();
+
+    // 1. Load all participants for this sports season.
+    const allParticipants = await db
+      .select({ id: schema.participants.id })
+      .from(schema.participants)
+      .where(eq(schema.participants.sportsSeasonId, sportsSeasonId));
+
+    const participantIds = allParticipants.map((p) => p.id);
+
+    if (participantIds.length === 0) {
+      throw new Error(`No participants found for sports season ${sportsSeasonId}.`);
+    }
+
+    // 2. Load Elo ratings and world rankings from participantExpectedValues.
+    const evRows = await db
+      .select({
+        participantId: schema.participantExpectedValues.participantId,
+        sourceElo: schema.participantExpectedValues.sourceElo,
+        worldRanking: schema.participantExpectedValues.worldRanking,
+      })
+      .from(schema.participantExpectedValues)
+      .where(eq(schema.participantExpectedValues.sportsSeasonId, sportsSeasonId));
+
+    const eloMap = new Map<string, { elo: number; rank: number }>();
+    for (const row of evRows) {
+      if (row.sourceElo !== null) {
+        eloMap.set(row.participantId, {
+          elo: row.sourceElo,
+          rank: row.worldRanking ?? 9999,
+        });
+      }
+    }
+
+    // Build pool: all participants with Elo ratings, sorted by rank
+    const pool: TeamWithElo[] = participantIds
+      .filter((id) => eloMap.has(id))
+      .map((id) => {
+        const e = eloMap.get(id)!;
+        return { id, elo: e.elo, rank: e.rank };
+      })
+      .sort((a, b) => a.rank - b.rank);
+
+    if (pool.length === 0) {
+      throw new Error(
+        `No participants with Elo ratings found for sports season ${sportsSeasonId}. ` +
+        `Enter Elo ratings via the CS Elo admin page before simulating.`
+      );
+    }
+
+    // 3. Load QP config (placements 1–16 earn QP; 17+ earn 0).
+    const qpConfigArray = await getQPConfig(sportsSeasonId);
+    const qpConfig = new Map<number, number>(
+      qpConfigArray.map((c) => [c.placement, parseFloat(c.points)])
+    );
+
+    // 4. Load all CS major scoring events for this sports season.
+    const events = await db.query.scoringEvents.findMany({
+      where: and(
+        eq(schema.scoringEvents.sportsSeasonId, sportsSeasonId),
+        eq(schema.scoringEvents.eventType, "major_tournament")
+      ),
+      orderBy: (e, { asc }) => [asc(e.eventDate)],
+    });
+
+    if (events.length === 0) {
+      throw new Error(
+        `No major_tournament scoring events found for sports season ${sportsSeasonId}. ` +
+        `Create the CS Major scoring events first.`
+      );
+    }
+
+    // 5. For completed events, read actual QP from eventResults.
+    const completedEventIds = events.filter((e) => e.isComplete).map((e) => e.id);
+    const actualQPMap = new Map<string, number>(participantIds.map((id) => [id, 0]));
+
+    if (completedEventIds.length > 0) {
+      const actualResults = await db
+        .select({
+          participantId: schema.eventResults.participantId,
+          qualifyingPointsAwarded: schema.eventResults.qualifyingPointsAwarded,
+        })
+        .from(schema.eventResults)
+        .where(inArray(schema.eventResults.scoringEventId, completedEventIds));
+
+      for (const r of actualResults) {
+        if (r.qualifyingPointsAwarded !== null) {
+          const prev = actualQPMap.get(r.participantId) ?? 0;
+          actualQPMap.set(r.participantId, prev + parseFloat(r.qualifyingPointsAwarded));
+        }
+      }
+    }
+
+    // 6. Load stage results for each event (for explicit field composition).
+    const eventStageResults = new Map<string, Awaited<ReturnType<typeof getCs2StageResultsMapForEvent>>>();
+    for (const event of events) {
+      const stageResults = await getCs2StageResultsMapForEvent(event.id);
+      if (stageResults.size > 0) {
+        eventStageResults.set(event.id, stageResults);
+      }
+    }
+
+    const incompleteEvents = events.filter((e) => !e.isComplete);
+
+    // 7. Monte Carlo loop.
+    const counts: number[][] = Array.from({ length: participantIds.length }, () => Array(8).fill(0));
+    const idToIndex = new Map<string, number>(participantIds.map((id, i) => [id, i]));
+
+    for (let sim = 0; sim < NUM_SIMULATIONS; sim++) {
+      const simQP = new Map<string, number>(actualQPMap);
+
+      for (const event of incompleteEvents) {
+        const stageResultsForEvent = eventStageResults.get(event.id);
+        const eventQP = simulateOneMajor(pool, stageResultsForEvent, qpConfig);
+        for (const [pid, qp] of eventQP) {
+          simQP.set(pid, (simQP.get(pid) ?? 0) + qp);
+        }
+      }
+
+      // Rank all participants by total QP descending.
+      const ranked = [...simQP.entries()].sort((a, b) => b[1] - a[1]);
+      for (let rank = 0; rank < Math.min(8, ranked.length); rank++) {
+        const [pid] = ranked[rank];
+        const idx = idToIndex.get(pid);
+        if (idx !== undefined) counts[idx][rank]++;
+      }
+    }
+
+    // 8. Convert counts to probabilities.
+    return participantIds.map((participantId, i) => ({
+      participantId,
+      probabilities: {
+        probFirst:   counts[i][0] / NUM_SIMULATIONS,
+        probSecond:  counts[i][1] / NUM_SIMULATIONS,
+        probThird:   counts[i][2] / NUM_SIMULATIONS,
+        probFourth:  counts[i][3] / NUM_SIMULATIONS,
+        probFifth:   counts[i][4] / NUM_SIMULATIONS,
+        probSixth:   counts[i][5] / NUM_SIMULATIONS,
+        probSeventh: counts[i][6] / NUM_SIMULATIONS,
+        probEighth:  counts[i][7] / NUM_SIMULATIONS,
+      },
+      source: "cs2_major_qualifying_points_monte_carlo",
+    }));
+  }
+}
+
+// ─── Single major simulation ───────────────────────────────────────────────────
+
+/**
+ * Simulate one CS2 Major and return QP earned per participant.
+ * Uses explicit stage assignments if provided; otherwise infers from world ranking.
+ *
+ * Returns a Map from participantId → QP earned in this major.
+ */
+function simulateOneMajor(
+  pool: TeamWithElo[],
+  stageResults: Map<string, { stageEntry: number; stageEliminated: number | null; stageEliminatedWins: number | null }> | undefined,
+  qpConfig: Map<number, number>
+): Map<string, number> {
+  const qpMap = new Map<string, number>();
+
+  // Determine the 32-team field and stage assignments.
+  let stage1Teams: TeamWithElo[];
+  let stage2Direct: TeamWithElo[];
+  let stage3Direct: TeamWithElo[];
+
+  if (stageResults && stageResults.size > 0) {
+    // Use explicit stage assignments from the database.
+    const s1: TeamWithElo[] = [];
+    const s2: TeamWithElo[] = [];
+    const s3: TeamWithElo[] = [];
+
+    for (const [participantId, result] of stageResults) {
+      const team = pool.find((t) => t.id === participantId);
+      if (!team) continue;
+
+      // If result is already complete (stageEliminated is set), we can skip simulation
+      // for that team and use the known outcome. For simplicity in this iteration,
+      // we still simulate incomplete stages using Elo.
+      if (result.stageEntry === 1) s1.push(team);
+      else if (result.stageEntry === 2) s2.push(team);
+      else if (result.stageEntry === 3) s3.push(team);
+    }
+
+    stage1Teams = s1;
+    stage2Direct = s2;
+    stage3Direct = s3;
+  } else {
+    // Infer stage assignments from world ranking.
+    const field = sampleField(pool, FIELD_SIZE);
+    const sorted = [...field].sort((a, b) => a.rank - b.rank);
+
+    // Top 8 → Stage 3 (Legends), next 8 → Stage 2 (Challengers), bottom 16 → Stage 1
+    stage3Direct = sorted.slice(0, 8);
+    stage2Direct = sorted.slice(8, 16);
+    stage1Teams  = sorted.slice(16, 32);
+  }
+
+  // Stage 1: Swiss Bo1, 16 → 8 advance
+  const stage1Result = simulateSwiss(stage1Teams, false);
+
+  // Stage 2: Swiss Bo1/Bo3, 16 → 8 advance
+  // Use Bo1 for Stage 2 (matches are Bo1 early rounds, Bo3 for deciders;
+  // we simplify to Bo1 for Stage 2 and Bo3 for Stage 3)
+  const stage2Teams = [...stage2Direct, ...stage1Result.advanced];
+  const stage2Result = simulateSwiss(stage2Teams, false);
+
+  // Stage 3: Swiss all Bo3, 16 → 8 advance
+  const stage3Teams = [...stage3Direct, ...stage2Result.advanced];
+  const stage3Result = simulateSwiss(stage3Teams, true);
+
+  // Champions Stage: 8-team single elimination
+  const champResult = simulateChampionsStage(stage3Result.advanced);
+
+  // Assign QP from Champions Stage (placements 1–8)
+  for (const [pid, placement] of champResult.placements) {
+    qpMap.set(pid, qpConfig.get(placement) ?? 0);
+  }
+
+  // Assign QP for Stage 3 exits (placements 9–16), sub-ranked by wins
+  const stage3ExitQP = calcStage3ExitQP(stage3Result.eliminated, qpConfig);
+  for (const [pid, qp] of stage3ExitQP) {
+    qpMap.set(pid, qp);
+  }
+
+  // Stage 1 and 2 exits get 0 QP
+  for (const t of stage1Result.eliminated) qpMap.set(t.id, 0);
+  for (const t of stage2Result.eliminated) qpMap.set(t.id, 0);
+
+  return qpMap;
+}
diff --git a/app/services/simulations/registry.ts b/app/services/simulations/registry.ts
index 088d47b..eca9a44 100644
--- a/app/services/simulations/registry.ts
+++ b/app/services/simulations/registry.ts
@@ -19,6 +19,7 @@ import { AFLSimulator } from "./afl-simulator";
 import { SnookerSimulator } from "./snooker-simulator";
 import { TennisSimulator } from "./tennis-simulator";
 import { DartsSimulator } from "./darts-simulator";
+import { CSMajorSimulator } from "./cs-major-simulator";
 import { MLBSimulator } from "./mlb-simulator";
 import { WNBASimulator } from "./wnba-simulator";
 import { WorldCupSimulator } from "./world-cup-simulator";
@@ -40,6 +41,7 @@ export const SIMULATOR_TYPES = [
   "wnba_bracket",
   "world_cup",
   "darts_bracket",
+  "cs2_major_qualifying_points",
 ] as const;
 
 export type SimulatorType = typeof SIMULATOR_TYPES[number];
@@ -128,6 +130,10 @@ const REGISTRY: Record<SimulatorType, { info: SimulatorInfo; create: () => Simul
     info: { name: "PDC World Darts Championship Monte Carlo", description: "Simulates the 128-player World Darts Championship bracket using set-level Bernoulli win probability and Elo ratings. Top 32 seeds placed in fixed positions; remaining 96 players randomly drawn per simulation." },
     create: () => new DartsSimulator(),
   },
+  cs2_major_qualifying_points: {
+    info: { name: "CS2 Major Qualifying Points Monte Carlo", description: "Simulates 2 CS2 Majors per season (3 Swiss stages: Opening Bo1, Elimination Bo1, Decider Bo3, then Champions Stage single-elimination). Awards QP by final placement; ranks teams by total QP across both majors. Stage 3 exits (placements 9–16) are sub-ranked by W-L record." },
+    create: () => new CSMajorSimulator(),
+  },
 };
 
 export function getSimulator(simulatorType: SimulatorType): Simulator {
diff --git a/database/schema.ts b/database/schema.ts
index f522f26..c9bec68 100644
--- a/database/schema.ts
+++ b/database/schema.ts
@@ -99,6 +99,7 @@ export const simulatorTypeEnum = pgEnum("simulator_type", [
   "wnba_bracket",
   "world_cup",
   "darts_bracket",
+  "cs2_major_qualifying_points",
 ]);
 
 export const playoffMatchGameStatusEnum = pgEnum("playoff_match_game_status", [
@@ -859,6 +860,7 @@ export const scoringEventsRelations = relations(scoringEvents, ({ one, many }) =
   eventResults: many(eventResults),
   playoffMatches: many(playoffMatches),
   tournamentGroups: many(tournamentGroups),
+  cs2MajorStageResults: many(cs2MajorStageResults),
 }));
 
 export const eventResultsRelations = relations(eventResults, ({ one }) => ({
@@ -1196,3 +1198,43 @@ export const participantGolfSkillsRelations = relations(participantGolfSkills, (
     references: [sportsSeasons.id],
   }),
 }));
+
+// ─── CS2 Major Stage Results ───────────────────────────────────────────────────
+// Tracks which teams are assigned to each Swiss stage of a CS2 Major, and their
+// advancement/elimination results. One row per (scoringEventId, participantId).
+//
+// stageEntry:          1=Opening Stage, 2=Elimination Stage, 3=Decider Stage
+// stageEliminated:     which stage they were eliminated at (null = made Champions Stage)
+// stageEliminatedWins: wins at time of elimination (0, 1, or 2); used to rank teams
+//                      within placements 9–16 for Stage 3 QP (2-3 > 1-3 > 0-3)
+// finalPlacement:      overall placement 1–32 (set after event completes)
+
+export const cs2MajorStageResults = pgTable("cs2_major_stage_results", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  scoringEventId: uuid("scoring_event_id")
+    .notNull()
+    .references(() => scoringEvents.id, { onDelete: "cascade" }),
+  participantId: uuid("participant_id")
+    .notNull()
+    .references(() => participants.id, { onDelete: "cascade" }),
+  stageEntry: integer("stage_entry").notNull(),
+  stageEliminated: integer("stage_eliminated"),
+  stageEliminatedWins: integer("stage_eliminated_wins"),
+  finalPlacement: integer("final_placement"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (t) => ({
+  uniqueEventParticipant: uniqueIndex("cs2_major_stage_results_unique")
+    .on(t.scoringEventId, t.participantId),
+}));
+
+export const cs2MajorStageResultsRelations = relations(cs2MajorStageResults, ({ one }) => ({
+  scoringEvent: one(scoringEvents, {
+    fields: [cs2MajorStageResults.scoringEventId],
+    references: [scoringEvents.id],
+  }),
+  participant: one(participants, {
+    fields: [cs2MajorStageResults.participantId],
+    references: [participants.id],
+  }),
+}));
diff --git a/drizzle/0068_cs2_major_simulator.sql b/drizzle/0068_cs2_major_simulator.sql
new file mode 100644
index 0000000..3d1e8b9
--- /dev/null
+++ b/drizzle/0068_cs2_major_simulator.sql
@@ -0,0 +1,26 @@
+ALTER TYPE "public"."simulator_type" ADD VALUE 'cs2_major_qualifying_points';--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "cs2_major_stage_results" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"scoring_event_id" uuid NOT NULL,
+	"participant_id" uuid NOT NULL,
+	"stage_entry" integer NOT NULL,
+	"stage_eliminated" integer,
+	"stage_eliminated_wins" integer,
+	"final_placement" integer,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "cs2_major_stage_results" ADD CONSTRAINT "cs2_major_stage_results_scoring_event_id_scoring_events_id_fk" FOREIGN KEY ("scoring_event_id") REFERENCES "public"."scoring_events"("id") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "cs2_major_stage_results" ADD CONSTRAINT "cs2_major_stage_results_participant_id_participants_id_fk" FOREIGN KEY ("participant_id") REFERENCES "public"."participants"("id") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "cs2_major_stage_results_unique" ON "cs2_major_stage_results" USING btree ("scoring_event_id","participant_id");
diff --git a/drizzle/meta/_journal.json b/drizzle/meta/_journal.json
index b9ae77a..36b96fd 100644
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -477,6 +477,13 @@
       "when": 1774900000000,
       "tag": "0067_darts_bracket",
       "breakpoints": true
+    },
+    {
+      "idx": 68,
+      "version": "7",
+      "when": 1775000000000,
+      "tag": "0068_cs2_major_simulator",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file