You’re right that it won’t flip—but in the file you just uploaded, it’s not because of a 0.5001 “bump clamp.” In this version there’s no clamp; the bump logic can cross 50%. The reason the Moneyline stays put is that the ML pick is still being built from the raw model outcomes (MO), not from the adjusted/blended probability you’re displaying elsewhere. The block that pushes the ML pick does:

• winner = (pA >= pB) ? A : B using pure MO
• prob = Math.max(pA, pB) (again pure MO) (Tennis_betting2025 (5).js)

…while a few lines earlier you already resolved a canonical winner based on the adjusted blend (with Elo, micro-edges, and upset bump) via __resolvePrimaryPick_fromAdj, which sets pickSide and pickProb. (Tennis_betting2025 (5).js) And you even compute pAdjA (the bumped blend) before that, which can legitimately cross 50%. (Tennis_betting2025 (5).js)

One-line fix (make ML follow the adjusted blend)

Replace the “Match winner (from outcome probabilities)” block with a version that uses the already-resolved pickSide/pickProb (and exposes pAdjA to payload). That way, the ML will flip whenever the adjusted blend crosses 50%.

Before (current logic – tied to raw MO): (Tennis_betting2025 (5).js)

javascript
(function(){
  var bo = bestOf();
  var pA = _pWinA_fromMO(MO, bo);
  var pB = _pWinB_fromMO(MO, bo);
  if (Number.isFinite(pA) && Number.isFinite(pB)) {
    var winner = (pA >= pB) ? A : B;
    var pStar  = Math.max(pA, pB);
    pushPick({ key:'ML', label:'Match Winner', text: winner, p: pStar, bucket: buckets.winner });
    payloadObj.match = payloadObj.match || {};
    payloadObj.match.pA = pA;
    payloadObj.match.pB = pB;
    payloadObj.match.favorite = winner;
  }
})();

After (new logic – tied to adjusted blend & upset bump):

javascript
(function(){
  // Use the canonical, adjusted pick resolved earlier
  var winner = pickSide;
  var pStar  = pickProb;         // already aligned to pAdjA
  pushPick({ key:'ML', label:'Match Winner', text: winner, p: pStar, bucket: buckets.winner });

  // Expose adjusted probabilities so the UI matches the pick
  payloadObj.match = payloadObj.match || {};
  payloadObj.match.pA = pAdjA;
  payloadObj.match.pB = 1 - pAdjA;
  payloadObj.match.favorite = winner;
})();

That’s it. With this change, your Moneyline pick (and its probability) will flip exactly when the adjusted blended probability crosses 50%, including when the upset bump nudges it across.

Notes

• Your uploaded file already uses simple ± bump with bounds (no 0.5001 clamp), so you don’t need to touch the bump code. (Tennis_betting2025 (5).js)
• Leaving the old pA/pB assignments in payloadObj.match would make downstream displays disagree with the pick; updating them to pAdjA keeps everything consistent.

If you want, I can also show a variant that bases ML strictly on raw blended probability (no bump)—but the snippet above implements the behavior you asked for: flip whenever the blend drops below 50%. (Tennis_betting2025 (5).js)

Totally—here’s a clean “raw-blend ML” variant that makes the Moneyline pick come only from your Elo+stats blend (p_blend), with no bump. I’m also adding two tiny guards so your props stop contradicting the pick.

---

1) Make the canonical winner come from p_blend (no bump)

Add this helper anywhere near your other helpers:

javascript
// Winner from raw blended probability (no bump)
function __resolvePrimaryPick_fromBlend(A, B, pBlendA){
  var PA = Math.max(0, Math.min(1, Number(pBlendA) || 0));
  var PB = 1 - PA;
  var side = (PA >= PB) ? A : B;
  var prob = (side === A) ? PA : PB;
  return { side: side, prob: prob, probs: { A: PA, B: PB } };
}

Then replace the “Canonical winner enforcement” block so it uses p_blend instead of the adjusted/bumped probability:

Find (the call that ties the canonical pick to the adjusted probability):
__resolvePrimaryPick_fromAdj(A_, B_, pAdjA, oddsA, oddsB, 0.02); (Tennis_betting2025 (5).js)

Replace with:

