Fix MLB simulator: projected wins drive seeding, perf fix, + surface simulate errors (#65)

## Summary

- **MLB simulator seeding now responds to projected wins**: replaced hardcoded FanGraphs `p_div`/`p_wc` probability draws with Binomial regular-season simulation. Admin-entered projected wins (via Elo) now drive both playoff _qualification_ odds and in-bracket game win probability, not just the latter.
- **Reads current standings mid-season**: `getRegularSeasonStandings` is called so synced `wins`/`gamesPlayed` feed into each simulation iteration's projected final standings.
- **27× seeding performance improvement**: `sampleBinomial` now uses a Box-Muller normal approximation for `n ≥ 30`, dropping the seeding phase from ~243M to ~3M `Math.random()` calls per 50K-sim run (pre-season, 162 remaining games × 30 teams).
- **Missing-standings warning**: when standings exist for some teams but not all recognized ones (partial sync), a `logger.warn` now surfaces which teams are falling back to 0 wins / 162 remaining instead of silently distorting seeding.
- **Cleanup**: `eloToRDif` calls `rawWinRateFromElo` instead of inlining the same formula.
- **Simulate errors surface inline**: moved simulation action from dedicated route to parent page `intent="simulate"` so errors display inline rather than crashing to an error page.

## Test plan

- [ ] `npm run test:run -- mlb-simulator` — 49 tests pass
- [ ] `npm run typecheck` — clean
- [ ] Trigger a simulation from the admin panel for an MLB season with projected wins entered; confirm teams with higher projected wins show meaningfully higher EVs
- [ ] Confirm that running simulate with no projected wins entered (pre-season defaults) still produces a valid bracket
- [ ] Check logs after simulating a season where some teams lack standings rows — confirm warning appears

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Chris Parsons <chrisparsons1127@gmail.com>
Reviewed-on: #65

app/services/simulations/__tests__/mlb-simulator.test.ts

@@ -3,8 +3,11 @@ import {
   normalizeTeamName,
   getTeamData,
   winRateFromRDif,
+  rawWinRateFromRDif,
+  rawWinRateFromElo,
   rdifWinProbability,
   eloToRDif,
+  sampleBinomial,
   simBo3,
   simBo5,
   simBo7,
@@ -104,36 +107,6 @@ describe("getTeamData", () => {
   });
 });
 
-// ─── Seeding probabilities sanity checks ─────────────────────────────────────
-
-describe("team seeding probabilities", () => {
-  const DIVISIONS = {
-    "AL East":    ["New York Yankees", "Baltimore Orioles", "Boston Red Sox", "Tampa Bay Rays", "Toronto Blue Jays"],
-    "AL Central": ["Kansas City Royals", "Cleveland Guardians", "Minnesota Twins", "Detroit Tigers", "Chicago White Sox"],
-    "AL West":    ["Houston Astros", "Seattle Mariners", "Texas Rangers", "Los Angeles Angels", "Athletics"],
-    "NL East":    ["Philadelphia Phillies", "Atlanta Braves", "New York Mets", "Washington Nationals", "Miami Marlins"],
-    "NL Central": ["Milwaukee Brewers", "Chicago Cubs", "St. Louis Cardinals", "Cincinnati Reds", "Pittsburgh Pirates"],
-    "NL West":    ["Los Angeles Dodgers", "San Diego Padres", "Arizona Diamondbacks", "San Francisco Giants", "Colorado Rockies"],
-  };
-
-  it("p_div values sum to ~1.0 within each division", () => {
-    for (const [divName, teams] of Object.entries(DIVISIONS)) {
-      const sum = teams.reduce((s, name) => s + (getTeamData(name)?.p_div ?? 0), 0);
-      expect(sum, `${divName} p_div sum should be ~1`).toBeCloseTo(1.0, 1);
-    }
-  });
-
-  it("Dodgers have the highest p_div in NL West", () => {
-    const dodgers = getTeamData("Los Angeles Dodgers")?.p_div ?? 0;
-    expect(dodgers).toBeGreaterThan(0.8);
-  });
-
-  it("rebuilding teams have very low p_div", () => {
-    expect(getTeamData("Chicago White Sox")?.p_div ?? 1).toBeLessThan(0.02);
-    expect(getTeamData("Colorado Rockies")?.p_div ?? 1).toBeLessThan(0.01);
-  });
-});
-
 // ─── winRateFromRDif ──────────────────────────────────────────────────────────
 
 describe("winRateFromRDif", () => {
@@ -160,6 +133,59 @@ describe("winRateFromRDif", () => {
   });
 });
 
