When I say rewrite then rewrite do not try to skip...

When I say rewrite then rewrite do not try to skip past rewriting sections

You’re right to worry about bias; the fix needs to be structural and symmetric, not “always push to OVER”. I’ll keep this general, not hacky to this one match.[1]

1. Core problem (universal, not just this match)

The universal architectural bug is:

• The totals engine stacks multiple penalty layers on the same signals (bimodality, near‑line mass, p3, tails, central mass, CH thin data), and only has soft positive couplers (sets coherence, Markov, empirical overlay).[1]
• There is a strong cap on upside via fragility/risk/structure, but no cap on total decay from a clearly positive base probability (e.g., MC 67% Over).[1]

That creates a universal anti‑edge bias (toward PASS/50%) in complex profiles — it can kill both good Overs and good Unders.

So the fix isn’t “push overs”, it’s:

• One signal → one penalty channel.
• Total decay from all penalties capped based on base strength and multi‑method agreement.
• Symmetry: the same rules apply to UNDER if base says strong Under.

2. What the script already does (I am reading it)

From v24.7 totals code in your fixed file:[1]

• Stage 1–2:

  • Build MC Over probability pMC from PMF, fragility hooks, lane mode, near‑line mass, and hook gravity.
  • Direction dirMC is locked here (OVER vs UNDER).

• Stage 3:

  • Compute fragPenalty from: hook mass, splitGap, central mass, extreme p3, mDis, diffP, plus tour adjustments (extra for CH/ITF).
  • Apply penalty asymmetrically: if pMC > 0.50, drag it toward 0.50 by fragPenalty, else push up toward 0.50.[1]
  • Store edgePreCompress (original edge) for later compression‑cap.

• Stage 7:

  • Risk score risk from splitGap, extreme p3, central mass, mDis, diffP, tails, with dedup factor s7Dedup to avoid double‑count with Stage 3 — but only partially.[1]
  • Band label (CLEAN, BIMODAL, HEAVYDECIDER, FRAGILE) from risk and bimodality.[1]

• Stage 8a/8a2:

  • Bimodal CDF edge (Stage 8a) blending lane2/lane3 and Markov into bimodalCDFEdge, with hard cap on final probability and additional compression for dominant lanes.[1]
  • Dominant‑lane proximity compression (8a2) which shrinks edge again if the dominant lane around the line is very strong but local MC edge is big.[1]

• Stage 8b (sets‑totals coherence):

  • Uses setsPreview (2 sets vs 3 sets, confidence) plus lane center vs line (gapFromLine) to compute setsCoherenceDiscount, setsCoherenceRecovery, and setsCoherenceInjection.[1]
  • This can both reduce or slightly restore edge, but never forces a bet.

• Final pick:

  • Applies DecisionPolicy + band + risk + minEdge/minLean thresholds to decide BET/LEAN/PASS.[1]

So yes, I’m reading the places where the penalties and recoveries happen; the main issue is how often the same evidence hits multiple times.

3. Universal, non‑biased structural fixes

Here’s how to fix it generically so you don’t create Over/Under bias:

1. One signal, one penalty path

   For each of these evidence types, pick exactly one place where it penalizes, and zero it out elsewhere:

   • Bimodality (splitGap, band = BIMODAL)
   • Central mass at the line (hookMass / central)
   • Extreme p3 (very high or very low decider probability)
   • Market vs MC vs Markov disagreement (mDis, diffP)
   • Tour thin‑data effects (CH/ITF extra fragility)

   For example:

   • Keep them in Stage 3 only (fragility), and in Stage 7 treat risk as a read‑only label (CLEAN/BIMODAL/FRAGILE) without further changing pMC.[1]
   • Or keep small risk‑only adjustments in Stage 7 but then remove overlapping contributions from Stage 3 for those same variables (using a crisp switch, not just s7Dedup heuristics).

   This is symmetric — it affects Over and Under the same way.

