Add market scanner and Circa OCR support

.env.example

@@ -3,3 +3,17 @@ GUILD_ID=optional_guild_id_for_faster_command_registration
 DATABASE_URL=postgresql://username:password@host:26257/database?sslmode=require
 PORT=7860
 ADMIN_ROLE_NAME=Admin
+ODDS_API_KEY=
+ODDS_API_BASE_URL=https://api.the-odds-api.com/v4
+ODDS_API_SPORT_KEY=baseball_mlb
+ODDS_API_REGIONS=us
+ODDS_API_MARKETS=batter_home_runs,batter_hits,batter_total_bases,batter_rbis,batter_runs_scored,batter_hits_runs_rbis,pitcher_strikeouts
+CIRCA_DROPBOX_URL=
+SCAN_REPORT_CHANNEL_ID=
+SCAN_ALERT_CHANNEL_ID=
+SCAN_MORNING_TIME=08:00
+SCAN_TIMEZONE=America/Chicago
+SCAN_MIN_BOOKS=3
+SCAN_DISAGREEMENT_THRESHOLD=0.08
+SCAN_ALERT_COOLDOWN_MINUTES=180
+SCAN_FREQUENCY_MINUTES=15

README.md

@@ -114,3 +114,29 @@ Deployment assets included in this repo:
 - `docs/oracle-always-free.md`
 - `deploy/oracle/roibot.service`
 - `deploy/oracle/roibot.env.example`
+
+## Market Scanner
+
+Market scanning is admin-controlled and built into the same long-running bot process.
+
+- `/scanstatus` shows scanner health and last-run information
+- `/scanrun` runs the Circa disagreement scanner manually
+- `/scanreport` posts the morning discrepancy and width reports on demand
+- `/circatest` previews Circa OCR parsing
+
+Environment variables for scanner features:
+
+- `ODDS_API_KEY`
+- `ODDS_API_BASE_URL`
+- `ODDS_API_SPORT_KEY`
+- `ODDS_API_REGIONS`
+- `ODDS_API_MARKETS`
+- `CIRCA_DROPBOX_URL`
+- `SCAN_REPORT_CHANNEL_ID`
+- `SCAN_ALERT_CHANNEL_ID`
+- `SCAN_MORNING_TIME`
+- `SCAN_TIMEZONE`
+- `SCAN_MIN_BOOKS`
+- `SCAN_DISAGREEMENT_THRESHOLD`
+- `SCAN_ALERT_COOLDOWN_MINUTES`
+- `SCAN_FREQUENCY_MINUTES`

deploy/oracle/roibot.env.example

@@ -3,3 +3,17 @@ DATABASE_URL=postgresql://username:password@host:26257/database?sslmode=require
 GUILD_ID=optional_guild_id_for_faster_command_registration
 ADMIN_ROLE_NAME=Admin
 PORT=7860
+ODDS_API_KEY=
+ODDS_API_BASE_URL=https://api.the-odds-api.com/v4
+ODDS_API_SPORT_KEY=baseball_mlb
+ODDS_API_REGIONS=us
+ODDS_API_MARKETS=batter_home_runs,batter_hits,batter_total_bases,batter_rbis,batter_runs_scored,batter_hits_runs_rbis,pitcher_strikeouts
+CIRCA_DROPBOX_URL=
+SCAN_REPORT_CHANNEL_ID=
+SCAN_ALERT_CHANNEL_ID=
+SCAN_MORNING_TIME=08:00
+SCAN_TIMEZONE=America/Chicago
+SCAN_MIN_BOOKS=3
+SCAN_DISAGREEMENT_THRESHOLD=0.08
+SCAN_ALERT_COOLDOWN_MINUTES=180
+SCAN_FREQUENCY_MINUTES=15

package-lock.json

@@ -11,8 +11,10 @@
         "chart.js": "^4.5.0",
         "discord.js": "^14.25.1",
         "dotenv": "^17.2.3",
+        "pdfjs-dist": "^5.6.205",
         "pg": "^8.16.3",
-        "skia-canvas": "^3.0.8"
+        "skia-canvas": "^3.0.8",
+        "tesseract.js": "^7.0.0"
       },
       "devDependencies": {
         "pg-mem": "^3.0.5"
@@ -176,6 +178,256 @@
       "integrity": "sha512-M5UknZPHRu3DEDWoipU6sE8PdkZ6Z/S+v4dD+Ke8IaNlpdSQah50lz1KtcFBa2vsdOnwbbnxJwVM4wty6udA5w==",
       "license": "MIT"
     },
+    "node_modules/@napi-rs/canvas": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas/-/canvas-0.1.97.tgz",
+      "integrity": "sha512-8cFniXvrIEnVwuNSRCW9wirRZbHvrD3JVujdS2P5n5xiJZNZMOZcfOvJ1pb66c7jXMKHHglJEDVJGbm8XWFcXQ==",
+      "license": "MIT",
+      "optional": true,
+      "workspaces": [
+        "e2e/*"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas-android-arm64": "0.1.97",
+        "@napi-rs/canvas-darwin-arm64": "0.1.97",
+        "@napi-rs/canvas-darwin-x64": "0.1.97",
+        "@napi-rs/canvas-linux-arm-gnueabihf": "0.1.97",
+        "@napi-rs/canvas-linux-arm64-gnu": "0.1.97",
+        "@napi-rs/canvas-linux-arm64-musl": "0.1.97",
+        "@napi-rs/canvas-linux-riscv64-gnu": "0.1.97",
+        "@napi-rs/canvas-linux-x64-gnu": "0.1.97",
+        "@napi-rs/canvas-linux-x64-musl": "0.1.97",
+        "@napi-rs/canvas-win32-arm64-msvc": "0.1.97",
+        "@napi-rs/canvas-win32-x64-msvc": "0.1.97"
+      }
+    },
+    "node_modules/@napi-rs/canvas-android-arm64": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-android-arm64/-/canvas-android-arm64-0.1.97.tgz",
+      "integrity": "sha512-V1c/WVw+NzH8vk7ZK/O8/nyBSCQimU8sfMsB/9qeSvdkGKNU7+mxy/bIF0gTgeBFmHpj30S4E9WHMSrxXGQuVQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-arm64": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-arm64/-/canvas-darwin-arm64-0.1.97.tgz",
+      "integrity": "sha512-ok+SCEF4YejcxuJ9Rm+WWunHHpf2HmiPxfz6z1a/NFQECGXtsY7A4B8XocK1LmT1D7P174MzwPF9Wy3AUAwEPw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-x64": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-x64/-/canvas-darwin-x64-0.1.97.tgz",
+      "integrity": "sha512-PUP6e6/UGlclUvAQNnuXCcnkpdUou6VYZfQOQxExLp86epOylmiwLkqXIvpFmjoTEDmPmXrI+coL/9EFU1gKPA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm-gnueabihf": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm-gnueabihf/-/canvas-linux-arm-gnueabihf-0.1.97.tgz",
+      "integrity": "sha512-XyXH2L/cic8eTNtbrXCcvqHtMX/nEOxN18+7rMrAM2XtLYC/EB5s0wnO1FsLMWmK+04ZSLN9FBGipo7kpIkcOw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-gnu": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-gnu/-/canvas-linux-arm64-gnu-0.1.97.tgz",
+      "integrity": "sha512-Kuq/M3djq0K8ktgz6nPlK7Ne5d4uWeDxPpyKWOjWDK2RIOhHVtLtyLiJw2fuldw7Vn4mhw05EZXCEr4Q76rs9w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-musl": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-musl/-/canvas-linux-arm64-musl-0.1.97.tgz",
+      "integrity": "sha512-kKmSkQVnWeqg7qdsiXvYxKhAFuHz3tkBjW/zyQv5YKUPhotpaVhpBGv5LqCngzyuRV85SXoe+OFj+Tv0a0QXkQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-riscv64-gnu": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-riscv64-gnu/-/canvas-linux-riscv64-gnu-0.1.97.tgz",
+      "integrity": "sha512-Jc7I3A51jnEOIAXeLsN/M/+Z28LUeakcsXs07FLq9prXc0eYOtVwsDEv913Gr+06IRo34gJJVgT0TXvmz+N2VA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-gnu": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-gnu/-/canvas-linux-x64-gnu-0.1.97.tgz",
+      "integrity": "sha512-iDUBe7AilfuBSRbSa8/IGX38Mf+iCSBqoVKLSQ5XaY2JLOaqz1TVyPFEyIck7wT6mRQhQt5sN6ogfjIDfi74tg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-musl": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-musl/-/canvas-linux-x64-musl-0.1.97.tgz",
+      "integrity": "sha512-AKLFd/v0Z5fvgqBDqhvqtAdx+fHMJ5t9JcUNKq4FIZ5WH+iegGm8HPdj00NFlCSnm83Fp3Ln8I2f7uq1aIiWaA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-arm64-msvc": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-win32-arm64-msvc/-/canvas-win32-arm64-msvc-0.1.97.tgz",
+      "integrity": "sha512-u883Yr6A6fO7Vpsy9YE4FVCIxzzo5sO+7pIUjjoDLjS3vQaNMkVzx5bdIpEL+ob+gU88WDK4VcxYMZ6nmnoX9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-x64-msvc": {
+      "version": "0.1.97",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-win32-x64-msvc/-/canvas-win32-x64-msvc-0.1.97.tgz",
+      "integrity": "sha512-sWtD2EE3fV0IzN+iiQUqr/Q1SwqWhs2O1FKItFlxtdDkikpEj5g7DKQpY3x55H/MAOnL8iomnlk3mcEeGiUMoQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
     "node_modules/@sapphire/async-queue": {
       "version": "1.5.5",
       "resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.5.5.tgz",
@@ -246,6 +498,12 @@
         "node": ">= 14"
       }
     },
