FAILURE MAP
← Case archive

FA-82336 / Poker hand evaluation / Open access

Board declared to play when only the category matches · case 01

A player whose ace kicker matters is told the board plays.

Verified by executionVariant 1 · 8 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

Candidate hands are matched to the best hand by category only.

VERIFIED REPAIR

Match the full key, category and every tiebreak rank.

Unsuccessful approach: Matching category and top rank still ignores deeper kickers.

Case contract

Input: {"hole": two cards, "board": five cards}. Return the minimum number of hole cards (0, 1 or 2) needed to make the player's best possible five-card hand; 0 means the board plays.

Why this case matters

"Board plays" detection drives split-pot explanations and hand-history annotations.

1 / The failure

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json
import collections
import itertools
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key5(h):
        vals=sorted((R.index(c[0])+2 for c in h), reverse=True)
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        flush=len({c[1] for c in h})==1
        straight=len(cnt)==5 and (vals[0]-vals[4]==4 or vals==[14,5,4,3,2])
        top=5 if vals==[14,5,4,3,2] else vals[0]
        if straight: return (8 if flush else 4, [top])
        if flush: return (5, vals)
        return ({(4,1):7,(3,2):6,(3,1,1):3,(2,2,1):2,(2,1,1,1):1}.get(tuple(shape),0), order)
    hole=x['hole']; board=x['board']
    best=max(key5(c) for c in itertools.combinations(hole+board,5))
    for n in range(3):
        for hc in itertools.combinations(hole,n):
            for bc in itertools.combinations(board,5-n):
                if key5(hc+bc)[0]==best[0]: return n
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1)],
 [('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('flush with one card', {'board': ['3h', '7h', '9h', 'Jh', 'Kd'], 'hole': ['Ah', '2c']}, 1),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('flush with one card', {'board': ['3h', '7h', '9h', 'Jh', 'Kd'], 'hole': ['Ah', '2c']}, 1),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
board straight plays00Passed
one card kicker01Failed
hole ranks duplicate board straight00Passed
second hole card redundant11Passed
wheel with both22Passed
both cards pair22Passed
pocket pair22Passed
same category better kicker01Failed

SHA-256 / 79405cddbfced61797d09afd0ff508c5c98142cc26aed035fa8723695de305d4

2 / The unsuccessful fix

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json
import collections
import itertools
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key5(h):
        vals=sorted((R.index(c[0])+2 for c in h), reverse=True)
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        flush=len({c[1] for c in h})==1
        straight=len(cnt)==5 and (vals[0]-vals[4]==4 or vals==[14,5,4,3,2])
        top=5 if vals==[14,5,4,3,2] else vals[0]
        if straight: return (8 if flush else 4, [top])
        if flush: return (5, vals)
        return ({(4,1):7,(3,2):6,(3,1,1):3,(2,2,1):2,(2,1,1,1):1}.get(tuple(shape),0), order)
    hole=x['hole']; board=x['board']
    best=max(key5(c) for c in itertools.combinations(hole+board,5))
    for n in range(3):
        for hc in itertools.combinations(hole,n):
            for bc in itertools.combinations(board,5-n):
                if key5(hc+bc)[0]==best[0] and key5(hc+bc)[1][0]==best[1][0]: return n
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1)],
 [('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('flush with one card', {'board': ['3h', '7h', '9h', 'Jh', 'Kd'], 'hole': ['Ah', '2c']}, 1),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('flush with one card', {'board': ['3h', '7h', '9h', 'Jh', 'Kd'], 'hole': ['Ah', '2c']}, 1),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
board straight plays00Passed
one card kicker01Failed
hole ranks duplicate board straight00Passed
second hole card redundant11Passed
wheel with both22Passed
both cards pair22Passed
pocket pair22Passed
same category better kicker01Failed

SHA-256 / fcd31741881de2be2c550d8c30f2e2aac82b588ab9770cc2e79a5f9282cc6469

3 / The verified repair

Exit 0
"""Failure Map reference implementation. Python standard library only."""
import json
import collections
import itertools
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key5(h):
        vals=sorted((R.index(c[0])+2 for c in h), reverse=True)
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        flush=len({c[1] for c in h})==1
        straight=len(cnt)==5 and (vals[0]-vals[4]==4 or vals==[14,5,4,3,2])
        top=5 if vals==[14,5,4,3,2] else vals[0]
        if straight: return (8 if flush else 4, [top])
        if flush: return (5, vals)
        return ({(4,1):7,(3,2):6,(3,1,1):3,(2,2,1):2,(2,1,1,1):1}.get(tuple(shape),0), order)
    hole=x['hole']; board=x['board']
    best=max(key5(c) for c in itertools.combinations(hole+board,5))
    for n in range(3):
        for hc in itertools.combinations(hole,n):
            for bc in itertools.combinations(board,5-n):
                if key5(hc+bc)==best: return n
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1)],
 [('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('flush with one card', {'board': ['3h', '7h', '9h', 'Jh', 'Kd'], 'hole': ['Ah', '2c']}, 1),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('flush with one card', {'board': ['3h', '7h', '9h', 'Jh', 'Kd'], 'hole': ['Ah', '2c']}, 1),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
board straight plays00Passed
one card kicker11Passed
hole ranks duplicate board straight00Passed
second hole card redundant11Passed
wheel with both22Passed
both cards pair22Passed
pocket pair22Passed
same category better kicker11Passed

SHA-256 / ce532ab45c3b2ef3d1482e84f72c385f411c637ab4e06681082992edfaec6e85

Verification & scope

A deterministic toy model with an explicitly stated contract; card strings are rank+suit (for example "As", "Td"); no claim of conformance to any casino or tournament rulebook. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:50:11.298544+00:00.

Case digest / 1b644c51a62a647692a366e2aa55920130f4807f95f2a7168e252bdcc2f81646