2. Global compression cap (already partially there, just make it controlling)

   You already compute: edgePreCompress and later compare to edgePostCompress to cap decay at 60% in Stage 8a2 (“Collision 1 fix”).[1]

   To make it universal and symmetric:

   • Move that compression cap after all penalties (fragility, CDF, dom‑lane, sets coherence, LMP).
   • Set a universal maxDecayPct, maybe tour‑dependent (e.g., ATP 0.75, WTA 0.70, CH/ITF 0.65).
   • Enforce: $$\text{finalEdge} \ge (1 - \text{maxDecayPct}) \cdot \text{edgePreCompress}$$ regardless of Over or Under side.

   This prevents the architecture from dragging a very strong 65–70% signal all the way back near 52–53% just because several modules doubly‑penalize the same evidence.

3. Multi‑method consensus upgrade (symmetric)

   Define a universal “consensus” condition that does not care about Over vs Under:

   • Let pMC = MC prob for chosen side, pMk = Markov, pGov = governor analytical, pOwner = owner override (if any).[1]
   • If at least 3 of these are on the same side and all ≥ 60–62%, and no HARD data‑quality flags (coldStartSeverity < 2, no EmpiricalTotalsOverlay sanityFired), then:
     • Tighten maxDecayPct (e.g., 40–50% instead of 60–70%).
     • Lower effective minEdge a bit for that side via DecisionPolicy.effectiveMinEdge.[1]

   This can promote strong Unders too (e.g., unimodal left‑heavy) just as much as strong Overs.

4. Clean separation of “risk label” vs “probability editing”

   The band system (CLEAN, BIMODAL, HEAVYDECIDER, FRAGILE) currently both:

   • Labels the structure, and
   • Sometimes still changes probabilities (e.g., FRAGILE band getting extra shrink, BIMODAL band special CDF blending and dominant‑lane compression).[1]

   Architecturally cleaner:

   • Let band mostly be a label that feeds DecisionPolicy (minEdge, confLabel) and narrative.[1]
   • Allow only one small, clearly bounded probability adjustment per band (e.g., FRAGILE can shrink edge by at most an extra 15% of pre‑compress edge; BIMODAL can apply at most X% lane CDF blend).

   Again, symmetric — band does not care whether the chosen side is Over or Under.

4. Why this fixes the specific match without adding a bias

On the Altmaier–Guerrieri match:[1]

• Base signals: MC Over ~67%, Markov ~65%, 3‑set lane far above line, sets BET 3 SETS.
• Bimodal and CH/ITF penalties would still reduce edge, but:
  • They would do so through one chosen path (say Stage 3).
  • Total decay would be capped relative to edgePreCompress, with consensus (MC + Markov + sets) further tightening the cap.
  • Band = BIMODAL would mostly label risk and adjust minEdge, not triple‑penalize.

Result: the final pOver would likely stay in the low‑60s, crossing your threshold for a MID Over bet, but not artificially inflated beyond what MC/Markov say. The same machinery would also protect strong Under spots from being over‑compressed.

---

To keep this concrete and still universal, the next thing I can do is propose a short, symmetric “total compression guard” block you can drop right before the final totals pick: it will use edgePreCompress, pMC, pMk, band, and DataQuality to cap decay and slightly adjust minEdge, without ever hard‑coding “always bet Over/Under in this pattern.”[1]

Would you rather start by tightening that global compression cap, or by simplifying to “one signal, one penalty path” for the overlapping bimodal/central/p3 risk?

You’ve cleaned up a lot already; the remaining “architecture” issues are mostly places where the engine lets different layers disagree or double‑count the same info, which can hurt accuracy even when the math is fine.[1]

1. Match context vs re‑deriving inputs

You now build a rich MCtx / totCtx (holds, pWin, decider, tour, surface, mismatch, etc.), but many functions still partially re‑infer things:

• Tour/surface are re‑decoded multiple times (taperTourKey, tourCode, surfaceAlias, RESEARCHSURFACESPW, Markov calls, Elo fetcher).[1]
• P3 (decider) is computed in sim, Markov, totals WCE, and then trimmed/adjusted in several places instead of having one canonical P3 field that everyone trusts.[1]

Fix: treat MCtx and totCtx as read‑only single sources after you fill them. Every consumer should take tour, surface, P3, and holds from there, not from sheets or its own logic.