+    "node_modules/bmp-js": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/bmp-js/-/bmp-js-0.1.0.tgz",
+      "integrity": "sha512-vHdS19CnY3hwiNdkaqk93DvjVLfbEcI8mys4UjuWrlX1haDmroo8o4xCzh4wD6DGV6HxRCyauwhHRqMTfERtjw==",
+      "license": "MIT"
+    },
     "node_modules/call-bind": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
@@ -609,6 +867,12 @@
         "node": ">= 14"
       }
     },
+    "node_modules/idb-keyval": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/idb-keyval/-/idb-keyval-6.2.2.tgz",
+      "integrity": "sha512-yjD9nARJ/jb1g+CvD0tlhUHOrJ9Sy0P8T9MF3YaLlHnSRpwPfpTX0XIvpmw3gAJUmEu3FiICLBDPXVwyEvrleg==",
+      "license": "Apache-2.0"
+    },
     "node_modules/immutable": {
       "version": "4.3.8",
       "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.3.8.tgz",
@@ -616,6 +880,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/is-url": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/is-url/-/is-url-1.2.4.tgz",
+      "integrity": "sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==",
+      "license": "MIT"
+    },
     "node_modules/isarray": {
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
@@ -740,6 +1010,33 @@
         "url": "https://nearley.js.org/#give-to-nearley"
       }
     },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/node-readable-to-web-readable-stream": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/node-readable-to-web-readable-stream/-/node-readable-to-web-readable-stream-0.4.2.tgz",
+      "integrity": "sha512-/cMZNI34v//jUTrI+UIo4ieHAB5EZRY/+7OmXZgBxaWBMcW2tGdceIw06RFxWxrKZ5Jp3sI2i5TsRo+CBhtVLQ==",
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/object-hash": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-2.2.0.tgz",
@@ -760,12 +1057,34 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/opencollective-postinstall": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/opencollective-postinstall/-/opencollective-postinstall-2.0.3.tgz",
+      "integrity": "sha512-8AV/sCtuzUeTo8gQK5qDZzARrulB3egtLzFgteqB2tcT4Mw7B8Kt7JcDHmltjz6FOAHsvTevk70gZEbhM4ZS9Q==",
+      "license": "MIT",
+      "bin": {
+        "opencollective-postinstall": "index.js"
+      }
+    },
     "node_modules/parenthesis": {
       "version": "3.1.8",
       "resolved": "https://registry.npmjs.org/parenthesis/-/parenthesis-3.1.8.tgz",
       "integrity": "sha512-KF/U8tk54BgQewkJPvB4s/US3VQY68BRDpH638+7O/n58TpnwiwnOtGIOsT2/i+M78s61BBpeC83STB88d8sqw==",
       "license": "MIT"
     },
+    "node_modules/pdfjs-dist": {
+      "version": "5.6.205",
+      "resolved": "https://registry.npmjs.org/pdfjs-dist/-/pdfjs-dist-5.6.205.tgz",
+      "integrity": "sha512-tlUj+2IDa7G1SbvBNN74UHRLJybZDWYom+k6p5KIZl7huBvsA4APi6mKL+zCxd3tLjN5hOOEE9Tv7VdzO88pfg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=20.19.0 || >=22.13.0 || >=24"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas": "^0.1.96",
+        "node-readable-to-web-readable-stream": "^0.4.2"
+      }
+    },
     "node_modules/pg": {
       "version": "8.20.0",
       "resolved": "https://registry.npmjs.org/pg/-/pg-8.20.0.tgz",
@@ -985,6 +1304,12 @@
         "node": ">=0.12"
       }
     },
+    "node_modules/regenerator-runtime": {
+      "version": "0.13.11",
+      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz",
+      "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==",
+      "license": "MIT"
+    },
     "node_modules/ret": {
       "version": "0.1.15",
       "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz",
@@ -1044,6 +1369,36 @@
         "parenthesis": "^3.1.5"
       }
     },
+    "node_modules/tesseract.js": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/tesseract.js/-/tesseract.js-7.0.0.tgz",
+      "integrity": "sha512-exPBkd+z+wM1BuMkx/Bjv43OeLBxhL5kKWsz/9JY+DXcXdiBjiAch0V49QR3oAJqCaL5qURE0vx9Eo+G5YE7mA==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bmp-js": "^0.1.0",
+        "idb-keyval": "^6.2.0",
+        "is-url": "^1.2.4",
+        "node-fetch": "^2.6.9",
+        "opencollective-postinstall": "^2.0.3",
+        "regenerator-runtime": "^0.13.3",
+        "tesseract.js-core": "^7.0.0",
+        "wasm-feature-detect": "^1.8.0",
+        "zlibjs": "^0.3.1"
+      }
+    },
+    "node_modules/tesseract.js-core": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/tesseract.js-core/-/tesseract.js-core-7.0.0.tgz",
+      "integrity": "sha512-WnNH518NzmbSq9zgTPeoF8c+xmilS8rFIl1YKbk/ptuuc7p6cLNELNuPAzcmsYw450ca6bLa8j3t0VAtq435Vw==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
     "node_modules/ts-mixer": {
       "version": "6.0.4",
       "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-6.0.4.tgz",
@@ -1071,6 +1426,28 @@
       "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
       "license": "MIT"
     },
+    "node_modules/wasm-feature-detect": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/wasm-feature-detect/-/wasm-feature-detect-1.8.0.tgz",
+      "integrity": "sha512-zksaLKM2fVlnB5jQQDqKXXwYHLQUVH9es+5TOOHwGOVJOCeRBCiPjwSg+3tN2AdTCzjgli4jijCH290kXb/zWQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
     "node_modules/ws": {
       "version": "8.20.0",
       "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
@@ -1107,6 +1484,15 @@
       "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
       "dev": true,
       "license": "ISC"
+    },
+    "node_modules/zlibjs": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/zlibjs/-/zlibjs-0.3.1.tgz",
+      "integrity": "sha512-+J9RrgTKOmlxFSDHo0pI1xM6BLVUv+o0ZT9ANtCxGkjIVCCUdx9alUF8Gm+dGLKbkkkidWIHFDZHDMpfITt4+w==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
     }
   }
 }

package.json

@@ -15,8 +15,10 @@
     "chart.js": "^4.5.0",
     "discord.js": "^14.25.1",
     "dotenv": "^17.2.3",
