Merge pull request #181 from choigod1023/codex/restore-live-pick-probability

fix: 경기 중 사전 픽·확률 및 현재 추정 표시 복구

Author: choigod1023

web/src/lib/saved-live-prediction.js

@@ -0,0 +1,49 @@
+import { scheduledAt } from "./match-status.js";
+import { estimateLiveProbability } from "./bet-ledger.js";
+
+const numeric = (value) => typeof value === "number" || (typeof value === "string" && value.trim())
+  ? Number(value) : NaN;
+const probability = (value) => {
+  const n = numeric(value);
+  return Number.isFinite(n) && n > 0 && n < 1 ? n : null;
+};
+
+/** Historical display only: never reconstruct a missing pregame pick from live odds. */
+export function savedLivePrediction(game, live = null, now = Date.now()) {
+  const record = game?.prediction_record;
+  const kickoff = scheduledAt(game);
+  const captured = Date.parse(record?.captured_at || "");
+  if (!record?.selection_id || !record.market || !record.selection
+      || kickoff == null || !Number.isFinite(captured) || captured >= kickoff || captured > now) return null;
+  const option = {
+    selection_id: record.selection_id, offer_id: record.offer_id,
+    market: record.market, label: record.label || "", 선택: record.selection,
+    배당: Number.isFinite(numeric(record.odds)) ? numeric(record.odds) : null,
+  };
+  const openingProbability = probability(record.probability);
+  const result = { option, openingProbability, capturedAt: record.captured_at, estimate: null,
+    estimateStatus: openingProbability === null ? "missing_opening" : "waiting_live" };
+  if (openingProbability === null || !live || live.status === "BEFORE") return result;
+  if (live.finished || live.cancelled || live.postponed) return { ...result, estimateStatus: "closed" };
+  const observed = Date.parse(game._liveFeedAt || live.observed_at || "");
+  if (!Number.isFinite(observed) || now - observed > 10 * 60 * 1000 || observed > now + 5000) {
+    return { ...result, estimateStatus: "stale_live" };
+  }
+  if (![live.home_score, live.away_score].every((v) => Number.isInteger(numeric(v)) && numeric(v) >= 0)) {
+    return { ...result, estimateStatus: "missing_score" };
+  }
+  // The existing estimator has no handicap/period/margin model. Do not present
+  // its generic win/loss fallback as a probability for those distinct contracts.
+  const supportedChoice = {
+    "승패": ["홈", "원정", "승", "패"],
+    "승무패": ["홈", "원정", "승", "패", "무", "무승부"],
+    "언더오버": ["언더", "오버"],
+  }[record.market]?.includes(record.selection);
+  if (!supportedChoice || !["sc", "bs", "bk"].includes(game.sport)
+      || (record.market === "언더오버" && !/\d/.test(option.label))) {
+    return { ...result, estimateStatus: "unsupported_market" };
+  }
+  const estimate = estimateLiveProbability({ openingProbability, game: { sport: game.sport },
+    selection: { market: option.market, label: option.label, choice: option.선택 } }, live);
+  return { ...result, estimate, estimateStatus: "available" };
+}

web/src/lib/saved-live-prediction.test.mjs