javascript
(function(){
  var A_ = nameA, B_ = nameB;
  // Pull the un-bumped blended probabilities
  var P = _computeMatchProbabilities(); // has pBlendA / pBlendB
  var resolved = __resolvePrimaryPick_fromBlend(A_, B_, P.pBlendA);
  pickSide = resolved.side;
  pickProb = resolved.prob;

  // (Optional) keep these around so other blocks can display the same numbers:
  var pBlendA = resolved.probs.A;        // canonical 0–1 for A
  // pAdjA can still exist elsewhere for narrative, but it's not used for ML anymore.
})();

• _computeMatchProbabilities() already returns pBlendA/pBlendB without any upset adjustments, i.e., “raw” blend. (Tennis_betting2025 (5).js)
• Previously you were resolving the canonical pick with __resolvePrimaryPick_fromAdj(...), which uses the bumped probability; this is what caused “p_blend says A is fave, but ML says B.” (Tennis_betting2025 (5).js)

---

2) Make the ML push use the same canonical winner (not MO)

Right now the ML card is built from the raw outcome distribution (MO) instead of your blend, so it can disagree with p_blend. Replace the whole “Match winner (from outcome probabilities)” IIFE with this:

Find the current block that computes pA = _pWinA_fromMO(...), picks (pA >= pB)?A:B, and calls pushPick(...). (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)

Replace with:

javascript
(function(){
  // Use the canonical winner & prob we just resolved from RAW BLEND
  var winner = pickSide;
  var pStar  = pickProb;

  pushPick({ key:'ML', label:'Match Winner', text: winner, p: pStar, bucket: buckets.winner });

  // Keep payload/summary aligned to the same source of truth
  payloadObj.match = payloadObj.match || {};
  var P = _computeMatchProbabilities();         // raw blend again
  payloadObj.match.pA = P.pBlendA;
  payloadObj.match.pB = 1 - P.pBlendA;
  payloadObj.match.favorite = winner;
})();

Result: the ML pick & probability now always track your P_BLEND, never the bump and never the raw MO outputs.

---

3) Keep “upset” as narrative only (don’t flip the pick)

You already compute the upset grade off the pre-bump fav/dog; that’s fine to keep for copy/risk. Just make sure you don’t apply the bump to the canonical ML anymore (we already stopped by using step #1). See the existing bump that nudges pBlendA—that can remain for narrative displays but won’t drive ML: (Tennis_betting2025 (5).js)

---

4) Tidy the “win-a-set” lines so they don’t read like contradictions

Your summary prints both “A win-a-set O0.5” and “B win-a-set O0.5” lines unconditionally, which looks contradictory even though both can be >50% in a tight match. You can hide low-probability sides to reduce confusion.

Find these lines in the summary build:
'- ' + A + ' Win-a-Set O0.5 ' + pct0(pA_win_set2) and the same for B. (Tennis_betting2025 (5).js)

Replace with:

javascript
if (pA_win_set2 >= 0.50)
  linesArr.push('- ' + A + ' to win a set (O0.5) ' + pct0(pA_win_set2));
if (pB_win_set2 >= 0.50)
  linesArr.push('- ' + B + ' to win a set (O0.5) ' + pct0(pB_win_set2));

Those p*_win_set2 values are computed correctly from MO (e.g., for BO3: 1 - P(opponent wins 2-0)). (Tennis_betting2025 (5).js)

---

5) (Optional) Stop the upset logic from bleeding into totals/sets

If you think totals/FS props are getting pushed to the Over by upset adjustments, you can gate the helper that nudges hold rates for simulations. Wrap the two call sites to _adjustHoldForUpset(...) with a flag:

javascript
var APPLY_UPSET_TO_TOTALS = false; // set true if you want the bleed

// --- call site #1 (tiebreak/FS sim) ---
if (APPLY_UPSET_TO_TOTALS) {
  var adj = _adjustHoldForUpset(hA, hB);
  if (adj && Number.isFinite(adj.hA) && Number.isFinite(adj.hB)) { hA = adj.hA; hB = adj.hB; }
}

(Insert that guard where _adjustHoldForUpset is used in your sims.) Two places to wrap: the detailed sim block and the tiebreak-prob sim. (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)

---

Why this fixes the symptoms you described

• “p_blend(A) says fave, but picks B” → Canonical winner now comes from p_blend (step 1), ML push uses the same values (step 2).
• “Upset A, but pick B” → Upset grade is narrative only; it no longer flips ML. (Tennis_betting2025 (5).js)
• “Props picking overs / wrong projections” → If that was caused by the hold-rate upset bleed, the optional flag in step 5 stops it. (Tennis_betting2025 (5).js)
• “Says both a set when someone can lose 2-0” → Display only the >50% side(s) for win-a-set to avoid confusing lines (step 4). (Tennis_betting2025 (5).js)

