Tighten lane minimum book thresholds

src/config.js

@@ -25,21 +25,21 @@ export function getConfig() {
   const scanMorningTime = process.env.SCAN_MORNING_TIME?.trim() || '08:00';
   const scanMorningFallbackTime = process.env.SCAN_MORNING_FALLBACK_TIME?.trim() || '09:45';
   const scanTimeZone = process.env.SCAN_TIMEZONE?.trim() || 'America/Chicago';
-  const scanMinBooks = Number(process.env.SCAN_MIN_BOOKS || 3);
+  const scanMinBooks = Number(process.env.SCAN_MIN_BOOKS || 6);
   const scanDisagreementThreshold = Number(process.env.SCAN_DISAGREEMENT_THRESHOLD || 0.08);
   const scanAlertCooldownMinutes = Number(process.env.SCAN_ALERT_COOLDOWN_MINUTES || 180);
   const scanFrequencyMinutes = Number(process.env.SCAN_FREQUENCY_MINUTES || 15);
   const scanHttpTimeoutMs = Number(process.env.SCAN_HTTP_TIMEOUT_MS || 15000);
   const directOddsCacheTtlMs = Number(process.env.DIRECT_ODDS_CACHE_TTL_MS || 60000);
   const sharpEdgeAlertThreshold = Number(process.env.SHARP_EDGE_ALERT_THRESHOLD || 0.04);
-  const sharpEdgeAlertMinBooks = Number(process.env.SHARP_EDGE_ALERT_MIN_BOOKS || 5);
+  const sharpEdgeAlertMinBooks = Number(process.env.SHARP_EDGE_ALERT_MIN_BOOKS || 6);
   const staleBookAlertThreshold = Number(process.env.STALE_BOOK_ALERT_THRESHOLD || 0.025);
   const reverseAlertThreshold = Number(process.env.REVERSE_ALERT_THRESHOLD || 0.03);
-  const dfsScanMinBooks = Number(process.env.DFS_SCAN_MIN_BOOKS || 3);
+  const dfsScanMinBooks = Number(process.env.DFS_SCAN_MIN_BOOKS || 4);
   const dfsEdgeAlertThreshold = Number(process.env.DFS_EDGE_ALERT_THRESHOLD || sharpEdgeAlertThreshold);
   const dfsReverseAlertThreshold = Number(process.env.DFS_REVERSE_ALERT_THRESHOLD || reverseAlertThreshold);
   const dfsStaleAlertThreshold = Number(process.env.DFS_STALE_ALERT_THRESHOLD || staleBookAlertThreshold);
-  const exchangeScanMinBooks = Number(process.env.EXCHANGE_SCAN_MIN_BOOKS || 3);
+  const exchangeScanMinBooks = Number(process.env.EXCHANGE_SCAN_MIN_BOOKS || 4);
   const exchangeEdgeAlertThreshold = Number(process.env.EXCHANGE_EDGE_ALERT_THRESHOLD || sharpEdgeAlertThreshold);
   const exchangeReverseAlertThreshold = Number(process.env.EXCHANGE_REVERSE_ALERT_THRESHOLD || reverseAlertThreshold);
   const exchangeStaleAlertThreshold = Number(process.env.EXCHANGE_STALE_ALERT_THRESHOLD || staleBookAlertThreshold);

src/market-scanner.js

@@ -2249,6 +2249,7 @@ function getSharpSourceMode(entry, lane = 'sportsbook') {
 
 export function analyzeSharpMarkets(entries, config = {}, options = {}) {
   const lane = normalizeLaneFilter(options.lane);
+  const laneMinBooks = getLaneMinBooks(config, lane);
   const grouped = new Map();
 
   for (const entry of entries) {
@@ -2268,7 +2269,13 @@ export function analyzeSharpMarkets(entries, config = {}, options = {}) {
 
   for (const [comparisonKey, groupEntries] of grouped.entries()) {
     const uniqueEntries = collapseEntriesByBook(groupEntries);
+    if (uniqueEntries.length < laneMinBooks) {
+      continue;
+    }
     const allImplied = uniqueEntries.map((entry) => entry.impliedProbability).filter((value) => value !== null && value !== undefined);
+    if (allImplied.length < laneMinBooks) {
+      continue;
+    }
     const marketWidth = allImplied.length > 1 ? Math.max(...allImplied) - Math.min(...allImplied) : 0;
     let sharpEntry = pickLaneSharpEntry(uniqueEntries, lane);
     let softEntries = [];
@@ -2296,7 +2303,7 @@ export function analyzeSharpMarkets(entries, config = {}, options = {}) {
       sharpImpliedProbability = sharpEntry.impliedProbability;
       sharpSourceMode = getSharpSourceMode(sharpEntry, lane);
     } else {
-      if (uniqueEntries.length < 2 || allImplied.length < 2) {
+      if (uniqueEntries.length < laneMinBooks || allImplied.length < laneMinBooks) {
         continue;
       }
 
@@ -4288,7 +4295,10 @@ export class MarketScanner {
           continue;
         }
         const minBooks = lane === 'sportsbook'
-          ? Number(this.config.sharpEdgeAlertMinBooks ?? 5)
+          ? Math.max(
+            Number(this.config.sharpEdgeAlertMinBooks ?? 6),
+            getLaneMinBooks(this.config, lane),
+          )
           : getLaneMinBooks(this.config, lane);
         const edgeThreshold = getLaneThreshold(this.config, lane, 'edge');
         for (const row of laneAnalysis.edgeRows) {

test/market-scanner.test.js

@@ -630,7 +630,7 @@ test('movement alerts skip games that have already started', async () => {
   assert.equal(sentPayloads.length, 0);
 });
 
-test('sharp edge alerts require pregame rows and at least five books compared', async () => {
+test('sharp edge alerts require pregame rows and at least six books compared', async () => {
   const sentPayloads = [];
   const scanner = new MarketScanner({
     client: {
@@ -660,7 +660,7 @@ test('sharp edge alerts require pregame rows and at least five books compared',
       scanAlertChannelId: 'alerts',
       sharpEdgeAlertsEnabled: true,
       sharpEdgeAlertThreshold: 0.04,
-      sharpEdgeAlertMinBooks: 5,
+      sharpEdgeAlertMinBooks: 6,
       scanAlertCooldownMinutes: 0,
       staleBookAlertsEnabled: false,
       reverseAlertsEnabled: false,
@@ -716,7 +716,7 @@ test('sharp edge alerts require pregame rows and at least five books compared',
         sharpOddsInput: '+390',
         bestSoftOddsInput: '+500',
         edgeImpliedPct: 0.061,
-        booksCompared: 5,
+        booksCompared: 6,
         eventCommenceTime: '2099-04-08T00:00:00.000Z',
         entries: [],
       },
@@ -800,7 +800,7 @@ test('sharp analysis prefers Circa, then FanDuel, then BetMGM for sportsbook ref
       oddsInput: '300',
       impliedProbability: americanToImpliedProbability('300'),
     },
-  ]);
+  ], { scanMinBooks: 2 });
 
   assert.equal(rows.sharpRows.length, 2);
 
@@ -845,6 +845,62 @@ test('sharp analysis keeps sportsbook, dfs, and exchange comparisons in separate
       oddsInput: '+140',
       impliedProbability: americanToImpliedProbability('+140'),
     },
+    {
+      marketKey: 'judge-hit',
+      source: 'odds_api',
+      book: 'DraftKings',
+      lane: 'sportsbook',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '+142',
+      impliedProbability: americanToImpliedProbability('+142'),
+    },
+    {
+      marketKey: 'judge-hit',
+      source: 'odds_api',
+      book: 'BetMGM',
+      lane: 'sportsbook',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '+145',
+      impliedProbability: americanToImpliedProbability('+145'),
+    },
+    {
+      marketKey: 'judge-hit',
+      source: 'odds_api',
+      book: 'Caesars',
+      lane: 'sportsbook',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '+150',
+      impliedProbability: americanToImpliedProbability('+150'),
+    },
+    {
+      marketKey: 'judge-hit',
+      source: 'odds_api',
+      book: 'FanDuel',
+      lane: 'sportsbook',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '+155',
+      impliedProbability: americanToImpliedProbability('+155'),
+    },
     {
       marketKey: 'judge-hit',
       source: 'odds_api',
@@ -873,6 +929,34 @@ test('sharp analysis keeps sportsbook, dfs, and exchange comparisons in separate
       oddsInput: '+125',
       impliedProbability: americanToImpliedProbability('+125'),
     },
+    {
+      marketKey: 'judge-hit',
+      source: 'odds_api',
+      book: 'Betr Picks',
+      lane: 'dfs',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '+118',
+      impliedProbability: americanToImpliedProbability('+118'),
+    },
+    {
+      marketKey: 'judge-hit',
+      source: 'odds_api',
+      book: 'DraftKings Pick6',
+      lane: 'dfs',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '+132',
+      impliedProbability: americanToImpliedProbability('+132'),
+    },
     {
       marketKey: 'judge-hit',
       source: 'odds_api',
@@ -901,11 +985,40 @@ test('sharp analysis keeps sportsbook, dfs, and exchange comparisons in separate
       oddsInput: '+130',
       impliedProbability: americanToImpliedProbability('+130'),
     },
+    {
+      marketKey: 'judge-hit',
+      source: 'odds_api',
+      book: 'Polymarket',
+      lane: 'exchange',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '+128',
+      impliedProbability: americanToImpliedProbability('+128'),
+    },
+    {
+      marketKey: 'judge-hit',
+      source: 'odds_api',
+      book: 'ProphetX',
+      lane: 'exchange',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '+135',
+      impliedProbability: americanToImpliedProbability('+135'),
+    },
   ];
 
-  const sportsbookRows = analyzeSharpMarkets(entries, {}, { lane: 'sportsbook' });
-  const dfsRows = analyzeSharpMarkets(entries, {}, { lane: 'dfs' });
-  const exchangeRows = analyzeSharpMarkets(entries, {}, { lane: 'exchange' });
+  const config = { scanMinBooks: 6, dfsScanMinBooks: 4, exchangeScanMinBooks: 4 };
+  const sportsbookRows = analyzeSharpMarkets(entries, config, { lane: 'sportsbook' });
+  const dfsRows = analyzeSharpMarkets(entries, config, { lane: 'dfs' });
+  const exchangeRows = analyzeSharpMarkets(entries, config, { lane: 'exchange' });
 
   assert.equal(sportsbookRows.sharpRows.length, 1);
   assert.equal(sportsbookRows.sharpRows[0].sharpBook, 'Circa');
@@ -918,7 +1031,155 @@ test('sharp analysis keeps sportsbook, dfs, and exchange comparisons in separate
   assert.equal(exchangeRows.sharpRows.length, 1);
   assert.equal(exchangeRows.sharpRows[0].sharpBook, 'Exchange Consensus');
   assert.equal(exchangeRows.sharpRows[0].sharpSourceMode, 'exchange_consensus');
-  assert.equal(exchangeRows.sharpRows[0].bestSoftBook, 'Novig');
+  assert.equal(exchangeRows.sharpRows[0].bestSoftBook, 'ProphetX');
+});
+
+test('sharp analysis excludes rows below sportsbook, dfs, and exchange minimum book counts', () => {
+  const config = { scanMinBooks: 6, dfsScanMinBooks: 4, exchangeScanMinBooks: 4 };
+  const entries = [
+    {
+      marketKey: 'eligible-sportsbook',
+      source: 'circa',
+      book: 'Circa',
+      lane: 'sportsbook',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '+120',
+      impliedProbability: americanToImpliedProbability('+120'),
+    },
+    ...[
+      ['FanDuel', '+125'],
+      ['DraftKings', '+130'],
+      ['BetMGM', '+135'],
+      ['Caesars', '+140'],
+      ['Fanatics', '+145'],
+    ].map(([book, oddsInput]) => ({
+      marketKey: 'eligible-sportsbook',
+      source: 'odds_api',
+      book,
+      lane: 'sportsbook',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput,
+      impliedProbability: americanToImpliedProbability(oddsInput),
+    })),
+    ...[
+      ['Circa', '+150'],
+      ['FanDuel', '+155'],
+      ['DraftKings', '+160'],
+      ['BetMGM', '+165'],
+      ['Caesars', '+170'],
+    ].map(([book, oddsInput]) => ({
+      marketKey: 'thin-sportsbook',
+      source: book === 'Circa' ? 'circa' : 'odds_api',
+      book,
+      lane: 'sportsbook',
+      playerName: 'Juan Soto',
+      team: 'NYM',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput,
+      impliedProbability: americanToImpliedProbability(oddsInput),
+    })),
+    ...[
+      ['PrizePicks', '+110'],
+      ['Underdog Fantasy', '+115'],
+      ['Betr Picks', '+120'],
+      ['DraftKings Pick6', '+125'],
+    ].map(([book, oddsInput]) => ({
+      marketKey: 'eligible-dfs',
+      source: 'odds_api',
+      book,
+      lane: 'dfs',
+      playerName: 'Kyle Schwarber',
+      team: 'PHI',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput,
+      impliedProbability: americanToImpliedProbability(oddsInput),
+    })),
+    ...[
+      ['PrizePicks', '+110'],
+      ['Underdog Fantasy', '+115'],
+      ['Betr Picks', '+120'],
+    ].map(([book, oddsInput]) => ({
+      marketKey: 'thin-dfs',
+      source: 'odds_api',
+      book,
+      lane: 'dfs',
+      playerName: 'Bryce Harper',
+      team: 'PHI',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput,
+      impliedProbability: americanToImpliedProbability(oddsInput),
+    })),
+    ...[
+      ['Kalshi', '+110'],
+      ['Novig', '+115'],
+      ['Polymarket', '+120'],
+      ['ProphetX', '+125'],
+    ].map(([book, oddsInput]) => ({
+      marketKey: 'eligible-exchange',
+      source: 'odds_api',
+      book,
+      lane: 'exchange',
+      playerName: 'Mookie Betts',
+      team: 'LAD',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput,
+      impliedProbability: americanToImpliedProbability(oddsInput),
+    })),
+    ...[
+      ['Kalshi', '+110'],
+      ['Novig', '+115'],
+      ['Polymarket', '+120'],
+    ].map(([book, oddsInput]) => ({
+      marketKey: 'thin-exchange',
+      source: 'odds_api',
+      book,
+      lane: 'exchange',
+      playerName: 'Shohei Ohtani',
+      team: 'LAD',
+      marketType: 'batter_hits',
+      marketLabel: 'Hits',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput,
+      impliedProbability: americanToImpliedProbability(oddsInput),
+    })),
+  ];
+
+  const sportsbookRows = analyzeSharpMarkets(entries, config, { lane: 'sportsbook' });
+  const dfsRows = analyzeSharpMarkets(entries, config, { lane: 'dfs' });
+  const exchangeRows = analyzeSharpMarkets(entries, config, { lane: 'exchange' });
+
+  assert.deepEqual(sportsbookRows.sharpRows.map((row) => row.playerName), ['Aaron Judge']);
+  assert.deepEqual(dfsRows.sharpRows.map((row) => row.playerName), ['Kyle Schwarber']);
+  assert.deepEqual(exchangeRows.sharpRows.map((row) => row.playerName), ['Mookie Betts']);
+  assert.ok(sportsbookRows.sharpRows.every((row) => row.booksCompared >= 6));
+  assert.ok(dfsRows.sharpRows.every((row) => row.booksCompared >= 4));
+  assert.ok(exchangeRows.sharpRows.every((row) => row.booksCompared >= 4));
+  assert.ok(sportsbookRows.marketHealthRows.every((row) => row.averageBooksCompared >= 6));
+  assert.ok(dfsRows.marketHealthRows.every((row) => row.averageBooksCompared >= 4));
+  assert.ok(exchangeRows.marketHealthRows.every((row) => row.averageBooksCompared >= 4));
 });
 
 test('circa board reposts when a new same-day snapshot appears', async () => {