FA-74226 / Feature flag rollout bucketing / Open access

Flag override resolution: Local overrides beat environment variables · case 01

An incident responder's environment pin is ignored on hosts with a local override file.

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

ROOT CAUSE

The override layer is listed before the environment layer.

VERIFIED REPAIR

Resolve env, then local override, then remote, then default.

Unsuccessful approach: Placing remote before the local override lets the server undo local pins.

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().replace('-', '_')
    layers = [('override', overrides, key, False), ('env', env, name, True), ('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']),
  ('local override beats remote', ['beta', 'a', {'beta': 'b'}, {'beta': 'c'}, {}], ['c', 'override']),
  ('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']),
  ('local override beats remote', ['beta', 'a', {'beta': 'b'}, {'beta': 'c'}, {}], ['c', 'override']),
  ('override layer sample 8',
   ['dark-mode-v2', False, {'dark-mode-v2': False}, {'dark-mode-v2': True}, {'FLAG_dark_mode_v2': 'True'}],
   [True, 'override']),
  ('override layer sample 42',
   ['dark-mode-v2', 7, {'dark-mode-v2': 'red'}, {'dark-mode-v2': 3}, {'FLAG_DARK_MODE_V2': '0'}],
   [0, 'env'])],
 [('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 48', ['beta', 0, {'beta': 3}, {'beta': 3}, {}], [3, 'override'])],
 [('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 4',
   ['dark-mode-v2', 0, {'dark-mode-v2': -2}, {'dark-mode-v2': -2}, {'FLAG_dark_mode_v2': 'yes'}],
   [-2, 'override']),
  ('override layer sample 16', ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {}], ['blue', 'default']),
  ('override layer sample 42',
   ['dark-mode-v2', 7, {'dark-mode-v2': 'red'}, {'dark-mode-v2': 3}, {'FLAG_DARK_MODE_V2': '0'}],
   [0, 'env'])],
 [('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 17',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 'red'}, {'dark-mode-v2': 'red'}, {'FLAG_DARK-MODE-V2': 'yes'}],
   ['red', 'override']),
  ('override layer sample 21',
   ['dark-mode-v2', False, {}, {}, {'FLAG_DARK-MODE-V2': 'true'}],
   [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	`[False, 'override']`	`[True, 'env']`	Failed
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
local override beats remote	`['c', 'override']`	`['c', 'override']`	Passed
override layer sample 1	`[1, 'remote']`	`[1, 'remote']`	Passed
override layer sample 2	`['blue', 'default']`	`['blue', 'default']`	Passed

SHA-256 / 11f3463e191a65346853a1d5875c176cbcb18e959f59c12904619e2fb0db3919

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), ('remote', remote, key, False), ('override', overrides, 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']),
  ('local override beats remote', ['beta', 'a', {'beta': 'b'}, {'beta': 'c'}, {}], ['c', 'override']),
  ('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']),
  ('local override beats remote', ['beta', 'a', {'beta': 'b'}, {'beta': 'c'}, {}], ['c', 'override']),
  ('override layer sample 8',
   ['dark-mode-v2', False, {'dark-mode-v2': False}, {'dark-mode-v2': True}, {'FLAG_dark_mode_v2': 'True'}],
   [True, 'override']),
  ('override layer sample 42',
   ['dark-mode-v2', 7, {'dark-mode-v2': 'red'}, {'dark-mode-v2': 3}, {'FLAG_DARK_MODE_V2': '0'}],
   [0, 'env'])],
 [('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 48', ['beta', 0, {'beta': 3}, {'beta': 3}, {}], [3, 'override'])],
 [('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 4',
   ['dark-mode-v2', 0, {'dark-mode-v2': -2}, {'dark-mode-v2': -2}, {'FLAG_dark_mode_v2': 'yes'}],
   [-2, 'override']),
  ('override layer sample 16', ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {}], ['blue', 'default']),
  ('override layer sample 42',
   ['dark-mode-v2', 7, {'dark-mode-v2': 'red'}, {'dark-mode-v2': 3}, {'FLAG_DARK_MODE_V2': '0'}],
   [0, 'env'])],
 [('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 17',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 'red'}, {'dark-mode-v2': 'red'}, {'FLAG_DARK-MODE-V2': 'yes'}],
   ['red', 'override']),
  ('override layer sample 21',
   ['dark-mode-v2', False, {}, {}, {'FLAG_DARK-MODE-V2': 'true'}],
   [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
local override beats remote	`['b', 'remote']`	`['c', 'override']`	Failed
override layer sample 1	`[1, 'remote']`	`[1, 'remote']`	Passed
override layer sample 2	`['blue', 'default']`	`['blue', 'default']`	Passed

SHA-256 / d782bc43266f484c03e3c0dbe5d18eb541a69b0a619862122bdd9ad6814fd128

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']),
  ('local override beats remote', ['beta', 'a', {'beta': 'b'}, {'beta': 'c'}, {}], ['c', 'override']),
  ('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']),
  ('local override beats remote', ['beta', 'a', {'beta': 'b'}, {'beta': 'c'}, {}], ['c', 'override']),
  ('override layer sample 8',
   ['dark-mode-v2', False, {'dark-mode-v2': False}, {'dark-mode-v2': True}, {'FLAG_dark_mode_v2': 'True'}],
   [True, 'override']),
  ('override layer sample 42',
   ['dark-mode-v2', 7, {'dark-mode-v2': 'red'}, {'dark-mode-v2': 3}, {'FLAG_DARK_MODE_V2': '0'}],
   [0, 'env'])],
 [('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 48', ['beta', 0, {'beta': 3}, {'beta': 3}, {}], [3, 'override'])],
 [('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 4',
   ['dark-mode-v2', 0, {'dark-mode-v2': -2}, {'dark-mode-v2': -2}, {'FLAG_dark_mode_v2': 'yes'}],
   [-2, 'override']),
  ('override layer sample 16', ['dark-mode-v2', 'blue', {'dark-mode-v2': 1}, {}, {}], ['blue', 'default']),
  ('override layer sample 42',
   ['dark-mode-v2', 7, {'dark-mode-v2': 'red'}, {'dark-mode-v2': 3}, {'FLAG_DARK_MODE_V2': '0'}],
   [0, 'env'])],
 [('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 17',
   ['dark-mode-v2', 'blue', {'dark-mode-v2': 'red'}, {'dark-mode-v2': 'red'}, {'FLAG_DARK-MODE-V2': 'yes'}],
   ['red', 'override']),
  ('override layer sample 21',
   ['dark-mode-v2', False, {}, {}, {'FLAG_DARK-MODE-V2': 'true'}],
   [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
local override beats remote	`['c', 'override']`	`['c', 'override']`	Passed
override layer sample 1	`[1, 'remote']`	`[1, 'remote']`	Passed
override layer sample 2	`['blue', 'default']`	`['blue', 'default']`	Passed

SHA-256 / 4c92ce8021adcaf4d605e23914a0511128012af6889ec251089b9234aed7a783

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

Case digest / 47df988a20bedcb09c3f3c351429709ed0218c5c16f613051fa245875cba1075