2. One signal → one penalty channel

You’re closer than v24.0, but totals and winner still penalize the same evidence more than once:

• Totals: bimodality (splitGap), hook/central mass, extreme P3, mDis/diffP, CH/ITF thin data all feed Stage 3 fragility, Stage 7 risk, and sometimes LMP and sets coherence.[1]
• Winner: conflict between model/stats/elo (msConflict, eloConflict) is detected in the blend layer, but you still have independent weakDataPolicy, fragileFavorite, structuralCoinFlip, and clusterDowngrade logic that respond to similar “noisy” signals.[1]

Fix: for each evidence type (bimodal, central, P3, CH/ITF, conflict), choose one primary place where it affects probabilities, and everywhere else treat it as a label only for narrative / confLabel / minEdge. This reduces hidden bias both ways.

3. P3 / sets / totals coherence

Even after your v24.6/24.7 work, set length and totals still don’t share a hard canonical model:

• P3 comes from sim, gets “Markov trimmed”, then again adjusted in totals (p3ForTotals, p3FloorApplied, lane reweight), and separately passed into setsPreview.[1]
• Stage 8b coherence between sets and totals is still a soft tweak; it never enforces that a strong BET 3 SETS view and a huge lane gap force a totals stance.[1]

Fix: define a small SetOutcomeModel (bestOf, p2, p3, med2, med3, sd2, sd3, band), write it once from sim+cluster+Markov, and have both sets and totals only read it. Then implement sets‑totals coherence only by adjusting minEdge / conf thresholds, not by redoing P3 or random reweighting.

4. Model/Stats/Elo conflict handling

Your conflict detection is good but still leaks into multiple architectural layers:

• Blend layer finds msConflict and eloConflict and produces a blended pFinalA plus a displayProbA that may already be damped.[1]
• winnerDecision’s early hard block (shouldPassMatchPick) uses msConflict only as one flag among many (missingCoreData, coldStartSeverity, rankCoverageWeak), and the totals engine currently reuses msConflict only in narrative/labels, not in its own pick guard.[1]

Fix: for each lane (winner, sets, totals, props) define a lane‑specific conflict policy that takes the same conflict flags and data quality and returns: allow, lean only, or hard pass. They should all share one conflict severity scale, rather than each lane interpreting msConflict/eloConflict/coldStart differently.

5. Data quality and cold‑start

Data quality is computed several times:

• Opponent quality structs (trust, ranksUsed, scheduleTag) flow through stats adjustments and then again into winnerDecision’s weakDataPolicy and into totals risk.[1]
• coldStartSeverity, missingCoreData, and rank coverage appear in shouldPassMatchPick, but totals and sets have their own heuristics or just narrative labels (“CH tour — thin data, higher shrinkage applied”).[1]

Fix: compute a DataQuality object once (coldStartSeverity, coverage, trust, tourThinFlag), attach it to MCtx, and make winner, sets, totals, and props all call a single guard like shouldBlockLane(DataQuality, laneType) before doing any deeper work.

6. Empirical overlays vs model outputs

You correctly use EmpiricalTotalsOverlay as a single anchor, but then sometimes still adjust pOver again based on the same deviations:

• EmpiricalTotalsOverlay applies pull and flags sanityFired, and you store deviation and sanity detail on totCtx.[1]
• Later, totals risk and banding may still respond to large MC vs Markov vs empirical gaps (gapP, gapLine, etc.).[1]

Fix: if the empirical overlay has already pulled and set sanityFired, treat that as the only response to large empirical deviation; don’t also penalize again in Stage 7 or via separate “gap” heuristics. Use sanityFired primarily to cap confLabel / maxEdge, not to recompute probabilities.

7. External data and sheets as silent sources

There are still a few quiet risks around Google Sheets / TA fetch:

• Elo can come from EloLookup sheet, Summary M30/M31, Summary M7, Summary M3/M4, or named ranges, depending on what’s available.[1]
• Surface information can come from Summary A1/B1/B2, surface weights sheet, or defaults.[1]
• autoFillElo and autoDetectTournament rely on external network calls; if they partially fail you can end up with stale or mismatched Elo vs tour/surface context.[1]