+// ─── rawWinRateFromRDif ───────────────────────────────────────────────────────
+
+describe("rawWinRateFromRDif", () => {
+  it("returns 0.5 for RDif = 0", () => {
+    expect(rawWinRateFromRDif(0)).toBeCloseTo(0.5, 6);
+  });
+
+  it("is higher than winRateFromRDif for positive RDif (less compression)", () => {
+    const rdif = 137;
+    expect(rawWinRateFromRDif(rdif)).toBeGreaterThan(winRateFromRDif(rdif));
+  });
+
+  it("Dodgers (RDif +137) project to ~.585 season win rate", () => {
+    // 137 runs / 1620 ≈ 0.585
+    expect(rawWinRateFromRDif(137)).toBeCloseTo(0.585, 2);
+  });
+
+  it("clamps to [0.01, 0.99]", () => {
+    expect(rawWinRateFromRDif(10000)).toBe(0.99);
+    expect(rawWinRateFromRDif(-10000)).toBe(0.01);
+  });
+});
+
+// ─── rawWinRateFromElo ────────────────────────────────────────────────────────
+
+describe("rawWinRateFromElo", () => {
+  it("returns 0.5 for Elo 1500 (average)", () => {
+    expect(rawWinRateFromElo(1500)).toBeCloseTo(0.5, 6);
+  });
+
+  it("returns above 0.5 for Elo above 1500", () => {
+    expect(rawWinRateFromElo(1600)).toBeGreaterThan(0.5);
+  });
+
+  it("returns below 0.5 for Elo below 1500", () => {
+    expect(rawWinRateFromElo(1400)).toBeLessThan(0.5);
+  });
+
+  it("round-trips from projected wins: projectedWins → Elo → rawWinRate ≈ winRate", () => {
+    // 95 wins out of 162 → winRate ≈ 0.5864
+    const projectedWins = 95;
+    const totalGames = 162;
+    const winRate = projectedWins / totalGames;
+    // Build Elo from winRate the same way projectedWinsToElo does
+    const elo = 1500 - 400 * Math.log10((1 - winRate) / winRate);
+    expect(rawWinRateFromElo(elo)).toBeCloseTo(winRate, 4);
+  });
+
+  it("is symmetric around 1500", () => {
+    expect(rawWinRateFromElo(1600)).toBeCloseTo(1 - rawWinRateFromElo(1400), 6);
+  });
+});
+
 // ─── rdifWinProbability ───────────────────────────────────────────────────────
 
 describe("rdifWinProbability (log5)", () => {
@@ -191,10 +217,72 @@ describe("rdifWinProbability (log5)", () => {
   });
 });
 
+// ─── sampleBinomial ───────────────────────────────────────────────────────────
+
+describe("sampleBinomial", () => {
+  it("returns 0 when n = 0", () => {
+    expect(sampleBinomial(0, 0.5)).toBe(0);
+  });
+
+  it("returns 0 when p = 0 (exact path, n < 30)", () => {
+    expect(sampleBinomial(10, 0)).toBe(0);
+  });
+
+  it("returns n when p = 1 (exact path, n < 30)", () => {
+    expect(sampleBinomial(10, 1)).toBe(10);
+  });
+
+  it("returns 0 when p = 0 (normal-approx path, n >= 30)", () => {
+    // p <= 0 guard fires before normal approx
+    expect(sampleBinomial(162, 0)).toBe(0);
+  });
+
+  it("returns n when p = 1 (normal-approx path, n >= 30)", () => {
+    // p >= 1 guard fires before normal approx
+    expect(sampleBinomial(162, 1)).toBe(162);
+  });
+
+  it("result is always in [0, n] — exact path (n < 30)", () => {
+    for (let i = 0; i < 50; i++) {
+      const result = sampleBinomial(10, 0.5);
+      expect(result).toBeGreaterThanOrEqual(0);
+      expect(result).toBeLessThanOrEqual(10);
+    }
+  });
+
+  it("result is always in [0, n] — normal-approx path (n >= 30)", () => {
+    for (let i = 0; i < 50; i++) {
+      const result = sampleBinomial(162, 0.5);
+      expect(result).toBeGreaterThanOrEqual(0);
+      expect(result).toBeLessThanOrEqual(162);
+    }
+  });
+
+  it("mean is close to n*p over many samples — normal-approx path", () => {
+    const n = 162;
+    const p = 0.586;
+    const samples = Array.from({ length: 2000 }, () => sampleBinomial(n, p));
+    const mean = samples.reduce((s, x) => s + x, 0) / samples.length;
+    // Expected mean ≈ 94.9; allow ±3 (well within 3σ for 2000 samples)
+    expect(mean).toBeGreaterThan(n * p - 3);
+    expect(mean).toBeLessThan(n * p + 3);
+  });
+
+  it("mean is close to n*p over many samples — exact path", () => {
+    const n = 10;
+    const p = 0.6;
+    const samples = Array.from({ length: 2000 }, () => sampleBinomial(n, p));
+    const mean = samples.reduce((s, x) => s + x, 0) / samples.length;
+    // Expected mean = 6; allow ±0.5
+    expect(mean).toBeGreaterThan(n * p - 0.5);
+    expect(mean).toBeLessThan(n * p + 0.5);
+  });
+});
+
 // ─── Series simulators ────────────────────────────────────────────────────────
 
-const teamA = { id: "a", name: "Team A", data: undefined };
+const teamA = { id: "a", name: "Team A", data: undefined, currentWins: 0, remainingGames: 0 };
-const teamB = { id: "b", name: "Team B", data: undefined };
+const teamB = { id: "b", name: "Team B", data: undefined, currentWins: 0, remainingGames: 0 };
 const alwaysA  = () => 1.0; // team A always wins each game
 const alwaysB  = () => 0.0; // team B always wins each game
 const coinFlip = () => 0.5;

