Add sharp market intelligence commands

src/commands.js

@@ -49,6 +49,96 @@ function addAnalyticsFilters(command, options = {}) {
   return command;
 }
 
+const MARKET_INTELLIGENCE_BOOK_CHOICES = [
+  { name: 'Circa', value: 'Circa' },
+  { name: 'FanDuel', value: 'FanDuel' },
+  { name: 'DraftKings', value: 'DraftKings' },
+  { name: 'BetMGM', value: 'BetMGM' },
+  { name: 'Caesars', value: 'Caesars' },
+];
+
+const MARKET_INTELLIGENCE_MARKET_CHOICES = [
+  { name: 'Home Runs', value: 'home_runs' },
+  { name: 'Hits', value: 'hits' },
+  { name: 'Total Bases', value: 'total_bases' },
+  { name: 'RBIs', value: 'rbis' },
+  { name: 'Runs', value: 'runs' },
+  { name: 'Steals', value: 'steals' },
+  { name: 'Hits + Runs + RBIs', value: 'hits_runs_rbis' },
+  { name: 'Pitcher Strikeouts', value: 'pitcher_strikeouts_generic' },
+];
+
+function addMarketIntelligenceFilters(command, options = {}) {
+  if (options.includeMarket !== false) {
+    command.addStringOption((option) =>
+      option
+        .setName('market')
+        .setDescription('Optional market filter.')
+        .setRequired(options.marketRequired === true)
+        .addChoices(...MARKET_INTELLIGENCE_MARKET_CHOICES)
+    );
+  }
+
+  if (options.includeBook) {
+    command.addStringOption((option) =>
+      option
+        .setName('book')
+        .setDescription('Optional book filter.')
+        .setRequired(options.bookRequired === true)
+        .addChoices(...MARKET_INTELLIGENCE_BOOK_CHOICES)
+    );
+  }
+
+  if (options.includeTeam) {
+    command.addStringOption((option) =>
+      option
+        .setName('team')
+        .setDescription('Optional team code filter, for example KCR or CHC.')
+        .setRequired(false)
+    );
+  }
+
+  if (options.includePlayer) {
+    command.addStringOption((option) =>
+      option
+        .setName('player')
+        .setDescription('Optional player filter.')
+        .setRequired(options.playerRequired === true)
+    );
+  }
+
+  if (options.includeMinEdge) {
+    command.addNumberOption((option) =>
+      option
+        .setName('min_edge')
+        .setDescription('Optional minimum sharp edge threshold as a decimal, for example 0.04 for 4%.')
+        .setRequired(false)
+    );
+  }
+
+  if (options.includeMinWidth) {
+    command.addNumberOption((option) =>
+      option
+        .setName('min_width')
+        .setDescription('Optional minimum market width threshold as a decimal, for example 0.05 for 5%.')
+        .setRequired(false)
+    );
+  }
+
+  if (options.includeLimit !== false) {
+    command.addIntegerOption((option) =>
+      option
+        .setName('limit')
+        .setDescription('Optional result limit.')
+        .setRequired(false)
+        .setMinValue(1)
+        .setMaxValue(25)
+    );
+  }
+
+  return command;
+}
+
 export const commands = [
   new SlashCommandBuilder()
     .setName('bet')
@@ -355,6 +445,60 @@ export const commands = [
         { name: 'Caesars', value: 'Caesars' }
       )
     ),
+  addMarketIntelligenceFilters(
+    new SlashCommandBuilder()
+      .setName('edgeboard')
+      .setDescription('Show the best current edges versus the sharp book.'),
+    { includeMarket: true, includeBook: true, includeTeam: true, includeMinEdge: true, includeLimit: true }
+  ),
+  addMarketIntelligenceFilters(
+    new SlashCommandBuilder()
+      .setName('playeredge')
+      .setDescription('Show sharp comparisons across all supported markets for one player.'),
+    { includePlayer: true, playerRequired: true, includeMarket: true, includeBook: true, includeMinEdge: true, includeLimit: true }
+  ),
+  addMarketIntelligenceFilters(
+    new SlashCommandBuilder()
+      .setName('marketedge')
+      .setDescription('Show the best current edges for one market.'),
+    { includeMarket: true, marketRequired: true, includeBook: true, includeTeam: true, includeMinEdge: true, includeLimit: true }
+  ),
+  addMarketIntelligenceFilters(
+    new SlashCommandBuilder()
+      .setName('widthboard')
+      .setDescription('Show the widest current market splits across books.'),
+    { includeMarket: true, includeBook: true, includeTeam: true, includeMinWidth: true, includeLimit: true }
+  ),
+  addMarketIntelligenceFilters(
+    new SlashCommandBuilder()
+      .setName('consensusvs')
+      .setDescription('Compare one book to the current sharp market.'),
+    { includeMarket: true, includeBook: true, bookRequired: true, includeTeam: true, includeMinEdge: true, includeLimit: true }
+  ),
+  addMarketIntelligenceFilters(
+    new SlashCommandBuilder()
+      .setName('steam')
+      .setDescription('Show recent price movement anchored to the current sharp market.'),
+    { includeMarket: true, includeBook: true, includeTeam: true, includePlayer: true, includeLimit: true }
+  ),
+  addMarketIntelligenceFilters(
+    new SlashCommandBuilder()
+      .setName('sharpboard')
+      .setDescription('Show the best current sharp-vs-soft values.'),
+    { includeMarket: true, includeBook: true, includeTeam: true, includeMinEdge: true, includeLimit: true }
+  ),
+  addMarketIntelligenceFilters(
+    new SlashCommandBuilder()
+      .setName('bookscoreboard')
+      .setDescription('Rank books by sharp mispricing count and size.'),
+    { includeMarket: true, includeBook: true, includeTeam: true, includeMinEdge: true, includeLimit: true }
+  ),
+  addMarketIntelligenceFilters(
+    new SlashCommandBuilder()
+      .setName('markethealth')
+      .setDescription('Show coverage and market quality by supported market.'),
+    { includeMarket: true, includeLimit: true }
+  ),
   new SlashCommandBuilder()
     .setName('alerts')
     .setDescription('Post the analyst alert-role embed to the welcome channel.'),

src/config.js