+    "pdfjs-dist": "^5.6.205",
     "pg": "^8.16.3",
-    "skia-canvas": "^3.0.8"
+    "skia-canvas": "^3.0.8",
+    "tesseract.js": "^7.0.0"
   },
   "devDependencies": {
     "pg-mem": "^3.0.5"

src/commands.js

@@ -199,6 +199,18 @@ export const commands = [
   new SlashCommandBuilder()
     .setName('commands')
     .setDescription('Post a public command reference embed.'),
+  new SlashCommandBuilder()
+    .setName('scanstatus')
+    .setDescription('Show the market scanner status and latest run info.'),
+  new SlashCommandBuilder()
+    .setName('scanrun')
+    .setDescription('Run the Circa market scanner manually.'),
+  new SlashCommandBuilder()
+    .setName('scanreport')
+    .setDescription('Post the daily scan reports immediately.'),
+  new SlashCommandBuilder()
+    .setName('circatest')
+    .setDescription('Run a Circa OCR diagnostic and preview parsed entries.'),
   new SlashCommandBuilder()
     .setName('alerts')
     .setDescription('Post the analyst alert-role embed to the welcome channel.'),

src/config.js

@@ -5,6 +5,24 @@ export function getConfig() {
   const databaseUrl = process.env.DATABASE_URL?.trim();
   const port = Number(process.env.PORT || 7860);
   const adminRoleName = process.env.ADMIN_ROLE_NAME?.trim() || 'Admin';
+  const oddsApiKey = process.env.ODDS_API_KEY?.trim() || null;
+  const oddsApiBaseUrl = process.env.ODDS_API_BASE_URL?.trim() || 'https://api.the-odds-api.com/v4';
+  const oddsApiSportKey = process.env.ODDS_API_SPORT_KEY?.trim() || 'baseball_mlb';
+  const oddsApiRegions = process.env.ODDS_API_REGIONS?.trim() || 'us';
+  const oddsApiMarkets = (process.env.ODDS_API_MARKETS?.trim()
+    || 'batter_home_runs,batter_hits,batter_total_bases,batter_rbis,batter_runs_scored,batter_hits_runs_rbis,pitcher_strikeouts')
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean);
+  const circaDropboxUrl = process.env.CIRCA_DROPBOX_URL?.trim() || null;
+  const scanReportChannelId = process.env.SCAN_REPORT_CHANNEL_ID?.trim() || null;
+  const scanAlertChannelId = process.env.SCAN_ALERT_CHANNEL_ID?.trim() || null;
+  const scanMorningTime = process.env.SCAN_MORNING_TIME?.trim() || '08:00';
+  const scanTimeZone = process.env.SCAN_TIMEZONE?.trim() || 'America/Chicago';
+  const scanMinBooks = Number(process.env.SCAN_MIN_BOOKS || 3);
+  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);
 
   if (!token) {
     throw new Error('Missing DISCORD_TOKEN in environment.');
@@ -20,5 +38,22 @@ export function getConfig() {
     databaseUrl,
     port,
     adminRoleName,
+    scanner: {
+      enabled: Boolean(oddsApiKey && circaDropboxUrl && scanReportChannelId && scanAlertChannelId),
+      oddsApiKey,
+      oddsApiBaseUrl,
+      oddsApiSportKey,
+      oddsApiRegions,
+      oddsApiMarkets,
+      circaDropboxUrl,
+      scanReportChannelId,
+      scanAlertChannelId,
+      scanMorningTime,
+      scanTimeZone,
+      scanMinBooks,
+      scanDisagreementThreshold,
+      scanAlertCooldownMinutes,
+      scanFrequencyMinutes,
+    },
   };
 }

src/db.js

@@ -230,6 +230,57 @@ export class BetStore {
       CREATE UNIQUE INDEX IF NOT EXISTS bets_user_bet_number_unique
       ON bets (discord_user_id, bet_number);
     `);
+
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS scan_runs (
+        id INT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
+        scan_type TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'completed',
+        captured_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        entry_count INT NOT NULL DEFAULT 0,
+        error_text TEXT
+      );
+    `);
+
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS scan_markets (
+        id INT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
+        scan_run_id INT NOT NULL REFERENCES scan_runs(id) ON DELETE CASCADE,
+        market_key TEXT NOT NULL,
+        source TEXT NOT NULL,
+        book TEXT NOT NULL,
+        event_name TEXT,
+        player_name TEXT NOT NULL,
+        market_type TEXT NOT NULL,
+        market_label TEXT NOT NULL,
+        side TEXT NOT NULL,
+        line_value DOUBLE PRECISION,
+        odds_input TEXT NOT NULL,
+        implied_probability DOUBLE PRECISION NOT NULL,
+        raw_label TEXT,
+        captured_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      );
+    `);
+
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS scan_reports (
+        id INT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
+        report_date DATE NOT NULL,
+        report_type TEXT NOT NULL,
+        channel_id TEXT NOT NULL,
+        primary_message_id TEXT,
+        secondary_message_id TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        CONSTRAINT scan_reports_date_type_unique UNIQUE (report_date, report_type)
+      );
+    `);
+
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS scan_alerts (
+        alert_key TEXT PRIMARY KEY,
+        last_sent_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      );
+    `);
   }
 
   async upsertUser(user) {
@@ -612,6 +663,127 @@ export class BetStore {
     });
   }
 
+  async recordMarketSnapshot(scanType, entries) {
+    const client = await this.pool.connect();
+
+    try {
+      await client.query('BEGIN');
+      const { rows } = await client.query(
+        `
+          INSERT INTO scan_runs (scan_type, status, entry_count)
+          VALUES ($1, 'completed', $2)
+          RETURNING id
+        `,
+        [scanType, entries.length]
+      );
+      const scanRunId = Number(rows[0].id);
+
+      for (const entry of entries) {
+        await client.query(
+          `
+            INSERT INTO scan_markets (
+              scan_run_id,
+              market_key,
+              source,
+              book,
+              event_name,
+              player_name,
+              market_type,
+              market_label,
+              side,
+              line_value,
+              odds_input,
+              implied_probability,
+              raw_label
+            )
+            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+          `,
+          [
+            scanRunId,
+            entry.marketKey,
+            entry.source,
+            entry.book,
+            entry.eventName,
+            entry.playerName,
+            entry.marketType,
+            entry.marketLabel,
+            entry.side,
+            entry.lineValue,
+            entry.oddsInput,
+            entry.impliedProbability,
+            entry.rawLabel,
+          ]
+        );
+      }
+
+      await client.query('COMMIT');
+      return scanRunId;
+    } catch (error) {
+      await client.query('ROLLBACK');
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  async hasScanReport(reportDate, reportType) {
+    const { rows } = await this.pool.query(
+      `
+        SELECT 1
+        FROM scan_reports
+        WHERE report_date = $1 AND report_type = $2
+      `,
+      [reportDate, reportType]
+    );
+
+    return Boolean(rows[0]);
+  }
+
+  async recordScanReport(reportDate, reportType, channelId, primaryMessageId, secondaryMessageId = null) {
+    await this.pool.query(
+      `
+        INSERT INTO scan_reports (report_date, report_type, channel_id, primary_message_id, secondary_message_id)
+        VALUES ($1, $2, $3, $4, $5)
+        ON CONFLICT (report_date, report_type) DO UPDATE SET
+          channel_id = EXCLUDED.channel_id,
+          primary_message_id = EXCLUDED.primary_message_id,
+          secondary_message_id = EXCLUDED.secondary_message_id,
+          created_at = NOW()
+      `,
+      [reportDate, reportType, channelId, primaryMessageId, secondaryMessageId]
+    );
+  }
+
+  async canSendScanAlert(alertKey, cooldownMinutes) {
+    const { rows } = await this.pool.query(
+      `
+        SELECT last_sent_at
+        FROM scan_alerts
+        WHERE alert_key = $1
+      `,
+      [alertKey]
+    );
+
+    if (!rows[0]) {
+      return true;
+    }
+
+    const lastSentAt = new Date(rows[0].last_sent_at);
+    return Date.now() - lastSentAt.getTime() >= cooldownMinutes * 60 * 1000;
+  }
+
+  async recordScanAlert(alertKey) {
+    await this.pool.query(
+      `
+        INSERT INTO scan_alerts (alert_key, last_sent_at)
+        VALUES ($1, NOW())
+        ON CONFLICT (alert_key) DO UPDATE SET
+          last_sent_at = NOW()
+      `,
+      [alertKey]
+    );
+  }
+
   async close() {
     await this.pool.end();
   }

src/embeds.js

@@ -289,6 +289,10 @@ export function buildCommandsEmbed() {
       { name: '/sports', value: 'Post public ROI and win-rate breakdowns by sport.' },
       { name: '/export', value: 'Export your filtered bets to CSV privately.' },
       { name: '/commands', value: 'Post this public command reference embed.' },
+      { name: '/scanstatus', value: 'Show the market scanner status and latest run info. Admin only.' },
+      { name: '/scanrun', value: 'Run the market scanner manually. Admin only.' },
+      { name: '/scanreport', value: 'Post the morning scan reports immediately. Admin only.' },
+      { name: '/circatest', value: 'Run a Circa OCR diagnostic preview. Admin only.' },
       { name: '/alerts', value: 'Post the public analyst alert-role panel to the welcome channel. Only for jew_olympics.' },
       { name: '/welcome', value: 'Post the public welcome embed and tag everyone. Only for Kenny F\'n Powers.' }
     );
@@ -382,6 +386,89 @@ export function buildExportAttachment(rows) {
   });
 }
 
+export function buildScanStatusEmbed(status) {
+  return new EmbedBuilder()
+    .setColor(status.enabled ? PALETTE.amber : PALETTE.gray)
+    .setTitle('Market Scanner Status')
+    .setDescription(status.enabled
+      ? 'Scanner is configured and ready to run MLB Circa comparisons.'
+      : 'Scanner is disabled because one or more scan environment variables are missing.')
+    .addFields(
+      { name: 'Enabled', value: status.enabled ? 'Yes' : 'No', inline: true },
+      { name: 'Frequency', value: `${status.frequencyMinutes} minutes`, inline: true },
+      { name: 'Morning Time', value: `${status.morningTime} (${status.timeZone})`, inline: true },
+      { name: 'Report Channel', value: status.reportChannelId ? `<#${status.reportChannelId}>` : 'Not set', inline: true },
+      { name: 'Alert Channel', value: status.alertChannelId ? `<#${status.alertChannelId}>` : 'Not set', inline: true },
+      { name: 'Min Books / Threshold', value: `${status.minBooks} / ${(status.disagreementThreshold * 100).toFixed(2)}%`, inline: true },
+      { name: 'Last Scan', value: status.lastScanAt ?? 'Never', inline: true },
+      { name: 'Last Report', value: status.lastReportAt ?? 'Never', inline: true },
+      { name: 'Last Counts', value: `API: ${status.lastApiEntries ?? 0} | Circa: ${status.lastCircaEntries ?? 0} | Alerts: ${status.lastAlertCount ?? 0}`, inline: false },
+      { name: 'Last Error', value: status.lastScanError ?? 'None', inline: false },
+    );
+}
+
+export function buildMarketTopEmbed(title, rows, options = {}) {
+  const metricLabel = options.metricLabel ?? 'Edge';
+  const metricFormatter = options.metricFormatter ?? ((row) => String(row.valueEdge ?? '0'));
+  const secondaryValue = options.secondaryValue ?? ((row) => row.oddsInput);
+  const embed = new EmbedBuilder()
+    .setColor(PALETTE.amber)
+    .setTitle(title)
+    .setDescription('MLB player props ranked from the latest market scan.');
+
+  if (rows.length === 0) {
+    return embed.addFields({ name: 'No rows', value: 'No matching markets were found in the latest scan.' });
+  }
+
+  embed.addFields(
+    rows.map((row, index) => ({
+      name: `${index + 1}. ${row.playerName} - ${row.marketLabel}`,
+      value: [
+        `Side: ${row.side.toUpperCase()}${row.lineValue !== null && row.lineValue !== undefined ? ` ${row.lineValue}` : ''}`,
+        `Book: ${row.book} | Odds: ${row.oddsInput}`,
+        `${metricLabel}: ${metricFormatter(row)} | Books: ${row.books}`,
+        `Detail: ${secondaryValue(row)}`,
+      ].join('\n'),
+      inline: false,
+    }))
+  );
+
+  return embed;
+}
+
+export function buildCircaAlertEmbed(alert) {
+  return new EmbedBuilder()
+    .setColor(PALETTE.red)
+    .setTitle('Circa Disagreement Alert')
+    .setDescription(`${alert.playerName} - ${alert.marketLabel}`)
+    .addFields(
+      { name: 'Circa', value: `${alert.side.toUpperCase()}${alert.lineValue !== null && alert.lineValue !== undefined ? ` ${alert.lineValue}` : ''} @ ${alert.oddsInput}`, inline: true },
+      { name: 'Furthest Book', value: `${alert.furthestBookName} @ ${alert.furthestBookOddsInput}`, inline: true },
+      { name: 'Books Compared', value: String(alert.books), inline: true },
+      { name: 'Max Deviation', value: `${(alert.maxDeviation * 100).toFixed(2)}%`, inline: true },
+      { name: 'Market Avg', value: `${((alert.marketAverageImpliedProbability ?? 0) * 100).toFixed(2)}% implied`, inline: true },
+      { name: 'Market Key', value: alert.marketKey, inline: false },
+    )
+    .setFooter({ text: 'Triggered because market books materially disagree with Circa.' });
+}
+
+export function buildCircaDiagnosticEmbed(result) {
+  const preview = result.parsedEntries.length > 0
+    ? result.parsedEntries.map((entry) =>
+      `${entry.playerName} | ${entry.marketLabel} | ${entry.side} ${entry.lineValue ?? ''} | ${entry.oddsInput}`.trim()
+    ).join('\n')
+    : 'No Circa entries parsed.';
+
+  return new EmbedBuilder()
+    .setColor(PALETTE.gold)
+    .setTitle('Circa OCR Diagnostic')
+    .setDescription(`Parsed **${result.totalEntries}** Circa entries from the latest download.`)
+    .addFields(
+      { name: 'Parsed Preview', value: truncate(preview, 1000), inline: false },
+      { name: 'OCR Text Sample', value: truncate(result.rawTextSample || 'No OCR text extracted.', 1000), inline: false },
+    );
+}
+
 function escapeCsv(value) {
   const stringValue = String(value);
   if (stringValue.includes(',') || stringValue.includes('"') || stringValue.includes('\n')) {

src/index.js

@@ -32,13 +32,17 @@ import {
   buildBulkAddEmbed,
   buildChartAttachment,
   buildCommandsEmbed,
+  buildCircaDiagnosticEmbed,
+  buildCircaAlertEmbed,
   buildDeleteBetEmbed,
   buildEditBetEmbed,
   buildErrorEmbed,
   buildExportAttachment,
+  buildMarketTopEmbed,
   buildResolveAllEmbed,
   buildResolveEmbed,
   buildRoiEmbed,
+  buildScanStatusEmbed,
   buildSportsEmbed,
   buildSummaryEmbed,
   buildWelcomeEmbed,
@@ -48,6 +52,7 @@ import {
 } from './embeds.js';
 import { parseBulkAddInput } from './bulk-add.js';
 import { parseBetIdList } from './resolve-bulk.js';
+import { MarketScanner } from './market-scanner.js';
 
 const BET_MODAL_PREFIX = 'bet-entry-modal';
 const BULK_ADD_MODAL_PREFIX = 'bulk-add-modal';
@@ -72,6 +77,17 @@ async function main() {
   const client = new Client({
     intents: [GatewayIntentBits.Guilds],
   });
+  const scanner = new MarketScanner({
+    client,
+    store,
+    config: config.scanner,
+    embeds: {
+      buildMarketTopEmbed,
+      buildCircaAlertEmbed,
+    },
+    logger: console,
+  });
+  client.__marketScanner = scanner;
 
   const healthServer = http.createServer((request, response) => {
     response.writeHead(200, { 'Content-Type': 'application/json' });
@@ -95,6 +111,8 @@ async function main() {
       await readyClient.application.commands.set(commands);
       console.log('Registered global slash commands');
     }
+
+    scanner.start();
   });
 
   client.on(Events.InteractionCreate, async (interaction) => {
@@ -151,6 +169,7 @@ async function main() {
   const shutdown = async () => {
     console.log('Shutting down...');
     healthServer.close();
+    await scanner.stop();
     client.destroy();
     await store.close();
     process.exit(0);
@@ -237,6 +256,26 @@ async function handleChatInput(interaction, store, config) {
     return;
   }
 
+  if (commandName === 'scanstatus') {
+    await handleScanStatus(interaction, config);
+    return;
+  }
+
+  if (commandName === 'scanrun') {
+    await handleScanRun(interaction, config);
+    return;
+  }
+
+  if (commandName === 'scanreport') {
+    await handleScanReport(interaction, config);
+    return;
+  }
+
+  if (commandName === 'circatest') {
+    await handleCircaTest(interaction, config);
+    return;
+  }
+
   if (commandName === 'alerts') {
     await handleAlerts(interaction);
     return;
@@ -785,6 +824,95 @@ async function handleAlerts(interaction) {
   });
 }
 
+async function handleScanStatus(interaction, config) {
+  const isAdmin = await memberHasRoleName(interaction, config.adminRoleName);
+  if (!isAdmin) {
+    await denyAdminOnly(interaction, config.adminRoleName);
+    return;
+  }
+
+  const scanner = interaction.client.__marketScanner;
+  await interaction.reply({
+    embeds: [buildScanStatusEmbed(scanner?.getStatus?.() ?? { enabled: false, frequencyMinutes: 0, morningTime: 'N/A', timeZone: 'N/A', minBooks: 0, disagreementThreshold: 0 })],
+    flags: MessageFlags.Ephemeral,
+  });
+}
+
+async function handleScanRun(interaction, config) {
+  const isAdmin = await memberHasRoleName(interaction, config.adminRoleName);
+  if (!isAdmin) {
+    await denyAdminOnly(interaction, config.adminRoleName);
+    return;
+  }
+
+  const scanner = interaction.client.__marketScanner;
+  if (!scanner?.getStatus().enabled) {
+    await interaction.reply({
+      embeds: [buildErrorEmbed('Scanner disabled', 'Set the market scan environment variables before running scanner commands.')],
+      flags: MessageFlags.Ephemeral,
+    });
+    return;
+  }
+
+  await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+  const analysis = await scanner.runDisagreementScan();
+  await interaction.editReply({
+    embeds: [
+      buildMarketTopEmbed('Manual Scan Complete', analysis.circaAlerts.slice(0, 10), {
+        metricLabel: 'Circa Deviation',
+        metricFormatter: (row) => `${(row.maxDeviation * 100).toFixed(2)}%`,
+        secondaryValue: (row) => `${row.furthestBookName} @ ${row.furthestBookOddsInput}`,
+      }),
+    ],
+  });
+}
+
+async function handleScanReport(interaction, config) {
+  const isAdmin = await memberHasRoleName(interaction, config.adminRoleName);
+  if (!isAdmin) {
+    await denyAdminOnly(interaction, config.adminRoleName);
+    return;
+  }
+
+  const scanner = interaction.client.__marketScanner;
+  if (!scanner?.getStatus().enabled) {
+    await interaction.reply({
+      embeds: [buildErrorEmbed('Scanner disabled', 'Set the market scan environment variables before running scanner commands.')],
+      flags: MessageFlags.Ephemeral,
+    });
+    return;
+  }
+
+  await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+  await scanner.runMorningReport();
+  await interaction.editReply({
+    embeds: [buildErrorEmbed('Morning report posted', `Sent the discrepancy and width reports to <#${config.scanner.scanReportChannelId}>.`).setColor(0x2563eb)],
+  });
+}
+
+async function handleCircaTest(interaction, config) {
+  const isAdmin = await memberHasRoleName(interaction, config.adminRoleName);
+  if (!isAdmin) {
+    await denyAdminOnly(interaction, config.adminRoleName);
+    return;
+  }
+
+  const scanner = interaction.client.__marketScanner;
+  if (!scanner?.getStatus().enabled) {
+    await interaction.reply({
+      embeds: [buildErrorEmbed('Scanner disabled', 'Set the market scan environment variables before running scanner commands.')],
+      flags: MessageFlags.Ephemeral,
+    });
+    return;
+  }
+
+  await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+  const diagnostic = await scanner.runCircaDiagnostic();
+  await interaction.editReply({
+    embeds: [buildCircaDiagnosticEmbed(diagnostic)],
+  });
+}
+
 async function handleButton(interaction, store) {
   const alertRoleName = parseAlertRoleButtonId(interaction.customId);
   if (alertRoleName) {
@@ -870,6 +998,13 @@ async function memberHasRoleName(interaction, roleName) {
   return member.roles.cache.some((role) => role.name === roleName);
 }
 
+async function denyAdminOnly(interaction, roleName) {
+  await interaction.reply({
+    embeds: [buildErrorEmbed('Not allowed', `Only members with the **${roleName}** role can use this command.`)],
+    flags: MessageFlags.Ephemeral,
+  });
+}
+
 function auditLog(event, payload) {
   console.log(`[audit] ${event}`, payload);
 }

src/market-scanner.js

@@ -0,0 +1,670 @@
+import { Canvas } from 'skia-canvas';
+import * as pdfjsLib from 'pdfjs-dist/legacy/build/pdf.mjs';
+import { createWorker } from 'tesseract.js';
+
+const MARKET_TYPE_LABELS = {
+  batter_home_runs: 'Home Runs',
+  batter_hits: 'Hits',
+  batter_total_bases: 'Total Bases',
+  batter_rbis: 'RBIs',
+  batter_runs_scored: 'Runs',
+  batter_hits_runs_rbis: 'Hits + Runs + RBIs',
+  pitcher_strikeouts: 'Pitcher Strikeouts',
+  home_runs: 'Home Runs',
+  hits: 'Hits',
+  total_bases: 'Total Bases',
+  rbis: 'RBIs',
+  runs: 'Runs',
+  hits_runs_rbis: 'Hits + Runs + RBIs',
+  pitcher_strikeouts_generic: 'Pitcher Strikeouts',
+};
+
+const OCR_MARKET_PATTERNS = [
+  { type: 'home_runs', label: 'Home Runs', pattern: /(home\s*runs?|hr\b)/i },
+  { type: 'total_bases', label: 'Total Bases', pattern: /(total\s*bases?|tb\b)/i },
+  { type: 'hits_runs_rbis', label: 'Hits \+ Runs \+ RBIs', pattern: /(hits?\s*\+\s*runs?\s*\+\s*rbis?|hrr?i?)/i },
+  { type: 'rbis', label: 'RBIs', pattern: /\brbis?\b/i },
+  { type: 'runs', label: 'Runs', pattern: /\bruns?\b/i },
+  { type: 'hits', label: 'Hits', pattern: /\bhits?\b/i },
+  { type: 'pitcher_strikeouts_generic', label: 'Pitcher Strikeouts', pattern: /(strikeouts?|k['’]?s?\b)/i },
+];
+
+function normalizeWhitespace(value) {
+  return String(value ?? '')
+    .replace(/\u00a0/g, ' ')
+    .replace(/[|]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+export function normalizePlayerName(name) {
+  return normalizeWhitespace(name)
+    .replace(/[^a-zA-Z0-9.\-'\s]/g, '')
+    .toLowerCase();
+}
+
+export function slugify(value) {
+  return normalizeWhitespace(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+export function americanToImpliedProbability(oddsInput) {
+  if (!oddsInput) {
+    return null;
+  }
+
+  const odds = Number(String(oddsInput).trim());
+  if (!Number.isFinite(odds) || odds === 0) {
+    return null;
+  }
+
+  if (odds > 0) {
+    return Number((100 / (odds + 100)).toFixed(6));
+  }
+
+  return Number((Math.abs(odds) / (Math.abs(odds) + 100)).toFixed(6));
+}
+
+function normalizeSide({ marketKey, outcomeName, description, point }) {
+  const name = normalizeWhitespace(outcomeName).toLowerCase();
+  const desc = normalizeWhitespace(description).toLowerCase();
+
+  if (desc === 'over' || /^over\b/.test(name)) {
+    return 'over';
+  }
+
+  if (desc === 'under' || /^under\b/.test(name)) {
+    return 'under';
+  }
+
+  if (marketKey === 'batter_home_runs') {
+    return 'yes';
+  }
+
+  return 'yes';
+}
+
+function normalizeLine(point, side, marketKey) {
+  if (point !== null && point !== undefined && point !== '') {
+    const parsed = Number(point);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+
+  if (marketKey === 'batter_home_runs' || side === 'yes') {
+    return 0.5;
+  }
+
+  return null;
+}
+
+function normalizeMarketLabel(marketKey) {
+  return MARKET_TYPE_LABELS[marketKey] ?? marketKey;
+}
+
+export function buildMarketKey(entry) {
+  return [
+    slugify(entry.playerName),
+    slugify(entry.marketType),
+    entry.side || 'yes',
+    entry.lineValue ?? 'na',
+  ].join('|');
+}
+
+export function normalizeOddsApiEntries(payload = []) {
+  const entries = [];
+
+  for (const event of payload) {
+    for (const bookmaker of event.bookmakers ?? []) {
+      for (const market of bookmaker.markets ?? []) {
+        for (const outcome of market.outcomes ?? []) {
+          const impliedProbability = americanToImpliedProbability(outcome.price);
+          if (impliedProbability === null) {
+            continue;
+          }
+
+          const playerName = normalizeWhitespace(outcome.name);
+          if (!playerName) {
+            continue;
+          }
+
+          const side = normalizeSide({
+            marketKey: market.key,
+            outcomeName: outcome.name,
+            description: outcome.description,
+            point: outcome.point,
+          });
+          const lineValue = normalizeLine(outcome.point, side, market.key);
+          const entry = {
+            source: bookmaker.title === 'Circa' ? 'circa' : 'odds_api',
+            book: bookmaker.title,
+            eventName: `${event.away_team} @ ${event.home_team}`,
+            eventId: event.id,
+            team: null,
+            playerName,
+            playerKey: normalizePlayerName(playerName),
+            marketType: market.key,
+            marketLabel: normalizeMarketLabel(market.key),
+            side,
+            lineValue,
+            oddsInput: String(outcome.price),
+            impliedProbability,
+            rawLabel: [playerName, outcome.description, outcome.point, outcome.price].filter(Boolean).join(' '),
+          };
+          entry.marketKey = buildMarketKey(entry);
+          entries.push(entry);
+        }
+      }
+    }
+  }
+
+  return entries;
+}
+
+function detectMarketType(line) {
+  const normalizedLine = normalizeWhitespace(line);
+  return OCR_MARKET_PATTERNS.find((candidate) => candidate.pattern.test(normalizedLine)) ?? null;
+}
+
+function extractSide(line) {
+  const normalizedLine = normalizeWhitespace(line).toLowerCase();
+  if (/\bover\b/.test(normalizedLine) || /\bo\s*\d/.test(normalizedLine)) {
+    return 'over';
+  }
+  if (/\bunder\b/.test(normalizedLine) || /\bu\s*\d/.test(normalizedLine)) {
+    return 'under';
+  }
+  if (/\b1\+\b/.test(normalizedLine)) {
+    return 'yes';
+  }
+  return 'yes';
+}
+
+function extractLineValue(line, side) {
+  const withoutOdds = normalizeWhitespace(line).replace(/([+-]\d{2,6}).*$/, '').trim();
+  const matches = [...withoutOdds.matchAll(/(\d+(?:\.\d+)?)/g)];
+  if (matches.length === 0) {
+    return side === 'yes' ? 0.5 : null;
+  }
+
+  const parsed = Number(matches[matches.length - 1][1]);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function extractOdds(line) {
+  const match = normalizeWhitespace(line).match(/([+-]\d{2,6})/);
+  return match ? match[1] : null;
+}
+
+function extractPlayerName(line, marketPattern) {
+  let cleaned = normalizeWhitespace(line);
+  cleaned = cleaned.replace(/([+-]\d{2,6}).*$/, '').trim();
+  cleaned = cleaned.replace(/\b(over|under)\b.*$/i, '').trim();
+  cleaned = cleaned.replace(/\bo\s*\d.*$/i, '').trim();
+  cleaned = cleaned.replace(/\bu\s*\d.*$/i, '').trim();
+  if (marketPattern) {
+    cleaned = cleaned.replace(marketPattern.pattern, '').trim();
+  }
+  cleaned = cleaned.replace(/\b\d+(?:\.\d+)?\+?\b/g, '').trim();
+  return cleaned;
+}
+
+export function parseCircaOcrText(text) {
+  const entries = [];
+  const lines = String(text ?? '')
+    .split(/\n+/)
+    .map((line) => normalizeWhitespace(line))
+    .filter(Boolean);
+
+  for (const rawLine of lines) {
+    const line = normalizeWhitespace(rawLine);
+    const oddsInput = extractOdds(line);
+    if (!oddsInput) {
+      continue;
+    }
+
+    const marketPattern = detectMarketType(line);
+    if (!marketPattern) {
+      continue;
+    }
+
+    const playerName = extractPlayerName(line, marketPattern);
+    if (!playerName || playerName.length < 3) {
+      continue;
+    }
+
+    const side = extractSide(line);
+    const lineValue = extractLineValue(line, side);
+    const impliedProbability = americanToImpliedProbability(oddsInput);
+    if (impliedProbability === null) {
+      continue;
+    }
+
+    const entry = {
+      source: 'circa',
+      book: 'Circa',
+      eventName: 'Circa MLB',
+      eventId: null,
+      team: null,
+      playerName,
+      playerKey: normalizePlayerName(playerName),
+      marketType: marketPattern.type,
+      marketLabel: marketPattern.label,
+      side,
+      lineValue,
+      oddsInput,
+      impliedProbability,
+      rawLabel: line,
+    };
+    entry.marketKey = buildMarketKey(entry);
+    entries.push(entry);
+  }
+
+  return dedupeBy(entries, (entry) => `${entry.marketKey}|${entry.book}`);
+}
+
+function dedupeBy(values, getKey) {
+  const seen = new Set();
+  const output = [];
+
+  for (const value of values) {
+    const key = getKey(value);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    output.push(value);
+  }
+
+  return output;
+}
+
+function trimmedAverage(values) {
+  if (values.length === 0) {
+    return null;
+  }
+
+  const sorted = [...values].sort((left, right) => left - right);
+  const trimmed = sorted.length >= 5 ? sorted.slice(1, -1) : sorted;
+  const total = trimmed.reduce((sum, value) => sum + value, 0);
+  return total / trimmed.length;
+}
+
+export function analyzeMarkets(entries, config = {}) {
+  const grouped = new Map();
+
+  for (const entry of entries) {
+    if (!grouped.has(entry.marketKey)) {
+      grouped.set(entry.marketKey, []);
+    }
+    grouped.get(entry.marketKey).push(entry);
+  }
+
+  const discrepancies = [];
+  const widths = [];
+  const circaAlerts = [];
+
+  for (const groupEntries of grouped.values()) {
+    const marketBooks = groupEntries.filter((entry) => entry.book !== 'Circa');
+    if (marketBooks.length < 2) {
+      continue;
+    }
+
+    const impliedProbabilities = marketBooks.map((entry) => entry.impliedProbability).filter((value) => value !== null);
+    if (impliedProbabilities.length < 2) {
+      continue;
+    }
+
+    const consensusImplied = trimmedAverage(impliedProbabilities);
+    const bestBook = marketBooks.reduce((best, entry) =>
+      entry.impliedProbability < best.impliedProbability ? entry : best, marketBooks[0]);
+    const width = Math.max(...impliedProbabilities) - Math.min(...impliedProbabilities);
+
+    discrepancies.push({
+      ...bestBook,
+      consensusImpliedProbability: consensusImplied,
+      valueEdge: consensusImplied !== null ? Number((consensusImplied - bestBook.impliedProbability).toFixed(6)) : 0,
+      books: marketBooks.length,
+    });
+
+    widths.push({
+      ...bestBook,
+      width,
+      books: marketBooks.length,
+      bestOddsInput: marketBooks.reduce((best, entry) => entry.impliedProbability < best.impliedProbability ? entry : best, marketBooks[0]).oddsInput,
+      worstOddsInput: marketBooks.reduce((worst, entry) => entry.impliedProbability > worst.impliedProbability ? entry : worst, marketBooks[0]).oddsInput,
+    });
+
+    const circaEntry = groupEntries.find((entry) => entry.book === 'Circa');
+    if (!circaEntry) {
+      continue;
+    }
+
+    if (marketBooks.length < (config.minBooks ?? 3)) {
+      continue;
+    }
+
+    const maxDeviation = Math.max(
+      ...marketBooks.map((entry) => Math.abs(entry.impliedProbability - circaEntry.impliedProbability))
+    );
+
+    if (maxDeviation >= (config.disagreementThreshold ?? 0.08)) {
+      const furthestBook = marketBooks.reduce((furthest, entry) =>
+        Math.abs(entry.impliedProbability - circaEntry.impliedProbability) > Math.abs(furthest.impliedProbability - circaEntry.impliedProbability)
+          ? entry
+          : furthest,
+      marketBooks[0]);
+      circaAlerts.push({
+        ...circaEntry,
+        books: marketBooks.length,
+        marketAverageImpliedProbability: trimmedAverage(impliedProbabilities),
+        maxDeviation,
+        furthestBookName: furthestBook.book,
+        furthestBookOddsInput: furthestBook.oddsInput,
+        marketKey: circaEntry.marketKey,
+      });
+    }
+  }
+
+  return {
+    discrepancies: discrepancies.sort((left, right) => right.valueEdge - left.valueEdge),
+    widths: widths.sort((left, right) => right.width - left.width),
+    circaAlerts: circaAlerts.sort((left, right) => right.maxDeviation - left.maxDeviation),
+  };
+}
+
+async function fetchArrayBuffer(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Request failed with ${response.status} for ${url}`);
+  }
+  return response.arrayBuffer();
+}
+
+async function extractPdfText(buffer) {
+  const loadingTask = pdfjsLib.getDocument({ data: new Uint8Array(buffer), useWorkerFetch: false, isEvalSupported: false });
+  const pdf = await loadingTask.promise;
+  let text = '';
+
+  for (let pageNumber = 1; pageNumber <= pdf.numPages; pageNumber += 1) {
+    const page = await pdf.getPage(pageNumber);
+    const textContent = await page.getTextContent();
+    const pageText = textContent.items.map((item) => item.str).join(' ').trim();
+    if (pageText.length > 20) {
+      text += `${pageText}\n`;
+      continue;
+    }
+
+    const viewport = page.getViewport({ scale: 2 });
+    const canvas = new Canvas(Math.ceil(viewport.width), Math.ceil(viewport.height));
+    const context = canvas.getContext('2d');
+    await page.render({ canvasContext: context, viewport }).promise;
+    const pngBuffer = await canvas.toBuffer('png');
+    text += `${await recognizeTextFromImage(pngBuffer)}\n`;
+  }
+
+  return text;
+}
+
+let ocrWorkerPromise = null;
+
+async function getOcrWorker() {
+  if (!ocrWorkerPromise) {
+    ocrWorkerPromise = createWorker('eng');
+  }
+
+  return ocrWorkerPromise;
+}
+
+async function recognizeTextFromImage(imageBuffer) {
+  const worker = await getOcrWorker();
+  const result = await worker.recognize(imageBuffer);
+  return result.data.text ?? '';
+}
+
+export async function fetchCircaEntries(config) {
+  const buffer = await fetchArrayBuffer(config.circaDropboxUrl);
+  const text = await extractPdfText(buffer);
+  return {
+    text,
+    entries: parseCircaOcrText(text),
+  };
+}
+
+export async function fetchOddsApiEntries(config) {
+  const url = new URL(`${config.oddsApiBaseUrl.replace(/\/$/, '')}/sports/${config.oddsApiSportKey}/odds/`);
+  url.searchParams.set('apiKey', config.oddsApiKey);
+  url.searchParams.set('regions', config.oddsApiRegions);
+  url.searchParams.set('markets', config.oddsApiMarkets.join(','));
+  url.searchParams.set('oddsFormat', 'american');
+  url.searchParams.set('dateFormat', 'iso');
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Odds API request failed with ${response.status}`);
+  }
+
+  const payload = await response.json();
+  return normalizeOddsApiEntries(payload);
+}
+
+function formatZonedParts(date, timeZone) {
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone,
+    hour12: false,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+  }).formatToParts(date);
+
+  return Object.fromEntries(parts.filter((part) => part.type !== 'literal').map((part) => [part.type, part.value]));
+}
+
+export function getZonedDateKey(date, timeZone) {
+  const parts = formatZonedParts(date, timeZone);
+  return `${parts.year}-${parts.month}-${parts.day}`;
+}
+
+function getZonedTime(date, timeZone) {
+  const parts = formatZonedParts(date, timeZone);
+  return `${parts.hour}:${parts.minute}`;
+}
+
+export class MarketScanner {
+  constructor({ client, store, config, embeds, logger = console }) {
+    this.client = client;
+    this.store = store;
+    this.config = config;
+    this.embeds = embeds;
+    this.logger = logger;
+    this.scanTimer = null;
+    this.reportTimer = null;
+    this.running = false;
+    this.status = {
+      enabled: config.enabled,
+      lastScanAt: null,
+      lastReportAt: null,
+      lastScanError: null,
+      lastCircaEntries: 0,
+      lastApiEntries: 0,
+      lastAlertCount: 0,
+    };
+  }
+
+  start() {
+    if (!this.config.enabled) {
+      this.logger.log('Market scanner disabled: missing scan configuration');
+      return;
+    }
+
+    this.logger.log('Market scanner enabled', {
+      reportChannelId: this.config.scanReportChannelId,
+      alertChannelId: this.config.scanAlertChannelId,
+      morningTime: this.config.scanMorningTime,
+      timeZone: this.config.scanTimeZone,
+      frequencyMinutes: this.config.scanFrequencyMinutes,
+    });
+
+    this.scanTimer = setInterval(() => {
+      this.runDisagreementScan().catch((error) => {
+        this.status.lastScanError = error.message;
+        this.logger.error('Scanner interval failed', error);
+      });
+    }, this.config.scanFrequencyMinutes * 60 * 1000);
+
+    this.reportTimer = setInterval(() => {
+      this.maybeRunMorningReport().catch((error) => {
+        this.status.lastScanError = error.message;
+        this.logger.error('Morning report interval failed', error);
+      });
+    }, 60 * 1000);
+
+    this.runDisagreementScan().catch((error) => {
+      this.status.lastScanError = error.message;
+      this.logger.error('Initial scanner run failed', error);
+    });
+  }
+
+  async stop() {
+    if (this.scanTimer) {
+      clearInterval(this.scanTimer);
+    }
+    if (this.reportTimer) {
+      clearInterval(this.reportTimer);
+    }
+    if (ocrWorkerPromise) {
+      const worker = await ocrWorkerPromise;
+      await worker.terminate();
+      ocrWorkerPromise = null;
+    }
+  }
+
+  getStatus() {
+    return {
+      ...this.status,
+      reportChannelId: this.config.scanReportChannelId,
+      alertChannelId: this.config.scanAlertChannelId,
+      morningTime: this.config.scanMorningTime,
+      timeZone: this.config.scanTimeZone,
+      frequencyMinutes: this.config.scanFrequencyMinutes,
+      minBooks: this.config.scanMinBooks,
+      disagreementThreshold: this.config.scanDisagreementThreshold,
+    };
+  }
+
+  async maybeRunMorningReport(now = new Date()) {
+    if (!this.config.enabled) {
+      return null;
+    }
+
+    const dateKey = getZonedDateKey(now, this.config.scanTimeZone);
+    if (getZonedTime(now, this.config.scanTimeZone) !== this.config.scanMorningTime) {
+      return null;
+    }
+
+    const hasReport = await this.store.hasScanReport(dateKey, 'morning');
+    if (hasReport) {
+      return null;
+    }
+
+    return this.runMorningReport(dateKey);
+  }
+
+  async runMorningReport(dateKey = getZonedDateKey(new Date(), this.config.scanTimeZone)) {
+    const analysis = await this.collectMarketAnalysis('morning');
+    const channel = await this.client.channels.fetch(this.config.scanReportChannelId);
+    if (!channel?.isTextBased()) {
+      throw new Error(`Report channel ${this.config.scanReportChannelId} is not text-based`);
+    }
+
+    const discrepancyMessage = await channel.send({
+      embeds: [this.embeds.buildMarketTopEmbed('Top 10 Discrepancies', analysis.discrepancies.slice(0, 10), {
+        metricLabel: 'Consensus Edge',
+        metricFormatter: (row) => `${(row.valueEdge * 100).toFixed(2)}%`,
+      })],
+    });
+    const widthMessage = await channel.send({
+      embeds: [this.embeds.buildMarketTopEmbed('Top 10 Market Width', analysis.widths.slice(0, 10), {
+        metricLabel: 'Implied Width',
+        metricFormatter: (row) => `${(row.width * 100).toFixed(2)}%`,
+        secondaryValue: (row) => `${row.bestOddsInput} -> ${row.worstOddsInput}`,
+      })],
+    });
+
+    await this.store.recordScanReport(dateKey, 'morning', this.config.scanReportChannelId, discrepancyMessage.id, widthMessage.id);
+    this.status.lastReportAt = new Date().toISOString();
+    return analysis;
+  }
+
+  async runDisagreementScan() {
+    const analysis = await this.collectMarketAnalysis('scan');
+    const channel = await this.client.channels.fetch(this.config.scanAlertChannelId);
+    if (!channel?.isTextBased()) {
+      throw new Error(`Alert channel ${this.config.scanAlertChannelId} is not text-based`);
+    }
+
+    let sentCount = 0;
+    for (const alert of analysis.circaAlerts) {
+      const cooldownOk = await this.store.canSendScanAlert(
+        alert.marketKey,
+        this.config.scanAlertCooldownMinutes,
+      );
+      if (!cooldownOk) {
+        continue;
+      }
+
+      await channel.send({
+        embeds: [this.embeds.buildCircaAlertEmbed(alert)],
+      });
+      await this.store.recordScanAlert(alert.marketKey);
+      sentCount += 1;
+    }
+
+    this.status.lastAlertCount = sentCount;
+    return analysis;
+  }
+
+  async runCircaDiagnostic() {
+    const result = await fetchCircaEntries(this.config);
+    return {
+      rawTextSample: result.text.slice(0, 1000),
+      parsedEntries: result.entries.slice(0, 10),
+      totalEntries: result.entries.length,
+    };
+  }
+
+  async collectMarketAnalysis(scanType) {
+    if (this.running) {
+      throw new Error('Market scanner is already running');
+    }
+
+    this.running = true;
+    try {
+      const [oddsEntries, circaResult] = await Promise.all([
+        fetchOddsApiEntries(this.config),
+        fetchCircaEntries(this.config),
+      ]);
+      const allEntries = [...oddsEntries, ...circaResult.entries];
+      const analysis = analyzeMarkets(allEntries, {
+        minBooks: this.config.scanMinBooks,
+        disagreementThreshold: this.config.scanDisagreementThreshold,
+      });
+
+      await this.store.recordMarketSnapshot(scanType, allEntries);
+      this.status.lastScanAt = new Date().toISOString();
+      this.status.lastScanError = null;
+      this.status.lastApiEntries = oddsEntries.length;
+      this.status.lastCircaEntries = circaResult.entries.length;
+
+      return analysis;
+    } catch (error) {
+      this.status.lastScanError = error.message;
+      throw error;
+    } finally {
+      this.running = false;
+    }
+  }
+}

test/market-scanner.test.js

@@ -0,0 +1,105 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  americanToImpliedProbability,
+  analyzeMarkets,
+  buildMarketKey,
+  normalizeOddsApiEntries,
+  parseCircaOcrText,
+} from '../src/market-scanner.js';
+
+test('converts american odds to implied probability', () => {
+  assert.equal(americanToImpliedProbability('+100'), 0.5);
+  assert.equal(americanToImpliedProbability('-150'), 0.6);
+});
+
+test('normalizes odds api entries into shared market keys', () => {
+  const entries = normalizeOddsApiEntries([
+    {
+      id: 'event-1',
+      away_team: 'Yankees',
+      home_team: 'Red Sox',
+      bookmakers: [
+        {
+          title: 'FanDuel',
+          markets: [
+            {
+              key: 'batter_total_bases',
+              outcomes: [
+                { name: 'Aaron Judge', description: 'Over', point: 1.5, price: -110 },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  ]);
+
+  assert.equal(entries.length, 1);
+  assert.equal(entries[0].marketKey, buildMarketKey(entries[0]));
+  assert.equal(entries[0].side, 'over');
+});
+
+test('parses circa OCR lines into normalized entries', () => {
+  const entries = parseCircaOcrText('Aaron Judge Over 1.5 Total Bases -110\nJuan Soto Over 0.5 Home Runs +250');
+
+  assert.equal(entries.length, 2);
+  assert.equal(entries[0].book, 'Circa');
+  assert.equal(entries[0].marketLabel, 'Total Bases');
+});
+
+test('ranks discrepancy, width, and circa alerts', () => {
+  const entries = [
+    {
+      marketKey: 'judge|total-bases|over|1.5',
+      playerName: 'Aaron Judge',
+      marketLabel: 'Total Bases',
+      marketType: 'batter_total_bases',
+      side: 'over',
+      lineValue: 1.5,
+      book: 'FanDuel',
+      oddsInput: '+110',
+      impliedProbability: americanToImpliedProbability('+110'),
+    },
+    {
+      marketKey: 'judge|total-bases|over|1.5',
+      playerName: 'Aaron Judge',
+      marketLabel: 'Total Bases',
+      marketType: 'batter_total_bases',
+      side: 'over',
+      lineValue: 1.5,
+      book: 'DraftKings',
+      oddsInput: '-120',
+      impliedProbability: americanToImpliedProbability('-120'),
+    },
+    {
+      marketKey: 'judge|total-bases|over|1.5',
+      playerName: 'Aaron Judge',
+      marketLabel: 'Total Bases',
+      marketType: 'batter_total_bases',
+      side: 'over',
+      lineValue: 1.5,
+      book: 'BetMGM',
+      oddsInput: '-125',
+      impliedProbability: americanToImpliedProbability('-125'),
+    },
+    {
+      marketKey: 'judge|total-bases|over|1.5',
+      playerName: 'Aaron Judge',
+      marketLabel: 'Total Bases',
+      marketType: 'batter_total_bases',
+      side: 'over',
+      lineValue: 1.5,
+      book: 'Circa',
+      oddsInput: '-150',
+      impliedProbability: americanToImpliedProbability('-150'),
+    },
+  ];
+
+  const analysis = analyzeMarkets(entries, { minBooks: 3, disagreementThreshold: 0.05 });
+
+  assert.equal(analysis.discrepancies.length, 1);
+  assert.equal(analysis.widths.length, 1);
+  assert.equal(analysis.circaAlerts.length, 1);
+  assert.equal(analysis.circaAlerts[0].furthestBookName, 'FanDuel');
+});