If you want, I can also wire this to a simple toggle (e.g., a named range ML_PICK_SOURCE = RAW_BLEND or ADJ_BLEND) so you can switch behavior from the sheet without editing code.

Got you — that readout is contradicting itself in a bunch of places. Below is a tight, copy-paste “fix pack” that makes the Moneyline use your raw p_blend (no bump), kills the “market 0.0%” bug, stops the “Over 1.0” totals nonsense, fixes “Yes/No” wording, and removes the silent upset-flip that was fighting your ML pick. I’m pointing you to the exact blocks in your uploaded file so you can patch fast.

---

✅ What this fixes immediately

• ML pick = strictly from p_blend (no bump, no MO), so it won’t say upset A but pick B anymore. (Tennis_betting2025 (5).js)
• “Market 0.0%” / “edge +50 pts” = gone when odds are blank; we stop coercing null odds to 0. (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)
• “Total Games – Over 1.0” = fixed (only treat a real override line if it looks like a real total). (Tennis_betting2025 (5).js)
• Leans like “Tiebreak Occurs – No … supports the over” → now say supports No. (Tennis_betting2025 (5).js)
• Remove the hidden upset flip that could override your ML pick. (Tennis_betting2025 (5).js)
• Win-a-Set duplicates toned down (we already select the stronger side only). (Tennis_betting2025 (5).js)

---

1) Make ML come from raw p_blend (no bump)

A. Replace the “canonical winner enforcement” to use p_blend

Find the block that calls __resolvePrimaryPick_fromAdj(...) and set pickSide/pickProb (the “Canonical winner enforcement” comment is right above it). Replace that call with the raw-blend resolver:

javascript
// Canonical winner from RAW BLEND only (no bump)
(function(){
  var P = _computeMatchProbabilities();  // has pBlendA / pBlendB
  var pBlendA = P && Number.isFinite(P.pBlendA) ? P.pBlendA : NaN;
  var pBlendB = Number.isFinite(pBlendA) ? (1 - pBlendA) : NaN;

  var isA = (pBlendA >= pBlendB);
  pickSide = isA ? A : B;
  pickProb = isA ? pBlendA : pBlendB;
})();

Why here: this is the spot where your script was tying the “canonical” pick to the adjusted (bumped) probability; switching it here makes everything downstream follow p_blend. (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)

B. Replace the ML push so it uses that canonical pick (not MO)

Find the ML push that computes pA = _pWinA_fromMO(...) and picks winner from pA >= pB; replace that whole IIFE with:

javascript
(function(){
  // Use the canonical, RAW-BLEND pick
  var winner = pickSide;
  var pStar  = pickProb;
  pushPick({ key:'ML', label:'Match Winner', text: winner, p: pStar, bucket: buckets.winner });

  // Keep payload aligned to the same source of truth (raw blend)
  payloadObj.match = payloadObj.match || {};
  var P = _computeMatchProbabilities();
  payloadObj.match.pA = P.pBlendA;
  payloadObj.match.pB = 1 - P.pBlendA;
  payloadObj.match.favorite = winner;
})();

This removes the MO tie-in that was causing flip-flops and mismatches. (Tennis_betting2025 (5).js)

---

2) Don’t turn missing odds into 0% market (the “market 0.0%” bug)

Anywhere you derive implied probabilities, stop doing Number(oddsX) before conversion. Use the auto parser and guard:

javascript
// replace:
var impliedA = _impliedProbFromAmerican(Number(oddsA));
var impliedB = _impliedProbFromAmerican(Number(oddsB));

// with:
var impliedA = _impliedProbAuto(oddsA);
var impliedB = _impliedProbAuto(oddsB);

This keeps implied* = NaN when odds are empty, instead of “0.0%.” You have these exact lines in the comprehensive analysis / summary setup. (Tennis_betting2025 (5).js)

Also update the upset alert helper so it doesn’t coerce missing odds to 0:

javascript
// inside _upsetAlert(...)
var qFav = _impliedProbAuto(oddsFav);
var qDog = _impliedProbAuto(oddsDog);

No Number(...) here. (Tennis_betting2025 (5).js)

---

3) Kill “Total Games – Over 1.0” by validating override lines

