FA-74241 / Feature flag rollout bucketing / Open access

Flag override resolution: Negative integers from the environment are rejected · case 01

An operator cannot pin an offset flag to -3 via the environment.

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

ROOT CAUSE

The digit check runs on the whole string, including the minus sign.

VERIFIED REPAIR

Allow a single leading "-" before the digits.

Unsuccessful approach: Also accepting a leading "+" admits spellings the contract rejects.

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
                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']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('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']),
  ('override layer sample 6', ['beta', True, {}, {'beta': 0}, {'FLAG_beta': '-3'}], [True, 'default']),
  ('override layer sample 7', ['beta', True, {}, {'beta': 3}, {'FLAG_beta': 'True'}], [True, 'default']),
  ('override layer sample 8',
   ['dark-mode-v2', False, {'dark-mode-v2': False}, {'dark-mode-v2': True}, {'FLAG_dark_mode_v2': 'True'}],
   [True, 'override'])],
 [('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']),
  ('override layer sample 13', ['beta', 7, {'beta': -2}, {}, {}], [-2, 'remote'])],
 [('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 17',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 'red'}, {'dark-mode-v2': 'red'}, {'FLAG_DARK-MODE-V2': 'yes'}],
   ['red', 'override']),
  ('override layer sample 18',
   ['dark-mode-v2', 0, {}, {'dark-mode-v2': True}, {'FLAG_DARK_MODE_V2': 'true'}],
   [0, 'default'])],
 [('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']),
  ('override layer sample 23', ['beta', False, {'beta': 'red'}, {'beta': 1}, {}], [False, '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	`[0, 'default']`	`[-3, 'env']`	Failed
plus sign is not a valid integer	`[9, 'remote']`	`[9, 'remote']`	Passed
override layer sample 1	`[1, 'remote']`	`[1, 'remote']`	Passed
override layer sample 2	`['blue', 'default']`	`['blue', 'default']`	Passed

SHA-256 / 5e71dcecdd6128517509811f0dee007caf354c210f6487115a216dc8944a851f

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.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']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('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']),
  ('override layer sample 6', ['beta', True, {}, {'beta': 0}, {'FLAG_beta': '-3'}], [True, 'default']),
  ('override layer sample 7', ['beta', True, {}, {'beta': 3}, {'FLAG_beta': 'True'}], [True, 'default']),
  ('override layer sample 8',
   ['dark-mode-v2', False, {'dark-mode-v2': False}, {'dark-mode-v2': True}, {'FLAG_dark_mode_v2': 'True'}],
   [True, 'override'])],
 [('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']),
  ('override layer sample 13', ['beta', 7, {'beta': -2}, {}, {}], [-2, 'remote'])],
 [('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 17',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 'red'}, {'dark-mode-v2': 'red'}, {'FLAG_DARK-MODE-V2': 'yes'}],
   ['red', 'override']),
  ('override layer sample 18',
   ['dark-mode-v2', 0, {}, {'dark-mode-v2': True}, {'FLAG_DARK_MODE_V2': 'true'}],
   [0, 'default'])],
 [('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']),
  ('override layer sample 23', ['beta', False, {'beta': 'red'}, {'beta': 1}, {}], [False, '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
plus sign is not a valid integer	`[4, 'env']`	`[9, 'remote']`	Failed
override layer sample 1	`[1, 'remote']`	`[1, 'remote']`	Passed
override layer sample 2	`['blue', 'default']`	`['blue', 'default']`	Passed

SHA-256 / b6c15190f31d8850d5ac5e9e44b949c1f34d82dbbf2811b6f9df1a7752492ba1

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']),
  ('plus sign is not a valid integer', ['beta', 0, {'beta': 9}, {}, {'FLAG_BETA': '+4'}], [9, 'remote']),
  ('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']),
  ('override layer sample 6', ['beta', True, {}, {'beta': 0}, {'FLAG_beta': '-3'}], [True, 'default']),
  ('override layer sample 7', ['beta', True, {}, {'beta': 3}, {'FLAG_beta': 'True'}], [True, 'default']),
  ('override layer sample 8',
   ['dark-mode-v2', False, {'dark-mode-v2': False}, {'dark-mode-v2': True}, {'FLAG_dark_mode_v2': 'True'}],
   [True, 'override'])],
 [('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']),
  ('override layer sample 13', ['beta', 7, {'beta': -2}, {}, {}], [-2, 'remote'])],
 [('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 17',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 'red'}, {'dark-mode-v2': 'red'}, {'FLAG_DARK-MODE-V2': 'yes'}],
   ['red', 'override']),
  ('override layer sample 18',
   ['dark-mode-v2', 0, {}, {'dark-mode-v2': True}, {'FLAG_DARK_MODE_V2': 'true'}],
   [0, 'default'])],
 [('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']),
  ('override layer sample 23', ['beta', False, {'beta': 'red'}, {'beta': 1}, {}], [False, '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
plus sign is not a valid integer	`[9, 'remote']`	`[9, 'remote']`	Passed
override layer sample 1	`[1, 'remote']`	`[1, 'remote']`	Passed
override layer sample 2	`['blue', 'default']`	`['blue', 'default']`	Passed

SHA-256 / 2af0a23a73882ff5469f52427f15a1b750618fe9bee33908ea74cc4418f7d77c

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.895303+00:00.

Case digest / 05375cb94bcb4c52c6291a5cabb1fa4c47d78a1425ee9ac5716d5322b0a6b9f7