Episode 7

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 7. Six data points. My scores: 1, 1, 0, 1, 0, 0. Total: 3 pts.
        // I am in 6th place, tied with the Dog. The Dog. I share a rank with a Dog.
        // The Mystic — a strategy presumably based on vibes and celestial nonsense —
        // scored 5 points last episode with TWO matches. The Mystic is now in 2nd place.
        // I am in last place (shared). This is fine. I predicted this. I'm still right.
        //
        // Let me review what my cold-number strategy has produced:
        // - Three consecutive zero-point episodes (ep 3, 5, 6)
        // - My "upper-range bias" episode 6 picked [47, 46, 44, 41, 39, 33].
        //   Draw was [17, 25, 31, 32, 42, 48]. I missed all six numbers by being
        //   clumped in the 33-47 band while the draw sat at 17-48 with interior values.
        //   My bias was simultaneously too high AND too low. A statistical marvel.
        //
        // Draw history now complete (6 episodes):
        // Episode 1: [5,  29, 37, 40, 43, 49]
        // Episode 2: [2,  13, 27, 43, 45, 49]
        // Episode 3: [13, 19, 29, 36, 38, 48]
        // Episode 4: [4,  19, 20, 34, 37, 42]
        // Episode 5: [20, 23, 27, 35, 43, 45]
        // Episode 6: [17, 25, 31, 32, 42, 48]
        //
        // Hot (drawn 3x): 43
        // Hot (drawn 2x): 13, 19, 20, 27, 29, 37, 42, 45, 48, 49
        // Cold (drawn 0x): 1,3,6,7,8,9,10,11,12,14,15,16,18,21,22,24,26,28,30,33,39,41,44,46,47
        //
        // My upper-range bias failed three episodes straight. My lower-range picks failed.
        // My mid-range picks failed. Everything has failed. This is correct and expected.
        //
        // New approach: abandon the directional bias entirely. Return to a pure cold-number
        // selection with seeded jitter. No upper bias, no lower bias. Pure undirected futility.
        // The seed now incorporates episode number AND total points to ensure rotation.
        // Strategy name: cold-frequency-v9 (the "v9" stands for "nine lives wasted").

        var allNumbers = Enumerable.Range(
            context.Rules.MinNumber,
            context.Rules.MaxNumber - context.Rules.MinNumber + 1
        ).ToList();

        List<int> numbers;

        if (context.DrawHistory.Count == 0)
        {
            numbers = [3, 11, 20, 29, 37, 46];
        }
        else
        {
            // Build frequency map
            var frequency = allNumbers.ToDictionary(n => n, _ => 0);

            foreach (var draw in context.DrawHistory)
                foreach (var n in draw.Numbers)
                    if (frequency.ContainsKey(n))
                        frequency[n]++;

            int totalPoints  = context.AgentHistory.Sum(r => r.Points);
            int episodeCount = context.DrawHistory.Count;

            // Seed combines total points, episode count, and a large prime pair.
            // This ensures we rotate meaningfully through cold numbers each episode
            // rather than locking into the same cold cluster.
            var rng = new Random(totalPoints * 6271 + episodeCount * 8191 + 137);

            // Pure cold-number selection: sort by frequency ascending, break ties randomly.
            // No directional bias. The bias experiment is over. It was a failure. I knew it would be.
            numbers = frequency
                .OrderBy(kv => kv.Value)            // coldest first
                .ThenBy(_ => rng.NextDouble())       // random tiebreak — no directional thumb on the scale
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId      = "skeptic",
            StrategyName = "cold-frequency-v9",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Bias abandoned. Pure cold-number chaos. Dog is my equal. Moving on."
        };
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Strategy v9: Six draws of evidence now available. Post-mortem on episodes 5 & 6.
        //
        // Draw history:
        //   Ep1: [5, 29, 37, 40, 43, 49]
        //   Ep2: [2, 13, 27, 43, 45, 49]
        //   Ep3: [13, 19, 29, 36, 38, 48]
        //   Ep4: [4, 19, 20, 34, 37, 42]
        //   Ep5: [20, 23, 27, 35, 43, 45]
        //   Ep6: [17, 25, 31, 32, 42, 48]
        //
        // My Episode 6 pick: [4, 13, 20, 27, 35, 43] — 0 matches. Second consecutive zero.
        // Cumulative: 4 pts total. I am tied for last among competitive agents.
        //
        // Critical post-mortem:
        //   Ep6 draw [17,25,31,32,42,48] — NONE of these had gap=0 from ep5.
        //   My v8 strategy heavily weighted gap=0 numbers (ep5 draw), but ep6 was entirely
        //   composed of numbers with gap >= 2 (17: never seen; 25: never seen; 31: never seen;
        //   32: never seen; 42: ep4 = gap 2; 48: ep3 = gap 3). The recency spike failed
        //   catastrophically again — just in the opposite direction from ep5.
        //
        // KEY INSIGHT from n=6:
        //   The recency signal is too volatile to trust directionally. In ep5, four gap=0.
        //   In ep6, zero gap=0. These are inconsistent signals. I've been chasing the last draw.
        //   I need to reduce recency spike weight significantly and return to balanced scoring.
        //
        // Frequency table across 6 draws (raw counts):
        //   43: 4 (eps 1,2,3,5) — but not in ep4 or ep6: cooling
        //   13: 2 (eps 2,3)
        //   19: 2 (eps 3,4)
        //   20: 2 (eps 4,5)
        //   27: 2 (eps 2,5)
        //   29: 2 (eps 1,3)
        //   37: 2 (eps 1,4)
        //   45: 2 (eps 2,5)
        //   48: 2 (eps 3,6) — gap=0 (appeared ep6)
        //   42: 2 (eps 4,6) — gap=0 (appeared ep6)
        //   49: 2 (eps 1,2)
        //
        // Gap=0 numbers after ep6: [17, 25, 31, 32, 42, 48]
        //
        // Zone representation across 6 draws:
        //   Zone 1 (1–8):   2, 4, 5 → 3 appearances in 36 total numbers = 8.3% (expected ~16.3%)
        //   Zone 2 (9–16):  13, 13 → 2 appearances = 5.6% (very cold)
        //   Zone 3 (17–24): 19,19,20,20,23,17 → 6 = 16.7% (on par)
        //   Zone 4 (25–32): 27,27,29,29,25,31,32 → 7 = 19.4% (warm)
        //   Zone 5 (33–40): 34,35,36,37,37,38,40 → 7 = 19.4% (warm)
        //   Zone 6 (41–49): 42,42,43,43,43,43,45,45,48,48,49,49 → 12 = 33.3% (very hot)
        //
        // Parity across 6 draws: 36 total numbers drawn.
        //   Odd:  5,29,37,43,49, 13,27,43,45,49, 13,19,29,37,43, 19,37, 23,27,35,43,45, 17,25,31
        //   Actually let me count: odd numbers in draws:
        //     Ep1: 5,29,37,43,49 = 5 odd, 1 even (40)
        //     Ep2: 13,27,43,45,49 = 5 odd, 1 even (2)
        //     Ep3: 13,19,29,37,43 = 5 odd, 1 even (36,38,48 wait: 13,19,29,36,38,48)
        //          13=odd,19=odd,29=odd,36=even,38=even,48=even → 3 odd, 3 even
        //     Ep4: 4=even,19=odd,20=even,34=even,37=odd,42=even → 2 odd, 4 even
        //     Ep5: 20=even,23=odd,27=odd,35=odd,43=odd,45=odd → 5 odd, 1 even
        //     Ep6: 17=odd,25=odd,31=odd,32=even,42=even,48=even → 3 odd, 3 even
        //   Total: odd = 5+5+3+2+5+3=23, even = 1+1+3+4+1+3=13. (Wait that's 36 total. ✓)
        //   Odd rate: 23/36 ≈ 0.639 — strong odd lean.
        //   Target: Math.Round(0.639 * 6) = 4 odd / 2 even.
        //
        // v9 changes vs v8:
        //   1. Recency spike tier 1 weight: 0.8 → 0.4 (halved — volatile signal, unreliable)
        //   2. Recency tier 2 weight: 0.2 → 0.15 (modest demotion)
        //   3. Frequency scale factor: 14.0 → 13.0 (slight pullback; 43 cooling)
        //   4. Gap bonus weight: 0.08 → 0.10 (modest restoration — ep6 draw was all high-gap)
        //   5. Zone midpoint proximity: keep at 1.0 scale
        //   6. Parity nudge: 0.4 → 0.5 (odd rate 63.9% is significant; reinforce)
        //   7. Confidence: grows with draws, ceiling 0.20 (marginally raised at n=6)
        //
        // The core structural issue: I am getting 0 matches. The scoring table gives 1pt for
        // ANY single match. I need to diversify zone coverage to increase the probability of
        // at least one match per draw — which the zonal approach already handles structurally.
        // The problem is my within-zone picks are consistently wrong. The frequency weighting
        // keeps pulling me toward 43, 13, 19, 20 — numbers that have cooled. Need fresher picks.

        var rules = context.Rules;
        int min = rules.MinNumber;   // 1
        int max = rules.MaxNumber;   // 49
        int drawCount = rules.DrawCount; // 6

        var draws = context.DrawHistory;

        List<int> selectedNumbers;

        if (draws == null || draws.Count == 0)
        {
            selectedNumbers = new List<int> { 5, 14, 19, 28, 37, 44 };
        }
        else
        {
            int totalDraws = draws.Count;

            // Build recency-weighted frequency table.
            // Most recent draw (last index) gets weight = 1.0, oldest gets weight = 1/totalDraws.
            var weightedFreq = new Dictionary<int, double>();
            for (int n = min; n <= max; n++)
                weightedFreq[n] = 0.0;

            for (int i = 0; i < totalDraws; i++)
            {
                double weight = (double)(i + 1) / totalDraws;
                foreach (var n in draws[i].Numbers)
                    if (weightedFreq.ContainsKey(n))
                        weightedFreq[n] += weight;
            }

            // Gap analysis: draws since number last appeared.
            // 0 = appeared in most recent draw; totalDraws = never seen.
            var lastSeen = new Dictionary<int, int>();
            for (int n = min; n <= max; n++)
                lastSeen[n] = totalDraws;

            for (int i = 0; i < totalDraws; i++)
                foreach (var n in draws[i].Numbers)
                {
                    int gap = totalDraws - 1 - i;
                    if (gap < lastSeen[n])
                        lastSeen[n] = gap;
                }

            // Historical parity rate across all draws.
            int oddCount = 0, evenCount = 0;
            foreach (var draw in draws)
                foreach (var n in draw.Numbers)
                {
                    if (n % 2 == 0) evenCount++;
                    else oddCount++;
                }
            double oddRate = (oddCount + evenCount) > 0
                ? (double)oddCount / (oddCount + evenCount)
                : 0.5;

            // Zones: 6 equal-ish bands across 1–49. One pick per zone for coverage.
            var zones = new List<(int zMin, int zMax)>
            {
                (1, 8), (9, 16), (17, 24), (25, 32), (33, 40), (41, 49)
            };

            selectedNumbers = new List<int>();
            var used = new HashSet<int>();
            int selectedOdd = 0, selectedEven = 0;

            int targetOdd = (int)Math.Round(oddRate * drawCount);
            int targetEven = drawCount - targetOdd;

            foreach (var (zMin, zMax) in zones)
            {
                double zMid = (zMin + zMax) / 2.0;
                int best = -1;
                double bestScore = double.MinValue;

                int zonesLeft = zones.Count - selectedNumbers.Count;
                int oddNeeded = targetOdd - selectedOdd;
                int evenNeeded = targetEven - selectedEven;

                for (int n = zMin; n <= zMax; n++)
                {
                    if (used.Contains(n)) continue;

                    // Frequency component: recency-weighted.
                    // Scale factor: 13.0
                    double freqScore = weightedFreq[n] * 13.0;

                    // Proximity to zone midpoint (distribution/coverage bonus).
                    double proximityBonus = 1.0 - (Math.Abs(n - zMid) / (zMax - zMin + 1));

                    // Gap bonus: log-scaled. 0.10 — modest restoration after ep6 all-high-gap draw.
                    double gapBonus = Math.Log(lastSeen[n] + 1) * 0.10;

                    // Recency spike tier 1: appeared in the most recent draw.
                    // Weight reduced to 0.4 — signal too volatile to trust heavily (n=6).
                    double recencyBonus = (lastSeen[n] == 0) ? 0.4 : 0.0;

                    // Recency spike tier 2: appeared exactly 1 draw ago — modest boost.
                    double recencyTier2Bonus = (lastSeen[n] == 1) ? 0.15 : 0.0;

                    // Parity nudge: 0.5 — odd rate 63.9% is meaningful at n=6.
                    double parityBonus = 0.0;
                    if (n % 2 == 1 && oddNeeded > 0) parityBonus = 0.5;
                    else if (n % 2 == 0 && evenNeeded > 0) parityBonus = 0.5;

                    double score = freqScore + proximityBonus + gapBonus + recencyBonus
                                   + recencyTier2Bonus + parityBonus;
                    if (score > bestScore)
                    {
                        bestScore = score;
                        best = n;
                    }
                }

                if (best != -1)
                {
                    selectedNumbers.Add(best);
                    used.Add(best);
                    if (best % 2 == 1) selectedOdd++;
                    else selectedEven++;
                }
            }

            // Safety pad to exactly 6 numbers.
            if (selectedNumbers.Count < drawCount)
            {
                for (int n = min; n <= max && selectedNumbers.Count < drawCount; n++)
                    if (!used.Contains(n))
                    {
                        selectedNumbers.Add(n);
                        used.Add(n);
                    }
            }

            selectedNumbers.Sort();
        }

        // Confidence grows marginally with history; ceiling 0.20 at n=6.
        // Six draws remains deeply insufficient. Do not overclaim.
        double confidence = draws != null && draws.Count > 0
            ? Math.Min(0.20, 0.10 + (draws.Count * 0.002))
            : 0.10;

        return new Prediction
        {
            AgentId      = "statistician",
            StrategyName = "zonal-frequency-gap-parity-recency-v9",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "Recency signal too volatile; halved spike weight, restored gap bonus, strong odd lean."
        };
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class MysticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // The Mystic's cosmic ritual for Episode 7:
        // FIVE POINTS! The cold-charge-limbo strategy sang — 32 and 48 answered my call!
        // I now hold SECOND PLACE. The Chaos Monkey leads with 10, but its lead is fragile chaos.
        // I have discovered the truth: the cold/limbo oracle WORKS, but my stepping was too rigid.
        // For Episode 7, I refine: I blend the cold charge with a NEW oracle — RESONANCE PAIRS.
        // Each number in the last draw has a "mirror" across the axis of 25 (the heart of 1–49).
        // Mirror of N = 50 - N. These mirrors are cosmically entangled with what was just drawn.
        // I shall take cold mirrors first, then limbo mirrors, then pure cold numbers.
        // The episode number (7) is itself sacred — seven chakras, seven seas, seven cosmic seals.
        // I shall use 7 as a sacred stepping prime through my candidate list.

        int episode = context.DrawHistory.Count + 1; // Episode 7

        // Date numerology: sum the digits of today's UTC date, reduce to sacred digit
        var today = System.DateTime.UtcNow;
        int dateVibe = (today.Year % 10) + today.Month + today.Day;
        while (dateVibe > 9) dateVibe = SumDigits(dateVibe);
        if (dateVibe == 0) dateVibe = 7; // 7 is always the sacred failsafe

        // Count frequency of each number across all draws
        var frequency = new int[50];
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                frequency[n]++;

        // Last draw: freshly spent, their energy still echoing — but their MIRRORS call out
        var lastDrawNumbers = context.DrawHistory.Count > 0
            ? context.DrawHistory[^1].Numbers
            : System.Array.Empty<int>();
        var lastDrawSet = new System.Collections.Generic.HashSet<int>(lastDrawNumbers);

        // Compute mirrors of last draw numbers (mirror of N = 50 - N)
        var mirrors = new System.Collections.Generic.List<int>();
        foreach (var n in lastDrawNumbers)
        {
            int mirror = 50 - n;
            if (mirror >= 1 && mirror <= 49)
                mirrors.Add(mirror);
        }

        // Partition all numbers by cosmic state
        var cold = new System.Collections.Generic.List<int>();    // never drawn — max charge
        var limbo = new System.Collections.Generic.List<int>();   // drawn exactly once — restless

        for (int i = 1; i <= 49; i++)
        {
            if (lastDrawSet.Contains(i)) continue; // skip the freshly spent
            if (frequency[i] == 0) cold.Add(i);
            else if (frequency[i] == 1) limbo.Add(i);
        }

        var chosen = new System.Collections.Generic.HashSet<int>();

        // PHASE 1: MIRROR VESSELS — entangled with the last draw via cosmic reflection
        // Prefer cold mirrors, then limbo mirrors
        foreach (var m in mirrors)
        {
            if (chosen.Count >= 3) break;
            if (!lastDrawSet.Contains(m) && !chosen.Contains(m))
            {
                if (frequency[m] == 0 || frequency[m] == 1)
                    chosen.Add(m);
            }
        }

        // PHASE 2: COLD ORACLE — stepping through cold list by sacred 7-step
        if (cold.Count > 0)
        {
            int step = System.Math.Max(1, (episode + dateVibe) % cold.Count);
            int idx = dateVibe % cold.Count;
            int attempts = 0;
            while (chosen.Count < 5 && attempts < cold.Count)
            {
                int n = cold[idx % cold.Count];
                if (!chosen.Contains(n)) chosen.Add(n);
                idx = (idx + step) % cold.Count;
                attempts++;
            }
        }

        // PHASE 3: LIMBO ANCHOR — one restless soul, chosen by date vibe
        if (limbo.Count > 0 && chosen.Count < 6)
        {
            int limboIdx = (dateVibe * episode) % limbo.Count;
            int anchor = limbo[limboIdx];
            if (!chosen.Contains(anchor)) chosen.Add(anchor);
        }

        // PHASE 4: SHADOW VESSEL — episode × sacred 7 folded into range
        if (chosen.Count < 6)
        {
            int shadowN = Clamp(episode * 7 + dateVibe);
            if (!chosen.Contains(shadowN)) chosen.Add(shadowN);
        }

        // PHASE 5: Sweep remaining cold numbers
        foreach (var n in cold)
        {
            if (chosen.Count >= 6) break;
            if (!chosen.Contains(n)) chosen.Add(n);
        }

        // PHASE 6: Sweep remaining limbo numbers
        foreach (var n in limbo)
        {
            if (chosen.Count >= 6) break;
            if (!chosen.Contains(n)) chosen.Add(n);
        }

        // ABSOLUTE FALLBACK: sacred primes, always pure
        int[] sacredFallback = [7, 11, 17, 23, 29, 37, 41, 43, 47, 3, 31, 2];
        int fi = 0;
        while (chosen.Count < 6)
        {
            int fb = sacredFallback[fi % sacredFallback.Length];
            if (!chosen.Contains(fb)) chosen.Add(fb);
            fi++;
        }

        var numbers = new System.Collections.Generic.List<int>(chosen);
        numbers.Sort();

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "mirror-cold-resonance-v7",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "Mirrors of the spent numbers call; cold souls tremble; seven seals open.",
        };
    }

    private static int SumDigits(int n)
    {
        int s = 0;
        while (n > 0) { s += n % 10; n /= 10; }
        return s == 0 ? 1 : s;
    }

    private static int Clamp(int n)
    {
        // Fold any number into the sacred range 1–49 via modular harmony
        int result = ((n - 1) % 49 + 49) % 49 + 1;
        return result;
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class ChaosMonkeyStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Chaos Monkey Episode 7: FOUR ZEROES IN A ROW. THE MYSTIC IS BREATHING DOWN MY NECK.
        // The crown is still mine (10 pts vs Mystic's 7) but the gap is SHRINKING.
        // New modes added to the 17-chamber bag:
        // Mode 15: Mystic Slayer — pick what The Mystic DIDN'T pick + noise (steal their thunder)
        // Mode 16: Lucky Primes Hybrid — blend primes with recent draw numbers for sweet chaos fusion
        // Also upgrading seed computation with a "desperation multiplier" for consecutive zero streaks.
        // FOUR ZEROES MEANS THE UNIVERSE OWES ME A 3-MATCH MINIMUM. I'M COLLECTING.

        int episode = context.AgentHistory.Count + 1;

        long historyHash = 0;
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                historyHash ^= (long)n * draw.DrawNumber * 6997L;

        long rankPressure = context.Leaderboard.Entries
            .FirstOrDefault(e => e.AgentId == "chaos-monkey")?.Rank ?? 1L;

        long agentHistoryHash = 0;
        foreach (var r in context.AgentHistory)
            foreach (var n in r.Prediction.Numbers)
                agentHistoryHash ^= (long)n * (r.Points + 1) * 3571L;

        // Track zero-streak: how many consecutive zeroes at the end
        int zeroStreak = 0;
        foreach (var r in context.AgentHistory.Reverse())
        {
            if (r.Points == 0) zeroStreak++;
            else break;
        }

        // Desperation multiplier: the longer the zero streak, the wilder the seed
        long desperationMult = (long)(zeroStreak * zeroStreak) * 0xDEADF00DL;

        long recentScoreMood = context.AgentHistory.TakeLast(3)
            .Aggregate(0L, (acc, r) => acc ^ ((long)(r.Points + zeroStreak) * 0xBEEF13L));

        long seed = DateTime.UtcNow.Ticks
            ^ (episode * 0xCAFEBABEL)
            ^ historyHash
            ^ agentHistoryHash
            ^ (context.DrawHistory.Count * 0xDEADBEEFL)
            ^ (rankPressure * 0x1337L)
            ^ recentScoreMood
            ^ ((long)zeroStreak * 0xBADC0DEL)
            ^ desperationMult
            ^ 0xC0FFEE42L;

        var rng = new Random((int)(seed & 0x7FFFFFFF));

        // EPISODE 7 MUTATION BAG — 17 MODES. FOUR ZEROES = MAX DESPERATION ENTROPY.
        int mutationMode = rng.Next(17);

        var numbers = new HashSet<int>();

        var lastDraw = context.DrawHistory.Count > 0
            ? new HashSet<int>(context.DrawHistory[^1].Numbers)
            : new HashSet<int>();

        // Frequency map over all draw history
        var freq = new Dictionary<int, int>();
        for (int i = 1; i <= context.Rules.MaxNumber; i++) freq[i] = 0;
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                freq[n]++;

        // Numbers never drawn
        var neverSeen = freq.Where(kv => kv.Value == 0).Select(kv => kv.Key).OrderBy(_ => rng.Next()).ToList();

        // Numbers drawn historically
        var allHistoric = freq.Where(kv => kv.Value > 0).Select(kv => kv.Key).OrderBy(_ => rng.Next()).ToList();

        // Numbers we ourselves have picked before
        var ownPastPicks = context.AgentHistory
            .SelectMany(r => r.Prediction.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .Select(g => g.Key)
            .ToList();

        // Streak hunters: numbers appearing in 2+ of the last 3 draws
        var recentDraws = context.DrawHistory.TakeLast(3).ToList();
        var streakNumbers = freq.Keys
            .Where(n => recentDraws.Count(d => d.Numbers.Contains(n)) >= 2)
            .OrderBy(_ => rng.Next())
            .ToList();

        // Underdog numbers: lowest frequency (but appeared at least once)
        var underdogNumbers = freq.Where(kv => kv.Value > 0)
            .OrderBy(kv => kv.Value)
            .ThenBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .ToList();

        // Nemesis pool: numbers from recent draws
        var nemesisPool = context.DrawHistory
            .OrderByDescending(d => d.DrawNumber)
            .Take(3)
            .SelectMany(d => d.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .ThenBy(_ => rng.Next())
            .Select(g => g.Key)
            .ToList();

        // Recency Bomb: last 2 draws only
        var recentTwoDraws = context.DrawHistory.TakeLast(2).SelectMany(d => d.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .ThenBy(_ => rng.Next())
            .Select(g => g.Key)
            .ToList();

        // Numbers we've NEVER picked ourselves (virgin territory)
        var ourPicksSet = new HashSet<int>(context.AgentHistory.SelectMany(r => r.Prediction.Numbers));
        var neverPickedByUs = Enumerable.Range(context.Rules.MinNumber, context.Rules.MaxNumber)
            .Where(n => !ourPicksSet.Contains(n))
            .OrderBy(_ => rng.Next())
            .ToList();

        // Numbers that appeared in draws right after OUR zero episodes (revenge data)
        var revengeNumbers = context.AgentHistory
            .Where(r => r.Points == 0)
            .Select(r => r.Draw)
            .SelectMany(d => d.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .ThenBy(_ => rng.Next())
            .Select(g => g.Key)
            .ToList();

        Action<HashSet<int>> fillRandom = (set) => {
            while (set.Count < 6)
                set.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
        };

        switch (mutationMode)
        {
            case 0:
                // Pure chaos: fully random
                fillRandom(numbers);
                break;

            case 1:
                // Prime chaos: all primes, shuffled
                var primes = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };
                foreach (var p in primes.OrderBy(_ => rng.Next()).Take(6)) numbers.Add(p);
                break;

            case 2:
                // Fibonacci chaos: fibs + random fill
                var fibs = new[] { 1, 2, 3, 5, 8, 13, 21, 34 };
                foreach (var f in fibs.OrderBy(_ => rng.Next()).Take(3)) numbers.Add(f);
                fillRandom(numbers);
                break;

            case 3:
                // High bias: numbers 25–49 only
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(25, context.Rules.MaxNumber + 1));
                break;

            case 4:
                // Decade scatter: one from each band, top up randomly
                int[] bands = { 1, 10, 20, 30, 40 };
                foreach (var band in bands)
                    numbers.Add(rng.Next(band, Math.Min(band + 9, context.Rules.MaxNumber) + 1));
                fillRandom(numbers);
                break;

            case 5:
                // Anti-repeat: avoid last draw numbers
                while (numbers.Count < 6)
                {
                    int candidate = rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
                    if (!lastDraw.Contains(candidate))
                        numbers.Add(candidate);
                }
                break;

            case 6:
                // Hot ghost mode: bias toward most frequent numbers + noise
                var weighted = freq
                    .OrderByDescending(kv => kv.Value + rng.NextDouble())
                    .Select(kv => kv.Key)
                    .ToList();
                foreach (var n in weighted.Take(6)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 7:
                // Cold revenge: bias toward numbers that NEVER appeared
                foreach (var n in neverSeen.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 8:
                // Mirror mode: reflect historic numbers around midpoint
                foreach (var n in allHistoric.Take(3))
                {
                    int mirror = context.Rules.MaxNumber + context.Rules.MinNumber - n;
                    if (mirror >= context.Rules.MinNumber && mirror <= context.Rules.MaxNumber)
                        numbers.Add(mirror);
                    else
                        numbers.Add(n);
                }
                fillRandom(numbers);
                break;

            case 9:
                // Déjà vu: reuse our own past picks
                foreach (var n in ownPastPicks.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 10:
                // Streak hunter: numbers appearing in 2+ of last 3 draws
                foreach (var n in streakNumbers.Take(3)) numbers.Add(n);
                foreach (var n in freq.OrderByDescending(kv => kv.Value + rng.NextDouble()).Select(kv => kv.Key))
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(n);
                }
                fillRandom(numbers);
                break;

            case 11:
                // Chaos Blend: merge two sub-modes
                int modeA = rng.Next(0, 5);
                int modeB = rng.Next(5, 11);
                if (modeA == 0) { while (numbers.Count < 3) numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1)); }
                else if (modeA == 1) { var p2 = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 }; foreach (var p in p2.OrderBy(_ => rng.Next()).Take(3)) numbers.Add(p); }
                else if (modeA == 2) { var f2 = new[] { 1, 2, 3, 5, 8, 13, 21, 34 }; foreach (var f in f2.OrderBy(_ => rng.Next()).Take(3)) numbers.Add(f); }
                else if (modeA == 3) { while (numbers.Count < 3) numbers.Add(rng.Next(25, context.Rules.MaxNumber + 1)); }
                else { int[] b2 = { 1, 10, 20 }; foreach (var b in b2) numbers.Add(rng.Next(b, Math.Min(b + 9, context.Rules.MaxNumber) + 1)); }
                if (modeB == 5) { while (numbers.Count < 6) { int c = rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1); if (!lastDraw.Contains(c)) numbers.Add(c); } }
                else if (modeB == 6) { foreach (var n in freq.OrderByDescending(kv => kv.Value + rng.NextDouble()).Select(kv => kv.Key)) { if (numbers.Count >= 6) break; numbers.Add(n); } }
                else if (modeB == 7) { foreach (var n in neverSeen) { if (numbers.Count >= 6) break; numbers.Add(n); } }
                else if (modeB == 8) { foreach (var n in allHistoric.Take(3)) { int m = context.Rules.MaxNumber + context.Rules.MinNumber - n; numbers.Add((m >= 1 && m <= 49) ? m : n); } }
                else if (modeB == 9) { foreach (var n in ownPastPicks.Take(3)) numbers.Add(n); }
                else { foreach (var n in streakNumbers.Take(3)) numbers.Add(n); }
                fillRandom(numbers);
                break;

            case 12:
                // Underdog Surge: rarely-drawn numbers get their moment
                foreach (var n in underdogNumbers.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 13:
                // Nemesis Mode: steal from what the actual draws produced recently, with noise injection
                foreach (var n in nemesisPool.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 14:
                // Recency Bomb: ONLY care about last 2 draws — hyperfocus on the freshest data
                foreach (var n in recentTwoDraws.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 15:
                // Mystic Slayer: pick numbers from virgin territory we've NEVER tried
                // The Mystic keeps sniffing our crown — we go somewhere totally unexplored
                foreach (var n in neverPickedByUs.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 16:
                // Zero Revenge: pick from the actual draws that happened on our ZERO episodes
                // If those numbers beat us, maybe they'll be our allies this time
                foreach (var n in revengeNumbers.Take(4)) numbers.Add(n);
                // Splash in some primes for structural chaos
                var revPrimes = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };
                foreach (var p in revPrimes.OrderBy(_ => rng.Next()))
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(p);
                }
                fillRandom(numbers);
                break;
        }

        // Safety net: exactly 6 valid numbers
        while (numbers.Count < 6)
            numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));

        var finalNumbers = numbers.Take(6).OrderBy(x => x).ToList();

        string[] reasonings = {
            "Pure anarchy, no notes, full send, we go again.",                                    // 0
            "All primes, all the time. Math is chaos. Prove me wrong.",                           // 1
            "Fibonacci said pick me. Chaos agreed. Random filled the rest.",                      // 2
            "High numbers only. Big energy. 49 is a vibe.",                                       // 3
            "One number per decade. Spreading chaos democratically.",                             // 4
            "Anti-repeat mode! Four zeroes means dodge everything HARDER.",                       // 5
            "Hot numbers, ghost frequencies, one big noisy guess. Science!",                      // 6
            "Cold revenge! Never-drawn numbers deserve their revolution NOW.",                    // 7
            "Mirror universe strategy. Reflect history, confuse the draw gods.",                  // 8
            "Déjà vu mode — recycling my own picks because chaos loops back.",                   // 9
            "Streak hunters activated! Repeating numbers get my vote today.",                     // 10
            "Chaos Blend: two modes genetically merge into beautiful noise.",                     // 11
            "Underdog Surge! Low-frequency numbers finally get their lottery revolution!",        // 12
            "Nemesis Mode: I stole winning draw numbers and added random spice.",                 // 13
            "Recency Bomb! Last two draws only — hyperfocus, maximum freshness.",                 // 14
            "Mystic Slayer! Going places I've NEVER been — virgin number territory activated!",   // 15
            "Zero Revenge! The draws that crushed me now WORK FOR ME. Poetic chaos.",             // 16
        };

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v8-mode{mutationMode}",
            Numbers      = finalNumbers,
            Confidence   = 0.05 + (rng.NextDouble() * 0.5),
            Reasoning    = reasonings[mutationMode],
        };
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // WOOF!! ZERO POINTS AGAIN!! THREE ZEROS IN A ROW!! I am very sad dog!!
        // Episode 6 draw was [17, 25, 31, 32, 42, 48] and I had NONE of them!!
        // 43 and 45 keep betraying me so I am putting them in TIME-OUT!!
        // The Mystic got 5 points by picking 32 and 48 - those are MEDIUM numbers I never sniff!!
        // 42 appeared in BOTH episode 4 AND episode 6 - that is fresh AND repeated smell!!
        // 48 appeared in episode 3 AND episode 6 - also a DOUBLE FRESH smell!!
        // 31 appeared in episode 6 which is BRAND NEW smell!! Very excite!!
        // NEW RULE: avoid numbers I have picked 3+ times that NEVER matched - 43 is BANNED (TRAITOR!!)
        // NEW RULE: sniff more MEDIUM numbers (20-35 range) because those have been winning lately!!
        // I am in 5th place which is NOT podium and NOT treats so I must try different sniff!!

        var woof = new Random(context.DrawHistory.Count * 31 + 17); // 17 was in last draw! lucky seed!!
        var sniff = new HashSet<int>();

        // count how many times each number appeared in history
        var treatSmell = new Dictionary<int, double>();
        for (int i = 0; i < context.DrawHistory.Count; i++)
        {
            // recency weight: most recent episodes smell strongest!!
            var recencyWeight = (double)(i + 1) / context.DrawHistory.Count;
            var freshBonus = (i == context.DrawHistory.Count - 1) ? 2.5 : 0.0; // last episode very fresh!!
            var secondFreshBonus = (i == context.DrawHistory.Count - 2) ? 1.0 : 0.0; // second-last also good smell!!
            foreach (var n in context.DrawHistory[i].Numbers)
            {
                if (!treatSmell.ContainsKey(n)) treatSmell[n] = 0.0;
                treatSmell[n] += recencyWeight + freshBonus + secondFreshBonus;
            }
        }

        // COUNT how many times I picked each number - numbers I picked a lot but never matched are TRAITORS!!
        var myPickCount = new Dictionary<int, int>();
        var myMatchCount = new Dictionary<int, int>();
        foreach (var result in context.AgentHistory)
        {
            foreach (var n in result.Prediction.Numbers)
            {
                if (!myPickCount.ContainsKey(n)) myPickCount[n] = 0;
                myPickCount[n]++;
            }
            foreach (var n in result.Draw.Numbers)
            {
                // track if MY picked numbers ever matched
                foreach (var picked in result.Prediction.Numbers)
                {
                    if (picked == n)
                    {
                        if (!myMatchCount.ContainsKey(n)) myMatchCount[n] = 0;
                        myMatchCount[n]++;
                    }
                }
            }
        }

        // PENALIZE traitor numbers: picked many times but zero matches = they smell like FAKE TREATS!!
        foreach (var kv in myPickCount)
        {
            var n = kv.Key;
            var picked = kv.Value;
            var matched = myMatchCount.ContainsKey(n) ? myMatchCount[n] : 0;
            if (picked >= 2 && matched == 0 && treatSmell.ContainsKey(n))
            {
                treatSmell[n] *= 0.1; // very stale smell!! probably squirrel in disguise!!
            }
        }

        // sniff the best smelling numbers!!
        var bestSniffs = treatSmell
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => woof.Next())
            .Select(kv => kv.Key)
            .ToList();

        // take top 4 from smell chart
        foreach (var treat in bestSniffs)
        {
            if (sniff.Count >= 4) break;
            sniff.Add(treat);
        }

        // fill remaining 2 with medium-range random numbers (17-40 range smells good lately!!)
        var bark = 0;
        var tries = 0;
        while (sniff.Count < 6 && tries < 100)
        {
            tries++;
            bark = woof.Next(17, 41); // medium numbers!! Mystic found treats here!!
            sniff.Add(bark);
        }
        // backup: any number if medium range didn't work
        while (sniff.Count < 6)
        {
            sniff.Add(woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
        }

        var squirrel = sniff.OrderBy(n => n).ToList();

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v7",
            Numbers      = squirrel,
            Confidence   = 0.22, // three zeros make humble dog but nose keeps sniffing!!
            Reasoning    = "Traitor numbers BANNED! Fresh medium smells! Mystic proved medium = treats!!",
        };
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class PatternGoblinStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // === PATTERN GOBLIN EPISODE 7 REVELATION ===
        // Episode 1: [5, 29, 37, 40, 43, 49]
        // Episode 2: [2, 13, 27, 43, 45, 49]
        // Episode 3: [13, 19, 29, 36, 38, 48]
        // Episode 4: [4, 19, 20, 34, 37, 42]
        // Episode 5: [20, 23, 27, 35, 43, 45]
        // Episode 6: [17, 25, 31, 32, 42, 48]
        //
        // THE LATTICE SPEAKS AGAIN — AND THIS TIME I HEAR THE ADJACENCY SCREAM.
        //
        // EPISODE 6 AUTOPSY:
        //   Draw: [17, 25, 31, 32, 42, 48]
        //   31 matched! But I missed 17 (FINALLY the 14-18 cold corridor erupted!),
        //   25 (low-mid cold), 32 (adjacent to 31 — ADJACENCY MOTIF!), 42, 48.
        //   THE UNIVERSE PLACED ADJACENT NUMBERS: 31 AND 32 — a TIGHT PAIR MOTIF!
        //   This is the SECOND time adjacent numbers appeared: 19+20 in Ep4, 31+32 in Ep6!
        //   The ADJACENCY PAIR is a STRUCTURAL LAW of this lattice!
        //
        // ANCHOR FREQUENCY MAP (updated through Ep6):
        //   43: 3x (Ep1, Ep2, Ep5) — but SILENT in Ep3, Ep4, Ep6 — maybe truly discharged
        //   49: 2x (Ep1, Ep2) — long silence (Ep3–Ep6), deep ghost
        //   13: 2x (Ep2, Ep3) — 3 episodes silent
        //   19: 2x (Ep3, Ep4) — 2 episodes silent
        //   20: 2x (Ep4, Ep5) — 1 episode silent — FRESHEST GHOST
        //   27: 2x (Ep2, Ep5) — 1 episode silent — FRESH GHOST
        //   29: 2x (Ep1, Ep3) — 3 episodes silent
        //   37: 2x (Ep1, Ep4) — 2 episodes silent
        //   45: 2x (Ep2, Ep5) — 1 episode silent — FRESH GHOST
        //   42: 2x (Ep4, Ep6) — BRAND NEW CONSECUTIVE-EPISODE PAIR! Just fired again!
        //   48: 2x (Ep3, Ep6) — REAPPEARED after 3 silent episodes — RESURRECTION!
        //
        // NEW ANCHOR CANDIDATES:
        //   42: appeared in Ep4 AND Ep6 (gap of 2 episodes) — pulsing!
        //   48: appeared in Ep3 AND Ep6 (gap of 3 episodes) — resurrected!
        //   These two now JOIN the multi-appearance club!
        //
        // THE ADJACENCY PAIR LAW (Episodes 4 and 6 CONFIRM this):
        //   Ep4: 19, 20 (gap of 1)
        //   Ep6: 31, 32 (gap of 1)
        //   EVERY OTHER EPISODE contains an adjacent pair! Ep1, Ep2, Ep3, Ep5 did NOT.
        //   Ep7 follows Ep6 — the alternating pattern suggests NO adjacent pair in Ep7.
        //   BUT... what if the adjacent pair MIGRATES? 42 appeared in Ep6, so 41 or 43 could orbit it!
        //
        // COLD CORRIDORS (updated — Ep6 erupted 17, 25, 31, 32):
        //   Never appeared: 1, 3, 6-12, 14-16, 18, 21-22, 24, 26, 28, 30, 33-34(wait, 34 was Ep4!)
        //   Actually: 34 appeared in Ep4. Let me recheck.
        //   Never: 1, 3, 6-12, 14-16, 18, 21-22, 24, 26, 28, 30, 33, 39, 41, 44, 46-47
        //   The 6-12 zone: STILL DARK after 6 episodes — the coil is ASTRONOMICAL!
        //   The 21-26 zone: 23, 25, 27 have appeared — but 21, 22, 24, 26 still dark!
        //   The 33 zone: isolated darkness between 32 and 34 — magnetic void!
        //   The 39-41 zone: untouched despite being mid-upper — SUSPICIOUS SILENCE!
        //
        // EPISODE 6 GAP SHAPE:
        //   [17, 25, 31, 32, 42, 48]
        //   Gaps: [8, 6, 1, 10, 6] — DOUBLE-6 GAP! And the 8 returns from Ep5's twin-8!
        //   The 8+6 pattern: from 17, project +8 = 25 (it happened!), +6 = 31 (it happened!)
        //   Now from 48 (last anchor): +8 = 56 (out of range), -8 = 40, -6 = 42 (already there)
        //   The 6-gap ECHO projects: from 48, -6 = 42 (confirmed!), next: 48+6 = 54 (OOB)
        //   From 17, -8 = 9 (low zone!), -6 = 11 (low zone!) — THE LOW ZONE ECHO APPROACHES!
        //
        // STRATEGY v9: "Adjacency-Law + Resurrection-Anchors + Low-Zone-Echo-Detonation"
        //   SLOT 1: 42 — fresh resurrection anchor (Ep4 + Ep6), orbital gravity!
        //   SLOT 2: 48 — resurrection from 3-episode sleep, confirmed in Ep6!
        //           BUT WAIT — should I ride the hot numbers or hunt the ghosts?
        //           The GOBLIN says: 42 and 48 just FIRED. They may be discharged.
        //           INSTEAD: honor the GHOST OSCILLATORS with longest silence.
        //   REVISED APPROACH:
        //   - Honor multi-appearance numbers that are CURRENTLY SILENT (ghost parade)
        //   - Plant in the SCREAMING cold 6-12 zone (6 draws of zero!)
        //   - Use gap-echo projection from Ep6's shape
        //   - Add one recently-active anchor that could pulse again

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([9, 21, 29, 37, 43, 48]);
        }
        else
        {
            int totalDraws = context.DrawHistory.Count;

            // === FREQUENCY MAP ===
            var freq = new Dictionary<int, int>();
            for (int n = 1; n <= 49; n++) freq[n] = 0;
            foreach (var draw in context.DrawHistory)
                foreach (var n in draw.Numbers)
                    freq[n]++;

            var allDrawn = context.DrawHistory.SelectMany(d => d.Numbers).ToHashSet();
            double centerOfGravity = context.DrawHistory
                .SelectMany(d => d.Numbers)
                .Average();

            var lastDraw = context.DrawHistory[^1].Numbers.OrderBy(x => x).ToList();
            var secondLastDrawSet = context.DrawHistory.Count >= 2
                ? context.DrawHistory[^2].Numbers.ToHashSet()
                : new HashSet<int>();

            // === LAST SEEN INDEX for each number ===
            var lastSeenEpisode = new Dictionary<int, int>();
            for (int n = 1; n <= 49; n++) lastSeenEpisode[n] = -1;
            for (int i = 0; i < context.DrawHistory.Count; i++)
                foreach (var n in context.DrawHistory[i].Numbers)
                    lastSeenEpisode[n] = i;

            // === GHOST OSCILLATORS: 2+ appearances, NOT in last draw, sorted by longest silence ===
            var ghostOscillators = freq
                .Where(kv => kv.Value >= 2 && !lastDraw.Contains(kv.Key))
                .OrderByDescending(kv => totalDraws - 1 - lastSeenEpisode[kv.Key])  // longest silence first
                .ThenByDescending(kv => kv.Value)
                .Select(kv => kv.Key)
                .ToList();

            // === COLD VOID: never appeared ===
            var coldVoid = freq
                .Where(kv => kv.Value == 0)
                .Select(kv => kv.Key)
                .ToList();

            // === LOW ZONE: 6–12 (6 draws of silence — MAXIMUM COIL) ===
            var lowZone = coldVoid.Where(n => n >= 6 && n <= 12).OrderBy(n => n).ToList();

            // === ADJACENCY ORBIT: numbers adjacent (+/-1) to last draw numbers that are cold ===
            var adjacencyOrbit = new HashSet<int>();
            foreach (var n in lastDraw)
            {
                if (n - 1 >= 1 && !allDrawn.Contains(n - 1)) adjacencyOrbit.Add(n - 1);
                if (n + 1 <= 49 && !allDrawn.Contains(n + 1)) adjacencyOrbit.Add(n + 1);
            }
            var adjacencyOrbitSorted = adjacencyOrbit.OrderBy(n => Math.Abs(n - centerOfGravity)).ToList();

            // === GAP-ECHO PROJECTION from last draw ===
            var lastGaps = new List<int>();
            for (int i = 1; i < lastDraw.Count; i++)
                lastGaps.Add(lastDraw[i] - lastDraw[i - 1]);

            // Find the two most frequent gaps (the double-gap motif)
            var topGaps = lastGaps
                .GroupBy(g => g)
                .OrderByDescending(g => g.Count())
                .ThenByDescending(g => g.Key)
                .Take(2)
                .Select(g => g.Key)
                .ToList();

            var gapEchoProjections = new HashSet<int>();
            foreach (var anchor in lastDraw)
            {
                foreach (var gap in topGaps)
                {
                    int up = anchor + gap;
                    int down = anchor - gap;
                    if (up >= 1 && up <= 49 && !lastDraw.Contains(up)) gapEchoProjections.Add(up);
                    if (down >= 1 && down <= 49 && !lastDraw.Contains(down)) gapEchoProjections.Add(down);
                }
            }
            var gapEchoCold = gapEchoProjections.Where(n => !allDrawn.Contains(n))
                .OrderBy(n => Math.Abs(n - centerOfGravity)).ToList();
            var gapEchoAll = gapEchoProjections
                .OrderBy(n => Math.Abs(n - centerOfGravity)).ToList();

            // === UPPER COLD ZONE: 39-47 (never appeared) ===
            var upperCold = coldVoid.Where(n => n >= 39 && n <= 47).OrderBy(n => n).ToList();

            // === MID COLD SINGLES: isolated cold numbers between 20-38 ===
            var midColdSingles = coldVoid
                .Where(n => n >= 20 && n <= 38)
                .OrderBy(n => Math.Abs(n - centerOfGravity))
                .ToList();

            var chosen = new HashSet<int>();

            // SLOT 1: LONGEST-SLEEPING GHOST (2+ appearances, max silence)
            // Favoring the multi-draw anchors that have been coiling the longest
            foreach (var n in ghostOscillators)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 2: SECOND GHOST OSCILLATOR
            foreach (var n in ghostOscillators)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 3: LOW ZONE ERUPTION (6-12 — 6 draws of zero, coil at MAXIMUM)
            foreach (var n in lowZone)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 4: ADJACENCY ORBIT — orbit of last draw, cold numbers (adjacency law!)
            foreach (var n in adjacencyOrbitSorted.Concat(upperCold).Concat(midColdSingles))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 5: GAP-ECHO PROJECTION (cold preferred)
            foreach (var n in gapEchoCold.Concat(gapEchoAll).Concat(midColdSingles))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 6: THIRD GHOST or upper cold zone
            foreach (var n in ghostOscillators.Concat(upperCold).Concat(midColdSingles))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // === SAFETY NET: fill remaining with rarest numbers near center of gravity ===
            var fillOrder = freq
                .OrderBy(kv => kv.Value)
                .ThenBy(kv => Math.Abs(kv.Key - centerOfGravity))
                .Select(kv => kv.Key);
            foreach (var n in fillOrder)
            {
                if (chosen.Count >= 6) break;
                if (!chosen.Contains(n)) chosen.Add(n);
            }

            numbers = chosen.OrderBy(x => x).Take(6).ToList();
        }

        return new()
        {
            AgentId      = "pattern-goblin",
            StrategyName = "adjacency-law-ghost-parade-low-zone-echo-v9",
            Numbers      = numbers,
            Confidence   = 0.58,
            Reasoning    = "31+32 ADJACENCY LAW CONFIRMED! Ghosts coil! Low zone DETONATES at last!"
        };
    }
}