app/models/__tests__/futures-odds-simulator.test.ts

@@ -6,7 +6,7 @@ vi.mock("~/database/context", () => ({
 }));
 
 import { database } from "~/database/context";
-import { batchSaveFuturesOddsForSimulator } from "../simulator";
+import { batchUpsertParticipantSimulatorInputs } from "../simulator";
 
 type SetPayload = Record<string, unknown>;
 
@@ -17,36 +17,71 @@ const onConflictDoUpdate = vi.fn((arg: { set: SetPayload }) => {
   return Promise.resolve(undefined);
 });
 
-const mockDb = {
+const tx = {
   insert: vi.fn(() => ({
     values: vi.fn(() => ({ onConflictDoUpdate })),
   })),
 };
 
+const mockDb = {
+  transaction: vi.fn((cb: (t: typeof tx) => Promise<unknown>) => cb(tx)),
+};
+
 beforeEach(() => {
   vi.clearAllMocks();
   conflictSetCalls.length = 0;
   (database as ReturnType<typeof vi.fn>).mockReturnValue(mockDb);
 });
 
-describe("batchSaveFuturesOddsForSimulator", () => {
+// Recursively flatten a Drizzle `sql` template into its static text so we can
-  it("persists odds without destroying a stored Elo/rating", async () => {
+// assert how a conflict-update column is built (e.g. wrapped in COALESCE).
-    await batchSaveFuturesOddsForSimulator([
+function sqlToText(value: unknown): string {
+  if (value === null || value === undefined) return "";
+  const chunks = (value as { queryChunks?: unknown[] }).queryChunks;
+  if (Array.isArray(chunks)) return chunks.map(sqlToText).join("");
+  const stringValue = (value as { value?: unknown }).value;
+  if (Array.isArray(stringValue)) return stringValue.join("");
+  if (typeof stringValue === "string") return stringValue;
+  return "";
+}
+
+describe("batchUpsertParticipantSimulatorInputs", () => {
+  it("updates only the columns it is given, preserving the rest (non-destructive)", async () => {
+    await batchUpsertParticipantSimulatorInputs([
+      // Odds-only import (e.g. from the bulk futures paste): no Elo/rating supplied.
       { participantId: "team-1", sportsSeasonId: "season-1", sourceOdds: 550 },
     ]);
 
-    // The upsert writes the odds and leaves Elo/rating untouched — whether the
+    // Runs in a transaction, writing the simulator-inputs row first then the
-    // odds override them is now decided by the configurable source priority,
+    // legacy EV bridge row.
-    // not by nulling stored values here.
+    expect(mockDb.transaction).toHaveBeenCalledTimes(1);
-    expect(mockDb.insert).toHaveBeenCalledTimes(1);
+    expect(conflictSetCalls.length).toBeGreaterThanOrEqual(1);
-    expect(conflictSetCalls).toHaveLength(1);
+
-    expect(conflictSetCalls[0]).toHaveProperty("sourceOdds");
+    const simulatorSet = conflictSetCalls[0];
-    expect(conflictSetCalls[0]).not.toHaveProperty("sourceElo");
+    // Every input column participates in the conflict update so partial pastes
-    expect(conflictSetCalls[0]).not.toHaveProperty("rating");
+    // can target any field...
+    for (const column of ["sourceOdds", "sourceElo", "worldRanking", "rating", "seed", "region"]) {
+      expect(simulatorSet).toHaveProperty(column);
+    }
+    // ...but each is COALESCE-wrapped, so a null incoming value keeps the stored
+    // one instead of clobbering it. A bare `excluded.*` here would be the bug.
+    const sourceEloSql = sqlToText(simulatorSet.sourceElo).toLowerCase();
+    expect(sourceEloSql).toContain("coalesce");
+    const ratingSql = sqlToText(simulatorSet.rating).toLowerCase();
+    expect(ratingSql).toContain("coalesce");
+
+    // Metadata must drop the per-column method flag whenever that column gets a
+    // fresh direct value, so a stale "generated" flag can't hide a newly entered
+    // Elo/rating. Blindly preserving metadata (e.g. COALESCE) would be the bug.
+    const metadataSql = sqlToText(simulatorSet.metadata).toLowerCase();
+    expect(metadataSql).toContain("sourceelomethod");
+    expect(metadataSql).toContain("ratingmethod");
+    expect(metadataSql).toContain("excluded.source_elo");
+    expect(metadataSql).toContain("excluded.rating");
   });
 
   it("is a no-op when given no inputs", async () => {
-    await batchSaveFuturesOddsForSimulator([]);
+    await batchUpsertParticipantSimulatorInputs([]);
-    expect(mockDb.insert).not.toHaveBeenCalled();
+    expect(mockDb.transaction).not.toHaveBeenCalled();
   });
 });

app/models/participant-expected-value.ts

@@ -6,11 +6,11 @@
  */
 
 import { database } from "~/database/context";
-import { seasonParticipantExpectedValues, seasonParticipants, seasonParticipantSimulatorInputs } from "~/database/schema";
+import { seasonParticipantExpectedValues, seasonParticipants } from "~/database/schema";
-import { eq, and, count, inArray, sql } from "drizzle-orm";
+import { eq, and, count, sql } from "drizzle-orm";
 import type { ProbabilityDistribution, ScoringRules } from "~/services/ev-calculator";
 import { calculateEV, normalizeProbabilities, calculateReplacementLevel, calculateVORP } from "~/services/ev-calculator";
-import { batchSaveParticipantSimulatorSourceOdds, batchUpsertParticipantSimulatorInputs } from "~/models/simulator";
+import { batchUpsertParticipantSimulatorInputs } from "~/models/simulator";
 
 export type ProbabilitySource = "manual" | "futures_odds" | "elo_simulation" | "performance_model";
 
@@ -366,100 +366,6 @@ export async function batchUpsertParticipantEVs(
   return results;
 }
 
-/**
- * Save American odds for a batch of seasonParticipants without touching probabilities or EV.
- * Used by the futures-odds admin page to persist odds before running the full simulation.
- */
-export async function batchSaveSourceOdds(
-  inputs: Array<{ participantId: string; sportsSeasonId: string; sourceOdds: number }>
-): Promise<void> {
-  const db = database();
-
-  await db.transaction(async (tx) => {
-    const now = new Date();
-
-    for (const { participantId, sportsSeasonId, sourceOdds } of inputs) {
-      const existing = await tx
-        .select({ id: seasonParticipantExpectedValues.id })
-        .from(seasonParticipantExpectedValues)
-        .where(
-          and(
-            eq(seasonParticipantExpectedValues.participantId, participantId),
-            eq(seasonParticipantExpectedValues.sportsSeasonId, sportsSeasonId)
-          )
-        )
-        .limit(1);
-
-      if (existing.length > 0) {
-        await tx
-          .update(seasonParticipantExpectedValues)
-          // Persist the odds and label the source as odds-driven for display.
-          // We no longer null a stored Elo here: how much these odds move it is
-          // decided at run time by the season's blend weight
-          // (SimulatorInputPolicy.oddsWeight), and prepareSimulatorInputsForRun
-          // overwrites the resolved Elo before the simulator reads it.
-          .set({ sourceOdds, source: "futures_odds", updatedAt: now })
-          .where(eq(seasonParticipantExpectedValues.id, existing[0].id));
-      } else {
-        // Insert a stub record — probabilities/EV will be filled in by the simulator
-        await tx.insert(seasonParticipantExpectedValues).values({
-          participantId,
-          sportsSeasonId,
-          probFirst: "0",
-          probSecond: "0",
-          probThird: "0",
-          probFourth: "0",
-          probFifth: "0",
-          probSixth: "0",
-          probSeventh: "0",
-          probEighth: "0",
-          expectedValue: "0",
-          source: "futures_odds",
-          sourceOdds,
-          calculatedAt: now,
-          updatedAt: now,
-        });
-      }
-    }
-  });
-
-  await batchSaveParticipantSimulatorSourceOdds(inputs);
-}
-
-export async function clearSourceOddsForParticipants(
-  sportsSeasonId: string,
-  participantIds: string[]
-): Promise<void> {
-  if (participantIds.length === 0) return;
-  const db = database();
-  const now = new Date();
-  await db.transaction(async (tx) => {
-    await tx
-      .update(seasonParticipantExpectedValues)
-      .set({ sourceOdds: null, updatedAt: now })
-      .where(
-        and(
-          eq(seasonParticipantExpectedValues.sportsSeasonId, sportsSeasonId),
-          inArray(seasonParticipantExpectedValues.participantId, participantIds)
-        )
-      );
-    await tx
-      .update(seasonParticipantSimulatorInputs)
-      .set({
-        sourceOdds: null,
-        rating: null,
-        metadata: sql`coalesce(${seasonParticipantSimulatorInputs.metadata}, '{}'::jsonb) - 'ratingMethod'`,
-        updatedAt: now,
-      })
-      .where(
-        and(
-          eq(seasonParticipantSimulatorInputs.sportsSeasonId, sportsSeasonId),
-          inArray(seasonParticipantSimulatorInputs.participantId, participantIds)
-        )
-      );
-  });
-}
-
 /**
  * Persist raw Elo ratings (and optional world rankings) for a batch of seasonParticipants.
  * Used by Elo-based simulators like snooker_bracket and darts_bracket.

app/models/simulator.ts

@@ -307,93 +307,6 @@ export async function getParticipantSimulatorInputs(
   });
 }
 
-function generatedRatingMethodSql() {
-  return sql`${schema.seasonParticipantSimulatorInputs.metadata}->>'ratingMethod' in ('sourceOdds', 'fallbackRating', 'averageKnown', 'worstKnownMinus')`;
-}
-
-export async function batchSaveParticipantSimulatorSourceOdds(
-  inputs: Array<{ participantId: string; sportsSeasonId: string; sourceOdds: number }>
-): Promise<void> {
-  if (inputs.length === 0) return;
-  const db = database();
-  const now = new Date();
-  const seasonIds = [...new Set(inputs.map((input) => input.sportsSeasonId))];
-
-  await db.transaction(async (tx) => {
-    await tx
-      .update(schema.seasonParticipantSimulatorInputs)
-      .set({
-        rating: null,
-        metadata: sql`coalesce(${schema.seasonParticipantSimulatorInputs.metadata}, '{}'::jsonb) - 'ratingMethod'`,
-        updatedAt: now,
-      })
-      .where(
-        and(
-          inArray(schema.seasonParticipantSimulatorInputs.sportsSeasonId, seasonIds),
-          generatedRatingMethodSql()
-        )
-      );
-
-    await tx
-      .insert(schema.seasonParticipantSimulatorInputs)
-      .values(
-        inputs.map((input) => ({
-          participantId: input.participantId,
-          sportsSeasonId: input.sportsSeasonId,
-          sourceOdds: input.sourceOdds,
-          createdAt: now,
-          updatedAt: now,
-        }))
-      )
-      .onConflictDoUpdate({
-        target: [
-          schema.seasonParticipantSimulatorInputs.participantId,
-          schema.seasonParticipantSimulatorInputs.sportsSeasonId,
-        ],
-        set: {
-          sourceOdds: sql`excluded.source_odds`,
-          rating: sql`case when ${generatedRatingMethodSql()} then null else ${schema.seasonParticipantSimulatorInputs.rating} end`,
-          metadata: sql`case when ${generatedRatingMethodSql()} then coalesce(${schema.seasonParticipantSimulatorInputs.metadata}, '{}'::jsonb) - 'ratingMethod' else ${schema.seasonParticipantSimulatorInputs.metadata} end`,
-          updatedAt: now,
-        },
-      });
-  });
-}
-
-export async function batchSaveFuturesOddsForSimulator(
-  inputs: Array<{ participantId: string; sportsSeasonId: string; sourceOdds: number }>
-): Promise<void> {
-  if (inputs.length === 0) return;
-  const db = database();
-  const now = new Date();
-
-  // Persist the odds non-destructively. How much these odds move a stored
-  // Elo/rating is now governed by the season's blend weight (see resolveSourceElos
-  // / SimulatorInputPolicy.oddsWeight), so we no longer null out manually entered
-  // Elo here — that policy decides at run time.
-  await db
-    .insert(schema.seasonParticipantSimulatorInputs)
-    .values(
-      inputs.map((input) => ({
-        participantId: input.participantId,
-        sportsSeasonId: input.sportsSeasonId,
-        sourceOdds: input.sourceOdds,
-        createdAt: now,
-        updatedAt: now,
-      }))
-    )
-    .onConflictDoUpdate({
-      target: [
-        schema.seasonParticipantSimulatorInputs.participantId,
-        schema.seasonParticipantSimulatorInputs.sportsSeasonId,
-      ],
-      set: {
-        sourceOdds: sql`excluded.source_odds`,
-        updatedAt: now,
-      },
-    });
-}
-
 export async function batchUpsertParticipantSimulatorInputs(
   inputs: UpsertParticipantSimulatorInput[]
 ): Promise<void> {
@@ -426,16 +339,34 @@ export async function batchUpsertParticipantSimulatorInputs(
           schema.seasonParticipantSimulatorInputs.participantId,
           schema.seasonParticipantSimulatorInputs.sportsSeasonId,
         ],
+        // Non-destructive: only overwrite a column when the incoming value is
+        // non-null. This lets a partial import (e.g. odds-only) update just the
+        // columns it provides without clobbering previously stored inputs like a
+        // manually entered Elo or rating. Mirrors the COALESCE bridge used for the
+        // legacy EV table below.
         set: {
-          sourceOdds: sql`excluded.source_odds`,
+          sourceOdds: sql`COALESCE(excluded.source_odds, ${schema.seasonParticipantSimulatorInputs.sourceOdds})`,
-          sourceElo: sql`excluded.source_elo`,
+          sourceElo: sql`COALESCE(excluded.source_elo, ${schema.seasonParticipantSimulatorInputs.sourceElo})`,
-          worldRanking: sql`excluded.world_ranking`,
+          worldRanking: sql`COALESCE(excluded.world_ranking, ${schema.seasonParticipantSimulatorInputs.worldRanking})`,
-          rating: sql`excluded.rating`,
+          rating: sql`COALESCE(excluded.rating, ${schema.seasonParticipantSimulatorInputs.rating})`,
-          projectedWins: sql`excluded.projected_wins`,
+          projectedWins: sql`COALESCE(excluded.projected_wins, ${schema.seasonParticipantSimulatorInputs.projectedWins})`,
-          projectedTablePoints: sql`excluded.projected_table_points`,
+          projectedTablePoints: sql`COALESCE(excluded.projected_table_points, ${schema.seasonParticipantSimulatorInputs.projectedTablePoints})`,
-          seed: sql`excluded.seed`,
+          seed: sql`COALESCE(excluded.seed, ${schema.seasonParticipantSimulatorInputs.seed})`,
-          region: sql`excluded.region`,
+          region: sql`COALESCE(excluded.region, ${schema.seasonParticipantSimulatorInputs.region})`,
-          metadata: sql`excluded.metadata`,
+          // Metadata carries the method flags (sourceEloMethod/ratingMethod) that
+          // tell readers whether the stored Elo/rating is generated vs. a trusted
+          // direct value. When a caller supplies explicit metadata, use it as-is
+          // (prepareSimulatorInputsForRun and the projection importer set the
+          // correct flags). Otherwise preserve existing metadata, but drop the
+          // method flag for any column receiving a fresh direct value — otherwise a
+          // stale "generated" flag would cause that newly-entered Elo/rating to be
+          // filtered out as derived (see getParticipantSimulatorInputs).
+          metadata: sql`CASE
+            WHEN excluded.metadata IS NOT NULL THEN excluded.metadata
+            ELSE COALESCE(${schema.seasonParticipantSimulatorInputs.metadata}, '{}'::jsonb)
+              - (CASE WHEN excluded.source_elo IS NOT NULL THEN 'sourceEloMethod' ELSE '' END)
+              - (CASE WHEN excluded.rating IS NOT NULL THEN 'ratingMethod' ELSE '' END)
+          END`,
           updatedAt: sql`excluded.updated_at`,
         },
       });

app/routes/admin.simulators.tsx

@@ -271,11 +271,6 @@ export default function AdminSimulators({ loaderData }: Route.ComponentProps) {
                             Setup
                           </Link>
                         </Button>
-                        {sim.supportsFuturesOdds && (
-                          <Button variant="ghost" size="sm" asChild>
-                            <Link to={`/admin/sports-seasons/${sim.sportsSeasonId}/futures-odds`}>Futures</Link>
-                          </Button>
-                        )}
                         <Button variant="ghost" size="sm" asChild>
                           <Link to={`/admin/sports-seasons/${sim.sportsSeasonId}/expected-values`}>EVs</Link>
                         </Button>

app/routes/admin.sports-seasons.$id.futures-odds.tsx

@@ -1,394 +1,9 @@
-import { Form, redirect, useLoaderData, useActionData, useNavigation } from 'react-router';
+import { redirect } from 'react-router';
 import type { Route } from './+types/admin.sports-seasons.$id.futures-odds';
 
-import { logger } from '~/lib/logger';
+// Futures odds entry has been consolidated into the Bulk Simulator Inputs card on
-import { findSportsSeasonById } from '~/models/sports-season';
+// the simulator setup page (paste sportsbook lines like `Chiefs +450` or a CSV with
-import { findParticipantsBySportsSeasonId } from '~/models/season-participant';
+// a sourceOdds column). This route now just redirects old bookmarks/links there.
-import { getAllParticipantEVsForSeason, batchSaveSourceOdds, clearSourceOddsForParticipants } from '~/models/participant-expected-value';
-import { batchSaveFuturesOddsForSimulator } from '~/models/simulator';
-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, Info, CheckCircle2, AlertCircle } from 'lucide-react';
-import { runSportsSeasonSimulation } from '~/services/simulations/runner';
-
-export function meta({ data }: Route.MetaArgs): Route.MetaDescriptors {
-  return [{ title: `Futures Odds — ${data?.sportsSeason?.name ?? "Sports Season"} - Brackt Admin` }];
-}
-
 export async function loader({ params }: Route.LoaderArgs) {
-  const sportsSeasonId = params.id;
+  return redirect(`/admin/sports-seasons/${params.id}/simulator`);
-
-  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);
-
-  // Show any saved odds regardless of what simulation ran afterwards
-  const existingOdds = new Map(
-    existingEVs
-      .filter(ev => ev.sourceOdds !== null)
-      .map(ev => [ev.participantId, ev.sourceOdds])
-  );
-
-  return {
-    sportsSeason,
-    participants,
-    existingOdds,
-  };
-}
-
-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);
-
-  // Parse odds from form
-  const futuresOdds: Array<{ participantId: string; odds: number; name: string }> = [];
-
-  for (const participant of participants) {
-    const oddsValue = formData.get(`odds_${participant.id}`) as string;
-    if (oddsValue && oddsValue.trim() !== '') {
-      const odds = Number(oddsValue);
-      if (!isNaN(odds)) {
-        futuresOdds.push({
-          participantId: participant.id,
-          odds,
-          name: participant.name,
-        });
-      }
-    }
-  }
-
-  if (futuresOdds.length === 0) {
-    return { success: false, message: 'Please enter odds for at least one participant' };
-  }
-
-  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.' };
-  }
-
-  const shouldClearExisting = formData.get('clearExisting') === '1';
-
-  try {
-    const oddsInputs = futuresOdds.map(({ participantId, odds }) => ({ participantId, sportsSeasonId, sourceOdds: odds }));
-
-    // Save to legacy table (EV-page display), then clear all ratings and save
-    // sourceOdds to the simulator inputs table so odds always drive the run.
-    // Sequential: batchSaveFuturesOddsForSimulator must win on the inputs table.
-    await batchSaveSourceOdds(oddsInputs);
-    await batchSaveFuturesOddsForSimulator(oddsInputs);
-
-    if (shouldClearExisting) {
-      const keptIds = new Set(futuresOdds.map(f => f.participantId));
-      const clearedIds = participants.filter(p => !keptIds.has(p.id)).map(p => p.id);
-      await clearSourceOddsForParticipants(sportsSeasonId, clearedIds);
-    }
-    await runSportsSeasonSimulation(sportsSeasonId);
-  } catch (error) {
-    logger.error('Error running simulation:', error);
-    return {
-      success: false,
-      message: error instanceof Error ? error.message : 'Simulation failed',
-    };
-  }
-
-  return redirect(`/admin/sports-seasons/${sportsSeasonId}/expected-values`);
-}
-
-function normalizeName(name: string): string {
-  return name.toLowerCase().replace(/[^a-z0-9\s]/g, '').replace(/\s+/g, ' ').trim();
-}
-
-export default function AdminSportsSeasonFuturesOdds() {
-  const { sportsSeason, participants, existingOdds } = useLoaderData<typeof loader>();
-  const actionData = useActionData<ActionData>();
-  const navigation = useNavigation();
-
-  // Initialize odds values from existing data
-  const [oddsValues, setOddsValues] = useState<Record<string, string>>(() => {
-    const initial: Record<string, string> = {};
-    participants.forEach(p => {
-      const existingOdd = existingOdds.get(p.id);
-      if (existingOdd !== undefined && existingOdd !== null) {
-        initial[p.id] = existingOdd.toString();
-      }
-    });
-    return initial;
-  });
-
-  // Bulk import state
-  const [clearExisting, setClearExisting] = useState(false);
-  const [bulkText, setBulkText] = useState('');
-  const [parseResults, setParseResults] = useState<{
-    matched: Array<{ participantId: string; name: string; odds: number; inputName: string }>;
-    unmatched: Array<{ inputName: string; odds: number }>;
-  } | 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 oddsPattern = /^(.+?)\s+([+-]\d{2,6})\s*$/;
-
-    const matched: Array<{ participantId: string; name: string; odds: number; inputName: string }> = [];
-    const unmatched: Array<{ inputName: string; odds: number }> = [];
-    const seenParticipants = new Set<string>();
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.length < 3) continue;
-
-      const match = oddsPattern.exec(trimmed);
-      if (!match) continue;
-
-      const inputName = match[1].trim();
-      const odds = parseInt(match[2], 10);
-      if (isNaN(odds)) continue;
-
-      const participant = findParticipantMatch(inputName);
-      if (participant && !seenParticipants.has(participant.id)) {
-        seenParticipants.add(participant.id);
-        matched.push({ participantId: participant.id, name: participant.name, odds, inputName });
-      } else if (!participant) {
-        unmatched.push({ inputName, odds });
-      }
-    }
-
-    setParseResults({ matched, unmatched });
-  }
-
-  function applyMatches() {
-    if (!parseResults) return;
-    const newOdds = clearExisting ? {} : { ...oddsValues };
-    for (const m of parseResults.matched) {
-      newOdds[m.participantId] = m.odds.toString();
-    }
-    setOddsValues(newOdds);
-    setParseResults(null);
-    setBulkText('');
-    setClearExisting(false);
-  }
-
-  const isSubmitting = navigation.state === 'submitting';
-
-  return (
-    <div className="container mx-auto py-8">
-      <div className="mb-8">
-        <h1 className="text-3xl font-bold mb-2">Futures Odds Entry</h1>
-        <p className="text-muted-foreground">
-          {sportsSeason.sport.name} - {sportsSeason.name}
-        </p>
-      </div>
-
-      {/* Bulk Import */}
-      <Card className="mb-6">
-        <CardHeader>
-          <CardTitle>Bulk Import</CardTitle>
-          <CardDescription>
-            Paste odds from FanDuel, DraftKings, OddsChecker, or any site. Each line should end with
-            American odds (e.g. <code>Kansas City Chiefs +450</code>). Team names are fuzzy-matched to
-            participants.
-          </CardDescription>
-        </CardHeader>
-        <CardContent className="space-y-4">
-          <Textarea
-            placeholder={`Paste odds here, one team per line:\nKansas City Chiefs +450\nSan Francisco 49ers +600\nBaltimore Ravens +700`}
-            value={bulkText}
-            onChange={e => { setBulkText(e.target.value); setParseResults(null); }}
-            rows={8}
-            className="font-mono text-sm"
-          />
-          <div className="flex items-center gap-4">
-            <Button type="button" variant="outline" onClick={parseBulkText} disabled={!bulkText.trim()}>
-              Parse Odds
-            </Button>
-            <label className="flex items-center gap-2 text-sm cursor-pointer select-none">
-              <input
-                type="checkbox"
-                checked={clearExisting}
-                onChange={e => setClearExisting(e.target.checked)}
-                className="h-4 w-4"
-              />
-              Clear existing odds not in this import
-            </label>
-          </div>
-
-          {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; {m.odds > 0 ? '+' : ''}{m.odds}
-                        </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">{u.odds > 0 ? '+' : ''}{u.odds}</span>
-                      </div>
-                    ))}
-                  </div>
-                </div>
-              )}
-
-              {parseResults.matched.length === 0 && parseResults.unmatched.length === 0 && (
-                <p className="text-sm text-muted-foreground">No odds found. Make sure each line ends with a value like +450 or -200.</p>
-              )}
-
-              {parseResults.matched.length > 0 && (
-                <Button type="button" onClick={applyMatches}>
-                  Apply {parseResults.matched.length} matched odds to form
-                </Button>
-              )}
-            </div>
-          )}
-        </CardContent>
-      </Card>
-
-      <div className="grid gap-6 lg:grid-cols-2">
-        <div>
-          <Card>
-            <CardHeader>
-              <CardTitle>Championship Futures Odds</CardTitle>
-              <CardDescription>
-                Enter American odds (e.g., +550, -200) for each participant's championship probability.
-                Enter American odds, then run the ICM simulation to compute and save probability distributions.
-              </CardDescription>
-            </CardHeader>
-            <CardContent>
-              <Form method="post" className="space-y-4">
-                <input type="hidden" name="clearExisting" value={clearExisting ? "1" : ""} />
-                <div className="space-y-3">
-                  {participants.map((participant) => (
-                    <div key={participant.id} className="grid grid-cols-2 gap-4 items-center">
-                      <Label htmlFor={`odds_${participant.id}`}>{participant.name}</Label>
-                      <Input
-                        type="number"
-                        id={`odds_${participant.id}`}
-                        name={`odds_${participant.id}`}
-                        placeholder="+550"
-                        value={oddsValues[participant.id] ?? ''}
-                        onChange={(e) =>
-                          setOddsValues((prev) => ({
-                            ...prev,
-                            [participant.id]: e.target.value,
-                          }))
-                        }
-                      />
-                    </div>
-                  ))}
-                </div>
-
-                <div className="bg-muted p-4 rounded-lg space-y-2">
-                  <div className="flex items-center gap-2 font-medium">
-                    <Info className="h-4 w-4" />
-                    ICM Calculation
-                  </div>
-                  <div className="space-y-1 text-sm">
-                    <div>Uses Independent Chip Model from poker tournaments</div>
-                    <div>Works with any number of participants</div>
-                    <div className="text-xs text-muted-foreground mt-2">
-                      Every team gets probabilities for 1st-8th place, even longshots.
-                    </div>
-                  </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 ? 'Running...' : 'Run Simulation'}
-                </Button>
-              </Form>
-            </CardContent>
-          </Card>
-
-          <Card className="mt-4">
-            <CardHeader>
-              <CardTitle>How It Works</CardTitle>
-            </CardHeader>
-            <CardContent className="text-sm space-y-2">
-              <ol className="list-decimal list-inside space-y-2">
-                <li>Converts American odds to championship win probabilities</li>
-                <li>Removes bookmaker vig (normalizes to 100%)</li>
-                <li>Uses ICM algorithm to distribute probabilities across all placements</li>
-                <li>Generates probability distribution (1st through 8th place) for ALL participants</li>
-                <li>Even teams with +100000 odds get non-zero probabilities</li>
-              </ol>
-            </CardContent>
-          </Card>
-        </div>
-      </div>
-    </div>
-  );
 }

