feat(ai-engine): value sniper thresholds and logic relaxed

src/common/utils/match-status.util.ts

@@ -81,7 +81,6 @@ export const LIVE_STATUS_VALUES_FOR_DB = [
   "Playing",
   "Half Time",
   "liveGame",
-  "minutes",
 ];
 
 export const LIVE_STATE_VALUES_FOR_DB = [
@@ -110,7 +109,6 @@ export const FINISHED_STATUS_VALUES_FOR_DB = [
   "postGame",
   "posted",
   "Posted",
-  "state",
 ];
 
 export const FINISHED_STATE_VALUES_FOR_DB = [

src/modules/predictions/dto/index.ts

@@ -148,6 +148,27 @@ export class MatchPickDto {
   @ApiProperty({ required: false, default: 0 })
   implied_prob?: number;
 
+  @ApiProperty({ required: false, default: 0 })
+  model_probability?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  model_edge?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  calibrated_probability?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  odds_band_probability?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  odds_band_sample?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  odds_band_edge?: number;
+
+  @ApiProperty({ required: false, default: false })
+  odds_band_aligned?: boolean;
+
   @ApiProperty()
   play_score: number;
 
@@ -171,6 +192,9 @@ export class MatchPickDto {
     enum: ["CORE", "VALUE", "LEAN", "LONGSHOT", "PASS"],
   })
   signal_tier?: SignalTier;
+
+  @ApiProperty({ required: false, default: false })
+  is_guaranteed?: boolean;
 }
 
 export class MatchBetAdviceDto {
@@ -227,6 +251,27 @@ export class MatchBetSummaryItemDto {
   @ApiProperty({ required: false, default: 0 })
   implied_prob?: number;
 
+  @ApiProperty({ required: false, default: 0 })
+  model_probability?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  model_edge?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  calibrated_probability?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  odds_band_probability?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  odds_band_sample?: number;
+
+  @ApiProperty({ required: false, default: 0 })
+  odds_band_edge?: number;
+
+  @ApiProperty({ required: false, default: false })
+  odds_band_aligned?: boolean;
+
   @ApiProperty({ required: false, default: 0 })
   odds?: number;
 

src/modules/predictions/predictions.service.ts

@@ -60,7 +60,7 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
     confidence_interval_too_wide_for_main_pick:
       "Ana seçim için güven aralığı çok geniş",
     confidence_band_low: "Güven bandı düşük",
-    playable_edge_found: "Oynanabilir avantaj bulundu",
+    playable_edge_found: "Model avantaj sinyali bulundu",
     market_signal_dominant: "Piyasa sinyali baskın",
     team_form_signal_dominant: "Takım formuna dayalı sinyaller çok baskın",
     lineup_signal_strong: "İlk on bir sinyali güçlü",
@@ -77,7 +77,12 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
     limited_data_confidence: "Veri kısıtlı olduğu için güven sınırlı",
     data_quality_issue: "Veri kalitesi sorunu var",
     high_risk_low_data_quality: "Risk yüksek, veri kalitesi düşük",
-    insufficient_play_score: "Oynanabilirlik puanı yetersiz",
+    insufficient_play_score: "Model sinyali yetersiz",
+    odds_band_confirms_value: "Tarihsel oran bandı değeri doğruluyor",
+    odds_band_sample_too_low: "Tarihsel oran bandı örneklemi yetersiz",
+    odds_band_missing_probability: "Tarihsel oran bandı olasılığı yok",
+    odds_band_unavailable: "Tarihsel oran bandı kullanılamıyor",
+    odds_band_not_aligned: "Model ve tarihsel oran bandı aynı yönde değil",
     no_bet_conditions_met: "Bahis koşulları oluşmadı",
     market_passed_all_gates: "Market tüm güvenlik kontrollerini geçti",
     no_ev_edge_minimum_stake:
@@ -129,10 +134,7 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
     private readonly feederService: FeederService,
     @Optional() private readonly predictionsQueue?: PredictionsQueue,
   ) {
-    this.aiEngineUrl = this.configService.get(
-      "AI_ENGINE_URL",
-      "http://localhost:8000",
-    );
+    this.aiEngineUrl = this.resolveAiEngineUrl();
     this.aiEngineClient = new AiEngineClient({
       baseUrl: this.aiEngineUrl,
       logger: this.logger,
@@ -421,6 +423,59 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
     }
   }
 
+  private resolveAiEngineUrl(): string {
+    const configuredUrl = this.configService.get(
+      "AI_ENGINE_URL",
+      "http://localhost:8000",
+    );
+    const localEnvUrl = this.readLocalEnvValue("AI_ENGINE_URL");
+
+    if (
+      process.env.NODE_ENV !== "production" &&
+      localEnvUrl &&
+      localEnvUrl !== configuredUrl &&
+      this.isLocalhostUrl(configuredUrl) &&
+      this.isLocalhostUrl(localEnvUrl)
+    ) {
+      this.logger.warn(
+        `AI_ENGINE_URL inherited from parent process (${configuredUrl}) differs from .env.local (${localEnvUrl}); using .env.local for local development`,
+      );
+      return localEnvUrl;
+    }
+
+    return configuredUrl;
+  }
+
+  private readLocalEnvValue(key: string): string | null {
+    const filePath = path.join(process.cwd(), ".env.local");
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    const line = fs
+      .readFileSync(filePath, "utf8")
+      .split(/\r?\n/u)
+      .find((entry) => entry.trim().startsWith(`${key}=`));
+
+    if (!line) {
+      return null;
+    }
+
+    return line
+      .slice(line.indexOf("=") + 1)
+      .trim()
+      .replace(/^['"]|['"]$/gu, "");
+  }
+
+  private isLocalhostUrl(value: string): boolean {
+    try {
+      const url = new URL(value);
+      return ["localhost", "127.0.0.1", "::1"].includes(url.hostname);
+    } catch {
+      return false;
+    }
+  }
+
   private async getMatchContext(matchId: string): Promise<MatchContext> {
     const match = await this.prisma.match.findUnique({
       where: { id: matchId },
@@ -705,6 +760,7 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
       ),
       confidence_interval: interval,
       signal_tier: this.classifySignalTier(record, interval),
+      is_guaranteed: false,
     };
   }
 
@@ -793,7 +849,7 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
 
     const evMatch = normalized.match(/^ev_edge_([-+][\d.]+%)_grade_(\w)$/);
     if (evMatch) {
-      return `Beklenen avantaj ${evMatch[1]} (Not ${evMatch[2]})`;
+      return `Teorik avantaj sinyali: Not ${evMatch[2]}`;
     }
 
     const negativeEdgeMatch = normalized.match(
@@ -803,6 +859,13 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
       return `Model avantajı negatif (${negativeEdgeMatch[1]})`;
     }
 
+    const bandNoValueMatch = normalized.match(
+      /^odds_band_no_value_([-+]?[\d.]+)$/,
+    );
+    if (bandNoValueMatch) {
+      return `Tarihsel oran bandı değeri doğrulamadı (${bandNoValueMatch[1]})`;
+    }
+
     const edgeThresholdMatch = normalized.match(
       /^below_market_edge_threshold_([-+]?[\d.]+)$/,
     );
@@ -1514,8 +1577,15 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
           pick: item.pick,
           playable: item.playable,
           bet_grade: item.bet_grade,
+          odds: item.odds,
+          model_edge: item.model_edge,
+          calibrated_probability: item.calibrated_probability,
           calibrated_confidence: item.calibrated_confidence,
           ev_edge: item.ev_edge ?? 0,
+          odds_band_probability: item.odds_band_probability,
+          odds_band_sample: item.odds_band_sample,
+          odds_band_edge: item.odds_band_edge,
+          odds_band_aligned: item.odds_band_aligned,
           stake_units: item.stake_units,
         }))
       : [];
@@ -1531,8 +1601,15 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
             pick: payload.main_pick.pick,
             playable: payload.main_pick.playable,
             bet_grade: payload.main_pick.bet_grade,
+            odds: payload.main_pick.odds,
+            model_edge: payload.main_pick.model_edge,
+            calibrated_probability: payload.main_pick.calibrated_probability,
             calibrated_confidence: payload.main_pick.calibrated_confidence,
             ev_edge: payload.main_pick.ev_edge ?? 0,
+            odds_band_probability: payload.main_pick.odds_band_probability,
+            odds_band_sample: payload.main_pick.odds_band_sample,
+            odds_band_edge: payload.main_pick.odds_band_edge,
+            odds_band_aligned: payload.main_pick.odds_band_aligned,
             stake_units: payload.main_pick.stake_units,
           }
         : null,
@@ -1542,6 +1619,8 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
             pick: payload.value_pick.pick,
             playable: payload.value_pick.playable,
             bet_grade: payload.value_pick.bet_grade,
+            odds: payload.value_pick.odds,
+            model_edge: payload.value_pick.model_edge,
             calibrated_confidence: payload.value_pick.calibrated_confidence,
             ev_edge: payload.value_pick.ev_edge ?? 0,
           }