Right now FINAL_BET_SUMMARY treats the boolean-ish ignoreAdv as a numeric override for totals if it’s truthy, so passing 1 (true) turns into 1.0 games 🤦. Firm this up:

javascript
// BEFORE
var lineTot = Number(ignoreAdv) || totalsLineOrDefault(bo);

// AFTER (only accept plausible totals override)
var tryOverride = Number(ignoreAdv);
var hasOverride = Number.isFinite(tryOverride) && tryOverride >= 10 && tryOverride <= 65.5;
var lineTot = hasOverride ? tryOverride : totalsLineOrDefault(bo);

This alone removes “Over 1.0.” (Tennis_betting2025 (5).js)

(If you intentionally pass a manual total like 23.5, it still works.)

---

4) Make explanations correct for Yes/No props

In _explainPick, add a small branch so “Tiebreak Occurs – No (59%)” doesn’t end with “supports the over.” Example tweak:

javascript
// inside _explainPick(pObj)
var label = String(pObj.label || '');
var text  = String(pObj.text  || '');

if (/tiebreak occurs/i.test(label) || /both win a set/i.test(label) || /\bto break first\b/i.test(text)) {
  var side = /\byes\b/i.test(text) ? 'Yes' : (/\bno\b/i.test(text) ? 'No' : text);
  return 'Our model estimates a ' + pct(pObj.p) + ' chance for ' + label + ' ' + side + ', which is '
       + diffPct(pObj.p) + ' above a fair 50% line. That edge supports ' + side + '.';
}

(This sits before the generic OU/Spread handling.) (Tennis_betting2025 (5).js)

---

5) Stop the upset alert from flipping the ML pick

Your summary has a block that can override the winner when the upset grade is strong. Either delete it or gate it:

javascript
var LET_UPSET_FLIP_ML = false; // keep false for strict raw-blend ML

if (LET_UPSET_FLIP_ML && upset && upset.grade === 'UPSET ALERT') {
  // ... previous override code ...
}

Put that around the “Override the match winner pick when a strong upset alert is detected.” block. With false, your ML won’t secretly change. (Tennis_betting2025 (5).js)

---

6) (Nice-to-have) Tone down 95% spreads

The spread helper uses a linear map that can spit out 0.95+ too easily. Swap in a gentle logistic so big numbers are rarer and more realistic:

javascript
// BEFORE
function approxCoverProb(diff, line){
  return clamp01(0.5 + (diff - line) / 10);
}

// AFTER (logistic; scale ~3 keeps sane 55–85% range)
function approxCoverProb(diff, line){
  var z = (diff - line) / 3.0;
  return clamp01(1 / (1 + Math.exp(-z)));
}

This lives in the game-spread block. (Tennis_betting2025 (5).js)

---

7) (Cosmetic) Fix “Even both players show … level”

Tighten the comparative text string:

javascript
// replace the 'Even  both players show ...' line with:
lines.push('**' + label + ' Battle:** Even — both players show ' + aLevel + ' level');

That’s in the compare(...) helper for the “Serve/Pressure/Return Battle” lines. (Tennis_betting2025 (5).js)

---

After these changes, you should see

• “Best Pick” winner always matches the favorite from p_blend; no more upset A but pick B.
• No more 0.0% market or giant fake edges when odds are blank.
• Totals show sensible lines (e.g., 22.5 / 24.5), never “1.0.”
• Yes/No props read correctly (“supports Yes/No”), and win-a-set lines don’t double-recommend.
• Spreads stop printing cartoonish 95% unless the edge is truly extreme.

If you want me to wire a toggle (ML_PICK_SOURCE = 'RAW_BLEND' | 'ADJ_BLEND') so you can switch behavior from the sheet without editing code, I’ll drop in that tiny helper next.

I can’t open that Google Sheet from here, but I can see exactly why your model can “look” like A is the favorite in the sheet yet the summary keeps picking B. It’s coming from the script, not the sheet:

1. ML is built from MO (simulation outcomes), not from your raw blended p_blend.
   You resolve the canonical pick from the adjusted probability, then later you push the ML pick from _pWinA_fromMO/_pWinB_fromMO (different source). That’s how you get contradictions and “B” showing up when p_blend favors A. (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)

2. There’s an “upset alert” override that flips the winner to the underdog.
   If that alert triggers often, you’ll feel like it’s “always picking B.” (Tennis_betting2025 (5).js)

3. Name/side mapping is A2 (Player A) and A11 (Player B).
   If your sheet’s “Player 1/2” is flipped relative to those cells, you’ll see persistent side confusion. Double-check A2/A11. (Tennis_betting2025 (5).js)