@@ -0,0 +1,62 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { savedLivePrediction } from "./saved-live-prediction.js";
+
+const now = Date.parse("2026-09-05T11:00:00Z");
+const record = { selection_id: "saved", offer_id: "old-offer", market: "승패", label: "",
+  selection: "홈", odds: 1.8, probability: .57, captured_at: "2026-09-05T08:00:00Z" };
+const game = { year: 2026, date: "09.05(토) 18:00", sport: "bs", home: "홈팀", away: "원정팀",
+  prediction_record: record, options: [], _liveFeedAt: new Date(now).toISOString() };
+const live = { status: "STARTED", status_text: "6회초", home_score: 4, away_score: 1 };
+
+test("empty options retain the recorded pick and probability for live estimates", () => {
+  const result = savedLivePrediction(game, live, now);
+  assert.equal(result.option.선택, "홈");
+  assert.equal(result.openingProbability, .57);
+  assert.ok(result.estimate.probability > .57);
+  assert.equal(record.probability, .57);
+});
+test("changed live odds, selection identity and probabilities never overwrite the prior", () => {
+  const result = savedLivePrediction({ ...game, _liveOddsChanged: true,
+    options: [{ selection_id: "new", 선택: "원정", 시장확률: .9, 배당: 1.1 }] }, live, now);
+  assert.equal(result.option.selection_id, "saved");
+  assert.equal(result.option.배당, 1.8);
+  assert.equal(result.openingProbability, .57);
+});
+for (const value of [null, undefined, "", " ", true, 0, 1, -1, NaN, Infinity]) {
+  test(`missing/invalid saved probability (${String(value)}) keeps the pick but no fabricated estimate`, () => {
+    const result = savedLivePrediction({ ...game, prediction_record: { ...record, probability: value } }, live, now);
+    assert.equal(result.option.선택, "홈");
+    assert.equal(result.openingProbability, null);
+    assert.equal(result.estimate, null);
+  });
+}
+test("no record or post-kickoff record never creates a retrospective pick", () => {
+  assert.equal(savedLivePrediction({ ...game, prediction_record: null }, live, now), null);
+  for (const captured_at of ["2026-09-05T09:00:00Z", "2026-09-05T10:00:00Z", "bad", null]) {
+    assert.equal(savedLivePrediction({ ...game, prediction_record: { ...record, captured_at } }, live, now), null);
+  }
+});
+test("missing/stale scores preserve the fixed prior, not a current estimate", () => {
+  for (const value of [null, undefined, "", true, -1]) {
+    assert.equal(savedLivePrediction(game, { ...live, home_score: value }, now).estimateStatus, "missing_score");
+  }
+  const stale = savedLivePrediction({ ...game, _liveFeedAt: "2026-09-05T10:00:00Z" }, live, now);
+  assert.equal(stale.openingProbability, .57);
+  assert.equal(stale.estimate, null);
+  assert.equal(stale.estimateStatus, "stale_live");
+});
+test("totals always estimate against the saved line, never current lines", () => {
+  const result = savedLivePrediction({ ...game, prediction_record: { ...record, market: "언더오버", label: "U/O 7.5", selection: "언더" },
+    options: [{ market: "언더오버", label: "U/O 9.5", line: 9.5 }] }, live, now);
+  assert.equal(result.option.label, "U/O 7.5");
+  assert.equal(result.estimateStatus, "available");
+});
+test("unsupported contracts and finished games retain the prior without generic win estimates", () => {
+  for (const market of ["핸디캡", "전반승패", "승①패", "승⑤패"]) {
+    const result = savedLivePrediction({ ...game, prediction_record: { ...record, market } }, live, now);
+    assert.equal(result.openingProbability, .57);
+    assert.equal(result.estimateStatus, "unsupported_market");
+  }
+  assert.equal(savedLivePrediction(game, { ...live, finished: true }, now).estimateStatus, "closed");
+});

web/src/pages/Markets.jsx

