FA-74231 / Feature flag rollout bucketing / Open access

Flag override resolution: Dashes survive in environment variable names · case 01

FLAG_DARK-MODE-V2 can never be set from a shell, so the env layer is unreachable for dashed keys.

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

ROOT CAUSE

The key is uppercased but dashes are not replaced with underscores.

VERIFIED REPAIR

Uppercase the key and replace "-" with "_".

Unsuccessful approach: Replacing dashes without uppercasing looks up a lowercase variable name.

Case contract

Layers in precedence order: env var FLAG_<KEY uppercased with "-" -> "_">, local overrides[key], remote[key], then the default. A layer is used only if its value is valid for the default's type, else the next layer is tried. Non-env values must have exactly the default's type (bool is not int). Env strings: bool defaults accept "true"/"false" case-insensitively; int defaults accept digits with an optional leading "-"; str defaults accept any string. Return [value, source].

Why this case matters

Local and environment overrides are how operators pin flags during incidents; precedence must be exact.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(key, default, remote, overrides, env):
    def coerce(v, from_env):
        if from_env:
            if isinstance(default, bool):
                low = v.lower()
                return (True, low == 'true') if low in ('true', 'false') else (False, None)
            if isinstance(default, int):
                body = v[1:] if v.startswith('-') else v
                return (True, int(v)) if body.isdigit() else (False, None)
            return (True, v)
        return (True, v) if type(v) is type(default) else (False, None)
    name = 'FLAG_' + key.upper()
    layers = [('env', env, name, True), ('override', overrides, key, False), ('remote', remote, key, False)]
    for source, table, k, from_env in layers:
        if k in table:
            ok, value = coerce(table[k], from_env)
            if ok:
                return [value, source]
    return [default, 'default']
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('boolean remote value rejected for integer flag', ['beta', 3, {'beta': True}, {}, {}], [3, 'default']),
  ('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('dashed key maps to underscored env name',
   ['dark-mode-v2', 'blue', {}, {}, {'FLAG_DARK_MODE_V2': 'green'}],
   ['green', 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('override layer sample 1', ['beta', 7, {'beta': 1}, {}, {}], [1, 'remote']),
  ('override layer sample 2', ['new-ui', 'blue', {'new-ui': False}, {}, {}], ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('dashed key maps to underscored env name',
   ['dark-mode-v2', 'blue', {}, {}, {'FLAG_DARK_MODE_V2': 'green'}],
   ['green', 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('override layer sample 6', ['beta', True, {}, {'beta': 0}, {'FLAG_beta': '-3'}], [True, 'default']),
  ('override layer sample 22',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {'FLAG_dark_mode_v2': 'True'}],
   ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('dashed key maps to underscored env name',
   ['dark-mode-v2', 'blue', {}, {}, {'FLAG_DARK_MODE_V2': 'green'}],
   ['green', 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('override layer sample 11', ['beta', True, {'beta': -2}, {'beta': 0}, {}], [True, 'default']),
  ('override layer sample 12', ['dark-mode-v2', 'blue', {}, {'dark-mode-v2': 0}, {}], ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('non-boolean env text is invalid for boolean flag',
   ['beta', True, {'beta': True}, {}, {'FLAG_BETA': 'yes'}],
   [True, 'remote']),
  ('override layer sample 16', ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {}], ['blue', 'default']),
  ('override layer sample 22',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {'FLAG_dark_mode_v2': 'True'}],
   ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('non-boolean env text is invalid for boolean flag',
   ['beta', True, {'beta': True}, {}, {'FLAG_BETA': 'yes'}],
   [True, 'remote']),
  ('local override beats remote', ['beta', 'a', {'beta': 'b'}, {'beta': 'c'}, {}], ['c', 'override']),
  ('override layer sample 21',
   ['dark-mode-v2', False, {}, {}, {'FLAG_DARK-MODE-V2': 'true'}],
   [False, 'default']),
  ('override layer sample 22',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {'FLAG_dark_mode_v2': 'True'}],
   ['blue', 'default'])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(*args), 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 fixture	Actual	Expected	Outcome
boolean remote value rejected for integer flag	`[3, 'default']`	`[3, 'default']`	Passed
environment beats local override	`[False, 'override']`	`[True, 'env']`	Failed
dashed key maps to underscored env name	`['blue', 'default']`	`['green', 'env']`	Failed
invalid env value falls through to remote	`[5, 'remote']`	`[5, 'remote']`	Passed
negative integer from env	`[-3, 'env']`	`[-3, 'env']`	Passed
env boolean is case-insensitive	`[True, 'env']`	`[True, 'env']`	Passed
override layer sample 1	`[1, 'remote']`	`[1, 'remote']`	Passed
override layer sample 2	`['blue', 'default']`	`['blue', 'default']`	Passed

SHA-256 / 483fd7f94f925c03aa8276c6a25e5c9e1e8f1911e87c2929b54ec33b558881c4

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(key, default, remote, overrides, env):
    def coerce(v, from_env):
        if from_env:
            if isinstance(default, bool):
                low = v.lower()
                return (True, low == 'true') if low in ('true', 'false') else (False, None)
            if isinstance(default, int):
                body = v[1:] if v.startswith('-') else v
                return (True, int(v)) if body.isdigit() else (False, None)
            return (True, v)
        return (True, v) if type(v) is type(default) else (False, None)
    name = 'FLAG_' + key.replace('-', '_')
    layers = [('env', env, name, True), ('override', overrides, key, False), ('remote', remote, key, False)]
    for source, table, k, from_env in layers:
        if k in table:
            ok, value = coerce(table[k], from_env)
            if ok:
                return [value, source]
    return [default, 'default']
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('boolean remote value rejected for integer flag', ['beta', 3, {'beta': True}, {}, {}], [3, 'default']),
  ('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('dashed key maps to underscored env name',
   ['dark-mode-v2', 'blue', {}, {}, {'FLAG_DARK_MODE_V2': 'green'}],
   ['green', 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('override layer sample 1', ['beta', 7, {'beta': 1}, {}, {}], [1, 'remote']),
  ('override layer sample 2', ['new-ui', 'blue', {'new-ui': False}, {}, {}], ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('dashed key maps to underscored env name',
   ['dark-mode-v2', 'blue', {}, {}, {'FLAG_DARK_MODE_V2': 'green'}],
   ['green', 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('override layer sample 6', ['beta', True, {}, {'beta': 0}, {'FLAG_beta': '-3'}], [True, 'default']),
  ('override layer sample 22',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {'FLAG_dark_mode_v2': 'True'}],
   ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('dashed key maps to underscored env name',
   ['dark-mode-v2', 'blue', {}, {}, {'FLAG_DARK_MODE_V2': 'green'}],
   ['green', 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('override layer sample 11', ['beta', True, {'beta': -2}, {'beta': 0}, {}], [True, 'default']),
  ('override layer sample 12', ['dark-mode-v2', 'blue', {}, {'dark-mode-v2': 0}, {}], ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('non-boolean env text is invalid for boolean flag',
   ['beta', True, {'beta': True}, {}, {'FLAG_BETA': 'yes'}],
   [True, 'remote']),
  ('override layer sample 16', ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {}], ['blue', 'default']),
  ('override layer sample 22',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {'FLAG_dark_mode_v2': 'True'}],
   ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('non-boolean env text is invalid for boolean flag',
   ['beta', True, {'beta': True}, {}, {'FLAG_BETA': 'yes'}],
   [True, 'remote']),
  ('local override beats remote', ['beta', 'a', {'beta': 'b'}, {'beta': 'c'}, {}], ['c', 'override']),
  ('override layer sample 21',
   ['dark-mode-v2', False, {}, {}, {'FLAG_DARK-MODE-V2': 'true'}],
   [False, 'default']),
  ('override layer sample 22',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {'FLAG_dark_mode_v2': 'True'}],
   ['blue', 'default'])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(*args), 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 fixture	Actual	Expected	Outcome
boolean remote value rejected for integer flag	`[3, 'default']`	`[3, 'default']`	Passed
environment beats local override	`[False, 'override']`	`[True, 'env']`	Failed
dashed key maps to underscored env name	`['blue', 'default']`	`['green', 'env']`	Failed
invalid env value falls through to remote	`[5, 'remote']`	`[5, 'remote']`	Passed
negative integer from env	`[0, 'default']`	`[-3, 'env']`	Failed
env boolean is case-insensitive	`[False, 'default']`	`[True, 'env']`	Failed
override layer sample 1	`[1, 'remote']`	`[1, 'remote']`	Passed
override layer sample 2	`['blue', 'default']`	`['blue', 'default']`	Passed

SHA-256 / 32efceb93c33e59cf00446cca6623661d50301c68c92f04a3570e4d9e54f00a0

3 / The verified repair

Exit 0

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(key, default, remote, overrides, env):
    def coerce(v, from_env):
        if from_env:
            if isinstance(default, bool):
                low = v.lower()
                return (True, low == 'true') if low in ('true', 'false') else (False, None)
            if isinstance(default, int):
                body = v[1:] if v.startswith('-') else v
                return (True, int(v)) if body.isdigit() else (False, None)
            return (True, v)
        return (True, v) if type(v) is type(default) else (False, None)
    name = 'FLAG_' + key.upper().replace('-', '_')
    layers = [('env', env, name, True), ('override', overrides, key, False), ('remote', remote, key, False)]
    for source, table, k, from_env in layers:
        if k in table:
            ok, value = coerce(table[k], from_env)
            if ok:
                return [value, source]
    return [default, 'default']
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('boolean remote value rejected for integer flag', ['beta', 3, {'beta': True}, {}, {}], [3, 'default']),
  ('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('dashed key maps to underscored env name',
   ['dark-mode-v2', 'blue', {}, {}, {'FLAG_DARK_MODE_V2': 'green'}],
   ['green', 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('override layer sample 1', ['beta', 7, {'beta': 1}, {}, {}], [1, 'remote']),
  ('override layer sample 2', ['new-ui', 'blue', {'new-ui': False}, {}, {}], ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('dashed key maps to underscored env name',
   ['dark-mode-v2', 'blue', {}, {}, {'FLAG_DARK_MODE_V2': 'green'}],
   ['green', 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('override layer sample 6', ['beta', True, {}, {'beta': 0}, {'FLAG_beta': '-3'}], [True, 'default']),
  ('override layer sample 22',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {'FLAG_dark_mode_v2': 'True'}],
   ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('dashed key maps to underscored env name',
   ['dark-mode-v2', 'blue', {}, {}, {'FLAG_DARK_MODE_V2': 'green'}],
   ['green', 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('override layer sample 11', ['beta', True, {'beta': -2}, {'beta': 0}, {}], [True, 'default']),
  ('override layer sample 12', ['dark-mode-v2', 'blue', {}, {'dark-mode-v2': 0}, {}], ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('invalid env value falls through to remote',
   ['beta', 0, {'beta': 5}, {}, {'FLAG_BETA': 'lots'}],
   [5, 'remote']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('non-boolean env text is invalid for boolean flag',
   ['beta', True, {'beta': True}, {}, {'FLAG_BETA': 'yes'}],
   [True, 'remote']),
  ('override layer sample 16', ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {}], ['blue', 'default']),
  ('override layer sample 22',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {'FLAG_dark_mode_v2': 'True'}],
   ['blue', 'default'])],
 [('environment beats local override',
   ['new-ui', False, {}, {'new-ui': False}, {'FLAG_NEW_UI': 'true'}],
   [True, 'env']),
  ('negative integer from env', ['beta', 0, {}, {}, {'FLAG_BETA': '-3'}], [-3, 'env']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('env boolean is case-insensitive', ['beta', False, {}, {}, {'FLAG_BETA': 'TRUE'}], [True, 'env']),
  ('non-boolean env text is invalid for boolean flag',
   ['beta', True, {'beta': True}, {}, {'FLAG_BETA': 'yes'}],
   [True, 'remote']),
  ('local override beats remote', ['beta', 'a', {'beta': 'b'}, {'beta': 'c'}, {}], ['c', 'override']),
  ('override layer sample 21',
   ['dark-mode-v2', False, {}, {}, {'FLAG_DARK-MODE-V2': 'true'}],
   [False, 'default']),
  ('override layer sample 22',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {'FLAG_dark_mode_v2': 'True'}],
   ['blue', 'default'])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(*args), 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 fixture	Actual	Expected	Outcome
boolean remote value rejected for integer flag	`[3, 'default']`	`[3, 'default']`	Passed
environment beats local override	`[True, 'env']`	`[True, 'env']`	Passed
dashed key maps to underscored env name	`['green', 'env']`	`['green', 'env']`	Passed
invalid env value falls through to remote	`[5, 'remote']`	`[5, 'remote']`	Passed
negative integer from env	`[-3, 'env']`	`[-3, 'env']`	Passed
env boolean is case-insensitive	`[True, 'env']`	`[True, 'env']`	Passed
override layer sample 1	`[1, 'remote']`	`[1, 'remote']`	Passed
override layer sample 2	`['blue', 'default']`	`['blue', 'default']`	Passed

SHA-256 / 85e08334691f424cfa012c3db5b51b8b5dec8a7ddca9b31d8ed6e5eea7a69aee

Verification & scope

A deterministic toy flag-evaluation model with a stipulated contract; it does not reproduce any vendor SDK byte for byte. 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:48:54.760797+00:00.

Case digest / 7c242dc48f97ddf6f7d43014970c4f974a9d0175c92d696bb4d2cfc8f5ab4914