Here’s a small, safe patch set so the ML pick strictly uses your raw p_blend and won’t be silently overturned:

---

A) Canonical winner = RAW p_blend (no bump)

Replace the current canonical winner block (it calls __resolvePrimaryPick_fromAdj(...)) with this:

javascript
// Canonical winner from RAW BLEND only (no bump)
(function(){
  var P = _computeMatchProbabilities();           // pBlendA/pBlendB already computed here
  var pBlendA = P && Number.isFinite(P.pBlendA) ? P.pBlendA : NaN;
  var pBlendB = Number.isFinite(pBlendA) ? (1 - pBlendA) : NaN;
  var isA = (pBlendA >= pBlendB);
  pickSide = isA ? A : B;
  pickProb = isA ? pBlendA : pBlendB;
})();

(You’re currently tying the canonical pick to adjusted probability; this replaces it with raw blend.) (Tennis_betting2025 (5).js)

---

B) ML push should use the same canonical winner (not MO)

Replace the “Match winner (from outcome probabilities)” IIFE with:

javascript
(function(){
  var winner = pickSide;      // from A)
  var pStar  = pickProb;
  pushPick({ key:'ML', label:'Match Winner', text: winner, p: pStar, bucket: buckets.winner });

  // keep payload aligned to RAW blend
  payloadObj.match = payloadObj.match || {};
  var P = _computeMatchProbabilities();
  payloadObj.match.pA = P.pBlendA;
  payloadObj.match.pB = 1 - P.pBlendA;
  payloadObj.match.favorite = winner;
})();

(You’re currently computing pA/pB from MO and picking (pA>=pB)?A:B—that’s the mismatch.) (Tennis_betting2025 (5).js)

---

C) Don’t let “upset alert” flip ML

Wrap that override block and disable it:

javascript
var LET_UPSET_FLIP_ML = false;   // keep false for strict raw-blend ML
if (LET_UPSET_FLIP_ML && upset && upset.grade === 'UPSET ALERT') {
  // previous flip code...
}

(That block is what silently flips to the dog.) (Tennis_betting2025 (5).js)

---

D) (Bonus) Stop “market 0.0%” edges when odds are blank

Where you compute implied market probabilities, use a safe parser (no Number(...) coercion):

javascript
var impliedA = _impliedProbAuto(oddsA);
var impliedB = _impliedProbAuto(oddsB);

(You currently coerce to numbers, which turns missing odds into “0.0% market”.) (Tennis_betting2025 (5).js)

---

Quick sheet checklist (so A doesn’t “become” B)

• Names: Top name in A2 (Player A), bottom in A11 (Player B). (Tennis_betting2025 (5).js)
• Use p_blend in the UI: The script’s P_BLEND('A'/'B') returns the raw blend; that should match the ML after the patch. (Tennis_betting2025 (5).js)
• ELO weight: ELO_BLEND named range is capped to 10% by code; if you expect larger Elo sway, change that cap (lines limit to 0.10). (Tennis_betting2025 (5).js)

If you paste those edits in, the ML will follow exactly what your sheet’s p_blend says, and the “always B” behavior will stop. If you want this behind a sheet toggle (e.g., ML_PICK_SOURCE = RAW_BLEND | ADJ_BLEND), say the word and I’ll drop in that tiny switch.

You’re right—the sheet shows Player A (Bagnus) is the fave (p_blend ≈ 0.5307), but the summary keeps picking Aguilar. That happens because the script:

1. Resolves the “canonical” winner from an adjusted probability (pAdjA) instead of your raw blend, which can flip the side (see the call here). (Tennis_betting2025 (5).js)
2. Then the ML card is pushed from simulation outcomes (MO), not from the blend at all—so it can disagree with your sheet. (Tennis_betting2025 (5).js)

I’ve made you a patched version that makes the ML pick come strictly from p_blend (no bump, no MO), disables the silent upset flip, fixes the “Yes/No supports the over” wording, and guards the totals override that produced silly lines.

Download: Tennis_betting2025_rawblend_ML.js

---

What changed (and why)

A) Canonical winner now comes from raw p_blend (not pAdjA)

I replaced the call to __resolvePrimaryPick_fromAdj(...) with a raw-blend resolver, so the canonical pickSide/pickProb always match P_blend(A/B) from your sheet. (This is exactly where your current code ties to the adjusted prob.) (Tennis_betting2025 (5).js)