@@ -16,9 +16,9 @@ import { alignTodayRecommendations, buildTodayMemberships,
 import { usePolledData } from "../lib/poll.js";
 import { availableToday, nextTodayRefreshDelay } from "../lib/today-plan.js";
 import { freshnessStatus, waitingLabel } from "../lib/data-freshness.js";
-import { decisionFrozen, gamePhase, PHASE_LABEL, recommendationOutcome } from "../lib/match-status.js";
+import { decisionFrozen, gamePhase, PHASE_LABEL, recommendationOutcome, scheduledAt } from "../lib/match-status.js";
 import { predictionForGame } from "../lib/game-prediction.js";
-import { estimateLiveProbability } from "../lib/bet-ledger.js";
+import { savedLivePrediction } from "../lib/saved-live-prediction.js";
 import { commentaryMethod, directPickReason } from "../lib/recommendation.js";
 import { compactTeamPlayerLine } from "../lib/team-preview.js";
 import { deduplicateGameCards } from "../lib/game-dedup.js";
@@ -609,7 +609,7 @@ function MarketHistory({ rows }) {
   </details>;
 }
 
-function Game({ g, opts, wait, grades, lv, stale, generatedAt, year, todayMembership,
+export function Game({ g, opts, wait, grades, lv, stale, generatedAt, year, todayMembership,
   todayOption, highlightedToday, onSaveBet }) {
   // 같은 마켓의 두 선택지가 같은 등급이면 '=' — 어느 쪽을 사도 같아 고를 근거가 없다
   const tie = useMemo(() => {
@@ -626,25 +626,23 @@ function Game({ g, opts, wait, grades, lv, stale, generatedAt, year, todayMember
   // 모델 최대확률을 골라 새 추천을 만들지 않는다.
   const done = g.status === "정산";
   const liveClosed = g._liveStarted === true;
+  const phase = gamePhase(g, lv);
+  const kickoff = scheduledAt(g);
+  const started = liveClosed || phase !== "upcoming" || (kickoff != null && kickoff <= Date.now());
+  const locked = started || decisionFrozen(g);
+  const saved = savedLivePrediction(g, lv);
   const predictionUnavailable = !g.prediction_record
     && (done || g.prediction_status === "prediction_ledger_required");
   const prediction = wait || stale || predictionUnavailable || g._liveOddsChanged
     ? null : predictionForGame(opts);
-  const savedPick = g.prediction_record;
-  const savedOption = savedPick && {
-    ...(opts.find((o) => o.selection_id === savedPick.selection_id) || {}),
-    selection_id: savedPick.selection_id, market: savedPick.market,
-    label: savedPick.label || "", 선택: savedPick.selection, 배당: savedPick.odds,
-  };
-  const displayedOption = (decisionFrozen(g) && savedOption)
-    || todayOption || prediction?.option || null;
+  const displayedOption = (locked && saved?.option)
+    || (!started ? todayOption || prediction?.option : null) || null;
   const pick = displayedOption ? {
     o: displayedOption,
     g: gradeOf(grades, displayedOption["배당"]),
     tie: false,
   } : null;
   // 프로토 정산은 경기가 끝나고도 한참 뒤다. 그 사이를 실시간 점수가 메운다.
-  const phase = gamePhase(g, lv);
   // 필터 집계와 카드 본문이 반드시 같은 상태 판정을 사용해야 한다. 단순히
   // finished=false만 보면 갱신이 끊긴 중계 스냅샷이 카드에 영원히 LIVE로 남는다.
   const playing = phase === "live";
@@ -663,11 +661,11 @@ function Game({ g, opts, wait, grades, lv, stale, generatedAt, year, todayMember
     || (outcome.source === "score" && g.sport === "sc" && lv?.regular_time_score)
     || (lv && lv.home_score != null && lv.away_score != null
         ? [lv.home_score, lv.away_score] : null);
-  const analysis = wait || stale || predictionUnavailable || liveClosed
+  const analysis = wait || stale || predictionUnavailable || started
     ? null : performanceAnalysis(g, pick?.o || null, displayCommentary(g));
   const decision = analysis?.decision || buildDecisionViewModel(g, pick?.o || null);
   const forecast = analysis?.prediction;
-  const fallbackForecast = disruption || (g._liveOddsChanged
+  const fallbackForecast = disruption || (started && !saved ? "사전 예측 기록 없음" : g._liveOddsChanged
     ? "배당 변경 · 재계산 대기"
     : stale
     ? "최신 데이터 확인 필요"
@@ -678,20 +676,8 @@ function Game({ g, opts, wait, grades, lv, stale, generatedAt, year, todayMember
       : wait
         ? "배당 발표 전"
         : "분석 자료 확인 중");
-  const openingProbability = Number(
-    decision?.probability?.final ?? pick?.o?.["예상적중확률"] ?? pick?.o?.["시장확률"],
-  );
-  const liveProbability = playing && pick && Number.isFinite(openingProbability)
-    ? estimateLiveProbability({
-        openingProbability,
-        game: { sport: g.sport },
-        selection: {
-          market: pick.o.market,
-          label: pick.o.label || "",
-          choice: pick.o["선택"],
-        },
-      }, lv)
-    : null;
+  const openingProbability = saved?.openingProbability ?? null;
+  const liveProbability = playing ? saved?.estimate : null;
   const compactPlayers = compactTeamPlayerLine(analysis?.teamPreviews);
   const pendingLabel = g._liveOddsChanged ? "재계산" : stale ? "중단" : "보류";
   // 시작 전 산출물이 options=[]였던 경기는 해설에도 "배당 미발표"가 박혀 있다.
@@ -740,8 +726,10 @@ function Game({ g, opts, wait, grades, lv, stale, generatedAt, year, todayMember
         <span className="flex gap-1.5">
           {playing ? <>
               <span className="live-score-badge"><i />LIVE <b>{lv.status_text || "진행 중"}</b></span>
+              {Number.isFinite(openingProbability) &&
+                <OddsChip label="사전 확률" value={pct(openingProbability)} title="경기 시작 전에 저장된 픽의 고정 확률" />}
               {Number.isFinite(liveProbability?.probability) &&
-                <OddsChip label="현재 적중" value={pct(liveProbability.probability)}
+                <OddsChip label="현재 추정" value={pct(liveProbability.probability)}
                   title="사전 확률에 현재 점수와 남은 시간을 반영한 상황 추정치" />}
             </>
             : disruption ? <OddsChip label="상태" value={disruption.replace("경기 ", "")} />
@@ -764,6 +752,14 @@ function Game({ g, opts, wait, grades, lv, stale, generatedAt, year, todayMember
         </span>
       </summary>
       <div className="match-detail">
+        {locked && saved && !finished && (
+          <div className="mb-3 rounded border border-rule2 bg-panel px-3 py-2 text-[12px]" aria-label="저장된 사전 예측">
+            <b>경기 전 예측 픽 · {saved.option.market} {saved.option.label} {saved.option.선택}</b>
+            <p>사전 확률 {Number.isFinite(openingProbability) ? pct(openingProbability) : "기록 없음"} · 당시 배당 {odds(saved.option.배당)}</p>
+            {playing && !liveProbability && <small>현재 추정 확률은 {saved.estimateStatus === "unsupported_market"
+              ? "이 마켓에서 제공하지 않습니다." : "사전 확률과 최신 점수 자료가 모두 확인되어야 표시됩니다."}</small>}
+          </div>
+        )}
         <MarketHistory rows={g._marketHistory} />
         {todayMembership && recommendationReason && (
           <div className={`today-pick-signals ${highlightedToday ? "is-recommended" : "is-excluded"}`} role="note">

web/src/pages/live-pick-display.test.mjs

@@ -0,0 +1,49 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { createServer } from "vite";
+
+test("live card renders the saved pick and prior even with no current options", async () => {
+  const now = Date.parse("2026-09-05T11:00:00Z");
+  const originalNow = Date.now;
+  Date.now = () => now;
+  const server = await createServer({ configFile: false,
+    root: fileURLToPath(new URL("../../", import.meta.url)),
+    esbuild: { jsx: "automatic" }, optimizeDeps: { noDiscovery: true, include: [] },
+    server: { middlewareMode: true, watch: null }, appType: "custom" });
+  try {
+    const { Game } = await server.ssrLoadModule("/src/pages/Markets.jsx");
+    const lv = { status: "STARTED", status_text: "6회초", home_score: 4, away_score: 1 };
+    const g = { year: 2026, round: 105, date: "09.05(토) 18:00", sport: "bs",
+      home: "홈팀", away: "원정팀", status: "경기전", options: [],
+      _liveStarted: true, _liveFeedAt: new Date(now).toISOString(),
+      prediction_record: { selection_id: "saved", market: "승패", selection: "홈", label: "",
+        odds: 1.8, probability: .57, captured_at: "2026-09-05T08:00:00Z" } };
+    const props = { g, opts: [], lv, wait: true, stale: true, grades: { odds_bins: [] }, year: 2026 };
+    const html = renderToStaticMarkup(createElement(Game, props));
+    assert.match(html, /경기 전 예측 픽/);
+    assert.match(html, /57.0%/);
+    assert.match(html, /현재 추정/);
+    assert.match(html, /사전 확률/);
+    assert.doesNotMatch(html, /NaN/);
+    const missingProbability = renderToStaticMarkup(createElement(Game, { ...props,
+      g: { ...g, prediction_record: { ...g.prediction_record, probability: null } } }));
+    assert.match(missingProbability, /경기 전 예측 픽/);
+    assert.match(missingProbability, /사전 확률 기록 없음/);
+    assert.doesNotMatch(missingProbability, /0.0%/);
+    const unrecorded = renderToStaticMarkup(createElement(Game, { ...props,
+      g: { ...g, prediction_record: null },
+      todayOption: { market: "승패", 선택: "원정", 시장확률: .9 } }));
+    assert.match(unrecorded, /사전 예측 기록 없음/);
+    assert.doesNotMatch(unrecorded, /경기 전 예측 픽|90.0%/);
+    const stale = renderToStaticMarkup(createElement(Game, { ...props,
+      g: { ...g, _liveFeedAt: "2026-09-05T10:00:00Z" } }));
+    assert.match(stale, /57.0%/);
+    assert.doesNotMatch(stale, /현재 추정/);
+  } finally {
+    await server.close();
+    Date.now = originalNow;
+  }
+});