Now I have everything I need. The code is fully vi...

Question

Now I have everything I need. The code is fully visible. Here's the precise fix:

What the code actually does — confirmed

afDetectInjury looks at the Tennis Abstract match history and flags isBack = true when:[1]

Largest recent gap between matches is ≥ 60 days (the INJURYGAPDAYS constant), AND
The gap ended within the last 120 days (daysSinceReturn < 120) — or within 365 days with fewer than 15 matches back

The confidence is HIGH if gap ≥ 180 days + 2 retirements, MID if gap ≥ 90 + 1 retirement, LOW otherwise.[1]

afAutoTagInjury then writes (inj) into A2/A11 only for HIGH or MID confidence — but once written, it never expires.[1]

The correct fix based on Tennis Abstract's actual data

Tennis Abstract's player-classic.cgi data includes a date on every match row and a retirement flag (isRetirement) per match. The fix should use that date to determine whether the injury flag is still current — not just whether the tag exists in the cell.[1]

Here's the patch to afAutoTagInjury:

javascript
function afAutoTagInjury(sheet, cell, origName, injInfo) {
  try {
    if (!injInfo || !injInfo.isBack) return null;
    if (injInfo.confidence !== 'HIGH' && injInfo.confidence !== 'MID') return null;

    // ✅ FIX: Only tag if the return was recent (within 42 days)
    // Tennis Abstract dates let us know exactly when the player came back.
    // If they've played 5+ matches since returning, they're no longer "coming back"
    var now = new Date();
    var daysSinceReturn = injInfo.lastGapEnd
      ? Math.round((now.getTime() - injInfo.lastGapEnd.getTime()) / 86400000)
      : 999;

    var STALENESS_DAYS = 42;       // player back > 42 days ago → not injured anymore
    var MATCHES_BACK_CLEAR = 5;    // played 5+ matches since return → healthy

    if (daysSinceReturn > STALENESS_DAYS) {
      Logger.log('afAutoTagInjury: return was ' + daysSinceReturn + 'd ago, skipping tag');
      return null;
    }
    if (injInfo.matchesSinceReturn >= MATCHES_BACK_CLEAR) {
      Logger.log('afAutoTagInjury: ' + injInfo.matchesSinceReturn + ' matches since return, skipping tag');
      return null;
    }

    // Check if tag already exists
    var lc = origName.toLowerCase();
    var existingTags = ['inj','knee','ankle','leg','calf','hamstring','shoulder','elbow',
      'back','core','oblique','wrist','hand','fatigue','illness','sick','medical'];
    for (var t = 0; t < existingTags.length; t++) {
      if (lc.indexOf(existingTags[t]) !== -1) return null;
    }

    var tagged = origName + ' (inj)';
    sheet.getRange(cell).setValue(tagged);
    return tagged;

  } catch(e) {
    Logger.log('afAutoTagInjury error: ' + e.message);
    return null;
  }
}

You also need to pass matchesSinceReturn back through injInfo, which means adding it to the return object in afDetectInjury:

javascript
// In afDetectInjury, where matchesSinceReturn is already computed:
result.matchesSinceReturn = matchesSinceReturn;  // ← add this line

Why 42 days and 5 matches?

Tennis Abstract shows players typically play 2–4 matches per week at tour level. 42 days ≈ ~4–6 tournaments after returning, more than enough to consider them healthy.[2]
5 matches since return is roughly 1–2 full tournament runs — if they've completed that, the injury is no longer affecting their stats meaningfully.[2]

This way the (inj) tag only fires for genuinely recent returns, and old injuries from months ago in the Abstract data won't keep bypassing the market anchor forever.

Do not give to a sub agent

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?

Updates my script then send it as a downloadable txt link

Answer 1

Done — I updated your script based on the uploaded file (TennisLocks_v26_CAL_2_patched-3_no_conf_none.txt) and saved the fixed version here:

Download the updated script

Applied changes:

_afDetectInjury_ now returns daysSinceReturn and matchesSinceReturn
_afAutoTagInjury_ now only tags when return is within 42 days and matches since return are under 5
the autofill caller now routes through the updated injury-tag function every time, so stale auto-added (inj) tags can be cleared instead of lingering forever
syntax check passed after the edit

Now I have everything I need. The code is fully vi...

Domanda

What the code actually does — confirmed

The correct fix based on Tennis Abstract's actual data

Why 42 days and 5 matches?

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

2. One source of truth per concept

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

4. Avoid “shadow variables” that hide bugs

5. Enforce a “no double computation” rule

Pensiero

Summarizing and finalizing script update response

Risposta

Condividi questa Q&A