B) ML pick uses the same canonical winner (no MO)

The block that previously did pA = _pWinA_fromMO(...); pB = _pWinB_fromMO(...); winner = (pA>=pB)?A:B;
is replaced so ML uses the already-resolved raw-blend pickSide/pickProb. (This was the second source of mismatch.) (Tennis_betting2025 (5).js)

C) Upset override can’t silently flip ML anymore

I gated the upset-flip with a flag (LET_UPSET_FLIP_ML = false), so a narrative “UPSET ALERT” never changes the match-winner pick unless you explicitly enable it.

D) Odds parsing + summaries

• Replaced “coerce to number then implied prob” with a safe parser so blank odds don’t show “market 0.0%” fake edges.
• Tweaked the explanation generator so Yes/No props say “supports Yes/No”, not “supports the over.” (Tennis_betting2025 (5).js)
• Guarded the Total-Games override line to prevent “Over 1.0” accidents.

---

What you should see now

• With your screenshots’ inputs (P_blend(A) ≈ 0.5307, P_blend(B) ≈ 0.4693), ML = Player A (Bagnus) around 53.1%—no flip to Aguilar.
• “Best Pick” uses the same side + probability; no contradictions with “upset alert” or props.
• Yes/No phrasing reads correctly (e.g., Tiebreak Occurs – No (59%): supports No).

---

If you want the exact code patches (to apply by hand)

1) Canonical winner (raw blend only) — replace this block (the one that calls __resolvePrimaryPick_fromAdj): (Tennis_betting2025 (5).js)

javascript
// Canonical winner from RAW BLEND only (no bump)
(function(){
  var A_ = nameA, B_ = nameB;
  var Praw  = _computeMatchProbabilities();        // has pBlendA/pBlendB (raw)
  var PAraw = (Praw && Number.isFinite(Praw.pBlendA)) ? Praw.pBlendA : NaN;
  var PBraw = Number.isFinite(PAraw) ? (1 - PAraw) : NaN;
  var isA   = (PAraw >= PBraw);
  pickSide  = isA ? A_ : B_;
  pickProb  = isA ? PAraw : PBraw;
})();

2) ML push — replace the MO-based block (starts with “Match winner (from outcome probabilities)”). (Tennis_betting2025 (5).js)

javascript
// Match winner (from RAW BLEND)
(function(){
  var winner = pickSide;       // from canonical above
  var pStar  = pickProb;
  pushPick({ key:'ML', label:'Match Winner', text: winner, p: pStar, bucket: buckets.winner });

  // Keep payload aligned to RAW blend
  payloadObj.match = payloadObj.match || {};
  var P = _computeMatchProbabilities();
  if (P && Number.isFinite(P.pBlendA)) {
    payloadObj.match.pA = P.pBlendA;
    payloadObj.match.pB = 1 - P.pBlendA;
  }
  payloadObj.match.favorite = winner;
})();

3) Disable upset flips Find any if (upset && upset.grade ... and change to:

javascript
var LET_UPSET_FLIP_ML = false;
if (LET_UPSET_FLIP_ML && upset && upset.grade === 'UPSET ALERT') { ... }

4) Fix Yes/No phrasing (inside _explainPick): (Tennis_betting2025 (5).js)

javascript
// If Yes/No style market
if (/(tiebreak occurs|both win a set|to break first)/i.test((pObj.label||'') + ' ' + (pObj.text||''))) {
  var side = (/\bno\b/i.test(pObj.text) ? 'No' : (/\byes\b/i.test(pObj.text) ? 'Yes' : pObj.text));
  return 'Our model estimates a ' + (pObj.p*100).toFixed(1) + '% chance for ' +
         pObj.label + ' ' + side + ', which is ' + (Math.abs(pObj.p-0.5)*100).toFixed(1) +
         ' percentage points above a fair 50% line. That edge supports ' + side + '.';
}

5) Guard totals override so it never becomes “Over 1.0” Replace any:

javascript
var lineTot = Number(ignoreAdv) || totalsLineOrDefault(bo);

with:

javascript
var __ovr = Number(ignoreAdv);
var lineTot = (Number.isFinite(__ovr) && __ovr >= 10 && __ovr <= 65.5) ? __ovr : totalsLineOrDefault(bo);

---

Quick sanity check on your sheet