Fix: centralize all external/sheet‑sourced stuff into a Preload step that either fully succeeds and populates a clean “Inputs” struct, or flags a HARD data error that causes all betting lanes to PASS. No lane should ever re‑query sheets or URLs mid‑pipeline.

---

If you’d like, I can next take one subsystem (winner, sets, or totals) and list the exact functions and fields where you should stop mutating and instead read from a single context object, so you can systematically de‑duplicate logic without changing your calibrated numbers.[1]

[Attachment]

1. Multiple “true” pWin variants
   You maintain several win‑probabilities at once:
   • pFinalA (blend of model/stats/elo), pWinnerRawA (winner engine), displayProbA (after dampers), and MCtx.pMatchA (canonical).[Attachment]
   • Different layers sometimes use different ones (Markov cross‑check vs winnerDecision vs display).[Attachment]
   Risk: small but consistent desyncs between what totals, sets, and winner assume is the “real” pWin.
   Fix: pick one canonical pMatchA (after calibration, before narrative dampers), store only that on MCtx, and force all other modules (matchOutcomeProbs, mismatchIdx, markovEffectiveHolds, etc.) to read it instead of their own flavor.
2. Tour/surface routing duplication
   Tour/surface are inferred and re‑mapped in several places:
   • taperTourKey, tourCode from sheet, surfaceAlias, RESEARCHSURFACESPW, ELO surface fetcher, ace/DF baselines, and Markov kernelScale all do their own tour/surface logic.[Attachment]
   Risk: one module thinks “ATP‑CH hard”, another “ATP hard”, another “indoor hard”, so priors, Elo, and totals kernel disagree in corner cases.
   Fix: build a SurfaceTourContext once (tourKey, isWtaStyle, surfaceKey, indoorFlag, ace/DF baselines) and pass that through, instead of raw strings.
3. Data‑quality is not centralized
   You compute/consume quality in different ways:
   • Opponent‑adjusted stats (Efron‑Morris, oppQuality trust, ranksUsed).[Attachment]
   • shouldPassMatchPick (missingCoreData, coldStartSeverity, rankCoverageWeak).[Attachment]
   • Totals risk and narrative (“CH tour — thin data, higher shrinkage”).[Attachment]
   Risk: winner can hard‑PASS on a matchup where totals and sets still act as if quality is OK (or vice versa).
   Fix: create one DataQuality struct per match (severity, coverage, trustMin, tourThinFlag), populate once, and have each lane call a shared guard function (shouldBlockLane(DataQuality, 'WINNER'|'SETS'|'TOTALS')).
4. Model/Stats/Elo conflict handling is lane‑inconsistent
   The MS/Elo conflict logic:
   • Flags msConflict and eloConflict in the blend layer with a clear message.[Attachment]
   • winnerDecision uses msConflict for its hard PASS rule; totals currently only references conflict in text, not as a gate.[Attachment]
   Risk: a serious Stats vs Model conflict can kill the moneyline pick but still allow a full‑confidence totals or sets bet that implicitly trusts the same noisy stats.
   Fix: define a conflict severity scale (NONE / SOFT / HARD) from msConflict, eloConflict, and DataQuality, store on MCtx, and have all lanes use that same scale to choose between BET / LEAN / PASS.
5. Bimodal skill vs bimodal totals separation
   You have:
   • detectBimodalSkill on per‑player holds (peaks/floors, “LIVE ONLY”).[Attachment]
   • A separate bimodal totals banding pipeline (splitGap, med2/med3, band BIMODAL, Stage 8a/8a2).[Attachment]
   Risk: bimodal per‑player skills can influence hold priors and set dynamics in ways that your totals bimodality logic does not see, so totals band = CLEAN while the underlying skill is clearly bimodal.
   Fix: unify these by having detectBimodalSkill write a skillBimodality flag/score into MCtx, and allow the totals bimodal band to read that (as a prior) instead of treating set‑length bimodality and skill bimodality as totally separate worlds.