app/services/simulations/mlb-simulator.ts

@@ -6,35 +6,43 @@
  *
  * Algorithm:
  *   1. Load all participants for the sports season from DB
- *   2. Match participant names to hardcoded team data (RDif + league/division)
+ *   2. Load current standings (wins, gamesPlayed) from regularSeasonStandings
- *   3. For each simulation:
+ *   3. Load sourceElo ratings from seasonParticipantExpectedValues
- *      a. For each league (AL/NL), draw 1 division winner per division (3 draws),
+ *   4. Match participant names to hardcoded team data (RDif + league/division)
- *         then draw 3 wildcard teams from the remaining pool — all weighted by win rate.
+ *   5. For each simulation:
- *      b. Seed division winners 1–3 by RDif (best RDif = seed 1); WC teams 4–6 by RDif.
+ *      a. For each league (AL/NL), simulate remaining regular season games for
- *      c. Run the playoff bracket per league:
+ *         every team using Binomial sampling, giving final projected wins.
+ *      b. Division winner = best record in each division (3 per league).
+ *         Wild card = next 3 best records among non-division-winners per league.
+ *      c. Seed division winners 1–3 by final wins (best = seed 1);
+ *         WC teams 4–6 by final wins.
+ *      d. Run the playoff bracket per league:
  *         - Wildcard Round (best-of-3): 3 vs 6, 4 vs 5 (seeds 1 & 2 get byes)
  *         - Division Series (best-of-5): 1 vs lowest WC survivor, 2 vs other
  *         - League Championship Series (best-of-7)
- *      d. World Series (best-of-7): AL champ vs NL champ
+ *      e. World Series (best-of-7): AL champ vs NL champ
- *   4. Track placement counts per scoring tier
+ *   6. Track placement counts per scoring tier
- *   5. Convert counts to probability distributions
+ *   7. Convert counts to probability distributions
  *
  * Win probability (log5 formula):
- *   Step 1 — convert projected RDif to win rate:
+ *   Step 1 — convert projected RDif to win rate for playoff matchups:
  *     winRate = clamp(0.5 + rdif / RDIF_DIVISOR, 0.01, 0.99)
  *     RDIF_DIVISOR compresses team strengths toward .500 for playoff parity.
- *     See the RDIF_DIVISOR constant below for tuning guidance.
  *   Step 2 — Bill James log5 head-to-head probability:
  *     P(A beats B) = (wA - wA·wB) / (wA + wB - 2·wA·wB)
  *
+ * Regular season simulation (seeding):
+ *   Each team's raw per-game win rate is derived from sourceElo (if set) or
+ *   from the hardcoded RDif using SEEDING_RDIF_SCALE ≈ 10 runs/win × 162 games.
+ *   Remaining games = TOTAL_SEASON_GAMES − gamesPlayed are drawn from a
+ *   Binomial distribution.  This makes playoff seeding respond to both current
+ *   standings and user-entered projected wins.
+ *
  * Futures blending:
  *   If sourceOdds are stored in participantExpectedValues for this season,
- *   the per-game win probability is blended:
+ *   the per-game win probability for playoff series is blended:
  *     P(game) = RDIF_WEIGHT * rdifProb + ODDS_WEIGHT * oddsProb
- *   where oddsProb = normalizedOdds(A) / (normalizedOdds(A) + normalizedOdds(B)).
- *   Normalized odds are vig-removed futures win probabilities.
  *   RDIF_WEIGHT = 0.7, ODDS_WEIGHT = 0.3.
- *   Falls back to RDif-only when no odds are stored.
  *
  * Placement tiers → SimulationProbabilities mapping:
  *   probFirst              = World Series champion (1 per sim)
@@ -46,16 +54,12 @@
  *
  * Team data keys:
  *   rdif:  FanGraphs Depth Charts projected run differential for 2026.
- *          Used for per-game win probability via log5.
+ *          Used as fallback for seeding win rate and for playoff series win probability.
- *   p_div: Probability of winning own division (FanGraphs Depth Charts divTitle).
+ *   league/division: Static MLB structure — does not change season-to-season.
- *          Must sum to ~1.0 within each 5-team division.
- *   p_wc:  Probability of claiming one of 3 wildcard slots (FanGraphs Depth Charts wcTitle).
- *          Used as relative weights among non-division-winners in each league.
  *
  * Sources:
- *   rdif:       https://www.fangraphs.com/standings/projected-standings
+ *   rdif: https://www.fangraphs.com/standings/projected-standings
- *   p_div/p_wc: https://www.fangraphs.com/standings/playoff-odds/dc/div
+ * Update rdif at the start of each season.
- * Update at the start of each season.
  *
  * Divisions:
  *   AL East:    Yankees, Orioles, Red Sox, Rays, Blue Jays
@@ -75,29 +79,30 @@ import {
   convertAmericanOddsToProbability,
   normalizeProbabilities,
 } from "~/services/probability-engine";