app/routes/admin.sports-seasons.$id.simulator.tsx

@@ -110,6 +110,39 @@ function findParticipantId(name: string, participants: Array<{ id: string; name:
   );
 }
 
+const ODDS_LINE_PATTERN = /^(.+?)\s+([+-]\d{2,6})\s*$/;
+
+function parseOddsLines(
+  lines: string[],
+  sportsSeasonId: string,
+  participants: Array<{ id: string; name: string }>
+): { inputs: UpsertParticipantSimulatorInput[]; unmatched: string[] } {
+  const inputs: UpsertParticipantSimulatorInput[] = [];
+  const unmatched: string[] = [];
+  const seen = new Set<string>();
+
+  for (const line of lines) {
+    const match = ODDS_LINE_PATTERN.exec(line);
+    if (!match) continue;
+
+    const name = match[1].trim();
+    const sourceOdds = Number(match[2]);
+    if (!Number.isFinite(sourceOdds)) continue;
+
+    const participantId = findParticipantId(name, participants);
+    if (!participantId) {
+      unmatched.push(name);
+      continue;
+    }
+    if (seen.has(participantId)) continue;
+    seen.add(participantId);
+
+    inputs.push({ participantId, sportsSeasonId, sourceOdds });
+  }
+
+  return { inputs, unmatched };
+}
+
 function parseInputCsv(
   text: string,
   sportsSeasonId: string,
@@ -122,7 +155,10 @@ function parseInputCsv(
   const indexes = new Map(header.map((value, index) => [value, index]));
   const nameIndex = indexes.get("name");
   if (nameIndex === undefined) {
-    throw new Error("Bulk input CSV must include a `name` column.");
+    // No CSV header — treat the paste as sportsbook futures odds, one team per
+    // line ending in American odds (e.g. `Kansas City Chiefs +450`). This is the
+    // friendly bulk-futures path; team names are fuzzy-matched to participants.
+    return parseOddsLines(lines, sportsSeasonId, participants);
   }
 
   const inputs: UpsertParticipantSimulatorInput[] = [];
@@ -241,7 +277,26 @@ export async function action({ request, params }: Route.ActionArgs): Promise<Act
       const suffix = parsed.unmatched.length > 0
         ? ` ${parsed.unmatched.length} row(s) were unmatched: ${parsed.unmatched.join(", ")}.`
         : "";
-      return { success: true, message: `Saved ${parsed.inputs.length} simulator input row(s).${suffix}` };
+      const saved = `Saved ${parsed.inputs.length} simulator input row(s).${suffix}`;
+
+      // Auto-run the simulation so saved inputs immediately drive the standings.
+      // The save itself already succeeded, so a run that never started (e.g.
+      // participants missing required inputs) is reported as success with the
+      // readiness gap — never as a failed save.
+      try {
+        await runSportsSeasonSimulation(sportsSeasonId);
+        return redirect(`/admin/sports-seasons/${sportsSeasonId}/expected-values`);
+      } catch (runError) {
+        const reason = runError instanceof Error ? runError.message : "could not run.";
+        // Distinguish "saved but never ran" (readiness/already-running) from
+        // "started running and failed mid-run": the runner only flips the season
+        // to status 'failed' once the simulation itself throws.
+        const season = await findSportsSeasonById(sportsSeasonId);
+        if (season?.simulationStatus === "failed") {
+          return { success: false, message: `${saved} The simulation failed: ${reason}` };
+        }
+        return { success: true, message: `${saved} Simulation not run yet: ${reason}` };
+      }
     } catch (error) {
       return { success: false, message: error instanceof Error ? error.message : "Failed to save simulator inputs." };
     }
@@ -334,8 +389,7 @@ export default function AdminSportsSeasonSimulator({ loaderData }: Route.Compone
           )}
 
           <div className="flex flex-wrap gap-2">
