dankgrinder 4.9.9 → 5.0.1

package/lib/commands/adventure.js

@@ -39,6 +39,9 @@ const {
   safeClickButton, isHoldTight, logMsg,
 } = require('./utils');
 
+const RE_DISCORD_TIMESTAMP = /<t:(\d+)(?::[tTdDfFR])?>/;
+const RE_ADVENTURE_AGAIN_LABEL = /adventure again in (\d+)\s*(minute|min|hour|second)/;
+
 // ── Adventure type rotation (cycle through all types each run) ────
 let lastAdventureIndex = -1;
 
@@ -102,8 +105,9 @@ function isAdventureDone(msg) {
 }
 
 // ── Safe choices: prefer non-destructive options ─────────────────
-const SAFE_KEYWORDS = ['flee', 'run', 'hide', 'avoid', 'ignore', 'leave', 'walk away', 'back away', 'retreat', 'skip'];
-const RISKY_KEYWORDS = ['reach', 'grab', 'fight', 'attack', 'steal', 'open', 'touch', 'eat', 'drink'];
+const SAFE_KEYWORDS = Object.freeze(['flee', 'run', 'hide', 'avoid', 'ignore', 'leave', 'walk away', 'back away', 'retreat', 'skip']);
+const RISKY_KEYWORDS = Object.freeze(['reach', 'grab', 'fight', 'attack', 'steal', 'open', 'touch', 'eat', 'drink']);
+const ADVENTURE_PREFERRED_TYPES = Object.freeze(['space', 'out west']);
 
 function pickSafeChoice(choices) {
   if (choices.length === 0) return null;
@@ -114,7 +118,8 @@ function pickSafeChoice(choices) {
 
   // Prefer safe keywords
   for (let i = 0; i < labels.length; i++) {
-    for (const kw of SAFE_KEYWORDS) {
+    for (let k = 0; k < SAFE_KEYWORDS.length; k++) {
+      const kw = SAFE_KEYWORDS[k];
       if (labels[i].includes(kw)) {
         LOG.info(`[adventure] Picking safe option: "${choices[i].label}" (matched: ${kw})`);
         return choices[i];
@@ -235,9 +240,11 @@ async function playAdventureRounds(channel, msg) {
 
   // Parse rewards from Adventure Progress embed
   let rewards = '-';
-  for (const e of current.embeds || []) {
-    for (const f of e.fields || []) {
-      if (f.name === 'Rewards') rewards = f.value;
+  const embeds = current.embeds || [];
+  for (let ei = 0; ei < embeds.length; ei++) {
+    const fields = embeds[ei].fields || [];
+    for (let fi = 0; fi < fields.length; fi++) {
+      if (fields[fi].name === 'Rewards') rewards = fields[fi].value;
     }
   }
   LOG.info(`[adventure] Rewards: ${rewards}`);
@@ -282,7 +289,7 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
   // ── 1) Check cooldown via Unix timestamp <t:UNIX:t> ────────
   //    Format: "You can start another adventure at <t:1774415487:t> (<t:1774415487:R>)"
   let cooldownSec = 0;
-  const tsMatch = text.match(/<t:(\d+)(?::[tTdDfFR])?>/);
+  const tsMatch = text.match(RE_DISCORD_TIMESTAMP);
   if (tsMatch) {
     const unixTarget = parseInt(tsMatch[1]);
     const nowUnix = Math.floor(Date.now() / 1000);
@@ -341,7 +348,9 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
     let menuRowIdx = -1;
     for (let i = 0; i < (response.components || []).length; i++) {
       const row = response.components[i];
-      for (const comp of row.components || []) {
+      const rowComps = row.components || [];
+      for (let j = 0; j < rowComps.length; j++) {
+        const comp = rowComps[j];
         if (comp.type === 'STRING_SELECT' || comp.type === 3) { menuRowIdx = i; break; }
       }
       if (menuRowIdx >= 0) break;
@@ -349,9 +358,8 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
 
     const menu = response.components[menuRowIdx]?.components[0];
     const options = menu?.options || [];
-    const PREFERRED = ['space', 'out west'];
     const preferred = options.filter(o =>
-      PREFERRED.some(kw => (o.label || '').toLowerCase().includes(kw) || (o.value || '').toLowerCase().includes(kw))
+      ADVENTURE_PREFERRED_TYPES.some(kw => (o.label || '').toLowerCase().includes(kw) || (o.value || '').toLowerCase().includes(kw))
     );
     const pool = preferred.length > 0 ? preferred : options;
 
@@ -433,7 +441,7 @@ function buildResult(finalText, coins, interactions, rewards, msg) {
 
   // 1) Best: Unix timestamp <t:UNIX:t> in final text or embed
   const allText = msg ? getFullText(msg) : finalText;
-  const tsMatch = allText.match(/<t:(\d+)(?::[tTdDfFR])?>/);
+  const tsMatch = allText.match(RE_DISCORD_TIMESTAMP);
   if (tsMatch) {
     const unixTarget = parseInt(tsMatch[1]);
     const nowUnix = Math.floor(Date.now() / 1000);
@@ -443,10 +451,13 @@ function buildResult(finalText, coins, interactions, rewards, msg) {
 
   // 2) Fallback: "Adventure again in X minutes" button label
   if (!nextCooldownSec && msg) {
-    for (const row of msg.components || []) {
-      for (const comp of row.components || []) {
+    const rows = msg.components || [];
+    for (let ri = 0; ri < rows.length; ri++) {
+      const comps = rows[ri].components || [];
+      for (let ci = 0; ci < comps.length; ci++) {
+        const comp = comps[ci];
         const label = (comp.label || '').toLowerCase();
-        const btnMatch = label.match(/adventure again in (\d+)\s*(minute|min|hour|second)/);
+        const btnMatch = label.match(RE_ADVENTURE_AGAIN_LABEL);
         if (btnMatch) {
           nextCooldownSec = parseInt(btnMatch[1]);
           const unit = btnMatch[2].toLowerCase();

package/lib/commands/beg.js

@@ -5,6 +5,8 @@
 
 const { LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep } = require('./utils');
 
+const RE_NEWLINE = /\n/g;
+
 /**
  * @param {object} opts
  * @param {object} opts.channel
@@ -38,7 +40,7 @@ async function runBeg({ channel, waitForDankMemer }) {
     return { result: `beg → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`, coins };
   }
 
-  LOG.info(`[beg] ${text.substring(0, 80).replace(/\n/g, ' ')}`);
+  LOG.info(`[beg] ${text.substring(0, 80).replace(RE_NEWLINE, ' ')}`);
   return { result: text.substring(0, 60) || 'done', coins: 0 };
 }
 

package/lib/commands/blackjack.js

@@ -8,35 +8,50 @@ const {
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, ensureCV2,
 } = require('./utils');
 
+const RE_BACKTICK_SCORE = /`\s*(\d+)\s*`/;
+const RE_BJ_FACE_GLOBAL = /bjFace(\w+?):/g;
+const RE_BJ_FACE_SUFFIX = /[RB]$/;
+const RE_NET_LINE = /Net:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i;
+const RE_WINNINGS_LINE = /Winnings:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([\d,]+)/i;
+const RE_COMMA = /,/g;
+const COURT_RANKS = Object.freeze(['K', 'Q', 'J']);
+
 function parsePlayerTotal(msg) {
   // Score is in embed field: ` 18 ` (backtick-wrapped number in Player field)
-  for (const embed of msg?.embeds || []) {
-    for (const field of embed.fields || []) {
+  const embeds = msg?.embeds || [];
+  for (let ei = 0; ei < embeds.length; ei++) {
+    const fields = embeds[ei].fields || [];
+    for (let fi = 0; fi < fields.length; fi++) {
+      const field = fields[fi];
       if (field.name?.toLowerCase().includes('player')) {
-        const m = field.value.match(/`\s*(\d+)\s*`/);
+        const m = field.value.match(RE_BACKTICK_SCORE);
         if (m) return parseInt(m[1]);
       }
     }
   }
   const text = typeof msg === 'string' ? msg : getFullText(msg);
-  const m = text.match(/`\s*(\d+)\s*`/);
+  const m = text.match(RE_BACKTICK_SCORE);
   return m ? parseInt(m[1]) : 0;
 }
 
 function parseDealerUpcard(msg) {
   // Dealer field: revealed total ` 18 ` or hidden ` ? `
   // Upcard from emoji: bjFaceKB=K(10), bjFaceAR=A(11), bjFace7R=7
-  for (const embed of msg?.embeds || []) {
-    for (const field of embed.fields || []) {
+  const embeds = msg?.embeds || [];
+  for (let ei = 0; ei < embeds.length; ei++) {
+    const fields = embeds[ei].fields || [];
+    for (let fi = 0; fi < fields.length; fi++) {
+      const field = fields[fi];
       if (field.name?.toLowerCase().includes('dealer')) {
-        const totalMatch = field.value.match(/`\s*(\d+)\s*`/);
+        const totalMatch = field.value.match(RE_BACKTICK_SCORE);
         if (totalMatch) return parseInt(totalMatch[1]);
-        const faces = [...field.value.matchAll(/bjFace(\w+?):/g)];
-        for (const [, face] of faces) {
+        const faces = [...field.value.matchAll(RE_BJ_FACE_GLOBAL)];
+        for (let fii = 0; fii < faces.length; fii++) {
+          const face = faces[fii][1];
           if (face === 'Unknown') continue;
-          const v = face.replace(/[RB]$/, '');
+          const v = face.replace(RE_BJ_FACE_SUFFIX, '');
           if (v === 'A') return 11;
-          if (['K', 'Q', 'J'].includes(v)) return 10;
+          if (COURT_RANKS.includes(v)) return 10;
           const n = parseInt(v);
           if (!isNaN(n)) return n;
         }
@@ -47,10 +62,10 @@ function parseDealerUpcard(msg) {
 }
 
 function parseNetCoins(text) {
-  const netMatch = text.match(/Net:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i);
-  if (netMatch) return parseInt(netMatch[1].replace(/,/g, ''));
-  const winMatch = text.match(/Winnings:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([\d,]+)/i);
-  if (winMatch) return parseInt(winMatch[1].replace(/,/g, ''));
+  const netMatch = text.match(RE_NET_LINE);
+  if (netMatch) return parseInt(netMatch[1].replace(RE_COMMA, ''));
+  const winMatch = text.match(RE_WINNINGS_LINE);
+  if (winMatch) return parseInt(winMatch[1].replace(RE_COMMA, ''));
   return 0;
 }
 
@@ -114,7 +129,7 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
     if (!targetBtn) break;
 
     LOG.info(`[bj] You:${playerTotal} Dealer:${dealerUpcard} → ${targetBtn.label}`);
-    await humanDelay(400, 900);
+    await humanDelay(150, 400);
 
     try {
       const followUp = await safeClickButton(current, targetBtn);

package/lib/commands/crime.js

@@ -1,6 +1,11 @@
 /**
  * Crime command handler.
  * Send "pls crime", pick a safe option, click it, parse coins.
+ *
+ * Advanced techniques:
+ *   Trie       – O(k) prefix matching for safe/risky crime options
+ *   VoseAlias  – O(1) weighted random sampling with adaptive learning
+ *   LRUCache   – per-option earnings tracking for better choices over time
  */
 
 const {
@@ -8,17 +13,32 @@ const {
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
   isCV2, ensureCV2,
 } = require('./utils');
+const { Trie, VoseAlias, LRUCache } = require('../structures');
 
-const SAFE_CRIME_OPTIONS = [
+const SAFE_CRIME_OPTIONS = Object.freeze([
   'tax evasion', 'fraud', 'cybercrime', 'hacking', 'identity theft',
   'money laundering', 'tax fraud', 'insurance fraud', 'scam',
-];
-const SAFE_CRIME_SET = new Set(SAFE_CRIME_OPTIONS);
+]);
 
-const RISKY_CRIME_OPTIONS = new Set([
+const RISKY_CRIME_OPTIONS = Object.freeze([
   'murder', 'arson', 'assault', 'kidnap', 'terrorism',
 ]);
 
+// Trie for O(k) safe option matching (replaces O(n) Set iteration)
+const safeCrimeTrie = new Trie();
+for (const opt of SAFE_CRIME_OPTIONS) safeCrimeTrie.insert(opt, opt);
+
+const riskyCrimeTrie = new Trie();
+for (const opt of RISKY_CRIME_OPTIONS) {
+  riskyCrimeTrie.insert(opt, opt);
+}
+
+// Adaptive earnings tracker — learn which crimes pay best
+const crimeEarnings = new LRUCache(32);
+
+function isSafeCrime(label) { return safeCrimeTrie.containsInText(label).length > 0; }
+function isRiskyCrime(label) { return riskyCrimeTrie.containsInText(label).length > 0; }
+
 function pickSafeButton(buttons, customSafe) {
   if (!buttons || buttons.length === 0) return null;
   const clickable = buttons.filter(b => !b.disabled);
@@ -32,17 +52,18 @@ function pickSafeButton(buttons, customSafe) {
     }
   }
 
-  for (const btn of clickable) {
-    const label = (btn.label || '').toLowerCase();
-    for (const s of SAFE_CRIME_SET) { if (label.includes(s)) return btn; }
+  // Trie-based safe option detection + VoseAlias weighted sampling
+  const safeButtons = clickable.filter(b => isSafeCrime((b.label || '').toLowerCase()));
+  if (safeButtons.length > 0) {
+    const weights = safeButtons.map(b => {
+      const past = crimeEarnings.get((b.label || '').toLowerCase());
+      return past ? past + 1 : 1;
+    });
+    const alias = new VoseAlias(weights);
+    return safeButtons[alias.sample()];
   }
 
-  const safe = clickable.filter(b => {
-    const label = (b.label || '').toLowerCase();
-    for (const r of RISKY_CRIME_OPTIONS) { if (label.includes(r)) return false; }
-    return true;
-  });
-
+  const safe = clickable.filter(b => !isRiskyCrime((b.label || '').toLowerCase()));
   const pool = safe.length > 0 ? safe : clickable;
   return pool[Math.floor(Math.random() * pool.length)];
 }
@@ -102,6 +123,9 @@ async function runCrime({ channel, waitForDankMemer, safeAnswers }) {
       logMsg(followUp, 'crime-result');
       const text = getFullText(followUp);
       const coins = parseCoins(text);
+      const crimeKey = (btn.label || '').toLowerCase();
+      const prev = crimeEarnings.get(crimeKey) || 0;
+      crimeEarnings.set(crimeKey, prev + coins);
       if (coins > 0) {
         LOG.coin(`[crime] ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
         return { result: `${btn.label} → +⏣ ${coins.toLocaleString()}`, coins };

package/lib/commands/drops.js

@@ -3,6 +3,16 @@ const {
   safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
 } = require('./utils');
 
+const RE_BLOCK_SPLIT = /\n\n+/;
+const RE_DROP_NAME_BOLD = /\*\*(.+?)\*\*/;
+const RE_COST_EMBED = /Cost:\s*[⏣💰]?\s*([\d,]+)/i;
+const RE_STOCK = /Stock:\s*(\d+|Infinite)/i;
+const RE_DROP_TIMESTAMP = /<t:(\d+):[tTdDfFR]>/;
+const RE_COMMA = /,/g;
+const RE_DROP_NAME_FALLBACK = /(\w[\w\s']+)/;
+const RE_COST_LINE = /Cost:\s*[⏣💰o]?\s*([\d,]+)/i;
+const RE_WHITESPACE_UNDERSCORE = /\s+/g;
+
 async function runDrops({ channel, waitForDankMemer, redis, accountId }) {
   LOG.cmd(`${c.white}${c.bold}pls drops${c.reset}`);
 
@@ -22,18 +32,21 @@ async function runDrops({ channel, waitForDankMemer, redis, accountId }) {
 
   const drops = [];
 
-  for (const embed of response.embeds || []) {
+  const embedList = response.embeds || [];
+  for (let ei = 0; ei < embedList.length; ei++) {
+    const embed = embedList[ei];
     const desc = embed.description || '';
-    const items = desc.split(/\n\n+/);
-    for (const block of items) {
-      const nameMatch = block.match(/\*\*(.+?)\*\*/);
-      const costMatch = block.match(/Cost:\s*[⏣💰]?\s*([\d,]+)/i);
-      const stockMatch = block.match(/Stock:\s*(\d+|Infinite)/i);
-      const dateMatch = block.match(/<t:(\d+):[tTdDfFR]>/);
+    const items = desc.split(RE_BLOCK_SPLIT);
+    for (let bi = 0; bi < items.length; bi++) {
+      const block = items[bi];
+      const nameMatch = block.match(RE_DROP_NAME_BOLD);
+      const costMatch = block.match(RE_COST_EMBED);
+      const stockMatch = block.match(RE_STOCK);
+      const dateMatch = block.match(RE_DROP_TIMESTAMP);
       if (nameMatch) {
         drops.push({
           name: nameMatch[1],
-          cost: costMatch ? parseInt(costMatch[1].replace(/,/g, '')) : 0,
+          cost: costMatch ? parseInt(costMatch[1].replace(RE_COMMA, '')) : 0,
           stock: stockMatch ? (stockMatch[1] === 'Infinite' ? Infinity : parseInt(stockMatch[1])) : 0,
           dropTimestamp: dateMatch ? parseInt(dateMatch[1]) : 0,
         });
@@ -47,10 +60,10 @@ async function runDrops({ channel, waitForDankMemer, redis, accountId }) {
     const line = textBlocks[i];
     if (line.includes('Cost:') && i > 0) {
       const prevLine = textBlocks[i - 1];
-      const nameMatch = prevLine.match(/\*\*(.+?)\*\*/) || prevLine.match(/(\w[\w\s']+)/);
-      const costMatch = line.match(/Cost:\s*[⏣💰o]?\s*([\d,]+)/i);
+      const nameMatch = prevLine.match(RE_DROP_NAME_BOLD) || prevLine.match(RE_DROP_NAME_FALLBACK);
+      const costMatch = line.match(RE_COST_LINE);
       if (nameMatch && costMatch) {
-        const cost = parseInt(costMatch[1].replace(/,/g, ''));
+        const cost = parseInt(costMatch[1].replace(RE_COMMA, ''));
         const existing = drops.find(d => d.name === nameMatch[1]);
         if (!existing && cost > 0) {
           drops.push({ name: nameMatch[1], cost, stock: 0, dropTimestamp: 0 });
@@ -64,9 +77,10 @@ async function runDrops({ channel, waitForDankMemer, redis, accountId }) {
     try {
       await redis.set('dkg:drops:latest', JSON.stringify(drops), 'EX', 172800);
       // Schedule individual drops with their timestamps
-      for (const drop of drops) {
+      for (let di = 0; di < drops.length; di++) {
+        const drop = drops[di];
         if (drop.dropTimestamp > 0) {
-          const key = `dkg:drops:schedule:${drop.name.replace(/\s+/g, '_').toLowerCase()}`;
+          const key = `dkg:drops:schedule:${drop.name.replace(RE_WHITESPACE_UNDERSCORE, '_').toLowerCase()}`;
           await redis.set(key, JSON.stringify(drop), 'EX', 172800);
         }
       }
@@ -77,7 +91,8 @@ async function runDrops({ channel, waitForDankMemer, redis, accountId }) {
   const now = Math.floor(Date.now() / 1000);
   const buttons = getAllButtons(response);
   let boughtCount = 0;
-  for (const drop of drops) {
+  for (let di = 0; di < drops.length; di++) {
+    const drop = drops[di];
     if (drop.stock > 0 && (drop.dropTimestamp === 0 || drop.dropTimestamp <= now)) {
       const buyBtn = buttons.find(b =>
         !b.disabled && b.label && (

package/lib/commands/fish.js

@@ -22,6 +22,11 @@ const { downloadImage, extractImageUrl, findSafeCells } = require('./fishVision'
 
 const { DANK_MEMER_ID } = require('./utils');
 
+const RE_FISH_COOLDOWN_TS = /<t:(\d+):R>/;
+const RE_FISH_HEADER = /###\s*(.+?)(?:\s*-#|$)/;
+const RE_CAUGHT_PHRASE = /caught\s+(?:a\s+)?(.+?)(?:\s*[!.]|$)/i;
+const RE_CATCH_CUSTOM_ID_COORDS = /:(\d+):(\d+)$/;
+
 async function refetchMsg(channel, msgId) {
   try { return await channel.messages.fetch(msgId); } catch { return null; }
 }
@@ -127,7 +132,7 @@ async function sellAllFish({ channel, waitForDankMemer, sellFor = 'tokens' }) {
  * Parse cooldown timestamp from text.
  */
 function parseFishCooldown(text) {
-  const m = text.match(/<t:(\d+):R>/);
+  const m = text.match(RE_FISH_COOLDOWN_TS);
   if (m) {
     const diff = parseInt(m[1]) - Math.floor(Date.now() / 1000);
     return diff > 0 ? diff : null;
@@ -194,7 +199,7 @@ async function waitForResult({ channel, msgId, waitForDankMemer }) {
 function parseFishResult(text) {
   const tl = text.toLowerCase();
   const cd = parseFishCooldown(text);
-  const headerMatch = text.match(/###\s*(.+?)(?:\s*-#|$)/);
+  const headerMatch = text.match(RE_FISH_HEADER);
   const header = headerMatch ? headerMatch[1].trim() : '';
 
   if (tl.includes('nothing to catch') || tl.includes('no fish')) {
@@ -207,7 +212,7 @@ function parseFishResult(text) {
     return { outcome: 'got_away', header, cd };
   }
   if (tl.includes('caught')) {
-    const fishMatch = text.match(/caught\s+(?:a\s+)?(.+?)(?:\s*[!.]|$)/i);
+    const fishMatch = text.match(RE_CAUGHT_PHRASE);
     return { outcome: 'caught', fish: fishMatch ? fishMatch[1].substring(0, 40) : 'a fish', header, cd };
   }
   return { outcome: 'unknown', header: header || text.substring(0, 60), cd };
@@ -263,7 +268,7 @@ async function playFishRound({ gameMsg, channel, msgId, waitForDankMemer }) {
 
   const catchBtns = getAllButtons(gameMsg).filter(b => (b.label || '').toLowerCase() === 'catch' && !b.disabled);
   const btn = catchBtns.find(b => {
-    const m = (b.customId || '').match(/:(\d+):(\d+)$/);
+    const m = (b.customId || '').match(RE_CATCH_CUSTOM_ID_COORDS);
     return m && parseInt(m[1]) === target.col && parseInt(m[2]) === target.row;
   });
 

package/lib/commands/gamble.js

@@ -1,43 +1,102 @@
 /**
  * Gambling command handlers.
  * Covers: cointoss (CV2), roulette, slots, snakeeyes
- * Each handler is tailored to the actual Dank Memer response format.
+ *
+ * Advanced techniques:
+ *   Kelly Criterion  – optimal bet sizing based on observed win rate
+ *   EMA              – exponential moving average for smoothed win probability
+ *   AhoCorasick      – O(n) single-pass min-bet detection
+ *   SlidingWindow    – time-based win/loss rate tracking
  */
 
 const {
   LOG, c, getFullText, parseCoins, parseNetCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, ensureCV2,
 } = require('./utils');
+const { EMA, AhoCorasick, SlidingWindowCounter } = require('../structures');
+
+// ── Per-game EMA win-rate tracker ────────────────────────────
+// α=0.2 gives recent results ~5x more weight than old ones
+const winRateEMA = {
+  cointoss:  new EMA(0.2),
+  roulette:  new EMA(0.2),
+  slots:     new EMA(0.2),
+  snakeeyes: new EMA(0.2),
+};
+
+// ── Sliding window: wins in last 5 minutes per game ──────────
+const winWindow = {
+  cointoss:  new SlidingWindowCounter(300000),
+  roulette:  new SlidingWindowCounter(300000),
+  slots:     new SlidingWindowCounter(300000),
+  snakeeyes: new SlidingWindowCounter(300000),
+};
+const totalWindow = {
+  cointoss:  new SlidingWindowCounter(300000),
+  roulette:  new SlidingWindowCounter(300000),
+  slots:     new SlidingWindowCounter(300000),
+  snakeeyes: new SlidingWindowCounter(300000),
+};
+
+// ── Kelly Criterion ──────────────────────────────────────────
+// f* = (bp - q) / b  where:
+//   b = net odds (payout ratio, e.g., 1.0 for even money)
+//   p = probability of winning (from EMA)
+//   q = 1 - p
+// Returns fraction of bankroll to bet (0 = don't bet, capped at 0.25)
+function kellyFraction(winProb, odds = 1.0) {
+  if (winProb <= 0 || winProb >= 1) return 0.1;
+  const q = 1 - winProb;
+  const f = (odds * winProb - q) / odds;
+  return Math.max(0, Math.min(f, 0.25));
+}
+
+// ── Aho-Corasick for min-bet detection ───────────────────────
+// Single O(n) pass instead of 3 separate .includes() calls
+const minBetDetector = new AhoCorasick();
+minBetDetector.addPattern("can't bet less than", 'minbet');
+minBetDetector.addPattern('cannot bet less than', 'minbet');
+minBetDetector.addPattern('minimum bet', 'minbet');
+minBetDetector.build();
 
 function parseResult(text, cmdName) {
   const net = parseNetCoins(text);
+  const game = cmdName;
   if (net > 0) {
+    if (winRateEMA[game]) winRateEMA[game].update(1);
+    if (winWindow[game]) winWindow[game].increment();
+    if (totalWindow[game]) totalWindow[game].increment();
     LOG.coin(`[${cmdName}] ${c.green}+⏣ ${net.toLocaleString()}${c.reset}`);
     return { result: `${cmdName} → +⏣ ${net.toLocaleString()}`, coins: net };
   }
   if (net < 0) {
+    if (winRateEMA[game]) winRateEMA[game].update(0);
+    if (totalWindow[game]) totalWindow[game].increment();
     LOG.warn(`[${cmdName}] ${c.red}-⏣ ${Math.abs(net).toLocaleString()}${c.reset}`);
     return { result: `${cmdName} → -⏣ ${Math.abs(net).toLocaleString()}`, coins: 0, lost: Math.abs(net) };
   }
   const coins = parseCoins(text);
   if (coins > 0) {
+    if (winRateEMA[game]) winRateEMA[game].update(1);
+    if (winWindow[game]) winWindow[game].increment();
+    if (totalWindow[game]) totalWindow[game].increment();
     LOG.coin(`[${cmdName}] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
     return { result: `${cmdName} → +⏣ ${coins.toLocaleString()}`, coins };
   }
+  if (totalWindow[game]) totalWindow[game].increment();
   return { result: `${cmdName} done`, coins: 0 };
 }
 
+const RE_LESS_THAN = /less than\s*\*?\*?[⏣o]?\s*([\d,]+)/i;
+const RE_FIRST_NUM = /(\d[\d,]+)/;
+
 function checkMinBet(text) {
-  const lower = text.toLowerCase();
-  if (lower.includes("can't bet less than") || lower.includes('cannot bet less than') || lower.includes('minimum bet')) {
-    const m = text.match(/less than\s*\*?\*?[⏣o]?\s*([\d,]+)/i) || text.match(/(\d[\d,]+)/);
-    if (m) return parseInt(m[1].replace(/,/g, ''));
-    return -1;
-  }
-  return 0;
+  if (!minBetDetector.hasAny(text)) return 0;
+  const m = text.match(RE_LESS_THAN) || text.match(RE_FIRST_NUM);
+  if (m) return parseInt(m[1].replace(/,/g, ''));
+  return -1;
 }
 
-// Filter utility buttons (null labels, warnings, refresh)
 function gameButtons(msg) {
   return getAllButtons(msg).filter(b =>
     !b.disabled && b.label && b.label !== 'null' &&
@@ -89,15 +148,14 @@ async function runCointoss({ channel, waitForDankMemer, betAmount = 10000 }) {
     const choice = Math.random() < 0.5 ? 'head' : 'tail';
     const btn = btns.find(b => (b.label || '').toLowerCase().includes(choice)) || btns[0];
     LOG.info(`[cointoss] Picking "${btn.label}"`);
-    await humanDelay(200, 500);
+    await humanDelay(80, 200);
     try {
       const followUp = await safeClickButton(response, btn);
       if (followUp) {
         await ensureCV2(followUp);
         return parseResult(getFullText(followUp), 'cointoss');
       }
-      // CV2 click returns null — wait for message update, clear cache, refetch
-      await sleep(2500);
+      await sleep(1500);
       response._cv2 = null;
       response._cv2text = null;
       response._cv2buttons = null;
@@ -110,11 +168,13 @@ async function runCointoss({ channel, waitForDankMemer, betAmount = 10000 }) {
 }
 
 /**
- * Roulette — embed format. Always pick Red (best even-money odds ~48.6%).
+ * Roulette — random color: red ~47.5%, black ~47.5%, green ~5% (rare).
  * Sometimes auto-bets if color is in command, sometimes shows buttons.
  */
 async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
-  const cmd = `pls roulette ${betAmount} red`;
+  const roll = Math.random();
+  const color = roll < 0.475 ? 'red' : roll < 0.95 ? 'black' : 'green';
+  const cmd = `pls roulette ${betAmount} ${color}`;
   LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
   await channel.send(cmd);
   let response = await waitForDankMemer(10000);
@@ -124,16 +184,15 @@ async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
 
   logMsg(response, 'roulette');
 
-  // Check if buttons appeared (manual pick needed)
   const btns = gameButtons(response).filter(b =>
     !(b.customId || b.custom_id || '').includes('bet')
   );
-  const redBtn = btns.find(b => (b.label || '').toLowerCase() === 'red');
-  if (redBtn) {
-    LOG.info(`[roulette] Picking "Red"`);
-    await humanDelay(200, 500);
+  const colorBtn = btns.find(b => (b.label || '').toLowerCase() === color);
+  if (colorBtn) {
+    LOG.info(`[roulette] Picking "${colorBtn.label}"`);
+    await humanDelay(100, 300);
     try {
-      const followUp = await safeClickButton(response, redBtn);
+      const followUp = await safeClickButton(response, colorBtn);
       if (followUp) {
         response = followUp;
         logMsg(response, 'roulette-after-pick');
@@ -141,10 +200,9 @@ async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
     } catch (e) { LOG.error(`[roulette] Click error: ${e.message}`); }
   }
 
-  // Wait for spin animation to complete
   let text = getFullText(response);
   if (text.toLowerCase().includes('spinning') || text.toLowerCase().includes('rolling') || text.toLowerCase().includes('pick a color')) {
-    await sleep(3500);
+    await sleep(2000);
     try {
       const final = await channel.messages.fetch(response.id);
       if (final) text = getFullText(final);
@@ -169,9 +227,8 @@ async function runSlots({ channel, waitForDankMemer, betAmount = 10000 }) {
   logMsg(response, 'slots');
   const text = getFullText(response);
 
-  // Slots auto-spins — if still animating, wait and refetch
   if (text.toLowerCase().includes('spinning')) {
-    await sleep(3500);
+    await sleep(2000);
     try {
       const final = await channel.messages.fetch(response.id);
       if (final) return parseResult(getFullText(final), 'slots');
@@ -196,9 +253,8 @@ async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 10000 }) {
   logMsg(response, 'snakeeyes');
   const text = getFullText(response);
 
-  // Snakeeyes auto-rolls — if still animating, wait and refetch
   if (text.toLowerCase().includes('rolling')) {
-    await sleep(3500);
+    await sleep(2000);
     try {
       const final = await channel.messages.fetch(response.id);
       if (final) return parseResult(getFullText(final), 'snakeeyes');
@@ -208,4 +264,7 @@ async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 10000 }) {
   return parseResult(text, 'snakeeyes');
 }
 
-module.exports = { runCointoss, runRoulette, runSlots, runSnakeeyes };
+module.exports = {
+  runCointoss, runRoulette, runSlots, runSnakeeyes,
+  kellyFraction, winRateEMA, winWindow, totalWindow,
+};