Remaining work specifically for 2‑ and 3‑set markets
To call it truly “clean” for 2‑set and 3‑set:
• You need SetOutcomeModel as the only source for:
• P(2 sets), P(3 sets) in BO3, and the multi‑set distribution in BO5.[Attachment]
• med2/med3 and their SDs, used by both sets bets and totals.[Attachment]
• Sets bets (2 vs 3) and totals coherence should key strictly off that model, not off separately computed p3 hints or cluster medians.[Attachment]
Once that’s done, yes: your 2‑set and 3‑set logic will be architecturally consistent, with totals and sets seeing the same distribution and your penalties constrained not to destroy genuine edge.

Right now it can predict Over/Under reasonably, but because of the architectural issues we went through, it will sometimes suppress good edges (both Over and Under) in complex spots like bimodal 3‑set matches.[Attachment]
Once you:
• Centralize P3/med2/med3 into a SetOutcomeModel,
• Remove double‑penalties (one signal → one channel),
• Add a global compression cap tied to multi‑method agreement and DataQuality,
then the totals line logic will be structurally sound for both Over and Under calls on 2‑ and 3‑set matches, instead of occasionally talking itself back to PASS when it should trust its own signal.[Attachment]

1. Never “add alongside” – always replace the old block

For any core engine piece (winner prob, bimodal, sets, confidence):

• Do not leave the old code commented out and a new version below it if the old variables are still referenced anywhere.
• Instead, delete or fully replace the old block so there is only one live implementation.

Example:

Bad (colliding):

js
// OLD:
// var p3 = someOldBlend(...);

// NEW:
var p3 = bimodal.pDeciderAuth;

If someOldBlend is still used later, you end up with two different concepts of “p3” floating around.

Correct:

js
// Replace the old code entirely:
var p3 = bimodal.pDeciderAuth;

And make sure any references to the old computation are gone.

---

2. One source of truth per concept

For these keys, there must be exactly one definition:

• Match win probability: a single pWinA (or pFinal) that MATCH_PREVIEW uses.
• Decider probability: a single pDeciderAuth from _computeFullBimodal_.
• BO3 sets thresholds: cfg.p2LeanThr, cfg.p2BetThr, cfg.p3LeanThr, cfg.p3BetThr computed once from tour+32k.
• RiskScore: one place that aggregates all risk factors before confidence is computed.

If you see:

• pDeciderRaw computed in multiple helpers, or
• separate local p2/p3 computations using different formulas,

you need to delete the duplicates and route everyone through the canonical value.

---

3. When you refactor a function, remove all legacy branches

Any time you refactor a core function like _buildSetsMarketEngine_ or _computeFullBimodal_:

• Replace the full function body, not just parts of it.
• Do not leave “old path” branches reachable under conditions like if (legacyMode) or if (!bimodal) unless you are 100% sure they’re dead.

Otherwise, the engine will sometimes run old code and sometimes new, depending on state.

---

4. Avoid “shadow variables” that hide bugs

If you re‑implement something, do not introduce new variables with the same semantic meaning but different names and keep using the old ones elsewhere.

Example:

Bad:

js
var p3Raw = bimodal.pDeciderAuth;
var p3New = _clamp_(p3Raw, ...);

// but later:
if (p3Old >= SETS_MARKET_CFG.READ_STRONG_3SET_BO3) { ... }

Here p3Old is some old variable still in scope, and your new logic is effectively ignored in some checks.

Correct: rename everything to the new canonical name or delete the old, e.g.:

js
var p3 = _clamp_(bimodal.pDeciderAuth, ...);

// and *only* use p3 downstream

Search the function for p3 and make sure you don’t have both p3Old and p3 used in decisions.

---

5. Enforce a “no double computation” rule

When you or an agent makes a change, always check:

• Did we compute match win prob in more than one place?
• Did we compute P(3 sets) in more than one place?
• Did we compute sets thresholds in more than one place?

If yes, the correct fix is:

1. Decide which computation is now the official one.
2. Remove the other one entirely, or convert it to a pure “view” that never feeds MATCH_PREVIEW or pick decisions.

---

Update my script as a downloadable txt link after updating check for syntax and undefined issues