@@ -30,6 +30,13 @@ export function getConfig() {
   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 staleBookAlertThreshold = Number(process.env.STALE_BOOK_ALERT_THRESHOLD || 0.025);
+  const reverseAlertThreshold = Number(process.env.REVERSE_ALERT_THRESHOLD || 0.03);
+  const marketBoardDefaultLimit = Number(process.env.MARKET_BOARD_DEFAULT_LIMIT || 10);
+  const sharpEdgeAlertsEnabled = process.env.SHARP_EDGE_ALERTS_ENABLED?.trim() !== 'false';
+  const staleBookAlertsEnabled = process.env.STALE_BOOK_ALERTS_ENABLED?.trim() !== 'false';
+  const reverseAlertsEnabled = process.env.REVERSE_ALERTS_ENABLED?.trim() !== 'false';
   const circaChannelId = process.env.CIRCA_CHANNEL_ID?.trim() || null;
   const circaDailyTime = process.env.CIRCA_DAILY_TIME?.trim() || '09:30';
   const circaTimeZone = process.env.CIRCA_TIMEZONE?.trim() || 'America/Chicago';
@@ -83,6 +90,13 @@ export function getConfig() {
       scanFrequencyMinutes,
       scanHttpTimeoutMs,
       directOddsCacheTtlMs,
+      sharpEdgeAlertThreshold,
+      staleBookAlertThreshold,
+      reverseAlertThreshold,
+      marketBoardDefaultLimit,
+      sharpEdgeAlertsEnabled,
+      staleBookAlertsEnabled,
+      reverseAlertsEnabled,
       circaChannelId,
       circaDailyTime,
       circaTimeZone,

src/db.js

@@ -772,6 +772,95 @@ export class BetStore {
     }
   }
 
+  async getScanRunById(scanRunId) {
+    const { rows } = await this.pool.query(
+      `
+        SELECT *
+        FROM scan_runs
+        WHERE id = $1
+        LIMIT 1
+      `,
+      [scanRunId]
+    );
+
+    if (!rows[0]) {
+      return null;
+    }
+
+    const run = rows[0];
+    const entriesResult = await this.pool.query(
+      `
+        SELECT *
+        FROM scan_markets
+        WHERE scan_run_id = $1
+        ORDER BY player_name, market_type, side, line_value NULLS FIRST, book
+      `,
+      [scanRunId]
+    );
+
+    return {
+      id: Number(run.id),
+      scanType: run.scan_type,
+      status: run.status,
+      entryCount: Number(run.entry_count ?? 0),
+      createdAt: run.created_at?.toISOString?.() ?? String(run.created_at),
+      errorText: run.error_text ?? null,
+      entries: entriesResult.rows.map((entry) => ({
+        marketKey: entry.market_key,
+        source: entry.source,
+        book: entry.book,
+        eventName: entry.event_name,
+        playerName: entry.player_name,
+        marketType: entry.market_type,
+        marketLabel: entry.market_label,
+        side: entry.side,
+        lineValue: numberOrNull(entry.line_value),
+        oddsInput: entry.odds_input,
+        impliedProbability: Number(entry.implied_probability),
+        rawLabel: entry.raw_label ?? null,
+      })),
+    };
+  }
+
+  async getLatestScanRun(scanType = null) {
+    const { rows } = await this.pool.query(
+      `
+        SELECT id
+        FROM scan_runs
+        ${scanType ? 'WHERE scan_type = $1' : ''}
+        ORDER BY created_at DESC, id DESC
+        LIMIT 1
+      `,
+      scanType ? [scanType] : []
+    );
+
+    if (!rows[0]) {
+      return null;
+    }
+
+    return this.getScanRunById(Number(rows[0].id));
+  }
+
+  async getPreviousScanRun(scanRunId, scanType = null) {
+    const { rows } = await this.pool.query(
+      `
+        SELECT id
+        FROM scan_runs
+        WHERE id < $1
+        ${scanType ? 'AND scan_type = $2' : ''}
+        ORDER BY id DESC
+        LIMIT 1
+      `,
+      scanType ? [scanRunId, scanType] : [scanRunId]
+    );
+
+    if (!rows[0]) {
+      return null;
+    }
+
+    return this.getScanRunById(Number(rows[0].id));
+  }
+
   async hasScanReport(reportDate, reportType) {
     const { rows } = await this.pool.query(
       `

src/embeds.js

@@ -307,6 +307,7 @@ export function buildCommandsEmbed() {
       { name: '/oddsquota', value: 'Show live Odds API quota usage headers. Admin only.' },
       { name: '/scanrun', value: 'Run the market scanner manually. Admin only.' },
       { name: '/scanreport', value: 'Post the morning scan reports immediately. Admin only.' },
+      { name: 'Sharp Market Commands', value: '`/edgeboard`, `/playeredge`, `/marketedge`, `/widthboard`, `/consensusvs`, `/steam`, `/sharpboard`, `/bookscoreboard`, `/markethealth` surface Circa-first market value and quality views.' },
       { name: '/hrodds', value: 'Show live Home Run odds for one player across Caesars, BetMGM, and Circa, or filter to one book.' },
       { name: 'Other Odds Commands', value: '`/hitodds`, `/tbodds`, `/rbiodds`, `/runodds`, `/sbodds`, `/kodds` show live player odds across books.' },
       { name: '/circatest', value: 'Run a Circa OCR diagnostic preview. Admin only.' },
@@ -524,6 +525,200 @@ export function buildMarketTopEmbed(title, rows, options = {}) {
   return embed;
 }
 
+export function buildSharpEdgeBoardEmbed(title, rows, filters = {}) {
+  const embed = new EmbedBuilder()
+    .setColor(PALETTE.primary)
+    .setTitle(title)
+    .setDescription(buildFilterBanner(filters, 'Best current soft-book prices versus the sharp market.'));
+
+  if (!rows.length) {
+    return embed.addFields({ name: 'No rows', value: 'No sharp-comparison rows matched the current filters.' });
+  }
+
+  embed.addFields(
+    rows.map((row, index) => ({
+      name: `${index + 1}. ${row.playerName} - ${row.marketLabel}`,
+      value: [
+        `Sharp: ${row.sharpBook} @ ${row.sharpOddsInput} | Best Soft: ${row.bestSoftBook} @ ${row.bestSoftOddsInput}`,
+        `Edge: ${formatPercent(row.edgeImpliedPct * 100)} | Width: ${formatPercent(row.marketWidthPct * 100)}`,
+        `Books: ${row.booksCompared} | Status: ${row.sharpSourceMode === 'circa' ? 'Circa' : 'BetMGM fallback'}`,
+      ].join('\n'),
+      inline: false,
+    }))
+  );
+
+  return embed;
+}
+
+export function buildPlayerEdgeEmbed({ playerName, rows }, filters = {}) {
+  const embed = new EmbedBuilder()
+    .setColor(PALETTE.primary)
+    .setTitle('Player Edge')
+    .setDescription(buildFilterBanner(filters, `Current sharp comparisons for **${playerName}**.`));
+
+  if (!rows.length) {
+    return embed.addFields({ name: 'No rows', value: 'No sharp comparisons were found for that player.' });
+  }
+
+  embed.addFields(
+    rows.map((row) => ({
+      name: row.marketLabel,
+      value: [
+        `Sharp: ${row.sharpBook} @ ${row.sharpOddsInput} | Best Soft: ${row.bestSoftBook} @ ${row.bestSoftOddsInput}`,
+        `Edge: ${formatPercent(row.edgeImpliedPct * 100)} | Width: ${formatPercent(row.marketWidthPct * 100)}`,
+      ].join('\n'),
+      inline: false,
+    }))
+  );
+
+  return embed;
+}
+
+export function buildConsensusVsEmbed({ summary, rows }, filters = {}) {
+  const embed = new EmbedBuilder()
+    .setColor(PALETTE.secondary)
+    .setTitle(`Consensus Vs ${summary.book}`)
+    .setDescription(buildFilterBanner(filters, 'How this book compares to the current sharp market.'));
+
+  embed.addFields(
+    { name: 'Compared Rows', value: String(summary.comparedRows), inline: true },
+    { name: 'Positive Edges', value: String(summary.betterThanSharpCount), inline: true },
+    { name: 'Average Edge', value: formatPercent(summary.averageEdgePct * 100), inline: true },
+  );
+
+  if (!rows.length) {
+    return embed.addFields({ name: 'No rows', value: 'No sharp comparison rows matched this book and filter set.' });
+  }
+
+  embed.addFields(
+    rows.slice(0, 10).map((row, index) => ({
+      name: `${index + 1}. ${row.playerName} - ${row.marketLabel}`,
+      value: [
+        `Sharp: ${row.sharpBook} @ ${row.sharpOddsInput} | ${summary.book}: ${row.compareOddsInput}`,
+        `Edge: ${formatPercent(row.compareEdgePct * 100)} | Width: ${formatPercent(row.marketWidthPct * 100)}`,
+      ].join('\n'),
+      inline: false,
+    }))
+  );
+
+  return embed;
+}
+
+export function buildBookScoreboardEmbed(title, rows, filters = {}) {
+  const embed = new EmbedBuilder()
+    .setColor(PALETTE.primary)
+    .setTitle(title)
+    .setDescription(buildFilterBanner(filters, 'Books ranked by how often and how far they differ from sharp.'));
+
+  if (!rows.length) {
+    return embed.addFields({ name: 'No rows', value: 'No book comparison rows matched the current filters.' });
+  }
+
+  embed.addFields(
+    rows.map((row, index) => ({
+      name: `${index + 1}. ${row.book}`,
+      value: [
+        `Positive Edges: ${row.positiveEdges} / ${row.comparedRows}`,
+        `Avg Edge: ${formatPercent(row.averageEdgePct * 100)} | Max Edge: ${formatPercent(row.maxEdgePct * 100)}`,
+        `Avg Width: ${formatPercent(row.averageWidthPct * 100)}`,
+      ].join('\n'),
+      inline: false,
+    }))
+  );
+
+  return embed;
+}
+
+export function buildMarketHealthEmbed(title, rows, filters = {}) {
+  const embed = new EmbedBuilder()
+    .setColor(PALETTE.secondary)
+    .setTitle(title)
+    .setDescription(buildFilterBanner(filters, 'Coverage and quality snapshot across supported sharp markets.'));
+
+  if (!rows.length) {
+    return embed.addFields({ name: 'No rows', value: 'No market health rows matched the current filters.' });
+  }
+
+  embed.addFields(
+    rows.map((row, index) => ({
+      name: `${index + 1}. ${row.marketLabel}`,
+      value: [
+        `Rows: ${row.rows} | Avg Books: ${row.averageBooksCompared.toFixed(2)}`,
+        `Avg Width: ${formatPercent(row.averageWidthPct * 100)}`,
+        `Sharp Source: Circa ${row.circaRows} | MGM fallback ${row.mgmFallbackRows}`,
+      ].join('\n'),
+      inline: false,
+    }))
+  );
+
+  return embed;
+}
+
+export function buildSteamEmbed(title, rows, filters = {}) {
+  const embed = new EmbedBuilder()
+    .setColor(PALETTE.info)
+    .setTitle(title)
+    .setDescription(buildFilterBanner(filters, 'Recent movement compared to the prior stored scan snapshot.'));
+
+  if (!rows.length) {
+    return embed.addFields({ name: 'No rows', value: 'No tracked price movement matched the current filters.' });
+  }
+
+  embed.addFields(
+    rows.map((row, index) => ({
+      name: `${index + 1}. ${row.playerName} - ${row.marketLabel}`,
+      value: [
+        `Moved Book: ${row.movedBook} | ${row.oldOddsInput} -> ${row.newOddsInput}`,
+        `Sharp: ${row.sharpBook} @ ${row.sharpOddsInput} | Delta: ${formatPercent(row.impliedDeltaPct * 100)}`,
+      ].join('\n'),
+      inline: false,
+    }))
+  );
+
+  return embed;
+}
+
+export function buildSharpAlertEmbed(row) {
+  return new EmbedBuilder()
+    .setColor(PALETTE.red)
+    .setTitle('Sharp Edge Alert')
+    .setDescription(`${row.playerName} - ${row.marketLabel}`)
+    .addFields(
+      { name: 'Sharp', value: `${row.sharpBook} @ ${row.sharpOddsInput}`, inline: true },
+      { name: 'Best Soft', value: `${row.bestSoftBook} @ ${row.bestSoftOddsInput}`, inline: true },
+      { name: 'Edge', value: formatPercent(row.edgeImpliedPct * 100), inline: true },
+      { name: 'Width', value: formatPercent(row.marketWidthPct * 100), inline: true },
+      { name: 'Books Compared', value: String(row.booksCompared), inline: true },
+      { name: 'Sharp Source', value: row.sharpSourceMode === 'circa' ? 'Circa' : 'BetMGM fallback', inline: true },
+    );
+}
+
+export function buildStaleBookAlertEmbed(row, staleEntry) {
+  return new EmbedBuilder()
+    .setColor(PALETTE.red)
+    .setTitle('Stale Book Alert')
+    .setDescription(`${row.playerName} - ${row.marketLabel}`)
+    .addFields(
+      { name: 'Sharp', value: `${row.sharpBook} @ ${row.sharpOddsInput}`, inline: true },
+      { name: 'Stale Book', value: `${staleEntry.book} @ ${staleEntry.oddsInput}`, inline: true },
+      { name: 'Current Edge', value: formatPercent(((row.sharpImpliedProbability ?? 0) - (staleEntry.impliedProbability ?? 0)) * 100), inline: true },
+    )
+    .setFooter({ text: 'Sharp and at least one other book moved, but this book did not.' });
+}
+
+export function buildReverseAlertEmbed(row, movement) {
+  return new EmbedBuilder()
+    .setColor(PALETTE.muted)
+    .setTitle('Reverse Alert')
+    .setDescription(`${row.playerName} - ${row.marketLabel}`)
+    .addFields(
+      { name: 'Sharp', value: `${row.sharpBook} @ ${row.sharpOddsInput}`, inline: true },
+      { name: 'Soft Move', value: `${movement.book} ${movement.previousEntry.oddsInput} -> ${movement.currentEntry.oddsInput}`, inline: true },
+      { name: 'Move Size', value: formatPercent(movement.impliedDeltaPct * 100), inline: true },
+    )
+    .setFooter({ text: 'A soft book moved materially while the sharp book stayed flat.' });
+}
+
 export function buildCircaAlertEmbed(alert) {
   return new EmbedBuilder()
     .setColor(PALETTE.red)
@@ -811,18 +1006,33 @@ function truncate(value, maxLength) {
 
 function buildFilterBanner(filters, baseText) {
   const labels = [];
+  if (filters.market) {
+    labels.push(filters.market);
+  }
   if (filters.dateWindow && filters.dateWindow !== 'all') {
     labels.push(filters.dateWindow.toUpperCase());
   }
   if (filters.book) {
     labels.push(filters.book);
   }
+  if (filters.team) {
+    labels.push(filters.team.toUpperCase());
+  }
+  if (filters.player) {
+    labels.push(filters.player);
+  }
   if (filters.sport) {
     labels.push(filters.sport);
   }
   if (filters.status) {
     labels.push(filters.status.toUpperCase());
   }
+  if (filters.minEdge !== undefined && filters.minEdge !== null) {
+    labels.push(`MIN EDGE ${Number(filters.minEdge)}`);
+  }
+  if (filters.minWidth !== undefined && filters.minWidth !== null) {
+    labels.push(`MIN WIDTH ${Number(filters.minWidth)}`);
+  }
 
   if (labels.length === 0) {
     return baseText;

src/index.js

@@ -38,6 +38,15 @@ import {
   buildCircaFailureEmbed,
   buildCircaMarketEmbeds,
   buildCircaMovementEmbed,
+  buildSharpAlertEmbed,
+  buildSharpEdgeBoardEmbed,
+  buildBookScoreboardEmbed,
+  buildMarketHealthEmbed,
+  buildPlayerEdgeEmbed,
+  buildConsensusVsEmbed,
+  buildSteamEmbed,
+  buildStaleBookAlertEmbed,
+  buildReverseAlertEmbed,
   buildPlayerOddsEmbed,
   buildOddsApiQuotaEmbed,
   buildCircaPaginationRow,
@@ -95,6 +104,12 @@ async function main() {
       buildCircaFailureEmbed,
       buildCircaMarketEmbeds,
       buildCircaMovementEmbed,
+      buildSharpAlertEmbed,
+      buildSharpEdgeBoardEmbed,
+      buildBookScoreboardEmbed,
+      buildMarketHealthEmbed,
+      buildStaleBookAlertEmbed,
+      buildReverseAlertEmbed,
     },
     logger: console,
   });
@@ -372,6 +387,51 @@ async function handleChatInput(interaction, store, config) {
     return;
   }
 
+  if (commandName === 'edgeboard') {
+    await handleSharpBoard(interaction, config, 'edgeboard');
+    return;
+  }
+
+  if (commandName === 'playeredge') {
+    await handleSharpBoard(interaction, config, 'playeredge');
+    return;
+  }
+
+  if (commandName === 'marketedge') {
+    await handleSharpBoard(interaction, config, 'marketedge');
+    return;
+  }
+
+  if (commandName === 'widthboard') {
+    await handleSharpBoard(interaction, config, 'widthboard');
+    return;
+  }
+
+  if (commandName === 'consensusvs') {
+    await handleSharpBoard(interaction, config, 'consensusvs');
+    return;
+  }
+
+  if (commandName === 'steam') {
+    await handleSharpBoard(interaction, config, 'steam');
+    return;
+  }
+
+  if (commandName === 'sharpboard') {
+    await handleSharpBoard(interaction, config, 'sharpboard');
+    return;
+  }
+
+  if (commandName === 'bookscoreboard') {
+    await handleSharpBoard(interaction, config, 'bookscoreboard');
+    return;
+  }
+
+  if (commandName === 'markethealth') {
+    await handleSharpBoard(interaction, config, 'markethealth');
+    return;
+  }
+
   if (commandName === 'alerts') {
     await handleAlerts(interaction);
     return;
@@ -391,6 +451,18 @@ function getAnalyticsFilters(interaction) {
   };
 }
 
+function getMarketIntelligenceFilters(interaction) {
+  return {
+    market: interaction.options.getString('market') ?? undefined,
+    book: interaction.options.getString('book') ?? undefined,
+    team: interaction.options.getString('team') ?? undefined,
+    player: interaction.options.getString('player') ?? undefined,
+    minEdge: interaction.options.getNumber('min_edge') ?? undefined,
+    minWidth: interaction.options.getNumber('min_width') ?? undefined,
+    limit: interaction.options.getInteger('limit') ?? undefined,
+  };
+}
+
 async function showBetModal(interaction) {
   const selectedBook = interaction.options.getString('book', true);
   const selectedSport = interaction.options.getString('sport', true);
@@ -1119,6 +1191,87 @@ async function handlePlayerOdds(interaction, config, marketType) {
   }
 }
 
+async function handleSharpBoard(interaction, config, commandName) {
+  await interaction.deferReply();
+
+  const scanner = interaction.client.__marketScanner;
+  if (!scanner?.getStatus().oddsWorkflowEnabled) {
+    await interaction.editReply({
+      embeds: [buildErrorEmbed('Sharp lookup disabled', 'Set the Odds API environment variables before using these market-awareness commands.')],
+    });
+    return;
+  }
+
+  const filters = getMarketIntelligenceFilters(interaction);
+
+  try {
+    if (commandName === 'edgeboard') {
+      const result = await scanner.getEdgeBoard(filters);
+      await interaction.editReply({ embeds: [buildSharpEdgeBoardEmbed('Edge Board', result.rows, filters)] });
+      return;
+    }
+
+    if (commandName === 'sharpboard') {
+      const result = await scanner.getSharpBoard(filters);
+      await interaction.editReply({ embeds: [buildSharpEdgeBoardEmbed('Sharp Board', result.rows, filters)] });
+      return;
+    }
+
+    if (commandName === 'marketedge') {
+      const market = interaction.options.getString('market', true);
+      const result = await scanner.getMarketEdge(market, filters);
+      await interaction.editReply({ embeds: [buildSharpEdgeBoardEmbed('Market Edge', result.rows, filters)] });
+      return;
+    }
+
+    if (commandName === 'widthboard') {
+      const result = await scanner.getWidthBoard(filters);
+      await interaction.editReply({ embeds: [buildSharpEdgeBoardEmbed('Width Board', result.rows, filters)] });
+      return;
+    }
+
+    if (commandName === 'playeredge') {
+      const player = interaction.options.getString('player', true);
+      const result = await scanner.getPlayerEdge(player, filters);
+      await interaction.editReply({ embeds: [buildPlayerEdgeEmbed({ playerName: player, rows: result.rows }, filters)] });
+      return;
+    }
+
+    if (commandName === 'consensusvs') {
+      const book = interaction.options.getString('book', true);
+      const result = await scanner.getConsensusVsBook(book, filters);
+      await interaction.editReply({ embeds: [buildConsensusVsEmbed(result, filters)] });
+      return;
+    }
+
+    if (commandName === 'bookscoreboard') {
+      const result = await scanner.getBookScoreboard(filters);
+      await interaction.editReply({ embeds: [buildBookScoreboardEmbed('Book Scoreboard', result.rows, filters)] });
+      return;
+    }
+
+    if (commandName === 'markethealth') {
+      const result = await scanner.getMarketHealth(filters);
+      await interaction.editReply({ embeds: [buildMarketHealthEmbed('Market Health', result.rows, filters)] });
+      return;
+    }
+
+    if (commandName === 'steam') {
+      const result = await scanner.getSteamBoard(filters);
+      await interaction.editReply({ embeds: [buildSteamEmbed('Steam', result.rows, filters)] });
+      return;
+    }
+
+    await interaction.editReply({
+      embeds: [buildErrorEmbed('Command unavailable', 'That sharp market command is not wired up yet.')],
+    });
+  } catch (error) {
+    await interaction.editReply({
+      embeds: [buildErrorEmbed('Sharp view unavailable', error.message || 'The sharp market lookup hit an unexpected error.')],
+    });
+  }
+}
+
 async function handleButton(interaction, store) {
   const alertRoleName = parseAlertRoleButtonId(interaction.customId);
   if (alertRoleName) {

src/market-scanner.js

@@ -2084,6 +2084,310 @@ export function analyzeMarkets(entries, config = {}) {
   };
 }
 
+function normalizeSharpMarketType(marketType) {
+  return normalizeCircaMarketType(marketType);
+}
+
+function buildSharpComparisonKey(entry) {
+  return [
+    normalizePlayerName(entry.playerName),
+    normalizeSharpMarketType(entry.marketType),
+    entry.side || 'yes',
+    entry.lineValue ?? 'na',
+  ].join('|');
+}
+
+function collapseEntriesByBook(entries = []) {
+  const byBook = new Map();
+  for (const entry of entries) {
+    const book = normalizeBookFilter(entry.book) ?? entry.book ?? 'Unknown book';
+    const current = byBook.get(book);
+    if (!current || (entry.impliedProbability ?? Number.MAX_SAFE_INTEGER) < (current.impliedProbability ?? Number.MAX_SAFE_INTEGER)) {
+      byBook.set(book, {
+        ...entry,
+        book,
+      });
+    }
+  }
+  return [...byBook.values()];
+}
+
+function filterSharpRows(rows = [], filters = {}) {
+  const normalizedBook = filters.book ? normalizeBookFilter(filters.book) : null;
+  const normalizedMarket = filters.market ? normalizeSharpMarketType(filters.market) : null;
+  const normalizedTeam = filters.team ? normalizeWhitespace(filters.team).toUpperCase() : null;
+  const normalizedPlayer = filters.player ? normalizePlayerName(filters.player) : null;
+  const minEdge = filters.minEdge !== undefined && filters.minEdge !== null ? Number(filters.minEdge) : null;
+  const minWidth = filters.minWidth !== undefined && filters.minWidth !== null ? Number(filters.minWidth) : null;
+
+  return rows.filter((row) => {
+    if (normalizedBook && normalizeBookFilter(row.bestSoftBook) !== normalizedBook && normalizeBookFilter(row.sharpBook) !== normalizedBook) {
+      return false;
+    }
+    if (normalizedMarket && normalizeSharpMarketType(row.marketType) !== normalizedMarket) {
+      return false;
+    }
+    if (normalizedTeam && normalizeWhitespace(row.team ?? '').toUpperCase() !== normalizedTeam) {
+      return false;
+    }
+    if (normalizedPlayer && normalizePlayerName(row.playerName) !== normalizedPlayer) {
+      return false;
+    }
+    if (minEdge !== null && !(row.edgeImpliedPct >= minEdge)) {
+      return false;
+    }
+    if (minWidth !== null && !(row.marketWidthPct >= minWidth)) {
+      return false;
+    }
+    return true;
+  });
+}
+
+function applyResultLimit(rows = [], limit) {
+  const numericLimit = Number(limit);
+  if (!Number.isFinite(numericLimit) || numericLimit <= 0) {
+    return rows;
+  }
+  return rows.slice(0, numericLimit);
+}
+
+export function analyzeSharpMarkets(entries, config = {}) {
+  const grouped = new Map();
+
+  for (const entry of entries) {
+    const key = buildSharpComparisonKey(entry);
+    if (!grouped.has(key)) {
+      grouped.set(key, []);
+    }
+    grouped.get(key).push(entry);
+  }
+
+  const sharpRows = [];
+  const groupedState = new Map();
+
+  for (const [comparisonKey, groupEntries] of grouped.entries()) {
+    const uniqueEntries = collapseEntriesByBook(groupEntries);
+    const sharpEntry = uniqueEntries.find((entry) => normalizeBookFilter(entry.book) === 'Circa')
+      ?? uniqueEntries.find((entry) => normalizeBookFilter(entry.book) === 'BetMGM');
+
+    if (!sharpEntry) {
+      continue;
+    }
+
+    const softEntries = uniqueEntries.filter((entry) => normalizeBookFilter(entry.book) !== normalizeBookFilter(sharpEntry.book));
+    if (softEntries.length === 0) {
+      continue;
+    }
+
+    const bestSoftEntry = softEntries.reduce((best, entry) =>
+      (entry.impliedProbability ?? Number.MAX_SAFE_INTEGER) < (best.impliedProbability ?? Number.MAX_SAFE_INTEGER) ? entry : best,
+    softEntries[0]);
+
+    const allImplied = uniqueEntries.map((entry) => entry.impliedProbability).filter((value) => value !== null && value !== undefined);
+    const marketWidth = allImplied.length > 1 ? Math.max(...allImplied) - Math.min(...allImplied) : 0;
+    const edgeImplied = (sharpEntry.impliedProbability ?? 0) - (bestSoftEntry.impliedProbability ?? 0);
+
+    const row = {
+      comparisonKey,
+      marketKey: sharpEntry.marketKey,
+      playerName: sharpEntry.playerName,
+      playerKey: normalizePlayerName(sharpEntry.playerName),
+      team: sharpEntry.team ?? bestSoftEntry.team ?? null,
+      marketType: normalizeSharpMarketType(sharpEntry.marketType),
+      marketLabel: MARKET_TYPE_LABELS[normalizeSharpMarketType(sharpEntry.marketType)] ?? sharpEntry.marketLabel,
+      side: sharpEntry.side,
+      lineValue: sharpEntry.lineValue ?? null,
+      sharpBook: normalizeBookFilter(sharpEntry.book) ?? sharpEntry.book,
+      sharpOddsInput: sharpEntry.oddsInput,
+      sharpImpliedProbability: sharpEntry.impliedProbability,
+      sharpSourceMode: normalizeBookFilter(sharpEntry.book) === 'Circa' ? 'circa' : 'mgm_fallback',
+      bestSoftBook: normalizeBookFilter(bestSoftEntry.book) ?? bestSoftEntry.book,
+      bestSoftOddsInput: bestSoftEntry.oddsInput,
+      bestSoftImpliedProbability: bestSoftEntry.impliedProbability,
+      edgeImpliedPct: Number(edgeImplied.toFixed(6)),
+      priceDeltaCents: (americanOddsToNumber(bestSoftEntry.oddsInput) ?? 0) - (americanOddsToNumber(sharpEntry.oddsInput) ?? 0),
+      marketWidthPct: Number(marketWidth.toFixed(6)),
+      booksCompared: uniqueEntries.length,
+      marketStatus: normalizeBookFilter(sharpEntry.book) === 'Circa' ? 'circa' : 'mgm_fallback',
+      eventName: sharpEntry.eventName ?? bestSoftEntry.eventName ?? null,
+      entries: uniqueEntries,
+      softEntries,
+    };
+
+    sharpRows.push(row);
+    groupedState.set(comparisonKey, {
+      comparisonKey,
+      sharpRow: row,
+      entries: uniqueEntries,
+      sharpEntry,
+      softEntries,
+      bestSoftEntry,
+    });
+  }
+
+  const edgeRows = sharpRows
+    .filter((row) => row.edgeImpliedPct > 0)
+    .sort((left, right) => right.edgeImpliedPct - left.edgeImpliedPct || right.marketWidthPct - left.marketWidthPct);
+
+  const widthRows = [...sharpRows]
+    .sort((left, right) => right.marketWidthPct - left.marketWidthPct || right.edgeImpliedPct - left.edgeImpliedPct);
+
+  const marketHealth = [...sharpRows]
+    .reduce((map, row) => {
+      const key = row.marketType;
+      if (!map.has(key)) {
+        map.set(key, {
+          marketType: key,
+          marketLabel: row.marketLabel,
+          rows: 0,
+          sharpCoverage: 0,
+          widthTotal: 0,
+          booksTotal: 0,
+          circaRows: 0,
+          mgmFallbackRows: 0,
+        });
+      }
+      const current = map.get(key);
+      current.rows += 1;
+      current.sharpCoverage += 1;
+      current.widthTotal += row.marketWidthPct;
+      current.booksTotal += row.booksCompared;
+      if (row.sharpSourceMode === 'circa') {
+        current.circaRows += 1;
+      } else {
+        current.mgmFallbackRows += 1;
+      }
+      return map;
+    }, new Map());
+
+  const marketHealthRows = [...marketHealth.values()]
+    .map((row) => ({
+      ...row,
+      averageWidthPct: row.rows > 0 ? row.widthTotal / row.rows : 0,
+      averageBooksCompared: row.rows > 0 ? row.booksTotal / row.rows : 0,
+    }))
+    .sort((left, right) => right.sharpCoverage - left.sharpCoverage || right.averageBooksCompared - left.averageBooksCompared);
+
+  return {
+    sharpRows,
+    edgeRows,
+    widthRows,
+    marketHealthRows,
+    groupedState,
+  };
+}
+
+function summarizeBookVsSharp(rows, targetBook) {
+  const normalizedTargetBook = normalizeBookFilter(targetBook);
+  const comparisons = [];
+
+  for (const row of rows) {
+    const targetEntry = row.entries.find((entry) => normalizeBookFilter(entry.book) === normalizedTargetBook);
+    if (!targetEntry) {
+      continue;
+    }
+    comparisons.push({
+      ...row,
+      compareBook: normalizedTargetBook,
+      compareOddsInput: targetEntry.oddsInput,
+      compareImpliedProbability: targetEntry.impliedProbability,
+      compareEdgePct: Number(((row.sharpImpliedProbability ?? 0) - (targetEntry.impliedProbability ?? 0)).toFixed(6)),
+      comparePriceDeltaCents: (americanOddsToNumber(targetEntry.oddsInput) ?? 0) - (americanOddsToNumber(row.sharpOddsInput) ?? 0),
+    });
+  }
+
+  const summary = {
+    book: normalizedTargetBook,
+    comparedRows: comparisons.length,
+    betterThanSharpCount: comparisons.filter((row) => row.compareEdgePct > 0).length,
+    averageEdgePct: comparisons.length > 0
+      ? comparisons.reduce((sum, row) => sum + row.compareEdgePct, 0) / comparisons.length
+      : 0,
+    maxEdgePct: comparisons.length > 0
+      ? Math.max(...comparisons.map((row) => row.compareEdgePct))
+      : 0,
+  };
+
+  comparisons.sort((left, right) => right.compareEdgePct - left.compareEdgePct || right.marketWidthPct - left.marketWidthPct);
+  return {
+    summary,
+    rows: comparisons,
+  };
+}
+
+function summarizeBooksFromSharpRows(rows) {
+  const grouped = new Map();
+
+  for (const row of rows) {
+    for (const entry of row.softEntries) {
+      const book = normalizeBookFilter(entry.book) ?? entry.book;
+      if (!grouped.has(book)) {
+        grouped.set(book, {
+          book,
+          comparedRows: 0,
+          positiveEdges: 0,
+          totalEdgePct: 0,
+          maxEdgePct: 0,
+          averageWidthPct: 0,
+          totalWidthPct: 0,
+        });
+      }
+
+      const current = grouped.get(book);
+      const edgePct = Number(((row.sharpImpliedProbability ?? 0) - (entry.impliedProbability ?? 0)).toFixed(6));
+      current.comparedRows += 1;
+      current.totalEdgePct += edgePct;
+      current.totalWidthPct += row.marketWidthPct;
+      if (edgePct > 0) {
+        current.positiveEdges += 1;
+      }
+      if (edgePct > current.maxEdgePct) {
+        current.maxEdgePct = edgePct;
+      }
+    }
+  }
+
+  return [...grouped.values()]
+    .map((row) => ({
+      ...row,
+      averageEdgePct: row.comparedRows > 0 ? row.totalEdgePct / row.comparedRows : 0,
+      averageWidthPct: row.comparedRows > 0 ? row.totalWidthPct / row.comparedRows : 0,
+    }))
+    .sort((left, right) => right.positiveEdges - left.positiveEdges || right.maxEdgePct - left.maxEdgePct);
+}
+
+function buildSharpAlertKey(prefix, row, book = null) {
+  return [
+    prefix,
+    row.comparisonKey,
+    normalizeBookFilter(row.sharpBook) ?? row.sharpBook,
+    book ? normalizeBookFilter(book) ?? book : 'na',
+    row.sharpOddsInput,
+    row.bestSoftOddsInput ?? 'na',
+  ].join('|');
+}
+
+function buildSharpMovements(currentEntries, previousEntries) {
+  const previousByBook = new Map(previousEntries.map((entry) => [normalizeBookFilter(entry.book) ?? entry.book, entry]));
+  const currentByBook = new Map(currentEntries.map((entry) => [normalizeBookFilter(entry.book) ?? entry.book, entry]));
+  const movements = [];
+
+  for (const [book, currentEntry] of currentByBook.entries()) {
+    const previousEntry = previousByBook.get(book);
+    if (!previousEntry || previousEntry.oddsInput === currentEntry.oddsInput) {
+      continue;
+    }
+    movements.push({
+      book,
+      currentEntry,
+      previousEntry,
+      impliedDeltaPct: ((currentEntry.impliedProbability ?? 0) - (previousEntry.impliedProbability ?? 0)),
+    });
+  }
+
+  return movements;
+}
+
 function normalizeCircaFilename(name) {
   return normalizeWhitespace(String(name ?? ''))
     .replace(/[\u200B-\u200D\uFEFF]/g, '')
@@ -3461,6 +3765,155 @@ export class MarketScanner {
     };
   }
 
+  async getCurrentSharpAnalysis(options = {}) {
+    const requestedMarkets = Array.isArray(options.oddsApiMarkets) && options.oddsApiMarkets.length > 0
+      ? options.oddsApiMarkets
+      : this.config.oddsApiMarkets;
+    const [oddsEntries, circaSnapshot] = await Promise.all([
+      this.getDirectOddsEntries(requestedMarkets),
+      this.getCircaSnapshotForAnalysis().catch(() => null),
+    ]);
+    const circaEntries = circaSnapshot?.entries ?? [];
+    const allEntries = [...oddsEntries, ...circaEntries];
+    const legacy = analyzeMarkets(allEntries, {
+      minBooks: this.config.scanMinBooks,
+      disagreementThreshold: this.config.scanDisagreementThreshold,
+    });
+    const sharp = analyzeSharpMarkets(allEntries, this.config);
+    return {
+      ...legacy,
+      ...sharp,
+      allEntries,
+      oddsEntries,
+      circaSnapshot,
+    };
+  }
+
+  async getSharpBoard(filters = {}) {
+    const analysis = await this.getCurrentSharpAnalysis();
+    return {
+      title: 'Sharp Board',
+      rows: applyResultLimit(filterSharpRows(analysis.edgeRows, filters), filters.limit ?? this.config.marketBoardDefaultLimit),
+      analysis,
+    };
+  }
+
+  async getEdgeBoard(filters = {}) {
+    const analysis = await this.getCurrentSharpAnalysis();
+    return {
+      title: 'Edge Board',
+      rows: applyResultLimit(filterSharpRows(analysis.edgeRows, filters), filters.limit ?? this.config.marketBoardDefaultLimit),
+      analysis,
+    };
+  }
+
+  async getWidthBoard(filters = {}) {
+    const analysis = await this.getCurrentSharpAnalysis();
+    return {
+      title: 'Width Board',
+      rows: applyResultLimit(filterSharpRows(analysis.widthRows, filters), filters.limit ?? this.config.marketBoardDefaultLimit),
+      analysis,
+    };
+  }
+
+  async getPlayerEdge(player, filters = {}) {
+    const analysis = await this.getCurrentSharpAnalysis();
+    return {
+      title: 'Player Edge',
+      rows: filterSharpRows(analysis.sharpRows, { ...filters, player })
+        .sort((left, right) => right.edgeImpliedPct - left.edgeImpliedPct || right.marketWidthPct - left.marketWidthPct),
+      analysis,
+    };
+  }
+
+  async getMarketEdge(market, filters = {}) {
+    const analysis = await this.getCurrentSharpAnalysis();
+    return {
+      title: 'Market Edge',
+      rows: applyResultLimit(
+        filterSharpRows(analysis.edgeRows, { ...filters, market }),
+        filters.limit ?? this.config.marketBoardDefaultLimit,
+      ),
+      analysis,
+    };
+  }
+
+  async getConsensusVsBook(book, filters = {}) {
+    const analysis = await this.getCurrentSharpAnalysis();
+    const filteredRows = filterSharpRows(analysis.sharpRows, filters);
+    return summarizeBookVsSharp(filteredRows, book);
+  }
+
+  async getBookScoreboard(filters = {}) {
+    const analysis = await this.getCurrentSharpAnalysis();
+    const rows = summarizeBooksFromSharpRows(filterSharpRows(analysis.sharpRows, filters));
+    return {
+      title: 'Book Scoreboard',
+      rows: applyResultLimit(rows, filters.limit ?? this.config.marketBoardDefaultLimit),
+      analysis,
+    };
+  }
+
+  async getMarketHealth(filters = {}) {
+    const analysis = await this.getCurrentSharpAnalysis();
+    const normalizedMarket = filters.market ? normalizeSharpMarketType(filters.market) : null;
+    const rows = analysis.marketHealthRows.filter((row) => !normalizedMarket || row.marketType === normalizedMarket);
+    return {
+      title: 'Market Health',
+      rows: applyResultLimit(rows, filters.limit ?? this.config.marketBoardDefaultLimit),
+      analysis,
+    };
+  }
+
+  async getSteamBoard(filters = {}) {
+    const currentRun = await this.store.getLatestScanRun('scan');
+    if (!currentRun) {
+      throw new Error('No completed scan snapshot is available yet.');
+    }
+    const previousRun = await this.store.getPreviousScanRun(currentRun.id, 'scan');
+    if (!previousRun) {
+      throw new Error('No prior scan snapshot is available yet.');
+    }
+
+    const currentAnalysis = analyzeSharpMarkets(currentRun.entries, this.config);
+    const previousGrouped = analyzeSharpMarkets(previousRun.entries, this.config).groupedState;
+    const rows = [];
+
+    for (const [comparisonKey, state] of currentAnalysis.groupedState.entries()) {
+      const previousState = previousGrouped.get(comparisonKey);
+      if (!previousState) {
+        continue;
+      }
+
+      const movements = buildSharpMovements(state.entries, previousState.entries);
+      for (const movement of movements) {
+        rows.push({
+          ...state.sharpRow,
+          movedBook: movement.book,
+          oldOddsInput: movement.previousEntry.oddsInput,
+          newOddsInput: movement.currentEntry.oddsInput,
+          impliedDeltaPct: movement.impliedDeltaPct,
+        });
+      }
+    }
+
+    const filtered = filterSharpRows(rows, filters)
+      .filter((row) => {
+        if (filters.book) {
+          return normalizeBookFilter(row.movedBook) === normalizeBookFilter(filters.book);
+        }
+        return true;
+      })
+      .sort((left, right) => Math.abs(right.impliedDeltaPct) - Math.abs(left.impliedDeltaPct));
+
+    return {
+      title: 'Steam',
+      rows: applyResultLimit(filtered, filters.limit ?? this.config.marketBoardDefaultLimit),
+      currentRun,
+      previousRun,
+    };
+  }
+
   async maybeRunMorningReport(now = new Date()) {
     if (!this.config.enabled) {
       return null;
@@ -3503,6 +3956,15 @@ export class MarketScanner {
         secondaryValue: (row) => `${row.bestOddsInput} -> ${row.worstOddsInput}`,
       })],
     });
+    await channel.send({
+      embeds: [this.embeds.buildSharpEdgeBoardEmbed('Morning Sharp Board', applyResultLimit(analysis.edgeRows, this.config.marketBoardDefaultLimit))],
+    });
+    await channel.send({
+      embeds: [this.embeds.buildBookScoreboardEmbed('Morning Book Scoreboard', applyResultLimit(summarizeBooksFromSharpRows(analysis.sharpRows), this.config.marketBoardDefaultLimit))],
+    });
+    await channel.send({
+      embeds: [this.embeds.buildMarketHealthEmbed('Morning Market Health', applyResultLimit(analysis.marketHealthRows, this.config.marketBoardDefaultLimit))],
+    });
 
     await this.store.recordScanReport(dateKey, 'morning', this.config.scanReportChannelId, discrepancyMessage.id, widthMessage.id);
     this.status.lastReportAt = new Date().toISOString();
@@ -3537,6 +3999,98 @@ export class MarketScanner {
       sentCount += 1;
     }
 
+    if (this.config.sharpEdgeAlertsEnabled) {
+      for (const row of analysis.edgeRows) {
+        if (row.edgeImpliedPct < this.config.sharpEdgeAlertThreshold) {
+          continue;
+        }
+        const alertKey = buildSharpAlertKey('sharp-edge', row, row.bestSoftBook);
+        const cooldownOk = await this.store.canSendScanAlert(alertKey, this.config.scanAlertCooldownMinutes);
+        if (!cooldownOk) {
+          continue;
+        }
+        await channel.send({
+          embeds: [this.embeds.buildSharpAlertEmbed(row)],
+        });
+        await this.store.recordScanAlert(alertKey);
+        sentCount += 1;
+      }
+    }
+
+    const currentRun = analysis.scanRunId ? await this.store.getScanRunById(analysis.scanRunId) : null;
+    const previousRun = currentRun ? await this.store.getPreviousScanRun(currentRun.id, 'scan') : null;
+    if (currentRun && previousRun) {
+      const currentState = analyzeSharpMarkets(currentRun.entries, this.config).groupedState;
+      const previousState = analyzeSharpMarkets(previousRun.entries, this.config).groupedState;
+
+      if (this.config.staleBookAlertsEnabled) {
+        for (const [comparisonKey, state] of currentState.entries()) {
+          const prior = previousState.get(comparisonKey);
+          if (!prior) {
+            continue;
+          }
+          const currentSharpBook = normalizeBookFilter(state.sharpEntry.book);
+          const previousSharp = prior.entries.find((entry) => normalizeBookFilter(entry.book) === currentSharpBook);
+          if (!previousSharp || previousSharp.oddsInput === state.sharpEntry.oddsInput) {
+            continue;
+          }
+          const currentMoves = buildSharpMovements(state.entries, prior.entries);
+          const movedBooks = new Set(currentMoves.map((movement) => movement.book));
+          for (const softEntry of state.softEntries) {
+            const softBook = normalizeBookFilter(softEntry.book);
+            if (softBook === currentSharpBook || movedBooks.has(softBook)) {
+              continue;
+            }
+            const edgePct = (state.sharpEntry.impliedProbability ?? 0) - (softEntry.impliedProbability ?? 0);
+            if (edgePct < this.config.staleBookAlertThreshold) {
+              continue;
+            }
+            const alertKey = buildSharpAlertKey('stale-book', state.sharpRow, softBook);
+            const cooldownOk = await this.store.canSendScanAlert(alertKey, this.config.scanAlertCooldownMinutes);
+            if (!cooldownOk) {
+              continue;
+            }
+            await channel.send({
+              embeds: [this.embeds.buildStaleBookAlertEmbed(state.sharpRow, softEntry)],
+            });
+            await this.store.recordScanAlert(alertKey);
+            sentCount += 1;
+          }
+        }
+      }
+
+      if (this.config.reverseAlertsEnabled) {
+        for (const [comparisonKey, state] of currentState.entries()) {
+          const prior = previousState.get(comparisonKey);
+          if (!prior) {
+            continue;
+          }
+          const currentSharpBook = normalizeBookFilter(state.sharpEntry.book);
+          const previousSharp = prior.entries.find((entry) => normalizeBookFilter(entry.book) === currentSharpBook);
+          const sharpMoved = previousSharp && previousSharp.oddsInput !== state.sharpEntry.oddsInput;
+          if (sharpMoved) {
+            continue;
+          }
+          const currentMoves = buildSharpMovements(state.entries, prior.entries);
+          for (const movement of currentMoves) {
+            if (movement.book === currentSharpBook || Math.abs(movement.impliedDeltaPct) < this.config.reverseAlertThreshold) {
+              continue;
+            }
+            const alertKey = buildSharpAlertKey('reverse', state.sharpRow, movement.book);
+            const cooldownOk = await this.store.canSendScanAlert(alertKey, this.config.scanAlertCooldownMinutes);
+            if (!cooldownOk) {
+              continue;
+            }
+            await channel.send({
+              embeds: [this.embeds.buildReverseAlertEmbed(state.sharpRow, movement)],
+            });
+            await this.store.recordScanAlert(alertKey);
+            sentCount += 1;
+          }
+        }
+      }
+    }
+
     this.status.lastAlertCount = sentCount;
     return analysis;
   }
@@ -3874,8 +4428,9 @@ export class MarketScanner {
         minBooks: this.config.scanMinBooks,
         disagreementThreshold: this.config.scanDisagreementThreshold,
       });
+      const sharpAnalysis = analyzeSharpMarkets(allEntries, this.config);
 
-      await this.store.recordMarketSnapshot(scanType, allEntries);
+      const scanRunId = await this.store.recordMarketSnapshot(scanType, allEntries);
       this.status.lastScanAt = new Date().toISOString();
       this.status.lastScanError = null;
       this.status.lastApiEntries = oddsEntries.length;
@@ -3883,7 +4438,12 @@ export class MarketScanner {
       this.status.lastCircaFileName = circaResult.fileName ?? null;
       this.status.lastCircaFingerprintAt = circaResult.seenAt ?? new Date().toISOString();
 
-      return analysis;
+      return {
+        ...analysis,
+        ...sharpAnalysis,
+        allEntries,
+        scanRunId,
+      };
     } catch (error) {
       this.status.lastScanError = error.message;
       if (String(error.message ?? '').toLowerCase().includes('pdf') || String(error.message ?? '').toLowerCase().includes('ocr') || String(error.message ?? '').toLowerCase().includes('circa')) {

test/market-scanner.test.js

@@ -3,6 +3,7 @@ import assert from 'node:assert/strict';
 import {
   americanToImpliedProbability,
   analyzeMarkets,
+  analyzeSharpMarkets,
   buildMarketKey,
   extractCircaPdfFromArchiveBuffer,
   extractCircaFileCandidatesFromHtml,
@@ -444,6 +445,93 @@ test('fetches odds api entries from event-level endpoints', async () => {
   }
 });
 
+test('sharp analysis prefers Circa and falls back to BetMGM when Circa is missing', () => {
+  const rows = analyzeSharpMarkets([
+    {
+      marketKey: 'judge-hr',
+      source: 'circa',
+      book: 'Circa',
+      eventName: 'Yankees @ Red Sox',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'home_runs',
+      marketLabel: 'Home Runs',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '400',
+      impliedProbability: americanToImpliedProbability('400'),
+    },
+    {
+      marketKey: 'judge-hr',
+      source: 'odds_api',
+      book: 'Caesars',
+      eventName: 'Yankees @ Red Sox',
+      playerName: 'Aaron Judge',
+      team: 'NYY',
+      marketType: 'batter_home_runs',
+      marketLabel: 'Home Runs',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '450',
+      impliedProbability: americanToImpliedProbability('450'),
+    },
+    {
+      marketKey: 'soto-hr',
+      source: 'odds_api',
+      book: 'BetMGM',
+      eventName: 'Mets @ Braves',
+      playerName: 'Juan Soto',
+      team: 'NYM',
+      marketType: 'batter_home_runs',
+      marketLabel: 'Home Runs',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '420',
+      impliedProbability: americanToImpliedProbability('420'),
+    },
+    {
+      marketKey: 'soto-hr',
+      source: 'odds_api',
+      book: 'FanDuel',
+      eventName: 'Mets @ Braves',
+      playerName: 'Juan Soto',
+      team: 'NYM',
+      marketType: 'batter_home_runs',
+      marketLabel: 'Home Runs',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '470',
+      impliedProbability: americanToImpliedProbability('470'),
+    },
+    {
+      marketKey: 'acuna-hr',
+      source: 'odds_api',
+      book: 'FanDuel',
+      eventName: 'Mets @ Braves',
+      playerName: 'Ronald Acuna Jr.',
+      team: 'ATL',
+      marketType: 'batter_home_runs',
+      marketLabel: 'Home Runs',
+      side: 'yes',
+      lineValue: 0.5,
+      oddsInput: '300',
+      impliedProbability: americanToImpliedProbability('300'),
+    },
+  ]);
+
+  assert.equal(rows.sharpRows.length, 2);
+
+  const judge = rows.sharpRows.find((row) => row.playerName === 'Aaron Judge');
+  assert.equal(judge.sharpBook, 'Circa');
+  assert.equal(judge.sharpSourceMode, 'circa');
+
+  const soto = rows.sharpRows.find((row) => row.playerName === 'Juan Soto');
+  assert.equal(soto.sharpBook, 'BetMGM');
+  assert.equal(soto.sharpSourceMode, 'mgm_fallback');
+
+  assert.equal(rows.sharpRows.some((row) => row.playerName === 'Ronald Acuna Jr.'), false);
+});
+
 test('returns partial odds results when later event requests hit 429', async () => {
   const originalFetch = global.fetch;
   const calls = [];