+import { getRegularSeasonStandings } from "~/models/regular-season-standings";
 
 // ─── Simulation parameters ────────────────────────────────────────────────────
 
 const NUM_SIMULATIONS = 50_000;
+const TOTAL_SEASON_GAMES = 162;
 
 /**
- * Controls how much projected run differential spreads teams away from .500.
+ * Controls how much projected run differential spreads teams away from .500
- *
+ * for single-game playoff matchups.
- * Baseline: 1620 (≈ 10 runs per win × 162 games). This gives the raw
- * Pythagorean-derived win rate, which tends to overstate dominance in
- * playoff matchups where you face elite pitching. Increasing this constant
- * compresses all team strengths toward .500 — reducing every strong team's
- * win probability in each series and yielding more upset potential across
- * the entire bracket. Decrease to amplify differences.
  *
  * Effect on Dodgers (RDif +137):
- *   1620 → win rate 0.585 (raw Pythagorean projection — too dominant)
+ *   1620 → win rate 0.585 (raw Pythagorean — too dominant for playoff matchups)
- *   2000 → win rate 0.568
- *   4000 → win rate 0.534
  *   8000 → win rate 0.517 (current — near coin-flip vs any playoff team)
  */
 const RDIF_DIVISOR = 8000;
 
+/**
+ * Scale for converting RDif to a raw per-game win rate for regular-season
+ * seeding simulation.  Unlike RDIF_DIVISOR (which compresses for playoff
+ * parity), this uses ~10 runs/win × 162 games to give realistic season win%.
+ */
+const SEEDING_RDIF_SCALE = 1620;
+
 /**
  * Blend weights for RDif vs. Vegas futures odds when sourceOdds are available.
  */
@@ -109,58 +114,58 @@ const ODDS_WEIGHT = 1 - RDIF_WEIGHT;
 // rdif: Projected run differential from FanGraphs Depth Charts.
 //       Source: https://www.fangraphs.com/standings/projected-standings
 //