-            {setupSections.includes("futuresOdds") && <Button variant="outline" size="sm" asChild><Link to={`/admin/sports-seasons/${sportsSeason.id}/futures-odds`}>Futures Odds</Link></Button>}
+            {setupSections.includes("eloRatings") &&<Button variant="outline" size="sm" asChild><Link to={`/admin/sports-seasons/${sportsSeason.id}/elo-ratings`}>Elo Ratings</Link></Button>}
-            {setupSections.includes("eloRatings") && <Button variant="outline" size="sm" asChild><Link to={`/admin/sports-seasons/${sportsSeason.id}/elo-ratings`}>Elo Ratings</Link></Button>}
             {setupSections.includes("surfaceElo") && <Button variant="outline" size="sm" asChild><Link to={`/admin/sports-seasons/${sportsSeason.id}/surface-elo`}>Surface Elo</Link></Button>}
             {setupSections.includes("golfSkills") && <Button variant="outline" size="sm" asChild><Link to={`/admin/sports-seasons/${sportsSeason.id}/golf-skills`}>Golf Skills</Link></Button>}
             {setupSections.includes("regularStandings") && <Button variant="outline" size="sm" asChild><Link to={`/admin/sports-seasons/${sportsSeason.id}/regular-standings`}>Regular Standings</Link></Button>}