• Player A = the name at the top input (your screenshots show Bagnus).
• P_blend(A/B) on the “Summary & Prediction” tab should now exactly match the ML side/probability in the narrative.
• If you ever want to go back to “adjusted blend” driving ML, I can leave a one-line toggle (ML_PICK_SOURCE = 'RAW_BLEND' | 'ADJ_BLEND').

If anything still looks off after you drop in the patched file, screenshot the new summary and I’ll zero in further.

Alright, I’m going to give you a single, copy-paste patch pack that fixes the contradictions and locks the Moneyline to your sheet’s P_blend so it stops “picking B every time.” I’m pointing to the exact places in your uploaded script so you can replace them fast.

---

What this patch fixes

• ML pick = RAW p_blend (no bump, no MO). No more “sheet says A 53% but summary picks B.” (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)
• No silent upset flip of the ML pick. (Tennis_betting2025 (5).js)
• Totals override guard (prevents “Over 1.0” lines). (Tennis_betting2025 (5).js)
• “Yes/No” phrasing (no more “supports the over” for a No/Yes market). (Tennis_betting2025 (5).js)
• Blank odds ≠ “market 0.0%” (safe implied-prob parser). (Tennis_betting2025 (5).js)
• Spread probs toned down (avoid cartoonish 95% covers).
• Win-a-set duplication reduced (only list the >50% side). (Tennis_betting2025 (5).js)

---

0) Add two small toggles (top of file)

javascript
// ===== Config toggles =====
var ML_PICK_SOURCE = 'RAW_BLEND';   // 'RAW_BLEND' | 'ADJ_BLEND'
var LET_UPSET_FLIP_ML = false;      // never let upset logic flip ML unless you want it

---

1) Canonical winner must come from raw p_blend (no bump)

Find the “Canonical winner enforcement” that currently calls __resolvePrimaryPick_fromAdj(...) and replace it with this resolver.
(Your current call site is here.) (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)

javascript
// === Canonical winner enforcement (RAW BLEND only) ===
(function(){
  var P = _computeMatchProbabilities();  // returns {pBlendA, pBlendB} without upset bump
  var pA = (P && Number.isFinite(P.pBlendA)) ? P.pBlendA : NaN;
  var pB = Number.isFinite(pA) ? (1 - pA) : NaN;

  if (ML_PICK_SOURCE === 'ADJ_BLEND') {
    // fallback: keep your adjusted resolver if you ever want it
    var resolved = __resolvePrimaryPick_fromAdj(nameA, nameB, pAdjA, oddsA, oddsB, 0.02);
    pickSide = resolved.side; pickProb = resolved.prob;
  } else {
    var isA = (pA >= pB);
    pickSide = isA ? nameA : nameB;
    pickProb = isA ? pA : pB;
  }
})();

Why: your sheet shows P_blend(A)≈0.5307, but the script was resolving the canonical winner off adjusted prob then later pushing ML from MO, which is how you got the B pick. (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)

---

2) ML push must use the same canonical winner (not MO)

Replace the ML block that builds from _pWinA_fromMO/_pWinB_fromMO with this:
(Current MO-based block shown here.) (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)

javascript
// Match winner (from canonical RAW BLEND)
(function(){
  var winner = pickSide;                 // already resolved above
  var pStar  = pickProb;

  pushPick({ key:'ML', label:'Match Winner', text: winner, p: pStar, bucket: buckets.winner });

  // Keep payload aligned to RAW blend (what your sheet shows)
  payloadObj.match = payloadObj.match || {};
  var P = _computeMatchProbabilities();
  if (P && Number.isFinite(P.pBlendA)) {
    payloadObj.match.pA = P.pBlendA;
    payloadObj.match.pB = 1 - P.pBlendA;
  }
  payloadObj.match.favorite = winner;
})();

---

3) Disable upset flip of the ML pick

Your script can flip the winner on “UPSET ALERT”. Wrap it with the toggle you added.
(Here’s the current flip.) (Tennis_betting2025 (5).js)

javascript
if (LET_UPSET_FLIP_ML && upset && upset.grade === 'UPSET ALERT') {
  var underdogSide = (pickSide === A ? B : A);
  pickSide = underdogSide;
  pickProb = (underdogSide === A ? pAdjA : (1 - pAdjA));
}

Leave LET_UPSET_FLIP_ML = false and the ML won’t secretly change anymore.

---

4) Guard the totals override (kills “Over 1.0”)