-// Update all three values at the start of each season from the FanGraphs pages above.
+// league/division: Static MLB structure — update only if teams change leagues.
+//
+// Update rdif at the start of each season.
 
 interface MlbTeamData {
   league: "AL" | "NL";
   division: "AL East" | "AL Central" | "AL West" | "NL East" | "NL Central" | "NL West";
   rdif: number;  // 2026 FanGraphs Depth Charts projected run differential
-  p_div: number; // 2026 FanGraphs Depth Charts divTitle — probability of winning own division
-  p_wc: number;  // 2026 FanGraphs Depth Charts wcTitle — probability of claiming a wild card slot
 }
 
 const TEAMS_DATA: Record<string, MlbTeamData> = {
   // ── American League East ───────────────────────────────────────────────────
-  "New York Yankees":   { league: "AL", division: "AL East",    rdif:  67, p_div: 0.374, p_wc: 0.358 },
+  "New York Yankees":   { league: "AL", division: "AL East",    rdif:  67 },
-  "Baltimore Orioles":  { league: "AL", division: "AL East",    rdif:  23, p_div: 0.128, p_wc: 0.310 },
+  "Baltimore Orioles":  { league: "AL", division: "AL East",    rdif:  23 },
-  "Boston Red Sox":     { league: "AL", division: "AL East",    rdif:  48, p_div: 0.247, p_wc: 0.373 },
+  "Boston Red Sox":     { league: "AL", division: "AL East",    rdif:  48 },
-  "Tampa Bay Rays":     { league: "AL", division: "AL East",    rdif:   2, p_div: 0.066, p_wc: 0.229 },
+  "Tampa Bay Rays":     { league: "AL", division: "AL East",    rdif:   2 },
-  "Toronto Blue Jays":  { league: "AL", division: "AL East",    rdif:  37, p_div: 0.184, p_wc: 0.349 },
+  "Toronto Blue Jays":  { league: "AL", division: "AL East",    rdif:  37 },
 
   // ── American League Central ────────────────────────────────────────────────
-  "Kansas City Royals":    { league: "AL", division: "AL Central", rdif:   8, p_div: 0.297, p_wc: 0.157 },
+  "Kansas City Royals":    { league: "AL", division: "AL Central", rdif:   8 },
-  "Cleveland Guardians":   { league: "AL", division: "AL Central", rdif: -38, p_div: 0.084, p_wc: 0.075 },
+  "Cleveland Guardians":   { league: "AL", division: "AL Central", rdif: -38 },
-  "Minnesota Twins":       { league: "AL", division: "AL Central", rdif: -15, p_div: 0.166, p_wc: 0.120 },
+  "Minnesota Twins":       { league: "AL", division: "AL Central", rdif: -15 },
-  "Detroit Tigers":        { league: "AL", division: "AL Central", rdif:  26, p_div: 0.449, p_wc: 0.155 },
+  "Detroit Tigers":        { league: "AL", division: "AL Central", rdif:  26 },
-  "Chicago White Sox":     { league: "AL", division: "AL Central", rdif: -112, p_div: 0.005, p_wc: 0.004 },
+  "Chicago White Sox":     { league: "AL", division: "AL Central", rdif: -112 },
 
   // ── American League West ───────────────────────────────────────────────────
-  "Houston Astros":      { league: "AL", division: "AL West",    rdif:  -1, p_div: 0.126, p_wc: 0.213 },
+  "Houston Astros":      { league: "AL", division: "AL West",    rdif:  -1 },
-  "Seattle Mariners":    { league: "AL", division: "AL West",    rdif:  66, p_div: 0.595, p_wc: 0.205 },
+  "Seattle Mariners":    { league: "AL", division: "AL West",    rdif:  66 },
-  "Texas Rangers":       { league: "AL", division: "AL West",    rdif:  20, p_div: 0.201, p_wc: 0.270 },
+  "Texas Rangers":       { league: "AL", division: "AL West",    rdif:  20 },
-  "Los Angeles Angels":  { league: "AL", division: "AL West",    rdif: -65, p_div: 0.011, p_wc: 0.035 },
+  "Los Angeles Angels":  { league: "AL", division: "AL West",    rdif: -65 },
-  "Athletics":           { league: "AL", division: "AL West",    rdif: -17, p_div: 0.068, p_wc: 0.146 },
+  "Athletics":           { league: "AL", division: "AL West",    rdif: -17 },
 
   // ── National League East ───────────────────────────────────────────────────
-  "Philadelphia Phillies": { league: "NL", division: "NL East",    rdif:  51, p_div: 0.243, p_wc: 0.444 },
+  "Philadelphia Phillies": { league: "NL", division: "NL East",    rdif:  51 },
-  "Atlanta Braves":        { league: "NL", division: "NL East",    rdif:  67, p_div: 0.357, p_wc: 0.425 },
+  "Atlanta Braves":        { league: "NL", division: "NL East",    rdif:  67 },
-  "New York Mets":         { league: "NL", division: "NL East",    rdif:  71, p_div: 0.389, p_wc: 0.413 },
+  "New York Mets":         { league: "NL", division: "NL East",    rdif:  71 },
-  "Washington Nationals":  { league: "NL", division: "NL East",    rdif: -113, p_div: 0.001, p_wc: 0.006 },
+  "Washington Nationals":  { league: "NL", division: "NL East",    rdif: -113 },
-  "Miami Marlins":         { league: "NL", division: "NL East",    rdif: -48, p_div: 0.011, p_wc: 0.075 },
+  "Miami Marlins":         { league: "NL", division: "NL East",    rdif: -48 },
 
   // ── National League Central ────────────────────────────────────────────────
-  "Milwaukee Brewers":   { league: "NL", division: "NL Central", rdif:   9, p_div: 0.243, p_wc: 0.170 },
+  "Milwaukee Brewers":   { league: "NL", division: "NL Central", rdif:   9 },
-  "Chicago Cubs":        { league: "NL", division: "NL Central", rdif:  23, p_div: 0.347, p_wc: 0.183 },
+  "Chicago Cubs":        { league: "NL", division: "NL Central", rdif:  23 },
-  "St. Louis Cardinals": { league: "NL", division: "NL Central", rdif: -55, p_div: 0.038, p_wc: 0.049 },
+  "St. Louis Cardinals": { league: "NL", division: "NL Central", rdif: -55 },
-  "Cincinnati Reds":     { league: "NL", division: "NL Central", rdif: -31, p_div: 0.086, p_wc: 0.095 },
+  "Cincinnati Reds":     { league: "NL", division: "NL Central", rdif: -31 },
-  "Pittsburgh Pirates":  { league: "NL", division: "NL Central", rdif:  13, p_div: 0.285, p_wc: 0.178 },
+  "Pittsburgh Pirates":  { league: "NL", division: "NL Central", rdif:  13 },
 
   // ── National League West ───────────────────────────────────────────────────
-  "Los Angeles Dodgers":    { league: "NL", division: "NL West",    rdif: 137, p_div: 0.900, p_wc: 0.082 },
+  "Los Angeles Dodgers":    { league: "NL", division: "NL West",    rdif: 137 },
-  "San Diego Padres":       { league: "NL", division: "NL West",    rdif:  -9, p_div: 0.023, p_wc: 0.240 },
+  "San Diego Padres":       { league: "NL", division: "NL West",    rdif:  -9 },
-  "Arizona Diamondbacks":   { league: "NL", division: "NL West",    rdif:   5, p_div: 0.039, p_wc: 0.322 },
+  "Arizona Diamondbacks":   { league: "NL", division: "NL West",    rdif:   5 },
-  "San Francisco Giants":   { league: "NL", division: "NL West",    rdif:   3, p_div: 0.038, p_wc: 0.317 },
+  "San Francisco Giants":   { league: "NL", division: "NL West",    rdif:   3 },
-  "Colorado Rockies":       { league: "NL", division: "NL West",    rdif: -173, p_div: 0.001, p_wc: 0.001 },
+  "Colorado Rockies":       { league: "NL", division: "NL West",    rdif: -173 },
 };
 
 // ─── Public helpers (exported for unit testing) ───────────────────────────────