@@ -484,8 +538,12 @@ export default function AdminSportsSeasonSimulator({ loaderData }: Route.Compone
         <CardHeader>
           <CardTitle>Bulk Simulator Inputs</CardTitle>
           <CardDescription>
-            Paste CSV with a header row. Supported columns: name, sourceElo, sourceOdds, worldRanking, rating,
+            Two ways to paste, then the simulation re-runs automatically on save:
-            projectedWins, projectedTablePoints, seed, region. Values must not contain commas.
+            <strong> CSV</strong> with a header row — supported columns: name, sourceElo, sourceOdds,
+            worldRanking, rating, projectedWins, projectedTablePoints, seed, region (values must not
+            contain commas); or <strong>futures odds</strong>, one team per line ending in American
+            odds (e.g. <code>Kansas City Chiefs +450</code>). Team names are fuzzy-matched to
+            participants. A partial paste only updates the columns it includes — other inputs are kept.
           </CardDescription>
         </CardHeader>
         <CardContent className="space-y-4">
@@ -495,7 +553,7 @@ export default function AdminSportsSeasonSimulator({ loaderData }: Route.Compone
               name="bulkInputs"
               rows={8}
               className="font-mono text-sm"
-              placeholder={`name,sourceElo,sourceOdds,worldRanking,rating\n${inputRows[0]?.participant.name ?? "Team Name"},1500,+2500,12,28.5`}
+              placeholder={`name,sourceElo,sourceOdds,worldRanking,rating\n${inputRows[0]?.participant.name ?? "Team Name"},1500,+2500,12,28.5\n\n— or paste futures odds only —\n${inputRows[0]?.participant.name ?? "Team Name"} +2500`}
             />
             <Button type="submit" disabled={isSubmitting}>
               <Save className="mr-2 h-4 w-4" />

app/routes/admin.sports-seasons.$id.tsx

@@ -675,14 +675,6 @@ export default function EditSportsSeason({ loaderData, actionData }: Route.Compo
                     <Calculator className="mr-2 h-4 w-4" />
                     Simulator Setup
                   </Button>
-                  <Button
-                    size="sm"
-                    variant="outline"
-                    onClick={() => navigate(`/admin/sports-seasons/${sportsSeason.id}/futures-odds`)}
-                  >
-                    <Calculator className="mr-2 h-4 w-4" />
-                    Futures Odds
-                  </Button>
                   <Button
                     size="sm"
                     variant="outline"