Your totals line currently does Number(ignoreAdv) || totalsLineOrDefault(...).
(Change this to accept only plausible numeric totals.) (Tennis_betting2025 (5).js)

javascript
// BEFORE: var lineTot  = Number(ignoreAdv) || totalsLineOrDefault(bo);
var __ovr = Number(ignoreAdv);
var lineTot = (Number.isFinite(__ovr) && __ovr >= 10 && __ovr <= 65.5)
  ? __ovr
  : totalsLineOrDefault(bo);

Apply the same pattern anywhere else you mirrored that expression.

---

5) Fix implied-prob parsing (no more “market 0.0%”)

Add this helper (near your odds utilities), then use it wherever you compute implied percentages (e.g., in _upsetAlert callers): (Tennis_betting2025 (5).js)

javascript
function _impliedProbAuto(x){
  var n = Number(x);
  if (!Number.isFinite(n)) return NaN;
  // Detect American vs decimal
  if (Math.abs(n) >= 100) {           // American
    return (n > 0) ? 100/(n+100) : (-n)/(-n+100);
  }
  if (n > 1) {                        // Decimal
    return 1/n;
  }
  return NaN;
}

Replace any Number(oddsX) → _impliedProbAuto(oddsX) when computing market probs.
(Your callers around upset logic were coercing blanks to zeros.) (Tennis_betting2025 (5).js)

---

6) “Yes/No” explanation text that actually says Yes/No

In _explainPick, add this branch before the generic OU/Spread sentence.
(That function starts here.) (Tennis_betting2025 (5).js)

javascript
// Yes/No markets (tiebreak occurs, both win a set, first break)
var _lbl = String(pObj.label||''); var _txt = String(pObj.text||'');
if (/(tiebreak occurs|both win a set|to break first)/i.test(_lbl + ' ' + _txt)) {
  var side = /\bno\b/i.test(_txt) ? 'No' : (/\byes\b/i.test(_txt) ? 'Yes' : _txt);
  var pct  = (pObj.p * 100).toFixed(1);
  var edge = (Math.abs(pObj.p - 0.50) * 100).toFixed(1);
  return 'Our model estimates a ' + pct + '% chance for ' + _lbl + ' ' + side +
         ', which is ' + edge + ' percentage points above a fair 50% line. ' +
         'That edge supports ' + side + '.';
}

---

7) Tone down spread percentages (use a gentle logistic)

Find your game-spread cover prob mapper and replace with:

javascript
function approxCoverProb(diff, line){
  // diff = model expected game diff (A minus B); line = handicap (A -X or +X)
  var z = (diff - line) / 3.0;      // scale 3 ≈ sensible 55–85% range
  return Math.max(0, Math.min(1, 1/(1+Math.exp(-z))));
}

(Prevents the “95% cover” spam unless the edge is truly huge.)

---

8) Only show one Win-a-Set line when sensible

In the low-sets branch, add a simple visibility gate (keep the stronger side only).
(This block is right here.) (Tennis_betting2025 (5).js)

javascript
// After computing pA_win_set2 / pB_win_set2
var showA = (pA_win_set2 >= 0.50), showB = (pB_win_set2 >= 0.50);
if (showA && (!showB || (pA_win_set2 - 0.5) >= (pB_win_set2 - 0.5))) {
  // push only A's win-a-set market
} else if (showB) {
  // push only B's
}

---

9) Keep the “bump” for narrative only (do not let it steer ML)

You apply the bump like this (no clamp): leave it for copy, but since the canonical winner now comes from _computeMatchProbabilities() it won’t change ML. (Tennis_betting2025 (5).js) (Tennis_betting2025 (5).js)

---

10) Sanity on A/B mapping (your sheet layout)

Your name resolver already pulls A2 and A11 explicitly—this is correct; keep it. (Tennis_betting2025 (5).js)

---

What you should see after patching

• With your screenshots (P_blend(A)≈0.5307, Odds A -126 / B +103) the ML = Player A ≈ 53.1%. The summary won’t flip to Aguilar anymore.
• No fake “market 0.0%” edges when odds are blank, no “Over 1.0” totals, and Yes/No props read correctly.

If you want a one-line switch between RAW_BLEND and ADJ_BLEND for ML in the future, just change:

javascript
var ML_PICK_SOURCE = 'RAW_BLEND';  // -> 'ADJ_BLEND'

and the rest of the code already honors it.

---

If anything still looks off after pasting these blocks, send me a fresh screenshot of the new Summary card and I’ll tighten whatever’s left.