@@ -180,7 +185,7 @@ export function getTeamData(name: string): MlbTeamData | undefined {
 }
 
 /**
- * Convert projected run differential to a compressed win rate for matchup probability.
+ * Convert projected run differential to a compressed win rate for playoff matchup probability.
  * Uses RDIF_DIVISOR to control how much team strength spreads away from .500.
  * Clamped to [0.01, 0.99] to avoid degenerate log5 values.
  * Exported for unit testing.
@@ -189,6 +194,26 @@ export function winRateFromRDif(rdif: number): number {
   return Math.min(0.99, Math.max(0.01, 0.5 + rdif / RDIF_DIVISOR));
 }
 
+/**
+ * Convert projected run differential to a raw per-game win rate for regular-season
+ * seeding simulation.  Uses SEEDING_RDIF_SCALE (~10 runs/win × 162 games) which
+ * gives a realistic season win percentage rather than the playoff-compressed value.
+ * Exported for unit testing.
+ */
+export function rawWinRateFromRDif(rdif: number): number {
+  return Math.min(0.99, Math.max(0.01, 0.5 + rdif / SEEDING_RDIF_SCALE));
+}
+
+/**
+ * Derive a raw per-game win rate directly from an Elo rating.
+ * This is the inverse Elo formula, returning the same win probability
+ * that was originally used to compute the Elo from projected wins.
+ * Exported for unit testing.
+ */
+export function rawWinRateFromElo(elo: number): number {
+  return 1 / (1 + Math.pow(10, (1500 - elo) / 400));
+}
+
 /**
  * Convert an Elo rating to an equivalent projected run differential.
  * Uses the standard Elo win probability formula (parity factor 400, average Elo 1500),
@@ -196,8 +221,7 @@ export function winRateFromRDif(rdif: number): number {
  * Exported for unit testing.
  */
 export function eloToRDif(elo: number): number {
-  const winRate = 1 / (1 + Math.pow(10, (1500 - elo) / 400));
+  return (rawWinRateFromElo(elo) - 0.5) * RDIF_DIVISOR;
-  return (winRate - 0.5) * RDIF_DIVISOR;
 }
 
 /**
@@ -213,6 +237,39 @@ export function rdifWinProbability(rdifA: number, rdifB: number): number {
   return (wA - wA * wB) / (wA + wB - 2 * wA * wB);
 }
 
+/**
+ * Sample the number of wins from n independent Bernoulli trials each with
+ * probability p.  Used to project remaining regular-season wins per team.
+ *
+ * For n ≥ 30 (where CLT applies well: n·p ≥ 5 and n·(1-p) ≥ 5 for any
+ * realistic win rate), uses a Box-Muller normal approximation — 2 Math.random()
+ * calls per team instead of n, cutting the seeding phase from ~243M to ~3M
+ * Math.random() calls per 50K-simulation run.  For small n the exact Bernoulli
+ * loop is used.  Both paths produce integer output clamped to [0, n].
+ * Exported for unit testing.
+ */
+export function sampleBinomial(n: number, p: number): number {
+  if (n <= 0) return 0;
+  if (p <= 0) return 0;
+  if (p >= 1) return n;
+
+  if (n >= 30) {
+    // Normal approximation via Box-Muller transform.
+    // Guard u1 > 0 to avoid log(0) = -Infinity.
+    const u1 = Math.max(Number.EPSILON, Math.random());
+    const u2 = Math.random();
+    const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+    return Math.round(Math.min(n, Math.max(0, n * p + Math.sqrt(n * p * (1 - p)) * z)));
+  }
+
+  // Exact Bernoulli trials for small n.
+  let wins = 0;
+  for (let i = 0; i < n; i++) {
+    if (Math.random() < p) wins++;
+  }
+  return wins;
+}
+
 // ─── Internal types ───────────────────────────────────────────────────────────
 
 interface TeamEntry {
@@ -220,6 +277,8 @@ interface TeamEntry {
   name: string;
   data: MlbTeamData | undefined;
   originalSeed?: number;
+  currentWins: number;    // from regularSeasonStandings (0 pre-season)
+  remainingGames: number; // TOTAL_SEASON_GAMES - gamesPlayed
 }
 
 /** Get projected RDif for a team entry. Fallback 0 (league-average) for unknown teams. */
@@ -227,30 +286,6 @@ function getEntryRDif(entry: TeamEntry): number {
   return entry.data?.rdif ?? 0;
 }
 
-/**
- * Weighted pick without replacement using the given weight function.
- * Returns undefined if no eligible team has positive weight.
- */
-function weightedPickByKey(
-  pool: TeamEntry[],
-  excluded: Set<TeamEntry>,
-  getWeight: (t: TeamEntry) => number
-): TeamEntry | undefined {
-  const eligible = pool.filter((t) => !excluded.has(t));
-  if (eligible.length === 0) return undefined;
-
-  const weights = eligible.map(getWeight);
-  const total = weights.reduce((s, w) => s + w, 0);
-  if (total === 0) return undefined;
-
-  let r = Math.random() * total;
-  for (let i = 0; i < eligible.length; i++) {
-    r -= weights[i];
-    if (r <= 0) return eligible[i];
-  }
-  return eligible[eligible.length - 1];
-}
-
 // ─── Series simulators ─────────────────────────────────────────────────────────
 
 type SeriesResult = { winner: TeamEntry; loser: TeamEntry };
@@ -301,21 +336,23 @@ export function simBo7(
 // ─── League bracket builder ───────────────────────────────────────────────────
 
 /**
- * Draws the 6-team playoff field for one league (AL or NL).
+ * Draws the 6-team playoff field for one league (AL or NL) by simulating the
+ * remaining regular season for each team.
  *
  * Steps:
- *   1. For each of the 3 divisions, draw 1 division winner weighted by p_div.
+ *   1. For each team, sample remaining wins from Binomial(remainingGames, seedingWinRate).
- *   2. From the remaining non-division-winners, draw 3 WC teams weighted by p_wc.
+ *      A tiny uniform noise [0, 0.001) is added to break integer ties randomly.
- *   3. Rank division winners 1–3 by RDif descending (best RDif → seed 1).
+ *   2. Division winner = team with highest final wins in each division (3 per league).
- *   4. Rank WC teams 4–6 by RDif descending (best RDif → seed 4).
+ *   3. Wild card = next 3 highest final wins among non-division-winners.
+ *   4. Seed division winners 1–3 by final wins descending (best = seed 1).
+ *   5. Seed WC teams 4–6 by final wins descending.
  *
  * Returns an array of 6 TeamEntry objects in seed order [1..6], each annotated
- * with originalSeed, or undefined if any draw is degenerate (no eligible team
+ * with originalSeed, or undefined if the league has fewer than 3 eligible WC teams.
- * with positive weight).
  */
 function drawLeaguePlayoffField(
   leagueTeams: TeamEntry[],
-  getRDif: (t: TeamEntry) => number = getEntryRDif
+  getSeedingWinRate: (t: TeamEntry) => number
 ): TeamEntry[] | undefined {
   // Group by division
   const divMap = new Map<string, TeamEntry[]>();
@@ -325,33 +362,42 @@ function drawLeaguePlayoffField(
     divMap.get(div)?.push(t);
   }
 
+  // Simulate remaining games for each team; tiny noise breaks integer win ties
+  const finalWins = new Map<string, number>();
+  for (const t of leagueTeams) {
+    finalWins.set(
+      t.id,
+      t.currentWins + sampleBinomial(t.remainingGames, getSeedingWinRate(t)) + Math.random() * 0.001
+    );
+  }
+
+  // Division winners: best record per division
   const divisionWinners: TeamEntry[] = [];
-  const allDivisionWinnerSet = new Set<TeamEntry>();
+  const divWinnerSet = new Set<TeamEntry>();
 
   for (const divTeams of divMap.values()) {
-    const winner = weightedPickByKey(divTeams, new Set(), (t) => t.data?.p_div ?? 0);
+    const winner = divTeams.reduce((best, t) =>
-    if (!winner) return undefined;
+      (finalWins.get(t.id) ?? 0) > (finalWins.get(best.id) ?? 0) ? t : best
+    );
     divisionWinners.push(winner);
-    allDivisionWinnerSet.add(winner);
+    divWinnerSet.add(winner);
   }
 
-  // Draw 3 WC teams from non-division-winners, weighted by p_wc
+  // Wild card: top 3 non-division-winners by final wins
-  const wcPool = leagueTeams.filter((t) => !allDivisionWinnerSet.has(t));
+  const wcTeams = leagueTeams
-  const wcTaken = new Set<TeamEntry>();
+    .filter((t) => !divWinnerSet.has(t))
-  const wcTeams: TeamEntry[] = [];
+    .toSorted((a, b) => (finalWins.get(b.id) ?? 0) - (finalWins.get(a.id) ?? 0))
+    .slice(0, 3);
 
-  for (let i = 0; i < 3; i++) {
+  if (wcTeams.length < 3) return undefined;
-    const wc = weightedPickByKey(wcPool, wcTaken, (t) => t.data?.p_wc ?? 0);
-    if (!wc) return undefined;
-    wcTeams.push(wc);
-    wcTaken.add(wc);
-  }
 
-  // Rank division winners 1–3 by RDif descending (best RDif = seed 1)
+  // Seed: div winners 1–3 and WC teams 4–6, both by final wins descending
-  const sortedDivWinners = divisionWinners.toSorted((a, b) => getRDif(b) - getRDif(a));
+  const sortedDivWinners = divisionWinners.toSorted(
-
+    (a, b) => (finalWins.get(b.id) ?? 0) - (finalWins.get(a.id) ?? 0)
-  // Rank WC teams 4–6 by RDif descending (best RDif = seed 4)
+  );
-  const sortedWcTeams = wcTeams.toSorted((a, b) => getRDif(b) - getRDif(a));
+  const sortedWcTeams = wcTeams.toSorted(
+    (a, b) => (finalWins.get(b.id) ?? 0) - (finalWins.get(a.id) ?? 0)
+  );
 
   const seeds = [...sortedDivWinners, ...sortedWcTeams];
   return seeds.map((t, i) => ({ ...t, originalSeed: i + 1 }));
@@ -421,12 +467,23 @@ export class MLBSimulator implements Simulator {
     }
 
     const participantIds = participantRows.map((r) => r.id);
+    const participantIdSet = new Set(participantIds);
 
-    const teams: TeamEntry[] = participantRows.map((r) => ({
+    // 2. Load current standings (wins + games played) to seed the regular-season simulation.
-      id: r.id,
+    const standings = await getRegularSeasonStandings(sportsSeasonId);
-      name: r.name,
+    const standingsByParticipantId = new Map(standings.map((s) => [s.participantId, s]));
-      data: getTeamData(r.name),
+
-    }));
+    const teams: TeamEntry[] = participantRows.map((r) => {
+      const standing = standingsByParticipantId.get(r.id);
+      const gamesPlayed = standing?.gamesPlayed ?? 0;
+      return {
+        id: r.id,
+        name: r.name,
+        data: getTeamData(r.name),
+        currentWins: standing?.wins ?? 0,
+        remainingGames: Math.max(0, TOTAL_SEASON_GAMES - gamesPlayed),
+      };
+    });
 
     // Warn about participants that don't match any hardcoded team.
     const unrecognized = teams.filter((t) => !t.data);
@@ -437,6 +494,22 @@ export class MLBSimulator implements Simulator {
       );
     }
 
+    // Warn when standings exist for some teams but not all recognized ones — this
+    // usually means a partial sync.  Missing teams fall back to 0 wins / 162
+    // remaining games (league-average strength), which distorts mid-season seeding.
+    if (standings.length > 0) {
+      const missingStandings = teams.filter(
+        (t) => t.data && !standingsByParticipantId.has(t.id)
+      );
+      if (missingStandings.length > 0) {
+        logger.warn(
+          `[MLBSimulator] ${missingStandings.length} recognized team(s) have no standings row — ` +
+            `seeding will use 0 wins / 162 remaining games for: ` +
+            missingStandings.map((t) => t.name).join(", ")
+        );
+      }
+    }
+
     const alTeams = teams.filter((t) => t.data?.league === "AL");
     const nlTeams = teams.filter((t) => t.data?.league === "NL");
 
@@ -459,7 +532,6 @@ export class MLBSimulator implements Simulator {
       .from(schema.seasonParticipantExpectedValues)
       .where(eq(schema.seasonParticipantExpectedValues.sportsSeasonId, sportsSeasonId));
 
-    const participantIdSet = new Set(participantIds);
     const oddsRows = evRows.filter(
       (r) => r.sourceOdds !== null && participantIdSet.has(r.participantId)
     );
@@ -476,22 +548,34 @@ export class MLBSimulator implements Simulator {
       });
     }
 
-    // Build a map of sourceElo-derived RDif values (overrides hardcoded TEAMS_DATA.rdif).
+    // Build a map of sourceElo-derived RDif values (overrides hardcoded TEAMS_DATA.rdif)
+    // for playoff series win probability.
     const sourceEloRDifMap = new Map<string, number>();
+    // Build a map of raw (uncompressed) win rates from sourceElo for regular-season seeding.
+    const rawWinRateMap = new Map<string, number>();
     for (const r of evRows) {
       if (r.sourceElo !== null && r.sourceElo !== undefined && participantIdSet.has(r.participantId)) {
         sourceEloRDifMap.set(r.participantId, eloToRDif(r.sourceElo));
+        rawWinRateMap.set(r.participantId, rawWinRateFromElo(r.sourceElo));
       }
     }
 
     // ─── Helpers ──────────────────────────────────────────────────────────────
 
-    /** Effective RDif: prefer sourceElo-derived value over hardcoded TEAMS_DATA.rdif. */
+    /** Effective RDif for playoff series: prefer sourceElo-derived value over hardcoded rdif. */
     const effectiveRDif = (entry: TeamEntry): number =>
       sourceEloRDifMap.get(entry.id) ?? getEntryRDif(entry);
 
     /**
-     * Blended per-game win probability for team A over team B.
+     * Raw per-game win rate for regular-season seeding simulation.
+     * Uses sourceElo-derived rate if available; falls back to hardcoded rdif
+     * with SEEDING_RDIF_SCALE (Pythagorean approximation).
+     */
+    const seedingWinRate = (entry: TeamEntry): number =>
+      rawWinRateMap.get(entry.id) ?? rawWinRateFromRDif(getEntryRDif(entry));
+
+    /**
+     * Blended per-game win probability for team A over team B in a playoff series.
      * When odds are available: 70% RDif log5 + 30% vig-removed futures head-to-head.
      */
     const gameWinProb = (a: TeamEntry, b: TeamEntry): number => {
@@ -519,8 +603,8 @@ export class MLBSimulator implements Simulator {
     let effectiveN = 0;
 
     for (let s = 0; s < NUM_SIMULATIONS; s++) {
-      const alField = drawLeaguePlayoffField(alTeams, effectiveRDif);
+      const alField = drawLeaguePlayoffField(alTeams, seedingWinRate);
-      const nlField = drawLeaguePlayoffField(nlTeams, effectiveRDif);
+      const nlField = drawLeaguePlayoffField(nlTeams, seedingWinRate);
       if (!alField || !nlField) continue; // degenerate draw — skip
 
       effectiveN++;