src/tasks/data-fetcher.task.ts

@@ -9,6 +9,7 @@ import * as path from "path";
 import { Prisma } from "@prisma/client";
 import { SidelinedResponse } from "../modules/feeder/feeder.types";
 import {
+  deriveStoredMatchStatus,
   FINISHED_STATE_VALUES_FOR_DB,
   FINISHED_STATUS_VALUES_FOR_DB,
   LIVE_STATE_VALUES_FOR_DB,
@@ -74,6 +75,17 @@ interface LiveLineupsJson {
   away: { xi: unknown[]; subs: unknown[] };
 }
 
+interface PendingPredictionRunForSettlement {
+  id: bigint;
+  matchId: string;
+  engineVersion: string;
+  payloadSummary: unknown;
+  scoreHome: number | null;
+  scoreAway: number | null;
+  htScoreHome: number | null;
+  htScoreAway: number | null;
+}
+
 type SportType = "football" | "basketball";
 
 // ────────────────────────────────────────────────────────────────
@@ -187,6 +199,7 @@ export class DataFetcherTask {
     await this.syncMatchList(today);
     await this.syncMatchList(tomorrow);
     await this.updateLiveScores();
+    await this.settlePredictionRuns();
     await this.fetchOddsForMatches();
     await this.fillMissingLineups();
 
@@ -263,13 +276,23 @@ export class DataFetcherTask {
 
           if (response.data?.data) {
             const matchData = response.data.data;
+            const scoreHome = matchData.homeScore ?? null;
+            const scoreAway = matchData.awayScore ?? null;
+            const storedStatus = deriveStoredMatchStatus({
+              state: matchData.state,
+              status: matchData.status,
+              substate: matchData.substate,
+              scoreHome,
+              scoreAway,
+            });
             await this.prisma.liveMatch.update({
               where: { id: match.id },
               data: {
-                scoreHome: matchData.homeScore ?? null,
-                scoreAway: matchData.awayScore ?? null,
-                state: matchData.state || matchData.status,
-                status: matchData.status,
+                scoreHome,
+                scoreAway,
+                state: matchData.state || null,
+                substate: matchData.substate || null,
+                status: storedStatus,
                 updatedAt: new Date(),
               },
             });
@@ -286,6 +309,292 @@ export class DataFetcherTask {
     }
   }
 
+  private async settlePredictionRuns(): Promise<void> {
+    try {
+      const rows = await this.prisma.$queryRawUnsafe<
+        PendingPredictionRunForSettlement[]
+      >(`
+        SELECT
+          pr.id,
+          pr.match_id AS "matchId",
+          pr.engine_version AS "engineVersion",
+          pr.payload_summary AS "payloadSummary",
+          m.score_home AS "scoreHome",
+          m.score_away AS "scoreAway",
+          m.ht_score_home AS "htScoreHome",
+          m.ht_score_away AS "htScoreAway"
+        FROM prediction_runs pr
+        JOIN matches m ON m.id = pr.match_id
+        WHERE pr.eventual_outcome IS NULL
+          AND m.sport = 'football'
+          AND m.status = 'FT'
+          AND m.score_home IS NOT NULL
+          AND m.score_away IS NOT NULL
+        ORDER BY pr.generated_at ASC
+        LIMIT 500
+      `);
+
+      if (rows.length === 0) return;
+
+      let settled = 0;
+      for (const row of rows) {
+        const result = this.resolvePredictionRunSettlement(row);
+        if (!result) continue;
+        const closingOddsSnapshot = await this.getClosingOddsSnapshot(row.matchId);
+        const settlementSummary = {
+          settled_at: new Date().toISOString(),
+          model_version: row.engineVersion,
+          outcome: result.outcome,
+          unit_profit: result.unitProfit,
+          final_score: {
+            home: row.scoreHome,
+            away: row.scoreAway,
+          },
+          halftime_score: {
+            home: row.htScoreHome,
+            away: row.htScoreAway,
+          },
+          closing_odds_snapshot: closingOddsSnapshot,
+        };
+
+        await this.prisma.$executeRawUnsafe(
+          `
+            UPDATE prediction_runs
+            SET eventual_outcome = $1,
+                unit_profit = $2,
+                payload_summary = payload_summary || jsonb_build_object('settlement', $3::jsonb)
+            WHERE id = $4
+          `,
+          result.outcome,
+          result.unitProfit,
+          JSON.stringify(settlementSummary),
+          row.id,
+        );
+        settled++;
+      }
+
+      if (settled > 0) {
+        this.logger.log(`Settled ${settled} prediction run(s)`);
+      }
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn(`Prediction run settlement skipped: ${message}`);
+    }
+  }
+
+  private async getClosingOddsSnapshot(
+    matchId: string,
+  ): Promise<Record<string, unknown>> {
+    const liveMatch = await this.prisma.liveMatch.findUnique({
+      where: { id: matchId },
+      select: {
+        odds: true,
+        oddsUpdatedAt: true,
+        status: true,
+        state: true,
+        scoreHome: true,
+        scoreAway: true,
+      },
+    });
+
+    if (liveMatch?.odds) {
+      return {
+        source: "live_match",
+        odds: liveMatch.odds,
+        odds_updated_at: liveMatch.oddsUpdatedAt?.toISOString() ?? null,
+        status: liveMatch.status ?? null,
+        state: liveMatch.state ?? null,
+        score_home: liveMatch.scoreHome,
+        score_away: liveMatch.scoreAway,
+      };
+    }
+
+    const categories = await this.prisma.oddCategory.findMany({
+      where: { matchId },
+      select: {
+        name: true,
+        selections: {
+          select: {
+            name: true,
+            oddValue: true,
+            position: true,
+            updatedAt: true,
+          },
+          orderBy: { position: "asc" },
+          take: 12,
+        },
+      },
+      orderBy: { name: "asc" },
+      take: 24,
+    });
+
+    return {
+      source: "odd_selections",
+      category_count: categories.length,
+      categories: categories.map((category) => ({
+        name: category.name,
+        selections: category.selections.map((selection) => ({
+          name: selection.name,
+          odd_value: selection.oddValue,
+          position: selection.position,
+          updated_at: selection.updatedAt?.toISOString() ?? null,
+        })),
+      })),
+    };
+  }
+
+  private resolvePredictionRunSettlement(
+    row: PendingPredictionRunForSettlement,
+  ): { outcome: string; unitProfit: number } | null {
+    const summary = this.asRecord(row.payloadSummary);
+    const mainPick = this.asRecord(summary.main_pick);
+    const market = String(mainPick.market || "");
+    const pick = String(mainPick.pick || "");
+    const playable = mainPick.playable === true;
+    const odds = Number(mainPick.odds || 0);
+
+    if (!market || !pick || !playable || !Number.isFinite(odds) || odds <= 1.01) {
+      return { outcome: "NO_BET", unitProfit: 0 };
+    }
+
+    const won = this.isPredictionPickWon({
+      market,
+      pick,
+      scoreHome: row.scoreHome,
+      scoreAway: row.scoreAway,
+      htScoreHome: row.htScoreHome,
+      htScoreAway: row.htScoreAway,
+    });
+
+    if (won === null) return null;
+
+    return {
+      outcome: `${won ? "WON" : "LOST"}:${market}:${pick}`,
+      unitProfit: Number((won ? odds - 1 : -1).toFixed(4)),
+    };
+  }
+
+  private isPredictionPickWon(input: {
+    market: string;
+    pick: string;
+    scoreHome: number | null;
+    scoreAway: number | null;
+    htScoreHome: number | null;
+    htScoreAway: number | null;
+  }): boolean | null {
+    const market = input.market.toUpperCase();
+    const pick = this.normalizePick(input.pick);
+    const scoreHome = input.scoreHome;
+    const scoreAway = input.scoreAway;
+    if (scoreHome === null || scoreAway === null) return null;
+
+    if (market === "MS") {
+      if (pick === "1") return scoreHome > scoreAway;
+      if (pick === "X" || pick === "0") return scoreHome === scoreAway;
+      if (pick === "2") return scoreAway > scoreHome;
+      return null;
+    }
+
+    if (market === "DC") {
+      const normalized = pick.replace("-", "");
+      if (normalized === "1X") return scoreHome >= scoreAway;
+      if (normalized === "X2") return scoreAway >= scoreHome;
+      if (normalized === "12") return scoreHome !== scoreAway;
+      return null;
+    }
+
+    if (market === "BTTS") {
+      const bothScored = scoreHome > 0 && scoreAway > 0;
+      if (pick.includes("VAR") || pick.includes("YES") || pick === "Y") {
+        return bothScored;
+      }
+      if (pick.includes("YOK") || pick.includes("NO") || pick === "N") {
+        return !bothScored;
+      }
+      return null;
+    }
+
+    const goalLine = this.goalLineForMarket(market);
+    if (goalLine !== null) {
+      const total =
+        market.startsWith("HT_")
+          ? this.nullableSum(input.htScoreHome, input.htScoreAway)
+          : scoreHome + scoreAway;
+      if (total === null) return null;
+      if (this.isOverPick(pick)) return total > goalLine;
+      return total < goalLine;
+    }
+
+    if (market === "HT") {
+      const htHome = input.htScoreHome;
+      const htAway = input.htScoreAway;
+      if (htHome === null || htAway === null) return null;
+      if (pick === "1") return htHome > htAway;
+      if (pick === "X" || pick === "0") return htHome === htAway;
+      if (pick === "2") return htAway > htHome;
+    }
+
+    if (market === "HTFT") {
+      const htHome = input.htScoreHome;
+      const htAway = input.htScoreAway;
+      if (htHome === null || htAway === null || !pick.includes("/")) return null;
+      const [htPick, ftPick] = pick.split("/");
+      return (
+        this.isResultPickWon(htPick, htHome, htAway) === true &&
+        this.isResultPickWon(ftPick, scoreHome, scoreAway) === true
+      );
+    }
+
+    return null;
+  }
+
+  private isResultPickWon(
+    pick: string,
+    homeScore: number,
+    awayScore: number,
+  ): boolean | null {
+    if (pick === "1") return homeScore > awayScore;
+    if (pick === "X" || pick === "0") return homeScore === awayScore;
+    if (pick === "2") return awayScore > homeScore;
+    return null;
+  }
+
+  private goalLineForMarket(market: string): number | null {
+    if (market === "OU15") return 1.5;
+    if (market === "OU25") return 2.5;
+    if (market === "OU35") return 3.5;
+    if (market === "HT_OU05") return 0.5;
+    if (market === "HT_OU15") return 1.5;
+    return null;
+  }
+
+  private nullableSum(a: number | null, b: number | null): number | null {
+    if (a === null || b === null) return null;
+    return a + b;
+  }
+
+  private normalizePick(value: string): string {
+    return value
+      .trim()
+      .toUpperCase()
+      .replace(/İ/g, "I")
+      .replace(/Ü/g, "U")
+      .replace(/Ş/g, "S")
+      .replace(/Ğ/g, "G")
+      .replace(/Ö/g, "O")
+      .replace(/Ç/g, "C");
+  }
+
+  private isOverPick(pick: string): boolean {
+    return pick.includes("UST") || pick.includes("OVER");
+  }
+
+  private asRecord(value: unknown): Record<string, unknown> {
+    return value && typeof value === "object" && !Array.isArray(value)
+      ? (value as Record<string, unknown>)
+      : {};
+  }
+
   // Phase 3: Odds + referee + lineups + sidelined
 
   private async fetchOddsForMatches(): Promise<void> {
@@ -705,6 +1014,15 @@ export class DataFetcherTask {
           // Safe score parsing
           const sHome = this.asInt(match.homeScore ?? match.score?.home);
           const sAway = this.asInt(match.awayScore ?? match.score?.away);
+          const storedStatus = deriveStoredMatchStatus({
+            state: match.state,
+            status: match.status,
+            substate: match.substate,
+            statusBoxContent: match.statusBoxContent,
+            scoreHome: sHome,
+            scoreAway: sAway,
+            score: match.score,
+          });
 
           // Handle postponed matches (ERT = Erteledendi)
           if (match.statusBoxContent === "ERT") {
@@ -733,7 +1051,7 @@ export class DataFetcherTask {
               leagueId: leagueId,
               state: match.state || null,
               substate: match.substate || null,
-              status: match.status || match.state || "NS",
+              status: storedStatus,
               scoreHome: sHome,
               scoreAway: sAway,
               homeTeamId: homeTeamId,
@@ -748,7 +1066,7 @@ export class DataFetcherTask {
               leagueId: leagueId,
               state: match.state || null,
               substate: match.substate || null,
-              status: match.status || match.state || "NS",
+              status: storedStatus,
               mstUtc: BigInt(match.mstUtc || Date.now()),
               scoreHome: sHome,
               scoreAway: sAway,