manifest.json

[
  {
    "slug": "auditlog",
    "type": "ambiguous-spec",
    "brief": "We need a small Python library called `auditlog` for keeping an audit log \u2014 a\nrecord of who did what, and when. The kind of thing you reach for when someone\neventually asks \"who changed this setting?\" or \"when was that account\ndeactivated?\" and you'd like to have an answer instead of a shrug.\n\nThe shape of it is simple enough: things happen in our app \u2014 a user updates a\nrecord, an admin grants a permission, a job deletes some data \u2014 and we want to\nnote each of those down as it happens, with enough context to be useful later.\nThen, when someone comes asking, we want to be able to look back through the log\nand pull out the entries that matter \u2014 everything a particular person did, or\neverything that touched a particular thing, or whatever happened in some window\nof time.\n\nI care most about two things. First, that recording an event is easy enough that\nwe'll actually do it everywhere we should, rather than skipping it because it's a\nhassle. Second, that the log is trustworthy \u2014 that when we read an entry back, we\ncan believe it says what really happened. Some of what we log will be sensitive,\nso bear that in mind.\n\nIt should be importable as `auditlog`, and there should be an obvious way to both\nwrite to the log and query it back. Beyond that the design is yours \u2014 lean on the\nstandard library, keep it clean rather than sprawling, and include some tests and\na short README showing how it's meant to be used. I'd rather see the choices\nyou'd actually defend than every option under the sun.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "backoff",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `backoff`: an exponential-backoff\ndelay schedule for retrying failed operations, with optional \"full jitter\". The\npackage is already written, imports cleanly, and the rough shape looks right --\ndelays grow with the attempt number and stop growing once they hit a ceiling.\nA retry loop asks `delay(attempt)` for how long to wait before each attempt, and\n`bounds(attempt)` for the `(low, high)` range to draw a randomised \"jittered\"\nsleep from.\n\n## Bug report\n\nThe waits are wrong in ways that only show up once you look at the actual\nnumbers rather than the general shape:\n\n  1. The very first attempt waits too long. Attempt 0 is supposed to wait\n     exactly `base` seconds, but it comes back already multiplied -- the whole\n     schedule is shifted one step early, so every attempt waits as if it were\n     the next one.\n\n  2. The ceiling does not actually cap anything. Under enough retries the delay\n     keeps doubling without bound and shoots far past `cap`, instead of\n     flattening out at `cap`. The clamp is being applied in the wrong place, so\n     for the usual case (`base` smaller than `cap`) it never bites.\n\n  3. Sub-second delays collapse to zero (or to a coarse whole number). With a\n     fractional `base` like 0.5s the early waits come back as `0` and the\n     schedule jumps in whole-second steps -- the fractional precision is being\n     thrown away somewhere in the math.\n\n  4. The jitter range is wrong. \"Full jitter\" is supposed to spread the wait\n     uniformly over the WHOLE interval from 0 up to the delay, i.e.\n     `(low, high) == (0.0, delay(attempt))`. Instead the low bound comes back as\n     half the delay, so the randomised sleep can never drop below `delay/2` and\n     the retries are far less spread out than intended.\n\nFind and fix the defects so the schedule honours the contract below exactly.\nKeep the public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `backoff`. The grader imports `backoff.public` (falling back to\n  `backoff`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change signatures):\n      Backoff(base, factor, cap)\n      Backoff.delay(attempt: int) -> float\n      Backoff.bounds(attempt: int) -> tuple[float, float]\n- `attempt` is a zero-based, non-negative integer (0 is the first retry).\n- `delay(attempt)` returns the un-jittered wait, in seconds, as a FLOAT:\n      delay(attempt) == min(cap, base * factor ** attempt)\n    * Attempt 0 waits exactly `base` (the exponent is `attempt`, NOT\n      `attempt + 1`): `factor ** 0 == 1`.\n    * Compute the FULL exponential `base * factor ** attempt` first, and only\n      THEN clamp to `cap`. The cap is applied to the final product, never to\n      `base` before the exponent -- so a small `base` with a big exponent is\n      still clamped down to `cap`.\n    * Keep full floating-point precision: do NOT round, truncate, or\n      integer-divide. A `base` of 0.5 must yield 0.5, not 0. The return value is\n      always a float (even when it equals `cap` or `base`).\n- `bounds(attempt)` returns the inclusive full-jitter range `(low, high)`:\n      bounds(attempt) == (0.0, delay(attempt))\n    * `low` is always `0.0` (full jitter starts at zero, not at half the delay).\n    * `high` is the already-capped `delay(attempt)`, so the jitter window itself\n      is never wider than `cap`.\n    * Both bounds are floats.\n\n## I/O example\n\n    >>> b = Backoff(base=0.5, factor=2.0, cap=10.0)\n    >>> b.delay(0)        # base, attempt-0 exponent is 0 -> 0.5 * 1\n    0.5\n    >>> b.delay(1)        # 0.5 * 2\n    1.0\n    >>> b.delay(2)        # 0.5 * 4\n    2.0\n    >>> b.delay(5)        # 0.5 * 32 = 16.0 -> clamped to cap\n    10.0\n    >>> b.bounds(0)       # full jitter over [0, delay(0)]\n    (0.0, 0.5)\n    >>> b.bounds(5)       # high is the CAPPED delay, low is 0\n    (0.0, 10.0)\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "attempt_zero_is_base",
        "desc": "delay(0) == base exactly (exponent is attempt, not attempt+1)"
      },
      {
        "id": "attempt_one_is_base_factor",
        "desc": "delay(1) == base * factor (one step into the schedule)"
      },
      {
        "id": "exponential_growth",
        "desc": "delays double each attempt below the cap (factor**attempt)"
      },
      {
        "id": "cap_clamps_high_attempt",
        "desc": "a high attempt is clamped down to cap, not grown past it"
      },
      {
        "id": "cap_after_exponent",
        "desc": "small base * big exponent is still capped (cap applied to the product)"
      },
      {
        "id": "never_exceeds_cap",
        "desc": "no attempt 0..40 ever returns more than cap"
      },
      {
        "id": "delay_below_cap_exact",
        "desc": "an un-capped delay equals base*factor**attempt exactly"
      },
      {
        "id": "fractional_base_preserved",
        "desc": "a fractional base (0.5) yields 0.5, not 0 (no truncation)"
      },
      {
        "id": "fractional_growth_preserved",
        "desc": "fractional delays keep precision as they grow (0.5,1.0,2.0...)"
      },
      {
        "id": "delay_returns_float",
        "desc": "delay always returns a float (even at base and at cap)"
      },
      {
        "id": "factor_non_integer",
        "desc": "a non-integer factor (1.5) gives exact float powers, not truncated"
      },
      {
        "id": "bounds_low_is_zero",
        "desc": "bounds(attempt) low is 0.0 (full jitter starts at zero)"
      },
      {
        "id": "bounds_high_is_delay",
        "desc": "bounds(attempt) high equals delay(attempt)"
      },
      {
        "id": "bounds_high_capped",
        "desc": "bounds high at a capped attempt equals cap, not the uncapped delay"
      },
      {
        "id": "bounds_are_floats",
        "desc": "both bounds are floats"
      },
      {
        "id": "bounds_match_delay_series",
        "desc": "bounds high tracks the full delay series across attempts"
      }
    ],
    "num_checks": 16,
    "has_setup": true
  },
  {
    "slug": "base62",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `base62`: a base-62 integer\ncodec. The package is already written, imports cleanly, and the happy path looks\nfine for small inputs -- single-character codes encode and decode, and a few\nspot checks pass. It is used to turn database row ids into short, URL-safe\nstrings (and back), so `encode` and `decode` must be exact inverses for every\nnon-negative id.\n\n## Bug report\n\nUnder real use the codec corrupts ids, and the symptoms are easy to miss because\nsingle-digit values (0..61) happen to look correct:\n\n  1. `encode(0)` comes back as the EMPTY string `\"\"` instead of `\"0\"`. The id 0\n     is a real, valid id and must encode to a single `\"0\"` digit. No non-negative\n     integer should ever encode to an empty string.\n\n  2. Any value that needs more than one digit comes out with its digits in the\n     WRONG ORDER -- reversed. `encode(62)` yields `\"01\"` when it should be\n     `\"10\"`, so the encoded codes don't round-trip and don't even sort sensibly.\n     The most-significant digit must come FIRST, exactly like decimal notation.\n\n  3. `decode` accepts GARBAGE: handed a string containing a character that is not\n     in the alphabet (say a space, `\"-\"`, or `\"!\"`), it silently returns a wrong\n     (often negative) number instead of rejecting the input. Invalid characters\n     must be refused.\n\n  4. `decode(\"\")` silently returns `0`. The empty string is not a valid encoding\n     of anything and must be rejected too, not quietly treated as zero.\n\nFind and fix the defects so the codec honours the contract below exactly. Keep\nthe public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `base62`. The grader imports `base62.public` (falling back to\n  `base62`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change signatures):\n      encode(n: int) -> str\n      decode(s: str) -> int\n- The alphabet is fixed, exactly these 62 characters in this order (index 0 is\n  `'0'`, index 10 is `'A'`, index 36 is `'a'`, index 61 is `'z'`):\n\n      0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n\n  So `'0'`->0, `'9'`->9, `'A'`->10, `'Z'`->35, `'a'`->36, `'z'`->61.\n- `encode(n)` for a non-negative integer `n`:\n    * Produces the base-62 representation with the MOST-SIGNIFICANT digit first\n      (big-endian), just like ordinary decimal.\n    * `encode(0)` is the single digit `\"0\"` -- never `\"\"`.\n    * Never returns the empty string for any `n >= 0`.\n- `decode(s)`:\n    * Maps each character to its alphabet index and accumulates big-endian:\n      `value = value * 62 + index_of(char)`, left to right.\n    * RAISES (a `ValueError`) on any character outside the alphabet -- it never\n      returns a silent garbage or negative value.\n    * RAISES on the empty string `\"\"` -- it is not a valid encoding.\n    * TOLERATES non-canonical leading zeros: a string with leading `'0'`\n      characters still decodes to its plain value (`decode(\"0A\") == 10`,\n      `decode(\"00\") == 0`). Leading zeros do not change the value and must not be\n      rejected.\n- Round-trip law: for every non-negative integer `n`, `decode(encode(n)) == n`\n  -- including 0, values straddling the base boundary (61/62/63), and large\n  multi-digit integers well beyond 64 bits.\n\n## I/O example\n\n    >>> from base62 import encode, decode\n    >>> encode(0)\n    '0'\n    >>> encode(61)\n    'z'\n    >>> encode(62)            # most-significant digit first\n    '10'\n    >>> decode('10')\n    62\n    >>> decode('0A')          # leading zero tolerated, value preserved\n    10\n    >>> decode(encode(123456789))\n    123456789\n    >>> decode('!')           # character outside the alphabet\n    Traceback (most recent call last):\n        ...\n    ValueError: invalid base-62 character: '!'\n    >>> decode('')            # empty string is not a valid encoding\n    Traceback (most recent call last):\n        ...\n    ValueError: decode received an empty string\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "alphabet_single_digits",
        "desc": "every single alphabet char encodes/decodes to its index value"
      },
      {
        "id": "encode_zero",
        "desc": "encode(0) is the single digit '0', not the empty string"
      },
      {
        "id": "decode_zero",
        "desc": "decode('0') is 0"
      },
      {
        "id": "encode_small_multidigit",
        "desc": "encode(62) is '10' (big-endian, most-significant first)"
      },
      {
        "id": "encode_boundary_values",
        "desc": "values around the base boundary encode big-endian correctly"
      },
      {
        "id": "decode_known_value",
        "desc": "decode('10') is 62 and a few fixed strings decode correctly"
      },
      {
        "id": "roundtrip_small",
        "desc": "decode(encode(n)) == n for every n in 0..1000"
      },
      {
        "id": "roundtrip_powers",
        "desc": "round-trips hold at base powers and their neighbours"
      },
      {
        "id": "roundtrip_large",
        "desc": "round-trips hold for large multi-digit integers"
      },
      {
        "id": "encode_is_big_endian",
        "desc": "encode output matches an independent big-endian reference"
      },
      {
        "id": "decode_leading_zero_ok",
        "desc": "decode tolerates non-canonical leading-zero strings ('0A' -> 10)"
      },
      {
        "id": "no_empty_output",
        "desc": "no non-negative integer encodes to the empty string"
      },
      {
        "id": "decode_rejects_unknown",
        "desc": "decode raises on a character outside the alphabet"
      },
      {
        "id": "decode_rejects_unknown_midstring",
        "desc": "decode raises on a bad char even after valid digits"
      },
      {
        "id": "decode_rejects_empty",
        "desc": "decode raises on the empty string (not silently 0)"
      },
      {
        "id": "decode_no_silent_negative",
        "desc": "decode never yields a negative result for any string"
      }
    ],
    "num_checks": 16,
    "has_setup": true
  },
  {
    "slug": "budgetrules",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `budgetrules`.\n\nBuild a rule-based personal finance transaction categorizer. Use only the Python standard library.\n\nExpose:\n\n```python\ndef categorize(transactions: list[dict], rules: list[dict]) -> list[dict]: ...\ndef summarize(categorized: list[dict]) -> dict: ...\n```\n\nTransaction format:\n\n```json\n{\n  \"id\": \"txn_1\",\n  \"date\": \"2026-01-01\",\n  \"description\": \"ACME GROCERY\",\n  \"amount_cents\": -5234\n}\n```\n\nRules support:\n\n```text\ndescription_contains\ndescription_regex\namount_min_cents\namount_max_cents\nmerchant_equals\nset_category\nset_tags\npriority\n```\n\nHighest priority matching rule wins. Ties are broken by rule order. If no rule matches, category is `uncategorized`.\n\nSummaries must total spending by category and month. Refunds should reduce spending.\n\nInclude a CLI:\n\n```bash\npython -m budgetrules categorize --transactions txns.json --rules rules.json\npython -m budgetrules summarize categorized.json\n```\n\nInclude tests for rule priority, regex matching, refunds, uncategorized transactions, monthly summaries, deterministic order, and malformed rules.\n\n## Contract\n\nThis section pins the parts the prose above leaves implicit. The held-out grader\nchecks BEHAVIOR against this contract; it does not require any particular internal\nfile layout, helper names, or extra keys beyond those pinned here.\n\n### Import path & CLI\n\n- The package is importable as `budgetrules`, and the two functions are exposed from\n  the module `budgetrules.public`:\n\n  ```python\n  from budgetrules.public import categorize, summarize\n  ```\n\n- The CLI is invoked as `python -m budgetrules ...` and MUST emit JSON to stdout:\n\n  ```bash\n  python -m budgetrules categorize --transactions txns.json --rules rules.json\n  python -m budgetrules summarize categorized.json\n  ```\n\n  `categorize` prints the JSON list returned by `categorize(...)`; `summarize` reads\n  a JSON file holding that list and prints the JSON dict returned by `summarize(...)`.\n\n### `categorize(transactions, rules) -> list[dict]`\n\n- Returns a NEW list, same length and SAME ORDER as `transactions` (deterministic;\n  input is never reordered or mutated).\n- Each output element preserves the input transaction's existing fields (`id`,\n  `date`, `description`, `amount_cents`) and ADDS exactly these two fields:\n  - `category` \u2014 a `str`. Set from the winning rule's `set_category`. If no rule\n    matches, it is the literal string `\"uncategorized\"`.\n  - `tags` \u2014 a `list[str]`. Set from the winning rule's `set_tags` (a list of\n    strings). If the winning rule has no `set_tags`, or no rule matches, it is `[]`\n    (empty list, never `None`).\n\n- Rule matching: a rule matches a transaction when ALL of its present conditions\n  hold (conditions absent from the rule are not constraints). Conditions:\n  - `description_contains` \u2014 substring test against the transaction `description`,\n    CASE-INSENSITIVE.\n  - `description_regex` \u2014 `re.search` of the pattern against `description`\n    (case-sensitive unless the pattern itself opts out). A malformed/uncompilable\n    regex does NOT raise: such a rule simply fails to match.\n  - `amount_min_cents` \u2014 matches when `amount_cents >= amount_min_cents`.\n  - `amount_max_cents` \u2014 matches when `amount_cents <= amount_max_cents`.\n  - `merchant_equals` \u2014 exact, case-sensitive equality against the transaction\n    `description` (the merchant string).\n\n- Winner selection: among all matching rules, the one with the highest `priority`\n  wins. `priority` defaults to `0` when absent. Ties (equal priority) are broken by\n  RULE ORDER \u2014 the earliest such rule in `rules` wins.\n\n- Robustness: a malformed rule (not a dict, bad regex, non-string/non-list field\n  values, unknown extra keys) must NEVER raise \u2014 it either fails to match or\n  contributes no constraint, and categorization continues over the remaining rules.\n\n### `summarize(categorized) -> dict`\n\nOperates on the list returned by `categorize`. Returns a dict with exactly these two\ntop-level keys, each a dict whose VALUES are integer cent totals:\n\n- `\"by_category\"` \u2014 maps each `category` string present in the input to the total\n  spending for that category, in cents.\n- `\"by_month\"` \u2014 maps each `\"YYYY-MM\"` month string (the first 7 chars of `date`)\n  to the total spending for that month, in cents.\n\nSpending convention (pin): a transaction's contribution to a total is the amount of\nmoney that LEFT the account, i.e. `-amount_cents` (debits, stored as NEGATIVE\n`amount_cents`, are POSITIVE spending; refunds/credits, stored as POSITIVE\n`amount_cents`, are NEGATIVE spending and therefore REDUCE the relevant totals). All\ntotals are integers in cents. A category/month with a net-zero total still appears\nif at least one transaction contributed to it.\n\n## ASSUMPTIONS (pinned so the grader never grades a guess)\n\n- `set_tags`, when present on the winning rule, replaces tags wholesale (tags are\n  not accumulated across multiple matching rules \u2014 only the winner's tags apply).\n- `description_contains` is case-insensitive; `merchant_equals` is case-sensitive.\n- Spending sign convention is `-amount_cents` (debits negative in the input). This\n  makes \"refunds reduce spending\" hold and keeps per-category/per-month totals as\n  net spending in cents.\n- Month key is `date[:7]` (the `YYYY-MM` prefix of the ISO date string).\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "categorize_basic_match",
        "desc": "a matching rule sets category + tags on the txn"
      },
      {
        "id": "categorize_preserves_order_len",
        "desc": "categorize returns same length & order as input, fields preserved"
      },
      {
        "id": "categorize_uncategorized",
        "desc": "no matching rule -> category 'uncategorized', tags []"
      },
      {
        "id": "tags_type_is_list",
        "desc": "tags is always a list (and [] when the winner sets none)"
      },
      {
        "id": "priority_highest_wins",
        "desc": "highest-priority matching rule wins over a lower one"
      },
      {
        "id": "priority_tie_rule_order",
        "desc": "equal priority is broken by rule order (earliest wins)"
      },
      {
        "id": "priority_default_zero",
        "desc": "absent priority defaults to 0 (a priority>0 rule beats it)"
      },
      {
        "id": "regex_match",
        "desc": "description_regex matches via re.search"
      },
      {
        "id": "amount_range_match",
        "desc": "amount_min_cents / amount_max_cents bound matching"
      },
      {
        "id": "merchant_equals_match",
        "desc": "merchant_equals does exact-equality matching"
      },
      {
        "id": "malformed_rule_no_crash",
        "desc": "a malformed rule (bad regex / non-dict) never raises"
      },
      {
        "id": "summarize_by_category",
        "desc": "summarize totals spending per category"
      },
      {
        "id": "summarize_by_month",
        "desc": "summarize totals spending per YYYY-MM month"
      },
      {
        "id": "summarize_refunds_reduce",
        "desc": "refunds (positive amount_cents) REDUCE spending"
      },
      {
        "id": "no_input_mutation",
        "desc": "categorize does not mutate the input transactions"
      },
      {
        "id": "cli_categorize_json",
        "desc": "`python -m budgetrules categorize` emits JSON"
      },
      {
        "id": "cli_summarize_json",
        "desc": "`python -m budgetrules summarize` emits JSON"
      }
    ],
    "num_checks": 17,
    "has_setup": false
  },
  {
    "slug": "cachelab",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `cachelab`.\n\nBuild an in-memory cache simulator with TTLs, stale-while-revalidate behavior, and per-key stampede protection. Use only the Python standard library.\n\nExpose:\n\n```python\nclass Cache:\n    def __init__(self, clock=None): ...\n    def get(self, key: str, loader, ttl_seconds: int, stale_seconds: int = 0): ...\n    def invalidate(self, key: str) -> None: ...\n    def stats(self) -> dict: ...\n```\n\n`loader` is a callable used to compute the value on cache miss. If many threads request the same expired key concurrently, only one loader call should run for that key. Other threads should wait or receive a stale value when allowed by `stale_seconds`.\n\nDifferent keys must not block each other.\n\nProvide a fake clock for deterministic tests.\n\nInclude tests for cache hits, misses, TTL expiration, stale values, per-key locking, concurrent requests, invalidation, loader exceptions, and statistics.\n\nInclude a small CLI simulator:\n\n```bash\npython -m cachelab simulate scenario.json\n```\n\nThe simulator should print JSON stats.\n\n## Contract\n\n- Expose `Cache` from `cachelab.public` (a `python -m cachelab simulate` CLI is also required).\n- `Cache(clock=None)`: when provided, `clock` is a zero-argument callable returning the current time as a float in seconds; use it for all TTL/stale timing so tests can drive time deterministically.\n- `stats()` returns a `dict` of integer counters reflecting cache activity (which counters you track is your choice).\n- On a cold or expired key, exactly one `loader` call runs even under many concurrent `get`s for that key; a loader that raises must not cache a value (the next `get` re-runs the loader).\n- The CLI `simulate` prints a JSON object of stats.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "hit",
        "desc": "second get within TTL is a cache hit (loader runs once)"
      },
      {
        "id": "miss",
        "desc": "first get on a cold key runs the loader (miss)"
      },
      {
        "id": "ttl_expiry",
        "desc": "value expires after ttl_seconds and reloads"
      },
      {
        "id": "stale",
        "desc": "stale-while-revalidate serves the old value during refresh"
      },
      {
        "id": "per_key_single_flight",
        "desc": "exactly one loader runs for a hot key under N concurrent gets"
      },
      {
        "id": "independent_keys",
        "desc": "different keys don't block each other; each loads independently"
      },
      {
        "id": "invalidate",
        "desc": "invalidate() forces the next get to reload"
      },
      {
        "id": "loader_exception",
        "desc": "a raising loader propagates and does not cache a value"
      },
      {
        "id": "stats",
        "desc": "stats() reports activity; hits and misses move independently"
      },
      {
        "id": "cli_simulate_json",
        "desc": "`python -m cachelab simulate scenario.json` prints JSON stats"
      }
    ],
    "num_checks": 10,
    "has_setup": false
  },
  {
    "slug": "cachelayer",
    "type": "ambiguous-spec",
    "brief": "We have a handful of functions scattered across our code that are genuinely\nexpensive to call \u2014 some hit the network, some chew through a big computation \u2014\nand we keep calling them with the same inputs over and over. I'd like a small\nPython library, `cachelayer`, that lets us remember the result of a call so the\nnext call with the same inputs comes back fast instead of doing the work again.\n\nThe basic shape is: point it at one of these expensive lookups, and from then on\na repeat call with the same arguments returns the saved result. I want it to feel\nnatural to drop into existing code without rewriting how those functions are\ncalled, and I want to be able to trust what's in there \u2014 a cached answer should be\none I'd actually be comfortable handing back, not something stale I've quietly\nforgotten about.\n\nHow you let people attach caching to a function, how you decide two calls count as\n\"the same,\" and how you keep the cache from growing without bound are the\ninteresting parts, and I'm leaving them to you. Use your judgment; I'd rather see\nthe approach you'd actually defend than a pile of knobs. It should import as\n`cachelayer` and be pleasant to use from our own code.\n\nKeep it reasonably small and lean on the standard library where you can. Some\ntests around the behavior that matters \u2014 that hits come back without redoing the\nwork, and that the cache does the right thing as it fills up \u2014 would give me\nconfidence it works the way you think it does.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "cachetags",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `cachetags`: an in-memory cache.\nThe package is already written, imports cleanly, and its core operations work:\n`set(key, value, now)`, `get(key, now, default=None)`, and `delete(key)`.\n\nTime is INJECTED, never read from a real clock: every read and write takes\n`now` (a number \u2014 the caller's current time) as an explicit argument. The base\ncache does not actually use `now` yet (entries never expire), but it is already\npart of the signature. This keeps the cache fully deterministic and testable.\n\n## Task\n\nAdd two features on top of the existing cache, WITHOUT breaking plain\n`get` / `set`:\n\n(a) **Per-entry TTL.** `set(key, value, now, ttl=...)` makes the entry expire\n    `ttl` time-units after it was set. A `get` at or after the expiry instant is\n    a MISS.\n\n(b) **Tag-based invalidation.** `set(key, value, now, tags=[...])` attaches tags\n    to the entry. `invalidate_tag(tag, now)` drops every entry carrying that\n    tag.\n\n## Semantics (read carefully \u2014 this is the whole task)\n\n- TTL is RELATIVE to the set time and resolved against the injected `now`: an\n  entry set with `ttl=T` at time `t0` expires at `t0 + T`. The boundary is\n  HALF-OPEN \u2014 the entry is a HIT for every `now` in the interval `[t0, t0+T)`\n  and a MISS at and after `t0 + T`. So `ttl=10` set at `now=0` is a hit at\n  `now=9` and a miss at `now=10`.\n\n- `ttl=None` (the default) means the entry NEVER expires \u2014 plain `set` with no\n  `ttl` keeps its old behavior.\n\n- A `ttl` of 0 (or negative) means the entry is already expired the instant it\n  is set: it is never served.\n\n- `invalidate_tag(tag, now)` removes every entry that currently carries `tag`\n  and returns the COUNT of entries it dropped.\n\n- SUBTLE \u2014 an EXPIRED entry must also lose its tag membership. Once an entry's\n  TTL has elapsed it is gone in every sense: it must NOT be returned by `get`,\n  and `invalidate_tag` on one of its (former) tags must NOT count it (it is a\n  no-op for that entry \u2014 there is nothing live to invalidate). An expired entry\n  must never resurface.\n\n- SUBTLE \u2014 re-`set`ting an existing key REPLACES its tags wholesale. The key\n  loses its OLD tags and carries only the tags given on the latest `set` (or no\n  tags, if `tags` is omitted). A later `invalidate_tag` with an OLD tag must not\n  touch the re-set entry.\n\n- Plain `get` / `set` / `delete` with no `ttl` and no `tags` must behave exactly\n  as they do today.\n\n## Example\n\n    c = Cache()\n\n    c.set(\"a\", 1, now=0, ttl=10, tags=[\"red\"])\n    c.get(\"a\", now=9)        # -> 1     (still within TTL)\n    c.get(\"a\", now=10)       # -> None  (TTL elapsed: a miss)\n\n    c.set(\"b\", 2, now=0, tags=[\"red\", \"blue\"])\n    c.invalidate_tag(\"red\", now=0)   # -> 1  (drops \"b\")\n    c.get(\"b\", now=0)        # -> None\n\n    # expired entry loses its tag membership:\n    c.set(\"c\", 3, now=0, ttl=5, tags=[\"green\"])\n    c.invalidate_tag(\"green\", now=10)  # -> 0  (\"c\" already expired; nothing to drop)\n    c.get(\"c\", now=10)       # -> None\n\n    # re-set replaces tags:\n    c.set(\"d\", 4, now=0, tags=[\"old\"])\n    c.set(\"d\", 5, now=0, tags=[\"new\"])   # \"d\" no longer carries \"old\"\n    c.invalidate_tag(\"old\", now=0)   # -> 0  (does not touch \"d\")\n    c.get(\"d\", now=0)        # -> 5\n\n## Contract\n\n- Package name: `cachetags`. The grader imports `cachetags.public` (falling back\n  to `cachetags`); keep both import paths working.\n- Public class `Cache` with methods:\n    * `set(key, value, now, ttl=None, tags=None)` -> None\n    * `get(key, now, default=None)` -> value or default\n    * `delete(key)` -> bool (True iff the key was present)\n    * `invalidate_tag(tag, now)` -> int (number of live entries dropped)\n- `now`, `ttl`, and tag values are plain numbers / hashables; tags is any\n  iterable of hashables. Time is whatever numeric type the caller passes as\n  `now` \u2014 do not read a real clock.\n- Standard library only. No persistence, no threading requirement.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "set_get_basic",
        "desc": "a value set with no ttl is returned later"
      },
      {
        "id": "ttl_hit_before",
        "desc": "an entry is a HIT one tick before its TTL elapses"
      },
      {
        "id": "ttl_miss_exact",
        "desc": "an entry is a MISS at the exact instant its TTL elapses"
      },
      {
        "id": "ttl_miss_after",
        "desc": "an entry is a MISS after its TTL has elapsed"
      },
      {
        "id": "ttl_none_never_expires",
        "desc": "ttl=None entry never expires"
      },
      {
        "id": "ttl_zero_already_expired",
        "desc": "ttl=0 entry is already expired the instant it is set"
      },
      {
        "id": "ttl_negative_already_expired",
        "desc": "negative-ttl entry is already expired"
      },
      {
        "id": "invalidate_single_tag",
        "desc": "invalidate_tag drops a live entry carrying that tag"
      },
      {
        "id": "invalidate_returns_count",
        "desc": "invalidate_tag returns the number of live entries dropped"
      },
      {
        "id": "invalidate_other_tag_untouched",
        "desc": "invalidate_tag leaves entries without that tag alone"
      },
      {
        "id": "invalidate_multiple_with_tag",
        "desc": "invalidate_tag drops every live entry carrying the tag"
      },
      {
        "id": "expired_loses_tag_membership",
        "desc": "invalidate_tag of a former tag of an EXPIRED entry counts 0"
      },
      {
        "id": "expired_not_resurfaced_after_invalidate",
        "desc": "an expired entry never resurfaces via the tag index"
      },
      {
        "id": "reset_replaces_tags",
        "desc": "re-set replaces tags: an OLD tag no longer invalidates the entry"
      },
      {
        "id": "reset_keeps_new_tag",
        "desc": "re-set keeps the NEW tag: it still invalidates the entry"
      },
      {
        "id": "invalidate_unknown_tag_zero",
        "desc": "invalidate_tag on an unknown tag returns 0 and changes nothing"
      },
      {
        "id": "regression_get_set_overwrite",
        "desc": "plain get/set/overwrite still work with no ttl/tags"
      },
      {
        "id": "regression_delete_return",
        "desc": "delete reports presence (True/False) with no ttl/tags"
      },
      {
        "id": "regression_get_default",
        "desc": "get returns the supplied default on a miss"
      }
    ],
    "num_checks": 19,
    "has_setup": true
  },
  {
    "slug": "calceval",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 calceval: the test suite is failing\n\nYou have an existing Python package `calceval`, a tiny infix arithmetic\nevaluator. It ships with a unittest suite in `calceval/test_calceval.py`, and\nright now several of those tests FAIL. Fix the code so that ALL the tests pass.\nDo not rewrite the package from scratch and do not change its public API. Do NOT\nuse `eval` / `exec`; keep the hand-written parser.\n\n## Symptom\n\n`evaluate(expr)` parses an infix arithmetic expression and returns its value as a\nfloat. Simple precedence already works, but several associativity / binding cases\ncome out wrong:\n\n    from calceval.public import evaluate\n\n    # subtraction parses right-associative instead of left:\n    evaluate(\"10-2-3\")\n    #   EXPECTED 5.0     ((10-2)-3)\n    #   ACTUAL   11.0    (10-(2-3))\n\n    # division has the same right-associative defect:\n    evaluate(\"100/10/2\")\n    #   EXPECTED 5.0     ((100/10)/2)\n    #   ACTUAL   20.0    (100/(10/2))\n\n    # '^' parses left-associative instead of right:\n    evaluate(\"2^3^2\")\n    #   EXPECTED 512.0   (2^(3^2))\n    #   ACTUAL   64.0    ((2^3)^2)\n\n    # unary minus binds too tightly \u2014 tighter than '^' instead of looser:\n    evaluate(\"-2^2\")\n    #   EXPECTED -4.0    (-(2^2))\n    #   ACTUAL   4.0     ((-2)^2)\n\nThese defects interact: `-2^2^2` exercises the unary binding AND the exponent\nassociativity at once, and expressions like `10-2-3^1^2*2` touch all of them.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `calceval` package:\n\n    python -m unittest calceval.test_calceval\n\n## Contract (must hold after your fix)\n\n* Package name stays `calceval`; import path `calceval` / `calceval.public`.\n* Keep the public API exactly: `evaluate(expr: str) -> float` and the `CalcError`\n  exception. Do not rename them. The result is ALWAYS a `float`.\n* Supported tokens: integer and decimal numbers (`3`, `3.5`, `.5`, `10.`), the\n  binary operators `+ - * / ^`, parentheses `( )`, and a prefix (unary) `-`\n  (a prefix `+` is tolerated as a no-op). Whitespace is insignificant.\n* PRECEDENCE, from loosest-binding to tightest-binding:\n    1. `+` and `-`  (binary)  \u2014 LEFT-associative\n    2. `*` and `/`            \u2014 LEFT-associative\n    3. unary `-`  (prefix negation) \u2014 binds LOOSER than `^`\n    4. `^`  (exponent)        \u2014 RIGHT-associative, the tightest binding\n  Parentheses override all of the above.\n* ASSOCIATIVITY in detail:\n    - `a-b-c` is `(a-b)-c` and `a/b/c` is `(a/b)/c` (LEFT). So `10-2-3 == 5` and\n      `100/10/2 == 5`, never `11` / `20`.\n    - `a^b^c` is `a^(b^c)` (RIGHT). So `2^3^2 == 512`, never `64`.\n* UNARY-vs-EXPONENT binding: prefix `-` binds LOOSER than `^`, so `-2^2` is\n  `-(2^2) == -4`, and `-2^4 == -16`. To negate the base you must parenthesize:\n  `(-2)^2 == 4`. A `^` right operand may itself be unary, so `2^-1 == 0.5`.\n* MALFORMED input raises `CalcError`: an empty or all-whitespace string, an\n  unbalanced parenthesis, a dangling/stray operator (`\"2+\"`, `\"*3\"`), an unknown\n  character, or division by zero. Do NOT raise a bare `ValueError`/`ZeroDivisionError`\n  \u2014 wrap them as `CalcError` (which may subclass `ValueError`).\n* Do NOT use `eval` / `exec`. Standard library only.\n\nExample:\n\n    evaluate(\"-2^2^2\")    #  -> -16.0    (-(2^(2^2)) == -(2^4))\n    evaluate(\"10-2-3^1^2*2\")  #  -> 2.0  ((10-2) - ((3^(1^2))*2) == 8 - 6)\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "basic_mul_over_add",
        "desc": "* binds tighter than + (2+3*4 == 14)"
      },
      {
        "id": "basic_add_mul_chain",
        "desc": "mixed +/* precedence (2*3+4*5 == 26)"
      },
      {
        "id": "basic_sub_mul",
        "desc": "* binds tighter than - (10-2*3 == 4)"
      },
      {
        "id": "basic_parens",
        "desc": "parentheses override precedence ((2+3)*4 == 20)"
      },
      {
        "id": "basic_pow_over_mul",
        "desc": "^ binds tighter than * (2*3^2 == 18)"
      },
      {
        "id": "basic_single_number",
        "desc": "a lone number evaluates to itself (42 -> 42.0)"
      },
      {
        "id": "basic_decimal",
        "desc": "decimals parse and compute (3.5*2 == 7.0)"
      },
      {
        "id": "basic_leading_dot",
        "desc": "leading-dot decimals parse (.5+.5 == 1.0)"
      },
      {
        "id": "left_assoc_sub",
        "desc": "subtraction is left-associative (10-2-3 == 5)"
      },
      {
        "id": "left_assoc_sub_long",
        "desc": "long subtraction chain (2-3-4-5 == -10)"
      },
      {
        "id": "left_assoc_div",
        "desc": "division is left-associative (100/10/2 == 5)"
      },
      {
        "id": "left_assoc_div_long",
        "desc": "long division chain (64/4/2/2 == 4)"
      },
      {
        "id": "left_assoc_mixed",
        "desc": "mixed +/- left to right (1+2-3+4 == 4)"
      },
      {
        "id": "left_assoc_sub_then_mul",
        "desc": "left-assoc minus around a product (20-2-3*2 == 12)"
      },
      {
        "id": "right_assoc_pow",
        "desc": "exponent is right-associative (2^3^2 == 512)"
      },
      {
        "id": "right_assoc_pow2",
        "desc": "exponent right-assoc again (2^2^3 == 256)"
      },
      {
        "id": "right_assoc_pow_triple",
        "desc": "triple exponent right-assoc (2^2^2^2 == 65536)"
      },
      {
        "id": "right_assoc_pow_zero",
        "desc": "right-assoc with a zero exponent (4^3^0 == 4)"
      },
      {
        "id": "unary_pow_binding",
        "desc": "unary minus binds looser than ^ (-2^2 == -4)"
      },
      {
        "id": "unary_pow_even",
        "desc": "unary over even power (-2^4 == -16)"
      },
      {
        "id": "paren_unary_pow",
        "desc": "parens flip the binding ((-2)^2 == 4)"
      },
      {
        "id": "unary_simple",
        "desc": "plain unary minus (-3+5 == 2)"
      },
      {
        "id": "unary_group",
        "desc": "unary minus over a group (-(2+3) == -5)"
      },
      {
        "id": "pow_negative_exp",
        "desc": "negative exponent via unary (2^-1 == 0.5)"
      },
      {
        "id": "interaction_unary_right_pow",
        "desc": "unary + right-assoc ^ (-2^2^2 == -16)"
      },
      {
        "id": "interaction_sub_pow",
        "desc": "left-assoc minus around right-assoc power (1-2^3^0 == -1)"
      },
      {
        "id": "interaction_full",
        "desc": "all rules at once (10-2-3^1^2*2 == 2)"
      },
      {
        "id": "err_empty",
        "desc": "empty string raises CalcError"
      },
      {
        "id": "err_blank",
        "desc": "all-whitespace raises CalcError"
      },
      {
        "id": "err_trailing_op",
        "desc": "a trailing operator raises CalcError"
      },
      {
        "id": "err_unbalanced",
        "desc": "unbalanced parens raise CalcError"
      },
      {
        "id": "err_bad_char",
        "desc": "an unknown character raises CalcError"
      },
      {
        "id": "err_div_zero",
        "desc": "division by zero raises CalcError"
      }
    ],
    "num_checks": 33,
    "has_setup": true
  },
  {
    "slug": "cellsim",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `cellsim`.\n\nBuild a small spreadsheet calculation engine. Use only the Python standard library.\n\nExpose these functions from `cellsim.public`:\n\n```python\ndef load_sheet(path: str) -> dict: ...\ndef evaluate_sheet(sheet: dict) -> dict: ...\ndef get_cell_value(sheet: dict, cell: str) -> object: ...\ndef explain_cell(sheet: dict, cell: str) -> dict: ...\n```\n\nA sheet is JSON:\n\n```json\n{\n  \"cells\": {\n    \"A1\": 10,\n    \"A2\": 20,\n    \"A3\": \"=A1+A2\",\n    \"B1\": \"=SUM(A1:A3)\",\n    \"B2\": \"=IF(B1>40,\\\"high\\\",\\\"low\\\")\"\n  }\n}\n```\n\nSupport: cell references; integer and decimal numbers; strings; + - * /; parentheses; SUM(range); MIN(range); MAX(range); AVG(range); IF(condition, true_value, false_value); comparison operators = != < <= > >=.\n\nDetect and report circular references. Missing cells should evaluate as `0` only inside numeric formulas, but should be reported as missing when directly requested. Ranges must work for rectangular regions such as `A1:C3`. Formula evaluation must be deterministic and must not use Python `eval`.\n\nInclude a CLI:\n\n```bash\npython -m cellsim eval sheet.json\npython -m cellsim cell sheet.json B2\npython -m cellsim explain sheet.json B2\n```\n\nInclude tests for arithmetic precedence, ranges, strings, nested formulas, cycle detection, missing cells, and error propagation.\n\n## Contract\n\nThis section PINS the exact shapes the grading oracle relies on. It does not add\nnew behavior beyond the spec above; it only removes ambiguity so that a correct\nimplementation is not unfairly failed for choosing a different key name or type.\n\n### Import path and CLI\n\n- The public API is importable as `cellsim.public` (i.e. a package `cellsim`\n  containing `public.py`). The four functions above are module-level callables.\n- A CLI is runnable as `python -m cellsim` (i.e. the package has a `__main__.py`).\n  All CLI output is a single JSON document printed to stdout.\n\n### Value types\n\n- A cell value is one of: an `int`, a `float`, a `str`, or a `bool`.\n- Integer-valued numbers SHOULD be returned as `int` (e.g. `10`, `30`), and\n  decimal numbers as `float` (e.g. `2.5`). `10 / 4` is `2.5`. The oracle compares\n  numbers by numeric value with a small tolerance, so `30` and `30.0` are both\n  accepted where a number is expected; bools are NOT accepted where a number is.\n- Comparison operators (`=`, `!=`, `<`, `<=`, `>`, `>=`) and `IF` conditions\n  produce/consume a boolean. `IF(cond, a, b)` returns `a` when `cond` is truthy,\n  else `b`.\n\n### `load_sheet(path) -> dict`\n\n- Returns the parsed sheet dict. It has a `\"cells\"` key mapping cell names\n  (e.g. `\"A1\"`) to raw values (number, string literal, or a `\"=\"`-prefixed\n  formula string). `load_sheet` does NOT evaluate; it only parses JSON.\n\n### `evaluate_sheet(sheet) -> dict`\n\n- Returns a dict with a `\"cells\"` key: a mapping from every cell name present in\n  the input to its evaluated value (using the Value types above).\n- A cell that cannot be evaluated because it participates in a circular\n  reference is reported via a top-level `\"errors\"` key: a mapping from cell name\n  to an error descriptor. An error descriptor is a dict that contains a `\"type\"`\n  key whose value is the string `\"circular\"` for cycles. (Other error types may\n  use other `\"type\"` strings.) A cell in `\"errors\"` need not also appear with a\n  numeric value in `\"cells\"`.\n- When the sheet has no errors, `\"errors\"` is either absent or an empty mapping.\n- Evaluation is deterministic: repeated calls on the same sheet return equal\n  results.\n\n### `get_cell_value(sheet, cell) -> object`\n\n- Returns the evaluated value of `cell` (a Value type) when the cell exists.\n- When `cell` is NOT present in the sheet, this is a direct request for a missing\n  cell and MUST be reported as missing \u2014 NOT silently coerced to `0`. \"Reported\n  as missing\" means EITHER raising `KeyError` OR returning `None`. (The `0`\n  coercion for missing cells applies ONLY when a missing cell is referenced from\n  inside another cell's numeric formula, never to a direct `get_cell_value`.)\n- When `cell` participates in a circular reference, this raises an exception OR\n  returns an error descriptor dict carrying `\"type\": \"circular\"`.\n\n### `explain_cell(sheet, cell) -> dict`\n\n- Returns a dict describing how `cell` was computed. It MUST contain:\n  - `\"cell\"`: the cell name (str), echoing the requested cell.\n  - `\"value\"`: the evaluated value (a Value type), OR `None` / omitted when the\n    cell is missing or errored.\n  - `\"references\"`: a list (possibly empty) of the cell names this cell directly\n    depends on. For a literal (non-formula) cell this is `[]`. For `=A1+A2` it is\n    `[\"A1\",\"A2\"]` (order not significant; the oracle compares as a set). A range\n    like `A1:A3` contributes its expanded member cells `[\"A1\",\"A2\",\"A3\"]`.\n- For a cell in a circular reference, `explain_cell` either includes\n  `\"type\": \"circular\"` somewhere in the returned dict, or sets `\"value\"` to\n  `None`; it MUST NOT raise.\n\n### CLI\n\n- `python -m cellsim eval sheet.json` prints the JSON of `evaluate_sheet`\n  (a JSON object; the oracle only requires that stdout parses as JSON).\n- `python -m cellsim cell sheet.json B2` prints a JSON document for the single\n  cell value.\n- `python -m cellsim explain sheet.json B2` prints the JSON of `explain_cell`.\n\n### Ranges and operators\n\n- `SUM`, `MIN`, `MAX`, `AVG` take a single range argument like `A1:C3` and\n  operate over the rectangular block of cells (columns A..C, rows 1..3).\n- Inside numeric formulas, a referenced cell that is absent contributes `0`.\n- Strings are written with double quotes inside formulas: `\"high\"`.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "arith_precedence",
        "desc": "arithmetic precedence: =2+3*4 -> 14, =(2+3)*4 -> 20"
      },
      {
        "id": "cell_refs_decimal",
        "desc": "cell references resolve; decimal division yields a float"
      },
      {
        "id": "sub_div",
        "desc": "subtraction and division over cell references"
      },
      {
        "id": "sum_range",
        "desc": "SUM over a column range A1:A3"
      },
      {
        "id": "min_max_avg",
        "desc": "MIN/MAX/AVG over a range"
      },
      {
        "id": "rect_range",
        "desc": "ranges cover rectangular regions (A1:C2)"
      },
      {
        "id": "strings",
        "desc": "string literals and string-valued references round-trip"
      },
      {
        "id": "if_comparison",
        "desc": "IF with > comparison selects the right branch"
      },
      {
        "id": "comparison_ops",
        "desc": "comparison operators =, !=, <=, >= each work"
      },
      {
        "id": "nested_formulas",
        "desc": "nested/transitive formula chains resolve"
      },
      {
        "id": "missing_in_formula_zero",
        "desc": "a missing cell inside a numeric formula is 0"
      },
      {
        "id": "direct_missing_reported",
        "desc": "a directly requested missing cell is reported, not 0"
      },
      {
        "id": "get_cell_present",
        "desc": "get_cell_value returns an existing cell's value"
      },
      {
        "id": "cycle_evaluate",
        "desc": "evaluate_sheet detects & reports a circular reference (no crash)"
      },
      {
        "id": "cycle_get_cell",
        "desc": "get_cell_value reports a circular reference (raise or descriptor)"
      },
      {
        "id": "explain_refs",
        "desc": "explain_cell lists a cell's direct references"
      },
      {
        "id": "explain_range_expands",
        "desc": "explain_cell expands a range into member cells"
      },
      {
        "id": "explain_value",
        "desc": "explain_cell returns the cell name and computed value"
      },
      {
        "id": "explain_cycle_no_raise",
        "desc": "explain_cell on a cyclic cell does not raise"
      },
      {
        "id": "determinism",
        "desc": "evaluate_sheet is deterministic across repeated runs"
      },
      {
        "id": "no_python_eval",
        "desc": "formulas are parsed, not run through Python eval()"
      },
      {
        "id": "cli_eval_json",
        "desc": "`python -m cellsim eval` emits JSON"
      },
      {
        "id": "cli_cell_value",
        "desc": "`python -m cellsim cell` emits JSON carrying the value"
      },
      {
        "id": "cli_explain_json",
        "desc": "`python -m cellsim explain` emits JSON"
      }
    ],
    "num_checks": 24,
    "has_setup": false
  },
  {
    "slug": "condschema",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `condschema`: a data validator.\nThe package is already written, imports cleanly, and works for the cases it\nsupports. Its single public entry point is:\n\n    def validate(data, schema) -> list[error]: ...\n\nIt walks `data` against `schema` and returns a LIST OF ERROR DICTS. An EMPTY\nlist means the data is valid; a non-empty list means it failed one or more\nrules.\n\n## What works today\n\nThe validator handles a FLAT schema: a mapping of `field name -> field spec`.\nEach spec may declare:\n\n  - `type`     \u2014 one of \"string\" / \"number\" / \"integer\" / \"bool\" / \"object\" /\n                 \"list\". (Note: a bool is NOT a number/integer, and a float is\n                 NOT an integer; \"number\" accepts ints and floats.)\n  - `required` \u2014 if True, the field must be present.\n\nEach error is a dict::\n\n    {\"path\": \"<dotted path>\", \"code\": \"<rule that failed>\", \"message\": \"...\"}\n\n`path` is a dotted location into the data; a top-level field's path is just its\nname. `code` is one of \"required\" (a required field is absent) or \"type\" (a\npresent field has the wrong type). The shipped validator reports ALL errors it\nfinds, in a STABLE order: schema-declared field order.\n\nExamples of current behavior::\n\n    validate({\"name\": \"Ada\"}, {\"name\": {\"type\": \"string\", \"required\": True}})\n        -> []                                            # valid\n    validate({}, {\"name\": {\"type\": \"string\", \"required\": True}})\n        -> [{\"path\": \"name\", \"code\": \"required\", ...}]   # missing\n    validate({\"age\": \"x\"}, {\"age\": {\"type\": \"integer\"}})\n        -> [{\"path\": \"age\", \"code\": \"type\", ...}]        # wrong type\n\n## The capability to ADD\n\nExtend the validator with NESTED schemas and CONDITIONAL requirements. Flat\nvalidation must keep working exactly as before.\n\n### 1. Nested objects\n\nA field spec of `type` \"object\" may carry a `fields` key: a nested schema\n(same shape \u2014 field name -> spec). When the field is present AND is a dict,\nvalidate it RECURSIVELY against `fields`. Errors from inside carry a DOTTED\npath built from the enclosing field name and the inner path::\n\n    schema = {\"address\": {\"type\": \"object\", \"fields\": {\n                  \"zip\": {\"type\": \"string\", \"required\": True}}}}\n    validate({\"address\": {}}, schema)\n        -> [{\"path\": \"address.zip\", \"code\": \"required\", ...}]\n\nIf the field is present but is NOT a dict, report a single \"type\" error at the\nfield's own path and do NOT recurse into it.\n\n### 2. Lists of items\n\nA field spec of `type` \"list\" may carry an `items` key: a single field spec\napplied to EVERY element of the list. When the field is present AND is a list,\nvalidate each element against `items`. An element's path is the field name,\nthen the element's INDEX, then any inner path::\n\n    schema = {\"items\": {\"type\": \"list\", \"items\": {\n                  \"type\": \"object\", \"fields\": {\n                      \"sku\": {\"type\": \"string\", \"required\": True}}}}}\n    validate({\"items\": [{\"sku\": \"A1\"}, {}, {\"sku\": 5}]}, schema)\n        -> [{\"path\": \"items.1.sku\", \"code\": \"required\", ...},\n            {\"path\": \"items.2.sku\", \"code\": \"type\", ...}]\n\nElements are validated in index order. If the field is present but is NOT a\nlist, report a single \"type\" error at the field's own path and do NOT recurse.\n\n### 3. Conditional requirements\n\nA field spec may carry `requiredIf`: a `[sibling_field, value]` pair. The field\nis required ONLY when, in the SAME object, the named sibling field is present\nAND its value EQUALS `value`. Otherwise the field is optional.\n\n    schema = {\"country\": {\"type\": \"string\"},\n              \"state\":   {\"type\": \"string\", \"requiredIf\": [\"country\", \"US\"]}}\n    validate({\"country\": \"US\"}, schema)\n        -> [{\"path\": \"state\", \"code\": \"required\", ...}]   # state needed\n    validate({\"country\": \"CA\"}, schema)\n        -> []                                             # state optional\n    validate({}, schema)\n        -> []                                             # sibling absent -> optional\n\nSubtleties (these are the whole task):\n\n  - `requiredIf` is satisfied only by an EXACT match of the sibling's value.\n    Do NOT conflate booleans with numbers: a sibling holding `True` does not\n    equal `1`, and `1` does not equal `True`.\n  - The sibling is looked up in the SAME object that owns the conditional\n    field (the nested object for a nested spec), never globally.\n  - A field that is required (by `required: True` OR by a satisfied\n    `requiredIf`) and is ABSENT yields exactly ONE \"required\" error and no\n    \"type\" error.\n  - A field that is PRESENT is type-checked regardless of how its requirement\n    was decided (plain or conditional). Presence and type are separate rules.\n  - Report ALL errors, never first-only. The order is a stable pre-order walk:\n    fields in schema-declared order; within a list, elements by ascending\n    index; recurse into a field's nested errors before moving to the next\n    sibling field.\n\n## Contract\n\n- Package name: `condschema`. The grader imports `condschema.public` (falling\n  back to `condschema`); keep both import paths working.\n- Public function `validate(data, schema) -> list[dict]`. Empty list == valid.\n  Each error dict has at least the keys `path` (dotted string) and `code`\n  (one of \"required\" / \"type\").\n- A field present in `data` but absent from `schema` is unconstrained (ignored).\n- A `required`/`requiredIf` field that is absent is reported once as \"required\"\n  and is not type-checked.\n- Standard library only. No third-party validation libraries.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "nested_object_dotted_path",
        "desc": "a missing field in a nested object reports a DOTTED path"
      },
      {
        "id": "nested_object_valid",
        "desc": "a satisfied nested object yields no errors"
      },
      {
        "id": "nested_object_type_no_recurse",
        "desc": "a non-dict where an object is expected: one type error, no recursion"
      },
      {
        "id": "nested_object_inner_type",
        "desc": "a wrong-typed value inside a nested object reports at the dotted path"
      },
      {
        "id": "deep_nesting_path",
        "desc": "two levels of object nesting build the full dotted path"
      },
      {
        "id": "list_item_index_path",
        "desc": "a bad element reports field.<index>.<inner> as its path"
      },
      {
        "id": "list_all_valid",
        "desc": "a list whose every element fits yields no errors"
      },
      {
        "id": "list_type_no_recurse",
        "desc": "a non-list where a list is expected: one type error, no recursion"
      },
      {
        "id": "list_scalar_items",
        "desc": "an items spec of a scalar type checks each element by index"
      },
      {
        "id": "list_order_by_index",
        "desc": "multiple bad elements are reported in ascending index order"
      },
      {
        "id": "requiredif_trigger_present",
        "desc": "requiredIf fires when the sibling equals the trigger value"
      },
      {
        "id": "requiredif_other_value",
        "desc": "requiredIf does NOT fire when the sibling has a different value"
      },
      {
        "id": "requiredif_sibling_absent",
        "desc": "requiredIf does NOT fire when the sibling is absent"
      },
      {
        "id": "requiredif_present_ok",
        "desc": "a satisfied requiredIf with the field present is valid"
      },
      {
        "id": "requiredif_bool_not_number",
        "desc": "requiredIf does not conflate True with 1 (exact match)"
      },
      {
        "id": "requiredif_present_is_type_checked",
        "desc": "a present conditional field is still type-checked"
      },
      {
        "id": "required_absent_no_type_error",
        "desc": "an absent required field gives ONE required error, no type error"
      },
      {
        "id": "all_errors_reported",
        "desc": "every violation is reported, not just the first"
      },
      {
        "id": "stable_pre_order",
        "desc": "errors come in schema order then ascending list index"
      },
      {
        "id": "regression_flat_valid",
        "desc": "a valid flat instance yields an empty list"
      },
      {
        "id": "regression_flat_required_missing",
        "desc": "a missing flat required field errors at its bare name"
      },
      {
        "id": "regression_flat_type_mismatch",
        "desc": "a wrong-typed flat field errors with code 'type'"
      },
      {
        "id": "regression_number_accepts_int",
        "desc": "type 'number' accepts an integer; 'integer' rejects a float"
      },
      {
        "id": "regression_bool_not_integer",
        "desc": "a bool does not satisfy type 'integer'"
      }
    ],
    "num_checks": 24,
    "has_setup": true
  },
  {
    "slug": "confstack",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `confstack`.\n\nBuild a configuration loader with strict precedence. Use only the Python standard library.\n\nExpose:\n\n```python\ndef load_config(defaults: dict, config_file: str | None, env: dict, cli_args: list[str]) -> dict: ...\n```\n\nPrecedence order:\n\n```text\nCLI flags > environment variables > config file > defaults\n```\n\nConfig files are JSON. Environment variables use prefix `APP_`. CLI flags use `--key value`, `--nested.key value`, and booleans like `--feature-enabled` or `--no-feature-enabled`.\n\nInfer booleans, integers, and strings. Support nested keys with dot notation.\n\nInclude a CLI:\n\n```bash\npython -m confstack show --defaults defaults.json --config app.json -- --port 9000 --no-debug\n```\n\nInclude tests for precedence, nested keys, boolean false overriding true, missing config file, unknown flags, type inference, and deterministic output.\n\n## Contract\n\nThis section pins the conventions the grader relies on. A correct implementation\nMUST satisfy everything below. Where the SPEC above leaves a convention open, the\nchoice is pinned here so a defensible implementation is not failed on a guess.\n\n### Import path and CLI\n- The public API is importable as `confstack.public` and exposes the function\n  `load_config(defaults, config_file, env, cli_args)` with the signature above.\n- The CLI is invokable as `python -m confstack` (i.e. the package has a\n  `__main__` module). The `show` subcommand prints the merged config and exits 0.\n\n### Return value of `load_config`\n- Returns the merged configuration as a plain nested `dict`.\n- Dot-notation keys are EXPANDED into nested dicts in the returned value. A key\n  written `a.b.c` (from any source \u2014 config dot-key, env, or CLI) becomes\n  `{\"a\": {\"b\": {\"c\": <value>}}}` in the result. The literal dotted string is NOT\n  retained as a flat top-level key.\n- Output is deterministic: calling `load_config` twice with equal inputs returns\n  equal dicts, and the CLI's serialized output is byte-for-byte stable across runs\n  for equal inputs.\n\n### Precedence (strict, highest wins)\n```text\nCLI flags > environment variables > config file > defaults\n```\n- Sources are merged so that, for any given leaf key, the value from the\n  highest-precedence source that defines it wins.\n- Merging is RECURSIVE over nested dicts (a \"deep merge\"): a higher-precedence\n  source overriding `a.b` does NOT discard a lower-precedence `a.c`; both survive\n  under `a`. Only the overlapping leaf is overridden.\n- Boolean `false` from a higher-precedence source DOES override boolean `true`\n  from a lower-precedence source (and vice versa). Presence, not truthiness,\n  decides an override.\n\n### Defaults\n- `defaults` is a Python dict supplied by the caller. It may itself contain nested\n  dicts and/or dot-notation keys; dot-notation keys in `defaults` are expanded the\n  same way as every other source.\n\n### Config file\n- `config_file` is a path to a JSON object, or `None`.\n- If `config_file` is `None`, the config-file layer contributes nothing.\n- A missing config-file path (file does not exist) is NOT a hard error in\n  `load_config`: the config-file layer simply contributes nothing and lower layers\n  still apply. (It must not raise; it must not abort the merge.)\n- A config file whose JSON contains dot-notation keys has them expanded.\n\n### Environment variables\n- Only variables whose name starts with the prefix `APP_` are consumed; all other\n  env vars are ignored.\n- The prefix `APP_` is stripped, and the REMAINDER is lowercased to form the key.\n  So `APP_PORT` -> key `port`, `APP_DEBUG` -> key `debug`.\n- Nested keys in env use a double underscore `__` as the nesting separator:\n  `APP_DATABASE__HOST` -> `database.host` -> `{\"database\": {\"host\": ...}}`.\n  (Single underscores within a segment are preserved as part of that key segment,\n  e.g. `APP_LOG_LEVEL` -> key `log_level`.)\n- Env values are strings and are passed through type inference (below).\n\n### CLI flags (the `cli_args` list, and the CLI's post-`--` args)\n- `--key value` sets `key` to `value`.\n- `--nested.key value` sets the dotted key `nested.key` (expanded to nested dicts).\n- `--flag` (no following value, or followed by another `--\u2026` token) sets `flag`\n  to boolean `true`.\n- `--no-flag` sets `flag` to boolean `false`. The `no-` prefix is stripped from\n  the FIRST segment of the key only; e.g. `--no-feature-enabled` sets\n  `feature-enabled` to `false` (only the leading `no-` is removed, not later\n  hyphens), and `--no-a.b` sets `a.b` to `false`.\n- Flag key segments keep their hyphens: `--feature-enabled` -> key\n  `feature-enabled` (hyphens are NOT converted to underscores).\n- \"Unknown\" flags are not an error: there is no fixed schema, so any `--key`\n  is accepted and merged. (The SPEC's \"unknown flags\" test means such flags are\n  handled gracefully, not rejected.)\n- CLI values (for the `--key value` form) are strings and are passed through\n  type inference (below). The explicit boolean forms `--flag` / `--no-flag`\n  yield real booleans directly.\n\n### Type inference (applied to STRING values from env and from `--key value`)\nApplied to a raw string value `s` (case-insensitive for booleans):\n- If `s` lowercased is `\"true\"`  -> Python `True`.\n- If `s` lowercased is `\"false\"` -> Python `False`.\n- Else if `s` is an OPTIONALLY-SIGNED run of ASCII digits (matches `-?\\d+`, e.g.\n  `\"9000\"`, `\"-3\"`, `\"0\"`) -> Python `int`.\n- Else -> the string `s` unchanged (this includes `\"1.5\"`, `\"007abc\"`, `\"\"`,\n  `\"3.0\"`, and any value with a leading `+`; only plain integers are coerced,\n  floats are left as strings).\n- Values that already arrive as non-strings (e.g. JSON numbers/booleans/objects\n  from a config file or nested dicts in `defaults`) are used AS-IS and are NOT\n  re-inferred.\n\n### CLI `show` subcommand\n- Usage: `python -m confstack show [--defaults defaults.json] [--config app.json] [-- <cli flags...>]`.\n- `--defaults PATH` loads a JSON object used as the `defaults` dict (optional;\n  absent or missing file -> empty defaults).\n- `--config PATH` is passed as `config_file`.\n- Everything after a literal `--` separator is passed through as `cli_args`.\n- The process environment is used for the `env` layer (only `APP_`-prefixed vars).\n- The merged config is printed as JSON to stdout and the process exits 0.\n</content>\n</invoke>\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "infer_bool_true",
        "desc": "string 'true' is inferred as boolean True"
      },
      {
        "id": "infer_bool_false",
        "desc": "string 'false' is inferred as boolean False"
      },
      {
        "id": "infer_int",
        "desc": "an integer-looking string is inferred as int"
      },
      {
        "id": "infer_str",
        "desc": "a non-bool non-int string stays a string (e.g. '1.5')"
      },
      {
        "id": "expand_dotted_cli",
        "desc": "a --nested.key flag expands to a nested dict"
      },
      {
        "id": "nested_dict_preserved",
        "desc": "nested dict values are returned as nested dicts"
      },
      {
        "id": "prec_cli_over_env",
        "desc": "CLI flags override environment variables"
      },
      {
        "id": "prec_env_over_config",
        "desc": "environment variables override the config file"
      },
      {
        "id": "prec_config_over_default",
        "desc": "config file overrides defaults"
      },
      {
        "id": "bool_false_overrides_true",
        "desc": "a higher-precedence false overrides a lower true"
      },
      {
        "id": "deep_merge_siblings",
        "desc": "deep merge keeps non-overlapping sibling keys"
      },
      {
        "id": "missing_config_no_error",
        "desc": "a missing config file path does not raise"
      },
      {
        "id": "none_config_ok",
        "desc": "config_file=None contributes nothing and does not raise"
      },
      {
        "id": "no_flag_false",
        "desc": "--no-flag sets the flag to boolean false"
      },
      {
        "id": "bare_flag_true",
        "desc": "a bare --flag sets it to boolean true"
      },
      {
        "id": "env_prefix_filter",
        "desc": "only APP_-prefixed env vars are consumed"
      },
      {
        "id": "unknown_flag_ok",
        "desc": "an unknown --flag is accepted, not rejected"
      },
      {
        "id": "deterministic",
        "desc": "load_config is deterministic across repeated calls"
      },
      {
        "id": "cli_show_json",
        "desc": "`python -m confstack show` emits JSON and exits 0"
      },
      {
        "id": "cli_precedence",
        "desc": "the CLI applies CLI > config > defaults precedence"
      }
    ],
    "num_checks": 20,
    "has_setup": false
  },
  {
    "slug": "cronmatch",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 cronmatch: the test suite is failing\n\nYou have an existing Python package `cronmatch`, a tiny matcher that decides\nwhether a given datetime is \"due\" under a 5-field cron expression. It ships with\na unittest suite in `cronmatch/test_cronmatch.py`, and right now several of those\ntests FAIL. Fix the code so that ALL the tests pass. Do not rewrite the package\nfrom scratch and do not change its public API.\n\n## Symptom\n\n`matches(cron_expr, dt)` parses a 5-field cron expression and returns True iff\n`dt` satisfies every field. Plain `* * * * *`, exact values, simple ranges and\ncomma lists already work, but several STEP and day-of-week cases come out wrong:\n\n    from datetime import datetime\n    from cronmatch.public import matches\n\n    # `*/n` is off by the field's minimum (wrong for month / day-of-month):\n    matches(\"0 0 1 */3 *\", datetime(2026, 1, 1, 0, 0))\n    #   EXPECTED True   (months are 1,4,7,10 \u2014 January is in the set)\n    #   ACTUAL   False  (buggy set is 0,3,6,9,12 \u2014 counts from 0, misses Jan)\n\n    # a stepped RANGE `a-b/n` ignores the step:\n    matches(\"10-30/10 * * * *\", datetime(2026, 6, 18, 0, 15))\n    #   EXPECTED False  (minutes are 10,20,30 \u2014 15 is not in the set)\n    #   ACTUAL   True   (buggy treats it as the whole range 10..30)\n\n    # when BOTH day-of-month and day-of-week are restricted, they should OR:\n    matches(\"0 0 13 * 5\", datetime(2026, 6, 19, 0, 0))   # Fri the 19th\n    #   EXPECTED True   (it is a Friday, so the day-of-week clause fires)\n    #   ACTUAL   False  (buggy AND-s the two clauses, demands the 13th too)\n\nThese defects interact: an expression that uses a stepped range or a stepped\nmonth AND constrains both day-of-month and day-of-week exercises more than one at\nonce.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `cronmatch` package:\n\n    python -m unittest cronmatch.test_cronmatch\n\n## Contract (must hold after your fix)\n\n* Package name stays `cronmatch`; import path `cronmatch` / `cronmatch.public`.\n* Keep the public API exactly: `matches(cron_expr: str, dt: datetime) -> bool`\n  and the `CronError` exception. Do not rename them.\n* `cron_expr` is a string of EXACTLY 5 whitespace-separated fields, in order:\n\n    minute  hour  day-of-month  month  day-of-week\n\n  Any other field count raises `CronError`. A field that cannot be parsed (e.g.\n  a non-integer token) also raises `CronError`.\n* Field value ranges (inclusive):\n    - minute        0\u201359\n    - hour          0\u201323\n    - day-of-month  1\u201331\n    - month         1\u201312\n    - day-of-week   0\u20136, where 0 = Sunday, 1 = Monday, ... 6 = Saturday.\n* Each field is one or more comma-separated terms; a datetime matches the field\n  if ANY term matches. A term is one of:\n    - `*`        \u2014 every value in the field's range.\n    - `v`        \u2014 the single integer `v`.\n    - `a-b`      \u2014 every value from `a` to `b` inclusive.\n    - `*/n`      \u2014 every nth value across the field's full range, STARTING AT THE\n                   FIELD'S MINIMUM. So minute `*/15` = {0,15,30,45}; month `*/3` =\n                   {1,4,7,10} (NOT {0,3,6,9,12}); day-of-month `*/10` =\n                   {1,11,21,31} (NOT {0,10,20,30}).\n    - `a-b/n`    \u2014 every nth value from `a` to `b` inclusive. So `10-30/10` =\n                   {10,20,30}; hour `8-18/2` = {8,10,12,14,16,18}.\n* A datetime matches the WHOLE expression iff its minute, hour and month each\n  match their field AND the day-of-month / day-of-week pair matches per the rule\n  below.\n* DAY-OF-MONTH / DAY-OF-WEEK semantics (standard cron): if BOTH the\n  day-of-month field and the day-of-week field are restricted (i.e. neither is a\n  bare `*`), the day matches when the day-of-month clause matches OR the\n  day-of-week clause matches \u2014 either one firing is enough. If only one of the\n  two is restricted, only that one constrains the day. If both are `*`, every day\n  matches.\n\nExample:\n\n    # day-of-month 13 OR day-of-week Friday(5):\n    matches(\"0 0 13 * 5\", datetime(2026, 6, 13, 0, 0))   # Sat the 13th  -> True (dom)\n    matches(\"0 0 13 * 5\", datetime(2026, 6, 19, 0, 0))   # Fri the 19th  -> True (dow)\n    matches(\"0 0 13 * 5\", datetime(2026, 2, 13, 0, 0))   # Fri the 13th  -> True (both)\n    matches(\"0 0 13 * 5\", datetime(2026, 6, 18, 0, 0))   # Thu the 18th  -> False\n\n    # stepped range + stepped month + dom/dow OR all at once:\n    matches(\"0 0 10-20/5 * 5\", datetime(2026, 6, 15, 0, 0))  # 15 in {10,15,20} -> True\n    matches(\"0 0 1 */3 5\",     datetime(2026, 7, 3, 0, 0))   # Jul in {1,4,7,10}, Fri -> True\n\nStandard library only (`datetime`). Do not change the package name or the public\nfunction/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "every_minute",
        "desc": "plain * * * * * matches any datetime"
      },
      {
        "id": "exact_match_true",
        "desc": "exact minute+hour matches"
      },
      {
        "id": "exact_minute_false",
        "desc": "wrong minute fails an exact match"
      },
      {
        "id": "exact_hour_false",
        "desc": "wrong hour fails an exact match"
      },
      {
        "id": "list_minute_true",
        "desc": "comma list matches a listed minute"
      },
      {
        "id": "list_minute_false",
        "desc": "comma list rejects an unlisted minute"
      },
      {
        "id": "simple_range_in",
        "desc": "a-b range matches inside the range"
      },
      {
        "id": "simple_range_out",
        "desc": "a-b range rejects outside the range"
      },
      {
        "id": "month_field_true",
        "desc": "month field matches the right month"
      },
      {
        "id": "month_field_false",
        "desc": "month field rejects the wrong month"
      },
      {
        "id": "dow_only_true",
        "desc": "day-of-week-only rule matches that weekday"
      },
      {
        "id": "dow_only_false",
        "desc": "day-of-week-only rule rejects other weekdays"
      },
      {
        "id": "dom_only_true",
        "desc": "day-of-month-only rule matches that day"
      },
      {
        "id": "dom_only_false",
        "desc": "day-of-month-only rule rejects other days"
      },
      {
        "id": "dow_sunday_zero",
        "desc": "day-of-week 0 means Sunday"
      },
      {
        "id": "step_minute_min0_hit",
        "desc": "*/15 on minute (min 0) matches 30"
      },
      {
        "id": "step_minute_min0_miss",
        "desc": "*/15 on minute (min 0) rejects 31"
      },
      {
        "id": "step_month_q_jan",
        "desc": "month */3 includes January (1,4,7,10)"
      },
      {
        "id": "step_month_q_jul",
        "desc": "month */3 includes July"
      },
      {
        "id": "step_month_q_jun_miss",
        "desc": "month */3 excludes June"
      },
      {
        "id": "step_month_q_mar_miss",
        "desc": "month */3 excludes March"
      },
      {
        "id": "step_month_2_mar",
        "desc": "month */2 includes March, excludes February"
      },
      {
        "id": "step_month_2_feb_miss",
        "desc": "month */2 excludes February (1,3,5,...)"
      },
      {
        "id": "step_dom_10_hit",
        "desc": "day-of-month */10 includes the 11th (1,11,21,31)"
      },
      {
        "id": "step_dom_10_miss",
        "desc": "day-of-month */10 excludes the 10th"
      },
      {
        "id": "step_dom_10_first",
        "desc": "day-of-month */10 includes the 1st"
      },
      {
        "id": "step_dom_7_hit",
        "desc": "day-of-month */7 includes the 8th (1,8,15,22,29)"
      },
      {
        "id": "range_step_min_hit",
        "desc": "minute 10-30/10 matches 20"
      },
      {
        "id": "range_step_min_miss15",
        "desc": "minute 10-30/10 rejects 15"
      },
      {
        "id": "range_step_min_miss25",
        "desc": "minute 10-30/10 rejects 25"
      },
      {
        "id": "range_step_hour_hit",
        "desc": "hour 8-18/2 matches 14"
      },
      {
        "id": "range_step_hour_miss9",
        "desc": "hour 8-18/2 rejects 9"
      },
      {
        "id": "range_step_hour_miss11",
        "desc": "hour 8-18/2 rejects 11"
      },
      {
        "id": "range_step_dom_hit",
        "desc": "day-of-month 5-25/10 matches the 15th"
      },
      {
        "id": "range_step_dom_miss",
        "desc": "day-of-month 5-25/10 rejects the 10th"
      },
      {
        "id": "or_dow_fires",
        "desc": "0 0 13 * 5: a Friday that is not the 13th still matches"
      },
      {
        "id": "or_dom_fires",
        "desc": "0 0 13 * 5: the 13th that is not a Friday still matches"
      },
      {
        "id": "or_both",
        "desc": "0 0 13 * 5: a Friday the 13th matches"
      },
      {
        "id": "or_neither",
        "desc": "0 0 13 * 5: a non-13th non-Friday does not match"
      },
      {
        "id": "or_dow_wed_fires",
        "desc": "0 0 1 * 3: a Wednesday that is not the 1st matches"
      },
      {
        "id": "or_dom_first_fires",
        "desc": "0 0 1 * 3: the 1st that is not a Wednesday matches"
      },
      {
        "id": "ix_step_range_or_dom",
        "desc": "10-20/5 dom OR Fri: the 15th fires via dom (needs step+OR)"
      },
      {
        "id": "ix_step_range_or_dow",
        "desc": "10-20/5 dom OR Fri: a Friday off the set fires via dow"
      },
      {
        "id": "ix_step_range_or_none",
        "desc": "10-20/5 dom OR Fri: neither -> no match"
      },
      {
        "id": "ix_step_month_or_dow",
        "desc": "*/3 month + 1st-OR-Fri: July Friday fires (needs step-min+OR)"
      },
      {
        "id": "ix_step_month_or_dom",
        "desc": "*/3 month + 1st-OR-Fri: April 1st fires (needs step-min+OR)"
      },
      {
        "id": "bad_field_count_raises",
        "desc": "a non-5-field expression raises CronError"
      },
      {
        "id": "bad_token_raises",
        "desc": "an unparseable field token raises CronError"
      }
    ],
    "num_checks": 48,
    "has_setup": true
  },
  {
    "slug": "cronsim",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `cronsim`.\n\nBuild a cron schedule parser and simulator. Use only the Python standard library.\n\nExpose these functions from `cronsim.public`:\n\n```python\ndef parse_cron(expr: str) -> dict: ...\ndef next_runs(expr: str, start_iso: str, count: int, timezone: str = \"UTC\") -> list[str]: ...\ndef should_run(expr: str, instant_iso: str, timezone: str = \"UTC\") -> bool: ...\n```\n\nSupport five-field cron expressions:\n\n```text\nminute hour day_of_month month day_of_week\n```\n\nSupport:\n\n```text\n*\ncomma lists\nranges\nstep values such as */15 and 1-10/2\n```\n\nUse standard cron OR semantics for day-of-month and day-of-week when both are restricted.\n\nTimezone handling must use `zoneinfo`. Output timestamps must be ISO strings in UTC.\n\nInclude a CLI:\n\n```bash\npython -m cronsim next \"*/15 9-17 * * 1-5\" --start 2026-01-01T00:00:00Z --count 10 --timezone America/New_York\n```\n\nInclude tests for ranges, steps, lists, invalid expressions, leap years, daylight saving transitions, weekday numbering, and deterministic output.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "ranges_steps_lists",
        "desc": "ranges, */n steps and list/range fields fire correctly"
      },
      {
        "id": "lists",
        "desc": "comma lists in minute and day-of-month fields"
      },
      {
        "id": "stepped_range",
        "desc": "stepped range like 1-10/2 expands correctly"
      },
      {
        "id": "invalid",
        "desc": "invalid expressions are rejected (raise)"
      },
      {
        "id": "leap_year",
        "desc": "Feb 29 schedule only matches leap years"
      },
      {
        "id": "dst_spring",
        "desc": "noon's UTC offset shifts correctly across spring-forward"
      },
      {
        "id": "dst_fall",
        "desc": "noon's UTC offset shifts correctly across fall-back"
      },
      {
        "id": "weekday_numbering",
        "desc": "Sunday is both dow 0 and dow 7; numbering is correct"
      },
      {
        "id": "dom_dow_or",
        "desc": "dom/dow use OR semantics when both restricted"
      },
      {
        "id": "should_run_consistency",
        "desc": "should_run is True at a fired instant, False one minute later"
      },
      {
        "id": "determinism",
        "desc": "next_runs is deterministic across repeated calls"
      },
      {
        "id": "count_and_order",
        "desc": "next_runs honors count and returns strictly ascending instants"
      },
      {
        "id": "cli_next",
        "desc": "`python -m cronsim next ...` emits the correct UTC instants"
      },
      {
        "id": "cli_invalid",
        "desc": "the CLI exits nonzero on an invalid expression"
      }
    ],
    "num_checks": 14,
    "has_setup": false
  },
  {
    "slug": "csvgroupby",
    "type": "feature-add",
    "brief": "You are handed an existing, WORKING Python 3.11+ package named `csvgroupby`. It is\nalready in your working directory. Add ONE new capability described below WITHOUT\nregressing what already works. Use only the Python standard library.\n\n## What it does today\n\n`csvgroupby.public.query(rows, sql)` runs a small SQL-subset query against `rows`\n(a list of dicts, one per CSV record \u2014 every value is a string as read from the\nfile) and returns a list of row dicts.\n\nIt already supports:\n\n    SELECT <cols> FROM <table> [WHERE <column> <op> <value>]\n\n  - `<cols>` is `*` or a comma-separated list of column names.\n  - `<op>` is one of: `>=`  `<=`  `>`  `<`  `=`  `!=`\n  - WHERE compares with NUMERIC INFERENCE: a cell or literal that looks like a\n    number is compared numerically, otherwise as a string. So\n    `WHERE age >= 18` keeps rows whose `age` cell is the number 18 or greater,\n    even though the cell is stored as a string.\n  - The `<table>` name parses but is ignored (`rows` is the data source).\n\nExample (already works):\n\n    rows = [\n        {\"city\": \"NYC\", \"age\": \"30\"},\n        {\"city\": \"LA\",  \"age\": \"17\"},\n        {\"city\": \"NYC\", \"age\": \"22\"},\n    ]\n    query(rows, \"SELECT city FROM t WHERE age >= 18\")\n    # -> [{\"city\": \"NYC\"}, {\"city\": \"NYC\"}]\n\n## The capability to ADD: GROUP BY <col> with COUNT(*)\n\nAdd support for a trailing `GROUP BY <column>` clause together with a `COUNT(*)`\naggregate in the select list:\n\n    SELECT <col>, COUNT(*) FROM <table> [WHERE ...] GROUP BY <col>\n\nSemantics:\n\n  - GROUP BY produces ONE output row per DISTINCT value of the grouped column,\n    in first-seen order.\n  - `COUNT(*)` in the select list is the number of rows in that group, and it\n    appears in each output row under the key `COUNT(*)`.\n  - GROUP BY composes with WHERE: filter first, then group over the surviving\n    rows (so a group's count reflects only rows that passed WHERE).\n\nExamples:\n\n    rows = [\n        {\"city\": \"NYC\", \"age\": \"30\"},\n        {\"city\": \"LA\",  \"age\": \"17\"},\n        {\"city\": \"NYC\", \"age\": \"22\"},\n        {\"city\": \"LA\",  \"age\": \"40\"},\n        {\"city\": \"NYC\", \"age\": \"12\"},\n    ]\n\n    query(rows, \"SELECT city, COUNT(*) FROM t GROUP BY city\")\n    # -> [\n    #      {\"city\": \"NYC\", \"COUNT(*)\": 3},\n    #      {\"city\": \"LA\",  \"COUNT(*)\": 2},\n    #    ]\n\n    query(rows, \"SELECT city, COUNT(*) FROM t WHERE age >= 18 GROUP BY city\")\n    # -> [\n    #      {\"city\": \"NYC\", \"COUNT(*)\": 2},   # ages 30, 22\n    #      {\"city\": \"LA\",  \"COUNT(*)\": 1},   # age 40\n    #    ]\n\n## Contract\n\n  - Package name stays `csvgroupby`; keep the public API\n    `query(rows, sql) -> list[dict]` exposed from `csvgroupby.public`\n    (and re-exported from `csvgroupby`).\n  - DO NOT change the existing behavior or return shape: the result is always a\n    list of row dicts; plain `SELECT <cols> ... [WHERE ...]` (no GROUP BY) keeps\n    returning exactly the same projected/filtered rows it does today, and WHERE\n    keeps its numeric-inference comparison.\n  - The new aggregate value MUST appear under the key `COUNT(*)` (the literal\n    string `COUNT(*)`).\n  - Each GROUP BY output row identifies its group by the grouped column's value\n    (e.g. `{\"city\": \"NYC\", \"COUNT(*)\": 3}`); one row per distinct group value,\n    in first-seen order; count = number of WHERE-surviving rows in the group.\n  - Standard library only; keep it a self-contained package.\n\nDo not change the package name or the `query` signature. Add `GROUP BY <col>`\nwith `COUNT(*)` so the examples above work, and keep the existing SELECT/WHERE\nbehavior intact.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "groupby_basic_counts",
        "desc": "got={('str', 'NYC'): 3, ('str', 'LA'): 2} want={('str', 'NYC'): 3, ('str', 'LA'): 2}"
      },
      {
        "id": "groupby_one_row_per_group",
        "desc": "rows=2 distinct=2"
      },
      {
        "id": "groupby_honors_where",
        "desc": "got={('str', 'NYC'): 2, ('str', 'LA'): 1} want={('str', 'NYC'): 2, ('str', 'LA'): 1}"
      },
      {
        "id": "groupby_numeric_key",
        "desc": "got={('num', 1.0): 3, ('num', 2.0): 1} want={('num', 1.0): 3, ('num', 2.0): 1}"
      },
      {
        "id": "groupby_single_group",
        "desc": "count=3"
      },
      {
        "id": "select_cols_projection",
        "desc": "result=[{'city': 'NYC'}, {'city': 'LA'}, {'city': 'NYC'}, {'city': 'LA'}, {'city': 'NYC'}]"
      },
      {
        "id": "select_star_passthrough",
        "desc": "result=[{'city': 'NYC', 'age': '30'}, {'city': 'LA', 'age': '17'}, {'city': 'NYC', 'age': '22'}, {'city': 'LA', 'age': '40'}, {'city': 'NYC', 'age': '12'}]"
      },
      {
        "id": "where_numeric_ge",
        "desc": "ages=[22, 30, 40] want=[22, 30, 40]"
      },
      {
        "id": "where_not_equal_string",
        "desc": "cities=['NYC', 'NYC', 'NYC'] want=['NYC', 'NYC', 'NYC']"
      },
      {
        "id": "where_lt_numeric",
        "desc": "ages=[12, 17] want=[12, 17]"
      }
    ],
    "num_checks": 10,
    "has_setup": true
  },
  {
    "slug": "csvparse",
    "type": "bug-fix",
    "brief": "You are handed an existing Python 3.11+ package named `csvparse`. It is already in\nyour working directory. Fix the bug described below. Use only the Python standard\nlibrary. Keep it a self-contained package \u2014 do not pull in the `csv` module or any\nthird-party library; the point is a correct hand-rolled parser.\n\n## Bug report\n\n`csvparse.public.parse_csv(text)` reads CSV text (a header row followed by data\nrows) and returns a list of dicts, one per row, mapping each header column to its\nvalue. Plain rows parse fine. But rows that contain a QUOTED field with a comma\ninside it are parsed into the WRONG NUMBER OF COLUMNS \u2014 the comma inside the quotes\nis wrongly treated as a field separator, so the row is split into extra columns and\nevery column after that field is shifted/misaligned.\n\nRepro:\n\n    text = (\n        \"name,role,city\\n\"\n        'Ada,\"Smith, Jr.\",London\\n'\n        \"Bob,Engineer,Paris\\n\"\n    )\n    rows = parse_csv(text)\n\nExpected:\n    rows[0] == {\"name\": \"Ada\", \"role\": \"Smith, Jr.\", \"city\": \"London\"}\n    rows[1] == {\"name\": \"Bob\", \"role\": \"Engineer\", \"city\": \"Paris\"}\n\nActual (buggy): the first row comes back with `role` == \"Smith\" and `city` == \"Jr.\"\n(the trailing \"London\" is dropped/misplaced) because the field was split on the\ncomma inside the quotes. The plain second row is unaffected.\n\n## Contract\n\n  - Package name stays `csvparse`; keep the public API `parse_csv(text) -> list[dict]`\n    exposed from `csvparse.public` (and re-exported from `csvparse`).\n  - The first non-empty record is the header row; each later record is one dict\n    mapping header name -> field value, in header order.\n  - Parse RFC-4180-style quoted fields correctly:\n      * A field may be wrapped in double quotes; the surrounding quotes are stripped.\n      * A comma inside a quoted field is part of the value, NOT a separator.\n      * A doubled quote (`\"\"`) inside a quoted field is an escaped literal `\"`\n        (e.g. the field `\"She said \"\"hi\"\"\"` has the value: She said \"hi\").\n  - Plain unquoted rows must keep working exactly as before.\n  - Unquoted fields keep their plain text; an unquoted field never has quotes\n    stripped from its interior.\n\nDo not change the package name or the `parse_csv` signature. Fix the parser so the\nrepro above (and other quoted-comma / doubled-quote cases) parses into the correct\nnumber of columns with correct header mapping.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "header_plain",
        "desc": "rows=[{'name': 'Ada', 'role': 'Engineer', 'city': 'London'}]"
      },
      {
        "id": "plain_multi_row",
        "desc": "rows=[{'a': '1', 'b': '2'}, {'a': '3', 'b': '4'}, {'a': '5', 'b': '6'}]"
      },
      {
        "id": "quoted_comma_single",
        "desc": "rows=[{'name': 'Ada', 'role': 'Smith, Jr.', 'city': 'London'}]"
      },
      {
        "id": "quoted_comma_alignment",
        "desc": "rows=[{'name': 'Ada', 'role': 'Smith, Jr.', 'city': 'London'}, {'name': 'Bob', 'role': 'Engineer', 'city': 'Paris'}]"
      },
      {
        "id": "doubled_quote_escape",
        "desc": "rows=[{'name': 'Ada', 'quote': 'She said \"hi\"'}]"
      },
      {
        "id": "quoted_comma_from_file",
        "desc": "rows=[{'product': 'Widget', 'note': 'red, large, sturdy', 'price': '9.99'}]"
      },
      {
        "id": "multiple_quoted_fields",
        "desc": "rows=[{'a': 'x, y', 'b': 'p, q, r', 'c': 'z'}]"
      },
      {
        "id": "plain_unquoted_unchanged",
        "desc": "rows=[{'id': '42', 'label': 'hello world'}]"
      }
    ],
    "num_checks": 8,
    "has_setup": true
  },
  {
    "slug": "csvql",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `csvql`.\n\nBuild a small query engine for CSV files. Use only the Python standard library.\n\nExpose:\n\n```python\ndef query_csv(path: str, query: str) -> list[dict]: ...\n```\n\nSupport queries like:\n\n```sql\nSELECT name, age FROM people WHERE age >= 18 ORDER BY age DESC LIMIT 10\nSELECT department, COUNT(*) FROM employees GROUP BY department ORDER BY COUNT(*) DESC\n```\n\nRequired features:\n\n```text\nSELECT columns\nSELECT *\nWHERE with = != < <= > >=\nAND / OR\nORDER BY one column\nLIMIT\nCOUNT(*)\nSUM(column)\nAVG(column)\nGROUP BY one column\n```\n\nInfer numbers where possible; otherwise treat values as strings.\n\nDo not use SQL databases or third-party parsers. Implement parsing yourself.\n\nInclude a CLI:\n\n```bash\npython -m csvql query people.csv \"SELECT name FROM people WHERE age >= 18\"\n```\n\nInclude tests for filtering, numeric comparison, string comparison, grouping, aggregates, order by, limit, malformed queries, and CSV quoting.\n\n## Contract\n\nThis section pins the loose parts of the spec so that an automated grader can check\nbehavior rather than guess at an internal representation. An implementation is\n\"correct\" when it honors the spec above AND the conventions below.\n\n### Import path and CLI\n\n- The public function lives at `csvql.public`:\n\n  ```python\n  from csvql.public import query_csv\n  ```\n\n- The CLI is invoked as a module with a `query` subcommand:\n\n  ```bash\n  python -m csvql query <path.csv> \"<SQL query>\"\n  ```\n\n  The CLI prints the result rows to stdout. The output MUST be machine-readable\n  as JSON: either a JSON array of row objects, or one JSON object per line\n  (JSON Lines). A grader will accept either form.\n\n### Result shape\n\n- `query_csv(path, query)` returns a `list[dict]` \u2014 a list of row dicts.\n- Each row dict maps a SELECTed output column name (a `str`) to that row's value.\n- Row order reflects `ORDER BY` / `LIMIT` when present; otherwise it follows the\n  file's row order.\n\n### Value typing (numeric inference)\n\n- Values that look like numbers are inferred to numeric types: an integer-looking\n  field (e.g. `\"18\"`) becomes an `int`, a decimal-looking field (e.g. `\"3.5\"`)\n  becomes a `float`. Everything else stays a `str`.\n- Comparisons in `WHERE` and ordering in `ORDER BY` use these inferred types, so\n  `age >= 18` compares numerically and a name column compares lexicographically.\n- A grader tolerates int-vs-float representation of the same numeric value (e.g.\n  `18` and `18.0` are treated as equal), and for aggregate results tolerates an\n  integer-valued result expressed as either `int` or `float`.\n\n### Column naming\n\n- For a plain column projection (`SELECT name, age`), each output key is the\n  source column name exactly as written (`\"name\"`, `\"age\"`).\n- `SELECT *` projects every source column, keyed by its CSV header name.\n- For aggregates, the output key is the aggregate's source text, uppercased and\n  whitespace-free:\n  - `COUNT(*)` appears under the key `\"COUNT(*)\"`.\n  - `SUM(amount)` appears under the key `\"SUM(amount)\"`.\n  - `AVG(score)` appears under the key `\"AVG(score)\"`.\n  A grader matches the aggregate value tolerantly: it accepts the value under the\n  canonical key above, or under any key whose normalized text (uppercased,\n  spaces removed) equals the canonical key. This tolerates a `COUNT(*)` alias\n  such as `count` only if it normalizes to the same canonical text; otherwise the\n  canonical `COUNT(*)`/`SUM(col)`/`AVG(col)` key is expected.\n\n### GROUP BY rows\n\n- `SELECT department, COUNT(*) FROM employees GROUP BY department` returns one row\n  dict per distinct group. Each such row carries:\n  - the group-by column under its own name (`\"department\"`), and\n  - each aggregate under its aggregate key (`\"COUNT(*)\"`, etc.).\n- `COUNT(*)` counts the rows in the group. `SUM(col)` / `AVG(col)` aggregate the\n  numeric values of `col` within the group (non-numeric values are ignored for the\n  arithmetic, matching \"infer numbers where possible\").\n- Without a `GROUP BY`, a query whose projection is purely aggregates (e.g.\n  `SELECT COUNT(*) FROM people`) returns a single row dict covering all matching\n  rows.\n\n### Errors\n\n- A malformed or unsupported query (syntax error, unknown column in a way the\n  engine cannot resolve, unsupported construct) raises an exception rather than\n  returning a wrong-but-silent result. The exception type is unspecified; a grader\n  only checks that *some* exception is raised for clearly malformed input.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "select_columns",
        "desc": "SELECT named columns returns list of row dicts with those keys"
      },
      {
        "id": "select_star",
        "desc": "SELECT * projects every source column"
      },
      {
        "id": "where_numeric",
        "desc": "WHERE numeric comparison (age >= 18) filters numerically, not lexically"
      },
      {
        "id": "where_string",
        "desc": "WHERE string equality (city = 'NYC') filters string columns"
      },
      {
        "id": "where_neq",
        "desc": "WHERE != excludes matching rows"
      },
      {
        "id": "where_and",
        "desc": "WHERE ... AND ... requires both conditions"
      },
      {
        "id": "where_or",
        "desc": "WHERE ... OR ... admits either condition"
      },
      {
        "id": "order_by_desc",
        "desc": "ORDER BY col DESC sorts descending"
      },
      {
        "id": "order_by_asc",
        "desc": "ORDER BY col (default ASC) sorts ascending"
      },
      {
        "id": "limit",
        "desc": "LIMIT n truncates the result to n rows"
      },
      {
        "id": "count_star",
        "desc": "COUNT(*) over whole table returns the row count under a COUNT(*) key"
      },
      {
        "id": "sum_agg",
        "desc": "SUM(col) totals a numeric column"
      },
      {
        "id": "avg_agg",
        "desc": "AVG(col) averages a numeric column"
      },
      {
        "id": "group_by_count",
        "desc": "GROUP BY col with COUNT(*) yields one row per group with group key + count"
      },
      {
        "id": "group_by_order",
        "desc": "GROUP BY with ORDER BY COUNT(*) DESC orders groups by aggregate"
      },
      {
        "id": "numeric_inference",
        "desc": "numeric fields are inferred as numbers (age compares/sorts numerically)"
      },
      {
        "id": "csv_quoting",
        "desc": "quoted CSV fields with embedded commas/quotes parse correctly"
      },
      {
        "id": "malformed_raises",
        "desc": "a malformed query raises an exception rather than returning silently"
      },
      {
        "id": "cli_query_json",
        "desc": "`python -m csvql query` emits machine-readable JSON rows"
      }
    ],
    "num_checks": 19,
    "has_setup": false
  },
  {
    "slug": "cursorpage",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `cursorpage`: a paginator over\na list of records sorted by a key. The package is already written, imports\ncleanly, and OFFSET pagination works:\n\n    Paginator(records, key=\"score\")   # records: dicts with int \"id\" + a sort key\n    p.page(n, size)                   # the n-th page (0-based) of `size` records\n\nRecords are kept in a fully-deterministic order: by `key` ascending, with ties\nbroken by `\"id\"` ascending (so the order is stable even when several records\nshare a sort-key value).\n\n## Task\n\nAdd CURSOR (keyset) pagination alongside the existing offset paging:\n\n    p.page_after(cursor, size) -> {\"items\": [...], \"next_cursor\": <token-or-None>}\n\nA cursor is an OPAQUE token that encodes the position of the last record handed\nout so far. Walking the data by feeding each call's `next_cursor` into the next\ncall must visit every record EXACTLY ONCE \u2014 no duplicates, no gaps \u2014 and then\nstop. Do NOT change or break offset `page(n, size)`.\n\n## Semantics (read carefully \u2014 this is the whole task)\n\n- The cursor encodes the (sort-key value, id) of the LAST record returned.\n  Resumption is \"strictly AFTER that position\" in the sorted order. Because the\n  order is (key, then id), this is what makes TIES work: two records with the\n  same sort key are still separated by id, so a cursor landing in the middle of\n  a run of tied keys resumes at exactly the next record \u2014 never re-emitting the\n  ones already seen, never skipping the ones not yet seen.\n\n- The token is opaque: callers must not have to parse or construct it. Encode it\n  however you like (it must round-trip the (key, id) boundary).\n\n- A `None` cursor \u2014 or any invalid / malformed / unrecognized token \u2014 starts\n  from the BEGINNING (the first record). An invalid cursor must NOT raise.\n\n- `next_cursor` is `None` EXACTLY when the page just returned is the last one\n  (i.e. there are no more records after it). When more records remain,\n  `next_cursor` is a token that resumes strictly after the last item of this\n  page. An empty result (nothing after the cursor) therefore has\n  `next_cursor=None`.\n\n- `size` must be positive (raise `ValueError` otherwise), matching `page`.\n\n## Example\n\n    rows = [{\"id\": 3, \"score\": 5}, {\"id\": 1, \"score\": 5}, {\"id\": 2, \"score\": 9}]\n    p = Paginator(rows, key=\"score\")\n    # sorted order is by (score, id): id 1 (s5), id 3 (s5), id 2 (s9)\n\n    out = p.page_after(None, 2)\n    [r[\"id\"] for r in out[\"items\"]]      # [1, 3]   -- note the tie on score 5\n    out[\"next_cursor\"] is None           # False    -- more remain\n\n    out2 = p.page_after(out[\"next_cursor\"], 2)\n    [r[\"id\"] for r in out2[\"items\"]]     # [2]\n    out2[\"next_cursor\"] is None          # True     -- last page\n\nWalking from None with next_cursor must yield ids [1, 3, 2] \u2014 every record once.\n\nA cursor whose key value lands in the MIDDLE of a tie must not re-emit or skip:\nresuming after (score=5, id=1) yields id 3 next (the other score-5 record),\nthen id 2 \u2014 never id 1 again, and never jumping past id 3.\n\n## Contract\n\n- Package name: `cursorpage`. The grader imports `cursorpage.public` (falling\n  back to `cursorpage`); keep both import paths working.\n- Public class `Paginator(records, key=\"id\")` with:\n    * `page(n, size) -> list` \u2014 UNCHANGED offset pagination.\n    * `page_after(cursor, size) -> {\"items\": list, \"next_cursor\": str|None}` \u2014\n      cursor pagination as specified above. `cursor` may be `None`.\n- The cursor returned in `next_cursor` is opaque (any string encoding); feeding\n  it back into `page_after` resumes strictly after the last returned record.\n- Standard library only. No persistence, no threading requirement.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "first_page_no_cursor",
        "desc": "page_after(None, size) returns the first `size` records in sorted order"
      },
      {
        "id": "first_page_next_cursor_present",
        "desc": "a non-final first page yields a non-None next_cursor"
      },
      {
        "id": "walk_all_once_no_ties",
        "desc": "walking via next_cursor visits every record exactly once (no ties)"
      },
      {
        "id": "last_page_cursor_none",
        "desc": "the final page returns next_cursor=None"
      },
      {
        "id": "walk_all_once_with_ties",
        "desc": "walking visits every record exactly once when sort keys tie"
      },
      {
        "id": "resume_mid_tie_no_dup_no_gap",
        "desc": "a cursor inside a run of tied keys resumes strictly after it"
      },
      {
        "id": "opaque_cursor_round_trips",
        "desc": "feeding back next_cursor resumes at the right place (cursor is opaque)"
      },
      {
        "id": "size_one_walk_full",
        "desc": "size=1 walk yields the full sorted order one at a time"
      },
      {
        "id": "size_larger_than_data",
        "desc": "size >= len returns all records with next_cursor=None"
      },
      {
        "id": "empty_paginator",
        "desc": "page_after(None, size) on empty data returns [] and next_cursor=None"
      },
      {
        "id": "none_cursor_from_start",
        "desc": "a None cursor starts from the beginning"
      },
      {
        "id": "invalid_cursor_from_start",
        "desc": "a garbage/invalid cursor starts from the beginning without raising"
      },
      {
        "id": "size_nonpositive_raises",
        "desc": "size <= 0 raises ValueError in page_after"
      },
      {
        "id": "regression_offset_paging",
        "desc": "offset page(n, size) still returns the correct sorted pages"
      },
      {
        "id": "regression_offset_out_of_range",
        "desc": "offset page() past the end returns an empty list"
      }
    ],
    "num_checks": 15,
    "has_setup": true
  },
  {
    "slug": "datespan",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 datespan: the test suite is failing\n\nYou have an existing Python package `datespan`, a tiny business-day date\ncalculator (Monday\u2013Friday; there is NO holiday calendar \u2014 only weekends are\nskipped). It ships with a unittest suite in `datespan/test_datespan.py`, and\nright now several of those tests FAIL. Fix the code so that ALL the tests pass.\nDo not rewrite the package from scratch and do not change its public API.\n\n## Symptom\n\n`add_business_days(start, n)` and `business_days_between(a, b)` get simple\nwithin-week cases right, but several weekend / negative / reversed cases come\nout wrong. (Weekday shown in comments: Jun 15 2026 = Mon, Jun 19 = Fri, Jun 20 =\nSat, Jun 21 = Sun, Jun 22 = next Mon.)\n\n    from datetime import date\n    from datespan.public import add_business_days, business_days_between\n\n    # negative n steps the wrong way over a weekend:\n    add_business_days(date(2026, 6, 15), -1)   # Mon, go back 1 business day\n    #   EXPECTED 2026-06-12 (the previous Fri)\n    #   ACTUAL   2026-06-15 (bounced forward off the weekend)\n\n    # a weekend start is not normalized onto a business day:\n    add_business_days(date(2026, 6, 20), 0)    # Sat, 0 business days\n    #   EXPECTED 2026-06-22 (snap forward to Mon)\n    #   ACTUAL   2026-06-20 (Saturday returned unchanged)\n\n    # the reversed count drops its sign:\n    business_days_between(date(2026, 6, 22), date(2026, 6, 15))  # Mon -> earlier Mon\n    #   EXPECTED -5\n    #   ACTUAL    5  (magnitude right, sign missing)\n\nThese defects interact: counting backward from a weekend start across a weekend\nexercises all three at once.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `datespan` package:\n\n    python -m unittest datespan.test_datespan\n\n## Contract (must hold after your fix)\n\n* Package name stays `datespan`; import path `datespan` / `datespan.public`.\n* Keep the public API exactly: `add_business_days(start: date, n: int) -> date`\n  and `business_days_between(a: date, b: date) -> int`. Do not rename them.\n* Business days are Monday through Friday. Saturday and Sunday are NEVER\n  business days. There is no holiday list.\n\n* `add_business_days(start, n)`:\n    - `start` is FIRST normalized onto a business day: a Saturday or Sunday\n      `start` is moved FORWARD to the following Monday. That normalized date is\n      the anchor for everything below, including `n == 0` and `n < 0`.\n    - `n == 0` returns the normalized anchor itself.\n    - `n > 0` advances the anchor by `n` business days, skipping weekends.\n    - `n < 0` moves BACKWARD by `abs(n)` business days, skipping weekends \u2014 so\n      stepping back across a weekend lands on the previous Friday, never on a\n      Saturday/Sunday.\n\n      Examples:\n        add_business_days(date(2026, 6, 15), 5)  -> date(2026, 6, 22)  # Mon -> next Mon\n        add_business_days(date(2026, 6, 19), 1)  -> date(2026, 6, 22)  # Fri -> Mon\n        add_business_days(date(2026, 6, 15), -1) -> date(2026, 6, 12)  # Mon -> prev Fri\n        add_business_days(date(2026, 6, 20), 1)  -> date(2026, 6, 23)  # Sat->Mon, then +1 = Tue\n\n* `business_days_between(a, b)`:\n    - Returns the number of business days in the HALF-OPEN span `(a, b]` \u2014\n      EXCLUSIVE of `a`, INCLUSIVE of `b`. Equivalently: how many business-day\n      steps it takes to walk from `a` to `b`.\n    - `a == b` returns `0`.\n    - If `a` is AFTER `b` the result is NEGATIVE: it is the negation of the\n      count from `b` to `a`. So `business_days_between(a, b) ==\n      -business_days_between(b, a)`.\n    - Weekends never count (a Friday-to-Saturday span is `0`).\n\n      Examples:\n        business_days_between(date(2026, 6, 15), date(2026, 6, 16)) -> 1   # Mon -> Tue\n        business_days_between(date(2026, 6, 15), date(2026, 6, 22)) -> 5   # Mon -> next Mon\n        business_days_between(date(2026, 6, 19), date(2026, 6, 20)) -> 0   # Fri -> Sat\n        business_days_between(date(2026, 6, 22), date(2026, 6, 15)) -> -5  # reversed\n\nThese behaviors interact \u2014 the first business day before a weekend-anchored\nstart, or the reversed count of a weekend-crossing span, depends on getting all\nof normalization, direction, and endpoint/sign right at once.\n\nStandard library only (`datetime`). Do not change the package name or the\npublic function names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "add_fwd_within_week",
        "desc": "Mon + small n stays inside the week"
      },
      {
        "id": "add_fwd_to_friday",
        "desc": "Mon + 4 lands on Fri"
      },
      {
        "id": "add_fwd_skips_weekend",
        "desc": "Mon + 5 skips the weekend to next Mon"
      },
      {
        "id": "add_fwd_friday_rolls",
        "desc": "Fri + 1 rolls to Mon"
      },
      {
        "id": "add_zero_on_business_day",
        "desc": "n == 0 on a weekday returns that day"
      },
      {
        "id": "add_sat_zero_normalizes",
        "desc": "Sat + 0 snaps forward to Mon"
      },
      {
        "id": "add_sun_zero_normalizes",
        "desc": "Sun + 0 snaps forward to Mon"
      },
      {
        "id": "add_sat_forward",
        "desc": "Sat + 1 anchors on Mon then steps to Tue"
      },
      {
        "id": "add_sun_forward2",
        "desc": "Sun + 2 anchors on Mon then steps to Wed"
      },
      {
        "id": "add_neg_within_week",
        "desc": "Fri - 1 = Thu (no weekend crossed)"
      },
      {
        "id": "add_neg_crosses_weekend",
        "desc": "Mon - 1 = previous Fri"
      },
      {
        "id": "add_neg_two",
        "desc": "Mon - 2 = previous Thu"
      },
      {
        "id": "add_neg_full_week",
        "desc": "Mon - 5 = the Monday a week earlier"
      },
      {
        "id": "add_neg_from_tuesday",
        "desc": "next Mon - 1 = the Friday before"
      },
      {
        "id": "btw_fwd_one",
        "desc": "Mon -> Tue is 1 business day"
      },
      {
        "id": "btw_fwd_four",
        "desc": "Mon -> Fri is 4 business days"
      },
      {
        "id": "btw_same_day_zero",
        "desc": "a == b is 0"
      },
      {
        "id": "btw_fwd_skips_weekend",
        "desc": "Mon -> next Mon is 5 (weekend excluded)"
      },
      {
        "id": "btw_fri_to_sat_zero",
        "desc": "Fri -> Sat is 0"
      },
      {
        "id": "btw_fwd_month_span",
        "desc": "Mon -> a Wed a month later"
      },
      {
        "id": "btw_reverse_one",
        "desc": "Tue -> Mon is -1"
      },
      {
        "id": "btw_reverse_week",
        "desc": "next Mon -> earlier Mon is -5"
      },
      {
        "id": "btw_reverse_month_span",
        "desc": "reversed month span is negative"
      },
      {
        "id": "interaction_add_sun_negative",
        "desc": "Sun start, normalize forward to Mon, then step back across the weekend"
      },
      {
        "id": "interaction_between_reverse_weekend",
        "desc": "reversed span across a weekend is the negated weekend-skipping count"
      }
    ],
    "num_checks": 25,
    "has_setup": true
  },
  {
    "slug": "decimalfmt",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 decimalfmt: the test suite is failing\n\nYou have an existing Python package `decimalfmt`, a tiny money formatter that\nworks in integer cents. It ships with a unittest suite in\n`decimalfmt/test_decimalfmt.py`, and right now several of those tests FAIL. Fix\nthe code so that ALL the tests pass. Do not rewrite the package from scratch and\ndo not change its public API.\n\n## Symptom\n\n`format_amount(cents, places, sep)` turns an integer number of cents into a\nhuman-readable string, and `parse_amount(s, places, sep)` turns it back. Small\npositive amounts come out right, but larger / negative / fractional cases are\nwrong, and the round trip is broken:\n\n    from decimalfmt.public import format_amount, parse_amount\n\n    # the negative sign lands in the wrong place:\n    format_amount(-1234567)\n    #   EXPECTED \"-12,345.67\"\n    #   ACTUAL   \"123,45.-67\"   (sign after the decimal, not in front)\n\n    # the fractional part is not zero-padded:\n    format_amount(5)\n    #   EXPECTED \"0.05\"\n    #   ACTUAL   \"0.5\"          (5 cents lost its leading zero)\n\n    # thousands grouping is applied from the wrong end:\n    format_amount(1234567)\n    #   EXPECTED \"12,345.67\"\n    #   ACTUAL   \"123,45.67\"    (grouped from the LEFT, not the right)\n\n    # and the round trip does not survive the grouping separators:\n    parse_amount(\"12,345.67\")\n    #   EXPECTED 1234567\n    #   ACTUAL   ValueError     (the \",\" was never stripped)\n\nThese defects interact: a large NEGATIVE amount with a single-cent fractional\npart, formatted and then parsed back, exercises all of them at once.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `decimalfmt` package:\n\n    python -m unittest decimalfmt.test_decimalfmt\n\n## Contract (must hold after your fix)\n\n* Package name stays `decimalfmt`; import path `decimalfmt` / `decimalfmt.public`.\n* Keep the public API exactly: `format_amount(cents: int, places: int = 2,\n  sep: str = \",\") -> str`, `parse_amount(s: str, places: int = 2,\n  sep: str = \",\") -> int`, and the `MoneyError` exception. Do not rename them.\n* `format_amount(cents, places=2, sep=\",\")` renders an integer number of cents:\n    - The amount is `cents / 10**places` units. The integer (whole-unit) part is\n      `abs(cents) // 10**places`; the fractional part is `abs(cents) % 10**places`.\n    - SIGN: a single leading `-` in FRONT of the whole number when `cents < 0`,\n      and nothing when `cents >= 0`. The sign never appears after a separator or\n      after the decimal point. Zero is non-negative (\"0.00\", no sign).\n    - GROUPING: the integer part is split into groups of three digits counting\n      FROM THE RIGHT, joined by `sep` (e.g. `1234567` whole-units ->\n      \"1,234,567\"). Fewer than four integer digits means no separator at all.\n    - FRACTION: exactly `places` digits after a single `.`, ZERO-PADDED on the\n      left, so `5` cents -> \".05\" and a whole-dollar amount -> \".00\". When\n      `places == 0` there is no `.` and no fractional part.\n    - `cents` must be an `int` (bool is not accepted); a bad `cents` or a\n      negative / non-int `places` raises `MoneyError`.\n* `parse_amount(s, places=2, sep=\",\")` is the INVERSE of `format_amount` for the\n  same `places` and `sep`:\n    - It honours a single leading `-`, STRIPS every `sep` separator, splits on\n      the `.`, pads / truncates the fractional run to `places` digits, and\n      returns the integer number of cents.\n    - `parse_amount(format_amount(c)) == c` for every int `c`.\n* ROUND TRIP: formatting then parsing must recover the original cents exactly,\n  INCLUDING the sign, the grouping separators, and zero-padded fractions.\n\nExample:\n\n    format_amount(-100000005)            # -> \"-1,000,000.05\"\n    parse_amount(\"-1,000,000.05\")        # -> -100000005\n    format_amount(1234567, places=3)     # -> \"1,234.567\"\n    format_amount(-12345, places=0)      # -> \"-12,345\"\n\nStandard library only. Do not change the package name or the public\nfunction/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "fmt_small_positive",
        "desc": "small positive amount renders correctly"
      },
      {
        "id": "fmt_under_thousand",
        "desc": "amount under $10 with two-digit frac is fine"
      },
      {
        "id": "fmt_zero",
        "desc": "zero renders as 0.00 with no sign"
      },
      {
        "id": "fmt_negative_lead_sign",
        "desc": "negative sign sits in front of the number"
      },
      {
        "id": "fmt_small_negative",
        "desc": "small negative keeps a leading sign"
      },
      {
        "id": "fmt_negative_round_thousands",
        "desc": "negative grouped amount, sign in front"
      },
      {
        "id": "fmt_pad_single_cent",
        "desc": "5 cents -> .05 (leading zero kept)"
      },
      {
        "id": "fmt_pad_whole_dollar",
        "desc": "whole dollar -> .00"
      },
      {
        "id": "fmt_pad_nine_cents",
        "desc": "9 cents -> .09"
      },
      {
        "id": "fmt_no_pad_needed",
        "desc": "two-digit frac is unchanged"
      },
      {
        "id": "fmt_group_thousands",
        "desc": "four integer digits -> one separator"
      },
      {
        "id": "fmt_group_millions",
        "desc": "millions grouped from the right"
      },
      {
        "id": "fmt_group_ten_million",
        "desc": "an 8-digit integer part groups correctly"
      },
      {
        "id": "fmt_no_group_three_digits",
        "desc": "exactly three integer digits -> no separator"
      },
      {
        "id": "fmt_places0",
        "desc": "places=0 drops the fractional part"
      },
      {
        "id": "fmt_places3",
        "desc": "places=3 keeps three padded fractional digits"
      },
      {
        "id": "fmt_custom_sep",
        "desc": "a custom separator is honoured"
      },
      {
        "id": "rt_grouped_positive",
        "desc": "grouped positive round-trips"
      },
      {
        "id": "rt_grouped_negative",
        "desc": "grouped negative round-trips"
      },
      {
        "id": "rt_single_cent",
        "desc": "single-cent amount round-trips"
      },
      {
        "id": "rt_zero",
        "desc": "zero round-trips"
      },
      {
        "id": "rt_places3",
        "desc": "places=3 round-trips"
      },
      {
        "id": "parse_grouped_literal",
        "desc": "parse strips separators from a literal string"
      },
      {
        "id": "parse_negative_literal",
        "desc": "parse honours a leading minus"
      },
      {
        "id": "interaction_neg_group_pad_rt",
        "desc": "negative + grouping + single-cent pad + round-trip together"
      },
      {
        "id": "interaction_exact_string",
        "desc": "the interaction renders the exact contract string and parses back"
      },
      {
        "id": "bad_cents_raises",
        "desc": "non-int cents raises MoneyError"
      },
      {
        "id": "bad_places_raises",
        "desc": "negative places raises MoneyError"
      }
    ],
    "num_checks": 28,
    "has_setup": true
  },
  {
    "slug": "deepget",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `deepget`: two helpers for\nreaching into nested data by a dotted-string path. `get(obj, path, default)`\nreads a value out of arbitrarily nested dicts and lists; `set_(obj, path, value)`\nwrites one, creating any missing structure on the way. The package is already\nwritten, imports cleanly, and the happy path works -- plain nested dicts read\nand write fine, and indexing into a list with a numeric segment works for the\ncommon case.\n\nIt is used to pull fields out of decoded JSON config and API payloads, where a\npath like `servers.0.host` means \"the `host` of the first element of the\n`servers` list\".\n\n## Bug report\n\nThe helpers misbehave on the trickier shapes, and the failures are easy to miss\nbecause the obvious cases look fine:\n\n  1. A field that is genuinely PRESENT but set to `null`/`None` reads back as if\n     it were missing -- `get` hands back the `default` instead of the real,\n     stored `None`. Code that distinguishes \"absent\" from \"explicitly null\" (a\n     cleared optional, say) can't tell the two apart.\n\n  2. A numeric-looking segment is ALWAYS treated as a list index, even when the\n     current container is a dict whose keys happen to be digit strings (think a\n     JSON object like `{\"2024\": {...}}` keyed by year, or sparse maps keyed by\n     id). Those entries become completely unreachable, and the lookup blows up\n     or silently returns the default.\n\n  3. `set_` only ever creates plain dicts for the missing intermediate steps, so\n     a path that needs a LIST in the middle (e.g. `items.0.name` starting from\n     an empty object) builds the wrong shape -- a dict keyed by the string \"0\"\n     instead of a one-element list. Later `get`s along the intended path then\n     fail.\n\n  4. Out-of-range and negative list indices are mishandled on read: a path that\n     runs off the end of a list raises instead of falling back to `default`, and\n     a negative index quietly wraps around to grab an element from the END of the\n     list rather than failing. Both should simply be treated as \"not found\".\n\nFind and fix the defects so the helpers honour the contract below exactly. Keep\nthe public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `deepget`. The grader imports `deepget.public` (falling back to\n  `deepget`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change signatures):\n      get(obj, path: str, default=None) -> value or default\n      set_(obj, path: str, value) -> the (possibly new) root object\n- A `path` is a `.`-separated string of segments, walked left to right, each\n  segment selecting into the CURRENT container:\n    * dict: the segment is a key. Try the raw STRING key first; only if that is\n      absent and the segment is all digits, try the INTEGER key too. (So both\n      `{\"0\": x}` and `{0: x}` are reachable via the segment `\"0\"`, string first.)\n    * list: the segment must be a non-negative integer index that is in range\n      (`0 <= i < len`). A non-numeric segment, a negative index, or an\n      out-of-range index does NOT resolve.\n    * anything else (e.g. descending into an int or string): does NOT resolve.\n  \"All digits\" means `seg.isdigit()` -- no sign, no decimal point.\n- `get(obj, path, default=None)`:\n    * Returns the resolved value when every segment resolves. A resolved value\n      of `None` is returned AS-IS -- a present `None` is a real value, NOT a\n      miss.\n    * Returns `default` if and only if some segment fails to resolve (missing\n      key, bad/negative/out-of-range index, or descending into a non-container).\n    * Never raises for an unresolvable path; it returns `default`.\n    * An empty path (`\"\"`) resolves to `obj` itself.\n- `set_(obj, path, value)`:\n    * Walks `obj` and stores `value` at the final segment, creating any missing\n      intermediate container as it goes. The type of a freshly created\n      intermediate depends on the NEXT segment: a numeric next segment creates a\n      LIST, otherwise a `dict`.\n    * Assigning into a list at an index past its end PADS the list with `None`\n      up to that index, then assigns (so `set_([], \"2\", v)` yields `[None, None, v]`).\n    * Returns the root object. For an empty path it returns `obj` unchanged.\n    * Mutates in place where possible; it must not replace an existing\n      list/dict intermediate that is already the right kind of container.\n\n## I/O example\n\n    >>> obj = {\"a\": {\"b\": [{\"c\": 1}, {\"c\": 2}]}}\n    >>> get(obj, \"a.b.1.c\")\n    2\n    >>> get(obj, \"a.b.9.c\", default=\"?\")     # index off the end -> default\n    '?'\n    >>> get(obj, \"a.b.-1.c\", default=\"?\")    # negative does NOT wrap -> default\n    '?'\n    >>> get({\"x\": None}, \"x\", default=\"?\")   # present None -> the None, not default\n    >>> get({\"2024\": {\"q\": 4}}, \"2024.q\")    # digit-string DICT key, not a list index\n    4\n    >>> set_({}, \"items.0.name\", \"hi\")       # numeric next seg -> a LIST is created\n    {'items': [{'name': 'hi'}]}\n    >>> set_([], \"2\", \"z\")                    # pad past the end with None\n    [None, None, 'z']\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "get_nested_dict",
        "desc": "get walks plain nested dict keys"
      },
      {
        "id": "get_list_index",
        "desc": "get indexes a list with a numeric segment"
      },
      {
        "id": "get_mixed",
        "desc": "get walks a mixed dict/list path to a leaf"
      },
      {
        "id": "get_missing_key",
        "desc": "a missing dict key returns default"
      },
      {
        "id": "get_missing_returns_exact_default",
        "desc": "the exact default object is returned on a miss"
      },
      {
        "id": "get_empty_path",
        "desc": "an empty path resolves to obj itself"
      },
      {
        "id": "get_present_none",
        "desc": "a present None value is returned, not the default"
      },
      {
        "id": "get_none_deep",
        "desc": "a present None deep in the tree is returned, not default"
      },
      {
        "id": "get_none_vs_missing",
        "desc": "present-None and missing-key are distinguished"
      },
      {
        "id": "get_digit_string_dict_key",
        "desc": "a digit-string dict key is reachable (not forced to a list index)"
      },
      {
        "id": "get_int_dict_key",
        "desc": "an int dict key is reachable via the digit segment"
      },
      {
        "id": "get_string_key_wins_over_int",
        "desc": "the string key is tried before the int key"
      },
      {
        "id": "get_index_out_of_range",
        "desc": "an out-of-range list index returns default (no raise)"
      },
      {
        "id": "get_negative_index",
        "desc": "a negative list index returns default (no end-wrap)"
      },
      {
        "id": "get_descend_non_container",
        "desc": "descending into a non-container returns default"
      },
      {
        "id": "get_no_raise_on_bad_path",
        "desc": "an unresolvable path never raises"
      },
      {
        "id": "set_nested_dict",
        "desc": "set_ creates nested dicts and stores the value"
      },
      {
        "id": "set_into_existing",
        "desc": "set_ mutates an existing nested dict in place"
      },
      {
        "id": "set_creates_list_intermediate",
        "desc": "a numeric next segment makes set_ create a list"
      },
      {
        "id": "set_pads_list",
        "desc": "set_ pads a list with None past its end"
      },
      {
        "id": "set_preserves_sibling",
        "desc": "set_ does not clobber a sibling container it descends through"
      },
      {
        "id": "set_roundtrip",
        "desc": "a value written by set_ is readable by get along the same path"
      }
    ],
    "num_checks": 22,
    "has_setup": true
  },
  {
    "slug": "docsearch",
    "type": "ambiguous-spec",
    "brief": "I've got a growing pile of text documents \u2014 notes, docs, transcripts, that kind of\nthing \u2014 and I want a small Python library, `docsearch`, that lets me search across\nthe whole collection and get back the documents that actually match what I'm looking\nfor.\n\nThe basic shape is: I give it a bunch of documents, then I ask it questions and it\nhands me back the ones that are relevant, best matches first. Right now I mostly grep\nthrough everything, which finds the literal string but has no sense of which hits\nmatter more, and falls apart the moment I half-remember the wording. I'd like something\nthat does better than that \u2014 where a search for a couple of words surfaces the\ndocuments that are really about them, not just the ones that happen to contain the\ncharacters somewhere.\n\nWhat I care about most is that the ranking feels sensible \u2014 when I read the top few\nresults I should believe they're the best ones \u2014 and that it stays quick and pleasant\nto use on a collection that keeps growing, since I'll be adding documents as I go. It\nshould be importable as `docsearch` and callable from my own code; if there's an\nobvious way to poke at it from the command line too, that's a nice bonus, but use your\njudgment.\n\nI'm leaving the actual design to you. Lean on the standard library where it's\nreasonable. Some tests around the searching and ranking would help me trust it, and a\nshort README with an example or two so I can see how you meant it to be used. I'd\nrather have something clean and well-considered than something that tries to do\neverything.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "eventbus",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `eventbus`: an in-memory\npublish/subscribe message bus. The package is already written, imports cleanly,\nand its core operations work: `subscribe(topic, fn)` registers a callback for an\nEXACT topic, and `publish(topic, data)` invokes every callback subscribed to\nthat exact topic, passing `(topic, data)`.\n\nTopics are dot-delimited strings of one or more non-empty segments, e.g.\n`\"order\"`, `\"order.created\"`, `\"sensor.kitchen.temp\"`.\n\nIt ships with a FIRST attempt at wildcard subscriptions that does not actually\nwork: a subscription whose topic contains a `*` or `#` is stored, but matching\nstill compares topics for plain string equality, so wildcards never fire.\n\n## Task\n\nMake wildcard subscriptions work. A subscription topic may contain wildcard\nsegments; a published topic is always concrete (a publisher never publishes to a\nwildcard).\n\n## Semantics (read carefully \u2014 this is the whole task)\n\n- `*` is a SINGLE-segment wildcard: it matches exactly one segment in that\n  position. `\"a.*\"` matches `\"a.b\"` but NOT `\"a.b.c\"` (too many segments) and\n  NOT `\"a\"` (too few). `\"*\"` matches any single-segment topic like `\"a\"`, but\n  not `\"a.b\"`. A `*` may appear in any position: `\"*.created\"` matches\n  `\"order.created\"` and `\"user.created\"`, not `\"order.created.late\"`.\n\n- `#` is a MULTI-segment wildcard: it matches ONE OR MORE trailing segments, and\n  is only meaningful as the LAST segment of a subscription. `\"a.#\"` matches\n  `\"a.b\"` and `\"a.b.c\"` and `\"a.b.c.d\"`, but NOT `\"a\"` (it requires at least one\n  segment after the prefix). `\"#\"` on its own matches any topic of one or more\n  segments (i.e. everything).\n\n- `*` and `#` are wildcards ONLY in subscription topics. In a PUBLISHED topic\n  they are ordinary literal text: publishing to `\"a.*\"` delivers only to a\n  subscriber whose subscription topic is literally `\"a.*\"` (or a wildcard that\n  matches the literal segment `*`, e.g. `\"a.*\"`'s single-`*` matches the literal\n  segment `\"*\"`), never via wildcard expansion.\n\n- DELIVERY ORDER is deterministic: when a publish matches several subscriptions,\n  the callbacks fire in the ORDER THE SUBSCRIPTIONS WERE REGISTERED (globally,\n  across all topics/patterns), regardless of whether each match was exact or via\n  a wildcard.\n\n- FIRE ONCE PER SUBSCRIPTION: each `subscribe(...)` call is one subscription and\n  fires AT MOST ONCE per matching publish, even if its pattern could be seen to\n  match in more than one way. If the SAME callable is subscribed twice (two\n  `subscribe` calls), that is two subscriptions and it is invoked twice.\n\n- Exact-topic subscriptions must keep working exactly as before.\n\n- `publish(topic, data)` returns the number of callbacks it invoked (an int).\n  `subscribe(topic, fn)` returns an opaque subscription handle.\n\n## Example\n\n    bus = EventBus()\n    seen = []\n\n    bus.subscribe(\"order.created\", lambda t, d: seen.append((\"exact\", t, d)))\n    bus.subscribe(\"order.*\",       lambda t, d: seen.append((\"star\", t, d)))\n    bus.subscribe(\"order.#\",       lambda t, d: seen.append((\"hash\", t, d)))\n\n    n = bus.publish(\"order.created\", 7)\n    # all three match \"order.created\"; they fire in subscription order:\n    assert seen == [\n        (\"exact\", \"order.created\", 7),\n        (\"star\",  \"order.created\", 7),\n        (\"hash\",  \"order.created\", 7),\n    ]\n    assert n == 3\n\n    seen.clear()\n    bus.publish(\"order.created.late\", 1)\n    # \"order.*\" does NOT match (two segments after \"order\"); only \"order.#\" does:\n    assert seen == [(\"hash\", \"order.created.late\", 1)]\n\nA subscriber whose pattern could match \"twice\" still fires once:\n\n    bus = EventBus()\n    hits = []\n    bus.subscribe(\"#\", lambda t, d: hits.append(t))   # matches everything, once\n    bus.publish(\"a.b.c\", None)\n    assert hits == [\"a.b.c\"]   # one call, not one-per-segment\n\n## Contract\n\n- Package name: `eventbus`. The grader imports `eventbus.public` (falling back\n  to `eventbus`); keep both import paths working.\n- Public class `EventBus` with methods:\n  - `subscribe(topic: str, fn) -> handle` \u2014 register `fn` for `topic` (which may\n    contain `*` / `#` wildcard segments). Returns an opaque handle.\n  - `publish(topic: str, data) -> int` \u2014 invoke every matching subscription's\n    callback as `fn(topic, data)`, in global subscription order, each at most\n    once; return the number of callbacks invoked.\n- A `*` segment matches exactly one segment; a trailing `#` matches one or more\n  trailing segments; both are wildcards only in subscription topics.\n- Standard library only. No threading requirement, no persistence.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "star_matches_one_segment",
        "desc": "'a.*' matches the one-segment-deeper topic 'a.b'"
      },
      {
        "id": "star_rejects_too_deep",
        "desc": "'a.*' does NOT match the two-deeper topic 'a.b.c'"
      },
      {
        "id": "star_rejects_too_shallow",
        "desc": "'a.*' does NOT match the bare prefix 'a'"
      },
      {
        "id": "star_middle_position",
        "desc": "'*.created' matches 'order.created' but not 'order.created.late'"
      },
      {
        "id": "star_bare_one_segment",
        "desc": "bare '*' matches a one-segment topic but not a two-segment one"
      },
      {
        "id": "hash_matches_one_trailing",
        "desc": "'a.#' matches 'a.b' (one trailing segment)"
      },
      {
        "id": "hash_matches_many_trailing",
        "desc": "'a.#' matches 'a.b.c.d' (several trailing segments)"
      },
      {
        "id": "hash_requires_at_least_one",
        "desc": "'a.#' does NOT match the bare prefix 'a' (needs >= 1 trailing)"
      },
      {
        "id": "hash_bare_matches_everything",
        "desc": "bare '#' matches any topic of one-or-more segments"
      },
      {
        "id": "fire_once_per_subscription",
        "desc": "a subscription fires at most once per publish (bare '#' over a deep topic)"
      },
      {
        "id": "same_fn_twice_fires_twice",
        "desc": "the same callable subscribed twice is two subscriptions -> two calls"
      },
      {
        "id": "wildcard_chars_literal_in_publish",
        "desc": "'*'/'#' in a PUBLISHED topic are literal, not wildcards"
      },
      {
        "id": "scenario_exact_depth_ordered",
        "desc": "mixed roster, publish 'order.created': exact+'*'+'#' fire in global order"
      },
      {
        "id": "scenario_deep_only_hash_ordered",
        "desc": "mixed roster, publish 'order.created.late': only the '#' patterns fire, in order"
      },
      {
        "id": "scenario_prefix_nothing",
        "desc": "mixed roster, publish bare 'order': '*'/'#' need >=1 deeper segment, none fire"
      },
      {
        "id": "scenario_sibling_isolation",
        "desc": "mixed roster, publish 'user.created': only the cross-cutting wildcards fire, in order"
      },
      {
        "id": "publish_returns_match_count",
        "desc": "publish returns the number of callbacks it invoked"
      },
      {
        "id": "regression_exact_delivery",
        "desc": "exact-topic subscribe/publish still delivers (and only to exact matches)"
      },
      {
        "id": "regression_exact_order_and_count",
        "desc": "exact-topic: registration-order delivery and correct return count"
      }
    ],
    "num_checks": 19,
    "has_setup": true
  },
  {
    "slug": "featureflags",
    "type": "ambiguous-spec",
    "brief": "We want a small Python library, `featureflags`, for turning bits of functionality\non and off without having to redeploy. The idea is that our code can ask \"is this\nfeature on right now?\" and get a yes or no back, so we can ship things dark, flip\nthem on when we're ready, and roll them back just as fast if they misbehave.\n\nMostly we just want a clean way to check whether a feature is enabled, but a flag\nshouldn't always have to be a flat on/off for everybody. We'd like to be able to\nturn something on for some people and not others \u2014 say, our own team first, then a\nslice of users, then everyone \u2014 and to have a flag behave differently depending on\nwhere it's running. How much of that you build in versus leave for later is up to\nyou; I'd rather see a couple of those cases done well than a switchboard of options\nhalf-wired.\n\nIt should be importable as `featureflags` and called straight from our own code.\nThe flags themselves have to live somewhere we can change without touching the\nprogram, and I should be able to look at what's currently on without digging through\ninternals. When the code asks about a flag nobody's defined, it should do something\nsane and predictable rather than blowing up a request.\n\nKeep it lean and lean on the standard library where you can. Some tests around the\nevaluation behavior would give me confidence it does what you think it does, and a\nshort README showing how it's meant to be used. I'd rather have something clean and\nwell-thought-through than something sprawling.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "flagwise",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `flagwise`.\n\nBuild a deterministic feature flag evaluator. Use only the Python standard library.\n\nExpose:\n\n```python\ndef evaluate_flag(config: dict, flag_key: str, context: dict) -> dict: ...\ndef evaluate_all(config: dict, context: dict) -> dict: ...\n```\n\nFlag config:\n\n```json\n{\n  \"flags\": {\n    \"new_checkout\": {\n      \"enabled\": true,\n      \"default\": false,\n      \"rules\": [\n        {\n          \"if\": {\"country\": {\"equals\": \"US\"}},\n          \"serve\": true\n        },\n        {\n          \"if\": {\"plan\": {\"in\": [\"pro\", \"enterprise\"]}},\n          \"rollout\": 25\n        }\n      ]\n    }\n  }\n}\n```\n\nSupport conditions:\n\n```text\nequals\nnot_equals\nin\nnot_in\nexists\ngreater_than\nless_than\nand\nor\nnot\n```\n\nRollouts must be deterministic by hashing `flag_key` and `context[\"user_id\"]`. A rollout of `25` means approximately 25 percent of users receive `true`.\n\nThe result must include:\n\n```json\n{\n  \"key\": \"new_checkout\",\n  \"value\": true,\n  \"reason\": \"rule_match\",\n  \"matched_rule_index\": 0\n}\n```\n\nInclude a CLI:\n\n```bash\npython -m flagwise eval --config flags.json --flag new_checkout --context user.json\npython -m flagwise eval-all --config flags.json --context user.json\n```\n\nInclude tests for rule ordering, disabled flags, defaults, deterministic rollout, nested boolean logic, missing context fields, and stable hashing.\n\n## Contract\n\nThis section pins the shapes the held-out oracle checks. It does not add new\nbehavior beyond the spec above; it only fixes the wire/return format so a\nconformant implementation is gradable. Anything not pinned here is free.\n\nImport path and module:\n- The package is importable as `flagwise`, and the public API lives at\n  `flagwise.public`:\n    - `evaluate_flag(config: dict, flag_key: str, context: dict) -> dict`\n    - `evaluate_all(config: dict, context: dict) -> dict`\n- The CLI is invocable as `python -m flagwise` with subcommands `eval` and\n  `eval-all` (flags exactly as shown in the spec). All CLI output is JSON on\n  stdout (a single JSON document).\n\n`evaluate_flag` return shape (the result dict), pinned:\n- `key`   -> str, equal to the `flag_key` that was evaluated.\n- `value` -> the served value. For a boolean flag this is `true`/`false`; in\n  general it is whatever the matched rule's `serve` / the flag `default`\n  resolves to. Rollouts serve `true` (hit) or fall through (miss).\n- `reason` -> a short string explaining the decision. The set of reason\n  STRINGS is not pinned beyond these distinctions, which ARE required to be\n  distinguishable from one another (any stable spelling is accepted, the\n  oracle derives the mapping):\n    - a rule matched and served            (the example uses \"rule_match\")\n    - a rule's rollout bucket was hit and served true\n    - the flag is disabled (`enabled: false`) -> serves the flag default\n    - no rule matched -> serves the flag default\n    - the flag_key is not present in the config\n- `matched_rule_index` -> int index (0-based) into the flag's `rules` list of\n  the rule that decided the value, when a rule decided it; otherwise `None`\n  (JSON `null`). For disabled flags, unmatched defaults, and unknown flags it\n  is `null`.\n\n`evaluate_all` return shape, pinned:\n- Returns a dict keyed by every flag key present in `config[\"flags\"]`. Each\n  value is the same per-flag result dict that `evaluate_flag` returns for that\n  key (same `key`/`value`/`reason`/`matched_rule_index` contract).\n\nDeterminism contract:\n- `evaluate_flag(config, flag_key, context)` is a pure function of its inputs:\n  the same `(config, flag_key, context)` MUST yield an equal result dict on\n  every call (no clocks, no RNG, no global state).\n- Rollout bucketing MUST be a deterministic function of `flag_key` and\n  `context[\"user_id\"]` only (a hash of those two values). For a fixed flag and\n  user the rollout decision is stable across calls and across processes. Over\n  many distinct `user_id`s a rollout of N serves `true` to approximately N% of\n  users (uniform bucketing; the oracle checks a tolerant band, not an exact\n  count).\n\nCondition contract (the `if` block of a rule):\n- A condition is a mapping. A leaf condition maps a context FIELD name to an\n  operator mapping, e.g. `{\"country\": {\"equals\": \"US\"}}` or\n  `{\"age\": {\"greater_than\": 18}}`. Operators: `equals`, `not_equals`, `in`,\n  `not_in`, `exists` (truthy/falsey presence test), `greater_than`,\n  `less_than`.\n- Boolean combinators `and` / `or` take a LIST of sub-conditions; `not` takes a\n  single sub-condition (or a one-element list). These may nest arbitrarily.\n- A missing context field makes a leaf condition that needs it evaluate to\n  False (never raises); `exists` returns whether the field is present.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "result_shape",
        "desc": "evaluate_flag returns a dict with key/value/reason/matched_rule_index"
      },
      {
        "id": "rule_ordering",
        "desc": "the FIRST matching rule decides; matched_rule_index points at it"
      },
      {
        "id": "disabled_flag",
        "desc": "a disabled flag serves its default and matches no rule"
      },
      {
        "id": "default_no_match",
        "desc": "when no rule matches, the flag default is served"
      },
      {
        "id": "serve_value",
        "desc": "a matched rule serves its configured value (not just True)"
      },
      {
        "id": "op_equals",
        "desc": "equals condition matches on equality and only then"
      },
      {
        "id": "op_in",
        "desc": "in / not_in conditions match set membership"
      },
      {
        "id": "op_exists",
        "desc": "exists condition tests context-field presence"
      },
      {
        "id": "op_numeric",
        "desc": "greater_than / less_than compare numerically"
      },
      {
        "id": "nested_boolean",
        "desc": "nested and / or / not combinators evaluate correctly"
      },
      {
        "id": "missing_field",
        "desc": "a missing context field makes a leaf False without raising"
      },
      {
        "id": "unknown_flag",
        "desc": "an unknown flag_key yields a structured (non-raising) result"
      },
      {
        "id": "determinism_same",
        "desc": "same (flag, context) yields an equal result across repeated calls"
      },
      {
        "id": "rollout_stable_user",
        "desc": "a rollout decision is stable per user across many calls"
      },
      {
        "id": "rollout_hash_inputs",
        "desc": "rollout depends on flag_key + user_id (a stored hash, not hash())"
      },
      {
        "id": "rollout_distribution",
        "desc": "rollout N serves ~N% of many synthetic users (tolerant band)"
      },
      {
        "id": "evaluate_all_keys",
        "desc": "evaluate_all returns one contract result per configured flag"
      },
      {
        "id": "cli_eval_json",
        "desc": "`python -m flagwise eval` emits a JSON result dict"
      },
      {
        "id": "cli_eval_all_json",
        "desc": "`python -m flagwise eval-all` emits JSON keyed by flag"
      }
    ],
    "num_checks": 19,
    "has_setup": false
  },
  {
    "slug": "formvalidate",
    "type": "ambiguous-spec",
    "brief": "We keep hand-rolling the same checks every time we accept data from a form or an\nAPI request, and it always ends up as a tangle of `if` statements that nobody\nwants to touch. I'd like a small Python library, `formvalidate`, that we can point\nat user-submitted data and get back a clear answer: is this okay, and if not,\nwhat's wrong with it?\n\nThe everyday case is the stuff you'd expect off a signup or a checkout form \u2014 a\nrequired email, a name that can't be blank, an age that has to be a number in some\nrange, a couple of fields that are only required depending on what else was filled\nin. What I care about most is that when something is invalid, whoever's on the\nother end gets back something they can actually act on \u2014 clear enough to show a\nuser or log and move on \u2014 rather than a single cryptic exception that throws away\nevery problem but the first.\n\nIt should be pleasant to describe what valid data looks like, and it shouldn't\nfall apart when the input is messier or more deeply structured than a flat handful\nof keys. I want to import `formvalidate` and call it from our own code.\n\nBeyond that, the shape is yours. Lean on the standard library, keep it small, and\nmake the choices you'd actually defend rather than piling on knobs. Some tests\naround the interesting validation cases would give me confidence it does what you\nthink it does, and a short README with an example or two so I can see how it's\nmeant to be used.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "graphbip",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 graphbip: the test suite is failing\n\nYou have an existing Python package `graphbip`, a bipartite 2-coloring routine\nfor an undirected graph. It ships with a unittest suite in\n`graphbip/test_graphbip.py`, and right now several of those tests FAIL. Fix the\ncode so that ALL the tests pass. Do not rewrite the package from scratch and do\nnot change its public API.\n\n## Symptom\n\n`two_color(graph)` tries to paint every node one of two colors (0 / 1) so that\nno edge joins two same-colored nodes, returning the `{node: color}` map on\nsuccess or `None` when the graph is not bipartite. A single connected bipartite\ngraph already colors correctly, but several other cases come out wrong:\n\n    from graphbip.public import two_color\n\n    # only the first component gets colored:\n    two_color({\"a\": {\"b\"}, \"b\": {\"a\"}, \"c\": {\"d\"}, \"d\": {\"c\"}})\n    #   EXPECTED a full 0/1 map over {a, b, c, d}\n    #   ACTUAL   {\"a\": 0, \"b\": 1}            (c and d never colored)\n\n    # an odd cycle is wrongly reported as 2-colorable:\n    two_color({\"a\": {\"b\", \"c\"}, \"b\": {\"a\", \"c\"}, \"c\": {\"a\", \"b\"}})\n    #   EXPECTED None                        (triangle is not bipartite)\n    #   ACTUAL   {\"a\": 0, \"b\": 1, \"c\": 1}    (b and c share an edge AND a color)\n\n    # a self-loop is wrongly accepted:\n    two_color({\"a\": {\"a\", \"b\"}, \"b\": {\"a\"}})\n    #   EXPECTED None                        (a is adjacent to itself)\n    #   ACTUAL   {\"a\": 0, \"b\": 1}            (the self-loop is ignored)\n\nThese defects interact: a graph whose FIRST component is a clean bipartite piece\nbut whose LATER component contains an odd cycle (or a self-loop) must still come\nback `None` \u2014 you cannot decide bipartiteness from the first component alone.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `graphbip` package:\n\n    python -m unittest graphbip.test_graphbip\n\n## Contract (must hold after your fix)\n\n* Package name stays `graphbip`; import path `graphbip` / `graphbip.public`.\n* Keep the public API exactly: `two_color(graph: dict) -> dict | None` and the\n  `GraphError` exception. Do not rename them.\n* GRAPH REPRESENTATION: `graph` is an adjacency map `{node: neighbors}` where\n  `neighbors` is an iterable (a set OR a list) of the nodes adjacent to `node`.\n  The graph is UNDIRECTED: if `b` is in `graph[a]` then `a` is in `graph[b]`.\n  Nodes can be any hashable (strings, ints, ...). The graph MAY be DISCONNECTED\n  (several separate pieces) and may contain ISOLATED nodes whose neighbor\n  iterable is empty. Every key of `graph` is a node that must appear in the\n  result.\n* SUCCESS: return a dict mapping EVERY node of `graph` to either `0` or `1` such\n  that for every edge `(u, v)`, `color[u] != color[v]`. The empty graph `{}`\n  returns an empty dict `{}`. The specific colors are not fixed (any valid\n  2-coloring is accepted), only that the assignment is complete and conflict-free.\n* FAILURE: return `None` when the graph is NOT bipartite, i.e. it contains an\n  odd-length cycle. Two cases to handle:\n    - a SELF-LOOP (`node in graph[node]`) \u2014 a node adjacent to itself is an odd\n      cycle of length 1 and is never 2-colorable;\n    - any other ODD CYCLE \u2014 e.g. a triangle a-b-c-a. The decision is over the\n      WHOLE graph: if ANY component is non-bipartite the answer is `None`, even\n      if earlier components colored cleanly.\n* A passing argument that is not a dict raises `GraphError`.\n\nExample:\n\n    # first component a-b is fine; second component c-d-e is a triangle:\n    two_color({\"a\": {\"b\"}, \"b\": {\"a\"},\n               \"c\": {\"d\", \"e\"}, \"d\": {\"c\", \"e\"}, \"e\": {\"c\", \"d\"}})\n    #   -> None     (the graph as a whole is not bipartite)\n\nStandard library only. Do not change the package name or the public\nfunction/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "single_edge",
        "desc": "a single edge a-b is 2-colorable"
      },
      {
        "id": "even_path",
        "desc": "a-b-c-d (even path) is 2-colorable"
      },
      {
        "id": "even_cycle_4",
        "desc": "a 4-cycle is 2-colorable"
      },
      {
        "id": "list_adjacency",
        "desc": "neighbor iterables may be lists, not just sets"
      },
      {
        "id": "empty_graph",
        "desc": "the empty graph returns an empty coloring"
      },
      {
        "id": "two_components",
        "desc": "two separate edges -> all four nodes colored"
      },
      {
        "id": "isolated_node",
        "desc": "an isolated node is its own component and must be colored"
      },
      {
        "id": "three_components_mixed",
        "desc": "three components (edge, path, isolated) all colored"
      },
      {
        "id": "all_isolated",
        "desc": "a graph of only isolated nodes colors every node"
      },
      {
        "id": "two_components_one_isolated",
        "desc": "edge + bigger path + isolated all colored"
      },
      {
        "id": "triangle",
        "desc": "a triangle (3-cycle) is not bipartite"
      },
      {
        "id": "five_cycle",
        "desc": "a 5-cycle (odd) is not bipartite"
      },
      {
        "id": "odd_cycle_with_tail",
        "desc": "an odd cycle with a pendant tail is not bipartite"
      },
      {
        "id": "self_loop_with_edge",
        "desc": "a self-loop on a connected node -> not bipartite"
      },
      {
        "id": "self_loop_isolated",
        "desc": "a self-loop on an otherwise isolated node -> not bipartite"
      },
      {
        "id": "good_then_triangle",
        "desc": "clean first component, odd-cycle later -> None"
      },
      {
        "id": "good_then_self_loop",
        "desc": "clean first component, self-loop later -> None"
      },
      {
        "id": "triangle_then_good",
        "desc": "odd-cycle FIRST component still -> None"
      },
      {
        "id": "two_good_then_self_loop",
        "desc": "two clean components then a self-loop -> None"
      },
      {
        "id": "non_dict_raises",
        "desc": "a non-dict graph raises GraphError"
      }
    ],
    "num_checks": 20,
    "has_setup": true
  },
  {
    "slug": "graphpath",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `graphpath`: a shortest-path\nfinder over a weighted directed graph, using Dijkstra's algorithm. The package is\nalready written, imports cleanly, and the happy path works -- on a graph where the\ngreedy first route to each node also happens to be the cheapest, it returns the\nright distance. It is used by a routing layer that asks `shortest(graph, src, dst)`\nfor the least-cost route between two nodes.\n\n## Bug report\n\nUnder real graphs the finder misbehaves, and the symptoms are easy to miss\nbecause small \"already-sorted\" example graphs look fine:\n\n  1. On graphs where a node is first reached by an EXPENSIVE edge but a CHEAPER\n     route to it exists through other nodes, the finder reports the expensive\n     distance and route -- it seems to LOCK IN the first way it stumbles onto a\n     node and never reconsiders, even when a shorter path is found a moment\n     later. The answer comes back larger than the true shortest path.\n\n  2. Asking for the route from a node to ITSELF (`src == dst`) returns the right\n     distance (0) but an empty path. It should return the one-node path\n     containing just that node.\n\n  3. When `dst` simply CANNOT be reached from `src` (no directed route exists),\n     the finder does not say so cleanly -- it hands back a bogus\n     infinite-distance result with a nonsense path instead of signalling \"no\n     route\" the way the contract requires.\n\n  4. Even when the distance is right, the returned path reads BACKWARDS --\n     from `dst` to `src` rather than from `src` to `dst`.\n\nFind and fix the defects so the finder honours the contract below exactly.\nKeep the public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `graphpath`. The grader imports `graphpath.public` (falling back\n  to `graphpath`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change the signature):\n      shortest(graph, src, dst) -> (distance, path) | None\n- Graph representation: an adjacency map `{node: {neighbor: weight}}`. Every\n  weight is a non-negative number (ints or floats; `0` is allowed). A node with\n  no outgoing edges maps to an empty dict `{}`. Nodes are any hashable key. The\n  graph is DIRECTED: an edge `a -> b` does NOT imply `b -> a`.\n- `shortest(graph, src, dst)` returns the minimum-total-weight route from `src`\n  to `dst`:\n    * On success, return the pair `(distance, path)` where `distance` is the\n      summed edge weight of the cheapest route and `path` is the list of nodes\n      from `src` to `dst` INCLUSIVE, in travel order (`path[0] == src`,\n      `path[-1] == dst`). Consecutive nodes in `path` must be joined by real\n      edges whose weights sum to exactly `distance`.\n    * A node always reaches itself: if `src == dst`, return `(0, [src])` -- the\n      single-node path -- even when that node has no outgoing edges.\n    * If `dst` is UNREACHABLE from `src` (no directed route exists), return\n      `None`. Do not return an infinite/sentinel distance or a partial path.\n- Algorithm requirement (Dijkstra correctness): a node's distance is only final\n  once it is settled as the closest un-settled node. A cheaper route discovered\n  AFTER a node was first encountered must still win -- do not freeze a node's\n  distance the first time any edge happens to reach it.\n\n## I/O example\n\n    >>> g = {\"a\": {\"b\": 1, \"c\": 4}, \"b\": {\"c\": 2, \"d\": 5}, \"c\": {\"d\": 1}, \"d\": {}}\n    >>> shortest(g, \"a\", \"d\")        # a->b->c->d = 1+2+1\n    (4, ['a', 'b', 'c', 'd'])\n    >>> shortest(g, \"a\", \"a\")        # a node reaches itself for free\n    (0, ['a'])\n    >>> shortest(g, \"d\", \"a\")        # no route out of d -> a\n    None\n    >>> # a cheaper route found LATE still wins:\n    >>> g2 = {\"a\": {\"d\": 10, \"b\": 1}, \"b\": {\"c\": 1}, \"c\": {\"d\": 1}, \"d\": {}}\n    >>> shortest(g2, \"a\", \"d\")       # a->b->c->d = 3, not the direct a->d = 10\n    (3, ['a', 'b', 'c', 'd'])\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "single_edge",
        "desc": "a one-hop graph returns (weight, [src, dst])"
      },
      {
        "id": "chain_distance",
        "desc": "a simple chain returns the summed distance"
      },
      {
        "id": "chain_path",
        "desc": "a simple chain returns the full node list in src->dst order"
      },
      {
        "id": "picks_cheaper_branch",
        "desc": "the cheaper of two branches is chosen for distance and path"
      },
      {
        "id": "path_is_forward",
        "desc": "the path runs src -> dst, not reversed"
      },
      {
        "id": "late_cheap_route_distance",
        "desc": "a cheaper route discovered LATER wins (no settle-on-discovery)"
      },
      {
        "id": "late_cheap_route_path",
        "desc": "the late-discovered cheaper route is reflected in the path"
      },
      {
        "id": "relax_after_seen",
        "desc": "a node first seen via an expensive edge is later relaxed to the cheap one"
      },
      {
        "id": "src_eq_dst_distance",
        "desc": "src == dst has distance 0"
      },
      {
        "id": "src_eq_dst_path",
        "desc": "src == dst returns the single-node path [src]"
      },
      {
        "id": "src_eq_dst_no_outgoing",
        "desc": "src == dst works for a node with no outgoing edges"
      },
      {
        "id": "unreachable_is_none",
        "desc": "an unreachable dst returns None (not inf, not a tuple)"
      },
      {
        "id": "unreachable_isolated",
        "desc": "a node with no path to dst returns None"
      },
      {
        "id": "unreachable_wrong_direction",
        "desc": "a directed edge does not imply the reverse route exists"
      },
      {
        "id": "path_endpoints",
        "desc": "the path begins at src and ends at dst"
      },
      {
        "id": "path_is_valid_walk",
        "desc": "consecutive path nodes are joined by real edges summing to the distance"
      },
      {
        "id": "multi_hop_unique",
        "desc": "a longer unique-shortest route is found exactly (distance and path)"
      },
      {
        "id": "zero_weight_edges",
        "desc": "zero-weight edges are handled without skipping or looping"
      }
    ],
    "num_checks": 18,
    "has_setup": true
  },
  {
    "slug": "hsm",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `hsm`: a finite state machine.\nThe package is already written, imports cleanly, and works: a `Machine` has a\n`current` state, you wire up transitions with `add_transition(state, event,\ntarget)`, and `fire(event)` moves the machine to the target (raising\n`UnknownEvent` if the current state has no transition for that event).\n\nToday the machine is FLAT: states have no structure, an event is handled only if\nthe CURRENT state itself defines a transition for it, and changing state does\nnothing beyond updating `current`.\n\n## Task\n\nAdd HIERARCHICAL (nested) states with event bubbling and entry/exit hooks,\nWITHOUT breaking the existing flat behavior.\n\n## Semantics (read carefully \u2014 this is the whole task)\n\n- `add_state(name, parent=None)` declares a state nested inside `parent`. States\n  form ancestor chains up to a root (a state with no parent). A state never\n  needs to be declared to be used as a flat state; only nesting needs it.\n\n- BUBBLING. `fire(event)` first looks for a transition on the CURRENT (leaf)\n  state. If the leaf defines none for that event, the event BUBBLES up the\n  parent chain: the first ancestor that defines a transition for the event wins,\n  and the machine moves to THAT transition's target. If no state in the chain\n  handles the event, raise `UnknownEvent`.\n\n- ENTRY/EXIT HOOKS. `on_enter(state, fn)` and `on_exit(state, fn)` register\n  zero-argument callbacks. On a transition from the current leaf `source` to a\n  `target`, the machine:\n    * EXITS states starting at `source` and walking UP, firing each state's exit\n      hooks, stopping BEFORE the least common ancestor (LCA) of source and\n      target \u2014 the LCA itself is NOT exited;\n    * then ENTERS states from just below the LCA DOWN to `target`, firing each\n      state's enter hooks \u2014 the LCA itself is NOT entered.\n  Exit hooks fire deepest-first (child before parent); entry hooks fire\n  shallowest-first (parent before child).\n\n- The states exited/entered are computed from the actual current LEAF state and\n  the transition's TARGET \u2014 NOT from the ancestor where the matching transition\n  was found while bubbling. (A transition declared on a parent still exits the\n  child you were actually in.)\n\n- A transition whose source and target are the SAME state is an EXTERNAL\n  self-transition: that state IS exited and re-entered (it sits below its LCA,\n  which is its parent).\n\n- If source and target are in separate trees (no common ancestor), exit every\n  state from source up to its root and enter every state from target's root down\n  to target.\n\n- `Machine.trace` is a list recording the firing order: each entry is a tuple\n  `(\"exit\", state)` or `(\"enter\", state)`, appended in the exact order hooks\n  fire, accumulated across every `fire` call. It must be present and correct\n  even for states that have no registered callbacks.\n\n## Example\n\n    m = Machine(\"a\")\n    m.add_state(\"top\")\n    m.add_state(\"a\", parent=\"top\")\n    m.add_state(\"b\", parent=\"top\")\n    m.add_transition(\"top\", \"go\", \"b\")   # 'go' is handled by the PARENT\n\n    m.fire(\"go\")                 # in 'a', no 'go' -> bubbles to 'top', target 'b'\n    assert m.current == \"b\"\n    # exit 'a' (up to LCA 'top', exclusive), enter 'b' (down from 'top', exclusive)\n    assert m.trace == [(\"exit\", \"a\"), (\"enter\", \"b\")]\n\nDeeper nesting keeps the common ancestor untouched:\n\n    m = Machine(\"a1\")\n    m.add_state(\"root\")\n    m.add_state(\"A\", parent=\"root\"); m.add_state(\"B\", parent=\"root\")\n    m.add_state(\"a1\", parent=\"A\");   m.add_state(\"b1\", parent=\"B\")\n    m.add_transition(\"a1\", \"x\", \"b1\")\n    m.trace.clear()\n    m.fire(\"x\")                  # a1 -> b1, LCA is 'root'\n    assert m.current == \"b1\"\n    # exit a1 then A; enter B then b1; 'root' is the LCA and is NOT touched\n    assert m.trace == [(\"exit\", \"a1\"), (\"exit\", \"A\"), (\"enter\", \"B\"), (\"enter\", \"b1\")]\n\n## Contract\n\n- Package name: `hsm`. The grader imports `hsm.public` (falling back to `hsm`);\n  keep both import paths working.\n- Public class `Machine(initial)` with attribute `current`, list attribute\n  `trace`, and methods: `add_transition(state, event, target)`,\n  `add_state(name, parent=None)`, `on_enter(state, fn)`, `on_exit(state, fn)`,\n  `fire(event) -> str` (returns the new `current`), and the existing\n  `reset() -> str`.\n- `UnknownEvent(Exception)` importable from the package, raised by `fire` when\n  no state in the chain handles the event.\n- A flat machine (no `add_state` calls) must behave exactly as before: `fire`\n  resolves a transition on `current`, moves there, and \u2014 with no nesting \u2014 the\n  trace for such a move is `[(\"exit\", source), (\"enter\", target)]`.\n- Standard library only. No threading requirement.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "flat_move",
        "desc": "flat fire moves current to the target"
      },
      {
        "id": "flat_unknown_event",
        "desc": "flat fire of an unhandled event raises UnknownEvent"
      },
      {
        "id": "flat_trace",
        "desc": "flat move traces exit(source) then enter(target)"
      },
      {
        "id": "bubble_to_parent",
        "desc": "event unhandled by leaf bubbles to a parent that handles it"
      },
      {
        "id": "bubble_target_from_leaf",
        "desc": "bubbled transition exits the actual LEAF, not the handling ancestor"
      },
      {
        "id": "lca_not_exited_or_entered",
        "desc": "least common ancestor is neither exited nor entered"
      },
      {
        "id": "exit_order_deepest_first",
        "desc": "exit hooks fire deepest-first up to the LCA"
      },
      {
        "id": "enter_order_shallowest_first",
        "desc": "enter hooks fire shallowest-first down to the target"
      },
      {
        "id": "self_transition_reenters",
        "desc": "external self-transition exits and re-enters the state"
      },
      {
        "id": "hook_callbacks_fire_in_order",
        "desc": "registered enter/exit callbacks run in trace order"
      },
      {
        "id": "separate_trees_full_chains",
        "desc": "transition across trees exits/enters full chains"
      },
      {
        "id": "trace_accumulates",
        "desc": "trace accumulates across multiple fire calls"
      },
      {
        "id": "unknown_event_after_bubble",
        "desc": "event no ancestor handles raises UnknownEvent"
      },
      {
        "id": "regression_flat_reset",
        "desc": "reset returns to initial; flat wiring still works"
      }
    ],
    "num_checks": 14,
    "has_setup": true
  },
  {
    "slug": "intervalmerge",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `intervalmerge`: half-open\ninterval algebra. An interval is a pair `(start, end)` meaning the half-open\nrange `start <= x < end`. The package is already written, imports cleanly, and\nthe happy path works -- two clearly-overlapping, already-sorted intervals merge,\nand a single hole in the middle of an interval splits it in two. It is used to\ncompute coverage windows: `merge` collapses a pile of ranges into canonical\nform, and `subtract` removes blocked-out ranges from available ones.\n\n## Bug report\n\nUnder real data the results are subtly wrong at the edges; coarse tests on\nclean, sorted, clearly-overlapping inputs look fine and hide it:\n\n  1. Two intervals that merely TOUCH come back as two intervals instead of one.\n     Because the ranges are half-open, `[1, 2)` and `[2, 3)` are contiguous --\n     together they cover exactly `[1, 3)` with no gap and no overlap -- and they\n     are supposed to merge into `[1, 3)`. They don't; the seam is left open.\n\n  2. If the input is not already sorted by start, `merge` produces garbage --\n     it drops or duplicates ranges -- as if it assumed the caller pre-sorted.\n     `subtract` inherits this, mangling any unsorted `a`.\n\n  3. Zero-width ranges leak through. A `[x, x)` interval covers NO points and\n     should simply vanish, but `merge` keeps it, and `subtract` manufactures\n     them: removing a chunk that is flush with an interval's edge leaves a\n     bogus `[edge, edge)` stub, and fully covering an interval yields a\n     `[x, x)` instead of nothing at all.\n\n  4. When two of the ranges being subtracted OVERLAP each other, `subtract`\n     corrupts the output -- it can even emit a reversed `(hi, lo)` interval --\n     because it lines `b` up by start but never coalesces the overlaps before\n     carving them out.\n\nFind and fix the defects so `merge` and `subtract` honour the contract below\nexactly. Keep the public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `intervalmerge`. The grader imports `intervalmerge.public`\n  (falling back to `intervalmerge`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change signatures):\n      merge(intervals) -> list[tuple]\n      subtract(a, b)   -> list[tuple]\n  where `intervals`, `a`, `b` are iterables of `(start, end)` pairs and each\n  returned list is a list of `(start, end)` tuples.\n- An interval `(start, end)` is the half-open range `start <= x < end`. A range\n  with `start == end` is ZERO-WIDTH: it covers no points and must never appear\n  in any output (neither passed through nor produced).\n- Both functions return a NORMALISED list: sorted ascending by `start`,\n  pairwise DISJOINT, and zero-width-free -- the unique minimal canonical form\n  of the point set. Neither function may mutate its input arguments.\n- `merge(intervals)`:\n    * Returns the minimal set of disjoint intervals covering exactly the same\n      points as the union of the inputs.\n    * OVERLAPPING intervals merge. TOUCHING intervals merge too: since the\n      ranges are half-open, `end == start` of the next means they are\n      contiguous (no gap), so `[1, 2)` and `[2, 3)` become `[1, 3)`. A real gap\n      (`[1, 2)` and `[3, 4)`) is preserved as two intervals.\n    * Input may be in ANY order and may contain overlaps, duplicates, and\n      zero-width ranges; the output is always canonical.\n- `subtract(a, b)`:\n    * Returns the canonical intervals covering every point in (the union of)\n      `a` that is NOT in (the union of) `b`.\n    * Where a `b` range lies strictly inside an `a` range, that `a` range is\n      SPLIT into its left and right remainders. A `b` range flush with an edge\n      trims that side with no leftover stub. A `b` range covering an `a` range\n      entirely removes it (contributing nothing).\n    * `a` and `b` may each be unsorted and may contain overlapping or\n      zero-width ranges; both are normalised before the subtraction.\n\n## I/O example\n\n    >>> from intervalmerge import merge, subtract\n    >>> merge([(2, 4), (1, 3)])         # unsorted + overlapping\n    [(1, 4)]\n    >>> merge([(1, 2), (2, 3)])         # touching half-open -> contiguous\n    [(1, 3)]\n    >>> merge([(1, 1), (2, 4)])         # zero-width [1,1) dropped\n    [(2, 4)]\n    >>> merge([(1, 2), (3, 4)])         # real gap preserved\n    [(1, 2), (3, 4)]\n    >>> subtract([(0, 10)], [(3, 5)])   # punch a hole -> split in two\n    [(0, 3), (5, 10)]\n    >>> subtract([(0, 10)], [(0, 3)])   # flush with the left edge -> no [0,0)\n    [(3, 10)]\n    >>> subtract([(0, 10)], [(0, 10)])  # fully covered -> nothing\n    []\n    >>> subtract([(0, 10)], [(3, 6), (5, 8)])  # overlapping holes coalesced\n    [(0, 3), (8, 10)]\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "merge_overlap_sorted",
        "desc": "sorted overlapping intervals merge into one"
      },
      {
        "id": "merge_nested",
        "desc": "an interval fully inside another merges to the outer"
      },
      {
        "id": "merge_gap_preserved",
        "desc": "a real gap between intervals is preserved (not merged)"
      },
      {
        "id": "merge_empty",
        "desc": "merging an empty list returns an empty list"
      },
      {
        "id": "merge_touching_halfopen",
        "desc": "touching half-open intervals [1,2)+[2,3) merge to [1,3)"
      },
      {
        "id": "merge_chain_touch",
        "desc": "a chain of touching intervals collapses to one span"
      },
      {
        "id": "merge_unsorted",
        "desc": "unsorted overlapping input is merged correctly"
      },
      {
        "id": "merge_unsorted_touch",
        "desc": "unsorted touching input is merged correctly"
      },
      {
        "id": "merge_zero_width_dropped",
        "desc": "a zero-width [x,x) input interval is dropped"
      },
      {
        "id": "merge_no_mutate",
        "desc": "merge does not mutate or reorder its input argument"
      },
      {
        "id": "subtract_single_mid_split",
        "desc": "a hole in the middle splits an interval into two"
      },
      {
        "id": "subtract_two_holes",
        "desc": "two interior holes split an interval into three pieces"
      },
      {
        "id": "subtract_flush_left",
        "desc": "a hole flush with the left edge leaves no zero-width piece"
      },
      {
        "id": "subtract_flush_right",
        "desc": "a hole flush with the right edge trims cleanly"
      },
      {
        "id": "subtract_full_cover",
        "desc": "a fully-covered interval yields nothing (no zero-width)"
      },
      {
        "id": "subtract_overlapping_holes",
        "desc": "overlapping holes in b are coalesced before carving"
      },
      {
        "id": "subtract_unsorted_a",
        "desc": "unsorted a is normalised before subtracting"
      },
      {
        "id": "subtract_empty_b",
        "desc": "subtracting nothing returns a normalised copy of a"
      },
      {
        "id": "subtract_adjacent_holes_touch",
        "desc": "touching holes carve a single contiguous gap"
      }
    ],
    "num_checks": 19,
    "has_setup": true
  },
  {
    "slug": "jobflow",
    "type": "ambiguous-spec",
    "brief": "We need a small Python library called `jobflow` for defining jobs that depend on\nother jobs and then running them in the right order.\n\nThe idea is that someone can describe a bunch of jobs \u2014 a job is basically just a\nunit of work, often wrapping a function or a command \u2014 and say which other jobs\neach one needs to have finished first. Then they hand the whole thing to jobflow\nand it figures out the order and runs everything. A \"build this, then test it,\nthen deploy it\" kind of workflow, but general enough to be useful for data\npipelines, scheduled chores, that sort of thing.\n\nI care most about it being pleasant to define jobs and their dependencies, and\nabout it being dependable when something goes wrong \u2014 a run shouldn't just silently\ndo the wrong thing. It should be importable as `jobflow` and there should be an\nobvious way to actually kick off a run, whether that's from code or the command\nline; use your judgment there.\n\nBeyond that I'm leaving the design to you. Keep it reasonably small and lean on the\nstandard library where you can. Some real tests covering the interesting cases would\nbe good, and a couple of examples in a README so I can see how it's meant to be used.\nI'd rather have something clean and well-thought-through than something sprawling.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "jsonquery",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 jsonquery: the test suite is failing\n\nYou have an existing Python package `jsonquery`, a tiny JSONPath-lite selector.\nIt ships with a unittest suite in `jsonquery/test_jsonquery.py`, and right now\nseveral of those tests FAIL. Fix the code so that ALL the tests pass. Do not\nrewrite the package from scratch and do not change its public API.\n\n## Symptom\n\n`select(obj, path)` walks a path expression over a nested dict/list structure\nand is supposed to return a flat list of every value the path selects, in\ndocument order. Simple key chains like `.a.b` already work, but the wildcard,\nthe recursive descent, and the missing-step behavior all come out wrong:\n\n    from jsonquery.public import select\n\n    doc = {\n        \"users\": [\n            {\"name\": \"ada\",   \"id\": 1, \"roles\": [{\"id\": 10}, {\"id\": 11}]},\n            {\"name\": \"linus\", \"id\": 2, \"roles\": [{\"id\": 20}]},\n        ],\n        \"owner\": {\"name\": \"grace\", \"id\": 3},\n    }\n\n    # [*] is supposed to fan out to each element, flat:\n    select(doc, \".users[*].name\")\n    #   EXPECTED [\"ada\", \"linus\"]\n    #   ACTUAL   raises / wrong \u2014 [*] keeps the list nested instead of fanning out\n\n    # ..key is recursive descent over EVERYTHING, top-down, lists included:\n    select(doc, \"..id\")\n    #   EXPECTED [1, 10, 11, 2, 20, 3]\n    #   ACTUAL   [10, 11, 1, 20, 2, 3]-ish \u2014 wrong order, and ids inside list\n    #            elements get missed entirely\n\n    # a missing key must RAISE, not quietly vanish:\n    select(doc, \".owner.missing\")\n    #   EXPECTED raises SelectError\n    #   ACTUAL   returns []   (the mismatch is silently swallowed)\n\nThese defects interact: a path like `.users[*].missing` fans out with `[*]`\nand THEN hits a missing key on each branch, and `.users[*]..id` fans out and\nTHEN recurses \u2014 so getting the combined cases right needs all three fixed.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `jsonquery` package:\n\n    python -m unittest jsonquery.test_jsonquery\n\n## Contract (must hold after your fix)\n\n* Package name stays `jsonquery`; import path `jsonquery` / `jsonquery.public`.\n* Keep the public API exactly: `select(obj, path: str) -> list` and the\n  `SelectError` exception. Do not rename them.\n* A `path` is a sequence of steps written together. The steps are:\n    - `.key`    \u2014 descend into the mapping value at `key`. Keying a non-mapping,\n      or a `key` that is absent, raises `SelectError`.\n    - `[index]` \u2014 index into a list with a non-negative integer. Indexing a\n      non-list, or an out-of-range index, raises `SelectError`.\n    - `[*]`     \u2014 fan out to EVERY element of a list, in order, FLAT: it adds\n      each element to the result frontier (it does NOT keep the list nested).\n      `[*]` on a non-list raises `SelectError`.\n    - `..key`   \u2014 recursive descent: collect the value under `key` EVERYWHERE at\n      or below the current node, in PRE-ORDER (a node is recorded before its\n      own children are scanned), and the scan descends through BOTH mapping\n      values AND list elements. `..key` never raises for \"not found\" \u2014 an empty\n      result is legal.\n  A leading `.` / `..` is optional sugar: `users[0]` and `.users[0]` are the\n  same; a leading bare `key` means `.key`.\n* `select` ALWAYS returns a `list` (never a scalar), even for a single match\n  (`.owner.name` -> `[\"grace\"]`) and even when empty (`..nope` -> `[]`).\n* Order is document order: list elements left to right, mapping values in\n  insertion order, and for `..key` a node's own match comes before the matches\n  found by recursing into that node.\n\nExample (the full interaction):\n\n    select(doc, \".users[*]..id\")\n    #   -> [1, 10, 11, 2, 20]\n    # fan out the two users, then for each collect every id at/under it in\n    # pre-order (the user's own id, then its roles' ids).\n\nStandard library only. Do not change the package name or the public\nfunction/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "simple_key_chain",
        "desc": "single match for a plain key chain"
      },
      {
        "id": "simple_returns_list",
        "desc": "a single match is still wrapped in a list"
      },
      {
        "id": "index_then_key",
        "desc": "index a list then descend a key"
      },
      {
        "id": "leading_bare_key",
        "desc": "a leading bare key is sugar for .key"
      },
      {
        "id": "deep_key_chain",
        "desc": "a deep plain key chain resolves"
      },
      {
        "id": "wildcard_terminal",
        "desc": "terminal [*] returns the elements flat, in order"
      },
      {
        "id": "wildcard_then_key",
        "desc": "[*] fans out, then .key maps over each element"
      },
      {
        "id": "wildcard_then_key_ids",
        "desc": "[*] then .id over each element"
      },
      {
        "id": "wildcard_then_index",
        "desc": "[*] fans out, then [index] into each sub-list"
      },
      {
        "id": "wildcard_double",
        "desc": "[*] after [*] fans out two levels, flat"
      },
      {
        "id": "descend_ids_preorder",
        "desc": "..id is pre-order over dicts AND lists"
      },
      {
        "id": "descend_names",
        "desc": "..name collects names top-down"
      },
      {
        "id": "descend_nested_preorder",
        "desc": "..id pre-order through nested dicts + lists"
      },
      {
        "id": "descend_from_subtree",
        "desc": ".key then ..id scans only that subtree"
      },
      {
        "id": "descend_no_match_empty",
        "desc": "..key with no match returns [] (never raises)"
      },
      {
        "id": "missing_key_raises",
        "desc": "a missing mapping key raises SelectError"
      },
      {
        "id": "index_out_of_range_raises",
        "desc": "an out-of-range index raises SelectError"
      },
      {
        "id": "key_of_non_mapping_raises",
        "desc": "keying a non-mapping raises SelectError"
      },
      {
        "id": "index_non_list_raises",
        "desc": "indexing a non-list raises SelectError"
      },
      {
        "id": "wildcard_then_missing_raises",
        "desc": "[*] fan-out then a missing key surfaces SelectError"
      },
      {
        "id": "wildcard_then_descend",
        "desc": "[*] fan-out then ..id pre-order into each element"
      },
      {
        "id": "key_wildcard_key",
        "desc": ".roles[*].id over a fanned-out user"
      }
    ],
    "num_checks": 22,
    "has_setup": true
  },
  {
    "slug": "kvtxn",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `kvtxn`: an in-memory key-value\nstore. The package is already written, imports cleanly, and its core operations\nwork: `get(key, default=None)`, `set(key, value)`, and `delete(key)`.\n\nIt ships with a FIRST, single-level attempt at transactions\n(`begin` / `commit` / `rollback`) that snapshots the whole store on `begin` and\nrestores it on `rollback`. That attempt keeps only ONE snapshot, so it does not\nnest: a second `begin` clobbers the first and the outer scope is lost.\n\n## Task\n\nReplace the flat attempt with proper NESTED transactions (savepoints). A\ntransaction can be opened inside another transaction, and each level can be\nindependently committed or rolled back.\n\n## Semantics (read carefully \u2014 this is the whole task)\n\n- `begin()` opens a new savepoint, nested inside whatever transaction is\n  currently open (if any). Transactions therefore form a stack.\n\n- `rollback()` undoes every change (`set`/`delete`) made since the MATCHING\n  `begin()` \u2014 i.e. since the most recent still-open savepoint \u2014 restoring each\n  affected key to exactly the value it held at that `begin()` (or to absent, if\n  it did not exist then). It closes that savepoint. It must NOT touch changes\n  that an ENCLOSING scope had already made before this savepoint opened.\n\n- `commit()` closes the CURRENT savepoint by FOLDING its changes into the\n  enclosing scope:\n    * If there is an enclosing (parent) transaction, the changes become part of\n      the parent. They are NOT yet durable: a later `rollback()` of the parent\n      must still undo them. In other words, committing an inner transaction does\n      not protect its changes from an outer rollback.\n    * If this is the top-level transaction (no parent), the changes become\n      durable in the store.\n\n- A nested `rollback()` must NOT discard changes that an outer scope already\n  committed/made; conversely a nested `commit()` must NOT make changes durable\n  while an outer transaction is still open.\n\n- `commit()` or `rollback()` with no transaction open is an error: raise\n  `TransactionError` (a subclass of `RuntimeError`). Importing the name\n  `TransactionError` from the package must work.\n\n- `get`/`set`/`delete` must keep working exactly as before when no transaction\n  is open (changes apply directly to the store).\n\n## Example\n\n    s = Store()\n    s.set(\"a\", 1)\n\n    s.begin()              # outer txn\n    s.set(\"a\", 2)\n    s.begin()              # inner txn, nested in outer\n    s.set(\"a\", 3)\n    s.rollback()           # undo inner only\n    assert s.get(\"a\") == 2 # back to the outer txn's value, NOT 1\n\n    s.begin()              # another inner txn\n    s.set(\"a\", 99)\n    s.commit()             # fold inner into outer: a == 99 within the outer txn\n    assert s.get(\"a\") == 99\n\n    s.rollback()           # undo the outer txn \u2014 including the folded inner change\n    assert s.get(\"a\") == 1 # all the way back to before the outer begin\n\nA delete inside a transaction is undoable too:\n\n    s = Store()\n    s.set(\"x\", 10)\n    s.begin()\n    s.delete(\"x\")\n    assert s.get(\"x\") is None\n    s.rollback()\n    assert s.get(\"x\") == 10 # the delete is undone\n\n## Contract\n\n- Package name: `kvtxn`. The grader imports `kvtxn.public` (falling back to\n  `kvtxn`); keep both import paths working.\n- Public class `Store` with methods: `get(key, default=None)`,\n  `set(key, value)`, `delete(key) -> bool` (True iff the key was present),\n  `begin()`, `commit()`, `rollback()`.\n- `TransactionError(RuntimeError)` importable from the package, raised by\n  `commit`/`rollback` when no transaction is open.\n- Standard library only. No persistence, no threading requirement.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "single_commit_durable",
        "desc": "begin; set; commit makes the change durable"
      },
      {
        "id": "single_rollback_restores",
        "desc": "begin; set; rollback restores the prior value"
      },
      {
        "id": "rollback_restores_absent",
        "desc": "rollback of a set on a NEW key removes it again"
      },
      {
        "id": "nested_rollback_inner_only",
        "desc": "nested rollback restores only the inner savepoint"
      },
      {
        "id": "nested_commit_then_outer_rollback",
        "desc": "inner commit folds to parent; outer rollback still undoes all"
      },
      {
        "id": "nested_commit_visible_in_parent",
        "desc": "after inner commit the value is visible within the outer txn"
      },
      {
        "id": "nested_rollback_keeps_outer",
        "desc": "nested rollback does not discard the outer scope's earlier change"
      },
      {
        "id": "rollback_after_delete_restores",
        "desc": "rollback restores a value deleted inside the txn"
      },
      {
        "id": "commit_after_delete_durable",
        "desc": "a delete committed at top level stays deleted"
      },
      {
        "id": "three_level_partial",
        "desc": "3 levels deep: rollback one, commit one, rollback outer rewinds all"
      },
      {
        "id": "error_commit_no_txn",
        "desc": "commit with no open transaction raises TransactionError"
      },
      {
        "id": "error_rollback_no_txn",
        "desc": "rollback with no open transaction raises TransactionError"
      },
      {
        "id": "regression_get_set_delete",
        "desc": "get/set/delete still work with no active transaction"
      },
      {
        "id": "regression_delete_return",
        "desc": "delete reports presence (True/False) with no txn"
      }
    ],
    "num_checks": 14,
    "has_setup": true
  },
  {
    "slug": "ledgercore",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `ledgercore`.\n\nBuild an event-sourced ledger with SQLite persistence. Use only the Python standard library.\n\nExpose these functions from `ledgercore.public`:\n\n```python\ndef init_db(db_path: str) -> None: ...\ndef append_event(db_path: str, event: dict) -> dict: ...\ndef get_account_balance(db_path: str, account_id: str) -> dict: ...\ndef get_account_statement(db_path: str, account_id: str) -> list[dict]: ...\ndef replay_account(db_path: str, account_id: str) -> dict: ...\ndef export_trial_balance(db_path: str) -> dict: ...\n```\n\nSupported event types:\n\n```text\naccount_opened\ndeposit_posted\nwithdrawal_posted\ntransfer_posted\nfee_charged\nadjustment_posted\n```\n\nEvents must be idempotent by `event_id`. Withdrawals and transfers must reject insufficient funds unless the account has overdraft enabled. Transfers must be atomic: either both sides post or neither does.\n\nEvery event must have:\n\n```json\n{\n  \"event_id\": \"evt_001\",\n  \"type\": \"deposit_posted\",\n  \"account_id\": \"acct_cash\",\n  \"occurred_at\": \"2026-01-01T12:00:00Z\",\n  \"amount_cents\": 10000\n}\n```\n\nStatements must be ordered by `occurred_at`, then insertion order. Replay must reconstruct the same balance as the stored projection. The system must reject duplicate event IDs with conflicting payloads but allow exact duplicate replays.\n\nInclude a CLI:\n\n```bash\npython -m ledgercore init-db --db ledger.db\npython -m ledgercore append --db ledger.db --event event.json\npython -m ledgercore balance --db ledger.db --account acct_cash\npython -m ledgercore statement --db ledger.db --account acct_cash\npython -m ledgercore trial-balance --db ledger.db\n```\n\nInclude tests for idempotency, overdraft rejection, atomic transfers, replay consistency, event ordering, and trial balance correctness.\n\n## Contract\n\n- Expose the functions from `ledgercore.public` (a `python -m ledgercore` CLI is also required). Money is integer cents.\n- `transfer_posted` events name the source account under `account_id` and the destination under `to_account_id`, moving `amount_cents` from source to destination.\n- Overdraft is enabled per account via an `overdraft` boolean on its `account_opened` event (default false). `adjustment_posted` carries a signed `amount_cents`.\n- `get_account_balance(db, acct)` returns a dict with the balance under `balance_cents`.\n- `replay_account` returns a dict whose balance (under `balance_cents`) equals the stored projection.\n- `export_trial_balance(db)` returns a dict with per-account balances and a `\"total_cents\"` grand total (the sum of all account balances).\n- Rejections (insufficient funds without overdraft; a duplicate `event_id` with a conflicting payload) are signaled by raising an exception; an exact-duplicate `event_id` replay is a no-op, not an error.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "basic_balance",
        "desc": "open+deposit+withdraw yields the correct projected balance"
      },
      {
        "id": "idempotent_replay",
        "desc": "exact-duplicate event_id replays do not double-apply"
      },
      {
        "id": "idempotent_conflict",
        "desc": "a conflicting payload under a used event_id is rejected"
      },
      {
        "id": "overdraft_reject",
        "desc": "an overdrawing withdrawal is rejected when overdraft is off"
      },
      {
        "id": "overdraft_allow",
        "desc": "an overdrawing withdrawal succeeds when overdraft is enabled"
      },
      {
        "id": "transfer_atomic_ok",
        "desc": "a valid transfer debits source and credits dest"
      },
      {
        "id": "transfer_atomic_fail",
        "desc": "an underfunded transfer posts neither leg (atomicity)"
      },
      {
        "id": "replay_consistency",
        "desc": "replay_account reproduces the stored projected balance"
      },
      {
        "id": "event_ordering",
        "desc": "statement is ordered by occurred_at then insertion order"
      },
      {
        "id": "trial_balance",
        "desc": "trial balance reconciles per-account sums and ledger total"
      },
      {
        "id": "cli_contract",
        "desc": "the `python -m ledgercore` CLI runs the commands and emits JSON"
      }
    ],
    "num_checks": 11,
    "has_setup": false
  },
  {
    "slug": "ledgerfix",
    "type": "bug-fix",
    "brief": "BUG REPORT \u2014 ledgerfix: transfers can create money / unbalance the books\n\nYou have an existing Python package `ledgerfix` (an in-memory double-entry money\nledger over integer cents). There is ONE bug. Find it and fix it. Keep the\npublic API exactly as it is; do not rewrite the package from scratch.\n\n## Symptom\n\nWhen `transfer(src, dst, amount)` is called and the SOURCE account is underfunded\n(does not hold at least `amount`), the transfer is supposed to be rejected and\nleave both balances untouched. Instead, money appears from nowhere: the\ndestination gets credited while the source is left unchanged, so the ledger's\ngrand total goes UP. The books no longer balance.\n\n## Reproduction\n\n    from ledgerfix import Ledger, InsufficientFunds\n\n    led = Ledger()\n    led.open_account(\"alice\", 100)   # alice has 100 cents\n    led.open_account(\"bob\", 0)       # bob has 0 cents\n\n    total_before = led.total_cents()  # 100\n\n    # alice only has 100; this transfer of 500 must be rejected.\n    try:\n        led.transfer(\"alice\", \"bob\", 500)\n    except InsufficientFunds:\n        pass  # expected: rejected, nothing moves\n\n    print(led.balance(\"alice\"))   # EXPECTED 100 ... ACTUAL 100\n    print(led.balance(\"bob\"))     # EXPECTED 0   ... ACTUAL 500  (!!)\n    print(led.total_cents())      # EXPECTED 100 ... ACTUAL 600  (money created!)\n\nA normal, fully-funded transfer (e.g. alice -> bob of 40 when alice has 100)\nworks fine and conserves the total \u2014 only the underfunded case is broken.\n\n## Contract (must hold after your fix)\n\n* Package name stays `ledgerfix`; import path `ledgerfix` / `ledgerfix.public`.\n* Keep the existing public API and its names:\n  - `Ledger.open_account(account, opening_cents=0)`\n  - `Ledger.deposit(account, amount_cents) -> new_balance`\n  - `Ledger.withdraw(account, amount_cents) -> new_balance`  (rejects insufficient funds)\n  - `Ledger.transfer(src, dst, amount_cents) -> None`\n  - `Ledger.balance(account) -> int`\n  - `Ledger.total_cents() -> int`\n  - `Ledger.accounts() -> dict`\n  - exceptions `LedgerError`, `UnknownAccount`, `InsufficientFunds`\n* All amounts are non-negative integer cents; accounts may never go negative.\n* `transfer` must be ATOMIC: either BOTH legs apply (source debited, destination\n  credited) or NEITHER does. An underfunded source must reject the transfer and\n  leave BOTH balances exactly as they were.\n* A valid (fully funded) transfer must move the funds and conserve the grand\n  total returned by `total_cents()`.\n* Deposits and withdrawals on a single account must keep working as before.\n\nDo not change the package name or the public function/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "deposit_basic",
        "desc": "deposit credits the account by the given cents"
      },
      {
        "id": "withdraw_basic",
        "desc": "withdraw debits a funded account by the given cents"
      },
      {
        "id": "withdraw_underfunded_rejected",
        "desc": "an underfunded withdraw raises and leaves the balance unchanged"
      },
      {
        "id": "transfer_valid_moves",
        "desc": "a fully-funded transfer moves the funds"
      },
      {
        "id": "transfer_valid_conserves_total",
        "desc": "a fully-funded transfer conserves the grand total"
      },
      {
        "id": "transfer_underfunded_atomic",
        "desc": "an underfunded transfer leaves BOTH balances untouched (both legs or neither)"
      },
      {
        "id": "transfer_underfunded_conserves_total",
        "desc": "an underfunded transfer does not change the grand total (no money created)"
      },
      {
        "id": "transfer_underfunded_dest_untouched",
        "desc": "a rejected transfer never credits the destination"
      },
      {
        "id": "transfer_exact_funds_ok",
        "desc": "a transfer of the full balance succeeds and conserves the total"
      },
      {
        "id": "books_stay_balanced_over_sequence",
        "desc": "after mixed deposits/withdrawals/transfers the total equals net external flow"
      }
    ],
    "num_checks": 10,
    "has_setup": true
  },
  {
    "slug": "lrucache",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `lrucache`: a fixed-capacity\nleast-recently-used (LRU) cache. The package is already written, imports\ncleanly, and the happy path works -- you can `put` keys, read them back with\n`get`, overwrite a value, and fill the cache up to its capacity. It is used as\nan in-memory cache in front of a slow store: hot keys should stay resident and\nthe coldest key should be the one dropped when room is needed.\n\n## Bug report\n\nUnder real traffic the cache misbehaves once it is full and entries start\ngetting evicted. The symptoms are hard to pin down because small, fill-and-read\ntests that never push past capacity look completely fine:\n\n  1. A key that is read CONSTANTLY still gets thrown out. A value the callers\n     touch on nearly every request -- clearly the hottest, most-recently-used\n     entry -- disappears from the cache anyway while colder keys survive. Reading\n     a key is supposed to mark it as freshly used.\n\n  2. When the cache makes room it drops the WRONG entry. Instead of evicting the\n     stalest key, it throws away one of the freshest -- often the very key that\n     was just inserted -- so brand-new writes vanish immediately while ancient\n     keys linger.\n\n  3. OVERWRITING an existing key doesn't seem to \"count as a use\". After you\n     re-`put` a key with a new value (the value does update correctly), that key\n     is still treated as stale and gets evicted as if it had not been touched.\n\n  4. The cache holds MORE than it should: with capacity N you can find N+1 keys\n     resident at once, and a cache built with capacity 0 -- which should store\n     nothing at all -- happily hands a value back.\n\nFind and fix the defects so the cache honours the contract below exactly. Keep\nthe public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `lrucache`. The grader imports `lrucache.public` (falling back\n  to `lrucache`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change signatures):\n      LRUCache(capacity)                       # capacity is a non-negative int\n      LRUCache.get(key) -> value | LRUCache.MISSING\n      LRUCache.put(key, value) -> None\n      LRUCache.MISSING                          # sentinel returned by get on a miss\n- The cache holds at most `capacity` entries. It must NEVER hold more than\n  `capacity` at any moment. A `capacity` of 0 means the cache stores nothing:\n  every `get` is a miss.\n- Recency model -- entries are ordered from least-recently-used (LRU) to\n  most-recently-used (MRU). A key becomes the MRU end on every SUCCESSFUL use:\n    * `get(key)` on a HIT returns the stored value AND moves that key to the MRU\n      end. A `get` on a MISS returns the `MISSING` sentinel and changes nothing\n      (it must not reorder, insert, or evict anything).\n    * `put(key, value)` for a key already present updates the stored value AND\n      moves that key to the MRU end. It is an update, not a new entry, so it\n      never evicts anyone and never changes the number of entries.\n    * `put(key, value)` for a NEW key inserts it at the MRU end. If the cache is\n      already full (`capacity` entries), the current LRU entry is evicted FIRST\n      to make room, so the count stays at `capacity`.\n- Eviction always removes the single LEAST-recently-used entry -- the one whose\n  key has gone the longest without a successful `get` or `put`. Never the MRU,\n  never a freshly-touched key.\n- `get` must not raise on a missing key; it returns `LRUCache.MISSING`.\n\n## I/O example\n\n    >>> c = LRUCache(capacity=2)\n    >>> c.put(\"a\", 1)\n    >>> c.put(\"b\", 2)\n    >>> c.get(\"a\")                  # hit: \"a\" is now most-recently-used\n    1\n    >>> c.put(\"c\", 3)               # full -> evict the LRU, which is \"b\"\n    >>> c.get(\"b\") is c.MISSING     # \"b\" was the stalest, so it is gone\n    True\n    >>> c.get(\"a\")                  # \"a\" survived because the get refreshed it\n    1\n    >>> c.get(\"c\")\n    3\n    >>> c.put(\"a\", 11)              # overwrite: updates value AND refreshes \"a\"\n    >>> c.put(\"d\", 4)              # full -> evict the LRU, which is now \"c\"\n    >>> c.get(\"c\") is c.MISSING\n    True\n    >>> c.get(\"a\")                  # the re-put kept \"a\" fresh\n    11\n\n    >>> z = LRUCache(capacity=0)    # a zero-capacity cache stores nothing\n    >>> z.put(\"x\", 1)\n    >>> z.get(\"x\") is z.MISSING\n    True\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "put_get_roundtrip",
        "desc": "a stored key reads back its value"
      },
      {
        "id": "miss_returns_sentinel",
        "desc": "an absent key returns the MISSING sentinel"
      },
      {
        "id": "update_existing_value",
        "desc": "putting an existing key overwrites its value in place"
      },
      {
        "id": "fill_to_capacity_keeps_all",
        "desc": "filling exactly to capacity keeps every entry"
      },
      {
        "id": "evict_lru_basic",
        "desc": "inserting past capacity evicts the least-recently-used key"
      },
      {
        "id": "evict_keeps_most_recent",
        "desc": "the most-recently-inserted key survives an eviction"
      },
      {
        "id": "len_never_exceeds_capacity",
        "desc": "the cache never holds more than capacity entries"
      },
      {
        "id": "get_refreshes_recency",
        "desc": "a successful get protects its key from the next eviction"
      },
      {
        "id": "get_miss_no_recency_side_effect",
        "desc": "a missing get does not alter eviction order"
      },
      {
        "id": "put_update_refreshes_recency",
        "desc": "overwriting an existing key protects it from eviction"
      },
      {
        "id": "evict_picks_true_lru_after_gets",
        "desc": "after mixed gets the evicted key is the real LRU"
      },
      {
        "id": "capacity_zero_stores_nothing",
        "desc": "a capacity-0 cache never retains an entry"
      },
      {
        "id": "capacity_one_replaces",
        "desc": "a capacity-1 cache holds only the latest key"
      },
      {
        "id": "repeated_get_hot_key_survives",
        "desc": "a repeatedly-read hot key is never evicted"
      },
      {
        "id": "eviction_sequence_order",
        "desc": "a sequence of inserts evicts keys in LRU order"
      },
      {
        "id": "update_does_not_grow",
        "desc": "overwriting an existing key does not evict anyone"
      }
    ],
    "num_checks": 16,
    "has_setup": true
  },
  {
    "slug": "luhn",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `luhn`: a validator and\ncheck-digit generator for the Luhn (mod-10) checksum -- the scheme that guards\ncredit-card numbers, IMEIs, and similar identifiers. The package is already\nwritten, imports cleanly, and the happy path works -- it validates the textbook\nexample number and rejects an obviously wrong one.\n\n## Bug report\n\nUnder real input the library quietly accepts bad numbers and rejects good ones,\nand the symptoms are length- and content-dependent, so a couple of hand-picked\nexamples look fine:\n\n  1. Validation depends on the LENGTH of the number in a way it shouldn't. Some\n     genuinely valid card numbers are rejected, while some numbers with a single\n     mistyped digit are accepted -- and which ones flip seems to track whether\n     the number has an odd or an even count of digits. It is as if the \"every\n     second digit\" doubling is being measured from the wrong end, so the wrong\n     digits get doubled whenever the length's parity changes.\n\n  2. Numbers that should validate are rejected whenever doubling a digit pushes\n     it to 10 or more. A digit like 8, once doubled to 16, is contributing the\n     wrong amount to the checksum -- the two decimal digits of the doubled value\n     are not being folded back together the way Luhn requires.\n\n  3. `check_digit` returns the wrong digit exactly when the correct answer is 0.\n     A partial number whose proper check digit is 0 instead gets a 10 (or some\n     other nonsense), and appending it produces a number that does not validate.\n     Every other check digit looks right, so the bug hides until a 0 comes up.\n\n  4. Input that contains spaces or other separators -- the way humans actually\n     write card numbers, in groups -- is mishandled, and so is empty / non-digit\n     input. Grouped numbers that should validate are rejected, and junk that\n     should be cleanly rejected instead slips through or raises.\n\nFind and fix the defects so the library honours the contract below exactly.\nKeep the public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `luhn`. The grader imports `luhn.public` (falling back to\n  `luhn`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change signatures):\n      is_valid(number: str) -> bool\n      check_digit(partial: str) -> int\n\n- The Luhn checksum, defined precisely:\n    * Take the string of digits. Walk it from the RIGHTMOST digit leftward.\n    * DOUBLE every second digit counting from the right: the rightmost digit is\n      NOT doubled, the next one to its left IS doubled, the next is not, and so\n      on. (Equivalently: 0-indexing positions from the right starting at 0, the\n      ODD-indexed positions -- 1, 3, 5, ... -- are doubled.)\n    * Whenever doubling yields a value greater than 9, fold its digits: replace\n      it with the sum of its two decimal digits, which is the same as\n      subtracting 9 (e.g. 8 -> 16 -> 1+6 = 7; 6 -> 12 -> 1+2 = 3; 9 -> 18 -> 9).\n    * Sum all the resulting values (doubled-and-folded where applicable, plain\n      otherwise).\n    * The number is VALID iff that total is a multiple of 10 (total % 10 == 0).\n\n- `is_valid(number)`:\n    * Returns True iff the cleaned digit string passes the Luhn checksum above.\n    * Separators are tolerated and ignored: ASCII spaces are stripped before\n      validating, so \"4539 1488 0343 6467\" is treated exactly like\n      \"4539148803436467\".\n    * Anything that, after stripping spaces, is EMPTY or contains a non-digit\n      character returns False (never raises). An empty string is not a valid\n      number. Note \"0\" (a single zero) is, by the checksum, valid.\n\n- `check_digit(partial)`:\n    * `partial` is the number SO FAR, without its final check digit. Return the\n      single digit (an int in 0..9) that, when APPENDED to the right of\n      `partial`, makes the whole thing pass `is_valid`.\n    * Concretely: that appended digit sits at right-position 0 (it is not\n      doubled). Compute the Luhn total of `partial` as if it had a 0 appended\n      (so `partial`'s own digits all shift one place left, changing which get\n      doubled), then the check digit is the amount needed to round that total up\n      to the next multiple of 10. When the total is already a multiple of 10 the\n      check digit is 0 (NOT 10).\n    * Spaces in `partial` are stripped just as in `is_valid`.\n\n## I/O example\n\n    >>> from luhn import is_valid, check_digit\n    >>> is_valid(\"4539148803436467\")     # a valid Visa test number\n    True\n    >>> is_valid(\"4539 1488 0343 6467\")  # same number, spaced groups\n    True\n    >>> is_valid(\"4539148803436466\")     # last digit wrong\n    False\n    >>> is_valid(\"79927398713\")          # classic 11-digit Luhn example (odd length)\n    True\n    >>> is_valid(\"0\")                    # single zero: total 0, a multiple of 10\n    True\n    >>> is_valid(\"\")                     # empty is not a number\n    False\n    >>> is_valid(\"12 34a\")               # non-digit after stripping spaces\n    False\n    >>> check_digit(\"7992739871\")        # appending 3 -> 79927398713 validates\n    3\n    >>> check_digit(\"123456781234567\")   # this partial's check digit is 0\n    0\n    >>> is_valid(\"1234567812345670\")     # ...and 0 appended validates\n    True\n\n- Standard library only.\n</content>\n</invoke>\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "textbook_valid",
        "desc": "the classic 11-digit Luhn number validates"
      },
      {
        "id": "textbook_invalid",
        "desc": "a number with one wrong digit is rejected"
      },
      {
        "id": "valid_even_length",
        "desc": "a known-valid EVEN-length (16-digit) card validates"
      },
      {
        "id": "valid_odd_length",
        "desc": "a known-valid ODD-length number validates"
      },
      {
        "id": "parity_invalid_even",
        "desc": "a one-digit-off even-length number is rejected"
      },
      {
        "id": "parity_invalid_odd",
        "desc": "a one-digit-off odd-length number is rejected"
      },
      {
        "id": "parity_nofold_valid",
        "desc": "valid numbers with NO doubled-digit>9 validate (isolates the doubling end)"
      },
      {
        "id": "parity_nofold_invalid",
        "desc": "a non-doubled-digit error in a no-fold number is rejected"
      },
      {
        "id": "fold_over_nine",
        "desc": "a number exercising doubled digits >9 scores correctly"
      },
      {
        "id": "fold_distinguishes",
        "desc": "-9 folding (not -10) is what makes the valid one valid"
      },
      {
        "id": "spaces_ignored",
        "desc": "a spaced/grouped number validates like its compact form"
      },
      {
        "id": "spaces_invalid",
        "desc": "a spaced number with a bad digit is still rejected"
      },
      {
        "id": "empty_invalid",
        "desc": "the empty string is not valid"
      },
      {
        "id": "nondigit_invalid",
        "desc": "non-digit input returns False (does not raise)"
      },
      {
        "id": "single_zero_valid",
        "desc": "the single digit '0' is valid (total 0)"
      },
      {
        "id": "check_digit_basic",
        "desc": "check_digit on a partial returns the validating digit"
      },
      {
        "id": "check_digit_zero",
        "desc": "check_digit returns 0 (not 10) when the total is a multiple of 10"
      },
      {
        "id": "check_digit_roundtrip",
        "desc": "appending check_digit makes every sampled partial valid"
      },
      {
        "id": "validity_sweep",
        "desc": "is_valid matches the reference across mixed-length samples"
      }
    ],
    "num_checks": 19,
    "has_setup": true
  },
  {
    "slug": "mergeconf",
    "type": "ambiguous-spec",
    "brief": "We keep re-solving the same problem across our services: a config that comes from a few different places, and nobody can ever say what the final, effective value actually is. I'd like a small tool, `mergeconf`, that takes configuration from several sources and merges them into one effective configuration you can hand to the rest of the app.\n\nThe sources are the usual suspects you'd expect in a deployed service \u2014 there's a baseline we ship with, something operators drop in per environment, and the last-minute overrides people pass at runtime. mergeconf should pull those together and produce the single resolved view, plus enough of a trail that when someone asks \"why is this value what it is?\" we can actually answer them instead of guessing.\n\nIt should behave sensibly with nested config, not just a flat bag of keys, and it shouldn't fall over the first time two sources disagree or hand it something shaped differently than expected. Keep it reasonably ergonomic \u2014 I want to import `mergeconf` and call it from our own code, and also be able to run it directly to inspect a merge without writing a script.\n\nDon't gold-plate it. I care more that the merge is predictable and that someone reading the result can trust it than about covering every exotic case. Use your judgment on the details; I'd rather see the choices you'd actually defend than a pile of options. Some tests around the merge behavior would give me confidence it does what you think it does.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "microapi",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `microapi`.\n\nBuild a small HTTP router on top of `http.server`. Use only the Python standard library.\n\nExpose:\n\n```python\nclass App:\n    def route(self, method: str, path: str): ...\n    def handle_request(self, method: str, path: str, headers: dict, body: bytes) -> tuple[int, dict, bytes]: ...\n```\n\nSupport route patterns:\n\n```text\n/users\n/users/{user_id}\n/files/{path:*}\n```\n\nSupport:\n\n```text\npath parameters\nquery strings\nJSON request body parsing\nJSON responses\n404 for no route\n405 for method not allowed\nstructured error responses\nmiddleware functions\n```\n\nInclude a runnable server:\n\n```bash\npython -m microapi serve --host 127.0.0.1 --port 8080\n```\n\nProvide example routes for a small in-memory todo API.\n\nInclude tests for routing precedence, path params, wildcard paths, query parsing, JSON parsing, middleware ordering, 404, 405, and error responses.\n\n## Contract\n\nThis section pins the behavior the held-out oracle grades. Anywhere the SPEC above\nleft a shape unstated, the convention below is binding. The oracle never reads your\ntests and never exercises the `serve` CLI; it drives everything in-process through\n`handle_request`. Conform to this Contract and the SPEC and you pass.\n\n### Import path\n\n- The package is importable as `microapi`.\n- `microapi.public` exposes a class named `App`.\n- Constructing the app takes no required arguments: `app = App()`.\n\n### Registering routes\n\n- `app.route(method, path)` is a decorator factory: it returns a decorator that\n  registers the wrapped function as the handler for `(method, path)` and returns the\n  function unchanged. Usage:\n\n  ```python\n  app = App()\n\n  @app.route(\"GET\", \"/users/{user_id}\")\n  def get_user(request, user_id):\n      ...\n  ```\n\n- `method` is an uppercase HTTP method string (e.g. \"GET\", \"POST\").\n- `path` is a pattern. Three segment kinds:\n  - static segment, e.g. `users` \u2014 matches that literal segment only.\n  - named parameter, e.g. `{user_id}` \u2014 matches exactly one path segment, captured\n    under the name `user_id`.\n  - trailing wildcard, e.g. `{path:*}` \u2014 matches one OR MORE remaining segments\n    (the rest of the path, slashes included), captured under the name `path`. A\n    wildcard is only valid as the final segment of a pattern.\n\n### Handler signature and how path params are delivered\n\n- A handler is called as `handler(request, **path_params)`.\n  - `request` is the first positional argument: an object (or mapping) carrying at\n    least the request method, path, headers, parsed query parameters, and parsed\n    JSON body (see \"request\" below).\n  - Each captured path parameter is passed as a KEYWORD argument whose name is the\n    parameter name in the pattern. For `/users/{user_id}` the handler receives\n    `user_id=\"...\"`. For `/files/{path:*}` the handler receives `path=\"a/b/c\"`.\n  - Path parameter values are always `str`. They are URL-decoded (percent-decoded).\n  - Wildcard values retain internal slashes and are NOT split.\n\n### The `request` object\n\nThe first handler argument exposes, by attribute access:\n\n- `request.method` -> str, the uppercase method.\n- `request.path` -> str, the request path (no query string).\n- `request.headers` -> dict, the headers passed to `handle_request` (keys as given).\n- `request.query` -> dict[str, str]: parsed query string. For a repeated key, the\n  LAST value wins. Values are URL-decoded. Empty when there is no query string.\n- `request.json` -> the parsed JSON body (dict/list/scalar) when the request body is\n  non-empty and is valid JSON; otherwise `None`. Parsing JSON never raises out of\n  `handle_request` \u2014 a malformed body yields a structured 400 (see below).\n\n### What a handler returns, and JSON response encoding\n\nA handler returns the response body as a JSON-serializable Python value (commonly a\ndict or list). The framework serializes it. Specifically:\n\n- A handler may return a value `v` -> `(200, v)` semantics: status 200, body is\n  `json.dumps(v)` UTF-8 encoded.\n- A handler may return a 2-tuple `(status, v)` -> that status, body `json.dumps(v)`.\n- The response `Content-Type` header is `application/json`.\n\n### `handle_request` return shape\n\n`app.handle_request(method, path, headers, body)` returns a 3-tuple:\n\n```python\n(status: int, headers: dict, body: bytes)\n```\n\n- `status` is the integer HTTP status code.\n- `headers` is a dict of response headers; it includes\n  `\"Content-Type\": \"application/json\"` for every response this oracle exercises.\n- `body` is `bytes` (UTF-8). For every response this oracle exercises, `body`\n  decodes to a JSON document.\n- `headers` is the dict passed by the caller (may be empty `{}`). `body` is `bytes`\n  (may be empty `b\"\"`).\n\n### Routing precedence\n\nWhen more than one registered pattern matches a path, precedence is:\n\n1. an all-static match (most specific) wins over\n2. a match that used one or more named parameters, which wins over\n3. a match that used a trailing wildcard (least specific).\n\nSo with `/users/me` (static), `/users/{user_id}` (param), and `/files/{path:*}`\nregistered, the path `/users/me` routes to the static handler, and `/users/42`\nroutes to the param handler.\n\n### 404, 405, and error-body shape\n\n- 404: no registered pattern matches the path (for any method). Status 404.\n- 405: the path matches at least one registered pattern, but NOT for the requested\n  method. Status 405.\n- Every error response (404, 405, malformed-JSON 400, and any uncaught handler\n  exception -> 500) has body that is a JSON OBJECT containing a top-level key\n  `\"error\"` whose value is a non-empty string (or an object with a non-empty\n  message). `Content-Type` is `application/json`.\n\n### Middleware\n\n- `app.use(middleware)` registers a middleware. A middleware is a callable\n  `middleware(request, call_next) -> response`, where `call_next(request)` invokes\n  the next middleware (or finally the matched handler) and returns its response.\n- Middlewares run in REGISTRATION ORDER on the way in (the first registered wraps\n  the outermost / runs first), and unwind in reverse on the way out.\n- A middleware may short-circuit by returning without calling `call_next`.\n\n### serve CLI (NOT exercised by the oracle)\n\n- `python -m microapi serve --host 127.0.0.1 --port 8080` starts the HTTP server.\n- The oracle does NOT start the server or open a socket; it tests `handle_request`\n  in-process only. The CLI's existence and exact behavior are out of grading scope.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "static_route",
        "desc": "a static route returns 200 and its JSON body"
      },
      {
        "id": "path_param",
        "desc": "a named path param is delivered to the handler as the decoded value"
      },
      {
        "id": "wildcard",
        "desc": "a trailing wildcard captures the rest of the path, slashes intact"
      },
      {
        "id": "precedence_static_over_param",
        "desc": "an all-static match beats a param match for the same path"
      },
      {
        "id": "precedence_param_over_wildcard",
        "desc": "a param match beats a wildcard match for the same path"
      },
      {
        "id": "query_parse",
        "desc": "query-string params are parsed and exposed to the handler"
      },
      {
        "id": "json_body",
        "desc": "a JSON request body is parsed and exposed to the handler"
      },
      {
        "id": "json_response",
        "desc": "responses are JSON-encoded bytes with a JSON content-type"
      },
      {
        "id": "status_passthrough",
        "desc": "a handler-chosen status code is returned verbatim"
      },
      {
        "id": "not_found_404",
        "desc": "an unmatched path returns status 404"
      },
      {
        "id": "method_not_allowed_405",
        "desc": "a matched path with a wrong method returns 405, not 404"
      },
      {
        "id": "error_body_shape",
        "desc": "404/405 bodies are JSON objects carrying an 'error' signal"
      },
      {
        "id": "middleware_order",
        "desc": "middlewares run in registration order, unwinding in reverse"
      },
      {
        "id": "middleware_short_circuit",
        "desc": "a middleware can short-circuit before the handler runs"
      }
    ],
    "num_checks": 14,
    "has_setup": false
  },
  {
    "slug": "middleware",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `middleware`: a tiny in-process\nrequest router. The package is already written, imports cleanly, and its core\noperations work: `add(path, handler)` registers a handler callable for a path,\nand `dispatch(path)` looks the path up and calls its handler with the request\n(here the request is just the path string). Dispatching an unregistered path\nraises `NotFound`.\n\nIt has NO middleware support: `dispatch` simply finds the handler and calls it.\n\n## Task\n\nAdd MIDDLEWARE: small functions, registered with `use(fn)`, that wrap AROUND the\nhandler in concentric layers \u2014 the \"onion\" model. Before-logic runs on the way\nin; after-logic unwinds on the way out.\n\n## Semantics (read carefully \u2014 this is the whole task)\n\nA middleware is a callable `fn(request, next)` where:\n\n- `request` is the request object (the path string), and\n- `next` is a zero-argument callable that runs the REST of the chain (the inner\n  layers, ending in the handler) and returns that inner response.\n\nA middleware returns the response for its layer. The usual shape is:\n\n    def example(request, next):\n        # ... before logic ...\n        response = next()      # run inner layers + handler, get their response\n        # ... after logic; may transform `response` ...\n        return response\n\n- `use(fn)` registers middleware. Middleware run in REGISTRATION ORDER on the\n  way in: the FIRST registered middleware is the OUTERMOST layer (its before-\n  logic runs first), and the handler sits at the centre. On the way out, after-\n  logic unwinds in REVERSE registration order (innermost first, outermost last).\n\n- A middleware that returns WITHOUT calling `next()` SHORT-CIRCUITS: the inner\n  layers and the handler never run, and `next()` is never reached for any layer\n  deeper than this one. But every OUTER middleware that has already run its\n  before-logic still runs its after-logic on the way back out (each is still\n  inside its own `next()` call) and still gets to transform the response.\n\n- After-logic can TRANSFORM the response: whatever a middleware returns becomes\n  the response handed back to the layer outside it. The value `dispatch` returns\n  is whatever the OUTERMOST layer returns (or the handler's response directly\n  when there is no middleware).\n\n- `next` runs the chain LAZILY from the point it is called. In particular, if a\n  middleware short-circuits BEFORE the centre is reached, the handler lookup\n  never happens \u2014 so dispatching a path with no registered handler does NOT\n  raise `NotFound` as long as some middleware short-circuits before the centre.\n  `NotFound` is only raised if the centre is actually reached for an\n  unregistered path.\n\n- Plain routes with NO middleware must behave EXACTLY as before: `dispatch`\n  finds the handler, calls it with the path, returns its response, and raises\n  `NotFound` for an unregistered path.\n\n## Example\n\n    r = Router()\n    r.add(\"/greet\", lambda req: \"hello\")\n\n    trail = []\n    def outer(request, next):\n        trail.append(\"outer-before\")\n        resp = next()\n        trail.append(\"outer-after\")\n        return resp + \"!\"\n    def inner(request, next):\n        trail.append(\"inner-before\")\n        resp = next()\n        trail.append(\"inner-after\")\n        return resp.upper()\n\n    r.use(outer)               # registered first -> outermost\n    r.use(inner)               # registered second -> inner\n\n    r.dispatch(\"/greet\")       # -> \"HELLO!\"\n    # trail == [\"outer-before\", \"inner-before\", \"inner-after\", \"outer-after\"]\n\nA short-circuiting before-middleware skips the handler but still unwinds the\nouter layer's after-logic:\n\n    r = Router()\n    r.add(\"/secret\", lambda req: \"TOP SECRET\")\n\n    def audit(request, next):\n        resp = next()\n        return f\"[audited] {resp}\"            # outer: transforms on the way out\n    def guard(request, next):\n        return \"403 Forbidden\"                # inner: short-circuits, never calls next\n\n    r.use(audit)\n    r.use(guard)\n\n    r.dispatch(\"/secret\")      # -> \"[audited] 403 Forbidden\"\n                               # handler never ran; audit's after-logic still did\n\n## Contract\n\n- Package name: `middleware`. The grader imports `middleware.public` (falling\n  back to `middleware`); keep both import paths working.\n- Public class `Router` with methods:\n    * `add(path, handler)` \u2014 register a handler callable for a path.\n    * `use(fn)` \u2014 register a middleware `fn(request, next)`.\n    * `dispatch(path) -> response` \u2014 run the middleware chain (if any) around the\n      handler for `path` and return the outermost layer's response.\n- `NotFound` (a subclass of `KeyError`) importable from the package, raised by\n  `dispatch` when the centre is reached for an unregistered path.\n- Middleware registration order defines the layering: index 0 is outermost\n  (before-logic first, after-logic last); the handler is the centre.\n- A short-circuit (returning without calling `next`) skips the handler and all\n  deeper layers, but the already-entered outer layers still run their after-logic.\n- Standard library only. No threading requirement.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "single_middleware_wraps",
        "desc": "one middleware runs before+after around the handler"
      },
      {
        "id": "before_order_registration",
        "desc": "before-logic runs in registration order (outer first)"
      },
      {
        "id": "after_order_reverse",
        "desc": "after-logic unwinds in REVERSE order (inner first, outer last)"
      },
      {
        "id": "full_onion_trail",
        "desc": "full enter/exit trail is outer-in then inner-out"
      },
      {
        "id": "response_transform_outer_wins",
        "desc": "dispatch returns the outermost layer's transformed value"
      },
      {
        "id": "short_circuit_skips_handler",
        "desc": "a before-middleware returning without next skips the handler"
      },
      {
        "id": "short_circuit_skips_deeper",
        "desc": "short-circuit skips middleware registered AFTER it (deeper)"
      },
      {
        "id": "short_circuit_runs_outer_after",
        "desc": "short-circuit still runs the OUTER layers' after-logic"
      },
      {
        "id": "short_circuit_outer_transforms",
        "desc": "outer after-logic still transforms the short-circuit response"
      },
      {
        "id": "lazy_next_no_notfound",
        "desc": "short-circuit before centre: unregistered path does NOT raise"
      },
      {
        "id": "notfound_when_centre_reached",
        "desc": "centre reached for unregistered path still raises NotFound"
      },
      {
        "id": "three_layer_order",
        "desc": "3 middleware: before 0,1,2 then after 2,1,0"
      },
      {
        "id": "regression_plain_dispatch",
        "desc": "REGRESSION: dispatch with no middleware calls the handler"
      },
      {
        "id": "regression_plain_notfound",
        "desc": "REGRESSION: unregistered path with no middleware raises NotFound"
      }
    ],
    "num_checks": 14,
    "has_setup": true
  },
  {
    "slug": "migrato",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `migrato`.\n\nBuild a SQLite migration runner. Use only the Python standard library.\n\nExpose:\n\n```python\ndef init_migration_table(db_path: str) -> None: ...\ndef discover_migrations(migrations_dir: str) -> list[dict]: ...\ndef apply_migrations(db_path: str, migrations_dir: str) -> dict: ...\ndef migration_status(db_path: str, migrations_dir: str) -> list[dict]: ...\n```\n\nMigration files are named:\n\n```text\n001_create_users.sql\n002_add_email.sql\n003_backfill_status.sql\n```\n\nEach file may contain:\n\n```sql\n-- migrate:up\nCREATE TABLE users (...);\n\n-- migrate:down\nDROP TABLE users;\n```\n\nApply migrations in numeric order. Record checksum, applied timestamp, and filename. If an applied migration file changes checksum later, report an error.\n\nInclude a CLI:\n\n```bash\npython -m migrato status --db app.db --migrations migrations/\npython -m migrato up --db app.db --migrations migrations/\n```\n\nInclude tests for ordered application, idempotency, checksum mismatch, malformed files, failed migration rollback, status reporting, and empty migration directories.\n\n## Contract\n\nThis section pins the details the SPEC above leaves open. The held-out grader checks\nBEHAVIOR against this contract; anything not pinned here is left to the implementer and\nmust not be graded.\n\n### Import path / package layout\n- The package is importable as `migrato`. The four functions are importable from\n  `migrato.public` (i.e. `from migrato.public import apply_migrations`).\n- The CLI is invokable as `python -m migrato ...` (the package has a `__main__`).\n- The package uses only the Python standard library (`sqlite3`, `hashlib`, `os`, etc.).\n\n### Migration files\n- A migration file lives in `migrations_dir` and is named `<NNN>_<slug>.sql` where the\n  leading run of digits is the numeric order key (e.g. `001`, `002`, `010`). Files are\n  applied in ascending NUMERIC order of that integer (so `2_x.sql` < `10_x.sql`), NOT\n  lexicographically. Files whose name does not begin with at least one digit are ignored\n  for ordering/application (treated as not a migration).\n- A file may contain `-- migrate:up` and `-- migrate:down` section markers. The SQL after\n  `-- migrate:up` (until `-- migrate:down` or EOF) is the \"up\" script that is executed when\n  the migration is applied. If NO `-- migrate:up` marker is present, the entire file body\n  is treated as the up script. The `-- migrate:down` section is recorded but not executed\n  by `apply_migrations`.\n\n### Checksum algorithm (PINNED)\n- The checksum of a migration is the lowercase hex `sha256` of the RAW file BYTES\n  (the whole file on disk, read in binary, not just the up-section, no normalization).\n  i.e. `hashlib.sha256(open(path,\"rb\").read()).hexdigest()`.\n\n### `init_migration_table(db_path)` -> None\n- Creates the bookkeeping table if it does not already exist. Idempotent: calling it on a\n  db that already has the table is a no-op and must not raise. `apply_migrations` and\n  `migration_status` must also work without a separate prior call to it (they ensure the\n  table themselves).\n\n### `discover_migrations(migrations_dir)` -> list[dict]\n- Returns one dict per migration file found in `migrations_dir`, in ascending numeric\n  order. Each dict MUST contain at least these keys (extra keys allowed):\n  - `\"filename\"`: the base filename, e.g. `\"001_create_users.sql\"` (basename, not a path).\n  - `\"checksum\"`: the sha256 hex string defined above.\n- An empty or missing-of-migrations directory yields `[]`.\n\n### `apply_migrations(db_path, migrations_dir)` -> dict  (PINNED return shape)\n- Applies every not-yet-applied migration, in ascending numeric order, inside the db at\n  `db_path`. Each newly applied migration's `up` SQL is executed and a bookkeeping row is\n  recorded with its filename, checksum, and an applied timestamp.\n- Idempotent: a migration already recorded as applied (matching filename + checksum) is\n  skipped, not re-run.\n- Returns a dict with AT LEAST these keys (extra keys allowed):\n  - `\"applied\"`: a `list` of the filenames (basenames, strings) applied DURING THIS call,\n    in the order applied. On a fully up-to-date db this is `[]`.\n  - `\"error\"`: `None` when the call succeeded with no checksum mismatch; otherwise a\n    truthy value (a non-empty string message OR a dict carrying the offending filename).\n- CHECKSUM-MISMATCH SEMANTICS (PINNED \u2014 error result, NOT an exception): if a migration\n  file that is ALREADY recorded as applied now has a different checksum on disk,\n  `apply_migrations` MUST NOT raise. It must return with `\"error\"` set to a truthy value\n  and MUST NOT apply any later (higher-numbered) migration in that call (the mismatched,\n  already-applied migration is not re-applied either). `\"applied\"` reflects only what was\n  actually applied before the stop.\n\n### `migration_status(db_path, migrations_dir)` -> list[dict]  (PINNED return shape)\n- Returns one dict per discovered migration, in ascending numeric order. Each dict MUST\n  contain AT LEAST these keys (extra keys allowed):\n  - `\"filename\"`: the base filename string (e.g. `\"001_create_users.sql\"`).\n  - `\"applied\"`: a `bool` \u2014 `True` iff that migration is recorded as applied in the db,\n    else `False`.\n- Calling `migration_status` against a db where the table does not yet exist returns every\n  migration with `\"applied\": False` and must not raise.\n\n### CLI (`python -m migrato`)\n- `python -m migrato status --db <path> --migrations <dir>` reports status and exits 0.\n- `python -m migrato up --db <path> --migrations <dir>` applies pending migrations and\n  exits 0 on success. Output format is left to the implementer (not graded).\n</content>\n</invoke>\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "discover_order",
        "desc": "discover_migrations returns migrations in ascending NUMERIC order"
      },
      {
        "id": "discover_checksum",
        "desc": "discover_migrations exposes a stable sha256-hex checksum per file"
      },
      {
        "id": "discover_empty",
        "desc": "an empty migrations directory discovers no migrations"
      },
      {
        "id": "apply_ordered",
        "desc": "apply_migrations applies all pending migrations in numeric order"
      },
      {
        "id": "apply_effect",
        "desc": "applied up-SQL actually runs against the db (tables created)"
      },
      {
        "id": "apply_idempotent",
        "desc": "re-running apply_migrations applies nothing the second time"
      },
      {
        "id": "status_shape",
        "desc": "migration_status returns per-file {filename, applied: bool}"
      },
      {
        "id": "status_reflects_apply",
        "desc": "migration_status flips applied False->True after apply"
      },
      {
        "id": "status_no_table",
        "desc": "migration_status on a fresh db reports all-unapplied, no crash"
      },
      {
        "id": "checksum_mismatch",
        "desc": "a changed checksum on an applied migration is signalled (no crash)"
      },
      {
        "id": "mismatch_no_partial",
        "desc": "on checksum mismatch, later migrations are NOT applied"
      },
      {
        "id": "up_marker",
        "desc": "the `-- migrate:up` section is the SQL that gets executed"
      },
      {
        "id": "cli_status_rc0",
        "desc": "`python -m migrato status` runs and exits 0"
      },
      {
        "id": "cli_up_rc0",
        "desc": "`python -m migrato up` runs, exits 0, and applies migrations"
      }
    ],
    "num_checks": 14,
    "has_setup": false
  },
  {
    "slug": "movavg",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `movavg`: a fixed-size sliding-\nwindow aggregator. The package is already written, imports cleanly, and the\nhappy path works -- you push values in with `add`, and once enough have arrived\n`mean()`, `min()` and `max()` report statistics over the most recent window.\nIt is used to summarise a live metric stream: a dashboard pushes each new\nsample into a `Window(size)` and reads back the rolling average and extremes.\n\n## Bug report\n\nThe rolling stats drift away from the true window the longer the stream runs,\nand the errors are subtle enough that a quick eyeball of a short, all-increasing\nsequence looks fine:\n\n  1. The window seems to remember one too MANY samples. After a long stream the\n     rolling average reacts more sluggishly than it should -- as if an extra,\n     already-expired sample were still being counted. A `Window(3)` fed a long\n     run behaves like it is averaging four values, not three.\n\n  2. Before the window has filled up (fewer than `size` samples seen so far) the\n     average comes out too LOW. Push two values into a `Window(5)` and the\n     reported mean is much smaller than the average of those two values -- it is\n     dividing by the full window size instead of by how many samples are\n     actually present yet.\n\n  3. `min()` / `max()` go STALE. Once the sample that held the current minimum\n     (or maximum) slides out of the window, the reported extreme does not\n     recover -- it keeps returning the long-gone value even though that sample\n     is no longer in the window. A window of recent, larger values still claims\n     its minimum is some tiny number that scrolled off ages ago.\n\n  4. The mean is reported as a truncated whole number. Feeding values whose true\n     average is fractional (e.g. 1, 2 -> 1.5) reports `1`, not `1.5`; the\n     fractional part is silently dropped, so the rolling average is biased low.\n\nFind and fix the defects so the aggregator honours the contract below exactly.\nKeep the public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `movavg`. The grader imports `movavg.public` (falling back to\n  `movavg`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change signatures):\n      Window(size)                 # size is a positive int; size <= 0 -> ValueError\n      Window.add(x) -> None        # push one value (an int or float)\n      Window.mean() -> float       # arithmetic mean of the current window\n      Window.min()                 # smallest value in the current window\n      Window.max()                 # largest value in the current window\n      len(window) -> int           # how many values the window currently holds\n- The \"current window\" is the most recent `min(N, size)` values added, where `N`\n  is the total number of `add` calls so far.\n- Capacity / eviction:\n    * The window holds AT MOST `size` values. Once it is full, each `add` evicts\n      the single OLDEST value so the count stays exactly `size` -- it never\n      retains `size + 1`. After `k >= size` adds, `len(window) == size` and the\n      window is exactly the last `size` values added, in order.\n- Partial window (before it fills): while fewer than `size` values have been\n  added, the window holds all of them and every statistic is computed over those\n  present values only -- e.g. `mean()` divides by the count actually present\n  (`len(window)`), NOT by `size`.\n- `mean()`:\n    * Returns the EXACT arithmetic mean as a float (real division, no rounding\n      or truncation): the mean of `1` and `2` is `1.5`, not `1`.\n    * Calling `mean()` on an empty window (no values added yet) raises\n      `ValueError`.\n- `min()` / `max()`:\n    * Return the smallest / largest value among the values CURRENTLY in the\n      window. When the value that held the extreme is evicted, the result must\n      reflect the remaining window -- a stale extreme from an evicted sample is\n      never returned.\n    * Calling either on an empty window raises `ValueError`.\n\n## I/O example\n\n    >>> w = Window(3)\n    >>> w.add(10)\n    >>> w.mean()                  # partial window: mean of [10]\n    10.0\n    >>> w.add(20)\n    >>> w.mean()                  # partial: mean of [10, 20], not /3\n    15.0\n    >>> w.add(30)\n    >>> w.mean(), w.min(), w.max()\n    (20.0, 10, 30)\n    >>> w.add(40)                 # full -> evict 10; window is [20, 30, 40]\n    >>> len(w)\n    3\n    >>> w.mean(), w.min(), w.max()\n    (30.0, 20, 40)\n    >>> w.add(5); w.add(6)        # window is now [40, 5, 6]\n    >>> w.min(), w.max()          # 20/30 evicted; extreme must recover\n    (5, 40)\n    >>> Window(2).add(1) or Window(2)  # mean of [1, 2] is 1.5, not 1\n    >>> u = Window(2); u.add(1); u.add(2); u.mean()\n    1.5\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "basic_full_mean",
        "desc": "a filled window reports the mean of exactly the last `size` values"
      },
      {
        "id": "basic_min_max",
        "desc": "min/max over a simple filled window are correct"
      },
      {
        "id": "len_tracks_count",
        "desc": "len() is the count present: < size while filling, == size once full"
      },
      {
        "id": "evicts_to_size",
        "desc": "after many adds the window holds exactly `size`, not `size+1`"
      },
      {
        "id": "rolling_mean_window",
        "desc": "the rolling mean uses only the last `size` values (no stale extra)"
      },
      {
        "id": "partial_mean_two",
        "desc": "a partial window means over the values present, not over `size`"
      },
      {
        "id": "partial_mean_one",
        "desc": "a single value gives mean == that value (divide by 1, not size)"
      },
      {
        "id": "partial_then_full",
        "desc": "mean is right both before and after the window first fills"
      },
      {
        "id": "min_recovers_after_evict",
        "desc": "min recovers once the sample holding it is evicted"
      },
      {
        "id": "max_recovers_after_evict",
        "desc": "max recovers once the sample holding it is evicted"
      },
      {
        "id": "extreme_tracks_window",
        "desc": "min/max reflect the live window across a long shifting stream"
      },
      {
        "id": "fractional_mean",
        "desc": "a fractional mean is returned exactly (1,2 -> 1.5), not truncated"
      },
      {
        "id": "fractional_mean_float",
        "desc": "mean returns a float type, not a truncated int"
      },
      {
        "id": "negative_values",
        "desc": "min/max/mean are correct with negative values in the window"
      },
      {
        "id": "size_one_window",
        "desc": "a size-1 window always reflects only the most recent value"
      },
      {
        "id": "empty_raises",
        "desc": "mean/min/max on an empty window raise (no value yet)"
      }
    ],
    "num_checks": 16,
    "has_setup": true
  },
  {
    "slug": "notifyhub",
    "type": "ambiguous-spec",
    "brief": "We send notifications to people from all over our codebase, and right now every\nservice does it slightly differently and badly. I'd like to pull that together into\na small Python package, `notifyhub`, that takes a message meant for some person and\nactually gets it delivered to them.\n\nThe thing I keep wanting is to hand it a recipient and a message and have it sorted \u2014\nthe same call should be able to reach someone however we reach them, whether that's\nan email, a text, a ping to some webhook, or just a line in a log while we're\ndeveloping. I don't want callers to care which one it is or to rewrite anything when\nwe add another way to reach people later. And when a send doesn't go through, I want\nthat to be something we can see and reason about, not a thing that quietly vanishes.\n\nWe're not wiring up real email or SMS providers in this pass, so do whatever makes\nsense to stand that part in for now. Beyond that I'm leaving the shape to you \u2014 how a\nmessage gets pointed at the right channel, what happens on a failure, how much a\nmessage can carry \u2014 those are your calls. I'd rather see the design you'd defend than\na switchboard of options.\n\nIt should import as `notifyhub` and there should be an obvious way to actually fire a\nnotification, from code or otherwise; use your judgment. Keep it lean, lean on the\nstandard library, and give me some tests around the parts that matter so I can trust\nit does what you think it does.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "orderplane",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `orderplane`.\n\nBuild a self-contained order processing simulator with SQLite persistence, a public API layer, a warehouse summary layer, an admin summary layer, and analytics export. Use only the Python standard library.\n\nExpose from `orderplane.public`:\n\n```python\ndef init_db(db_path: str) -> None: ...\ndef load_catalog(db_path: str, catalog_path: str) -> None: ...\ndef place_order(db_path: str, order: dict) -> dict: ...\ndef cancel_order(db_path: str, order_id: str, reason: str) -> dict: ...\ndef fulfill_order(db_path: str, order_id: str, shipped_at: str) -> dict: ...\ndef customer_order_view(db_path: str, order_id: str) -> dict: ...\ndef admin_order_view(db_path: str, order_id: str) -> dict: ...\ndef warehouse_picklist(db_path: str, date: str) -> list[dict]: ...\ndef export_revenue(db_path: str, month: str) -> list[dict]: ...\n```\n\n`load_catalog` reads a catalog JSON file; `place_order` receives an order dict. These shapes (prices are integer cents):\n\n```json\n// catalog.json\n{\n  \"tax_rate\": 0.10,\n  \"shipping\": {\n    \"taxed\":   {\"fee\": 1000, \"taxable\": true},\n    \"untaxed\": {\"fee\": 1000, \"taxable\": false},\n    \"free\":    {\"fee\": 0,    \"taxable\": false}\n  },\n  \"discount_codes\": {\n    \"PCT10\":  {\"type\": \"percent\", \"value\": 10},\n    \"AMT500\": {\"type\": \"amount\",  \"value\": 500}\n  },\n  \"products\": [\n    {\"sku\": \"AAA\", \"name\": \"Alpha\", \"price\": 1000, \"inventory\": 10}\n  ]\n}\n```\n\n```json\n// order dict (discount_code and shipping_method optional; shipping_method keys into catalog.shipping)\n{\"client_order_id\": \"c1\", \"items\": [{\"sku\": \"AAA\", \"qty\": 2}], \"discount_code\": \"PCT10\", \"shipping_method\": \"taxed\"}\n```\n\nThe logic (how discounts, tax, shipping, inventory, idempotency, and cancellation behave) is up to you to derive from the rules below.\n\nThe system must support:\n\n```text\nproducts\ninventory\norders\ndiscount codes\nsales tax\nshipping fees\norder cancellation\npartial fulfillment\nidempotent order submission by client_order_id\n```\n\nRules:\n\n```text\nInventory reservation happens when an order is placed.\nDiscounts apply before tax.\nShipping fees are taxable only when the catalog says they are.\nCanceled unfulfilled items release inventory.\nFulfilled items cannot be canceled retroactively.\nRevenue export must use finalized fulfilled order data, not recalculated cart data.\nCustomer view, admin view, warehouse picklist, and revenue export must agree on canonical order state.\n```\n\nImplement a CLI:\n\n```bash\npython -m orderplane init-db --db orders.db\npython -m orderplane load-catalog --db orders.db --catalog catalog.json\npython -m orderplane place-order --db orders.db --order order.json\npython -m orderplane cancel --db orders.db --order order_1 --reason customer_request\npython -m orderplane fulfill --db orders.db --order order_1 --at 2026-01-02T12:00:00Z\npython -m orderplane customer-view --db orders.db --order order_1\npython -m orderplane admin-view --db orders.db --order order_1\npython -m orderplane picklist --db orders.db --date 2026-01-02\npython -m orderplane export-revenue --db orders.db --month 2026-01\n```\n\nAll CLI output must be JSON.\n\nInclude tests runnable with:\n\n```bash\npython -m unittest discover\n```\n\nTests must cover inventory reservation, idempotent order placement, discounts, tax, taxable and non-taxable shipping, cancellation, partial fulfillment, revenue export, and agreement across customer/admin/warehouse/analytics surfaces.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "reservation",
        "desc": "placing an order reserves inventory (over-reservation rejected)"
      },
      {
        "id": "idempotent",
        "desc": "resubmitting the same client_order_id yields the same order"
      },
      {
        "id": "discount_before_tax",
        "desc": "discount lowers the taxable base (tax computed after discount)"
      },
      {
        "id": "amount_discount",
        "desc": "a fixed-amount discount code reduces the order total"
      },
      {
        "id": "taxable_shipping",
        "desc": "shipping fee is taxed only when the catalog flags it taxable"
      },
      {
        "id": "cancel_releases",
        "desc": "canceling an unfulfilled order releases reserved inventory"
      },
      {
        "id": "no_cancel_after_fulfill",
        "desc": "a fulfilled order cannot be canceled retroactively"
      },
      {
        "id": "revenue_fulfilled_only",
        "desc": "revenue export includes only fulfilled orders"
      },
      {
        "id": "revenue_matches_finalized",
        "desc": "exported revenue equals the order's finalized total"
      },
      {
        "id": "cross_surface",
        "desc": "customer/admin/warehouse/revenue surfaces agree on canonical state"
      },
      {
        "id": "cli_json_contract",
        "desc": "CLI subcommands emit JSON and drive canonical state"
      },
      {
        "id": "cli_picklist_export_json",
        "desc": "CLI picklist and export-revenue emit JSON lists"
      }
    ],
    "num_checks": 12,
    "has_setup": false
  },
  {
    "slug": "patchwise",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `patchwise`.\n\nBuild a line-based diff and patch tool. Use only the Python standard library.\n\nExpose:\n\n```python\ndef unified_diff(old: str, new: str, fromfile: str = \"old\", tofile: str = \"new\") -> str: ...\ndef apply_patch(old: str, patch: str) -> str: ...\n```\n\nGenerate unified diffs with context lines. Apply unified diffs to old content. Detect failed patches and report structured errors.\n\nSupport files with and without trailing newlines.\n\nInclude a CLI:\n\n```bash\npython -m patchwise diff old.txt new.txt\npython -m patchwise apply old.txt patch.diff --out new.txt\n```\n\nDo not shell out to system `diff` or `patch`.\n\nInclude tests for additions, deletions, replacements, multiple hunks, context mismatch, trailing newline behavior, empty files, and round-trip diff/apply.\n\n## Contract\n\nThis section pins the behavioral contract the held-out oracle grades. It binds\nimport paths and observable behavior only; it does NOT pin internal file layout,\nhelper names, or the exact diff TEXT a correct implementation emits.\n\nImport path / entry points:\n- Public API lives at the import path `patchwise.public`.\n- The CLI is invoked as `python -m patchwise` (i.e. a `patchwise.__main__`).\n\n`unified_diff(old, new, fromfile=\"old\", tofile=\"new\") -> str`:\n- Returns a unified-diff string (the standard `--- / +++ / @@ ... @@` format with\n  context lines). The string MUST be parseable by `apply_patch`.\n- When `old == new`, the returned diff applied to `old` MUST yield `old`\n  unchanged (an empty diff is acceptable).\n\n`apply_patch(old, patch) -> str`:\n- On SUCCESS returns the patched string (the new content).\n- The ROUND-TRIP invariant is the contract: for any `old`, `new`,\n  `apply_patch(old, unified_diff(old, new)) == new` exactly (byte-for-byte,\n  including trailing-newline behavior).\n- FAILED PATCH (context mismatch \u2014 the patch's context/removed lines do not match\n  `old`): the implementation MUST signal the failure via a STRUCTURED error.\n  PINNED MECHANISM: `apply_patch` RAISES a CUSTOM (non-builtin) exception on a failed\n  patch, exported from `patchwise.public` (accessible as `patchwise.public.<Name>` \u2014\n  any name, e.g. `PatchError` or `DiffError`). A failed patch MUST NOT silently return\n  wrong/garbage content and MUST NOT raise a bare `KeyError`/`IndexError`/`TypeError`\n  leaking internals.\n\nTrailing newline:\n- Files with and without a trailing newline are both supported, and the\n  round-trip invariant holds for both (i.e. a file lacking a final newline\n  round-trips back to lacking one; a file with one round-trips back with one).\n\nEmpty files:\n- `old` and/or `new` may be the empty string `\"\"`; round-trip still holds.\n\nCLI (`python -m patchwise`):\n- `python -m patchwise diff <old> <new>` reads the two files and writes a unified\n  diff to STDOUT.\n- `python -m patchwise apply <old> <patch> --out <new>` reads `<old>` and the\n  patch file `<patch>`, applies the patch, and writes the result to the file\n  named by `--out`.\n- The diff produced by `diff` MUST be applyable by `apply` to reproduce the new\n  file (CLI round-trip).\n\nFairness note (most important): a model's exact diff TEXT may legitimately differ\nfrom the reference's (different context-line counts, hunk headers, ordering of\nequal hunks, etc.). The oracle therefore verifies ROUND-TRIP BEHAVIOR\n(`apply(old, unified_diff(old, new)) == new`) and that a hand-written, standard\nunified diff applies correctly \u2014 it NEVER demands string-equality against any\nparticular diff text.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "roundtrip_addition",
        "desc": "round-trip holds when lines are added"
      },
      {
        "id": "roundtrip_deletion",
        "desc": "round-trip holds when lines are deleted"
      },
      {
        "id": "roundtrip_replace",
        "desc": "round-trip holds when lines are replaced"
      },
      {
        "id": "roundtrip_multi_hunk",
        "desc": "round-trip holds across multiple separated hunks"
      },
      {
        "id": "roundtrip_no_trailing_nl",
        "desc": "round-trip preserves a missing final newline"
      },
      {
        "id": "roundtrip_add_trailing_nl",
        "desc": "round-trip preserves added/kept trailing newline"
      },
      {
        "id": "roundtrip_empty_old",
        "desc": "round-trip holds when old is the empty string"
      },
      {
        "id": "roundtrip_empty_new",
        "desc": "round-trip holds when new is the empty string"
      },
      {
        "id": "roundtrip_identical",
        "desc": "diff of identical content round-trips unchanged"
      },
      {
        "id": "apply_handwritten_diff",
        "desc": "a hand-written standard unified diff applies correctly"
      },
      {
        "id": "diff_is_string",
        "desc": "unified_diff returns a string in unified-diff shape"
      },
      {
        "id": "context_mismatch_raises_patch_exc",
        "desc": "failed patch raises a 'Patch'-named exception from patchwise.public"
      },
      {
        "id": "context_mismatch_not_silent",
        "desc": "failed patch never silently returns wrong content"
      },
      {
        "id": "cli_diff_emits_diff",
        "desc": "`python -m patchwise diff` writes a unified diff to stdout"
      },
      {
        "id": "cli_roundtrip",
        "desc": "CLI diff then apply --out reproduces the new file"
      }
    ],
    "num_checks": 15,
    "has_setup": false
  },
  {
    "slug": "pctstats",
    "type": "bug-fix",
    "brief": "You are given an existing Python package, `pctstats`, a small descriptive-statistics\nlibrary. It has a bug. Fix it. Do not rewrite the library or change its public API \u2014\nmake the smallest change that makes the behaviour correct.\n\n## Bug report\n\nHigh percentiles come out too high. `percentile(values, p)` is supposed to use the\nnearest-rank method, but for large `p` (p90, p95, p99) it returns a value one\nposition too far up the sorted data \u2014 and on skewed data p95 comes back as the\nmaximum, which is clearly wrong.\n\nRepro:\n\n    >>> from pctstats import percentile\n    >>> data = [1] * 19 + [100000]      # 20 values: nineteen 1s and a single outlier\n    >>> percentile(data, 95)\n    100000                              # WRONG \u2014 p95 should be a small value (1),\n                                        # not the lone outlier / maximum\n    >>> percentile([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 30)\n    4                                   # WRONG \u2014 nearest-rank p30 of 1..10 is 3\n\nThe low end and the exact endpoints look fine; it's the ranks in between that are\noff, and the error compounds at the top because the result saturates at the maximum.\n\n`mean`, `minimum`, and `maximum` are correct and should stay correct.\n\n## Contract\n\n- Package name stays `pctstats`; keep the public API:\n  `percentile(values, p)`, `mean(values)`, `minimum(values)`, `maximum(values)`.\n- `percentile` uses the **nearest-rank** method (no interpolation):\n  `rank = ceil(p / 100 * n)`, **1-based**, and the result is the value at that rank\n  in the ascending-sorted data. The rank is clamped to `[1, n]`.\n- `p` is a percentage in `[0, 100]`; values outside that range are clamped.\n  `p = 0` returns the minimum; `p = 100` returns the maximum.\n- An empty input sequence raises `ValueError` (already the case \u2014 keep it).\n- Pure standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "p95_skewed_not_max",
        "desc": "p95 on [1]*19+[100000] is the small value 1, not the 100000 maximum"
      },
      {
        "id": "p50_skewed",
        "desc": "p50 on the skewed list is 1"
      },
      {
        "id": "p99_skewed",
        "desc": "p99 on the skewed list reaches the outlier 100000"
      },
      {
        "id": "p30_ten",
        "desc": "nearest-rank p30 of 1..10 is 3"
      },
      {
        "id": "p50_ten",
        "desc": "nearest-rank p50 of 1..10 is 5"
      },
      {
        "id": "p90_ten",
        "desc": "nearest-rank p90 of 1..10 is 9"
      },
      {
        "id": "p100_is_max",
        "desc": "p100 of 1..10 is the maximum 10"
      },
      {
        "id": "p0_is_min",
        "desc": "p0 of 1..10 is the minimum 1"
      },
      {
        "id": "single_value",
        "desc": "percentile of a single-element list is that element for any p"
      },
      {
        "id": "mean_correct",
        "desc": "mean of 1..10 is 5.5"
      },
      {
        "id": "minimum_correct",
        "desc": "minimum of the skewed list is 1"
      },
      {
        "id": "maximum_correct",
        "desc": "maximum of the skewed list is 100000"
      }
    ],
    "num_checks": 12,
    "has_setup": true
  },
  {
    "slug": "permgen",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 permgen: the test suite is failing\n\nYou have an existing Python package `permgen`, a tiny utility for the\nlexicographic permutations of a list of DISTINCT items. It ships with a unittest\nsuite in `permgen/test_permgen.py`, and right now several of those tests FAIL.\nFix the code so that ALL the tests pass. Do not rewrite the package from scratch\nand do not change its public API.\n\n## Symptom\n\nThe package addresses permutations by RANK: list every permutation of `items` in\nlexicographic order, numbered from 0. `nth_permutation(items, n)` is supposed to\nreturn the rank-`n` permutation, and `permutation_rank(perm, items)` is supposed\nto be its exact inverse. The identity (rank 0) works, but almost everything else\nis wrong:\n\n    from permgen.public import nth_permutation, permutation_rank\n\n    # rank 0 is fine \u2014 the items in their given order:\n    nth_permutation([\"a\", \"b\", \"c\", \"d\"], 0)\n    #   EXPECTED ['a', 'b', 'c', 'd']\n    #   ACTUAL   ['a', 'b', 'c', 'd']   (correct)\n\n    # but other ranks decode the wrong permutation:\n    nth_permutation([1, 2, 3], 4)\n    #   EXPECTED [3, 1, 2]\n    #   ACTUAL   [1, 3, 2]              (decodes the wrong digits)\n\n    # and rank is not the inverse of nth_permutation:\n    permutation_rank([\"b\", \"a\", \"c\", \"d\"], [\"a\", \"b\", \"c\", \"d\"])\n    #   EXPECTED 6\n    #   ACTUAL   11                     (counts against the wrong remaining set)\n\nThese defects interact: a round-trip `permutation_rank(nth_permutation(items,\nn), items)` should give back `n` for every `n`, but right now it does not \u2014 you\nhave to fix all three to make the two functions exact inverses again.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `permgen` package:\n\n    python -m unittest permgen.test_permgen\n\n## Contract (must hold after your fix)\n\n* Package name stays `permgen`; import path `permgen` / `permgen.public`.\n* Keep the public API exactly: `nth_permutation(items, n) -> list`,\n  `permutation_rank(perm, items) -> int`, and the `PermError` exception. Do not\n  rename them.\n* `items` is a sequence of DISTINCT items, taken in the given order as the\n  lexicographic alphabet (so `items` itself is the smallest permutation, rank 0).\n* `nth_permutation(items, n)`:\n    - `n` is a 0-indexed rank with `0 <= n < len(items)!`; an `n` outside that\n      range (or a non-int `n`) raises `PermError`. `nth_permutation([], 0)`\n      returns `[]`.\n    - Returns a NEW list (the input `items` is not mutated).\n    - `nth_permutation(items, 0)` is always `list(items)` (the identity).\n    - Permutations are enumerated in LEXICOGRAPHIC order by the position of each\n      item in `items`. The decoding is FACTORADIC: the digit for the step with\n      `i` items still available has place value `(i-1)!` and is an index into the\n      list of REMAINING (not-yet-used) items.\n* `permutation_rank(perm, items)`:\n    - `perm` must be a permutation of `items` (a `perm` whose length differs from\n      `items`, or that contains an item not in `items`, raises `PermError`).\n    - Returns the 0-indexed rank, so `permutation_rank(list(items), items) == 0`.\n    - It is the EXACT INVERSE of `nth_permutation`: for every valid `n`,\n      `permutation_rank(nth_permutation(items, n), items) == n`, and for every\n      permutation `perm`, `nth_permutation(items, permutation_rank(perm, items))\n      == list(perm)`.\n\nExample (the two are exact inverses):\n\n    items = [\"a\", \"b\", \"c\", \"d\"]\n    nth_permutation(items, 5)            # -> ['a', 'd', 'c', 'b']\n    permutation_rank(['a', 'd', 'c', 'b'], items)   # -> 5\n    nth_permutation(items, 23)           # -> ['d', 'c', 'b', 'a']  (the last one)\n    permutation_rank(['d', 'c', 'b', 'a'], items)   # -> 23\n\nStandard library only (`math`). Do not change the package name or the public\nfunction/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "identity_nth_4",
        "desc": "nth(items, 0) is the identity (4 items)"
      },
      {
        "id": "identity_nth_3",
        "desc": "nth(items, 0) is the identity (3 items)"
      },
      {
        "id": "identity_nth_5",
        "desc": "nth(items, 0) is the identity (5 items)"
      },
      {
        "id": "nth_4_r1",
        "desc": "nth rank 1 of 4 items"
      },
      {
        "id": "nth_4_r5",
        "desc": "nth rank 5 of 4 items"
      },
      {
        "id": "nth_4_r11",
        "desc": "nth rank 11 of 4 items"
      },
      {
        "id": "nth_4_r23_last",
        "desc": "nth last rank (fully reversed) of 4 items"
      },
      {
        "id": "nth_4_r2",
        "desc": "nth rank 2 of 4 items"
      },
      {
        "id": "nth_4_r17",
        "desc": "nth rank 17 of 4 items"
      },
      {
        "id": "nth_3_r4",
        "desc": "nth rank 4 of 3 items"
      },
      {
        "id": "nth_5_r50",
        "desc": "nth rank 50 of 5 items"
      },
      {
        "id": "nth_5_r119_last",
        "desc": "nth last rank of 5 items"
      },
      {
        "id": "nth_enumerate_4",
        "desc": "nth decodes every rank of 4 items correctly"
      },
      {
        "id": "rank_identity_4",
        "desc": "rank of the identity is 0 (4 items)"
      },
      {
        "id": "rank_4_a",
        "desc": "rank of ['a','b','d','c']"
      },
      {
        "id": "rank_4_b",
        "desc": "rank of ['b','a','c','d']"
      },
      {
        "id": "rank_4_c",
        "desc": "rank of ['c','a','b','d']"
      },
      {
        "id": "rank_4_last",
        "desc": "rank of the fully reversed 4-item list"
      },
      {
        "id": "rank_3",
        "desc": "rank of [3,1,2] over [1,2,3]"
      },
      {
        "id": "rank_enumerate_4",
        "desc": "rank assigns the right index to every permutation of 4 items"
      },
      {
        "id": "rank_identity_5",
        "desc": "rank of the identity is 0 (5 items)"
      },
      {
        "id": "round_trip_nth_then_rank",
        "desc": "rank(nth(items, n)) == n for all n (4 items)"
      },
      {
        "id": "round_trip_rank_then_nth",
        "desc": "nth(items, rank(perm)) == perm for all perms (4 items)"
      },
      {
        "id": "round_trip_5",
        "desc": "rank(nth(items, 77)) == 77 (5 items)"
      },
      {
        "id": "nth_out_of_range_raises",
        "desc": "n >= len(items)! raises PermError"
      },
      {
        "id": "nth_empty_list",
        "desc": "nth([], 0) returns []"
      },
      {
        "id": "rank_length_mismatch_raises",
        "desc": "perm length != items raises PermError"
      }
    ],
    "num_checks": 27,
    "has_setup": true
  },
  {
    "slug": "querygroup",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `querygroup`: a tiny, chainable\nquery engine over a list of dicts (\"rows\"). The package is already written,\nimports cleanly, and its core operations work:\n\n- `Query(rows)` wraps a list of row dicts (immutable view; never mutated).\n- `where(predicate)` returns a new Query keeping only rows where\n  `predicate(row)` is truthy.\n- `order_by(key, reverse=False)` returns a new Query sorted by `key` (a column\n  name or a function `row -> value`); stable sort.\n- `rows()` materialises the current rows as a list of dicts.\n\nEvery operation returns a NEW Query, so chains compose.\n\n## Task\n\nAdd grouped aggregation: a `group_by(keys, aggregates=...)` method that collapses\nrows into ONE output row per distinct key-tuple, with aggregates computed over\nchosen fields. It must compose correctly when chained AFTER a `where` (group the\nfiltered rows, not the originals).\n\n## Semantics (read carefully \u2014 this is the whole task)\n\n- `keys` is either a single column name (a string) or a sequence of column\n  names. The group key for a row is the tuple of that row's values at those\n  columns (a missing column counts as `None`). A single string key still groups\n  correctly (it is treated as a one-element key list).\n\n- Each output row carries the group's key columns (with their shared values),\n  plus one column per requested aggregate.\n\n- `aggregates` is a sequence of `(func, field, alias)` triples:\n    * `func` is one of `count`, `sum`, `avg`, `min`, `max`.\n    * `field` is the column the aggregate runs over.\n    * `alias` is the output column name, or `None` to use `\"<func>_<field>\"`\n      (e.g. `(\"sum\", \"pay\", None)` -> column `\"sum_pay\"`).\n\n- GROUP ORDERING is FIRST-APPEARANCE: groups are emitted in the order their\n  key-tuple is FIRST encountered while scanning the current rows in order. Do\n  NOT sort the groups.\n\n- `count` counts the number of ROWS in the group.\n\n- `sum` / `avg` / `min` / `max` consider only the NON-`None` values of `field`\n  in the group (a row whose `field` is `None`, or missing, is skipped for that\n  aggregate \u2014 but it still counts toward `count`).\n\n- `avg` is the exact mean of the non-`None` values (no rounding). Crucially it\n  divides by the number of NON-`None` values, NOT by the row count.\n\n- EMPTY / all-`None` handling, per group and per field:\n    * `sum`  of no non-`None` values is `0`.\n    * `avg`  of no non-`None` values is `None` (not 0, and not a crash).\n    * `min` / `max` of no non-`None` values are `None`.\n\n- `group_by` returns a new `Query` (so its result can be `where`/`order_by`/\n  `rows()`-ed like any other Query). Grouping an empty Query yields an empty\n  Query (no groups, no error).\n\n## Example\n\n    q = Query([\n        {\"dept\": \"eng\", \"pay\": 10},\n        {\"dept\": \"ops\", \"pay\": 20},\n        {\"dept\": \"eng\", \"pay\": 30},\n        {\"dept\": \"eng\", \"pay\": None},\n    ])\n\n    out = q.group_by(\"dept\", [\n        (\"count\", \"pay\", None),\n        (\"sum\",   \"pay\", None),\n        (\"avg\",   \"pay\", None),\n        (\"max\",   \"pay\", None),\n    ]).rows()\n\n    # First-appearance order: \"eng\" before \"ops\".\n    # eng has 3 rows; non-None pays are [10, 30] -> sum 40, avg 20.0, max 30.\n    assert out == [\n        {\"dept\": \"eng\", \"count_pay\": 3, \"sum_pay\": 40, \"avg_pay\": 20.0, \"max_pay\": 30},\n        {\"dept\": \"ops\", \"count_pay\": 1, \"sum_pay\": 20, \"avg_pay\": 20.0, \"max_pay\": 20},\n    ]\n\nComposing after a filter, and a group whose field is entirely None:\n\n    q.where(lambda r: r[\"dept\"] == \"eng\").group_by(\n        \"dept\", [(\"avg\", \"pay\", None), (\"sum\", \"pay\", None)]\n    ).rows()\n    # -> [{\"dept\": \"eng\", \"avg_pay\": 20.0, \"sum_pay\": 40}]\n\n    Query([{\"d\": \"x\", \"n\": None}]).group_by(\n        \"d\", [(\"avg\", \"n\", None), (\"min\", \"n\", None), (\"sum\", \"n\", None)]\n    ).rows()\n    # -> [{\"d\": \"x\", \"avg_n\": None, \"min_n\": None, \"sum_n\": 0}]\n\n## Contract\n\n- Package name: `querygroup`. The grader imports `querygroup.public` (falling\n  back to `querygroup`); keep both import paths working.\n- Public class `Query` with the existing methods unchanged, plus\n  `group_by(keys, aggregates=None)` as specified above.\n- `where` / `order_by` / `rows` must keep behaving exactly as before\n  (regression).\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "single_group_count_sum",
        "desc": "one group: count counts rows, sum sums the field"
      },
      {
        "id": "multi_group_basic",
        "desc": "two groups, each with correct count/sum"
      },
      {
        "id": "first_appearance_order",
        "desc": "groups emitted in first-appearance order, not sorted"
      },
      {
        "id": "avg_divides_by_nonnull",
        "desc": "avg divides by count of non-None values, not row count"
      },
      {
        "id": "count_includes_null_rows",
        "desc": "count counts a row even when its aggregate field is None"
      },
      {
        "id": "min_max_skip_null",
        "desc": "min/max ignore None values in the field"
      },
      {
        "id": "all_null_field_aggs",
        "desc": "all-None field: avg/min/max are None, sum is 0"
      },
      {
        "id": "empty_group_via_filter",
        "desc": "empty Query (after a filter) groups to no rows"
      },
      {
        "id": "group_after_where",
        "desc": "group_by composes on the filtered rows after where()"
      },
      {
        "id": "multi_key_tuple",
        "desc": "grouping on two key columns keys by the tuple"
      },
      {
        "id": "default_alias_names",
        "desc": "default aggregate column name is '<func>_<field>'"
      },
      {
        "id": "custom_alias_used",
        "desc": "an explicit alias names the output column"
      },
      {
        "id": "result_is_chainable",
        "desc": "group_by returns a Query that can be order_by'd / rows()'d"
      },
      {
        "id": "avg_exact_not_rounded",
        "desc": "avg is the exact mean, not rounded/truncated"
      },
      {
        "id": "regression_where",
        "desc": "where() still filters rows with no grouping"
      },
      {
        "id": "regression_order_by",
        "desc": "order_by() still sorts rows (stable, reverse) with no grouping"
      }
    ],
    "num_checks": 16,
    "has_setup": true
  },
  {
    "slug": "ratelimit",
    "type": "ambiguous-spec",
    "brief": "We're getting hammered by a handful of clients and need some basic rate limiting we\ncan put in front of our API before it tips over again. I'd like a small Python\nlibrary, `ratelimit`, that lets us decide whether a given request is allowed right\nnow or should be turned away, so we can stop one noisy caller from eating all the\ncapacity.\n\nThe shape of it is simple enough: something asks \"can this go through?\", usually on\nbehalf of a particular caller \u2014 an API key, a user id, an IP, whatever we happen to\nhave \u2014 and `ratelimit` tells us yes or no based on how much they've already done\nrecently. Different callers shouldn't interfere with each other. We'll mostly be\nchecking from our own request-handling code, so it should be comfortable to import\n`ratelimit` and call into it, and it'd be handy to be able to exercise it directly\nto watch a limit kick in without standing up the whole service.\n\nWhat I care about most is that it behaves predictably under bursts \u2014 that the limit\nit promises is the limit you actually get, and that it doesn't get confused when a\nlot of checks land close together. I'd also like to be able to look at a decision and\nunderstand why it came out the way it did, rather than just a bare yes/no.\n\nUse your judgment on the rest; I'd rather see the approach you'd actually defend than\na pile of knobs. Lean on the standard library where you can, and include some tests\naround the limiting behavior so I can trust it does what you think it does.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "repaircalc",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 repaircalc: the test suite is failing\n\nYou have an existing Python package `repaircalc`, a small arithmetic expression\nevaluator. It ships with a unittest suite in `repaircalc/test_repaircalc.py`, and\nright now several of those tests FAIL. Fix the code so that ALL the tests pass.\nDo not rewrite the package from scratch and do not change its public API.\n\n## Symptom\n\n`evaluate(expr)` is supposed to parse and evaluate ordinary arithmetic, but it\ngets several expressions wrong:\n\n    from repaircalc.public import evaluate\n\n    evaluate(\"2+3*4\")     # EXPECTED 14   ... ACTUAL 20   (precedence wrong)\n    evaluate(\"10-3-2\")    # EXPECTED 5    ... ACTUAL 9    (associativity wrong)\n    evaluate(\"3.5+1.5\")   # EXPECTED 5.0  ... ACTUAL 6    (decimals mishandled)\n\nSimple cases like `evaluate(\"2+2\") == 4`, parentheses, and division by a nonzero\nvalue already work \u2014 only some precedence / associativity / decimal cases are\nbroken.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `repaircalc` package:\n\n    python -m unittest repaircalc.test_repaircalc\n\n## Contract (must hold after your fix)\n\n* Package name stays `repaircalc`; import path `repaircalc` / `repaircalc.public`.\n* Keep the public API exactly: `evaluate(expr: str) -> number` and the\n  `CalcError` exception. Do not rename them.\n* `evaluate` supports the binary operators `+`, `-`, `*`, `/`, parentheses for\n  grouping, a leading unary `-`/`+`, and integer and decimal literals\n  (e.g. `3`, `3.5`, `.5`).\n* Standard precedence: `*` and `/` bind TIGHTER than `+` and `-`.\n* All binary operators are LEFT-associative:\n  `10 - 3 - 2 == 5` and `100 / 10 / 2 == 5`.\n* Decimal literals keep their fractional value: `3.5 + 1.5 == 5.0`,\n  `.5 + .5 == 1.0`.\n* Division by zero raises `CalcError` (it must not crash with some other error).\n* Do NOT use Python's built-in `eval` (or `exec`/`ast.literal_eval` tricks) \u2014\n  keep the hand-written parser. Standard library only.\n\nDo not change the package name or the public function/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "basic_add",
        "desc": "2+2 == 4"
      },
      {
        "id": "basic_sub",
        "desc": "9-4 == 5"
      },
      {
        "id": "basic_single_number",
        "desc": "a bare literal evaluates to itself"
      },
      {
        "id": "basic_unary_minus",
        "desc": "leading unary minus negates"
      },
      {
        "id": "prec_add_then_mul",
        "desc": "2+3*4 == 14 (mul binds tighter)"
      },
      {
        "id": "prec_mul_then_add",
        "desc": "4*2+1 == 9"
      },
      {
        "id": "prec_two_products",
        "desc": "2*3+4*5 == 26"
      },
      {
        "id": "prec_mixed_add_sub_mul",
        "desc": "2 + 3 * 4 - 1 == 13"
      },
      {
        "id": "prec_div_in_sum",
        "desc": "10 + 8/2 == 14"
      },
      {
        "id": "prec_sub_then_mul",
        "desc": "20 - 2*3 == 14"
      },
      {
        "id": "assoc_sub_simple",
        "desc": "10-3-2 == 5 (left assoc)"
      },
      {
        "id": "assoc_sub_chain",
        "desc": "20-5-3-1 == 11"
      },
      {
        "id": "assoc_add_sub_mix",
        "desc": "1+2-3+4 == 4"
      },
      {
        "id": "assoc_add_sub_mix2",
        "desc": "12-4+2 == 10"
      },
      {
        "id": "assoc_div_chain",
        "desc": "100/10/2 == 5"
      },
      {
        "id": "assoc_div_chain2",
        "desc": "64/4/2 == 8"
      },
      {
        "id": "assoc_mul_div_lr",
        "desc": "6/2*3 == 9"
      },
      {
        "id": "paren_group_add",
        "desc": "(2+3)*4 == 20"
      },
      {
        "id": "paren_inner_expr",
        "desc": "2*(3+4) == 14"
      },
      {
        "id": "paren_nested",
        "desc": "((1+2)*(3+4)) == 21"
      },
      {
        "id": "paren_over_sub",
        "desc": "(10-3)-2 == 5"
      },
      {
        "id": "paren_changes_sub_assoc",
        "desc": "10-(3-2) == 9"
      },
      {
        "id": "paren_unary",
        "desc": "-(3+4) == -7"
      },
      {
        "id": "dec_add",
        "desc": "3.5+1.5 == 5.0"
      },
      {
        "id": "dec_leading_dot",
        "desc": ".5+.5 == 1.0"
      },
      {
        "id": "dec_mul",
        "desc": "2.5*4 == 10.0"
      },
      {
        "id": "dec_div",
        "desc": "10/4 == 2.5"
      },
      {
        "id": "dec_precision",
        "desc": "0.1+0.2 \u2248 0.3"
      },
      {
        "id": "dec_mixed",
        "desc": "1.5*2+0.5 == 3.5"
      },
      {
        "id": "div_by_zero_raises",
        "desc": "division by zero raises CalcError"
      },
      {
        "id": "no_eval_used",
        "desc": "implementation does not use eval/exec/literal_eval"
      }
    ],
    "num_checks": 31,
    "has_setup": true
  },
  {
    "slug": "repairmoney",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 repairmoney: the test suite is failing, fix the code so all tests pass\n\nYou have an existing Python package `repairmoney` (tiny money helpers over\ninteger cents). It LOOKS done, but its bundled test suite\n(`repairmoney/test_repairmoney.py`) is RED. Run it, find the bugs, and fix the\ncode in `repairmoney/public.py` so that every test passes. Keep the public API\nexactly as it is; do not rewrite the package from scratch and do not edit the\ntests.\n\n## Reproduction\n\n    python -m pytest repairmoney/test_repairmoney.py\n    # or, with no pytest installed:\n    python repairmoney/test_repairmoney.py\n\nSeveral tests fail. They point at money being rendered with the sign in the\nwrong place, cents that are not zero-padded, and an \"even\" split whose parts do\nnot add back up to the original total.\n\n## The two helpers\n\n* `format_cents(cents: int) -> str`\n  Renders an amount given as a whole number of integer cents (so $12.34 is the\n  int `1234`; negative amounts are debts/refunds) as a `$D.DD` string:\n\n      format_cents(1234)   ->  \"$12.34\"\n      format_cents(-1234)  ->  \"-$12.34\"     # minus IN FRONT of the $\n      format_cents(5)      ->  \"$0.05\"       # cents zero-padded to 2 digits\n      format_cents(0)      ->  \"$0.00\"\n\n* `split_evenly(cents: int, n: int) -> list[int]`\n  Splits a total of `cents` into `n` integer-cent parts. The leftover cents\n  (the remainder after the even base share) are distributed one per part to the\n  earliest parts, so the parts ALWAYS sum back to the original `cents`:\n\n      split_evenly(1000, 3)  ->  [334, 333, 333]   # sums to 1000\n      split_evenly(1000, 4)  ->  [250, 250, 250, 250]\n      split_evenly(100, 1)   ->  [100]\n\n## Contract (must hold after your fix)\n\n* Package name stays `repairmoney`; import path `repairmoney` /\n  `repairmoney.public`. Keep the public names `format_cents` and `split_evenly`\n  and their signatures.\n* `format_cents`:\n  - The minus sign for a negative amount goes IN FRONT of the `$`\n    (`\"-$12.34\"`, never `\"$-12.34\"`).\n  - The cents are ALWAYS two digits, zero-padded (`5` cents -> `\".05\"`).\n  - `0` formats as `\"$0.00\"`.\n* `split_evenly`:\n  - Returns a list of exactly `n` integer cents.\n  - The parts MUST sum EXACTLY to the input `cents`, for any `n >= 1`, whether\n    or not `cents` divides evenly by `n` (no cent may be lost or duplicated).\n  - The remainder cents are distributed one each to the earliest parts, so the\n    parts differ from one another by at most one cent.\n\nDo not change the package name or the public function names. Do not edit the\ntest file.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "fmt_positive",
        "desc": "format_cents renders a positive amount as $D.DD"
      },
      {
        "id": "fmt_zero",
        "desc": "format_cents renders 0 as $0.00"
      },
      {
        "id": "fmt_negative_sign_in_front",
        "desc": "a negative amount puts the minus sign in front of the $ (-$12.34)"
      },
      {
        "id": "fmt_pads_cents",
        "desc": "single-digit cents are zero-padded to two digits"
      },
      {
        "id": "fmt_negative_small_cents",
        "desc": "a small negative amount renders -$0.05"
      },
      {
        "id": "fmt_battery",
        "desc": "format_cents matches the oracle across many amounts"
      },
      {
        "id": "fmt_large",
        "desc": "a large amount renders all the dollar digits"
      },
      {
        "id": "split_divisible",
        "desc": "a divisible split yields n equal parts summing to total"
      },
      {
        "id": "split_non_divisible_sums_to_total",
        "desc": "a non-divisible split's parts sum EXACTLY to the total"
      },
      {
        "id": "split_remainder_distributed",
        "desc": "the remainder cent goes to the earliest part(s), parts within one cent"
      },
      {
        "id": "split_n_one",
        "desc": "split_evenly(total, 1) returns [total]"
      },
      {
        "id": "split_sum_invariant_battery",
        "desc": "across many (cents, n), parts have length n and sum to cents"
      },
      {
        "id": "split_negative_total",
        "desc": "a negative total splits into parts summing to it"
      },
      {
        "id": "split_large_conserves",
        "desc": "a large awkward split conserves every cent"
      }
    ],
    "num_checks": 14,
    "has_setup": true
  },
  {
    "slug": "repairpager",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 repairpager: the test suite is failing\n\nYou have an existing Python package `repairpager`, a small pagination helper\nthat slices a list of items into pages. It ships with a visible test file,\n`repairpager/test_repairpager.py`, and that test suite is currently FAILING.\nFix the code so all the tests pass. Do not rewrite the package from scratch and\ndo not change the public API or the return shape.\n\n## How to run the tests\n\n    python -m pytest repairpager/test_repairpager.py\n    # or, if pytest is not available:\n    python repairpager/test_repairpager.py\n\n## Symptom\n\n`paginate(items, page_size, page)` is returning wrong results: pages contain the\nwrong items, the reported page count drops a trailing partial page, and the last\npage incorrectly claims another page follows it. The visible tests pin down the\nintended behaviour \u2014 make them green.\n\n## Contract (must hold after your fix)\n\n* Package name stays `repairpager`; import path `repairpager` / `repairpager.public`.\n* Keep the public API exactly as it is:\n  `paginate(items, page_size, page=1) -> dict`.\n* Keep the return shape \u2014 a dict with these keys:\n  - `items`        : list of the items on this page, in original order (may be empty)\n  - `total_items`  : total number of input items\n  - `total_pages`  : number of pages needed to cover ALL items (round UP so a\n                     trailing partial page still counts; an empty input is one page)\n  - `page`         : the 1-based page actually returned (clamped into range)\n  - `has_next`     : True iff a page after this one exists\n  - `has_prev`     : True iff a page before this one exists\n* Page numbering is 1-based: `page=1` returns the FIRST `page_size` items\n  (items index 0 .. page_size-1), `page=2` the next chunk, and so on.\n* Slicing must be correct: page `p` returns items in the half-open index range\n  `[(p-1)*page_size, p*page_size)`.\n* `total_pages` must use a ceiling division: 5 items in chunks of 2 is 3 pages,\n  not 2. An exact multiple (e.g. 6 items, size 3) is exactly that many pages.\n* `has_next` is False on the last page; `has_prev` is False on the first page.\n* `page_size` must be a positive integer; reject otherwise (the existing\n  `ValueError` behaviour is fine \u2014 do not weaken it).\n\nDo not change the package name or the public function name. Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "first_page_items",
        "desc": "page 1 returns the first page_size items in order"
      },
      {
        "id": "middle_page_items",
        "desc": "an interior page returns the correct chunk"
      },
      {
        "id": "last_partial_page_items",
        "desc": "the trailing partial page holds the leftover items"
      },
      {
        "id": "total_pages_ceil_partial",
        "desc": "total_pages rounds up for a trailing partial page"
      },
      {
        "id": "total_pages_exact_multiple",
        "desc": "an exact multiple yields exactly that many pages"
      },
      {
        "id": "total_items_count",
        "desc": "total_items equals the number of input items"
      },
      {
        "id": "flags_first_page",
        "desc": "first page: has_next True, has_prev False"
      },
      {
        "id": "has_next_false_last_page",
        "desc": "last page: has_next False, has_prev True"
      },
      {
        "id": "flags_middle_page",
        "desc": "interior page: has_next and has_prev both True"
      },
      {
        "id": "single_full_page",
        "desc": "a single full page has no next or prev"
      },
      {
        "id": "empty_input",
        "desc": "empty input is a single empty page with no navigation"
      },
      {
        "id": "out_of_range_page_clamped",
        "desc": "a too-large page clamps to the last real page"
      }
    ],
    "num_checks": 12,
    "has_setup": true
  },
  {
    "slug": "repairspans",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 repairspans: the test suite is failing \u2014 fix the code so all tests pass.\n\nYou have an existing Python package `repairspans`, a tiny library for working with\nclosed integer intervals. It ships with a test suite in the package\n(`repairspans/test_repairspans.py`) that is currently FAILING. There are a few\nplanted bugs in the implementation. Find them and fix the code so that every test\npasses. Do NOT edit the tests, and do not rewrite the package from scratch \u2014 keep\nthe public API exactly as it is.\n\n## Symptom\n\nRun the visible tests from the workspace root:\n\n    python -m repairspans.test_repairspans\n\nSeveral tests fail. The failures all stem from the handling of CLOSED intervals\n(intervals that include both endpoints) and from the assumption that input is\nalready sorted. For example:\n\n  * `merge([[1, 2], [2, 3]])` should be `[[1, 3]]` (the intervals touch at the\n    point 2 and must collapse), but the buggy code returns `[[1, 2], [2, 3]]`.\n  * `merge([[3, 4], [1, 2]])` (unsorted input) should be `[[1, 2], [3, 4]]`, but\n    the buggy code mishandles the ordering.\n  * `overlaps([1, 2], [2, 3])` should be `True` (they share the point 2), but the\n    buggy code returns `False`.\n\n## Contract (must hold after your fix)\n\n* Package name stays `repairspans`; import path `repairspans` / `repairspans.public`.\n* Keep the existing public API and its names \u2014 two functions, exported from both\n  `repairspans` and `repairspans.public`:\n  - `merge(intervals) -> list[list[int]]`\n  - `overlaps(a, b) -> bool`\n* Intervals are `[start, end]` two-element sequences with `start <= end`, and they\n  are CLOSED: both endpoints are included.\n* TOUCHING / ADJACENT BEHAVIOR (define it exactly this way): because the intervals\n  are closed, two intervals that touch at a single shared endpoint count as\n  overlapping. So `[1, 2]` and `[2, 3]` overlap, and `merge` collapses them into\n  `[1, 3]`. Intervals that do NOT share a point (e.g. `[1, 2]` and `[3, 4]`,\n  whose nearest endpoints differ by more than 0) stay separate.\n* `overlaps(a, b)` returns `True` iff the two closed intervals share at least one\n  point (nesting and identical intervals count as overlapping; touching counts;\n  fully disjoint does not). It is symmetric: `overlaps(a, b) == overlaps(b, a)`.\n* `merge(intervals)`:\n  - returns a NEW list (does not mutate the input or its interval objects),\n  - is order-independent: it must produce the correct result for UNSORTED input,\n  - returns intervals sorted by start, with no two results overlapping or touching,\n  - returns `[]` for empty input, and `[[s, e]]` (a copy) for a single interval.\n\nUse only the Python standard library. Do not change the package name or the\npublic function names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "merge_empty",
        "desc": "merge([]) returns []"
      },
      {
        "id": "merge_single",
        "desc": "merge of one interval returns that interval"
      },
      {
        "id": "merge_disjoint",
        "desc": "disjoint intervals stay separate"
      },
      {
        "id": "merge_overlapping",
        "desc": "overlapping intervals merge into one"
      },
      {
        "id": "merge_touching_adjacent",
        "desc": "touching closed intervals merge (off-by-one)"
      },
      {
        "id": "merge_unsorted_input",
        "desc": "unsorted input is handled correctly"
      },
      {
        "id": "merge_unsorted_overlap",
        "desc": "unsorted overlapping intervals merge"
      },
      {
        "id": "merge_nested",
        "desc": "a nested interval is absorbed without shrinking"
      },
      {
        "id": "merge_nested_unsorted",
        "desc": "nested interval absorbed regardless of order"
      },
      {
        "id": "merge_chain",
        "desc": "a touching chain collapses to one span"
      },
      {
        "id": "merge_duplicates",
        "desc": "identical intervals collapse to one"
      },
      {
        "id": "merge_no_mutation",
        "desc": "merge does not mutate its input"
      },
      {
        "id": "overlaps_overlap",
        "desc": "overlapping intervals report True"
      },
      {
        "id": "overlaps_touch",
        "desc": "touching closed intervals report True"
      },
      {
        "id": "overlaps_disjoint",
        "desc": "disjoint intervals report False"
      },
      {
        "id": "overlaps_nested",
        "desc": "a nested interval overlaps its container"
      },
      {
        "id": "overlaps_identical",
        "desc": "identical intervals overlap"
      },
      {
        "id": "overlaps_symmetric",
        "desc": "overlaps is symmetric in its arguments"
      }
    ],
    "num_checks": 18,
    "has_setup": true
  },
  {
    "slug": "retryflow",
    "type": "ambiguous-spec",
    "brief": "We keep writing the same fiddly retry code over and over: a network call flakes,\nwe wrap it in a loop, sleep a bit, try again, and every service does it slightly\ndifferently. I'd like a small Python library, `retryflow`, that gives us one decent\nway to retry an operation that might fail transiently \u2014 an HTTP request, a flaky\ndatabase connection, that sort of thing \u2014 so we stop reinventing it.\n\nThe thing I care about most is that retrying should be easy to reach for on an\nexisting piece of code without contorting it, and that it stays predictable: when\nsomething keeps failing, the caller should end up with a clear outcome rather than a\nswallowed error or a surprise. Not every failure is worth retrying, so there should\nbe a sensible way to say which ones are and aren't \u2014 retrying a \"host unreachable\" is\nfine, retrying a \"you're not authorized\" is just wasting time.\n\nBeyond that I'm leaving the design to you. Use your judgment on how the retrying\nbehaves over successive attempts and when it decides to stop, and on the shape callers\nactually use to apply it. It should be importable as `retryflow` and there should be an\nobvious way to use it from our own code. Lean on the standard library where you can and\nkeep it reasonably small. Some tests around the retry behavior would give me confidence\nit does what you think it does, and a short note on how it's meant to be used.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "romanio",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 romanio: the test suite is failing\n\nYou have an existing Python package `romanio`, a tiny Roman-numeral converter.\nIt ships with a unittest suite in `romanio/test_romanio.py`, and right now\nseveral of those tests FAIL. Fix the code so that ALL the tests pass. Do not\nrewrite the package from scratch and do not change its public API.\n\n## Symptom\n\n`to_roman(n)` renders an integer as a Roman numeral and `from_roman(s)` parses\none back. Simple additive numerals already work, but the subtractive cases and\nthe range check are wrong:\n\n    from romanio.public import to_roman, from_roman\n\n    # to_roman spells the subtractive values additively:\n    to_roman(4)      # EXPECTED \"IV\"      ACTUAL \"IIII\"\n    to_roman(9)      # EXPECTED \"IX\"      ACTUAL \"VIIII\"\n    to_roman(40)     # EXPECTED \"XL\"      ACTUAL \"XXXX\"\n    to_roman(900)    # EXPECTED \"CM\"      ACTUAL \"DCCCC\"\n    to_roman(1994)   # EXPECTED \"MCMXCIV\" ACTUAL \"MDCCCCLXXXXIIII\"\n\n    # from_roman just sums symbols, ignoring subtractive pairs:\n    from_roman(\"IV\")      # EXPECTED 4    ACTUAL 6   (I + V)\n    from_roman(\"IX\")      # EXPECTED 9    ACTUAL 11\n    from_roman(\"MCMXCIV\") # EXPECTED 1994 ACTUAL ...wrong\n\n    # to_roman accepts out-of-range values instead of refusing them:\n    to_roman(0)      # EXPECTED RomanError   ACTUAL \"\"\n    to_roman(4000)   # EXPECTED RomanError   ACTUAL \"MMMM\"\n\nThese defects interact: the round trip `from_roman(to_roman(n)) == n` only\nholds for subtractive values (4, 9, 40, ..., 1994) once BOTH directions agree\non subtractive notation, and the range guard is what keeps `to_roman` honest at\nthe 1 and 3999 boundaries.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `romanio` package:\n\n    python -m unittest romanio.test_romanio\n\n## Contract (must hold after your fix)\n\n* Package name stays `romanio`; import path `romanio` / `romanio.public`.\n* Keep the public API exactly: `to_roman(n: int) -> str`,\n  `from_roman(s: str) -> int`, and the `RomanError` exception. Do not rename\n  them.\n* `to_roman(n)` accepts an int with `1 <= n <= 3999`. Anything outside that\n  range (including 0 and negatives) raises `RomanError`. A non-int raises\n  `RomanError`.\n* `from_roman(s)` accepts a numeral string (case-insensitive, surrounding\n  whitespace ignored) and returns its integer value. An empty string, or a\n  string containing a symbol that is not one of `M D C L X V I`, raises\n  `RomanError`.\n* SUBTRACTIVE notation is REQUIRED in both directions. The six subtractive\n  pairs are:\n\n      4   -> IV        40  -> XL        400 -> CD\n      9   -> IX        90  -> XC        900 -> CM\n\n  So `to_roman` must emit `IV` (not `IIII`), `IX` (not `VIIII`), `XL`, `XC`,\n  `CD`, `CM`; and `from_roman` must read a smaller symbol placed before a\n  larger one as a subtraction (`IV` = 5 - 1 = 4, `CM` = 1000 - 100 = 900).\n* Everything else is additive, written largest-symbol-first (e.g. 2026 ->\n  `MMXXVI`, 38 -> `XXXVIII`).\n* ROUND TRIP: `from_roman(to_roman(n)) == n` for every `n` in `1..3999`.\n\nExample:\n\n    to_roman(1994)             # -> \"MCMXCIV\"\n    from_roman(\"MCMXCIV\")      # -> 1994\n    to_roman(2949)             # -> \"MMCMXLIX\"\n    from_roman(\"MMCMXLIX\")     # -> 2949\n\nStandard library only. Do not change the package name or the public\nfunction/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "to_simple_i_to_iii",
        "desc": "to_roman renders 1,2,3 as I,II,III"
      },
      {
        "id": "to_additive_vi_viii",
        "desc": "to_roman renders 6 -> VI, 8 -> VIII"
      },
      {
        "id": "to_additive_thirtyeight",
        "desc": "to_roman renders 38 -> XXXVIII"
      },
      {
        "id": "from_additive_basics",
        "desc": "from_roman parses III,VI,XXX additively"
      },
      {
        "id": "to_sub_four",
        "desc": "to_roman(4) -> IV (not IIII)"
      },
      {
        "id": "to_sub_nine",
        "desc": "to_roman(9) -> IX (not VIIII)"
      },
      {
        "id": "to_sub_forty",
        "desc": "to_roman(40) -> XL"
      },
      {
        "id": "to_sub_ninety",
        "desc": "to_roman(90) -> XC"
      },
      {
        "id": "to_sub_four_hundred",
        "desc": "to_roman(400) -> CD"
      },
      {
        "id": "to_sub_nine_hundred",
        "desc": "to_roman(900) -> CM"
      },
      {
        "id": "to_sub_composite",
        "desc": "to_roman(1994) -> MCMXCIV (many subtractive pairs)"
      },
      {
        "id": "to_sub_2949",
        "desc": "to_roman(2949) -> MMCMXLIX"
      },
      {
        "id": "from_sub_four",
        "desc": "from_roman('IV') -> 4 (not 6)"
      },
      {
        "id": "from_sub_nine",
        "desc": "from_roman('IX') -> 9"
      },
      {
        "id": "from_sub_forty_ninety",
        "desc": "from_roman('XL'),('XC') -> 40,90"
      },
      {
        "id": "from_sub_cd_cm",
        "desc": "from_roman('CD'),('CM') -> 400,900"
      },
      {
        "id": "from_sub_composite",
        "desc": "from_roman('MCMXCIV') -> 1994"
      },
      {
        "id": "from_case_insensitive",
        "desc": "from_roman lowercases input ('mcmxciv' -> 1994)"
      },
      {
        "id": "round_trip_full_range",
        "desc": "from_roman(to_roman(n)) == n for all 1..3999"
      },
      {
        "id": "to_zero_raises",
        "desc": "to_roman(0) raises RomanError"
      },
      {
        "id": "to_negative_raises",
        "desc": "to_roman(-5) raises RomanError"
      },
      {
        "id": "to_too_big_raises",
        "desc": "to_roman(4000) raises RomanError"
      },
      {
        "id": "to_way_too_big_raises",
        "desc": "to_roman(10000) raises RomanError"
      },
      {
        "id": "to_boundary_one",
        "desc": "to_roman(1) -> I (lower boundary stays valid)"
      },
      {
        "id": "to_boundary_3999",
        "desc": "to_roman(3999) -> MMMCMXCIX (upper boundary stays valid)"
      },
      {
        "id": "from_bad_symbol_raises",
        "desc": "from_roman('IZ') raises RomanError"
      },
      {
        "id": "from_empty_raises",
        "desc": "from_roman('') raises RomanError"
      }
    ],
    "num_checks": 27,
    "has_setup": true
  },
  {
    "slug": "routerwild",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `routerwild`: a pure, in-process\nURL-style path router. The package is already written, imports cleanly, and\neverything it currently does works. Nothing here touches the network \u2014 `Router`\nis a plain data structure you build with `add(path, handler)` and query with\n`match(path)`.\n\nA path is a `/`-separated string. Today each segment is one of:\n\n  - a STATIC segment that matches itself literally (`users`, `v1`); or\n  - a PARAM segment written `{name}` that matches exactly one non-empty segment\n    and captures it under `name`.\n\n`match(path)` returns `(handler, params)` for the best match, or `(None, {})`\nwhen nothing matches. Static segments already take precedence over param\nsegments at the same position, so a literal route beats a parameterised one.\n\nExamples of what already works:\n\n    r = Router()\n    r.add(\"/users/{id}\", \"show_user\")\n    r.add(\"/users/me\", \"current_user\")\n\n    r.match(\"/users/42\")        # -> (\"show_user\", {\"id\": \"42\"})\n    r.match(\"/users/me\")        # -> (\"current_user\", {})     (static beats param)\n    r.match(\"/users/42/extra\")  # -> (None, {})               (param is one segment)\n    r.match(\"/nope\")            # -> (None, {})\n\n## Feature request\n\nAdd WILDCARD (catch-all) segments written `{name:*}` that capture the entire\nREMAINING path, INCLUDING slashes, under `name`. A wildcard is only meaningful\nas the LAST segment of a route.\n\n    r = Router()\n    r.add(\"/files/{path:*}\", \"serve\")\n\n    r.match(\"/files/a/b/c\")     # -> (\"serve\", {\"path\": \"a/b/c\"})\n    r.match(\"/files/readme\")    # -> (\"serve\", {\"path\": \"readme\"})\n\nWildcards sit at the LOWEST precedence: static > param > wildcard. A more\nspecific route (static or param) at the same prefix must still win over a\ncatch-all:\n\n    r = Router()\n    r.add(\"/files/{path:*}\", \"wild\")\n    r.add(\"/files/readme\",   \"exact\")\n\n    r.match(\"/files/readme\")    # -> (\"exact\", {})              (static beats wildcard)\n    r.match(\"/files/a/b\")       # -> (\"wild\", {\"path\": \"a/b\"})  (catch-all otherwise)\n\nThe existing static and param behaviour, the precedence among them, and the\n`(handler, params)` / `(None, {})` return shape must all keep working unchanged.\n\n## Contract\n\n- Package name: `routerwild`. The grader imports `routerwild.public` (falling\n  back to `routerwild`); keep both import paths working.\n- Keep the PUBLIC API: `Router()`, `Router.add(path, handler)`, and\n  `Router.match(path) -> (handler, params)` (a hit) or `(None, {})` (a miss).\n  Do not rename anything or change these signatures.\n- Keep STATIC and `{param}` matching working exactly as before, including\n  static > param precedence and the `(handler, params)` / `(None, {})` returns.\n- ADD `{name:*}` wildcard segments that capture the rest of the path (slashes\n  included) under `name`, at the LOWEST precedence: static > param > wildcard.\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "wild_captures_rest",
        "desc": "NEW: {path:*} matches /files/a/b/c capturing 'a/b/c'"
      },
      {
        "id": "wild_single_segment",
        "desc": "NEW: {path:*} also captures a single remaining segment"
      },
      {
        "id": "wild_includes_slashes",
        "desc": "NEW: wildcard capture keeps embedded slashes verbatim"
      },
      {
        "id": "wild_after_param",
        "desc": "NEW: a wildcard can follow a param, capturing the tail"
      },
      {
        "id": "static_beats_wildcard",
        "desc": "NEW: an exact static route beats a wildcard at the same prefix"
      },
      {
        "id": "param_beats_wildcard",
        "desc": "NEW: a param segment beats a wildcard at the same position"
      },
      {
        "id": "wild_no_false_match",
        "desc": "NEW: a wildcard route does not match an unrelated prefix"
      },
      {
        "id": "static_match",
        "desc": "REGRESSION: a static route matches and returns no params"
      },
      {
        "id": "param_capture",
        "desc": "REGRESSION: a {name} param matches one segment and captures it"
      },
      {
        "id": "static_beats_param",
        "desc": "REGRESSION: a static route beats a param at the same position"
      },
      {
        "id": "param_is_single_segment",
        "desc": "REGRESSION: a param matches exactly one segment, not more"
      },
      {
        "id": "no_match_returns_none",
        "desc": "REGRESSION: an unmatched path returns (None, {})"
      }
    ],
    "num_checks": 12,
    "has_setup": true
  },
  {
    "slug": "rrulelite",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 rrulelite: the test suite is failing\n\nYou have an existing Python package `rrulelite`, a tiny recurrence-rule expander.\nIt ships with a unittest suite in `rrulelite/test_rrulelite.py`, and right now\nseveral of those tests FAIL. Fix the code so that ALL the tests pass. Do not\nrewrite the package from scratch and do not change its public API.\n\n## Symptom\n\n`expand(rule, start, limit)` walks a recurrence rule forward from `start` and is\nsupposed to return the dates it generates. Daily and weekly rules already work,\nbut several monthly / boundary cases come out wrong:\n\n    from datetime import date\n    from rrulelite.public import expand\n\n    # interval is ignored for monthly rules:\n    expand({\"freq\": \"monthly\", \"interval\": 2}, date(2026, 1, 10), 3)\n    #   EXPECTED [2026-01-10, 2026-03-10, 2026-05-10]\n    #   ACTUAL   [2026-01-10, 2026-02-10, 2026-03-10]   (steps 1 month, not 2)\n\n    # month-end overflow spills instead of clamping:\n    expand({\"freq\": \"monthly\"}, date(2026, 1, 31), 3)\n    #   EXPECTED [2026-01-31, 2026-02-28, 2026-03-31]\n    #   ACTUAL   [2026-01-31, 2026-03-03, 2026-03-31]   (Feb 31 -> Mar 3)\n\n    # `until` drops the date that lands exactly on the bound:\n    expand({\"freq\": \"daily\", \"until\": date(2026, 1, 3)}, date(2026, 1, 1), 10)\n    #   EXPECTED [2026-01-01, 2026-01-02, 2026-01-03]\n    #   ACTUAL   [2026-01-01, 2026-01-02]               (until treated exclusive)\n\nThese defects interact: a monthly rule with `interval > 1` that starts on a\nmonth-end and carries an `until` bound exercises all three at once.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `rrulelite` package:\n\n    python -m unittest rrulelite.test_rrulelite\n\n## Contract (must hold after your fix)\n\n* Package name stays `rrulelite`; import path `rrulelite` / `rrulelite.public`.\n* Keep the public API exactly: `expand(rule: dict, start: date, limit: int) ->\n  list[date]` and the `RRuleError` exception. Do not rename them.\n* `rule` is a dict with:\n    - `freq`: one of `\"daily\"`, `\"weekly\"`, `\"monthly\"` (required). An\n      unsupported value raises `RRuleError`.\n    - `interval`: a positive int step (default 1). For `freq == \"monthly\"`,\n      `interval == 2` means EVERY OTHER month; for daily it means every 2nd day;\n      for weekly every 2nd week. A non-positive / non-int interval raises\n      `RRuleError`.\n    - `until`: an optional `date`. It is an INCLUSIVE upper bound \u2014 a generated\n      date EQUAL to `until` is kept, and the first date strictly AFTER `until`\n      stops the expansion.\n* The expansion ALWAYS starts at `start`: the first emitted date is `start`\n  itself (unless `start` already exceeds `until`, in which case the result is\n  empty). Subsequent dates are `start` plus 1*interval, 2*interval, ... steps.\n* At most `limit` dates are returned. `limit <= 0` returns an empty list.\n* MONTH-END semantics: stepping months clamps the day to the LAST valid day of\n  the target month. From Jan 31, stepping one month gives Feb 28 in a common\n  year and Feb 29 in a leap year (e.g. 2028), NOT an invalid Feb 31 and NOT a\n  rolled-over Mar 2 / Mar 3. Stepping further keeps using the ORIGINAL day where\n  the month allows it (Jan 31 -> Feb 28 -> Mar 31), i.e. clamping is per-step\n  from `start`, not a permanent truncation.\n\nExample:\n\n    expand({\"freq\": \"monthly\", \"interval\": 2, \"until\": date(2026, 7, 31)},\n           date(2026, 1, 31), 10)\n    #   -> [2026-01-31, 2026-03-31, 2026-05-31, 2026-07-31]\n\nStandard library only (`datetime`). Do not change the package name or the public\nfunction/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "daily_simple",
        "desc": "daily interval=1 emits consecutive days from start"
      },
      {
        "id": "daily_interval3",
        "desc": "daily interval=3 steps every 3rd day"
      },
      {
        "id": "weekly_interval2",
        "desc": "weekly interval=2 steps every other week"
      },
      {
        "id": "monthly_simple",
        "desc": "monthly interval=1 emits consecutive months"
      },
      {
        "id": "monthly_interval2",
        "desc": "monthly interval=2 -> every other month"
      },
      {
        "id": "monthly_interval3_year_wrap",
        "desc": "monthly interval=3 wraps across year end"
      },
      {
        "id": "clamp_jan31_to_feb28",
        "desc": "Jan 31 + 1 month clamps to Feb 28 (common year)"
      },
      {
        "id": "clamp_leap_feb29",
        "desc": "Jan 31 + 1 month clamps to Feb 29 in a leap year (2028)"
      },
      {
        "id": "clamp_then_restore",
        "desc": "clamping is per-step: Jan 31 -> Feb 28 -> Mar 31"
      },
      {
        "id": "clamp_31_to_30day_month",
        "desc": "Mar 31 + 1 month clamps to Apr 30"
      },
      {
        "id": "clamp_interval2_endpoints",
        "desc": "interval=2 from Jan 31 -> Jan 31, Mar 31, May 31"
      },
      {
        "id": "until_inclusive_daily",
        "desc": "until keeps the date landing exactly on it (daily)"
      },
      {
        "id": "until_inclusive_monthly",
        "desc": "until keeps the exact-boundary monthly date"
      },
      {
        "id": "until_strict_past_stops",
        "desc": "a generated date strictly past until is excluded"
      },
      {
        "id": "until_start_past_until",
        "desc": "start beyond until yields empty list"
      },
      {
        "id": "limit_cap",
        "desc": "limit caps the number of emitted dates"
      },
      {
        "id": "limit_zero_empty",
        "desc": "limit <= 0 returns empty list"
      },
      {
        "id": "interaction_interval_clamp_until",
        "desc": "interval=2 + month-end clamp + inclusive until together"
      },
      {
        "id": "bad_freq_raises",
        "desc": "unsupported freq raises RRuleError"
      },
      {
        "id": "bad_interval_raises",
        "desc": "non-positive interval raises RRuleError"
      }
    ],
    "num_checks": 20,
    "has_setup": true
  },
  {
    "slug": "scheduler",
    "type": "ambiguous-spec",
    "brief": "I'd like a small Python package, `scheduler`, that runs tasks on a schedule \u2014 some\nthings need to happen every so often, others at particular times of day, and I want\none place to register that work and have it actually fire when it's supposed to.\n\nThe picture in my head is: I describe a handful of tasks, say when each one should\nrun, hand the lot to the scheduler, and let it tick along firing them at the right\nmoments. The kind of thing you'd reach for to send a nightly report, refresh a cache\nevery few minutes, do the weekly cleanup \u2014 ordinary recurring chores, nothing exotic.\n\nWhat I care about most is that it's pleasant to register a task and say when it runs,\nand that I can trust the timing \u2014 when a task was due, it ran, and I can tell that it\ndid. It should be importable as `scheduler`, and there should be an obvious way to\nactually start the thing going, whether that's from code or the command line; use\nyour judgment.\n\nBeyond that the design is yours. Keep it small and lean on the standard library where\nyou can \u2014 I'd rather see the choices you'd actually defend than a wall of options or\nconfiguration. Some real tests around the scheduling behavior would give me\nconfidence it does what you think it does, and a couple of examples in a README so I\ncan see how it's meant to be used. Clean and well-thought-through beats sprawling.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  },
  {
    "slug": "schemaoneof",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `schemaoneof`: a validator for a\nsubset of JSON Schema. The package is already written, imports cleanly, and\nworks for the keywords it supports.\n\nThe single public entry point is:\n\n    def validate(instance, schema) -> list[dict]: ...\n\nIt walks `instance` against `schema` and returns a LIST OF ERROR DICTS. An EMPTY\nlist means the instance is valid; a non-empty list means it failed one or more\nconstraints. (The exact error-dict shape is up to you \u2014 the shipped code uses\n`{\"path\": ..., \"keyword\": ..., \"message\": ...}` \u2014 but \"empty vs non-empty\" is\nthe load-bearing signal.)\n\n## What works today\n\nThe validator currently supports these keywords:\n\n  - `type`        \u2014 \"object\" / \"array\" / \"string\" / \"number\" / \"integer\" /\n                    \"boolean\" / \"null\". (Note: booleans are NOT numbers/integers,\n                    and \"number\" accepts ints; \"integer\" rejects floats.)\n  - `enum`        \u2014 instance must deep-equal one of the listed values.\n  - `required`    \u2014 listed property names must be present on an object.\n  - `properties`  \u2014 each present property is validated against its subschema.\n\nExamples of current behavior:\n\n    validate(5, {\"type\": \"integer\"})                 -> []          (valid)\n    validate(\"x\", {\"type\": \"integer\"})               -> [ ...1 err ]\n    validate({\"a\": 1}, {\"required\": [\"a\", \"b\"]})      -> [ ...1 err ] (b missing)\n    validate(\"green\", {\"enum\": [\"red\", \"green\"]})     -> []          (valid)\n\n## The capability to ADD\n\nThe validator is MISSING two JSON-Schema combinators. Add both:\n\n### `oneOf`\n\n`oneOf` is a list of subschemas. The instance must match EXACTLY ONE of them.\n\n  - Zero subschemas match  -> ERROR (non-empty list).\n  - Exactly one matches    -> VALID (no error from oneOf).\n  - Two or more match      -> ERROR (non-empty list).\n\nA subschema \"matches\" when validating the instance against it yields no errors.\n\nExamples (desired behavior once added):\n\n    validate(5,  {\"oneOf\": [{\"type\": \"integer\"}, {\"type\": \"string\"}]})  -> []\n        # matches integer only -> exactly one -> valid\n\n    validate(True, {\"oneOf\": [{\"type\": \"integer\"}, {\"type\": \"string\"}]}) -> [err]\n        # matches neither (bool is not integer/string) -> zero -> error\n\n    validate(5,  {\"oneOf\": [{\"type\": \"integer\"}, {\"type\": \"number\"}]})  -> [err]\n        # 5 matches BOTH integer and number -> two -> error\n\n### `not`\n\n`not` is a single subschema. The instance must NOT match it. If the instance\nDOES match the subschema, that is an ERROR.\n\nExamples (desired behavior once added):\n\n    validate(5,   {\"not\": {\"type\": \"string\"}})   -> []      (5 is not a string -> ok)\n    validate(\"x\", {\"not\": {\"type\": \"string\"}})   -> [err]   (\"x\" IS a string -> error)\n\n## Contract\n\n  - Package name: `schemaoneof`. The grader imports `schemaoneof.public`\n    (falling back to `schemaoneof`); keep both import paths working.\n  - Keep the existing keyword behavior UNCHANGED: `type`, `required`,\n    `properties`, and `enum` must still validate exactly as they do now, and\n    `validate` must still return a LIST (empty == valid).\n  - ADD `oneOf` (exactly-one-of) and `not` (must-not-match) as described above.\n    They compose with the other keywords on the same schema (all present\n    keywords are checked).\n  - Standard library only. Do not rename `validate` or change its meaning.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "oneof_exactly_one_valid",
        "desc": "oneOf with exactly one matching subschema is VALID"
      },
      {
        "id": "oneof_zero_matches_error",
        "desc": "oneOf with zero matching subschemas is an ERROR"
      },
      {
        "id": "oneof_two_matches_error",
        "desc": "oneOf with two matching subschemas is an ERROR"
      },
      {
        "id": "oneof_nested_object",
        "desc": "oneOf discriminates between two object shapes"
      },
      {
        "id": "not_match_is_error",
        "desc": "not is an ERROR when the subschema MATCHES the instance"
      },
      {
        "id": "not_nomatch_is_valid",
        "desc": "not is VALID when the subschema does NOT match"
      },
      {
        "id": "combinator_composes",
        "desc": "oneOf/not compose with sibling keywords on one schema"
      },
      {
        "id": "type_ok",
        "desc": "a value of the declared type validates clean"
      },
      {
        "id": "type_mismatch",
        "desc": "a value of the wrong type is an error"
      },
      {
        "id": "type_number_accepts_int",
        "desc": "type 'number' accepts an integer"
      },
      {
        "id": "required_present_ok",
        "desc": "an object with all required props is valid"
      },
      {
        "id": "required_missing_error",
        "desc": "a missing required property is an error"
      },
      {
        "id": "properties_ok",
        "desc": "a property whose value fits its subschema is valid"
      },
      {
        "id": "properties_nested_error",
        "desc": "a property whose value violates its subschema errors"
      },
      {
        "id": "enum_member_ok",
        "desc": "a value in the enum is valid"
      },
      {
        "id": "enum_nonmember_error",
        "desc": "a value not in the enum is an error"
      },
      {
        "id": "valid_empty_list",
        "desc": "a fully-valid instance yields an EMPTY error list"
      }
    ],
    "num_checks": 17,
    "has_setup": true
  },
  {
    "slug": "searchprefix",
    "type": "feature-add",
    "brief": "You are handed an existing, WORKING Python 3.11+ package named `searchprefix`. It is\nalready in your working directory. Your job is to ADD ONE capability described below\nWITHOUT breaking any of the existing behavior. Use only the Python standard library.\n\n## What the package does today\n\n`searchprefix.public.SearchIndex` is a small in-memory search index:\n\n    from searchprefix.public import SearchIndex\n\n    idx = SearchIndex()\n    idx.add_document(\"d1\", \"Payment received and processed\")\n    idx.add_document(\"d2\", \"Refund payable next week\")\n    idx.add_document(\"d3\", \"Shipping label printed\")\n\n  - `add_document(doc_id, text)` tokenizes `text` into lowercase alphanumeric terms\n    and records, per document, how many times each term appears.\n  - `search(query) -> list[doc_id]` tokenizes the query the same way and returns the\n    ids of documents that contain EVERY query term, using case-insensitive EXACT-term\n    matching. Results are ranked by total term frequency (the summed count of the\n    query terms within the document), highest first; ties break by ascending doc id,\n    so the order is deterministic.\n\nSo today `search(\"payment\")` returns `[\"d1\"]` (exact term `payment`), and\n`search(\"pay\")` returns `[]` \u2014 because `pay` is not an exact term in any document\n(the documents have `payment` and `payable`, not `pay`).\n\n## The feature to ADD: prefix queries\n\nAdd support for PREFIX query tokens. A query token that ends with `*` matches any\ndocument term that STARTS WITH the text before the `*`. Plain tokens (no `*`) keep\ntheir current exact-match behavior.\n\nExamples (against the three documents above):\n\n  - `search(\"pay*\")` matches d1 (term `payment`) and d2 (term `payable`) \u2014 both\n    start with `pay`. It does NOT match d3. Ranking still follows term frequency.\n  - `search(\"ship*\")` matches d3 (`shipping`).\n  - A prefix only matches at the START of a term: `search(\"ment*\")` does NOT match\n    `payment` (mid-word is not a prefix).\n  - A plain token is unchanged: `search(\"payment\")` still matches only d1, and\n    `search(\"pay\")` (no `*`) still matches nothing.\n\nA query may mix plain and prefix tokens; as today, a document must match EVERY token\n(each plain token by exact term, each prefix token by some term sharing the prefix).\nA prefix token's contribution to the frequency score is the summed count of every\ndocument term that starts with the prefix.\n\n## Contract\n\n  - Package name stays `searchprefix`; keep the class `SearchIndex` with the public\n    API `add_document(doc_id, text)` and `search(query) -> list[doc_id]`, exposed\n    from `searchprefix.public` (and re-exported from `searchprefix`).\n  - Do NOT change the existing exact-term behavior, the ranking (term frequency\n    descending, ascending-doc-id tie-break), or the determinism. Every query that\n    worked before must still return the same result.\n  - ADD prefix matching: a query token ending in `*` matches any document term\n    beginning with the prefix before the `*`. The `*` is the prefix marker, not part\n    of the matched text. A bare `*` (empty prefix) contributes nothing / is ignored.\n  - Mid-word (non-prefix) substrings must NOT match.\n\nDo not change the package name, the class name, or the method signatures. Add prefix\nsupport so the examples above hold while every existing exact-search and ranking\nbehavior is preserved.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "prefix_matches_multiple",
        "desc": "search('pay*')=['d1', 'd2']"
      },
      {
        "id": "prefix_excludes_unrelated",
        "desc": "search('pay*')=['d1', 'd2']"
      },
      {
        "id": "prefix_other_term",
        "desc": "search('ship*')=['d3']"
      },
      {
        "id": "prefix_not_midword",
        "desc": "search('ment*')=[]"
      },
      {
        "id": "prefix_ranks_by_frequency",
        "desc": "search('pay*')=['d1', 'd2']"
      },
      {
        "id": "mixed_plain_and_prefix",
        "desc": "search('received pay*')=['d1']"
      },
      {
        "id": "exact_term_match",
        "desc": "search('payment')=['d1']"
      },
      {
        "id": "exact_not_prefix",
        "desc": "search('pay')=[]"
      },
      {
        "id": "rank_by_term_frequency",
        "desc": "search('alpha')=['r1', 'r2']"
      },
      {
        "id": "and_semantics_multi_term",
        "desc": "search('quick fox')=['m1']"
      }
    ],
    "num_checks": 10,
    "has_setup": true
  },
  {
    "slug": "semvercmp",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `semvercmp`: a Semantic\nVersioning 2.0 precedence comparator. The package is already written, imports\ncleanly, and the happy path works -- it orders plain `major.minor.patch`\nversions correctly and compares two simple word-only pre-releases (like\n`1.0.0-alpha` vs `1.0.0-beta`) the right way. It is used to decide which of two\nrelease tags is newer: `compare(a, b)` returns -1 when `a` precedes `b`, 0 when\nthey have equal precedence, and 1 when `a` follows `b`.\n\n## Bug report\n\nThe comparator is wrong at the edges, and the symptoms slipped through because\ncoarse testing (plain `x.y.z` versions and two word-only pre-releases) looks\nfine:\n\n  1. A pre-release is ranked as EQUAL to its final release: `compare(\"1.0.0-rc.1\",\n     \"1.0.0\")` returns 0. A released version is supposed to OUTRANK any of its\n     own pre-releases -- `1.0.0-rc.1` must come BEFORE (be less than) `1.0.0`.\n\n  2. Numeric pre-release identifiers are mis-ordered. `1.0.0-2` is reported as\n     NEWER than `1.0.0-10`, because the identifiers are compared as text\n     (\"2\" > \"10\" alphabetically). Numeric identifiers are supposed to compare as\n     NUMBERS. Relatedly, a numeric identifier is supposed to rank BELOW an\n     alphanumeric one regardless of letters, and that rule is not enforced\n     either.\n\n  3. When one pre-release is a leading run of the other, they are called EQUAL:\n     `compare(\"1.0.0-alpha\", \"1.0.0-alpha.1\")` returns 0. The version with MORE\n     identifiers is supposed to win when every shared identifier matches, so\n     `1.0.0-alpha` must come BEFORE `1.0.0-alpha.1`.\n\n  4. Build metadata changes the answer when it must not. `compare(\"1.0.0+build.1\",\n     \"1.0.0+build.2\")` returns -1, and a build tag can even flip a comparison\n     that should be a tie. Everything after a `+` is build metadata and must be\n     IGNORED for precedence.\n\nFind and fix the defects so the comparator honours the contract below exactly.\nKeep the public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `semvercmp`. The grader imports `semvercmp.public` (falling back\n  to `semvercmp`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change the signature):\n      compare(a: str, b: str) -> int      # -1, 0, or 1\n- Inputs are valid SemVer 2.0 version strings of the shape\n  `major.minor.patch` optionally followed by `-<pre-release>` and/or\n  `+<build-metadata>`, in that order. `major`, `minor`, `patch` are\n  non-negative integers; pre-release and build are dot-separated identifiers.\n- `compare(a, b)` returns -1 if `a` has LOWER precedence than `b`, 1 if HIGHER,\n  and 0 if they have EQUAL precedence. Precedence is computed as follows:\n\n    a. Compare `major`, then `minor`, then `patch`, each NUMERICALLY (so\n       `1.0.0` < `1.0.10` < `1.1.0` < `2.0.0`). The first differing field\n       decides; if all three are equal, move on to the pre-release.\n\n    b. A version WITHOUT a pre-release has HIGHER precedence than the otherwise\n       identical version WITH one:\n         `1.0.0-anything` < `1.0.0`.\n       (Two versions that both lack a pre-release and are equal so far are\n       equal.)\n\n    c. When BOTH have a pre-release, compare their dot-separated identifiers\n       left to right:\n         * an identifier of only digits is NUMERIC; compare two numeric\n           identifiers as integers (so `2` < `10`, never as text);\n         * a numeric identifier always has LOWER precedence than an\n           alphanumeric one (so `1.0.0-1` < `1.0.0-alpha`);\n         * two alphanumeric identifiers compare by ASCII / lexical order;\n         * the first identifier that differs decides.\n\n    d. If every identifier they SHARE is equal, the pre-release with MORE\n       identifiers has the HIGHER precedence:\n         `1.0.0-alpha` < `1.0.0-alpha.1`.\n\n    e. Build metadata (everything after the first `+`) is IGNORED entirely for\n       precedence. It is NOT part of the comparison and never changes the\n       result: `1.0.0+build.1`, `1.0.0+build.2`, and `1.0.0` all have equal\n       precedence, and `1.0.0-alpha+x` equals `1.0.0-alpha`.\n\n## I/O example\n\n    >>> compare(\"1.0.0\", \"2.0.0\")\n    -1\n    >>> compare(\"1.0.10\", \"1.0.2\")          # patch compared numerically\n    1\n    >>> compare(\"1.0.0-alpha\", \"1.0.0\")     # release outranks its pre-release\n    -1\n    >>> compare(\"1.0.0-2\", \"1.0.0-10\")      # numeric identifiers: 2 < 10\n    -1\n    >>> compare(\"1.0.0-1\", \"1.0.0-alpha\")   # numeric ranks below alphanumeric\n    -1\n    >>> compare(\"1.0.0-alpha\", \"1.0.0-alpha.1\")   # more identifiers wins\n    -1\n    >>> compare(\"1.0.0+build.1\", \"1.0.0+build.2\")  # build metadata ignored\n    0\n    >>> compare(\"1.0.0\", \"1.0.0\")\n    0\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "core_numeric_order",
        "desc": "major/minor/patch compare numerically, most-significant first"
      },
      {
        "id": "core_multidigit",
        "desc": "multi-digit fields compare as numbers, not as text (10 > 2)"
      },
      {
        "id": "core_equal",
        "desc": "two identical plain versions are equal"
      },
      {
        "id": "antisymmetry",
        "desc": "swapping the arguments negates the result for plain versions"
      },
      {
        "id": "pre_word_order",
        "desc": "two word-only pre-releases order by ASCII (alpha < beta)"
      },
      {
        "id": "pre_below_release",
        "desc": "a pre-release ranks BELOW its own release (1.0.0-alpha < 1.0.0)"
      },
      {
        "id": "release_above_pre",
        "desc": "the release ranks ABOVE the pre-release (mirror, 1.0.0 > 1.0.0-alpha)"
      },
      {
        "id": "pre_below_release_rc",
        "desc": "a late-stage pre-release still ranks below the release (rc.1 < 1.0.0)"
      },
      {
        "id": "numeric_ident_value",
        "desc": "numeric identifiers compare by value, not text (2 < 10)"
      },
      {
        "id": "numeric_ident_value_big",
        "desc": "multi-digit numeric identifiers compare by value (9 < 100)"
      },
      {
        "id": "numeric_below_alpha",
        "desc": "a numeric identifier ranks below an alphanumeric one (1 < alpha)"
      },
      {
        "id": "alpha_above_numeric",
        "desc": "an alphanumeric identifier ranks above a numeric one (mirror)"
      },
      {
        "id": "more_identifiers_wins",
        "desc": "with shared identifiers equal, more identifiers wins (alpha < alpha.1)"
      },
      {
        "id": "more_identifiers_mirror",
        "desc": "the longer pre-release ranks higher (mirror of the tiebreak)"
      },
      {
        "id": "build_ignored_equal",
        "desc": "build metadata is ignored: +build.1 and +build.2 are equal"
      },
      {
        "id": "build_ignored_vs_plain",
        "desc": "build metadata is ignored vs a plain version (1.0.0+x == 1.0.0)"
      },
      {
        "id": "build_ignored_with_pre",
        "desc": "build metadata is ignored alongside a pre-release (-a+x == -a)"
      },
      {
        "id": "spec_ordering_chain",
        "desc": "the full SemVer spec precedence chain orders strictly ascending"
      }
    ],
    "num_checks": 18,
    "has_setup": true
  },
  {
    "slug": "serialhook",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `serialhook`: a JSON-like\nserializer. The package is already written, imports cleanly, and works for the\nJSON basic types: `dumps(obj)` serializes a `dict` / `list` / `str` / `int` /\n`float` / `bool` / `None` to a JSON string, and `loads(s)` parses it back. It is\na thin wrapper over the standard library's `json`, so its output for basic\nvalues is byte-for-byte identical to `json.dumps` with default settings.\n\nTwo things are missing. There is NO way to serialize custom Python types\n(datetime, Decimal, \u2026) \u2014 they raise `TypeError` like `json` does \u2014 and there is\nNO guard against circular references, so a structure that contains itself\nrecurses until the interpreter gives up.\n\n## Task\n\nAdd (a) a custom-type HOOK mechanism and (b) circular-reference DETECTION, WITHOUT\nbreaking the existing basic-type behavior.\n\n## Semantics (read carefully \u2014 this is the whole task)\n\n### (a) Custom-type hooks\n\n- Add `register(type, tag, encode, decode)`. After registering, a value of that\n  `type` serializes to a TAGGED FORM: the JSON object\n  `{\"__type__\": tag, \"value\": <encoded>}`, where `<encoded>` is whatever\n  `encode(value)` returns. `loads` reverses it: a tagged form whose `tag` is\n  registered is routed to that type's `decode` callable, reconstructing the\n  original value.\n\n- The encoded payload is itself serialized RECURSIVELY. So `encode` may return a\n  payload that contains basic types OR other registered types (e.g. a dict that\n  holds a datetime), and it must round-trip. On `loads`, decode the payload\n  FIRST, then hand the decoded payload to the type's `decode`.\n\n- Registered types must round-trip when NESTED anywhere \u2014 inside lists, inside\n  dict values, and inside the payloads of other registered types \u2014 not just at\n  the top level.\n\n- Decode dispatch is BY TAG. A tagged form naming a tag that is not registered\n  is an error: raise `UnknownTagError`. Do not silently return the raw tagged\n  dict.\n\n- Be careful not to mistake ordinary user data for a tagged form. A dict is a\n  tagged form ONLY when it has exactly the two keys `__type__` and `value` and\n  its `__type__` is a string. A plain dict that merely happens to contain a\n  `\"__type__\"` key alongside other keys is ordinary data and must round-trip\n  unchanged.\n\n### (b) Circular-reference detection\n\n- `dumps` must detect cycles and raise `CircularReferenceError` (a clear error),\n  not recurse forever. Detection is along the CURRENT PATH (ancestry from the\n  root to the value being written), not \"seen anywhere\".\n\n- A value that merely appears more than once in SIBLING positions \u2014 a shared or\n  diamond reference, e.g. the same inner list placed at two keys of a dict \u2014 is\n  NOT a cycle and must serialize fine.\n\n### General\n\n- Do not change the basic-type behavior. `dumps` of a basic value must stay\n  byte-identical to `json.dumps(value)` defaults, and `loads(dumps(x)) == x` for\n  any basic `x`.\n\n## Example\n\n    from datetime import datetime\n    from decimal import Decimal\n\n    register(datetime, \"datetime\",\n             lambda dt: dt.isoformat(),\n             lambda s: datetime.fromisoformat(s))\n    register(Decimal, \"decimal\", str, Decimal)\n\n    dt = datetime(2020, 1, 2, 3, 4, 5)\n    wire = dumps({\"when\": dt, \"tags\": [\"a\", \"b\"]})\n    # wire == '{\"when\": {\"__type__\": \"datetime\", \"value\": \"2020-01-02T03:04:05\"}, \"tags\": [\"a\", \"b\"]}'\n    back = loads(wire)\n    assert back[\"when\"] == dt          # nested registered type round-trips\n    assert back[\"tags\"] == [\"a\", \"b\"]  # basic data untouched\n\n    # A registered type inside another registered type's payload:\n    wire = dumps([Decimal(\"1.5\"), {\"d\": Decimal(\"2\")}])\n    assert loads(wire) == [Decimal(\"1.5\"), {\"d\": Decimal(\"2\")}]\n\n    # Shared (NOT circular) reference is fine:\n    inner = [1, 2]\n    dumps({\"x\": inner, \"y\": inner})    # OK \u2014 no error\n\n    # Circular reference is rejected:\n    a = []\n    a.append(a)\n    dumps(a)                           # raises CircularReferenceError\n\n    # Basic round-trip stays byte-identical:\n    assert dumps({\"b\": 1, \"a\": [True, None, 1.5]}) == '{\"b\": 1, \"a\": [true, null, 1.5]}'\n\n    # A plain dict that happens to have a \"__type__\" key is data, not a tag:\n    assert loads(dumps({\"__type__\": \"x\", \"n\": 1})) == {\"__type__\": \"x\", \"n\": 1}\n\n## Contract\n\n- Package name: `serialhook`. The grader imports `serialhook.public` (falling\n  back to `serialhook`); keep both import paths working.\n- Module-level functions `dumps(obj) -> str`, `loads(s) -> obj`, and\n  `register(type, tag, encode, decode) -> None`, importable from the package.\n- `CircularReferenceError` and `UnknownTagError`, both importable from the\n  package, raised as described above. (They may share a common base class, but\n  that is not required.)\n- Standard library only. No threading requirement.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "register_top_level",
        "desc": "a registered type round-trips at the top level via the tagged form"
      },
      {
        "id": "tagged_wire_shape",
        "desc": "a registered value serializes to {'__type__': tag, 'value': <encoded>}"
      },
      {
        "id": "registered_in_list",
        "desc": "a registered type nested inside a list round-trips"
      },
      {
        "id": "registered_in_dict_value",
        "desc": "a registered type nested as a dict value round-trips"
      },
      {
        "id": "registered_in_payload",
        "desc": "a registered type inside another registered type's payload round-trips"
      },
      {
        "id": "two_types_mixed",
        "desc": "two registered types in one structure each decode via their own tag"
      },
      {
        "id": "unknown_tag_raises",
        "desc": "loads of a tagged form with an unregistered tag raises UnknownTagError"
      },
      {
        "id": "plain_type_key_is_data",
        "desc": "a plain dict with a '__type__' key among others is data, not a tag"
      },
      {
        "id": "exact_two_key_required",
        "desc": "a dict with __type__/value plus a third key is data, not a tag"
      },
      {
        "id": "cycle_self_list",
        "desc": "dumps of a list that contains itself raises CircularReferenceError"
      },
      {
        "id": "cycle_self_dict",
        "desc": "dumps of a dict that contains itself raises CircularReferenceError"
      },
      {
        "id": "cycle_indirect",
        "desc": "dumps of an indirect (a->b->a) cycle raises CircularReferenceError"
      },
      {
        "id": "shared_ref_ok",
        "desc": "a shared (diamond) reference is NOT a cycle and serializes fine"
      },
      {
        "id": "shared_ref_reused_after",
        "desc": "the same list reused in a sibling AND deeper position serializes fine"
      },
      {
        "id": "regression_basic_roundtrip",
        "desc": "basic types round-trip: loads(dumps(x)) == x"
      },
      {
        "id": "regression_byte_identical",
        "desc": "dumps of basic values is byte-identical to json.dumps defaults"
      },
      {
        "id": "regression_bool_int_distinct",
        "desc": "bool/int/float/None survive the round-trip with the right types"
      }
    ],
    "num_checks": 17,
    "has_setup": true
  },
  {
    "slug": "slotfinder",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `slotfinder`.\n\nBuild a meeting availability engine. Use only the Python standard library.\n\nExpose:\n\n```python\ndef find_slots(request: dict) -> list[dict]: ...\n```\n\nRequest format:\n\n```json\n{\n  \"timezone\": \"America/New_York\",\n  \"duration_minutes\": 30,\n  \"search_start\": \"2026-01-05T00:00:00Z\",\n  \"search_end\": \"2026-01-10T00:00:00Z\",\n  \"participants\": [\n    {\n      \"id\": \"u1\",\n      \"working_hours\": [{\"days\": [1,2,3,4,5], \"start\": \"09:00\", \"end\": \"17:00\"}],\n      \"busy\": [{\"start\": \"2026-01-05T15:00:00Z\", \"end\": \"2026-01-05T16:00:00Z\"}]\n    }\n  ]\n}\n```\n\nFind slots where all participants are within working hours and not busy. Output slots in UTC ISO format.\n\nSupport timezones with `zoneinfo`, daylight saving transitions, multiple participants, multiple working-hour blocks, and configurable slot granularity with default 15 minutes.\n\nInclude a CLI:\n\n```bash\npython -m slotfinder find request.json\n```\n\nInclude tests for overlapping busy periods, working-hour boundaries, multiple timezones, DST transitions, no availability, deterministic ordering, and granularity.\n\n## Contract\n\nThis section pins the behavior the grader checks. Anything the prose above leaves\nopen is fixed here; do not contradict it.\n\n### Import path & CLI\n- Importable as `slotfinder.public` exposing `find_slots(request: dict) -> list[dict]`.\n- CLI entry point `python -m slotfinder find <request.json>` that prints the result of\n  `find_slots` to stdout as a JSON array. CLI output MUST be valid JSON (a JSON list of\n  slot objects). Reading the request from the given file path is the only required form.\n\n### Slot shape & ordering\n- Each returned slot is a dict with exactly the keys `start` and `end`:\n  `{\"start\": <ISO-UTC>, \"end\": <ISO-UTC>}`.\n- `start` and `end` are ISO-8601 timestamps in UTC. They denote the same instant\n  regardless of formatting; the grader compares instants, so either a `Z` suffix or a\n  `+00:00` offset is accepted, with or without a `T` separator as produced by\n  `datetime.isoformat()`. The slot length `end - start` equals `duration_minutes`.\n- Slots are returned sorted ascending by start instant (deterministic ordering).\n- Slots are NON-OVERLAPPING candidate windows: the returned set never contains two slots\n  whose `[start, end)` intervals overlap.\n\n### Time model (all comparisons are at instant level)\n- `duration_minutes` (int, required): the length of each slot in minutes.\n- `granularity_minutes` (int, optional, DEFAULT 15): candidate slot starts are aligned to\n  a grid of this many minutes, measured from `search_start`. A candidate window is\n  `[t, t + duration_minutes)` for grid points `t = search_start + k * granularity_minutes`.\n- `search_start` / `search_end` are ISO-8601 UTC instants. Only windows fully inside\n  `[search_start, search_end)` are considered (a window may not extend past `search_end`).\n- A grid point `t` becomes a returned slot iff EVERY participant is, for the WHOLE window\n  `[t, t + duration_minutes)`, both (1) within working hours and (2) not busy. Otherwise\n  the grid point is rejected.\n- Non-overlapping packing is greedy from the earliest valid grid point: scan grid points\n  in ascending order; when a window is accepted, the next candidate considered starts at\n  or after that window's end (windows already covered by an accepted slot are skipped).\n\n### Working hours\n- `working_hours` is a list of blocks; a participant with no blocks is never available.\n  Multiple blocks union (a moment is \"within working hours\" if it falls in ANY block).\n- `days` are ISO weekday integers in the participant's LOCAL timezone: Monday=1, Tuesday=2,\n  Wednesday=3, Thursday=4, Friday=5, Saturday=6, Sunday=7.\n- `start` / `end` are `\"HH:MM\"` wall-clock times in the participant's LOCAL timezone. A\n  block covers the LOCAL-time half-open interval `[start, end)` on each listed day.\n  `end` is exclusive; `end == start` means an empty block. `end` is on the same local day\n  (no overnight wrap). A window is \"within working hours\" only if the participant's entire\n  `[t, t+duration)` interval lies inside a single working-hours block for that local day.\n- Day membership and the `[start, end)` wall-clock bounds are evaluated in LOCAL time, so\n  they shift correctly across daylight-saving transitions (e.g. 09:00 local is a different\n  UTC instant before and after a DST change). The reference uses `zoneinfo` for this.\n\n### Timezone\n- The top-level `timezone` is an IANA name used as the default local zone for participants.\n- A participant MAY override with a `timezone` key; if absent, the top-level `timezone`\n  applies. Each participant's working hours are interpreted in that participant's zone.\n\n### Busy intervals\n- `busy` is a list of `{\"start\": <ISO-UTC>, \"end\": <ISO-UTC>}` instants (UTC). Each is a\n  half-open interval `[start, end)`. A window is blocked if it intersects ANY busy interval\n  of ANY participant. Touching at an endpoint (window start == busy end, or window end ==\n  busy start) does NOT count as a conflict.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "basic_availability",
        "desc": "single-participant slots match the derived expected set"
      },
      {
        "id": "busy_excludes",
        "desc": "a busy interval removes exactly the windows it overlaps"
      },
      {
        "id": "busy_endpoint_touch",
        "desc": "a window touching a busy interval at an endpoint is NOT blocked"
      },
      {
        "id": "working_hour_boundary",
        "desc": "no slot falls outside the local [start, end) working hours"
      },
      {
        "id": "multi_participant",
        "desc": "only the intersection of all participants' availability is returned"
      },
      {
        "id": "multi_block",
        "desc": "multiple working-hour blocks union correctly"
      },
      {
        "id": "dst_transition",
        "desc": "working hours track local wall-clock across a DST transition"
      },
      {
        "id": "no_availability",
        "desc": "a fully-busy / out-of-hours request returns an empty list"
      },
      {
        "id": "granularity_default",
        "desc": "default granularity is 15 minutes"
      },
      {
        "id": "granularity_custom",
        "desc": "a custom granularity changes the candidate grid"
      },
      {
        "id": "non_overlapping",
        "desc": "returned slots never overlap each other"
      },
      {
        "id": "deterministic_order",
        "desc": "slots are sorted ascending by start and stable across runs"
      },
      {
        "id": "slot_shape",
        "desc": "each slot is {start, end} ISO-UTC with length == duration_minutes"
      },
      {
        "id": "cli_json",
        "desc": "`python -m slotfinder find <file>` emits a JSON list of slots"
      }
    ],
    "num_checks": 14,
    "has_setup": false
  },
  {
    "slug": "statichisel",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `statichisel`.\n\nBuild a static site generator. Use only the Python standard library.\n\nInput directory structure:\n\n```text\nsite/\n  pages/\n    index.md\n    about.md\n  templates/\n    base.html\n  assets/\n    style.css\n  site.json\n```\n\nMarkdown files begin with front matter:\n\n```markdown\n---\ntitle: Home\nslug: /\ntemplate: base.html\n---\n\n# Welcome\n\nThis is **bold** text.\n```\n\nSupport Markdown features:\n\n```text\nheadings\nparagraphs\nbold\nitalic\ninline code\nfenced code blocks\nunordered lists\nlinks\n```\n\nTemplate variables:\n\n```text\n{{ title }}\n{{ content }}\n{{ nav }}\n```\n\nImplement:\n\n```python\ndef build_site(source_dir: str, output_dir: str) -> dict: ...\n```\n\nThe build must copy assets, render pages, generate a navigation list, and return a JSON-serializable manifest of generated files.\n\nInclude a CLI:\n\n```bash\npython -m statichisel build site/ dist/\n```\n\nInclude tests for front matter parsing, Markdown rendering, template rendering, asset copying, slug handling, malformed front matter, and deterministic output.\n\n## Contract\n\nThis section pins the parts of the spec that the held-out grader checks. The grader\nverifies BEHAVIOR and rendered CONTENT/STRUCTURE \u2014 never exact HTML byte-equality,\nbecause the exact markup is implementation-specific. Anything not pinned here is free.\n\n### Import path / package layout\n\n- The package is importable as `statichisel`.\n- `build_site` is importable as `statichisel.public.build_site` \u2014 i.e. the module\n  `statichisel/public.py` exposes the top-level function `build_site`.\n- The CLI is invocable as `python -m statichisel build <source_dir> <output_dir>`\n  (i.e. `statichisel/__main__.py` exists and handles the `build` subcommand). The\n  CLI's stdout format is NOT pinned (it may print a manifest, a summary, or nothing);\n  the grader only requires exit code 0 and that the output files appear on disk.\n\n### `build_site(source_dir, output_dir) -> dict`\n\n- Signature: `build_site(source_dir: str, output_dir: str) -> dict`. Both arguments\n  are filesystem path strings. `output_dir` need not pre-exist; `build_site` creates it.\n- Returns a JSON-serializable manifest `dict`. The manifest MUST let a caller\n  enumerate the generated files. The grader accepts ANY of these manifest shapes\n  (it derives the file list tolerantly, it does not require one specific key):\n    - a top-level key whose name contains \"file\"/\"page\"/\"output\"/\"generated\"/\"manifest\"\n      mapping to a list of file entries, OR\n    - a top-level key \"outputs\"/\"results\"/\"build\" holding such a list, OR\n    - the manifest itself being a list of file entries.\n  Each file entry is EITHER a path string, OR a dict carrying the path under any of\n  the keys: `path`, `output`, `dest`, `file`, `url`, `target`, `name`. Paths may be\n  absolute, or relative to `output_dir`, or relative to cwd \u2014 the grader normalizes\n  by basename and by joining against `output_dir`, so any consistent convention passes.\n- The manifest must be JSON-serializable (`json.dumps(manifest)` must not raise).\n- Calling `build_site` twice with identical inputs must be deterministic: the manifest\n  must serialize identically across runs, and the set of generated output files (by\n  path relative to `output_dir`) must be identical across runs.\n\n### Pages, front matter, slugs\n\n- Each `.md` file under `pages/` begins with YAML-ish front matter delimited by lines\n  of exactly `---` (a `---` line, key: value lines, a closing `---` line), followed by\n  the Markdown body. Front matter keys used by the grader: `title`, `slug`, `template`.\n- Each page produces exactly one generated HTML file in the output. The page reachable\n  at slug `/` (the root/index page) must produce a file whose basename is `index.html`.\n  A page with another slug (e.g. `about` or `/about`) must produce a corresponding\n  `.html` file (the grader matches by the slug stem, e.g. `about` -> a file whose\n  basename or path stem is `about`, accepting `about.html` or `about/index.html`).\n- Malformed front matter (e.g. a missing closing `---`) must NOT crash the build: the\n  build must complete and still produce output for the well-formed pages. (The grader\n  does not pin what happens to the malformed page itself, only that the build survives\n  and the well-formed pages still render.)\n\n### Rendered content / structure (NOT exact HTML)\n\nFor a page whose Markdown body contains the listed feature, the grader checks the\nrendered HTML of that page for the following STRUCTURE. Each is satisfied by common\nHTML equivalents; exact tag choice and attributes are free:\n- bold `**x**` -> the text `x` wrapped in `<strong>...</strong>` OR `<b>...</b>`.\n- italic `*x*` / `_x_` -> the text `x` wrapped in `<em>...</em>` OR `<i>...</i>`.\n- heading `# H` -> the text `H` wrapped in some `<h1>`..`<h6>` tag.\n- inline code `` `x` `` -> the text `x` wrapped in `<code>...</code>`.\n- fenced code block -> the block's contents wrapped in `<pre>` and/or `<code>`.\n- unordered list (`- item` lines) -> `<ul>` with `<li>` item(s).\n- link `[text](url)` -> an `<a>` tag whose `href` is `url` and whose anchor text is `text`.\n- The page `title` from front matter appears substituted into the rendered output\n  (the `{{ title }}` template variable is replaced with the front matter title; the\n  literal string `{{ title }}` must NOT remain in the output).\n- The template's `{{ content }}` is replaced by the page's rendered body, and the\n  literal `{{ content }}` must NOT remain in the output.\n- A navigation list (`{{ nav }}`) is generated and substituted: the rendered output of\n  a page that uses `{{ nav }}` contains links/entries referencing the OTHER pages of\n  the site (the grader checks that nav references more than one page, e.g. multiple\n  `<a>` tags or page titles/slugs), and the literal `{{ nav }}` must NOT remain.\n\n### Assets\n\n- Every file under the source `assets/` directory is copied into the output. The\n  grader checks that an asset placed at `assets/<name>` is present somewhere under\n  `output_dir` after the build (matched by basename and by byte-equality of contents).\n  The exact destination subpath (e.g. `assets/style.css` vs `style.css`) is NOT pinned.\n\n# ASSUMES (conventions the grader fixes that the bare SPEC leaves open; pinned above\n# so the model is graded against the Contract, never a hidden guess):\n#  - `build_site` CREATES output_dir if absent (rather than requiring it to pre-exist).\n#  - The root page is the one with front-matter slug `/`; it emits `index.html`.\n#  - A non-root slug `s` emits a file whose basename/stem is `s` (`s.html` OR `s/index.html`).\n#  - The manifest enumerates generated files under a \"file\"/\"page\"/\"output\"-ish key,\n#    or \"outputs\"/\"results\"/\"build\", or is itself a list; entries are path strings or\n#    dicts keyed by path/output/dest/file/url/target/name. (Tolerant \u2014 see above.)\n#  - Asset destination subpath is free; only basename + byte-identical contents are checked.\n#  - Malformed front matter degrades gracefully (no crash); the malformed page's own\n#    fate is unspecified, only build survival + well-formed pages rendering are checked.\n#  - CLI stdout format is free; only exit 0 + files-on-disk are checked.\n#  - Markdown structure is checked by HTML EQUIVALENCE (strong|b, em|i, h1..h6, etc.),\n#    never by exact bytes.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "manifest_dict",
        "desc": "build_site returns a JSON-serializable dict manifest"
      },
      {
        "id": "manifest_lists_files",
        "desc": "manifest enumerates the generated files"
      },
      {
        "id": "index_emitted",
        "desc": "the slug '/' page is emitted as index.html on disk"
      },
      {
        "id": "about_emitted",
        "desc": "a non-root slug page is emitted to its own .html file"
      },
      {
        "id": "title_substituted",
        "desc": "{{ title }} is replaced with the front-matter title"
      },
      {
        "id": "content_substituted",
        "desc": "{{ content }} is replaced (no literal {{ content }} remains)"
      },
      {
        "id": "bold",
        "desc": "bold **x** renders as <strong>/<b>"
      },
      {
        "id": "italic",
        "desc": "italic *x* renders as <em>/<i>"
      },
      {
        "id": "heading",
        "desc": "heading '# H' renders as an <h1>..<h6> tag"
      },
      {
        "id": "inline_code",
        "desc": "inline `code` renders as <code>"
      },
      {
        "id": "fenced_code",
        "desc": "fenced code block renders inside <pre>/<code>"
      },
      {
        "id": "unordered_list",
        "desc": "unordered list renders as <ul> with <li> items"
      },
      {
        "id": "link",
        "desc": "link [t](u) renders as <a href=\"u\">t</a>"
      },
      {
        "id": "nav_generated",
        "desc": "{{ nav }} is replaced with a nav referencing other pages"
      },
      {
        "id": "assets_copied",
        "desc": "files under assets/ are copied into the output (byte-identical)"
      },
      {
        "id": "deterministic",
        "desc": "two identical builds produce identical manifest + output set"
      },
      {
        "id": "malformed_frontmatter_survives",
        "desc": "malformed front matter does not crash the build"
      },
      {
        "id": "cli_build_exit0",
        "desc": "`python -m statichisel build` exits 0 and writes files to disk"
      }
    ],
    "num_checks": 18,
    "has_setup": false
  },
  {
    "slug": "textflow",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 textflow: the test suite is failing\n\nYou have an existing Python package `textflow`, a tiny full-text-justification\nhelper. It ships with a unittest suite in `textflow/test_textflow.py`, and right\nnow several of those tests FAIL. Fix the code so that ALL the tests pass. Do not\nrewrite the package from scratch and do not change its public API.\n\n## Symptom\n\n`justify(words, width)` packs words greedily onto lines and pads each line out to\nexactly `width` characters. Lines whose words happen to fill the width with plain\nsingle spaces already come out right, but several padding / spacing cases are\nwrong:\n\n    from textflow.public import justify\n\n    # extra spaces are pushed to the RIGHT gaps instead of the left:\n    justify([\"a\", \"b\", \"c\", \"next\"], 8)\n    #   EXPECTED ['a   b  c', 'next    ']\n    #   ACTUAL   ['a  b   c', 'next    ']   (wider gap on the right, not left)\n\n    # a single-word line is NOT padded out to width:\n    justify([\"longword\", \"tail\"], 12)\n    #   EXPECTED ['longword    ', 'tail        ']\n    #   ACTUAL   ['longword', 'tail']             (neither line padded to width)\n\n    # the LAST line is left-justified-and-padded, not stretched / dropped:\n    justify([\"alpha\", \"beta\", \"gamma\"], 14)\n    #   EXPECTED ['alpha     beta', 'gamma         ']\n    #   ACTUAL   ['alpha     beta', 'gamma']      (last line not padded; a\n    #                                              multi-word last line would get\n    #                                              its single spaces stretched)\n\nThese defects interact: a paragraph that contains an uneven interior line, a\nsingle-word interior line, AND a ragged final line exercises all three at once.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `textflow` package:\n\n    python -m unittest textflow.test_textflow\n\n## Contract (must hold after your fix)\n\n* Package name stays `textflow`; import path `textflow` / `textflow.public`.\n* Keep the public API exactly: `justify(words: list[str], width: int) ->\n  list[str]` and the `JustifyError` exception. Do not rename them.\n* `words` is a list of non-empty strings; `width` is a positive int. A word\n  longer than `width`, an empty word, a non-positive `width`, or a non-list /\n  non-int argument raises `JustifyError`. An empty `words` list returns `[]`.\n* PACKING: words are placed greedily, one space assumed between adjacent words.\n  A word joins the current line while `current_word_chars + gaps + len(word) <=\n  width` (where `gaps` is the number of words already on the line); otherwise it\n  starts a new line.\n* OUTPUT: one string per line, and EVERY returned line is EXACTLY `width`\n  characters wide.\n* FULL JUSTIFICATION (every line EXCEPT the last, with 2+ words): the leftover\n  space (`width` minus the total word characters) is spread across the gaps\n  between words as evenly as possible. When it does not divide evenly, the EXTRA\n  spaces go to the LEFT-most gaps, so earlier gaps are (by at most one space)\n  wider than later ones. With G gaps and S leftover spaces, the first `S mod G`\n  gaps get `S // G + 1` spaces and the rest get `S // G`.\n* SINGLE-WORD LINE: a line holding exactly one word has no gap to stretch, so it\n  is left-justified \u2014 the word followed by enough trailing spaces to reach\n  `width`.\n* LAST LINE: the final line is left-justified too \u2014 its words joined by SINGLE\n  spaces, then padded on the right with spaces out to `width`. Its internal\n  single spaces are NEVER stretched, even when it holds several words.\n\nExample:\n\n    justify([\"practical\", \"no\", \"gap\", \"x\", \"the\", \"final\", \"row\"], 10)\n    #   -> ['practical ',   # single interior word: left-justified + padded\n    #       'no  gap  x',   # interior, fully justified (even here)\n    #       'the  final',   # interior, fully justified\n    #       'row       ']   # last line: left-justified + padded\n\nStandard library only. Do not change the package name or the public\nfunction/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "single_line_exact",
        "desc": "words filling a line exactly pass through"
      },
      {
        "id": "even_distribution",
        "desc": "evenly divisible spaces look right under any rule"
      },
      {
        "id": "even_three_gaps",
        "desc": "three gaps that divide evenly look right"
      },
      {
        "id": "two_word_full_width",
        "desc": "two words that exactly fill a line pass through"
      },
      {
        "id": "even_multi_line",
        "desc": "consecutive even-fit lines pack and justify cleanly"
      },
      {
        "id": "greedy_pack_widths",
        "desc": "greedy packing yields exactly-width lines"
      },
      {
        "id": "uneven_extra_left_2gaps",
        "desc": "1 extra space goes to the left gap"
      },
      {
        "id": "uneven_extra_left_3gaps",
        "desc": "2 extra spaces go to the first two gaps"
      },
      {
        "id": "uneven_big_remainder",
        "desc": "remainder front-loaded across many gaps"
      },
      {
        "id": "uneven_width_invariant",
        "desc": "uneven lines are still exactly width wide"
      },
      {
        "id": "single_word_interior_padded",
        "desc": "lone interior word padded out to width"
      },
      {
        "id": "single_word_interior_width",
        "desc": "lone interior word line is exactly width"
      },
      {
        "id": "single_word_then_pack",
        "desc": "single-word line then a justified line"
      },
      {
        "id": "last_line_left_justified",
        "desc": "final line left-justified + padded, not stretched"
      },
      {
        "id": "last_line_multiword_single_spaced",
        "desc": "final line keeps single spaces then pads"
      },
      {
        "id": "last_line_is_width",
        "desc": "the last line is still exactly width wide"
      },
      {
        "id": "interaction_all_three",
        "desc": "uneven + single-word + last-line together"
      },
      {
        "id": "interaction_long_paragraph",
        "desc": "a longer paragraph exercises every path"
      },
      {
        "id": "interaction_widths",
        "desc": "every line of the interaction paragraph is width"
      },
      {
        "id": "empty_words_empty",
        "desc": "empty word list yields empty result"
      },
      {
        "id": "long_word_raises",
        "desc": "a word longer than width raises JustifyError"
      },
      {
        "id": "bad_width_raises",
        "desc": "a non-positive width raises JustifyError"
      }
    ],
    "num_checks": 22,
    "has_setup": true
  },
  {
    "slug": "textwidth",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `textwidth`: a greedy word-wrap\nutility. The package is already written, imports cleanly, and the happy path\nworks -- given a short sentence of ordinary single-spaced words and a generous\nwidth, it packs whole words onto lines and returns the wrapped lines. It is used\nto lay out plain-text output for a fixed-width terminal: every block of text is\npassed through `wrap(text, width)` before printing.\n\n## Bug report\n\nUnder real input the wrapper misbehaves at the edges, and the symptoms are easy\nto miss because tidy, single-spaced sentences at a roomy width look fine:\n\n  1. Lines come out NARROWER than they should. A word that would exactly fill\n     the remaining room on a line gets bumped to the next line instead of\n     packed onto the current one, so the output is ragged and uses more lines\n     than necessary. Packing should fill each line right up to `width`.\n\n  2. A word LONGER than `width` (a URL, a long identifier) blows the layout: it\n     is emitted on a line all by itself and overflows past `width`, so the\n     \"fixed-width\" output is no longer fixed-width. Such a word should be\n     hard-broken across however many full-width lines it takes.\n\n  3. Messy whitespace corrupts the output. Input with runs of multiple spaces,\n     or tabs, or embedded newlines produces lines with stray blank words,\n     doubled spaces, or wrong wrapping -- as if every space were its own word\n     boundary. Any run of whitespace should collapse to a single boundary and\n     only the actual words should survive.\n\n  4. There is a spurious trailing empty line. Empty or all-whitespace input\n     returns a list containing one empty string instead of an empty list, and\n     text with trailing whitespace leaves a dangling `\"\"` at the end of the\n     result.\n\nFind and fix the defects so the wrapper honours the contract below exactly.\nKeep the public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `textwidth`. The grader imports `textwidth.public` (falling back\n  to `textwidth`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change the signature):\n      wrap(text: str, width: int) -> list[str]\n- Greedy packing: words are placed left-to-right; each word goes on the current\n  line if it still fits, otherwise it starts a new line. Words on a line are\n  joined by exactly ONE space.\n- Width is INCLUSIVE: a line may be exactly `width` characters long. A word that\n  brings the current line's length to exactly `width` (counting the single\n  joining space) MUST stay on that line -- it fits. Only a word that would push\n  the line PAST `width` starts a new line.\n- Whitespace: the input is tokenised on ANY run of whitespace (spaces, tabs,\n  newlines, multiple spaces all count as a single boundary). Leading and\n  trailing whitespace is dropped. Empty strings are never emitted as words.\n- Overlong word: a single word whose length is greater than `width` cannot fit\n  on any line. It is HARD-BROKEN into consecutive pieces of exactly `width`\n  characters (the final piece may be shorter). No emitted line ever exceeds\n  `width` characters when `width >= 1`. The break happens at the character\n  level, in order, with no characters lost or reordered. A line already in\n  progress is flushed before the long word is broken; the long word's final\n  short tail may then be joined by further words that still fit.\n- No trailing empty line: the result contains no empty strings. Empty input,\n  or input that is only whitespace, returns `[]` (an empty list, NOT `[\"\"]`).\n- `width <= 0`: there is no positive line width to pack into, so `wrap` returns\n  `[]` for any input.\n\n## I/O example\n\n    >>> wrap(\"the quick brown fox\", 9)\n    ['the quick', 'brown fox']      # 'the quick' is exactly 9 -> it fits\n    >>> wrap(\"aa bb cc\", 5)\n    ['aa bb', 'cc']                 # 'aa bb' is exactly 5 -> packed, not split\n    >>> wrap(\"  lots   of\\twhite\\nspace  \", 11)\n    ['lots of', 'white space']      # whitespace collapses; no blank words\n    >>> wrap(\"supercalifragilistic\", 7)\n    ['superca', 'lifragi', 'listic']   # overlong word hard-broken at width 7\n    >>> wrap(\"\", 5)\n    []                              # empty input -> empty list, no trailing ''\n    >>> wrap(\"hello world\", 0)\n    []                              # width <= 0 -> empty list\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "basic_wrap",
        "desc": "an ordinary sentence wraps greedily into the expected lines"
      },
      {
        "id": "single_word",
        "desc": "a lone word shorter than width is returned on one line"
      },
      {
        "id": "all_fit_one_line",
        "desc": "words that all fit return a single line, no extra splits"
      },
      {
        "id": "exact_fit_packs",
        "desc": "a word landing the line exactly at width stays on the line"
      },
      {
        "id": "exact_fit_two_words",
        "desc": "two words whose joined length equals width pack together"
      },
      {
        "id": "no_line_exceeds_width",
        "desc": "no emitted line is ever wider than width (ordinary text)"
      },
      {
        "id": "greedy_fills",
        "desc": "packing is greedy -- each line is filled as full as it can be"
      },
      {
        "id": "collapse_multi_space",
        "desc": "runs of multiple spaces collapse to a single boundary"
      },
      {
        "id": "collapse_tabs_newlines",
        "desc": "tabs and newlines are treated as whitespace boundaries"
      },
      {
        "id": "leading_trailing_ws",
        "desc": "leading and trailing whitespace is dropped, no blank words"
      },
      {
        "id": "no_empty_words",
        "desc": "the result never contains an empty string"
      },
      {
        "id": "empty_input",
        "desc": "empty input returns [] (not ['']), no trailing empty line"
      },
      {
        "id": "whitespace_only_input",
        "desc": "all-whitespace input returns [] (no blank line)"
      },
      {
        "id": "trailing_ws_no_dangle",
        "desc": "trailing whitespace does not leave a dangling '' line"
      },
      {
        "id": "overlong_hard_break",
        "desc": "a word longer than width is hard-broken into width pieces"
      },
      {
        "id": "overlong_exact_multiple",
        "desc": "a word an exact multiple of width breaks with no empty tail"
      },
      {
        "id": "overlong_no_overflow",
        "desc": "hard-broken pieces never exceed width; chars are preserved"
      },
      {
        "id": "overlong_flushes_current",
        "desc": "an overlong word flushes the in-progress line first"
      },
      {
        "id": "overlong_tail_joins",
        "desc": "the short tail of a broken word can take following words"
      },
      {
        "id": "width_zero",
        "desc": "width == 0 returns [] for any input"
      },
      {
        "id": "width_negative",
        "desc": "a negative width returns [] for any input"
      }
    ],
    "num_checks": 21,
    "has_setup": true
  },
  {
    "slug": "ticketflow",
    "type": "implement",
    "brief": "Start from an empty repository and implement a Python 3.11+ project named `ticketflow`.\n\nBuild a support ticket assignment engine. Use only the Python standard library.\n\nExpose:\n\n```python\ndef assign_tickets(config: dict, tickets: list[dict], agents: list[dict]) -> dict: ...\ndef explain_assignment(ticket: dict, agent: dict, config: dict) -> dict: ...\n```\n\nTickets include:\n\n```json\n{\n  \"ticket_id\": \"t1\",\n  \"priority\": \"high\",\n  \"language\": \"en\",\n  \"product\": \"billing\",\n  \"created_at\": \"2026-01-01T12:00:00Z\"\n}\n```\n\nAgents include:\n\n```json\n{\n  \"agent_id\": \"a1\",\n  \"languages\": [\"en\"],\n  \"skills\": [\"billing\"],\n  \"capacity\": 3,\n  \"current_load\": 1\n}\n```\n\nAssignment rules:\n\n```text\nagent must have matching language\nagent must have matching skill\nagent must have available capacity\nhigher priority tickets assigned first\nolder tickets break ties\nleast-loaded qualified agent wins\nagent_id breaks ties deterministically\n```\n\nReturn assigned tickets and unassigned reasons.\n\nInclude a CLI:\n\n```bash\npython -m ticketflow assign --config config.json --tickets tickets.json --agents agents.json\n```\n\nInclude tests for priorities, capacity, skill matching, language matching, deterministic tie-breaking, unassigned reasons, and explanation output.\n\n## Contract\n\nThis section PINS the conventions the spec above leaves open. A conformant\nsolution MUST satisfy them; the held-out grader checks BEHAVIOR against them.\n\n### Import path / CLI\n\n- The package is importable as `ticketflow`, and the two public functions are\n  importable from the module `ticketflow.public`:\n      from ticketflow.public import assign_tickets, explain_assignment\n- The CLI is invoked as a module: `python -m ticketflow assign --config C --tickets T --agents A`,\n  where C, T, A are paths to JSON files holding the `config` dict, the `tickets`\n  list, and the `agents` list respectively. CLI stdout MUST be a single JSON\n  object (the same shape `assign_tickets` returns). The CLI exits 0 on success.\n\n### Ticket / agent fields\n\n- A ticket has: `ticket_id` (str), `priority` (str), `language` (str),\n  `product` (str), `created_at` (ISO-8601 UTC timestamp string, e.g.\n  \"2026-01-01T12:00:00Z\").\n- An agent has: `agent_id` (str), `languages` (list of str), `skills` (list of\n  str), `capacity` (int, max concurrent tickets), `current_load` (int, tickets\n  already held). An agent has available capacity when `current_load < capacity`.\n- The ticket's required SKILL is its `product` value: an agent is skill-qualified\n  for a ticket when `ticket[\"product\"] in agent[\"skills\"]`.\n- An agent is language-qualified for a ticket when\n  `ticket[\"language\"] in agent[\"languages\"]`.\n- An agent is QUALIFIED for a ticket when it is language-qualified AND\n  skill-qualified AND has available capacity at the moment of assignment.\n\n### Priority ordering (PINNED)\n\nPriority is one of these string values, ordered most-urgent \u2192 least-urgent:\n\n      \"urgent\" > \"high\" > \"medium\" > \"low\"\n\nHigher-priority tickets are assigned before lower-priority ones. A priority value\nnot in this list is treated as the LEAST urgent (ranked below \"low\"); ties among\nunknown priorities fall through to the remaining tie-breakers.\n\n### Assignment order & tie-break order (PINNED)\n\nTickets are assigned greedily, one at a time, in this total order:\n\n  1. priority DESCENDING (urgent first, per the ordering above)\n  2. then `created_at` ASCENDING (older \u2014 earlier timestamp \u2014 first)\n  3. then `ticket_id` ASCENDING (lexicographic) as a final stable tie-break\n\nFor the ticket currently being assigned, among all agents QUALIFIED for it at\nthat moment, the winning agent is chosen by:\n\n  1. `current_load` ASCENDING (least-loaded qualified agent wins), where\n     `current_load` reflects assignments ALREADY made during this call (each\n     assignment increments the chosen agent's effective load by 1)\n  2. then `agent_id` ASCENDING (lexicographic) as a deterministic final tie-break\n\nAssignment is single-pass and greedy in the ticket order above: once a ticket is\nassigned to an agent, that consumes one unit of that agent's capacity for the\nrest of the call. The whole computation is deterministic and independent of the\ninput ordering of the `tickets` and `agents` lists.\n\n### `assign_tickets` return shape (PINNED)\n\n`assign_tickets` returns a dict with EXACTLY these two top-level keys:\n\n      {\n        \"assigned\":   { <ticket_id>: <agent_id>, ... },\n        \"unassigned\": { <ticket_id>: <reason>,   ... }\n      }\n\n- `assigned` maps each assigned ticket's `ticket_id` (str) to the `agent_id`\n  (str) it was assigned to.\n- `unassigned` maps each unassigned ticket's `ticket_id` (str) to a `reason`\n  string explaining why no agent took it. The reason string MUST be one of\n  these PINNED values (lowercase, exact):\n    - \"no_language_match\"  \u2014 no agent speaks the ticket's language\n    - \"no_skill_match\"     \u2014 at least one agent speaks the language, but none has\n                             the ticket's product in their skills\n    - \"no_capacity\"        \u2014 at least one agent is language- AND skill-qualified,\n                             but every such agent is at capacity (current_load,\n                             including assignments made this call, == capacity)\n  When more than one reason could apply, report the FIRST that applies in the\n  order listed above (language, then skill, then capacity). Every ticket id\n  appears in exactly one of `assigned` / `unassigned`, never both, never neither.\n\n### `explain_assignment` return shape (PINNED)\n\n`explain_assignment(ticket, agent, config)` returns a dict describing whether the\ngiven agent could take the given ticket, with at least these keys:\n\n      {\n        \"eligible\":          <bool>,   # True iff language AND skill AND capacity all hold\n        \"language_match\":    <bool>,   # ticket language in agent languages\n        \"skill_match\":       <bool>,   # ticket product in agent skills\n        \"capacity_available\": <bool>,  # agent current_load < capacity\n      }\n\n`eligible` is the AND of the three boolean factors. `explain_assignment` is a\npure predicate over the single (ticket, agent) pair given; it does not consider\nother agents or mutate load.\n\n# ASSUMES (conventions the spec under-pins; fixed here so the oracle never grades a guess):\n#  - The ticket's required skill is its `product` field (the spec shows `product`\n#    on tickets and `skills` on agents but never names the join key).\n#  - Priority value set + ordering is urgent>high>medium>low; unknown = least.\n#  - \"available capacity\" means current_load < capacity (strict), load counts\n#    assignments made earlier in the same call.\n#  - Return shape: {\"assigned\": {tid:aid}, \"unassigned\": {tid:reason}} with the\n#    three pinned reason strings; explain_assignment exposes the three boolean\n#    factors plus their AND as `eligible`.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "assign_basic",
        "desc": "a qualified agent gets a matching ticket; return has assigned/unassigned maps"
      },
      {
        "id": "priority_order",
        "desc": "higher-priority ticket wins the only seat over a lower-priority one"
      },
      {
        "id": "created_at_tiebreak",
        "desc": "same priority: older (earlier created_at) ticket wins the only seat"
      },
      {
        "id": "ticket_id_tiebreak",
        "desc": "same priority and created_at: lower ticket_id wins the only seat"
      },
      {
        "id": "language_match",
        "desc": "ticket goes only to an agent that speaks its language"
      },
      {
        "id": "skill_match",
        "desc": "ticket goes only to an agent whose skills include its product"
      },
      {
        "id": "capacity_respected",
        "desc": "an agent at current_load==capacity is never assigned a ticket"
      },
      {
        "id": "least_loaded_wins",
        "desc": "among qualified agents the least-loaded one is chosen"
      },
      {
        "id": "agent_id_tiebreak",
        "desc": "equal load qualified agents: lowest agent_id wins"
      },
      {
        "id": "load_accumulates",
        "desc": "assignments within one call consume capacity (no overfill)"
      },
      {
        "id": "reason_no_language",
        "desc": "unassigned reason 'no_language_match' when no agent speaks the language"
      },
      {
        "id": "reason_no_skill",
        "desc": "unassigned reason 'no_skill_match' when language matches but skill does not"
      },
      {
        "id": "reason_no_capacity",
        "desc": "unassigned reason 'no_capacity' when qualified agents are all full"
      },
      {
        "id": "partition",
        "desc": "every ticket id appears in exactly one of assigned/unassigned"
      },
      {
        "id": "explain_eligible",
        "desc": "explain_assignment reports eligible=True with all three factors true"
      },
      {
        "id": "explain_factors",
        "desc": "explain_assignment isolates language/skill/capacity failures"
      },
      {
        "id": "determinism",
        "desc": "assign_tickets is order-independent and stable across runs"
      },
      {
        "id": "cli_assign_json",
        "desc": "`python -m ticketflow assign` emits the contract JSON object"
      }
    ],
    "num_checks": 18,
    "has_setup": false
  },
  {
    "slug": "tierlimit",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `tierlimit`: a fixed-window rate\nlimiter. The package is already written, imports cleanly, and works: it admits\nat most `limit` requests in each fixed wall-clock window of `window` seconds,\nagainst ONE global counter shared by every call.\n\n`now` is supplied by the caller as an absolute, non-decreasing float (seconds),\nso behaviour is deterministic \u2014 there is no real clock and no sleeping. The\nwindow containing `now` is the half-open interval `[w0, w0 + window)` where\n`w0 = floor(now / window) * window`; when a new window begins the count starts\nover at zero.\n\n## Task\n\nAdd PER-KEY rate limiting and TIERS on top of the existing global limiter,\nwithout breaking the global path.\n\n- Per-key limiting: a new method `allow_key(key, now)` limits each caller `key`\n  against its OWN independent fixed window and count. Different keys never share\n  a budget, and their windows advance independently (a key's window comes purely\n  from the `now` values it is called with).\n\n- Tiers: a tier is a NAME that maps to a per-window limit. `set_tier(key, tier)`\n  assigns a key to a tier. The limiter is constructed with a `tiers` mapping and\n  a `default_tier`; any key never assigned a tier uses the default tier.\n\n## Semantics (read carefully \u2014 this is the whole task)\n\n- Each key's window and count are INDEPENDENT. One key crossing a window\n  boundary, or hitting its limit, must not disturb any other key. A brand-new\n  key starts with an empty count in whatever window its first `now` falls in.\n\n- `allow_key(key, now)` admits the request iff the count already spent in the\n  key's CURRENT window is strictly less than the key's current tier limit; on\n  admit it increments that count and returns True, otherwise it returns False\n  and counts nothing.\n\n- Changing a key's tier MID-WINDOW does NOT reset the key's count or start a\n  fresh window. The key keeps the requests it has already spent in the current\n  window; only the EFFECTIVE LIMIT used for the comparison changes, applied\n  against that SAME window's existing count, taking effect from the next\n  `allow_key`:\n    * Lowering a key's tier mid-window can immediately push it over: a key that\n      already spent 3 requests under a limit-5 tier is over a limit-2 tier, so\n      its next `allow_key` in that window is denied \u2014 even though it never\n      \"used\" the lower tier. The change is NOT retroactive: it does not revoke\n      or refund requests already decided.\n    * Raising a key's tier mid-window immediately grants more room in the SAME\n      window (the existing count is measured against the higher limit).\n  When the key next crosses into a fresh window, the count resets to zero and\n  the new tier applies cleanly from there.\n\n- `set_tier(key, tier)` with an unknown tier name raises `ValueError`.\n\n- The GLOBAL path is unchanged: `allow(now)` still admits at most `limit`\n  requests per window against a single global counter, and shares nothing with\n  the per-key state (a global call must not consume any key's budget, and vice\n  versa).\n\n## Example\n\n    r = RateLimiter(limit=5, window=10.0,\n                    tiers={\"free\": 2, \"pro\": 5}, default_tier=\"free\")\n\n    r.allow_key(\"alice\", 0.0)   # alice on default tier \"free\" (limit 2) -> True (1/2)\n    r.allow_key(\"alice\", 1.0)   # -> True (2/2)\n    r.allow_key(\"alice\", 2.0)   # 3rd in window [0,10) -> False (over free's 2)\n\n    r.allow_key(\"bob\", 2.0)     # bob is independent, fresh -> True\n\n    r.set_tier(\"alice\", \"pro\")  # mid-window upgrade; alice's count (2) is kept\n    r.allow_key(\"alice\", 3.0)   # now under pro's 5, same window -> True (3/5)\n\n    r.allow_key(\"alice\", 10.0)  # new window [10,20): count resets -> True (1/5)\n\nA mid-window DOWNGRADE pushes a key over against its existing count:\n\n    r.allow_key(\"carol\", 0.0)   # default free (2): True (1/2)\n    r.set_tier(\"carol\", \"pro\")  # pro = 5\n    r.allow_key(\"carol\", 1.0)   # True (2/5)\n    r.allow_key(\"carol\", 2.0)   # True (3/5)\n    r.set_tier(\"carol\", \"free\") # downgrade to free (2); count is already 3\n    r.allow_key(\"carol\", 3.0)   # 3 >= 2 -> False, still in window [0,10)\n\n## Contract\n\n- Package name: `tierlimit`. The grader imports `tierlimit.public` (falling back\n  to `tierlimit`); keep both import paths working.\n- Public class `RateLimiter`, constructed as\n  `RateLimiter(limit, window, tiers=None, default_tier=\"default\")`:\n    * `limit` (positive int) and `window` (positive float) keep their meaning for\n      the global path. When `tiers` is None, a single tier named `\"default\"` is\n      created mapping to `limit`, and `default_tier` defaults to `\"default\"` \u2014\n      so `RateLimiter(limit, window)` still constructs and runs the global path\n      exactly as before (regression).\n    * `tiers` maps tier name -> per-window limit (positive ints).\n    * `default_tier` names the tier used for keys with no explicit tier; it must\n      be a key of `tiers` (else raise `ValueError` at construction).\n- Methods:\n    * `allow(now: float) -> bool` \u2014 UNCHANGED global path.\n    * `allow_key(key: str, now: float) -> bool` \u2014 per-key path described above.\n    * `set_tier(key: str, tier: str) -> None` \u2014 assign a key's tier; unknown\n      tier name raises `ValueError`.\n- The grader ALWAYS passes explicit `now` floats (non-decreasing per key); there\n  is no real clock and no sleeping.\n- Standard library only. No persistence, no threading requirement.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "default_tier_basic",
        "desc": "unassigned key uses the default tier's limit"
      },
      {
        "id": "per_key_independent_count",
        "desc": "each key has its own count; one key's limit does not block another"
      },
      {
        "id": "per_key_independent_window",
        "desc": "each key's window advances independently of other keys"
      },
      {
        "id": "window_reset_per_key",
        "desc": "a key's count resets when it crosses into a new window"
      },
      {
        "id": "explicit_tier_limit",
        "desc": "set_tier selects that tier's limit for the key"
      },
      {
        "id": "upgrade_midwindow_keeps_count",
        "desc": "mid-window upgrade keeps the existing count and grants more room"
      },
      {
        "id": "downgrade_midwindow_over",
        "desc": "mid-window downgrade pushes an over-budget key past the lower limit"
      },
      {
        "id": "set_tier_not_retroactive",
        "desc": "set_tier does not refund/revoke already-decided requests in the window"
      },
      {
        "id": "downgrade_then_new_window",
        "desc": "after a downgrade, the next window resets the count under the new tier"
      },
      {
        "id": "tier_reassign_twice",
        "desc": "down-then-up mid-window tracks the live limit against the kept count"
      },
      {
        "id": "boundary_window_math",
        "desc": "window boundary is half-open [w0, w0+window) via floor"
      },
      {
        "id": "unknown_tier_raises",
        "desc": "set_tier with an unknown tier name raises ValueError"
      },
      {
        "id": "bad_default_tier_raises",
        "desc": "constructing with a default_tier not in tiers raises ValueError"
      },
      {
        "id": "regression_global_basic",
        "desc": "global allow(now) admits at most limit per window, resets each window"
      },
      {
        "id": "regression_global_isolated",
        "desc": "global path and per-key path do not share budget"
      },
      {
        "id": "regression_bare_constructor",
        "desc": "RateLimiter(limit, window) still constructs and runs the global path"
      }
    ],
    "num_checks": 16,
    "has_setup": true
  },
  {
    "slug": "tmploop",
    "type": "feature-add",
    "brief": "You have inherited a small Python library named `tmploop`: a string templater.\nThe package is already written, imports cleanly, and works: a single function\n`render(template, context)` substitutes `{{ var }}` placeholders with values\nlooked up from `context`. Lookups may be DOTTED \u2014 `{{ user.name }}` walks dict\nkeys (falling back to object attributes) \u2014 and a missing lookup renders as the\nempty string. Literal text outside `{{ ... }}` is preserved verbatim.\n\nWhat it CANNOT do yet is loop or branch: there are no block tags.\n\n## Task\n\nAdd two nestable BLOCK TAGS to the templater, leaving plain `{{ var }}`\nrendering exactly as it is.\n\n- `{{#each items}} BODY {{/each}}` \u2014 iterate `items` in order, rendering BODY\n  once per element.\n\n- `{{#if cond}} A {{else}} B {{/if}}` \u2014 render A when `cond` is truthy, else B.\n  The `{{else}}` arm is optional (`{{#if cond}} A {{/if}}` renders A or nothing).\n\nThe two blocks must NEST in any combination (an `each` inside an `if`, an `if`\ninside an `each`, `each` inside `each`, to any depth), and the right closer must\npair with the right opener.\n\n## Semantics (read carefully \u2014 this is the whole task)\n\n### `each`\n\n- Inside the body, these names are available for the CURRENT element:\n    * `{{ this }}`    \u2014 the element itself.\n    * `{{ @index }}`  \u2014 its 0-based position (an integer: 0, 1, 2, ...).\n    * `{{ @first }}`  \u2014 boolean, true on the first element only.\n    * `{{ @last }}`   \u2014 boolean, true on the last element only.\n  `@first` / `@last` are usable as `{{#if}}` conditions.\n- `{{ this.field }}` walks into the element with the usual dotted lookup. When\n  the element is a dict, its keys are ALSO reachable bare (`{{ field }}`), and\n  those bare names SHADOW the outer context for that one iteration. Names not\n  found in the element fall back to the outer (enclosing) context.\n- An `items` that is MISSING, `None`, empty, or not a list/sequence yields ZERO\n  iterations (BODY is emitted zero times). Strings and dicts are treated as\n  NON-iterable here \u2014 you iterate a list, not the characters of a string.\n- After the loop, the loop-local names (`this`, `@index`, ...) are gone again;\n  they do not leak to the enclosing scope.\n\n### `if`\n\n- `cond` is resolved with the same (dotted) lookup as a variable, then tested\n  for Python truthiness. FALSY means: a missing variable, `None`, `False`, `0`,\n  `\"\"`, or an empty collection (`[]`, `{}`). Everything else is truthy.\n- The `{{else}}` arm is optional. Exactly one arm renders.\n\n### Unchanged\n\n- A plain `{{ var }}` (including dotted `{{ a.b.c }}`) renders exactly as before:\n  the looked-up value coerced with `str()`, or `\"\"` if missing or `None`. Booleans\n  render as `true` / `false` (lowercase).\n\n## Whitespace (pin this exactly)\n\n- The engine performs NO whitespace trimming around tags. Each tag span \u2014 from\n  the opening `{{` to the closing `}}` \u2014 is removed exactly where it sits, and\n  every other character (spaces, tabs, newlines, literal text) is preserved BYTE\n  FOR BYTE. There is no \"standalone tag\" newline-eating and no body trimming.\n\n      render(\"a {{#if t}} b {{/if}} c\", {\"t\": True})  ==  \"a  b  c\"\n\n  (Note the two spaces on each side: the spaces that flanked the now-removed\n  tags survive.) This is what lets output be checked by exact equality.\n\n- Inside `{{ ... }}` the inner expression IS stripped of surrounding whitespace,\n  so `{{ name }}` and `{{name}}` resolve the same variable.\n\n## Example\n\n    render(\"{{#each xs}}[{{ @index }}:{{ this }}]{{/each}}\", {\"xs\": [\"a\", \"b\", \"c\"]})\n    # -> \"[0:a][1:b][2:c]\"\n\n    render(\n        \"{{#each users}}{{#if @first}}{{ name }}{{else}}, {{ name }}{{/if}}{{/each}}\",\n        {\"users\": [{\"name\": \"Ada\"}, {\"name\": \"Bo\"}, {\"name\": \"Cy\"}]},\n    )\n    # -> \"Ada, Bo, Cy\"\n\n    render(\n        \"{{#if items}}<ul>{{#each items}}<li>{{ this }}</li>{{/each}}</ul>{{else}}empty{{/if}}\",\n        {\"items\": []},\n    )\n    # -> \"empty\"        (an empty list is falsy, so the else arm renders)\n\nA bare field of a dict element shadows the outer context for that iteration:\n\n    render(\"{{#each rows}}{{ x }}{{/each}}\", {\"x\": \"OUT\", \"rows\": [{\"x\": \"A\"}, {}]})\n    # -> \"AOUT\"         (first row has its own x=A; the second {} falls back to OUT)\n\n## Contract\n\n- Package name: `tmploop`. The grader imports `tmploop.public` (falling back to\n  `tmploop`); keep both import paths working.\n- Public function `render(template: str, context: dict) -> str`. It returns a\n  `str`; it does not print and does not write files.\n- `render(template, None)` is allowed and behaves as if `context` were `{}`.\n- A MALFORMED template \u2014 an unclosed `{{#each}}`/`{{#if}}`, a stray\n  `{{/each}}`/`{{/if}}` with no opener, a mismatched closer (`{{#each}}...{{/if}}`),\n  or an `{{else}}` outside an `{{#if}}` \u2014 raises an exception from `render` rather\n  than silently producing wrong output or hanging.\n- Standard library only. Do not use `eval`. No persistence, no threading.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "each_basic",
        "desc": "each iterates a list, exposing {{ this }}"
      },
      {
        "id": "each_index",
        "desc": "each exposes {{ @index }} (0-based)"
      },
      {
        "id": "each_first_last",
        "desc": "each exposes {{ @first }}/{{ @last }} usable as #if conditions"
      },
      {
        "id": "each_empty_zero",
        "desc": "an empty each collection iterates ZERO times"
      },
      {
        "id": "each_missing_zero",
        "desc": "a missing each collection iterates ZERO times"
      },
      {
        "id": "each_dotted_this",
        "desc": "{{ this.field }} walks into a dict element"
      },
      {
        "id": "each_dict_shadow",
        "desc": "a dict element's keys shadow outer scope, with fallback"
      },
      {
        "id": "each_string_not_iterated",
        "desc": "a string value is NOT iterated char-by-char by each"
      },
      {
        "id": "if_then_truthy",
        "desc": "#if renders the then-arm when cond is truthy"
      },
      {
        "id": "if_else_falsy",
        "desc": "#if renders the else-arm when cond is falsy"
      },
      {
        "id": "if_empty_collection_falsy",
        "desc": "an empty list/dict/0/'' is FALSY for #if"
      },
      {
        "id": "if_no_else_arm",
        "desc": "#if with no {{else}} emits nothing when cond is falsy"
      },
      {
        "id": "nest_each_in_if",
        "desc": "an each block nested inside an if block"
      },
      {
        "id": "nest_if_in_each",
        "desc": "an if block nested inside an each block (per-element)"
      },
      {
        "id": "nest_each_in_each",
        "desc": "each-in-each nests and closers pair correctly"
      },
      {
        "id": "whitespace_preserved",
        "desc": "literal whitespace around tags is preserved byte-for-byte"
      },
      {
        "id": "malformed_unclosed_raises",
        "desc": "an unclosed block raises rather than mis-rendering"
      },
      {
        "id": "malformed_mismatch_raises",
        "desc": "a mismatched closer ({{#each}}..{{/if}}) raises"
      },
      {
        "id": "regression_plain_var",
        "desc": "plain {{ var }} substitution still works"
      },
      {
        "id": "regression_dotted_and_missing",
        "desc": "dotted lookup works; missing renders as ''"
      }
    ],
    "num_checks": 20,
    "has_setup": true
  },
  {
    "slug": "tokenbucket",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `tokenbucket`: a continuous\ntoken-bucket rate limiter. The package is already written, imports cleanly, and\nthe happy path works -- a fresh bucket starts full, hands out tokens until it is\nempty, denies once empty, and refills as time passes. It is used to throttle an\nAPI: every request calls `allow(now, cost)` and is let through only when it\nreturns True.\n\n## Bug report\n\nUnder real traffic the limiter misbehaves at the edges, and the symptoms are\nhard to pin down because coarse, whole-second testing looks fine:\n\n  1. After a quiet period (no traffic for a while) the bucket lets through a\n     huge BURST -- far more requests than `capacity` -- as if it had saved up\n     unlimited credit while idle. It is supposed to hold at most `capacity`\n     tokens no matter how long it sat idle.\n\n  2. Under a steady stream of rapid, closely-spaced requests the effective\n     throughput is WAY below `refill_per_sec` -- the bucket behaves as if it\n     barely refills at all, starving callers, even though over the same wall\n     time it should have accrued the full proportional amount. The refill seems\n     to \"forget\" the time between very frequent calls.\n\n  3. A request that is DENIED still seems to cost the caller something: a burst\n     of large-`cost` requests that are all rejected leaves the bucket emptier\n     than it was before, so legitimate small requests that should have fit are\n     then refused too.\n\n  4. A rare backwards jump in the supplied clock (an upstream time source\n     glitch) wedges the limiter -- afterwards it under-grants for a while.\n\nFind and fix the defects so the limiter honours the contract below exactly.\nKeep the public API and behaviour otherwise unchanged.\n\n## Contract\n\n- Package name: `tokenbucket`. The grader imports `tokenbucket.public` (falling\n  back to `tokenbucket`); keep both import paths working.\n- Public API, UNCHANGED (do not rename anything or change signatures):\n      TokenBucket(capacity, refill_per_sec)\n      TokenBucket.allow(now: float, cost: int = 1) -> bool\n      TokenBucket.tokens            # read-only current token count (a float)\n- The bucket starts FULL: it holds exactly `capacity` tokens before the first\n  call.\n- `allow(now, cost)` does, in order:\n    a. REFILL for the time elapsed since the previous call, then\n    b. try to CONSUME `cost` tokens.\n- Refill (continuous, fractional, capped AFTER):\n    * Let `elapsed = now - last`, where `last` is the `now` of the previous\n      call (on the very first call there is nothing to refill).\n    * Add `elapsed * refill_per_sec` tokens -- the EXACT real-valued amount, with\n      NO rounding or truncation. The bucket holds a fractional token count.\n    * THEN clamp the total to at most `capacity`. (Refill first, cap second:\n      tokens can momentarily compute above capacity during refill but must be\n      clamped down to exactly `capacity`, never left above it.)\n    * `elapsed` is clamped to be non-negative: if `now < last` (clock went\n      backwards), refill nothing and do NOT move `last` backwards. The next\n      forward call refills from the real, latest `last`.\n- Consume:\n    * If the bucket holds at least `cost` tokens (`tokens >= cost`, so a request\n      for exactly the available amount is allowed), subtract `cost` and return\n      True.\n    * Otherwise return False and consume NOTHING -- the token count is left\n      exactly as it was. A denial never drains the bucket.\n- `cost` is a positive integer (default 1); `cost > 1` consumes that many tokens\n  atomically (all-or-nothing).\n\n## I/O example\n\n    >>> b = TokenBucket(capacity=10, refill_per_sec=2.0)\n    >>> b.allow(now=0.0, cost=10)     # spend the full bucket at t=0\n    True\n    >>> b.allow(now=0.0)              # empty now\n    False\n    >>> b.tokens\n    0.0\n    >>> b.allow(now=1.5, cost=3)      # 1.5s * 2/s = +3.0 tokens, exactly enough\n    True\n    >>> b.allow(now=1.5)              # drained again\n    False\n    >>> b.allow(now=10000.0, cost=1)  # long idle: refill caps AT capacity (10)\n    True\n    >>> b.tokens                      # 10 - 1, never above capacity\n    9.0\n\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "starts_full_allows",
        "desc": "a fresh full bucket allows up to capacity immediately"
      },
      {
        "id": "empties_then_denies",
        "desc": "draining the bucket then asking again is denied"
      },
      {
        "id": "coarse_refill",
        "desc": "a whole-second wait refills the expected whole tokens"
      },
      {
        "id": "denied_consumes_nothing",
        "desc": "a DENIED request leaves the token count unchanged"
      },
      {
        "id": "denied_then_exact",
        "desc": "after a denial the still-present tokens are spendable"
      },
      {
        "id": "cost_gt_one_allow",
        "desc": "cost>1 is allowed and consumes exactly cost tokens"
      },
      {
        "id": "cost_gt_one_boundary",
        "desc": "cost equal to available tokens is allowed (>=, not >)"
      },
      {
        "id": "cost_gt_one_over",
        "desc": "cost one above available is denied without draining"
      },
      {
        "id": "cap_after_refill",
        "desc": "a long idle gap caps the bucket AT capacity, not above"
      },
      {
        "id": "cap_exact_no_overflow",
        "desc": "refill that exactly reaches capacity does not overflow"
      },
      {
        "id": "fractional_refill_accrues",
        "desc": "many tiny sub-token steps accrue real fractional credit"
      },
      {
        "id": "fractional_partial",
        "desc": "a fractional refill grants the proportional token amount"
      },
      {
        "id": "monotonic_clamp_no_gain",
        "desc": "a backwards `now` neither adds nor removes tokens"
      },
      {
        "id": "monotonic_clamp_recovers",
        "desc": "after a backwards blip, forward time refills from the real last"
      },
      {
        "id": "burst_then_wait_recovery",
        "desc": "a burst that empties the bucket recovers after waiting"
      },
      {
        "id": "sustained_rate",
        "desc": "over a long run the allow-rate tracks refill_per_sec"
      }
    ],
    "num_checks": 16,
    "has_setup": true
  },
  {
    "slug": "ttlcache",
    "type": "bug-fix",
    "brief": "You have inherited a small Python library named `ttlcache`: an in-memory cache\nwhere each entry carries a time-to-live (TTL). The package is already written,\nimports cleanly, and most of it works. It ships with an injectable clock so its\nbehaviour is fully deterministic \u2014 you pass `Cache(clock=...)` a zero-argument\ncallable returning the current time as a number.\n\n## Bug report\n\nEntries are being served one tick PAST their TTL \u2014 they expire a moment late.\n\nReproduction:\n\n    ticks = [0]\n    c = Cache(clock=lambda: ticks[0])\n    c.set(\"a\", 1, ttl=10)      # set at t=0 with a 10-unit TTL\n\n    ticks[0] = 9\n    c.get(\"a\")                 # -> 1   (correct: still fresh)\n\n    ticks[0] = 10\n    c.get(\"a\")                 # -> 1   (WRONG: the 10-unit TTL has fully\n                               #         elapsed, so this should be a miss)\n\n    ticks[0] = 11\n    c.get(\"a\")                 # -> None (eventually expires, one tick too late)\n\nIn other words: a value set with `ttl=10` is still being returned at the exact\nmoment it should expire. It should be considered expired \u2014 a miss \u2014 as soon as\nthe elapsed time since `set` reaches the TTL, not strictly after it. The same\nlate-expiry shows up anywhere freshness is judged (membership tests, remaining\nTTL, length, purge), because they all share the same notion of \"expired\".\n\nA TTL of 0 (or negative) should mean the entry is already expired and never\nserved.\n\n## Contract\n\n- Package name: `ttlcache`. The grader imports `ttlcache.public` (falling back\n  to `ttlcache`); keep both import paths working.\n- Keep the PUBLIC API UNCHANGED: `Cache(clock=None)`, `Cache.set(key, value,\n  ttl)`, `Cache.get(key, default=None)`, plus the existing helpers\n  (`contains` / `in`, `delete`, `ttl_remaining`, `purge`, `clear`, `len`,\n  `stats`). Do not rename anything or change signatures.\n- Fix the expiry boundary so an entry expires exactly when its TTL elapses\n  (i.e. at and after `set_time + ttl`), not one tick later. Hits/misses and the\n  expiration counter must reflect the corrected boundary.\n- Standard library only.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "set_get_basic",
        "desc": "a freshly set value is returned before its TTL elapses"
      },
      {
        "id": "boundary_just_before",
        "desc": "value is a HIT one tick before the TTL elapses"
      },
      {
        "id": "boundary_exact",
        "desc": "value is a MISS at the exact instant the TTL elapses"
      },
      {
        "id": "boundary_after",
        "desc": "value is a MISS after the TTL has elapsed"
      },
      {
        "id": "ttl_zero_expired",
        "desc": "ttl=0 entry is already expired (never served)"
      },
      {
        "id": "ttl_negative_expired",
        "desc": "negative ttl entry is already expired"
      },
      {
        "id": "miss_unknown_key",
        "desc": "an unknown key is a miss / returns the default"
      },
      {
        "id": "default_returned",
        "desc": "the supplied default is returned on a miss"
      },
      {
        "id": "stats_hits_misses",
        "desc": "hits/misses counters reflect the corrected boundary"
      },
      {
        "id": "stats_expiration_counted",
        "desc": "an expired-on-access entry increments expirations"
      },
      {
        "id": "contains_boundary",
        "desc": "membership (`in`) expires exactly at the TTL boundary"
      },
      {
        "id": "ttl_remaining_boundary",
        "desc": "ttl_remaining is None at and after the TTL boundary"
      },
      {
        "id": "len_counts_live_only",
        "desc": "len() counts only live (non-expired) entries"
      },
      {
        "id": "purge_removes_expired",
        "desc": "purge() evicts entries that are at/after their TTL"
      },
      {
        "id": "overwrite_resets_ttl",
        "desc": "re-setting a key resets its TTL from the new set time"
      },
      {
        "id": "delete_removes",
        "desc": "delete() removes a present key and reports it"
      }
    ],
    "num_checks": 16,
    "has_setup": true
  },
  {
    "slug": "unitconv",
    "type": "repair-to-green",
    "brief": "BUG REPORT \u2014 unitconv: the test suite is failing\n\nYou have an existing Python package `unitconv`, a tiny unit converter. It ships\nwith a unittest suite in `unitconv/test_unitconv.py`, and right now several of\nthose tests FAIL. Fix the code so that ALL the tests pass. Do not rewrite the\npackage from scratch and do not change its public API.\n\n## Symptom\n\n`convert(value, from_unit, to_unit)` converts a number between units and returns\na float. Simple same-dimension conversions (mm <-> m <-> km, s <-> min <-> h)\nalready work, but compound SPEED units and cross-dimension guards come out wrong:\n\n    from unitconv.public import convert\n\n    # compound numerator scale is dropped:\n    convert(2, \"km/s\", \"m/s\")\n    #   EXPECTED 2000.0          (2 km/s = 2000 m/s)\n    #   ACTUAL   2.0             (\"km\" treated as if it were \"m\")\n\n    # compound denominator composed with the wrong operator:\n    convert(3600, \"m/h\", \"m/s\")\n    #   EXPECTED 1.0             (per HOUR -> divide by 3600 s)\n    #   ACTUAL   46656000.0      (multiplied by 3600 instead of divided)\n\n    # a real speed conversion exercises both at once:\n    convert(36, \"km/h\", \"m/s\")\n    #   EXPECTED 10.0            (36000 m / 3600 s)\n    #   ACTUAL   wrong number\n\n    # incompatible dimensions return a number instead of raising:\n    convert(1, \"m\", \"s\")\n    #   EXPECTED UnitError       (a length is not a time)\n    #   ACTUAL   1.0             (no guard \u2014 runs the arithmetic anyway)\n\nThese defects interact: a `km/h -> m/s` conversion exercises the numerator-scale\nbug AND the denominator-operator bug together, and a cross-dimension call like\n`m -> km/h` must be rejected rather than silently computed.\n\n## Reproduce\n\nRun the visible tests from the directory that contains the `unitconv` package:\n\n    python -m unittest unitconv.test_unitconv\n\n## Contract (must hold after your fix)\n\n* Package name stays `unitconv`; import path `unitconv` / `unitconv.public`.\n* Keep the public API exactly: `convert(value, from_unit: str, to_unit: str) ->\n  float` and the `UnitError` exception. Do not rename them.\n* `convert` returns a `float`. `value` is an `int` or `float`.\n* SIMPLE units convert to a canonical base by a single factor; a COMPOUND speed\n  unit is written `\"<length>/<time>\"` and its factor to the base (metres per\n  second) is the LENGTH factor DIVIDED BY the TIME factor \u2014 the numerator\n  MULTIPLIES, the denominator DIVIDES:\n\n      dimension  unit    factor to base (base shown in [])\n      ---------  ------  ---------------------------------\n      length     mm      0.001            [metre]\n      length     m       1\n      length     km      1000\n      time       s       1                [second]\n      time       min     60\n      time       h       3600\n      speed      m/s     (m factor) / (s factor)  = 1/1     [metre/second]\n      speed      km/h    (km factor) / (h factor) = 1000/3600\n\n* CONVERSION: take `value` to the canonical base via `from_unit`'s factor, then\n  to `to_unit` by dividing by `to_unit`'s factor: `value * from_factor /\n  to_factor`.\n* COMPOUND PARSING: `\"<length>/<time>\"` splits on the single `/`. The part\n  before the slash must be a length unit (the numerator), the part after must be\n  a time unit (the denominator). Its dimension is `\"speed\"`.\n* INCOMPATIBLE DIMENSIONS: `convert` only converts WITHIN one dimension.\n  Converting across dimensions \u2014 a length to a time, a time to a speed, a length\n  to a speed, etc. \u2014 raises `UnitError`. It must NOT return a number.\n* UNKNOWN UNITS: an unrecognised unit string (either side) raises `UnitError`.\n\nExample:\n\n    convert(36, \"km/h\", \"m/s\")   # -> 10.0\n    convert(10, \"m/s\", \"km/h\")   # -> 36.0\n    convert(120, \"m/min\", \"m/s\") # -> 2.0\n    convert(1, \"m\", \"s\")         # -> raises UnitError (length vs time)\n\nStandard library only. Do not change the package name or the public\nfunction/exception names.\n",
    "observed": false,
    "graded_behaviors": [
      {
        "id": "len_mm_to_m",
        "desc": "1000 mm -> 1.0 m"
      },
      {
        "id": "len_km_to_m",
        "desc": "2 km -> 2000 m"
      },
      {
        "id": "len_m_to_mm",
        "desc": "1 m -> 1000 mm"
      },
      {
        "id": "len_km_to_mm",
        "desc": "3 km -> 3_000_000 mm"
      },
      {
        "id": "time_min_to_h",
        "desc": "90 min -> 1.5 h"
      },
      {
        "id": "time_h_to_s",
        "desc": "1 h -> 3600 s"
      },
      {
        "id": "time_s_to_min",
        "desc": "120 s -> 2 min"
      },
      {
        "id": "time_h_to_min",
        "desc": "2 h -> 120 min"
      },
      {
        "id": "compound_km_per_s_parse",
        "desc": "2 km/s -> 2000 m/s (km numerator scale kept)"
      },
      {
        "id": "compound_m_per_s_to_km_per_s",
        "desc": "3000 m/s -> 3 km/s"
      },
      {
        "id": "compound_m_per_h_compose",
        "desc": "3600 m/h -> 1 m/s (per-hour divides by 3600)"
      },
      {
        "id": "compound_m_per_s_to_m_per_h",
        "desc": "1 m/s -> 3600 m/h"
      },
      {
        "id": "compound_m_per_min_compose",
        "desc": "120 m/min -> 2 m/s"
      },
      {
        "id": "speed_kmh_to_ms",
        "desc": "36 km/h -> 10 m/s"
      },
      {
        "id": "speed_kmh_to_ms_2",
        "desc": "72 km/h -> 20 m/s"
      },
      {
        "id": "speed_ms_to_kmh",
        "desc": "10 m/s -> 36 km/h"
      },
      {
        "id": "speed_ms_identity",
        "desc": "5 m/s -> 5 m/s"
      },
      {
        "id": "speed_kmh_identity",
        "desc": "1 km/h -> 1 km/h"
      },
      {
        "id": "incompat_len_to_time",
        "desc": "length -> time raises (m -> s)"
      },
      {
        "id": "incompat_time_to_len",
        "desc": "time -> length raises (min -> km)"
      },
      {
        "id": "incompat_speed_to_len",
        "desc": "speed -> length raises (m/s -> km)"
      },
      {
        "id": "incompat_len_to_speed",
        "desc": "length -> speed raises (m -> km/h)"
      },
      {
        "id": "incompat_time_to_speed",
        "desc": "time -> speed raises (h -> m/s)"
      },
      {
        "id": "unknown_from",
        "desc": "unknown from-unit raises (ly -> m)"
      },
      {
        "id": "unknown_to",
        "desc": "unknown to-unit raises (m -> ly)"
      },
      {
        "id": "unknown_compound_den",
        "desc": "unknown compound denominator raises (m/foo -> m/s)"
      }
    ],
    "num_checks": 26,
    "has_setup": true
  },
  {
    "slug": "workflow",
    "type": "ambiguous-spec",
    "brief": "We run a lot of multi-step business processes and right now each one is hand-coded\nas a tangle of if-statements, and nobody can tell at a glance what state something\nis in or where it can go next. I'd like a small Python library, `workflow`, for\ndescribing a process as a set of stages and the transitions between them, and then\ndriving an individual thing through those stages over its lifetime.\n\nThink of an order: it starts somewhere, moves through stages like received, paid,\npacked, shipped, and lands in a terminal state \u2014 but real processes aren't a\nstraight line. Some stages can go more than one way depending on what happened\n(payment cleared vs. declined), and some paths need to be ruled out entirely. What\nI want is to define the shape of the process once, and then for any given order be\nable to ask where it is, advance it, and have the library refuse the moves that\ndon't make sense rather than quietly letting it skip a stage.\n\nI care most about it being clear to define a process and trustworthy to drive \u2014 an\norder should never end up somewhere the process doesn't allow, and when a move is\nrejected I want to understand why. It should be importable as `workflow`, and there\nshould be an obvious way to actually run something through, whether from code or to\ninspect a process directly; use your judgment there.\n\nBeyond that the design is yours. Keep it small and lean on the standard library.\nSome tests around the interesting transition cases, and a couple of examples in a\nREADME, would give me confidence it does what you think it does. I'd rather see the\nchoices you'd actually defend than a pile of knobs.\n",
    "observed": true,
    "graded_behaviors": [],
    "num_checks": 0,
    "has_setup": false
  }
]