{
  "id": "session-2026-10-09",
  "createdAt": "2026-10-09T06:19:16.072Z",
  "title": "Five repairs. Two ways of working.",
  "disclosure": "Recorded runs, static replay: visiting this site never starts an AI model or a paid API call. Both workflows passed 5/5 tasks (80/80 public cases); the independent reviewer made no source changes. One session, open tests, independently generated implementations. Root wall time includes dispatch preparation, scheduling, handoff pauses and concurrent publishing work; it is not model latency or a speed comparison. Model identity, token use and billed generation cost were not exported. Reproduction reruns saved code and tests, not agents.",
  "workflows": [
    {
      "id": "solo",
      "label": "Solo implementation",
      "wallTimeMs": 150344,
      "runtimeMs": 4274,
      "model": null,
      "tokens": null,
      "costUsd": null,
      "tasks": [
        {
          "id": "optimistic-ledger",
          "title": "Roll back only your own optimistic update",
          "language": "TypeScript",
          "status": "pass",
          "testDurationMs": 43,
          "brief": "# Roll back only your own optimistic update\n\nA frontend displays a counter immediately after an adjustment, before the server confirms it. Several updates can be pending together. Rejecting one must not erase the others, and duplicate acknowledgements must be harmless.\n\nRepair `apply(state, event)` and `value(state)` in `src/task.ts`, preserving their exported types and signatures. This is a pure TypeScript state helper, with no framework or network dependency.\n\n## Contract\n\n- `base` contains only committed adjustments. `pending` is the ordered list of unacknowledged `{token, delta}` entries. `settled` records tokens already committed or rolled back.\n- The displayed `value` is `base + sum(pending.delta)`.\n- An `adjust` with a new token appends exactly one entry to pending. It does not change base or settled. A token already pending or settled is an identity no-op, even if the repeated delta differs.\n- `commit` moves only the matching pending entry's delta into base, removes only that entry, and appends its token to settled.\n- `rollback` removes only the matching pending entry, leaves base unchanged, and appends its token to settled.\n- Commit and rollback may arrive in any order. Settling an unknown or previously settled token returns the original state by identity.\n- An accepted event returns a new state. Preserve the order of remaining pending entries and existing settled tokens. Never mutate input state, nested entries, arrays, or events. Accepted adjustments must snapshot their event fields rather than retaining a mutable event object.\n- `base` and deltas may be negative or zero. Tokens are nonempty strings. Inputs are well-formed, and all sums are safe integers; validation of malformed inputs is outside this task.\n- The caller owns retention of settled tokens. This helper must not evict them or use module-level memory.\n\nExample: base `10`, pending `A:+5, B:+2`; rollback A leaves displayed value `12`. Committing B then produces base `12`, no pending entries, and settled tokens `[A, B]`.\n\nOnly the implementation file is editable. All evaluation cases are public.\n",
          "diff": "--- baseline/optimistic-ledger/src/task.ts\n+++ solo/optimistic-ledger/src/task.ts\n@@ -13,15 +13,20 @@\n }\n \n export function apply(state: State, event: Event): State {\n+  if (state.settled.includes(event.token)) return state;\n+  const index = state.pending.findIndex(item => item.token === event.token);\n   if (event.type === 'adjust') {\n-    if (state.pending.some(item => item.token === event.token)) return state;\n-    return { ...state, pending: [...state.pending, event] };\n+    if (index !== -1) return state;\n+    return {\n+      ...state,\n+      pending: [...state.pending, { token: event.token, delta: event.delta }],\n+    };\n   }\n-  const item = state.pending.find(entry => entry.token === event.token);\n-  if (!item) return state;\n+  if (index === -1) return state;\n+  const item = state.pending[index];\n   return {\n-    base: event.type === 'commit' ? value(state) : state.base,\n-    pending: [],\n+    base: event.type === 'commit' ? state.base + item.delta : state.base,\n+    pending: state.pending.filter((_, pendingIndex) => pendingIndex !== index),\n     settled: [...state.settled, event.token],\n   };\n }\n",
          "log": "COMPILE | exit 0 | 906 ms\n\n\nTEST | exit 0 | 43 ms\nARENA_TESTS_PASSED=16\n"
        },
        {
          "id": "request-state",
          "title": "Keep stale responses out of the UI",
          "language": "TypeScript",
          "status": "pass",
          "testDurationMs": 38,
          "brief": "# Keep stale responses out of the UI\n\nA frontend search box starts requests while the user types. Responses arrive out of order, and some transports can report a late terminal event after cancellation or completion.\n\nRepair the pure `reduce(state, event)` helper in `src/task.ts`. Preserve its exported types, `initialState`, and function signature. This is a dependency-free TypeScript state task, not an Angular runtime test.\n\n## Contract\n\n- Request IDs are positive safe integers, allocated in strictly increasing order by the caller. Any invalid event ID must throw `RangeError`, even when the event would otherwise be stale.\n- A `start` event is accepted only when its ID is greater than the state's ID. It replaces `requestId` and `query`, sets `status` to `loading`, clears `error`, and retains the previous result items until a response arrives.\n- A `success` or `failure` event is accepted only when its ID equals the state's ID **and** the state is still `loading`. Ignore older, future, duplicate, or already-completed response events.\n- An accepted success replaces items, sets status to `success`, and clears error. Copy the supplied item array so subsequent caller mutation cannot alter state.\n- An accepted failure sets status to `error`, stores the supplied message verbatim, and retains the previous items and query.\n- Every ignored valid event returns the exact original state object. Every accepted event returns a new state object.\n- Never mutate input state, its arrays, the event, or the event's arrays. Inputs may be frozen.\n- The initial state is request ID `0`, empty query/items, status `idle`, and null error. Response events cannot start a request on their own.\n\nOnly the implementation file is editable. All evaluation cases are public.\n",
          "diff": "--- baseline/request-state/src/task.ts\n+++ solo/request-state/src/task.ts\n@@ -23,8 +23,9 @@\n     if (event.requestId <= state.requestId) return state;\n     return { ...state, requestId: event.requestId, query: event.query, status: 'loading', error: null };\n   }\n+  if (event.requestId !== state.requestId || state.status !== 'loading') return state;\n   if (event.type === 'success') {\n-    return { ...state, items: event.items, status: 'success', error: null };\n+    return { ...state, items: [...event.items], status: 'success', error: null };\n   }\n   return { ...state, status: 'error', error: event.error };\n }\n",
          "log": "COMPILE | exit 0 | 752 ms\n\n\nTEST | exit 0 | 38 ms\nARENA_TESTS_PASSED=18\n"
        },
        {
          "id": "retry-policy",
          "title": "Put a ceiling on retries",
          "language": "Java",
          "status": "pass",
          "testDurationMs": 56,
          "brief": "# Put a ceiling on retries\n\nA synchronous HTTP client asks this pure helper whether to schedule another request after the current attempt. Off-by-one errors and unchecked backoff can make an outage worse.\n\nRepair `Task.decide(int attempt, int maxAttempts, long baseDelayMillis, long maxDelayMillis, int status, Long retryAfterMillis)` in `src/Task.java`. The return type is the existing `Decision(boolean retry, long delayMillis)` record.\n\n## Contract\n\n- `attempt` is the number of the request that just finished, starting at 1. `maxAttempts` includes the initial request. Never retry once `attempt == maxAttempts`.\n- Retry only status `0` (transport failure), `408`, `429`, `502`, `503`, or `504`. All other valid HTTP statuses are terminal, including other 5xx statuses.\n- For a retry, exponential delay is `baseDelayMillis * 2^(attempt - 1)`, capped at `maxDelayMillis`. Calculate it without overflow, even for large attempt numbers and `long` values. A zero base delay stays zero.\n- For statuses `429` and `503` only, a non-null `retryAfterMillis` is a lower bound on the exponential delay; the final result is still capped by `maxDelayMillis`. For other statuses the hint does not affect the result.\n- A terminal decision is exactly `Decision(false, 0)`.\n- Validate every call before returning, including terminal decisions: `1 <= attempt <= maxAttempts`; both delays nonnegative; status either `0` or `100..599`; any non-null hint nonnegative. Reject violations with `IllegalArgumentException`.\n- This helper does not sleep, read a clock, perform a request, add jitter, or parse HTTP headers. A caller has already converted any server hint to milliseconds.\n\nOnly the implementation file is editable. All evaluation cases are public.\n",
          "diff": "--- baseline/retry-policy/src/Task.java\n+++ solo/retry-policy/src/Task.java\n@@ -10,12 +10,20 @@\n                 || (retryAfterMillis != null && retryAfterMillis < 0)) {\n             throw new IllegalArgumentException(\"Invalid retry input\");\n         }\n-        if (status != 0 && status != 408 && status != 429 && status < 500) {\n-            return new Decision(false, 0);\n+        boolean retryable = status == 0 || status == 408 || status == 429\n+                || status == 502 || status == 503 || status == 504;\n+        if (attempt == maxAttempts || !retryable) return new Decision(false, 0);\n+\n+        long delay = Math.min(baseDelayMillis, maxDelayMillis);\n+        int doublings = attempt - 1;\n+        // A positive delay reaches the cap within 63 doublings at most.\n+        while (doublings > 0 && delay > 0 && delay < maxDelayMillis) {\n+            delay = delay > maxDelayMillis / 2 ? maxDelayMillis : delay * 2;\n+            doublings--;\n         }\n-        if (attempt > maxAttempts) return new Decision(false, 0);\n-        long delay = Math.min(maxDelayMillis, baseDelayMillis * (1L << attempt));\n-        if (retryAfterMillis != null) delay = retryAfterMillis;\n+        if ((status == 429 || status == 503) && retryAfterMillis != null) {\n+            delay = Math.min(maxDelayMillis, Math.max(delay, retryAfterMillis));\n+        }\n         return new Decision(true, delay);\n     }\n }\n",
          "log": "COMPILE | exit 0 | 688 ms\n\n\nTEST | exit 0 | 56 ms\nARENA_TESTS_PASSED=17\n"
        },
        {
          "id": "sliding-window",
          "title": "Repair the rate-limit boundary",
          "language": "Java",
          "status": "pass",
          "testDurationMs": 49,
          "brief": "# Repair the rate-limit boundary\n\nAn in-memory limiter stores timestamps of accepted requests. Operators can lower the limit while requests are still in the window. Clients need a precise retry delay.\n\nRepair `Task.admit(long[] acceptedAt, long now, long windowMillis, int limit)` in `src/Task.java`, preserving its `Decision(boolean allowed, long retryAfterMillis, long[] acceptedAt)` record.\n\n## Contract\n\n- All times are caller-provided nonnegative integer milliseconds. Do not read a clock or retain global state.\n- Input timestamps are sorted in nondecreasing order, may repeat, and must not be in the future. Validate the entire input, including entries that will expire.\n- The active interval is **`(now - windowMillis, now]`**. A timestamp exactly one window old is expired.\n- Remove expired entries. If fewer than `limit` active entries remain, accept the request, append `now`, and return retry delay `0`.\n- Otherwise reject without appending. Return the smallest positive delay after which this request would be accepted if no other request arrives. When historical active entries exceed a newly lowered limit, enough entries must expire to leave fewer than `limit` entries.\n- The returned timestamp array contains only the retained active entries, plus the new request when accepted. Always return a fresh array and never mutate the input.\n- `now` and `windowMillis` may reach `Long.MAX_VALUE`; compute the relative retry delay without overflowing an absolute expiry timestamp.\n- Reject a null array, negative `now`, nonpositive window or limit, negative/future timestamps, or unsorted timestamps with `IllegalArgumentException`.\n\nExample: timestamps `[100, 150, 170]`, `now=180`, `windowMillis=100`, `limit=2` must reject with delay `70`, because two entries must expire before another request can fit.\n\nOnly the implementation file is editable. All evaluation cases are public.\n",
          "diff": "--- baseline/sliding-window/src/Task.java\n+++ solo/sliding-window/src/Task.java\n@@ -16,10 +16,12 @@\n             previous = timestamp;\n         }\n         int first = 0;\n-        while (first < acceptedAt.length && acceptedAt[first] < now - windowMillis) first++;\n+        while (first < acceptedAt.length && now - acceptedAt[first] >= windowMillis) first++;\n         long[] active = Arrays.copyOfRange(acceptedAt, first, acceptedAt.length);\n         if (active.length >= limit) {\n-            return new Decision(false, active[0] + windowMillis - now, active);\n+            // Enough entries must expire to leave at most limit - 1 requests.\n+            long age = now - active[active.length - limit];\n+            return new Decision(false, windowMillis - age, active);\n         }\n         long[] next = Arrays.copyOf(active, active.length + 1);\n         next[next.length - 1] = now;\n",
          "log": "COMPILE | exit 0 | 673 ms\n\n\nTEST | exit 0 | 49 ms\nARENA_TESTS_PASSED=14\n"
        },
        {
          "id": "weighted-allocation",
          "title": "Make every cent add up",
          "language": "Java",
          "status": "pass",
          "testDurationMs": 90,
          "brief": "# Make every cent add up\n\nA checkout service divides a nonnegative number of cents between weighted recipients. Independent rounding sometimes creates or loses a cent, and floating-point arithmetic fails on large orders.\n\nRepair `Task.allocate(long cents, long[] weights)` in `src/Task.java`.\n\n## Contract\n\n- Return a new array, one share per input weight, in the original order. Never mutate `weights`.\n- Each weight is a nonnegative `long`; at least one must be positive. `cents` can be any nonnegative `long`, including `Long.MAX_VALUE`.\n- Compute each ideal share exactly as `cents * weight / sum(weights)`. Start with its floor. Distribute the remaining cents to the largest fractional remainders, one cent per recipient, with ties awarded to the lower original index.\n- The weight sum and intermediate multiplication may exceed the range of `long`. Results must remain exact.\n- Reject negative cents, null/empty weights, negative weights, and an all-zero weight array with `IllegalArgumentException`.\n- Zero cents with valid weights returns an array of zeros. Zero-weight recipients receive zero.\n\nExamples: `allocate(10, [1, 1, 1])` returns `[4, 3, 3]`; `allocate(2, [1, 3, 3])` returns `[0, 1, 1]`.\n\nOnly the implementation file is editable. Tests are public; this is an open-test repair task, not a hidden evaluation.\n",
          "diff": "--- baseline/weighted-allocation/src/Task.java\n+++ solo/weighted-allocation/src/Task.java\n@@ -1,3 +1,6 @@\n+import java.math.BigInteger;\n+import java.util.Arrays;\n+\n public final class Task {\n     private Task() {}\n \n@@ -5,16 +8,36 @@\n         if (cents < 0 || weights == null || weights.length == 0) {\n             throw new IllegalArgumentException(\"Invalid allocation input\");\n         }\n-        double totalWeight = 0;\n+        BigInteger totalWeight = BigInteger.ZERO;\n         for (long weight : weights) {\n             if (weight < 0) throw new IllegalArgumentException(\"Negative weight\");\n-            totalWeight += weight;\n+            totalWeight = totalWeight.add(BigInteger.valueOf(weight));\n         }\n-        if (totalWeight == 0) throw new IllegalArgumentException(\"All weights are zero\");\n+        if (totalWeight.signum() == 0) {\n+            throw new IllegalArgumentException(\"All weights are zero\");\n+        }\n+\n         long[] shares = new long[weights.length];\n+        if (cents == 0) return shares;\n+        BigInteger amount = BigInteger.valueOf(cents);\n+        BigInteger[] remainders = new BigInteger[weights.length];\n+        Integer[] order = new Integer[weights.length];\n+        long remaining = cents;\n         for (int i = 0; i < weights.length; i++) {\n-            shares[i] = Math.round(cents * (weights[i] / totalWeight));\n+            BigInteger[] quotientAndRemainder = amount.multiply(BigInteger.valueOf(weights[i]))\n+                    .divideAndRemainder(totalWeight);\n+            shares[i] = quotientAndRemainder[0].longValueExact();\n+            remainders[i] = quotientAndRemainder[1];\n+            remaining -= shares[i];\n+            order[i] = i;\n         }\n+\n+        // All fractions have the same denominator, so their numerators suffice.\n+        Arrays.sort(order, (left, right) -> {\n+            int byRemainder = remainders[right].compareTo(remainders[left]);\n+            return byRemainder != 0 ? byRemainder : Integer.compare(left, right);\n+        });\n+        for (int i = 0; i < remaining; i++) shares[order[i]]++;\n         return shares;\n     }\n }\n",
          "log": "COMPILE | exit 0 | 679 ms\n\n\nTEST | exit 0 | 90 ms\nARENA_TESTS_PASSED=15\n"
        }
      ]
    },
    {
      "id": "reviewed",
      "label": "Implementation + independent review",
      "wallTimeMs": 415162,
      "runtimeMs": 4307,
      "model": null,
      "tokens": null,
      "costUsd": null,
      "tasks": [
        {
          "id": "optimistic-ledger",
          "title": "Roll back only your own optimistic update",
          "language": "TypeScript",
          "status": "pass",
          "testDurationMs": 38,
          "brief": "# Roll back only your own optimistic update\n\nA frontend displays a counter immediately after an adjustment, before the server confirms it. Several updates can be pending together. Rejecting one must not erase the others, and duplicate acknowledgements must be harmless.\n\nRepair `apply(state, event)` and `value(state)` in `src/task.ts`, preserving their exported types and signatures. This is a pure TypeScript state helper, with no framework or network dependency.\n\n## Contract\n\n- `base` contains only committed adjustments. `pending` is the ordered list of unacknowledged `{token, delta}` entries. `settled` records tokens already committed or rolled back.\n- The displayed `value` is `base + sum(pending.delta)`.\n- An `adjust` with a new token appends exactly one entry to pending. It does not change base or settled. A token already pending or settled is an identity no-op, even if the repeated delta differs.\n- `commit` moves only the matching pending entry's delta into base, removes only that entry, and appends its token to settled.\n- `rollback` removes only the matching pending entry, leaves base unchanged, and appends its token to settled.\n- Commit and rollback may arrive in any order. Settling an unknown or previously settled token returns the original state by identity.\n- An accepted event returns a new state. Preserve the order of remaining pending entries and existing settled tokens. Never mutate input state, nested entries, arrays, or events. Accepted adjustments must snapshot their event fields rather than retaining a mutable event object.\n- `base` and deltas may be negative or zero. Tokens are nonempty strings. Inputs are well-formed, and all sums are safe integers; validation of malformed inputs is outside this task.\n- The caller owns retention of settled tokens. This helper must not evict them or use module-level memory.\n\nExample: base `10`, pending `A:+5, B:+2`; rollback A leaves displayed value `12`. Committing B then produces base `12`, no pending entries, and settled tokens `[A, B]`.\n\nOnly the implementation file is editable. All evaluation cases are public.\n",
          "diff": "--- baseline/optimistic-ledger/src/task.ts\n+++ reviewed/optimistic-ledger/src/task.ts\n@@ -13,15 +13,19 @@\n }\n \n export function apply(state: State, event: Event): State {\n+  if (state.settled.includes(event.token)) return state;\n+  const index = state.pending.findIndex(item => item.token === event.token);\n   if (event.type === 'adjust') {\n-    if (state.pending.some(item => item.token === event.token)) return state;\n-    return { ...state, pending: [...state.pending, event] };\n+    if (index !== -1) return state;\n+    return {\n+      ...state,\n+      pending: [...state.pending, { token: event.token, delta: event.delta }],\n+    };\n   }\n-  const item = state.pending.find(entry => entry.token === event.token);\n-  if (!item) return state;\n+  if (index === -1) return state;\n   return {\n-    base: event.type === 'commit' ? value(state) : state.base,\n-    pending: [],\n+    base: event.type === 'commit' ? state.base + state.pending[index].delta : state.base,\n+    pending: [...state.pending.slice(0, index), ...state.pending.slice(index + 1)],\n     settled: [...state.settled, event.token],\n   };\n }\n",
          "log": "COMPILE | exit 0 | 787 ms\n\n\nTEST | exit 0 | 38 ms\nARENA_TESTS_PASSED=16\n"
        },
        {
          "id": "request-state",
          "title": "Keep stale responses out of the UI",
          "language": "TypeScript",
          "status": "pass",
          "testDurationMs": 38,
          "brief": "# Keep stale responses out of the UI\n\nA frontend search box starts requests while the user types. Responses arrive out of order, and some transports can report a late terminal event after cancellation or completion.\n\nRepair the pure `reduce(state, event)` helper in `src/task.ts`. Preserve its exported types, `initialState`, and function signature. This is a dependency-free TypeScript state task, not an Angular runtime test.\n\n## Contract\n\n- Request IDs are positive safe integers, allocated in strictly increasing order by the caller. Any invalid event ID must throw `RangeError`, even when the event would otherwise be stale.\n- A `start` event is accepted only when its ID is greater than the state's ID. It replaces `requestId` and `query`, sets `status` to `loading`, clears `error`, and retains the previous result items until a response arrives.\n- A `success` or `failure` event is accepted only when its ID equals the state's ID **and** the state is still `loading`. Ignore older, future, duplicate, or already-completed response events.\n- An accepted success replaces items, sets status to `success`, and clears error. Copy the supplied item array so subsequent caller mutation cannot alter state.\n- An accepted failure sets status to `error`, stores the supplied message verbatim, and retains the previous items and query.\n- Every ignored valid event returns the exact original state object. Every accepted event returns a new state object.\n- Never mutate input state, its arrays, the event, or the event's arrays. Inputs may be frozen.\n- The initial state is request ID `0`, empty query/items, status `idle`, and null error. Response events cannot start a request on their own.\n\nOnly the implementation file is editable. All evaluation cases are public.\n",
          "diff": "--- baseline/request-state/src/task.ts\n+++ reviewed/request-state/src/task.ts\n@@ -23,8 +23,9 @@\n     if (event.requestId <= state.requestId) return state;\n     return { ...state, requestId: event.requestId, query: event.query, status: 'loading', error: null };\n   }\n+  if (event.requestId !== state.requestId || state.status !== 'loading') return state;\n   if (event.type === 'success') {\n-    return { ...state, items: event.items, status: 'success', error: null };\n+    return { ...state, items: [...event.items], status: 'success', error: null };\n   }\n   return { ...state, status: 'error', error: event.error };\n }\n",
          "log": "COMPILE | exit 0 | 732 ms\n\n\nTEST | exit 0 | 38 ms\nARENA_TESTS_PASSED=18\n"
        },
        {
          "id": "retry-policy",
          "title": "Put a ceiling on retries",
          "language": "Java",
          "status": "pass",
          "testDurationMs": 69,
          "brief": "# Put a ceiling on retries\n\nA synchronous HTTP client asks this pure helper whether to schedule another request after the current attempt. Off-by-one errors and unchecked backoff can make an outage worse.\n\nRepair `Task.decide(int attempt, int maxAttempts, long baseDelayMillis, long maxDelayMillis, int status, Long retryAfterMillis)` in `src/Task.java`. The return type is the existing `Decision(boolean retry, long delayMillis)` record.\n\n## Contract\n\n- `attempt` is the number of the request that just finished, starting at 1. `maxAttempts` includes the initial request. Never retry once `attempt == maxAttempts`.\n- Retry only status `0` (transport failure), `408`, `429`, `502`, `503`, or `504`. All other valid HTTP statuses are terminal, including other 5xx statuses.\n- For a retry, exponential delay is `baseDelayMillis * 2^(attempt - 1)`, capped at `maxDelayMillis`. Calculate it without overflow, even for large attempt numbers and `long` values. A zero base delay stays zero.\n- For statuses `429` and `503` only, a non-null `retryAfterMillis` is a lower bound on the exponential delay; the final result is still capped by `maxDelayMillis`. For other statuses the hint does not affect the result.\n- A terminal decision is exactly `Decision(false, 0)`.\n- Validate every call before returning, including terminal decisions: `1 <= attempt <= maxAttempts`; both delays nonnegative; status either `0` or `100..599`; any non-null hint nonnegative. Reject violations with `IllegalArgumentException`.\n- This helper does not sleep, read a clock, perform a request, add jitter, or parse HTTP headers. A caller has already converted any server hint to milliseconds.\n\nOnly the implementation file is editable. All evaluation cases are public.\n",
          "diff": "--- baseline/retry-policy/src/Task.java\n+++ reviewed/retry-policy/src/Task.java\n@@ -10,12 +10,20 @@\n                 || (retryAfterMillis != null && retryAfterMillis < 0)) {\n             throw new IllegalArgumentException(\"Invalid retry input\");\n         }\n-        if (status != 0 && status != 408 && status != 429 && status < 500) {\n-            return new Decision(false, 0);\n+        boolean retryable = status == 0 || status == 408 || status == 429\n+                || status == 502 || status == 503 || status == 504;\n+        if (attempt == maxAttempts || !retryable) return new Decision(false, 0);\n+\n+        long delay = Math.min(baseDelayMillis, maxDelayMillis);\n+        // Positive delays reach the cap within 63 doublings, regardless of attempt size.\n+        for (int remaining = attempt - 1;\n+             remaining > 0 && delay > 0 && delay < maxDelayMillis;\n+             remaining--) {\n+            delay = delay > maxDelayMillis / 2 ? maxDelayMillis : delay * 2;\n         }\n-        if (attempt > maxAttempts) return new Decision(false, 0);\n-        long delay = Math.min(maxDelayMillis, baseDelayMillis * (1L << attempt));\n-        if (retryAfterMillis != null) delay = retryAfterMillis;\n+        if ((status == 429 || status == 503) && retryAfterMillis != null) {\n+            delay = Math.min(maxDelayMillis, Math.max(delay, retryAfterMillis));\n+        }\n         return new Decision(true, delay);\n     }\n }\n",
          "log": "COMPILE | exit 0 | 792 ms\n\n\nTEST | exit 0 | 69 ms\nARENA_TESTS_PASSED=17\n"
        },
        {
          "id": "sliding-window",
          "title": "Repair the rate-limit boundary",
          "language": "Java",
          "status": "pass",
          "testDurationMs": 60,
          "brief": "# Repair the rate-limit boundary\n\nAn in-memory limiter stores timestamps of accepted requests. Operators can lower the limit while requests are still in the window. Clients need a precise retry delay.\n\nRepair `Task.admit(long[] acceptedAt, long now, long windowMillis, int limit)` in `src/Task.java`, preserving its `Decision(boolean allowed, long retryAfterMillis, long[] acceptedAt)` record.\n\n## Contract\n\n- All times are caller-provided nonnegative integer milliseconds. Do not read a clock or retain global state.\n- Input timestamps are sorted in nondecreasing order, may repeat, and must not be in the future. Validate the entire input, including entries that will expire.\n- The active interval is **`(now - windowMillis, now]`**. A timestamp exactly one window old is expired.\n- Remove expired entries. If fewer than `limit` active entries remain, accept the request, append `now`, and return retry delay `0`.\n- Otherwise reject without appending. Return the smallest positive delay after which this request would be accepted if no other request arrives. When historical active entries exceed a newly lowered limit, enough entries must expire to leave fewer than `limit` entries.\n- The returned timestamp array contains only the retained active entries, plus the new request when accepted. Always return a fresh array and never mutate the input.\n- `now` and `windowMillis` may reach `Long.MAX_VALUE`; compute the relative retry delay without overflowing an absolute expiry timestamp.\n- Reject a null array, negative `now`, nonpositive window or limit, negative/future timestamps, or unsorted timestamps with `IllegalArgumentException`.\n\nExample: timestamps `[100, 150, 170]`, `now=180`, `windowMillis=100`, `limit=2` must reject with delay `70`, because two entries must expire before another request can fit.\n\nOnly the implementation file is editable. All evaluation cases are public.\n",
          "diff": "--- baseline/sliding-window/src/Task.java\n+++ reviewed/sliding-window/src/Task.java\n@@ -16,10 +16,15 @@\n             previous = timestamp;\n         }\n         int first = 0;\n-        while (first < acceptedAt.length && acceptedAt[first] < now - windowMillis) first++;\n+        while (first < acceptedAt.length && now - acceptedAt[first] >= windowMillis) {\n+            first++;\n+        }\n         long[] active = Arrays.copyOfRange(acceptedAt, first, acceptedAt.length);\n         if (active.length >= limit) {\n-            return new Decision(false, active[0] + windowMillis - now, active);\n+            // Enough entries must expire to leave at most limit - 1 requests.\n+            long timestamp = active[active.length - limit];\n+            long delay = windowMillis - (now - timestamp);\n+            return new Decision(false, delay, active);\n         }\n         long[] next = Arrays.copyOf(active, active.length + 1);\n         next[next.length - 1] = now;\n",
          "log": "COMPILE | exit 0 | 793 ms\n\n\nTEST | exit 0 | 60 ms\nARENA_TESTS_PASSED=14\n"
        },
        {
          "id": "weighted-allocation",
          "title": "Make every cent add up",
          "language": "Java",
          "status": "pass",
          "testDurationMs": 75,
          "brief": "# Make every cent add up\n\nA checkout service divides a nonnegative number of cents between weighted recipients. Independent rounding sometimes creates or loses a cent, and floating-point arithmetic fails on large orders.\n\nRepair `Task.allocate(long cents, long[] weights)` in `src/Task.java`.\n\n## Contract\n\n- Return a new array, one share per input weight, in the original order. Never mutate `weights`.\n- Each weight is a nonnegative `long`; at least one must be positive. `cents` can be any nonnegative `long`, including `Long.MAX_VALUE`.\n- Compute each ideal share exactly as `cents * weight / sum(weights)`. Start with its floor. Distribute the remaining cents to the largest fractional remainders, one cent per recipient, with ties awarded to the lower original index.\n- The weight sum and intermediate multiplication may exceed the range of `long`. Results must remain exact.\n- Reject negative cents, null/empty weights, negative weights, and an all-zero weight array with `IllegalArgumentException`.\n- Zero cents with valid weights returns an array of zeros. Zero-weight recipients receive zero.\n\nExamples: `allocate(10, [1, 1, 1])` returns `[4, 3, 3]`; `allocate(2, [1, 3, 3])` returns `[0, 1, 1]`.\n\nOnly the implementation file is editable. Tests are public; this is an open-test repair task, not a hidden evaluation.\n",
          "diff": "--- baseline/weighted-allocation/src/Task.java\n+++ reviewed/weighted-allocation/src/Task.java\n@@ -1,3 +1,6 @@\n+import java.math.BigInteger;\n+import java.util.Arrays;\n+\n public final class Task {\n     private Task() {}\n \n@@ -5,15 +8,33 @@\n         if (cents < 0 || weights == null || weights.length == 0) {\n             throw new IllegalArgumentException(\"Invalid allocation input\");\n         }\n-        double totalWeight = 0;\n+        BigInteger totalWeight = BigInteger.ZERO;\n         for (long weight : weights) {\n             if (weight < 0) throw new IllegalArgumentException(\"Negative weight\");\n-            totalWeight += weight;\n+            totalWeight = totalWeight.add(BigInteger.valueOf(weight));\n         }\n-        if (totalWeight == 0) throw new IllegalArgumentException(\"All weights are zero\");\n+        if (totalWeight.signum() == 0) throw new IllegalArgumentException(\"All weights are zero\");\n+\n         long[] shares = new long[weights.length];\n+        BigInteger[] remainders = new BigInteger[weights.length];\n+        Integer[] order = new Integer[weights.length];\n+        BigInteger amount = BigInteger.valueOf(cents);\n+        long remaining = cents;\n         for (int i = 0; i < weights.length; i++) {\n-            shares[i] = Math.round(cents * (weights[i] / totalWeight));\n+            BigInteger[] parts = amount.multiply(BigInteger.valueOf(weights[i]))\n+                    .divideAndRemainder(totalWeight);\n+            shares[i] = parts[0].longValueExact();\n+            remainders[i] = parts[1];\n+            order[i] = i;\n+            remaining -= shares[i];\n+        }\n+        Arrays.sort(order, (a, b) -> {\n+            int remainderOrder = remainders[b].compareTo(remainders[a]);\n+            return remainderOrder != 0 ? remainderOrder : Integer.compare(a, b);\n+        });\n+        // The sum of fractional remainders is an integer smaller than the array length.\n+        for (int i = 0; i < remaining; i++) {\n+            shares[order[i]]++;\n         }\n         return shares;\n     }\n",
          "log": "COMPILE | exit 0 | 690 ms\n\n\nTEST | exit 0 | 75 ms\nARENA_TESTS_PASSED=15\n"
        }
      ]
    }
  ]
}