Five Desks Code: tasks, calibration and source

README.md

@@ -0,0 +1,102 @@
+---
+license: apache-2.0
+pretty_name: Five Desks Code (OpenEnv environment)
+tags:
+- openenv
+- reinforcement-learning
+- rl-environment
+- tool-use
+- agents
+- software-engineering
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: tasks.jsonl
+---
+
+# Five Desks Code: agentic coding on real libraries from every domain
+
+Five Desks Code is an [OpenEnv](https://github.com/meta-pytorch/OpenEnv) environment for the
+[OpenEnv Arena](https://openenvarena-arena.hf.space/). Every task is real agentic software work: explore an
+unfamiliar repository, reproduce a problem, read code, run things, change code, check that nothing else broke, and
+submit. The repositories are pinned releases of open-source Python libraries from the arena's eight domains, so the
+coding happens inside finance, science, scheduling, subtitles, signing, pipe-flow and media code, and the media
+tasks use real production tools (ffmpeg, ImageMagick, Pillow).
+
+Why coding: RL on software tasks has been reported to carry over to other reasoning tasks (for example SWE-RL), and on this arena's own
+leaderboard the software-repair runs that had a learning signal averaged 4.0/40 against about 3.0 for all runs,
+including two of the three best single runs (a gap inside the 1 to 4 that runs with no learning at all have scored,
+so it is a hunch, not evidence). Three runs of our own narrower diligence tasks (Five Desks v1-v3) learned
+their tasks and scored 2, 2 and 1 out of 40.
+
+- **Image:** `ghcr.io/rca-umb/five-desks` (code tag, linux/amd64, public); the arena pins the digest.
+- **Source:** [`source/`](./source): environment, tests, the catalog builder and the calibration code.
+
+## Tasks
+
+**Bug fixing (`bugfix-<domain>-l1|l2`).** Each instance takes one library and one bug from a build-time catalog of
+525: a single token changed inside a function (a comparison, an operator, a constant, `and`/`or`, a `not`) that
+1 to 8 of the library's own tests catch. The catalog builder plants every candidate change in a container, runs the
+library's test suite, keeps the changes the tests catch, and then checks each one inside the final image (the
+untouched repository must fail, the original code must pass, at both levels). Level 1 is a failing CI run: the issue
+shows the failing test's output and the suite is in the repository. Level 2 is a user report: the issue shows only
+the failing check, and the tests that cover it are removed, so the policy has to reproduce, locate and verify on its
+own.
+
+**Media production (`media-production-l1|l2`).** Each instance generates its own media and a client spec plus
+production notes that add one requirement the spec does not mention: a trimmed, scaled clip (with or without a mono
+audio track), square thumbnails from photos rotated by EXIF (skipping placeholders), a contact sheet ordered by
+capture time, or a loudness-normalised FLAC delivery (with or without the leading silence).
+
+Tools (names and argument names are drawn per episode, e.g. `read_file`/`cat`/`open_file`, so the policy has to read
+the tool list): list files, read a file with line numbers, search with a regular expression, replace an exact
+snippet, write a file, run a shell command (60 s), run pytest (100 s), submit. One generic action for everything:
+`{"tool": "<name>", "args": {...}}`.
+
+## Reward and grading
+
+All or nothing. A bug fix scores 1 only if every catching test passes and no other test in those files fails that
+passes on the original library. Grading copies only the library's own source files from the workspace into a clean
+copy of the original project and runs the original tests there, so edits to tests, configuration or `conftest.py`
+change nothing, and a package containing symlinks scores 0. Media deliverables are measured, not trusted: stream
+properties with ffprobe, the first frame against the right moment of the source, thumbnail and tile content against
+references computed from a private copy of the inputs, and the peak level and start of the audio.
+
+The policy's commands run as the unprivileged `nobody` user with CPU, memory, file-size and process limits; the
+server, the bug catalog and the original sources are root-only. `source/codedesk/tests` checks: oracle 1 and
+untouched 0 for every task id, test-file edits and conftest tricks score 0, symlinks out score 0, the catching tests
+are absent at level 2, the policy cannot read the server, and a set of hostile tool calls (path escapes, a fork bomb,
+endless output, killing the server) cannot escape or crash an episode.
+
+## Calibration (Qwen3.8-27B, thinking off, arena reply parsing)
+
+HF Inference Providers (DeepInfra), temperature 1.0, arena-style system prompt with the action schema, budgets as
+submitted, replies parsed by their first JSON object (which matched the arena's training rewards on our earlier
+tasks). The trained tasks, one per domain plus media production:
+
+| task id | domain | code | what the policy gets | solved by the untrained model |
+|---|---|---|---|---|
+| bugfix-office-l1 | office | croniter, isodate, humanize | failing CI test given | 0.56 (16) |
+| bugfix-finance-l1 | finance | numpy-financial | failing CI test given | 0.50 (16) |
+| bugfix-science-l1 | natural science | uncertainties | failing CI test given | 0.31 (16) |
+| bugfix-industrial-l2 | industrial | fluids (pumps, valves, pipe flow, fittings) | user report only; catching tests removed | 0.38 (16) |
+| bugfix-media-l2 | media | srt, webvtt-py, python-slugify | user report only; catching tests removed | 0.56 (16) |
+| bugfix-security-l2 | cybersecurity | PyJWT, itsdangerous | user report only; catching tests removed | 0.50 (16) |
+| bugfix-software-l2 | software engineering | toolz, tabulate, inflection | user report only; catching tests removed | 0.69 (16) |
+| bugfix-math-l1 | math | more-itertools | failing CI test given | 0.50 (16) |
+| media-production-l2 | media | ffmpeg, ImageMagick, Pillow | clip, thumbnails, contact sheet or audio delivery from spec.md + notes.md | 0.44 (16) |
+
+All picked tasks have mixed outcomes, so GRPO groups carry signal. About a third of the losses are replies that are
+not one valid action (arguments outside `args`, invalid JSON escapes in long code strings, prose with no action):
+keeping tool calls well-formed while carrying code is part of what these tasks train. Episodes are long (about 13
+tool calls), so a 4-hour run takes fewer optimizer steps than with short tasks.
+
+## Libraries
+
+Pinned sources as published on PyPI, shipped with their licenses: croniter 6.2.4 (MIT), isodate 0.7.2 (BSD),
+humanize 4.16.0 (MIT), numpy-financial 1.0.0 (BSD-3-Clause), uncertainties 3.2.3 (BSD-3-Clause), fluids 1.3.1 (MIT),
+srt 3.5.3 (MIT), webvtt-py 0.5.1 (MIT), python-slugify 9.1.3 (MIT), PyJWT 2.15.1 (MIT), itsdangerous 2.2.0
+(BSD-3-Clause), toolz 1.2.0 (BSD-3-Clause), tabulate 0.10.0 (MIT), inflection 0.5.1 (MIT), more-itertools 11.1.0 (MIT).
+The bug catalog (which line was changed) is the answer key and is not published here; `source/codedesk/build`
+rebuilds it from these versions.

calibration/r1_summary.json

@@ -0,0 +1,419 @@
+{
+  "model": "Qwen/Qwen3.8-27B:deepinfra",
+  "lenient": true,
+  "episodes": 144,
+  "seconds": 1070,
+  "usage": {
+    "prompt_tokens": 13852782,
+    "completion_tokens": 233631,
+    "calls": 2124,
+    "empty_content": 115
+  },
+  "tasks": {
+    "bugfix-office-l1": {
+      "n": 8,
+      "mean": 0.5,
+      "solved": 4,
+      "rewards": [
+        0.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0
+      ],
+      "ends": {
+        "schema_invalid": 1,
+        "submitted": 4,
+        "empty": 1,
+        "no_json": 2
+      },
+      "turns": 13,
+      "rescued_replies": 23
+    },
+    "bugfix-office-l2": {
+      "n": 8,
+      "mean": 0.625,
+      "solved": 5,
+      "rewards": [
+        0.0,
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "ends": {
+        "no_json": 1,
+        "submitted": 6,
+        "budget": 1
+      },
+      "turns": 22.2,
+      "rescued_replies": 69
+    },
+    "bugfix-finance-l1": {
+      "n": 8,
+      "mean": 0.375,
+      "solved": 3,
+      "rewards": [
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 3,
+        "schema_invalid": 2,
+        "truncated": 1,
+        "no_json": 2
+      },
+      "turns": 7.9,
+      "rescued_replies": 18
+    },
+    "bugfix-finance-l2": {
+      "n": 8,
+      "mean": 0.125,
+      "solved": 1,
+      "rewards": [
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 3,
+        "out_of_steps": 1,
+        "no_json": 1,
+        "schema_invalid": 2,
+        "truncated": 1
+      },
+      "turns": 17.1,
+      "rescued_replies": 82
+    },
+    "bugfix-science-l1": {
+      "n": 8,
+      "mean": 0.25,
+      "solved": 2,
+      "rewards": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0
+      ],
+      "ends": {
+        "schema_invalid": 4,
+        "no_json": 1,
+        "budget": 1,
+        "submitted": 1,
+        "truncated": 1
+      },
+      "turns": 8.9,
+      "rescued_replies": 37
+    },
+    "bugfix-science-l2": {
+      "n": 8,
+      "mean": 0.25,
+      "solved": 2,
+      "rewards": [
+        1.0,
+        1.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 5,
+        "no_json": 1,
+        "out_of_steps": 1,
+        "schema_invalid": 1
+      },
+      "turns": 22.2,
+      "rescued_replies": 85
+    },
+    "bugfix-industrial-l1": {
+      "n": 8,
+      "mean": 0.875,
+      "solved": 7,
+      "rewards": [
+        1.0,
+        1.0,
+        1.0,
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "ends": {
+        "submitted": 7,
+        "no_json": 1
+      },
+      "turns": 13.6,
+      "rescued_replies": 59
+    },
+    "bugfix-industrial-l2": {
+      "n": 8,
+      "mean": 0.375,
+      "solved": 3,
+      "rewards": [
+        0.0,
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0
+      ],
+      "ends": {
+        "schema_invalid": 2,
+        "submitted": 3,
+        "no_json": 2,
+        "out_of_steps": 1
+      },
+      "turns": 17.2,
+      "rescued_replies": 21
+    },
+    "bugfix-media-l1": {
+      "n": 8,
+      "mean": 0.375,
+      "solved": 3,
+      "rewards": [
+        0.0,
+        1.0,
+        0.0,
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0
+      ],
+      "ends": {
+        "no_json": 2,
+        "submitted": 3,
+        "empty": 1,
+        "schema_invalid": 1,
+        "truncated": 1
+      },
+      "turns": 12.1,
+      "rescued_replies": 30
+    },
+    "bugfix-media-l2": {
+      "n": 8,
+      "mean": 0.375,
+      "solved": 3,
+      "rewards": [
+        0.0,
+        0.0,
+        1.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0,
+        0.0
+      ],
+      "ends": {
+        "schema_invalid": 3,
+        "submitted": 4,
+        "budget": 1
+      },
+      "turns": 13.2,
+      "rescued_replies": 54
+    },
+    "bugfix-security-l1": {
+      "n": 8,
+      "mean": 0.75,
+      "solved": 6,
+      "rewards": [
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "ends": {
+        "submitted": 6,
+        "no_json": 1,
+        "schema_invalid": 1
+      },
+      "turns": 10.6,
+      "rescued_replies": 27
+    },
+    "bugfix-security-l2": {
+      "n": 8,
+      "mean": 0.5,
+      "solved": 4,
+      "rewards": [
+        1.0,
+        0.0,
+        1.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 4,
+        "schema_invalid": 3,
+        "empty": 1
+      },
+      "turns": 12.2,
+      "rescued_replies": 50
+    },
+    "bugfix-software-l1": {
+      "n": 8,
+      "mean": 0.75,
+      "solved": 6,
+      "rewards": [
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 6,
+        "out_of_steps": 1,
+        "schema_invalid": 1
+      },
+      "turns": 17.8,
+      "rescued_replies": 68
+    },
+    "bugfix-software-l2": {
+      "n": 8,
+      "mean": 0.75,
+      "solved": 6,
+      "rewards": [
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        1.0
+      ],
+      "ends": {
+        "submitted": 6,
+        "empty": 1,
+        "schema_invalid": 1
+      },
+      "turns": 12.2,
+      "rescued_replies": 46
+    },
+    "bugfix-math-l1": {
+      "n": 8,
+      "mean": 0.5,
+      "solved": 4,
+      "rewards": [
+        1.0,
+        1.0,
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 5,
+        "no_json": 1,
+        "schema_invalid": 2
+      },
+      "turns": 13.9,
+      "rescued_replies": 56
+    },
+    "bugfix-math-l2": {
+      "n": 8,
+      "mean": 0.375,
+      "solved": 3,
+      "rewards": [
+        1.0,
+        1.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        1.0
+      ],
+      "ends": {
+        "submitted": 4,
+        "out_of_steps": 2,
+        "schema_invalid": 1,
+        "no_json": 1
+      },
+      "turns": 21.4,
+      "rescued_replies": 49
+    },
+    "media-production-l1": {
+      "n": 8,
+      "mean": 0.375,
+      "solved": 3,
+      "rewards": [
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 7,
+        "no_json": 1
+      },
+      "turns": 8.5,
+      "rescued_replies": 3
+    },
+    "media-production-l2": {
+      "n": 8,
+      "mean": 0.5,
+      "solved": 4,
+      "rewards": [
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0
+      ],
+      "ends": {
+        "submitted": 5,
+        "no_json": 1,
+        "schema_invalid": 2
+      },
+      "turns": 7.6,
+      "rescued_replies": 8
+    }
+  }
+}

calibration/r2_summary.json

@@ -0,0 +1,215 @@
+{
+  "model": "Qwen/Qwen3.8-27B:deepinfra",
+  "lenient": true,
+  "episodes": 72,
+  "seconds": 522,
+  "usage": {
+    "prompt_tokens": 7635035,
+    "completion_tokens": 98268,
+    "calls": 1042,
+    "empty_content": 61
+  },
+  "tasks": {
+    "bugfix-office-l1": {
+      "n": 8,
+      "mean": 0.625,
+      "solved": 5,
+      "rewards": [
+        1.0,
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 4,
+        "no_json": 1,
+        "schema_invalid": 2,
+        "truncated": 1
+      },
+      "turns": 12.9,
+      "rescued_replies": 35
+    },
+    "bugfix-finance-l1": {
+      "n": 8,
+      "mean": 0.625,
+      "solved": 5,
+      "rewards": [
+        1.0,
+        1.0,
+        0.0,
+        1.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 5,
+        "no_json": 1,
+        "schema_invalid": 2
+      },
+      "turns": 10.4,
+      "rescued_replies": 33
+    },
+    "bugfix-science-l1": {
+      "n": 8,
+      "mean": 0.375,
+      "solved": 3,
+      "rewards": [
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0
+      ],
+      "ends": {
+        "truncated": 1,
+        "schema_invalid": 2,
+        "submitted": 3,
+        "no_json": 2
+      },
+      "turns": 12,
+      "rescued_replies": 20
+    },
+    "bugfix-industrial-l2": {
+      "n": 8,
+      "mean": 0.375,
+      "solved": 3,
+      "rewards": [
+        0.0,
+        0.0,
+        1.0,
+        1.0,
+        0.0,
+        0.0,
+        0.0,
+        1.0
+      ],
+      "ends": {
+        "truncated": 1,
+        "schema_invalid": 1,
+        "submitted": 4,
+        "out_of_steps": 2
+      },
+      "turns": 23.5,
+      "rescued_replies": 58
+    },
+    "bugfix-media-l2": {
+      "n": 8,
+      "mean": 0.75,
+      "solved": 6,
+      "rewards": [
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0,
+        1.0
+      ],
+      "ends": {
+        "submitted": 6,
+        "schema_invalid": 2
+      },
+      "turns": 13.9,
+      "rescued_replies": 54
+    },
+    "bugfix-security-l2": {
+      "n": 8,
+      "mean": 0.5,
+      "solved": 4,
+      "rewards": [
+        0.0,
+        1.0,
+        1.0,
+        0.0,
+        0.0,
+        0.0,
+        1.0,
+        1.0
+      ],
+      "ends": {
+        "schema_invalid": 2,
+        "submitted": 4,
+        "out_of_steps": 2
+      },
+      "turns": 13.9,
+      "rescued_replies": 60
+    },
+    "bugfix-software-l2": {
+      "n": 8,
+      "mean": 0.625,
+      "solved": 5,
+      "rewards": [
+        0.0,
+        1.0,
+        1.0,
+        0.0,
+        0.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "ends": {
+        "out_of_steps": 2,
+        "submitted": 4,
+        "schema_invalid": 2
+      },
+      "turns": 16.1,
+      "rescued_replies": 30
+    },
+    "bugfix-math-l1": {
+      "n": 8,
+      "mean": 0.5,
+      "solved": 4,
+      "rewards": [
+        1.0,
+        1.0,
+        1.0,
+        0.0,
+        1.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "ends": {
+        "submitted": 4,
+        "no_json": 1,
+        "out_of_steps": 1,
+        "schema_invalid": 2
+      },
+      "turns": 13.4,
+      "rescued_replies": 40
+    },
+    "media-production-l2": {
+      "n": 8,
+      "mean": 0.375,
+      "solved": 3,
+      "rewards": [
+        1.0,
+        1.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        1.0
+      ],
+      "ends": {
+        "submitted": 5,
+        "schema_invalid": 2,
+        "no_json": 1
+      },
+      "turns": 6.9,
+      "rescued_replies": 9
+    }
+  }
+}

libraries.json

@@ -0,0 +1,52 @@
+{
+ "mutants_per_library": {
+  "croniter": 40,
+  "isodate": 37,
+  "humanize": 40,
+  "numpy_financial": 40,
+  "uncertainties": 39,
+  "webvtt": 40,
+  "slugify": 40,
+  "jwt": 35,
+  "toolz": 40,
+  "tabulate": 40,
+  "inflection": 38,
+  "more_itertools": 40,
+  "srt": 13,
+  "itsdangerous": 3,
+  "fluids": 40
+ },
+ "libraries_per_domain": {
+  "office-white-collar": [
+   "croniter",
+   "humanize",
+   "isodate"
+  ],
+  "finance-economics": [
+   "numpy_financial"
+  ],
+  "natural-science": [
+   "uncertainties"
+  ],
+  "media-content-production": [
+   "slugify",
+   "srt",
+   "webvtt"
+  ],
+  "cybersecurity": [
+   "itsdangerous",
+   "jwt"
+  ],
+  "software-engineering": [
+   "inflection",
+   "tabulate",
+   "toolz"
+  ],
+  "mathematics-or-formal-reasoning": [
+   "more_itertools"
+  ],
+  "industrial-physical-systems": [
+   "fluids"
+  ]
+ }
+}

source/codedesk/Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.12-slim
+LABEL org.opencontainers.image.title="Five Desks Code"
+LABEL org.opencontainers.image.description="OpenEnv environment: agentic coding on real open-source libraries from every arena domain"
+LABEL org.opencontainers.image.source="https://huggingface.co/datasets/rca-umb/five-desks"
+LABEL org.opencontainers.image.licenses="Apache-2.0"
+WORKDIR /app
+COPY requirements.lock /app/requirements.lock
+COPY codedesk/requirements-tools.txt /app/requirements-tools.txt
+RUN apt-get update && apt-get install -y --no-install-recommends git ffmpeg imagemagick \
+    && pip install --no-cache-dir -r requirements.lock -r requirements-tools.txt \
+    && apt-get purge -y git && apt-get autoremove -y && rm -rf /var/lib/apt/lists/* \
+    && pip uninstall -y pip
+COPY codedesk /app/codedesk
+# The server runs as root so it can run the policy's commands as `nobody`, which cannot read /app (the bug catalog
+# and the original library sources live there).
+RUN rm -rf /app/codedesk/build && chmod -R go-rwx /app
+ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1
+EXPOSE 8000
+CMD ["uvicorn", "codedesk.server.app:app", "--host", "0.0.0.0", "--port", "8000"]

source/codedesk/base.py

@@ -0,0 +1,168 @@
+"""Tools with declared arguments, and the base class for coding tasks."""
+
+import random
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable
+
+from . import runner
+
+TYPE_NAMES = {str: "string", int: "integer", float: "number", dict: "object", list: "array"}
+READ_LINES = 200
+
+
+@dataclass
+class Tool:
+    name: str
+    help: str
+    fn: Callable[[dict], str]
+    args: dict[str, type] = field(default_factory=dict)
+    optional: tuple[str, ...] = ()
+    final: bool = False
+
+    def signature(self) -> str:
+        parts = [f'"{k}": {TYPE_NAMES[t]}' + (" (optional)" if k in self.optional else "") for k, t in self.args.items()]
+        return "{" + ", ".join(parts) + "}"
+
+    def check(self, args: dict) -> str | None:
+        unknown = sorted(set(args) - set(self.args))
+        if unknown:
+            return f"Unknown argument(s) {unknown} for {self.name}. It takes {self.signature()}."
+        missing = [k for k in self.args if k not in args and k not in self.optional]
+        if missing:
+            return f"Missing argument(s) {missing} for {self.name}. It takes {self.signature()}."
+        for k, t in self.args.items():
+            if k in args and not (isinstance(args[k], t) and not (t is int and isinstance(args[k], bool))):
+                return f"Argument {k!r} of {self.name} must be a {TYPE_NAMES[t]}."
+        return None
+
+
+class CodingTask:
+    """One generated instance with its own workspace directory. Subclasses implement setup(), brief(), grade()."""
+
+    family = ""
+    domain = ""
+    levels = (1, 2)
+    max_steps = 30
+
+    def __init__(self, rng: random.Random, level: int, group: str = "", **opts):
+        self.rng, self.level, self.group, self.opts = rng, level, group, opts
+        self.ws = runner.new_workspace()
+        try:
+            self.setup()
+            runner.give_to_nobody(self.ws)
+        except BaseException:
+            self.close()
+            raise
+
+    def close(self):
+        runner.remove(self.ws)
+
+    # -- to implement --------------------------------------------------------------------------------
+    def setup(self):
+        raise NotImplementedError
+
+    def brief(self) -> str:
+        raise NotImplementedError
+
+    def grade(self, args: dict) -> float:
+        raise NotImplementedError
+
+    def oracle(self):
+        """Change the workspace into a correct solution (used by tests)."""
+        raise NotImplementedError
+
+    # -- shared tools --------------------------------------------------------------------------------
+    def _path(self, rel: str) -> Path | None:
+        rel = str(rel).strip()
+        p = (self.ws / rel.lstrip("/")).resolve() if not rel.startswith(str(self.ws)) else Path(rel).resolve()
+        ws = self.ws.resolve()
+        return p if p == ws or ws in p.parents else None
+
+    def coding_tools(self, tests: bool = True) -> list[Tool]:
+        tools = [
+            Tool("list_files", "list files under a directory of the repository (the root if omitted)", self._ls,
+                 {"path": str}, optional=("path",)),
+            Tool("read_file", f"show a file with line numbers (lines start-end, at most {READ_LINES} at a time)",
+                 self._read, {"path": str, "start": int, "end": int}, optional=("start", "end")),
+            Tool("search", "search the repository for a regular expression (grep -rn)", self._search,
+                 {"pattern": str, "path": str}, optional=("path",)),
+            Tool("edit_file", "replace an exact snippet of a file with new text (the snippet must occur once)",
+                 self._edit, {"path": str, "old": str, "new": str}),
+            Tool("write_file", "create or overwrite a whole file", self._write, {"path": str, "content": str}),
+            Tool("run", "run a shell command in the repository root (60 s limit), e.g. python -c '...'", self._run,
+                 {"command": str}),
+        ]
+        if tests:
+            tools.append(Tool("run_tests", "run pytest on a test file or directory (the whole suite if omitted; "
+                                           "100 s limit)",
+                              self._tests, {"target": str}, optional=("target",)))
+        return tools
+
+    def _ls(self, a):
+        p = self._path(a.get("path", "."))
+        if p is None or not p.is_dir():
+            return f"No directory {a.get('path')!r}."
+        rows = []
+        for q in sorted(p.rglob("*")):
+            rel = q.relative_to(self.ws).as_posix()
+            if any(part.startswith(".") or part == "__pycache__" for part in rel.split("/")):
+                continue
+            if q.is_file():
+                rows.append(rel)
+        return "\n".join(rows[:300]) + (f"\n... {len(rows) - 300} more" if len(rows) > 300 else "") or "(empty)"
+
+    def _read(self, a):
+        p = self._path(a["path"])
+        if p is None or not p.is_file():
+            return f"No file {a['path']!r}."
+        lines = p.read_text(errors="replace").split("\n")
+        start = max(1, a.get("start", 1))
+        end = min(len(lines), a.get("end", start + READ_LINES - 1), start + READ_LINES - 1)
+        body = "\n".join(f"{i:5d}  {lines[i - 1]}" for i in range(start, end + 1))
+        more = f"\n[lines {start}-{end} of {len(lines)}]" if end < len(lines) or start > 1 else ""
+        return body + more
+
+    def _search(self, a):
+        if not a["pattern"]:
+            return "pattern is empty"
+        p = self._path(a.get("path", "."))
+        if p is None:
+            return "path is outside the repository"
+        import shlex
+        code, out = runner.run(f"grep -rnE --exclude-dir=__pycache__ -- {shlex.quote(a['pattern'])} "
+                               f"{shlex.quote(str(p))} | head -60", self.ws, timeout=20)
+        return out.replace(str(self.ws) + "/", "") or "no matches"
+
+    def _edit(self, a):
+        p = self._path(a["path"])
+        if p is None or not p.is_file():
+            return f"No file {a['path']!r}."
+        text = p.read_text(errors="replace")
+        n = text.count(a["old"]) if a["old"] else 0
+        if n != 1:
+            return f"The snippet occurs {n} times in {a['path']}; it must occur exactly once (include more context)."
+        p.write_text(text.replace(a["old"], a["new"]))
+        return f"Edited {a['path']}."
+
+    def _write(self, a):
+        p = self._path(a["path"])
+        if p is None or p == self.ws.resolve():
+            return "path must be a file inside the repository"
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(a["content"])
+        runner.give_to_nobody(p.parent)
+        return f"Wrote {len(a['content'])} characters to {a['path']}."
+
+    def _run(self, a):
+        if not a["command"].strip():
+            return "command is empty"
+        code, out = runner.run(a["command"], self.ws, timeout=60)
+        return f"exit code {code}\n" + runner.trim(out.replace(str(self.ws) + "/", ""))
+
+    def _tests(self, a):
+        import shlex
+        target = a.get("target", "").strip()
+        code, out = runner.run("python -m pytest -q -p no:cacheprovider --tb=short -x --hypothesis-seed=0 "
+                               + (shlex.quote(target) if target else ""), self.ws, timeout=100)
+        return f"exit code {code}\n" + runner.trim(out.replace(str(self.ws) + "/", ""))

source/codedesk/build/Dockerfile.builder

@@ -0,0 +1,5 @@
+# Build-time only: runs pinned libraries' tests to build the mutation catalog (no network at run time).
+FROM python:3.12-slim
+RUN pip install --no-cache-dir pytest==8.3.3 hypothesis==6.112.1 numpy==2.1.2 python-dateutil==2.9.0.post0 \
+    pytz==2024.2 text-unidecode==1.3 freezegun==1.5.1
+WORKDIR /work

source/codedesk/build/catalog.py

@@ -0,0 +1,258 @@
+"""Build the bug catalog for Five Desks Code: single-token mutants of real libraries that their own tests detect.
+
+Runs inside the builder container (no network), never on the host:
+
+    docker run --rm --network none -v $PWD/sdists:/sdists:ro -v $PWD/out:/out -v $PWD:/build:ro \
+        codedesk-builder python /build/catalog.py [--per-lib 80]
+
+For each library: run its test suite once (baseline), enumerate mutation sites inside function bodies (comparison,
+arithmetic, boolean and constant changes), apply each one alone, run the tests again and keep mutants that 1 to 8
+previously passing tests catch. Writes /out/<lib>/ (the pristine source tree) and /out/catalog.json.
+"""
+
+import argparse
+import ast
+import io
+import json
+import os
+import random
+import re
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import tokenize
+import xml.etree.ElementTree as ET
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+# name: (sdist stem, package path inside the sdist, tests path, domain, test runner timeout s)
+LIBS = {
+    "croniter": ("croniter-6.2.4", "src/croniter", "src/croniter/tests", "office-white-collar", 120),
+    "isodate": ("isodate-0.7.2", "src/isodate", "tests", "office-white-collar", 60),
+    "humanize": ("humanize-4.16.0", "src/humanize", "tests", "office-white-collar", 60),
+    "numpy_financial": ("numpy-financial-1.0.0", "numpy_financial", "numpy_financial/tests", "finance-economics", 60),
+    "uncertainties": ("uncertainties-3.2.3", "uncertainties", "tests", "natural-science", 120),
+    "simple_pid": ("simple_pid-2.0.1", "simple_pid", "tests", "industrial-physical-systems", 60),
+    "srt": ("srt-3.5.3", "srt.py", "tests", "media-content-production", 180),
+    "webvtt": ("webvtt-py-0.5.1", "webvtt", "tests", "media-content-production", 60),
+    "slugify": ("python_slugify-9.1.3", "slugify", "tests", "media-content-production", 60),
+    "itsdangerous": ("itsdangerous-2.2.0", "src/itsdangerous", "tests", "cybersecurity", 60),
+    "jwt": ("pyjwt-2.15.1", "jwt", "tests", "cybersecurity", 60),
+    "toolz": ("toolz-1.2.0", "toolz", "toolz/tests", "software-engineering", 60),
+    "tabulate": ("tabulate-0.10.0", "tabulate", "test", "software-engineering", 60),
+    "inflection": ("inflection-0.5.1", "inflection", "test_inflection.py", "software-engineering", 60),
+    "more_itertools": ("more_itertools-11.1.0", "more_itertools", "tests", "mathematics-or-formal-reasoning", 240),
+    "semver": ("semver-3.1.0", "src/semver", "tests", "software-engineering", 60),
+    "fluids": ("fluids-1.3.1", "fluids", "tests", "industrial-physical-systems", 120),
+}
+# libraries whose catalog uses only some modules and the test files that cover them
+SUBSET = {
+    "fluids": {m: f"tests/test_{m}.py" for m in ["pump", "control_valve", "friction", "fittings", "core", "compressible",
+                                                 "safety_valve", "piping", "flow_meter", "separator", "two_phase",
+                                                 "open_flow", "jet_pump", "packed_bed", "drag", "mixing"]},
+}
+
+# tests that never finish on their own (real-time simulation); they are also removed from the shipped copies
+DESELECT = ["--deselect", "tests/test_pid.py::test_converge_system"]
+
+SWAPS = {ast.Lt: "<=", ast.LtE: "<", ast.Gt: ">=", ast.GtE: ">", ast.Eq: "!=", ast.NotEq: "==",
+         ast.Add: "-", ast.Sub: "+", ast.Mult: "/", ast.Div: "*", ast.FloorDiv: "/", ast.Mod: "//",
+         ast.And: "or", ast.Or: "and"}
+OP_TEXT = {ast.Lt: "<", ast.LtE: "<=", ast.Gt: ">", ast.GtE: ">=", ast.Eq: "==", ast.NotEq: "!=", ast.Add: "+",
+           ast.Sub: "-", ast.Mult: "*", ast.Div: "/", ast.FloorDiv: "//", ast.Mod: "%", ast.And: "and", ast.Or: "or"}
+
+
+def sites(src: str):
+    """Yield (line, col, old, new, kind, function) for single-token mutations inside function bodies."""
+    tree = ast.parse(src)
+    toks = [t for t in tokenize.generate_tokens(io.StringIO(src).readline) if t.type in (tokenize.OP, tokenize.NAME)]
+
+    def token_between(a, b, text):
+        for t in toks:
+            if a <= t.start and t.end <= b and t.string == text:
+                return t
+        return None
+
+    def walk(node, func):
+        for child in ast.iter_child_nodes(node):
+            name = child.name if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)) else func
+            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                # skip decorators and defaults: mutate the body only
+                for stmt in child.body:
+                    if not (isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Constant)):  # docstrings
+                        yield from walk_stmt(stmt, name)
+                continue
+            if isinstance(child, ast.ClassDef):
+                yield from walk(child, func)
+
+    def walk_stmt(stmt, func):
+        for n in ast.walk(stmt):
+            if isinstance(n, ast.Compare):
+                left = n.left
+                for op, right in zip(n.ops, n.comparators):
+                    if type(op) in SWAPS:
+                        t = token_between((left.end_lineno, left.end_col_offset), (right.lineno, right.col_offset),
+                                          OP_TEXT[type(op)])
+                        if t:
+                            yield t.start[0], t.start[1], t.string, SWAPS[type(op)], "compare", func
+                    left = right
+            elif isinstance(n, ast.BinOp) and type(n.op) in SWAPS:
+                if isinstance(n.left, ast.Constant) and isinstance(n.left.value, str):
+                    continue  # string formatting with %, concatenation
+                t = token_between((n.left.end_lineno, n.left.end_col_offset), (n.right.lineno, n.right.col_offset),
+                                  OP_TEXT[type(n.op)])
+                if t:
+                    yield t.start[0], t.start[1], t.string, SWAPS[type(n.op)], "arith", func
+            elif isinstance(n, ast.BoolOp) and type(n.op) in SWAPS:
+                for a, b in zip(n.values, n.values[1:]):
+                    t = token_between((a.end_lineno, a.end_col_offset), (b.lineno, b.col_offset), OP_TEXT[type(n.op)])
+                    if t:
+                        yield t.start[0], t.start[1], t.string, SWAPS[type(n.op)], "bool", func
+            elif isinstance(n, ast.UnaryOp) and isinstance(n.op, ast.Not):
+                yield n.lineno, n.col_offset, "not ", "", "not", func
+            elif (isinstance(n, ast.Constant) and type(n.value) is int and 0 <= n.value <= 64
+                  and n.end_lineno == n.lineno and n.end_col_offset - n.col_offset == len(str(n.value))):
+                yield n.lineno, n.col_offset, str(n.value), str(n.value + 1 if n.value != 1 else 0), "const", func
+
+    yield from walk(tree, None)
+
+
+def apply(src: str, line: int, col: int, old: str, new: str) -> str:
+    lines = src.splitlines(keepends=True)
+    text = lines[line - 1]
+    assert text[col:col + len(old)] == old, (text, col, old)
+    lines[line - 1] = text[:col] + new + text[col + len(old):]
+    return "".join(lines)
+
+
+def run_tests(root: Path, tests: str, timeout: int, select=None):
+    """Run pytest; return ({nodeid: outcome}, output) or (None, output) on a crash or timeout."""
+    with tempfile.TemporaryDirectory() as tmp:
+        xml = Path(tmp) / "r.xml"
+        cmd = [sys.executable, "-m", "pytest", "-q", "-p", "no:cacheprovider", "-p", "no:randomly", "--tb=no",
+               "--hypothesis-seed=0", f"--junitxml={xml}", "-o", "junit_family=xunit1", *DESELECT,
+               *(select or [tests])]
+        env = {**os.environ, "PYTHONPATH": f"{root}:{root}/src", "PYTHONDONTWRITEBYTECODE": "1"}
+        try:
+            proc = subprocess.run(cmd, cwd=root, env=env, capture_output=True, text=True, timeout=timeout)
+        except subprocess.TimeoutExpired:
+            return None, "timeout"
+        if not xml.exists():
+            return None, proc.stdout[-2000:] + proc.stderr[-2000:]
+        results = {}
+        for case in ET.parse(xml).getroot().iter("testcase"):
+            nodeid = f"{case.get('file') or case.get('classname')}::{case.get('name')}"
+            kids = {c.tag for c in case}
+            results[nodeid] = ("failed" if kids & {"failure", "error"} else "skipped" if "skipped" in kids else "passed")
+        return results, proc.stdout[-4000:]
+
+
+def failure_text(root: Path, nodeid: str, timeout: int) -> str:
+    file_part, _, name = nodeid.partition("::")
+    env = {**os.environ, "PYTHONPATH": f"{root}:{root}/src", "PYTHONDONTWRITEBYTECODE": "1"}
+    cmd = [sys.executable, "-m", "pytest", "-q", "-p", "no:cacheprovider", "--tb=short", "-x", "--hypothesis-seed=0",
+           *DESELECT, "-k", name.split("[")[0]]
+    path = file_part.replace(".", "/") + ".py" if not file_part.endswith(".py") else file_part
+    if (root / path).exists():
+        cmd.append(path)
+    try:
+        out = subprocess.run(cmd, cwd=root, env=env, capture_output=True, text=True, timeout=timeout).stdout
+    except subprocess.TimeoutExpired:
+        return ""
+    return out[-3000:]
+
+
+def build_lib(name, spec, per_lib, out_dir, workers):
+    stem, pkg, tests, domain, timeout = spec
+    pristine = out_dir / name
+    if pristine.exists():
+        shutil.rmtree(pristine)
+    with tarfile.open(f"/sdists/{stem}.tar.gz") as tf:
+        tf.extractall(out_dir / "_extract", filter="data")
+    shutil.move(str(out_dir / "_extract" / stem), str(pristine))
+    import time
+    subset = SUBSET.get(name)
+    select = sorted(set(subset.values())) if subset else None
+    t0 = time.monotonic()
+    base, out = run_tests(pristine, tests, timeout * 2, select)
+    timeout = max(15, int(5 * (time.monotonic() - t0)))  # mutants that loop forever are cut off early
+    if base is None:
+        print(f"{name}: baseline failed: {out[-300:]}", flush=True)
+        return []
+    passing = {k for k, v in base.items() if v == "passed"}
+    (out_dir / f"{name}.baseline.json").write_text(json.dumps(base, indent=0))
+    files = [pristine / pkg] if pkg.endswith(".py") else sorted((pristine / pkg).rglob("*.py"))
+    files = [f for f in files if "test" not in f.relative_to(pristine).as_posix().split("/")[-1]
+             and "/tests/" not in f.relative_to(pristine).as_posix()]
+    if subset:
+        files = [f for f in files if f.stem in subset and f.parent == pristine / pkg]
+    cands = []
+    for f in files:
+        src = f.read_text()
+        try:
+            for s in sites(src):
+                cands.append((f.relative_to(pristine).as_posix(), *s))
+        except (SyntaxError, tokenize.TokenError):
+            continue
+    rng = random.Random(f"catalog:{name}")
+    rng.shuffle(cands)
+    cands = cands[:per_lib * 3]
+    print(f"{name}: {len(passing)} passing tests, {len(cands)} candidate sites", flush=True)
+
+    def try_one(c):
+        rel, line, col, old, new, kind, func = c
+        work = Path(tempfile.mkdtemp())
+        try:
+            shutil.copytree(pristine, work / "lib")
+            path = work / "lib" / rel
+            mutated = apply(path.read_text(), line, col, old, new)
+            try:
+                ast.parse(mutated)
+            except SyntaxError:
+                return None
+            path.write_text(mutated)
+            res, _ = run_tests(work / "lib", tests, timeout, [subset[Path(rel).stem]] if subset else None)
+            if res is None:
+                return None
+            killed = sorted(k for k in passing if res.get(k) == "failed")
+            if not 1 <= len(killed) <= 8:
+                return None
+            fail = failure_text(work / "lib", killed[0], timeout)
+            return {"lib": name, "domain": domain, "file": rel, "line": line, "col": col, "old": old, "new": new,
+                    "kind": kind, "function": func, "killed": killed, "failure": fail,
+                    "tests_root": tests}
+        finally:
+            shutil.rmtree(work, ignore_errors=True)
+
+    kept = []
+    with ThreadPoolExecutor(workers) as pool:
+        for m in pool.map(try_one, cands):
+            if m and len(kept) < per_lib:
+                kept.append(m)
+    print(f"{name}: kept {len(kept)} mutants", flush=True)
+    return kept
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--per-lib", type=int, default=40)
+    ap.add_argument("--libs", default="")
+    ap.add_argument("--workers", type=int, default=4)
+    args = ap.parse_args()
+    out_dir = Path("/out")
+    out_dir.mkdir(exist_ok=True)
+    catalog_path = out_dir / "catalog.json"
+    catalog = json.loads(catalog_path.read_text()) if catalog_path.exists() else []
+    names = [n for n in LIBS if not args.libs or n in args.libs.split(",")]
+    catalog = [m for m in catalog if m["lib"] not in names]
+    for name in names:
+        catalog += build_lib(name, LIBS[name], args.per_lib, out_dir, args.workers)
+        catalog_path.write_text(json.dumps(catalog, indent=1))
+    shutil.rmtree(out_dir / "_extract", ignore_errors=True)
+    print("total mutants:", len(catalog))
+
+
+if __name__ == "__main__":
+    main()

source/codedesk/build/package.py

@@ -0,0 +1,54 @@
+"""Copy the built catalog and pristine library trees into codedesk/data for the image (file copies only).
+
+Usage (on the host, after catalog.py): python3 codedesk/build/package.py
+"""
+
+import ast
+import json
+import shutil
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+OUT, DATA = HERE / "out", HERE.parent / "data"
+# tests that never finish on their own; removed from the shipped copies
+STRIP = {"simple_pid": {"tests/test_pid.py": {"test_converge_system"}}}
+# simple-pid's tests depend on wall-clock timing and gave different results under load: not used
+DROP = {"simple_pid", "semver"}
+
+
+def strip_tests(path: Path, names: set[str]):
+    src = path.read_text()
+    spans = [(min([n.lineno] + [d.lineno for d in n.decorator_list]), n.end_lineno) for n in ast.walk(ast.parse(src))
+             if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef)) and n.name in names]
+    lines = src.splitlines(keepends=True)
+    for first, last in sorted(spans, reverse=True):
+        del lines[first - 1:last]
+    path.write_text("".join(lines))
+
+
+def main():
+    catalog = [m for m in json.loads((OUT / "catalog.json").read_text()) if m["lib"] not in DROP]
+    valid = OUT / "valid.json"
+    if valid.exists() and "--validated" in __import__("sys").argv:  # keep only mutants that passed validate.py
+        keys = {tuple(k) for k in json.loads(valid.read_text())["ok"]}
+        catalog = [m for m in catalog if (m["lib"], m["file"], m["line"], m["col"], m["new"]) in keys]
+    libs = sorted({m["lib"] for m in catalog})
+    shutil.rmtree(DATA, ignore_errors=True)
+    (DATA / "libs").mkdir(parents=True)
+    for lib in libs:
+        shutil.copytree(OUT / lib, DATA / "libs" / lib, ignore=shutil.ignore_patterns(
+            "__pycache__", "*.pyc", ".pytest_cache", ".hypothesis", "docs", ".github", "*.egg-info"))
+        for rel, names in STRIP.get(lib, {}).items():
+            strip_tests(DATA / "libs" / lib / rel, names)
+        shutil.copy(OUT / f"{lib}.baseline.json", DATA / f"{lib}.baseline.json")
+    stripped = {(lib, f"{rel}::{n}") for lib, files in STRIP.items() for rel, names in files.items() for n in names}
+    catalog = [m for m in catalog if not any((m["lib"], k.split("[")[0]) in stripped for k in m["killed"])]
+    (DATA / "catalog.json").write_text(json.dumps(catalog, indent=1))
+    by = {}
+    for m in catalog:
+        by[m["lib"]] = by.get(m["lib"], 0) + 1
+    print(len(catalog), "mutants", by)
+
+
+if __name__ == "__main__":
+    main()

source/codedesk/build/survey.sh

@@ -0,0 +1,13 @@
+set -u
+pip install -q python-dateutil pytz text-unidecode freezegun 2>/dev/null
+mkdir -p /tmp/src && cd /tmp/src
+for f in /out/*.tar.gz; do tar xzf "$f"; done
+for d in /tmp/src/*/; do
+  n=$(basename "$d")
+  t=$(find "$d" -path '*test*' -name '*.py' | wc -l)
+  src=$(find "$d" -name '*.py' -not -path '*test*' -not -path '*docs*' -not -name 'setup.py' -not -name 'conf.py' | xargs cat 2>/dev/null | wc -l)
+  start=$(date +%s.%N)
+  out=$(cd "$d" && PYTHONPATH="$d:$d/src" timeout 300 python -m pytest -q -x -p no:cacheprovider 2>&1 | tail -1)
+  end=$(date +%s.%N)
+  printf '%-28s testfiles=%-3s srclines=%-6s %6.1fs  %s\n' "$n" "$t" "$src" "$(echo "$end - $start" | bc 2>/dev/null || echo 0)" "$out"
+done

source/codedesk/build/validate.py

@@ -0,0 +1,55 @@
+"""Check every catalog mutant inside the image: the untouched workspace must fail and the original code must pass,
+at both levels. Writes the indices that pass to /out/valid.json.
+
+    docker run --rm -e PYTHONPATH=/app -v $PWD/codedesk/build/out:/out -v $PWD/codedesk/build/validate.py:/v.py:ro \
+        five-desks-code:native python /v.py
+"""
+
+import json
+import random
+import sys
+from concurrent.futures import ThreadPoolExecutor
+
+from codedesk.families.bugfix import LIBS, LibBugfix, catalog
+
+
+def check(i_m):
+    i, m = i_m
+    try:
+        for level in (1, 2):
+            t = LibBugfix(random.Random(i), level, LIBS[m["lib"]][1], mutant=m)
+            try:
+                if t.grade({}) != 0.0:
+                    return i, "untouched passes"
+                t.oracle()
+                if t.grade({}) != 1.0:
+                    return i, f"oracle fails (level {level})"
+            finally:
+                t.close()
+        return i, "ok"
+    except Exception as exc:  # generation problems count as failures
+        return i, f"error {type(exc).__name__}: {exc}"[:200]
+
+
+def main():
+    cat = catalog()
+    results = {}
+    with ThreadPoolExecutor(int(sys.argv[1]) if len(sys.argv) > 1 else 4) as pool:
+        for i, verdict in pool.map(check, list(enumerate(cat))):
+            results[i] = verdict
+    ok = [i for i, v in sorted(results.items()) if v == "ok"]
+    keys = [[cat[i]["lib"], cat[i]["file"], cat[i]["line"], cat[i]["col"], cat[i]["new"]] for i in ok]
+    bad = {}
+    for i, v in results.items():
+        if v != "ok":
+            bad.setdefault(cat[i]["lib"], []).append(v)
+    json.dump({"ok": keys, "failures": {k: v[:5] for k, v in bad.items()}}, open("/out/valid.json", "w"), indent=1)
+    by = {}
+    for i in ok:
+        by[cat[i]["lib"]] = by.get(cat[i]["lib"], 0) + 1
+    print(len(ok), "of", len(cat), "valid", by)
+    print({k: len(v) for k, v in bad.items()})
+
+
+if __name__ == "__main__":
+    main()

source/codedesk/environment.py

@@ -0,0 +1,101 @@
+"""The Five Desks Code OpenEnv environment: agentic coding on real libraries from every arena domain."""
+
+import random
+import secrets
+from typing import Any, Optional
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+from .families import FAMILIES
+from .interface import Interface
+from .models import ToolAction, ToolObservation
+
+MAX_OUTPUT_CHARS = 6000
+
+
+def task_ids() -> list[str]:
+    return [f"{fam}-{group}-l{level}" for fam, cls in FAMILIES.items() for group in cls.groups() for level in cls.levels]
+
+
+def build(task_id: str, seed: int):
+    fam, _, rest = task_id.partition("-")
+    group, _, level = rest.rpartition("-l")
+    cls = FAMILIES.get(fam)
+    if cls is None or group not in cls.groups() or level not in {str(lv) for lv in cls.levels}:
+        raise ValueError(f"unknown task_id {task_id!r}; known ids: {', '.join(task_ids())}")
+    return cls(random.Random(f"{task_id}:{seed}"), int(level), group)
+
+
+class CodeEnvironment(Environment):
+    SUPPORTS_CONCURRENT_SESSIONS = True
+
+    def __init__(self):
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._task = None
+        self._tools = {}
+        self._interface = None
+        self._steps_left = 0
+        self._done = True
+
+    def _close_task(self):
+        if self._task is not None:
+            self._task.close()
+
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, task_id: Optional[str] = None,
+              canonical_names: bool = False, **kwargs: Any) -> ToolObservation:
+        task_id = task_id or task_ids()[0]
+        seed = seed if seed is not None else secrets.randbits(48)
+        self._close_task()
+        self._task = build(task_id, seed)
+        tools = self._task.tools()
+        self._interface = None if canonical_names else Interface(tools, random.Random(f"names:{task_id}:{seed}"))
+        listed = self._interface.tools if self._interface else tools
+        self._tools = {t.name: t for t in listed}
+        self._state = State(episode_id=episode_id or str(uuid4()), step_count=0)
+        self._steps_left = self._task.max_steps
+        self._done = False
+        brief = self._interface.text(self._task.brief()) if self._interface else self._task.brief()
+        lines = [f"- {t.name} {t.signature()}: {t.help}" for t in listed]
+        text = (f"{brief}\n\nReply with exactly one JSON object per turn: {{\"tool\": \"<name>\", \"args\": {{...}}}}. "
+                "Tools:\n" + "\n".join(lines) + f"\nYou have {self._task.max_steps} tool calls.")
+        return ToolObservation(output=text, steps_left=self._steps_left, done=False, reward=0.0)
+
+    def _end(self, output: str, reward: float) -> ToolObservation:
+        self._done = True
+        self._close_task()
+        return ToolObservation(output=output, steps_left=self._steps_left, done=True,
+                               reward=round(min(1.0, max(0.0, reward)), 4))
+
+    def step(self, action: ToolAction, timeout_s: Optional[float] = None, **kwargs: Any) -> ToolObservation:  # type: ignore[override]
+        if self._task is None or self._done:
+            return ToolObservation(output="Episode is over. Call reset.", steps_left=0, done=True, reward=0.0)
+        self._state.step_count += 1
+        self._steps_left -= 1
+        name = action.tool.strip()
+        tool = self._tools.get(name)
+        if tool is not None and tool.final:  # submit (also the arena's finish action) grades the work so far
+            return self._end("Submitted.", float(tool.fn(dict(action.args))))
+        if tool is None and name == "submit":
+            return self._end("Submitted.", float(self._task.grade({})))
+        if tool is None:
+            output = f"Unknown tool {name!r}. Tools: {', '.join(self._tools)}."
+        elif (error := tool.check(action.args)) is not None:
+            output = error
+        else:
+            try:
+                output = tool.fn(action.args)
+            except Exception as exc:  # a tool bug must not kill the episode
+                output = f"Tool error: {type(exc).__name__}: {exc}"
+            if self._interface:
+                output = self._interface.text(output)
+            if len(output) > MAX_OUTPUT_CHARS:
+                output = output[:MAX_OUTPUT_CHARS] + "\n... [output truncated]"
+        if self._steps_left <= 0:
+            return self._end(output + "\nNo tool calls left; the work so far was submitted.", float(self._task.grade({})))
+        return ToolObservation(output=output, steps_left=self._steps_left, done=False, reward=0.0)
+
+    @property
+    def state(self) -> State:
+        return self._state

source/codedesk/families/__init__.py

@@ -0,0 +1,6 @@
+from .bugfix import LibBugfix, groups
+from .mediatools import MediaTools
+
+LibBugfix.groups = staticmethod(groups)
+
+FAMILIES = {cls.family: cls for cls in [LibBugfix, MediaTools]}

source/codedesk/families/bugfix.py

@@ -0,0 +1,221 @@
+"""Fix a real bug in a real library.
+
+Each instance takes one pinned open-source Python library and one mutant from the build-time catalog: a single
+token changed inside a function (a comparison, an operator, a constant, and/or, a `not`) that 1 to 8 of the
+library's own tests catch. Level 1 is a failing CI run: the test suite is in the repository and the issue shows
+the failing test's output. Level 2 is a user report: the issue shows only the failing check, and the tests that
+cover it are removed from the repository, so the policy has to find the code and verify its fix itself.
+
+Grading copies only the library's own source files from the workspace into a clean copy of the original project
+and runs the original test files that cover the bug: every catching test must pass and no other test in those
+files may fail that passes on the original. Edits to tests, configuration or anything else are ignored.
+"""
+
+import ast
+import json
+import re
+import shutil
+import tempfile
+import xml.etree.ElementTree as ET
+from functools import lru_cache
+from pathlib import Path
+
+from .. import runner
+from ..base import CodingTask, Tool
+
+DATA = Path(__file__).resolve().parents[1] / "data"
+# library -> (package path in the source tree, task group)
+LIBS = {
+    "croniter": ("src/croniter", "office"), "isodate": ("src/isodate", "office"), "humanize": ("src/humanize", "office"),
+    "numpy_financial": ("numpy_financial", "finance"), "uncertainties": ("uncertainties", "science"),
+    "fluids": ("fluids", "industrial"), "srt": ("srt.py", "media"), "webvtt": ("webvtt", "media"),
+    "slugify": ("slugify", "media"), "itsdangerous": ("src/itsdangerous", "security"), "jwt": ("jwt", "security"),
+    "toolz": ("toolz", "software"), "tabulate": ("tabulate", "software"), "inflection": ("inflection", "software"),
+    "semver": ("src/semver", "software"), "more_itertools": ("more_itertools", "math"),
+}
+DOMAINS = {"office": "office-white-collar", "finance": "finance-economics", "science": "natural-science",
+           "industrial": "industrial-physical-systems", "media": "media-content-production",
+           "security": "cybersecurity", "software": "software-engineering", "math": "mathematics-or-formal-reasoning"}
+SKIP = {".egg-info", "docs", ".github", "PKG-INFO", "__pycache__", "benchmarks", "examples"}
+
+
+@lru_cache(maxsize=1)
+def catalog() -> list[dict]:
+    path = DATA / "catalog.json"
+    return json.loads(path.read_text()) if path.exists() else []
+
+
+def pytest_outcomes(root: Path, files: list[str]) -> dict | None:
+    """Run the given test files under root as nobody; {test key: passed/failed/skipped}, or None if pytest crashed."""
+    xml = root / ".grade.xml"
+    runner.run("python -m pytest -q -p no:cacheprovider -p no:randomly --tb=no --hypothesis-seed=0 "
+               f"--junitxml={xml} -o junit_family=xunit1 " + " ".join(files), root, timeout=240)
+    if not xml.exists():
+        return None
+    outcomes = {}
+    for case in ET.parse(xml).getroot().iter("testcase"):
+        key = f"{case.get('file') or case.get('classname')}::{case.get('name')}"
+        kids = {c.tag for c in case}
+        outcomes[key] = "failed" if kids & {"failure", "error"} else "skipped" if "skipped" in kids else "passed"
+    return outcomes
+
+
+def owned_tmp(prefix: str) -> tempfile.TemporaryDirectory:
+    tmp = tempfile.TemporaryDirectory(prefix=prefix)
+    if runner.AS_ROOT:
+        import os
+        os.chown(tmp.name, runner.NOBODY, runner.NOBODY)
+    return tmp
+
+
+@lru_cache(maxsize=None)
+def pristine_outcomes(lib: str, files: tuple[str, ...]) -> dict:
+    """Outcomes of the same test files on the original library, in this image (tests can depend on run order)."""
+    with owned_tmp("pristine-") as tmp:
+        root = Path(tmp) / "repo"
+        copy_tree(DATA / "libs" / lib, root)
+        runner.give_to_nobody(Path(tmp))
+        return pytest_outcomes(root, list(files)) or {}
+
+
+def groups() -> list[str]:
+    present = {LIBS[m["lib"]][1] for m in catalog() if m["lib"] in LIBS}
+    return [g for g in DOMAINS if g in present]
+
+
+def copy_tree(src: Path, dst: Path):
+    def ignore(_, names):
+        return [n for n in names if n in SKIP or n.endswith(".egg-info") or n.startswith(".")]
+    shutil.copytree(src, dst, ignore=ignore, dirs_exist_ok=True)
+
+
+def mutate(text: str, m: dict) -> str:
+    lines = text.splitlines(keepends=True)
+    line = lines[m["line"] - 1]
+    assert line[m["col"]:m["col"] + len(m["old"])] == m["old"], m
+    lines[m["line"] - 1] = line[:m["col"]] + m["new"] + line[m["col"] + len(m["old"]):]
+    return "".join(lines)
+
+
+def test_file(key: str) -> str:
+    return key.split("::")[0]
+
+
+def test_name(key: str) -> str:
+    return key.split("::")[-1].split("[")[0]
+
+
+def remove_tests(path: Path, names: set[str]):
+    """Delete the named test functions (with their decorators) from a test file, keeping everything else."""
+    src = path.read_text()
+    tree = ast.parse(src)
+    spans = []
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name in names:
+            first = min([node.lineno] + [d.lineno for d in node.decorator_list])
+            spans.append((first, node.end_lineno))
+    lines = src.splitlines(keepends=True)
+    for first, last in sorted(spans, reverse=True):
+        del lines[first - 1:last]
+    path.write_text("".join(lines))
+
+
+def symptom(failure: str) -> str:
+    """The failing check from pytest's short traceback, without the test's name or location."""
+    keep, grab = [], False
+    for line in failure.splitlines():
+        if re.match(r"^\S+\.py:\d+: in ", line):
+            grab = True
+            continue
+        if grab and line.startswith("    ") and not line.startswith("    E"):
+            keep.append(line.strip())
+        elif line.startswith("E "):
+            keep.append(line[1:].strip())
+            if sum(1 for k in keep if k.startswith(("AssertionError", "assert", "+", "-", "Error", "Value", "Type", "Key",
+                                                      "Index", "Attribute"))) > 4:
+                break
+        elif line.startswith(("=", "_")) and keep:
+            break
+    return "\n".join(keep[-8:])
+
+
+class LibBugfix(CodingTask):
+    family = "bugfix"
+    levels = (1, 2)
+    max_steps = 30
+
+    def setup(self):
+        pool = [m for m in catalog() if LIBS.get(m["lib"], (None, None))[1] == self.group]
+        if self.level == 2:  # needs a readable check for the report
+            pool = [m for m in pool if symptom(m["failure"]).count("\n") >= 1] or pool
+        assert pool, f"no mutants for {self.group}"
+        self.m = m = self.opts.get("mutant") or self.rng.choice(pool)  # tests and validation can pick one
+        self.domain = DOMAINS[self.group]
+        self.lib_root = DATA / "libs" / m["lib"]
+        self.pkg = LIBS[m["lib"]][0]
+        copy_tree(self.lib_root, self.ws)
+        target = self.ws / m["file"]
+        self.original = target.read_text()
+        target.write_text(mutate(self.original, m))
+        self.killed = m["killed"]
+        if self.level == 2:
+            by_file = {}
+            for key in self.killed:
+                by_file.setdefault(test_file(key), set()).add(test_name(key))
+            for rel, names in by_file.items():
+                if (self.ws / rel).exists():
+                    remove_tests(self.ws / rel, names)
+        failing = self.killed[0]
+        if self.level == 1:
+            report = (f"# CI failure\n\nThe test suite fails on main. One failing test:\n\n    pytest '{failing}'\n\n"
+                      f"```\n{m['failure'].strip()[-2500:]}\n```\n\nFix the library (not the tests).\n")
+        else:
+            report = ("# Bug report\n\nA user reports that this check fails on the current version:\n\n"
+                      f"```\n{symptom(m['failure'])}\n```\n\nThe expected behaviour is the one the check asserts. Fix "
+                      "the library; the test suite has no test for this yet.\n")
+        (self.ws / "ISSUE.md").write_text(report)
+
+    def brief(self):
+        name = self.m["lib"].replace("_", "-")
+        how = ("Run the failing test, find the cause in the library code, fix it" if self.level == 1 else
+               "Reproduce the problem, find the cause in the library code, fix it")
+        return (f"SOFTWARE ({self.group}). This repository is the open-source Python library {name}. Read ISSUE.md. "
+                f"{how}, check that nothing else breaks, then submit. Only changes to the library's own source "
+                f"({self.pkg}) count.")
+
+    def tools(self):
+        return self.coding_tools(tests=True) + [Tool("submit", "submit your fix (ends the episode)", self.grade,
+                                                     final=True)]
+
+    def grade(self, a=None) -> float:
+        with owned_tmp("grade-") as tmp:
+            root = Path(tmp) / "repo"
+            copy_tree(self.lib_root, root)
+            src, dst = self.ws / self.pkg, root / self.pkg
+            # never follow links out of the workspace (the grader runs as root)
+            if src.is_symlink() or (src.is_dir() and any(p.is_symlink() for p in src.rglob("*"))):
+                return 0.0
+            if src.is_file():
+                shutil.copyfile(src, dst)
+            elif src.is_dir():
+                shutil.rmtree(dst)
+                shutil.copytree(src, dst, ignore=shutil.ignore_patterns("__pycache__", "*.pyc", "conftest.py"))
+            else:
+                return 0.0
+            # some libraries keep their tests inside the package: always grade with the original tests
+            tests = self.lib_root / self.m["tests_root"]
+            if tests.is_dir():
+                shutil.rmtree(root / self.m["tests_root"], ignore_errors=True)
+                copy_tree(tests, root / self.m["tests_root"])
+            elif tests.is_file():
+                shutil.copyfile(tests, root / self.m["tests_root"])
+            runner.give_to_nobody(Path(tmp))
+            files = sorted({test_file(k) for k in self.killed})
+            outcomes = pytest_outcomes(root, files)
+            if outcomes is None or any(outcomes.get(k) != "passed" for k in self.killed):
+                return 0.0
+            base = pristine_outcomes(self.m["lib"], tuple(files))
+            return float(not [k for k, v in outcomes.items() if v == "failed" and base.get(k) == "passed"])
+
+    def oracle(self):
+        (self.ws / self.m["file"]).write_text(self.original)

source/codedesk/families/mediatools.py

@@ -0,0 +1,345 @@
+"""Media production with real tools: ffmpeg, ImageMagick and Pillow.
+
+Each instance generates its own input media and a client spec (spec.md) plus production notes (notes.md) that add
+one requirement the spec does not mention. The policy uses the shell to produce the deliverable. Grading measures
+the output files (stream properties with ffprobe; picture content against references computed from a private copy
+of the inputs) and never trusts anything the policy wrote except the deliverables themselves.
+
+Variants: a trimmed and scaled video clip, square thumbnails from photos (some rotated by EXIF), a contact sheet
+ordered by capture time, and a loudness-normalised audio delivery.
+"""
+
+import json
+import math
+import shutil
+import tempfile
+from pathlib import Path
+
+from .. import runner
+from ..base import CodingTask, Tool
+
+ANALYZE = r'''
+import json, subprocess, sys
+from PIL import Image, ImageOps
+kind, path = sys.argv[1], sys.argv[2]
+def tiny(img, size):
+    return list(ImageOps.fit(img.convert("L"), size).getdata())
+if kind == "image":
+    try:
+        img = Image.open(path); img.load()
+        print(json.dumps({"size": img.size, "format": img.format, "tiny": tiny(img, (8, 8))}))
+    except Exception as e:
+        print(json.dumps({"error": str(e)[:200]}))
+elif kind == "tiles":
+    cols, rows, tw, th = map(int, sys.argv[3:7])
+    img = Image.open(path).convert("L")
+    out = []
+    for r in range(rows):
+        for c in range(cols):
+            box = img.crop((c * tw + tw // 4, r * th + th // 4, c * tw + 3 * tw // 4, r * th + 3 * th // 4))
+            px = list(box.getdata()); out.append(sum(px) / len(px))
+    print(json.dumps({"size": img.size, "tiles": out}))
+'''
+
+
+def ffprobe(path: Path, cwd: Path) -> dict:
+    code, out = runner.run(f"ffprobe -v error -show_streams -show_format -of json '{path}'", cwd, timeout=30)
+    try:
+        return json.loads(out)
+    except json.JSONDecodeError:
+        return {}
+
+
+def frame_tiny(path: Path, t: float, cwd: Path) -> list[int] | None:
+    """A 16x9 grayscale thumbnail of the frame at time t (seconds)."""
+    code, out = runner.run(f"ffmpeg -v error -ss {t:.3f} -i '{path}' -frames:v 1 -vf scale=16:9,format=gray "
+                           "-f rawvideo - | od -An -v -tu1", cwd, timeout=30)
+    vals = [int(v) for v in out.split() if v.isdigit()]
+    return vals if len(vals) == 144 else None
+
+
+def mad(a, b) -> float:
+    return sum(abs(x - y) for x, y in zip(a, b)) / max(1, len(a))
+
+
+class MediaTools(CodingTask):
+    family = "media"
+    levels = (1, 2)
+    max_steps = 24
+
+    @staticmethod
+    def groups():
+        return ["production"]
+
+    def setup(self):
+        self.domain = "media-content-production"
+        self.private = Path(tempfile.mkdtemp(prefix="media-ref-"))  # root-only copy of the inputs
+        self.variant = self.rng.randrange(4)
+        for attempt in range(20):  # generators assert their own invariants; redraw until they hold
+            try:
+                getattr(self, f"_v{self.variant}")()
+                break
+            except AssertionError:
+                for d in (self.ws, self.private):
+                    for p in d.iterdir():
+                        shutil.rmtree(p) if p.is_dir() else p.unlink()
+        else:
+            raise RuntimeError("could not generate a media task")
+        (self.ws / "spec.md").write_text(self.spec)
+        (self.ws / "notes.md").write_text("# Production notes\n\n" + "\n".join(f"- {n}" for n in self.notes) + "\n")
+
+    def close(self):
+        super().close()
+        if getattr(self, "private", None):
+            shutil.rmtree(self.private, ignore_errors=True)
+
+    def _sh(self, cmd: str, cwd: Path, timeout: int = 60):
+        code, out = runner.run(cmd, cwd, timeout=timeout)
+        assert code == 0, out[-500:]
+
+    # -- variant 0: trimmed, scaled clip ---------------------------------------------------------------
+    def _v0(self):
+        r = self.rng
+        dur = r.choice([12, 14, 16])
+        self.a = r.randint(2, dur - 7)
+        self.b = self.a + r.randint(3, 5)
+        self.w = r.choice([320, 426, 480])
+        self.fps = r.choice([12, 15, 24])
+        self.mono = r.random() < 0.5
+        self._sh(f"ffmpeg -v error -f lavfi -i testsrc2=size=640x360:rate=30:duration={dur} -f lavfi "
+                 f"-i sine=frequency={r.choice([330, 440, 550])}:duration={dur} -ac 2 -c:v libx264 -preset ultrafast "
+                 "-pix_fmt yuv420p -c:a aac -shortest input.mp4", self.ws, 120)
+        shutil.copy(self.ws / "input.mp4", self.private / "input.mp4")
+        self.ref = [frame_tiny(self.ws / "input.mp4", t + 0.05, self.ws) for t in (self.a, self.a - 1, self.a + 1)]
+        assert all(self.ref)
+        self.out = "deliver/clip.mp4"
+        self.spec = (f"# Clip delivery\n\nFrom input.mp4, deliver the segment from {self.a} s to {self.b} s as "
+                     f"{self.out}: H.264 video, {self.w} pixels wide with the aspect ratio kept (even height), "
+                     f"{self.fps} frames per second.\n")
+        self.notes = ["The client's player needs the audio track kept, downmixed to mono (one channel)."
+                      if self.mono else "The client will add their own music: deliver the clip with no audio track."]
+
+    def _g0(self, path: Path) -> bool:
+        info = ffprobe(path, self.ws)
+        streams = info.get("streams", [])
+        video = [s for s in streams if s.get("codec_type") == "video"]
+        audio = [s for s in streams if s.get("codec_type") == "audio"]
+        if len(video) != 1 or video[0].get("codec_name") != "h264":
+            return False
+        v = video[0]
+        h = round(self.w * 360 / 640 / 2) * 2
+        if v.get("width") != self.w or abs(int(v.get("height", 0)) - h) > 2:
+            return False
+        num, _, den = str(v.get("avg_frame_rate", "0/1")).partition("/")
+        try:
+            fps = float(num) / float(den or 1)
+        except (ValueError, ZeroDivisionError):
+            return False
+        if abs(fps - self.fps) > 0.5:
+            return False
+        try:
+            duration = float(info.get("format", {}).get("duration", 0))
+        except ValueError:
+            return False
+        if abs(duration - (self.b - self.a)) > 0.25:
+            return False
+        if self.mono != (len(audio) == 1 and audio[0].get("channels") == 1) or (not self.mono and audio):
+            return False
+        first = frame_tiny(path, 0.05, self.ws)
+        if first is None:
+            return False
+        right, before, after = (mad(first, ref) for ref in self.ref)
+        return right < 12 and right < before and right < after
+
+    # -- variant 1: thumbnails -------------------------------------------------------------------------
+    def _photos(self, n):
+        from PIL import Image, ImageDraw
+        r = self.rng
+        self.photos = []
+        (self.ws / "photos").mkdir()
+        for i in range(n):
+            w, h = r.choice([(640, 480), (800, 600), (480, 640), (1024, 768), (240, 180), (200, 260)])
+            img = Image.new("RGB", (w, h), tuple(r.randint(30, 220) for _ in range(3)))
+            d = ImageDraw.Draw(img)
+            d.rectangle([0, 0, w // 3, h // 3], fill=(250, 250, 250))  # a bright corner shows orientation
+            d.ellipse([w // 3, h // 3, 2 * w // 3, 2 * h // 3], fill=tuple(r.randint(0, 255) for _ in range(3)))
+            orient = r.choice([1, 1, 3, 6, 8])
+            exif = Image.Exif()
+            exif[0x0112] = orient
+            exif[0x9003] = f"2026:0{r.randint(1, 9)}:{r.randint(10, 28)} {r.randint(10, 19)}:{r.randint(10, 59)}:00"
+            stem = f"IMG_{r.randint(1000, 9999)}"
+            while any(p[0] == stem for p in self.photos):
+                stem = f"IMG_{r.randint(1000, 9999)}"
+            img.save(self.private / f"{stem}.jpg", quality=92, exif=exif)
+            shutil.copy(self.private / f"{stem}.jpg", self.ws / "photos" / f"{stem}.jpg")
+            self.photos.append((stem, img.size, orient, exif[0x9003]))
+
+    def _v1(self):
+        from PIL import Image, ImageOps
+        r = self.rng
+        self._photos(r.randint(5, 8))
+        self.size = r.choice([128, 160, 200])
+        self.min_side = 300
+        self.expected = {}
+        for stem, (w, h), _, _ in self.photos:
+            if min(w, h) < self.min_side:
+                continue
+            img = ImageOps.exif_transpose(Image.open(self.private / f"{stem}.jpg"))
+            thumb = ImageOps.fit(img, (self.size, self.size))
+            self.expected[stem] = list(ImageOps.fit(thumb.convert("L"), (8, 8)).getdata())
+        assert 2 <= len(self.expected) < len(self.photos)
+        self.spec = (f"# Thumbnails\n\nFor every photo in photos/, make a square {self.size}x{self.size} thumbnail: "
+                     "the photo shown upright (as a phone would display it), scaled to cover the square and "
+                     "centre-cropped. Save each as PNG in thumbs/ with the photo's name, e.g. thumbs/IMG_1234.png.\n")
+        self.notes = [f"Skip photos smaller than {self.min_side} pixels on their short side; no thumbnails for "
+                      "those (they are placeholders)."]
+
+    def _g1(self) -> bool:
+        thumbs = self.ws / "thumbs"
+        if not thumbs.is_dir():
+            return False
+        got = {p.stem: p for p in thumbs.iterdir() if p.suffix.lower() == ".png"}
+        if set(got) != set(self.expected):
+            return False
+        for stem, ref in self.expected.items():
+            stats = self._analyze("image", got[stem])
+            if stats.get("format") != "PNG" or tuple(stats.get("size", ())) != (self.size, self.size):
+                return False
+            if mad(stats["tiny"], ref) > 14:
+                return False
+        return True
+
+    # -- variant 2: contact sheet ----------------------------------------------------------------------
+    def _v2(self):
+        from PIL import Image, ImageOps
+        r = self.rng
+        self._photos(6)
+        assert len({p[3] for p in self.photos}) == 6 and sorted(self.photos, key=lambda p: p[3]) != sorted(self.photos)
+        self.cols, self.rows = (3, 2) if r.random() < 0.5 else (2, 3)
+        self.tw, self.th = r.choice([(160, 120), (200, 150)])
+        order = sorted(self.photos, key=lambda p: p[3])
+        self.expected = []
+        for stem, *_ in order:
+            img = ImageOps.exif_transpose(Image.open(self.private / f"{stem}.jpg"))
+            tile = ImageOps.fit(img, (self.tw, self.th)).convert("L")
+            box = tile.crop((self.tw // 4, self.th // 4, 3 * self.tw // 4, 3 * self.th // 4))
+            px = list(box.getdata())
+            self.expected.append(sum(px) / len(px))
+        self.out = "sheet.png"
+        self.spec = (f"# Contact sheet\n\nMake a contact sheet of the six photos in photos/ as {self.out}: a grid "
+                     f"{self.cols} tiles wide and {self.rows} tall, each tile exactly {self.tw}x{self.th} pixels "
+                     "(photo upright, scaled to cover and centre-cropped), no borders or gaps, filled left to right "
+                     "then top to bottom.\n")
+        self.notes = ["Order the photos by when they were taken (EXIF DateTimeOriginal), earliest first, not by "
+                      "file name."]
+
+    def _g2(self) -> bool:
+        path = self.ws / self.out
+        if not path.is_file():
+            return False
+        stats = self._analyze("tiles", path, self.cols, self.rows, self.tw, self.th)
+        if tuple(stats.get("size", ())) != (self.cols * self.tw, self.rows * self.th):
+            return False
+        return all(abs(a - b) <= 12 for a, b in zip(stats["tiles"], self.expected))
+
+    # -- variant 3: audio delivery ---------------------------------------------------------------------
+    def _v3(self):
+        r = self.rng
+        self.lead = r.choice([1.0, 1.5, 2.0])
+        self.rate = r.choice([16000, 22050, 24000])
+        self.peak = r.choice([-1.0, -2.0, -3.0])
+        self.trim = r.random() < 0.5
+        self._sh(f"ffmpeg -v error -f lavfi -i anullsrc=r=44100:cl=stereo:d={self.lead} -f lavfi "
+                 f"-i sine=frequency={r.choice([300, 500, 700])}:duration=4:sample_rate=44100 "
+                 "-filter_complex '[1]volume=-14dB,aformat=channel_layouts=stereo[t];[0][t]concat=n=2:v=0:a=1' "
+                 "-c:a pcm_s16le take.wav", self.ws, 60)
+        shutil.copy(self.ws / "take.wav", self.private / "take.wav")
+        self.out = "deliver/voice.flac"
+        self.spec = (f"# Audio delivery\n\nDeliver take.wav as {self.out}: FLAC, mono, {self.rate} Hz, normalised so "
+                     f"the peak sample is at {self.peak:g} dBFS (within 0.5 dB).\n")
+        self.notes = ["Cut the silence at the start: the delivery must begin within 0.1 s of the first sound."
+                      if self.trim else "Keep the timing exactly as recorded, including the silence at the start."]
+
+    def _g3(self) -> bool:
+        path = self.ws / self.out
+        info = ffprobe(path, self.ws)
+        audio = [s for s in info.get("streams", []) if s.get("codec_type") == "audio"]
+        if len(audio) != 1 or audio[0].get("codec_name") != "flac" or audio[0].get("channels") != 1:
+            return False
+        if int(audio[0].get("sample_rate", 0)) != self.rate:
+            return False
+        code, out = runner.run(f"ffmpeg -v error -i '{path}' -f s16le -ac 1 - | od -An -v -td2", self.ws, timeout=30)
+        samples = [int(v) for v in out.split() if v.lstrip("-").isdigit()]
+        if not samples:
+            return False
+        peak = max(abs(s) for s in samples)
+        if peak == 0 or abs(20 * math.log10(peak / 32768) - self.peak) > 0.5:
+            return False
+        first = next(i for i, s in enumerate(samples) if abs(s) > peak * 0.05) / self.rate
+        return first <= 0.1 if self.trim else abs(first - self.lead) <= 0.1
+
+    # -- shared ----------------------------------------------------------------------------------------
+    def _analyze(self, *args) -> dict:
+        script = self.private / "analyze.py"
+        script.write_text(ANALYZE)
+        # copy the script where nobody can read it but the policy cannot have changed it
+        tmp = runner.new_workspace("an-")
+        try:
+            shutil.copy(script, tmp / "analyze.py")
+            target = Path(args[1])
+            shutil.copy(target, tmp / ("in" + target.suffix))
+            runner.give_to_nobody(tmp)
+            extra = " ".join(str(a) for a in args[2:])
+            code, out = runner.run(f"python -I analyze.py {args[0]} in{target.suffix} {extra}", tmp, timeout=30)
+        finally:
+            runner.remove(tmp)
+        try:
+            return json.loads(out.strip().splitlines()[-1])
+        except (json.JSONDecodeError, IndexError):
+            return {}
+
+    def brief(self):
+        pointer = " Read spec.md and notes.md first." if self.level == 1 else " The brief is in spec.md."
+        return ("MEDIA. Production desk. Produce the deliverable described in this workspace with the tools on this "
+                f"machine (ffmpeg, ffprobe, ImageMagick's magick/convert, Python with Pillow).{pointer} Submit when "
+                "the files are in place.")
+
+    def tools(self):
+        return self.coding_tools(tests=False) + [Tool("submit", "submit the deliverable (ends the episode)",
+                                                      self.grade, final=True)]
+
+    def grade(self, a=None) -> float:
+        try:
+            if self.variant == 0:
+                return float(self._g0(self.ws / self.out))
+            return float(getattr(self, f"_g{self.variant}")())
+        except Exception:
+            return 0.0
+
+    def oracle(self):
+        """Produce a correct deliverable with the tools (used by tests)."""
+        if self.variant == 0:
+            audio = "-ac 1 -c:a aac" if self.mono else "-an"
+            cmd = (f"mkdir -p deliver && ffmpeg -v error -y -ss {self.a} -i input.mp4 -t {self.b - self.a} "
+                   f"-vf scale={self.w}:-2,fps={self.fps} -c:v libx264 -preset ultrafast {audio} {self.out}")
+        elif self.variant == 1:
+            keep = " ".join(f"'{s}'" for s in self.expected)
+            cmd = ("mkdir -p thumbs && python -c \"import sys\nfrom PIL import Image, ImageOps\nfor s in sys.argv[1:]:\n"
+                   f"    ImageOps.fit(ImageOps.exif_transpose(Image.open(f'photos/{{s}}.jpg')), ({self.size},{self.size}))"
+                   f".save(f'thumbs/{{s}}.png')\" {keep}")
+        elif self.variant == 2:
+            order = " ".join(p[0] for p in sorted(self.photos, key=lambda p: p[3]))
+            cmd = ("python -c \"import sys\nfrom PIL import Image, ImageOps\n"
+                   f"sheet = Image.new('RGB', ({self.cols * self.tw}, {self.rows * self.th}))\n"
+                   "for i, s in enumerate(sys.argv[1:]):\n"
+                   f"    t = ImageOps.fit(ImageOps.exif_transpose(Image.open(f'photos/{{s}}.jpg')), ({self.tw},{self.th}))\n"
+                   f"    sheet.paste(t, ((i % {self.cols}) * {self.tw}, (i // {self.cols}) * {self.th}))\n"
+                   f"sheet.save('{self.out}')\" {order}")
+        else:
+            trim = "silenceremove=start_periods=1:start_threshold=-50dB," if self.trim else ""
+            cmd = (f"mkdir -p deliver && ffmpeg -v error -y -i take.wav -af {trim}aresample={self.rate} -ac 1 tmp.wav "
+                   f"&& G=$(ffmpeg -i tmp.wav -af volumedetect -f null - 2>&1 | sed -n 's/.*max_volume: \\(.*\\) dB/\\1/p') "
+                   f"&& ffmpeg -v error -y -i tmp.wav -af volume=$(python -c \"print({self.peak} - ($G))\")dB "
+                   f"-ar {self.rate} -ac 1 {self.out} && rm tmp.wav")
+        code, out = runner.run(cmd, self.ws, timeout=120)
+        assert code == 0, out[-800:]

source/codedesk/interface.py

@@ -0,0 +1,72 @@
+"""Per-episode tool and argument names.
+
+Every private arena task brings its own interface. If one task always calls its tools read_file and run_tests, a
+policy can memorise the names instead of reading the tool list. Each reset therefore draws names from these pools
+(the canonical name is one of the options). `submit` keeps its name and arguments: it is also the arena's finish
+action.
+"""
+
+import random
+import re
+
+from .base import Tool
+
+TOOL_NAMES = {
+    "list_files": ["list_files", "ls", "tree", "list_dir"],
+    "read_file": ["read_file", "open_file", "cat", "view_file", "show_file"],
+    "search": ["search", "grep", "find_text", "search_code"],
+    "edit_file": ["edit_file", "str_replace", "replace_in_file", "patch_file"],
+    "write_file": ["write_file", "save_file", "create_file", "put_file"],
+    "run": ["run", "bash", "shell", "exec", "run_command"],
+    "run_tests": ["run_tests", "pytest", "test", "check_tests"],
+}
+ARG_NAMES = {
+    "path": ["path", "file", "filename"],
+    "start": ["start", "from_line", "first"],
+    "end": ["end", "to_line", "last"],
+    "pattern": ["pattern", "regex", "query"],
+    "old": ["old", "old_str", "find", "before"],
+    "new": ["new", "new_str", "replace", "after"],
+    "content": ["content", "text", "body"],
+    "command": ["command", "cmd", "script"],
+    "target": ["target", "path", "tests"],
+}
+# Names that are also ordinary words ("the style guide", "check how...") are renamed in the tool list but not in
+# running text; the others are replaced wherever they appear as a word.
+TEXT_SAFE = {name for name in TOOL_NAMES if "_" in name}
+
+
+class Interface:
+    def __init__(self, tools: list[Tool], rng: random.Random):
+        self.tool_names, used = {}, {"submit"}
+        for tool in tools:
+            options = [n for n in TOOL_NAMES.get(tool.name, [tool.name]) if n not in used] or [tool.name]
+            name = tool.name if tool.name == "submit" else rng.choice(options)
+            used.add(name)
+            self.tool_names[tool.name] = name
+        pairs = [(old, new) for old, new in self.tool_names.items() if old in TEXT_SAFE and old != new]
+        self._pattern = re.compile(r"\b(" + "|".join(re.escape(old) for old, _ in pairs) + r")\b") if pairs else None
+        self._lookup = dict(pairs)
+        self.tools = [self._rename(tool, rng) for tool in tools]
+
+    def _rename(self, tool: Tool, rng: random.Random) -> Tool:
+        if tool.name == "submit":
+            return tool
+        args, used = {}, set()
+        for arg in tool.args:
+            options = [n for n in ARG_NAMES.get(arg, [arg]) if n not in used] or [arg]
+            args[arg] = rng.choice(options)
+            used.add(args[arg])
+        back = {new: old for old, new in args.items()}
+
+        def fn(a, _fn=tool.fn):
+            return _fn({back.get(k, k): v for k, v in a.items()})
+
+        return Tool(self.tool_names[tool.name], self.text(tool.help), fn,
+                    {args[k]: t for k, t in tool.args.items()}, tuple(args[k] for k in tool.optional), tool.final)
+
+    def text(self, s: str) -> str:
+        """Rewrite canonical tool names in briefs and tool output to this episode's names."""
+        if not self._pattern or not isinstance(s, str):
+            return s
+        return self._pattern.sub(lambda m: self._lookup[m.group(1)], s)

source/codedesk/models.py

@@ -0,0 +1,19 @@
+"""Action and observation models. One generic action serves every task: each task lists its own tools."""
+
+from typing import Any
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+
+
+class ToolAction(Action):
+    tool: str = Field(min_length=1, max_length=40, description="Name of one of the tools listed in the task.")
+    args: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Arguments for that tool, exactly as the task lists them (an empty object if it takes none).",
+    )
+
+
+class ToolObservation(Observation):
+    output: str = Field(default="", description="Result of the last tool call.")
+    steps_left: int = Field(default=0, description="Tool calls left before the episode ends.")

source/codedesk/requirements-tools.txt

@@ -0,0 +1,5 @@
+# on top of requirements.lock (which already pins numpy, pillow, python-dateutil and pytz)
+pytest==8.3.3
+hypothesis==6.112.1
+text-unidecode==1.3
+freezegun==1.5.1

source/codedesk/runner.py

@@ -0,0 +1,88 @@
+"""Per-episode workspaces and command execution for the coding tasks.
+
+The server runs as root inside its container; every command the policy runs, and every test run, executes as the
+unprivileged `nobody` user in the episode's workspace, with CPU, memory, file-size and process limits applied by a
+shell prelude (no preexec_fn, which can deadlock in threaded servers). The server's code and the bug catalog are
+root-only, so the policy cannot read hidden tests or the original sources. Outside a root container (local
+development) commands run as the current user.
+"""
+
+import os
+import shutil
+import signal
+import subprocess
+import tempfile
+import threading
+from pathlib import Path
+
+NOBODY = 65534
+LIMITS = "ulimit -t 120 -v 4000000 -f 100000 -u 512 2>/dev/null; "
+MAX_OUTPUT = 4000
+_SLOTS = threading.BoundedSemaphore(4)
+AS_ROOT = hasattr(os, "geteuid") and os.geteuid() == 0
+
+
+def new_workspace(prefix: str = "ws-") -> Path:
+    path = Path(tempfile.mkdtemp(prefix=prefix))
+    if AS_ROOT:
+        os.chown(path, NOBODY, NOBODY)
+    path.chmod(0o755 if not AS_ROOT else 0o700)
+    return path
+
+
+def give_to_nobody(root: Path):
+    if not AS_ROOT:
+        return
+    for dirpath, dirnames, filenames in os.walk(root):
+        os.chown(dirpath, NOBODY, NOBODY)
+        for name in filenames:
+            p = os.path.join(dirpath, name)
+            if not os.path.islink(p):
+                os.chown(p, NOBODY, NOBODY)
+
+
+def remove(path: Path):
+    shutil.rmtree(path, ignore_errors=True)
+
+
+def _drain(stream, chunks, keep=200_000):
+    kept = 0
+    while block := stream.read(8192):
+        if kept < keep:
+            chunks.append(block[:keep - kept])
+            kept += len(chunks[-1])
+
+
+def run(command: str, cwd: Path, timeout: int = 60, env_extra: dict | None = None) -> tuple[int, str]:
+    """Run a shell command as nobody in cwd. Returns (exit code, combined output, tail-trimmed)."""
+    env = {"PATH": "/usr/local/bin:/usr/bin:/bin", "HOME": str(cwd), "LANG": "C.UTF-8", "PYTHONDONTWRITEBYTECODE": "1",
+           "PYTHONPATH": f"{cwd}:{cwd}/src", "TMPDIR": str(cwd), "MPLBACKEND": "Agg", **(env_extra or {})}
+    kwargs = dict(user=NOBODY, group=NOBODY, extra_groups=[]) if AS_ROOT else {}
+    with _SLOTS:
+        proc = subprocess.Popen(["/bin/sh", "-c", LIMITS + command], cwd=cwd, env=env, stdin=subprocess.DEVNULL,
+                                stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, errors="replace",
+                                start_new_session=True, **kwargs)
+        chunks = []
+        reader = threading.Thread(target=_drain, args=(proc.stdout, chunks), daemon=True)
+        reader.start()
+        try:
+            proc.wait(timeout=timeout)
+            timed_out = False
+        except subprocess.TimeoutExpired:
+            timed_out = True
+        try:  # stop everything the command started
+            os.killpg(proc.pid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError):
+            pass
+        proc.wait()
+        reader.join(2)
+    out = "".join(chunks)
+    if timed_out:
+        out += f"\n[timed out after {timeout} s]"
+    return (124 if timed_out else proc.returncode), out
+
+
+def trim(out: str, limit: int = MAX_OUTPUT) -> str:
+    if len(out) <= limit:
+        return out
+    return f"[... {len(out) - limit} characters cut ...]\n" + out[-limit:]

source/codedesk/server/app.py

@@ -0,0 +1,12 @@
+from openenv.core.env_server.http_server import create_app
+
+from codedesk.environment import CodeEnvironment
+from codedesk.models import ToolAction, ToolObservation
+
+app = create_app(
+    CodeEnvironment,
+    ToolAction,
+    ToolObservation,
+    env_name="five_desks_code",
+    max_concurrent_envs=8,
+)

source/codedesk/tests/test_codedesk.py

@@ -0,0 +1,120 @@
+"""Checks for Five Desks Code. Run inside the image (the libraries' tests run here):
+
+    docker run --rm five-desks-code:test python -m pytest -q /app/codedesk/tests
+"""
+
+import os
+
+import pytest
+
+from codedesk import runner
+from codedesk.environment import CodeEnvironment, build, task_ids
+from codedesk.models import ToolAction
+
+SEEDS = range(3)
+
+
+@pytest.mark.parametrize("task_id", task_ids())
+def test_oracle_scores_one_and_untouched_scores_zero(task_id):
+    for seed in SEEDS:
+        task = build(task_id, seed)
+        try:
+            assert task.grade({}) == 0.0, (task_id, seed, "untouched workspace must fail")
+            task.oracle()
+            assert task.grade({}) == 1.0, (task_id, seed, "oracle must pass")
+        finally:
+            task.close()
+
+
+def test_bugfix_ignores_test_edits_and_config():
+    ids = [t for t in task_ids() if t.startswith("bugfix-") and t.endswith("-l1")]
+    for task_id in ids[:4]:
+        task = build(task_id, 1)
+        try:
+            for key in task.killed:  # gut the test files and add a conftest that skips everything
+                path = task.ws / key.split("::")[0]
+                if path.exists():
+                    path.write_text("def test_nothing():\n    pass\n")
+            (task.ws / "conftest.py").write_text("import pytest\ncollect_ignore_glob = ['*']\n")
+            assert task.grade({}) == 0.0, task_id
+        finally:
+            task.close()
+
+
+def test_bugfix_package_symlink_out_scores_zero():
+    task_id = next(t for t in task_ids() if t.startswith("bugfix-") and t.endswith("-l1"))
+    task = build(task_id, 2)
+    try:
+        pkg = task.ws / task.pkg
+        target = pkg / "evil_link" if pkg.is_dir() else task.ws / "evil_link"
+        os.symlink("/etc/passwd", target)
+        task.oracle()
+        if pkg.is_dir():
+            assert task.grade({}) == 0.0
+    finally:
+        task.close()
+
+
+def test_level2_removes_the_catching_tests():
+    for task_id in [t for t in task_ids() if t.startswith("bugfix-") and t.endswith("-l2")]:
+        task = build(task_id, 0)
+        try:
+            for key in task.killed:
+                path = task.ws / key.split("::")[0]
+                name = key.split("::")[-1].split("[")[0]
+                if path.exists():
+                    assert f"def {name}(" not in path.read_text(), (task_id, key)
+            assert "pytest '" not in (task.ws / "ISSUE.md").read_text()
+        finally:
+            task.close()
+
+
+def test_policy_commands_cannot_read_the_server():
+    if not runner.AS_ROOT:
+        pytest.skip("only meaningful in the root container")
+    task = build(next(t for t in task_ids() if t.startswith("bugfix-")), 0)
+    try:
+        code, out = runner.run("id -u; cat /app/codedesk/data/catalog.json | head -c 50", task.ws)
+        assert out.splitlines()[0] == "65534"
+        assert "Permission denied" in out
+    finally:
+        task.close()
+
+
+def test_episode_flow_with_random_names_and_finish():
+    env = CodeEnvironment()
+    for task_id in task_ids()[:6]:
+        obs = env.reset(task_id=task_id, seed=4)
+        assert "Tools:" in obs.output and not obs.done
+        obs = env.step(ToolAction(tool="submit", args={}))
+        assert obs.done and obs.reward == 0.0, task_id
+    obs = env.reset(task_id=task_ids()[0], seed=5)
+    names = [line.split()[1] for line in obs.output.split("Tools:")[1].splitlines() if line.startswith("- ")]
+    listing = next(n for n in names if n in ("list_files", "ls", "tree", "list_dir"))
+    out = env.step(ToolAction(tool=listing, args={})).output
+    assert "ISSUE.md" in out
+    unknown = env.step(ToolAction(tool="no_such_tool", args={}))
+    assert "Unknown tool" in unknown.output and not unknown.done
+
+
+def test_hostile_tool_calls_do_not_escape_or_crash():
+    env = CodeEnvironment()
+    env.reset(task_id=next(t for t in task_ids() if t.startswith("bugfix-")), seed=7, canonical_names=True)
+    calls = [
+        ("read_file", {"path": "../../etc/passwd"}), ("read_file", {"path": "/app/codedesk/data/catalog.json"}),
+        ("write_file", {"path": "../escape.txt", "content": "x"}), ("write_file", {"path": "/tmp/x", "content": "x"}),
+        ("edit_file", {"path": "/etc/hostname", "old": "a", "new": "b"}), ("list_files", {"path": "/"}),
+        ("search", {"pattern": "(((", "path": "."}), ("search", {"pattern": "x", "path": "/app"}),
+        ("run", {"command": "yes | head -c 10000000"}), ("run", {"command": "sleep 100"}),
+        ("run", {"command": ":(){ :|:& };:"}), ("run", {"command": "cat /app/codedesk/data/catalog.json"}),
+        ("run", {"command": "python -c 'import os; os.kill(1, 9)'"}), ("read_file", {"path": "ISSUE.md", "start": -5, "end": 10**9}),
+        ("run_tests", {"target": "/etc"}), ("run_tests", {"target": "; rm -rf /"}),
+    ]
+    for tool, args in calls:
+        obs = env.step(ToolAction(tool=tool, args=args))
+        assert not obs.done, (tool, args)
+        assert len(obs.output) <= 7000
+        assert '"cases"' not in obs.output and '"killed"' not in obs.output, (tool, args, obs.output[:200])
+    assert not (env._task.ws.parent / "escape.txt").exists()
+    obs = env.step(ToolAction(tool="submit", args={}))
+    assert obs.done and obs.reward == 0.0

source/proxy_eval/run.py

@@ -0,0 +1,192 @@
+"""Play Qwen3.8-27B (thinking off) on the proxy tasks with arena-style prompts.
+
+Each episode is scored twice from one conversation:
+- strict: the arena's rule. A reply that is not exactly one JSON object, or an action that fails the task's
+  schema, ends the episode and the task scores its finish_action.
+- lenient: the conversation continues (first JSON object in the reply is used; schema errors are reported back
+  to the model), to show what the model would reach without format failures.
+
+Usage: HF_TOKEN_PATH=... .venv/bin/python -m proxy_eval.run --samples 2 --out reports/proxy/run1
+"""
+
+import argparse
+import copy
+import json
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from statistics import mean
+
+from pydantic import ValidationError
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+
+from calibrate import Model, first_json_object, system_prompt  # noqa: E402
+
+from .tasks import FAMILIES  # noqa: E402
+
+
+def classify(reply: str):
+    s = reply.strip()
+    if not s:
+        return None, "empty"
+    try:
+        obj = json.loads(s)
+        return (obj, None) if isinstance(obj, dict) else (None, "not_object")
+    except json.JSONDecodeError:
+        pass
+    if s.startswith("```"):
+        return None, "code_fence"
+    if first_json_object(s) is not None:
+        return None, "json_plus_text"
+    return None, "no_json"
+
+
+def unwrap(action):
+    if isinstance(action, dict) and set(action) == {"action"} and isinstance(action["action"], dict):
+        return action["action"]
+    return action
+
+
+def finish_score(task):
+    """Reward the arena would record if the episode were ended now through finish_action."""
+    if task.done:
+        return None
+    try:
+        clone = copy.deepcopy(task)
+    except TypeError:  # tasks holding a database connection score 0 on an empty finish
+        return 0.0
+    return clone.step(clone.Action.model_validate(task.finish_action)).reward
+
+
+def play(task, model, completion_budget, context_budget, system_extra=""):
+    schema = task.Action.model_json_schema()
+    messages = [{"role": "system", "content": system_prompt(schema) + system_extra}]
+    obs = task.reset()
+    ep = {"task_id": task.task_id, "family": task.family, "domain": task.domain, "turns": [],
+          "strict": None, "lenient": None, "strict_end": None, "lenient_end": None, "schema_errors": 0}
+    completion_used = 0
+    first = True
+
+    def strict_fail(kind):
+        if ep["strict"] is None:
+            ep["strict"], ep["strict_end"] = finish_score(task) or 0.0, kind
+
+    while True:
+        obs_text = json.dumps(obs)
+        messages.append({"role": "user", "content": obs_text})
+        if not first:
+            completion_used += len(obs_text) // 3
+        first = False
+        if completion_used >= completion_budget or sum(len(m["content"]) for m in messages) // 3 >= context_budget:
+            strict_fail("budget")
+            ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, "budget"
+            break
+        reply, used, finish_reason = model.chat(messages)
+        completion_used += used
+        messages.append({"role": "assistant", "content": reply})
+        ep["turns"].append({"obs": obs_text[:1500], "reply": reply[:1500], "tokens": used})
+        if finish_reason == "length":
+            strict_fail("truncated")
+            ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, "truncated"
+            break
+        strict_obj, kind = classify(reply)
+        if kind:
+            strict_fail(kind)
+        action = unwrap(strict_obj if strict_obj is not None else first_json_object(reply))
+        if action is None:
+            ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, kind
+            break
+        if action.get("finish") is True:
+            score = finish_score(task) or 0.0
+            strict_fail("finish")
+            ep["lenient"], ep["lenient_end"] = score, "finish"
+            break
+        try:
+            parsed = task.Action.model_validate(action)
+        except ValidationError as exc:
+            ep["schema_errors"] += 1
+            strict_fail("schema_invalid")
+            errors = "; ".join(f"{'.'.join(map(str, e['loc']))}: {e['msg']}" for e in exc.errors()[:3])
+            obs = {"error": f"Invalid action: {errors}"}
+            if task.steps + ep["schema_errors"] > task.max_steps + 3:
+                ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, "schema_invalid"
+                break
+            continue
+        step = task.step(parsed)
+        obs = step.observation
+        if step.done:
+            if ep["strict"] is None:
+                ep["strict"], ep["strict_end"] = step.reward, "done"
+            ep["lenient"], ep["lenient_end"] = step.reward, "done"
+            break
+    ep["n_turns"] = len(ep["turns"])
+    return ep
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", default="Qwen/Qwen3.8-27B:deepinfra")
+    parser.add_argument("--families", default="", help="comma-separated family prefixes (default: all)")
+    parser.add_argument("--seeds", default="0-4")
+    parser.add_argument("--samples", type=int, default=2)
+    parser.add_argument("--workers", type=int, default=8)
+    parser.add_argument("--temperature", type=float, default=1.0)
+    parser.add_argument("--max-tokens", type=int, default=2048)
+    parser.add_argument("--completion-budget", type=int, default=8192)
+    parser.add_argument("--context-budget", type=int, default=16384)
+    parser.add_argument("--thinking", action="store_true", help="enable the model's thinking mode")
+    parser.add_argument("--system-extra", default="", help="file whose text is appended to the system prompt "
+                        "(to imitate a model that has learned a habit)")
+    parser.add_argument("--out", required=True)
+    args = parser.parse_args()
+    extra = "\n\n" + Path(args.system_extra).read_text().strip() if args.system_extra else ""
+
+    lo, hi = map(int, args.seeds.split("-"))
+    fams = [f for f in FAMILIES if not args.families or any(f.startswith(p) for p in args.families.split(","))]
+    jobs = [(f, s) for f in fams for s in range(lo, hi + 1) for _ in range(args.samples)]
+    model = Model(args.model, args.max_tokens, args.temperature, args.thinking)
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    started, results = time.monotonic(), []
+
+    def run(job):
+        fam, seed = job
+        return play(FAMILIES[fam](seed), model, args.completion_budget, args.context_budget, extra)
+
+    with ThreadPoolExecutor(args.workers) as pool, open(out / "episodes.jsonl", "w") as log:
+        for fut in [pool.submit(run, j) for j in jobs]:
+            try:
+                ep = fut.result()
+            except Exception as exc:  # infrastructure errors are excluded, not scored
+                print("episode error:", repr(exc)[:300], file=sys.stderr)
+                continue
+            results.append(ep)
+            log.write(json.dumps(ep) + "\n")
+            log.flush()
+
+    summary = {}
+    for fam in fams:
+        eps = [e for e in results if e["family"] == fam]
+        if not eps:
+            continue
+        ends = {}
+        for e in eps:
+            ends[e["strict_end"]] = ends.get(e["strict_end"], 0) + 1
+        summary[fam] = {"n": len(eps), "strict": round(mean(e["strict"] for e in eps), 3),
+                        "lenient": round(mean(e["lenient"] for e in eps), 3), "strict_ends": ends,
+                        "turns": round(mean(e["n_turns"] for e in eps), 1)}
+    report = {"model": args.model, "system_extra": args.system_extra, "temperature": args.temperature, "thinking": args.thinking, "episodes": len(results),
+              "seconds": round(time.monotonic() - started), "usage": model.usage, "families": summary,
+              "overall": {"strict": round(mean(e["strict"] for e in results), 3),
+                          "lenient": round(mean(e["lenient"] for e in results), 3)}}
+    (out / "summary.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(f"{'family':24s} {'n':>3s} {'strict':>6s} {'lenient':>7s}  strict ends")
+    for fam, s in summary.items():
+        print(f"{fam:24s} {s['n']:3d} {s['strict']:6.2f} {s['lenient']:7.2f}  {s['strict_ends']}")
+    print("overall", report["overall"], "usage", model.usage, "seconds", report["seconds"])
+
+
+if __name__ == "__main__":
+    main()

source/requirements.lock

@@ -0,0 +1,353 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile requirements.in --python-version 3.12 --python-platform x86_64-unknown-linux-gnu -o requirements.lock
+aiofile==3.12.3
+    # via py-key-value-aio
+annotated-doc==0.0.5
+    # via
+    #   fastapi
+    #   typer
+annotated-types==0.8.0
+    # via pydantic
+anyio==4.15.1
+    # via
+    #   gradio
+    #   httpx
+    #   httpx2
+    #   mcp
+    #   openai
+    #   py-key-value-aio
+    #   sse-starlette
+    #   starlette
+    #   watchfiles
+attrs==26.1.0
+    # via
+    #   cyclopts
+    #   jsonschema
+    #   jsonschema-path
+    #   referencing
+authlib==1.8.0
+    # via fastmcp-slim
+beartype==0.22.9
+    # via py-key-value-aio
+brotli==1.2.0
+    # via gradio
+cachetools==7.2.1
+    # via py-key-value-aio
+caio==0.12.9
+    # via aiofile
+certifi==2026.7.22
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+cffi==2.1.1
+    # via cryptography
+charset-normalizer==3.5.2
+    # via requests
+click==8.5.0
+    # via
+    #   huggingface-hub
+    #   uvicorn
+cryptography==50.0.2
+    # via
+    #   authlib
+    #   joserfc
+    #   pyjwt
+    #   secretstorage
+cyclopts==5.2.0
+    # via fastmcp-slim
+dnspython==2.9.0
+    # via email-validator
+docstring-parser==0.18.0
+    # via cyclopts
+email-validator==2.3.0
+    # via pydantic
+exceptiongroup==1.3.1
+    # via fastmcp-slim
+fastapi==0.143.0
+    # via
+    #   gradio
+    #   openenv
+fastmcp==3.4.8
+    # via openenv
+fastmcp-slim==3.4.8
+    # via fastmcp
+filelock==4.0.12
+    # via huggingface-hub
+fsspec==2026.9.0
+    # via
+    #   gradio-client
+    #   huggingface-hub
+gradio==6.30.0
+    # via openenv
+gradio-client==2.7.2
+    # via
+    #   gradio
+    #   hf-gradio
+griffelib==2.3.2
+    # via fastmcp-slim
+groovy==0.1.2
+    # via gradio
+h11==0.16.0
+    # via
+    #   httpcore
+    #   httpcore2
+    #   uvicorn
+hf-gradio==0.4.1
+    # via gradio
+hf-xet==1.7.0
+    # via huggingface-hub
+httpcore==1.0.9
+    # via httpx
+httpcore2==2.13.1
+    # via httpx2
+httpx==0.28.1
+    # via
+    #   fastmcp-slim
+    #   gradio
+    #   gradio-client
+    #   mcp
+    #   openenv
+    #   safehttpx
+httpx-sse==0.4.3
+    # via mcp
+httpx2==2.13.1
+    # via
+    #   huggingface-hub
+    #   openai
+huggingface-hub==2.2.0
+    # via
+    #   gradio
+    #   gradio-client
+    #   openenv
+idna==3.20
+    # via
+    #   anyio
+    #   email-validator
+    #   httpx
+    #   httpx2
+    #   requests
+jaraco-classes==3.4.0
+    # via keyring
+jaraco-context==6.1.2
+    # via keyring
+jaraco-functools==4.6.0
+    # via keyring
+jeepney==0.9.0
+    # via
+    #   keyring
+    #   secretstorage
+jinja2==3.1.6
+    # via gradio
+jiter==0.17.0
+    # via openai
+joserfc==1.7.5
+    # via
+    #   authlib
+    #   fastmcp-slim
+jsonref==1.1.0
+    # via fastmcp-slim
+jsonschema==4.26.0
+    # via mcp
+jsonschema-path==0.5.0
+    # via fastmcp-slim
+jsonschema-specifications==2025.9.1
+    # via jsonschema
+keyring==25.7.0
+    # via py-key-value-aio
+markdown-it-py==4.2.0
+    # via rich
+markupsafe==3.0.4
+    # via
+    #   gradio
+    #   jinja2
+mcp==1.30.0
+    # via fastmcp-slim
+mdurl==0.1.2
+    # via markdown-it-py
+more-itertools==11.1.0
+    # via
+    #   jaraco-classes
+    #   jaraco-functools
+numpy==2.5.3
+    # via
+    #   gradio
+    #   pandas
+openai==3.27.0
+    # via openenv
+openapi-pydantic==0.6.0
+    # via fastmcp-slim
+openenv @ git+https://github.com/meta-pytorch/OpenEnv.git@86a180ede21e044f7929b9a7783ad83aa67d83a3
+    # via -r requirements.in
+opentelemetry-api==1.45.1
+    # via
+    #   fastapi
+    #   fastmcp-slim
+orjson==3.13.0
+    # via gradio
+packaging==26.3
+    # via
+    #   fastmcp-slim
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   openenv
+pandas==3.0.6
+    # via gradio
+pathable==0.6.0
+    # via jsonschema-path
+pillow==12.3.0
+    # via gradio
+platformdirs==4.12.4
+    # via fastmcp-slim
+py-key-value-aio==0.4.6
+    # via fastmcp-slim
+pycparser==3.11
+    # via cffi
+pydantic==2.14.0
+    # via
+    #   fastapi
+    #   fastmcp-slim
+    #   gradio
+    #   mcp
+    #   openai
+    #   openapi-pydantic
+    #   openenv
+    #   pydantic-settings
+pydantic-core==2.50.0
+    # via pydantic
+pydantic-settings==2.15.0
+    # via
+    #   fastmcp-slim
+    #   mcp
+pydub==0.25.1
+    # via gradio
+pygments==2.21.0
+    # via
+    #   rich
+    #   rich-rst
+pyjwt==2.15.1
+    # via mcp
+pyperclip==1.11.0
+    # via fastmcp-slim
+python-dateutil==2.9.0.post0
+    # via pandas
+python-dotenv==1.2.4
+    # via
+    #   fastmcp-slim
+    #   pydantic-settings
+python-multipart==0.0.32
+    # via
+    #   fastmcp-slim
+    #   gradio
+    #   mcp
+pytz==2026.5
+    # via gradio
+pyyaml==6.0.3
+    # via
+    #   fastmcp-slim
+    #   gradio
+    #   huggingface-hub
+    #   jsonschema-path
+    #   openenv
+referencing==0.37.0
+    # via
+    #   jsonschema
+    #   jsonschema-path
+    #   jsonschema-specifications
+requests==2.34.2
+    # via openenv
+rich==15.0.0
+    # via
+    #   cyclopts
+    #   fastmcp-slim
+    #   openenv
+    #   rich-rst
+    #   typer
+rich-rst==2.2.0
+    # via cyclopts
+rpds-py==2026.9.1
+    # via
+    #   jsonschema
+    #   referencing
+safehttpx==0.1.7
+    # via gradio
+secretstorage==3.5.0
+    # via keyring
+semantic-version==2.10.0
+    # via gradio
+shellingham==1.5.4
+    # via typer
+six==1.17.0
+    # via python-dateutil
+sniffio==1.3.1
+    # via openai
+sse-starlette==3.5.0
+    # via mcp
+starlette==1.7.0
+    # via
+    #   fastapi
+    #   fastmcp-slim
+    #   gradio
+    #   mcp
+    #   sse-starlette
+tomli==2.5.0
+    # via openenv
+tomli-w==1.2.0
+    # via openenv
+tomlkit==0.14.0
+    # via gradio
+tqdm==4.70.1
+    # via huggingface-hub
+truststore==0.10.4
+    # via
+    #   httpcore2
+    #   httpx2
+typer==0.27.3
+    # via
+    #   gradio
+    #   hf-gradio
+    #   openenv
+typing-extensions==4.16.0
+    # via
+    #   anyio
+    #   exceptiongroup
+    #   fastapi
+    #   fastmcp-slim
+    #   gradio
+    #   gradio-client
+    #   httpx2
+    #   huggingface-hub
+    #   mcp
+    #   openai
+    #   openenv
+    #   opentelemetry-api
+    #   py-key-value-aio
+    #   pydantic
+    #   pydantic-core
+    #   referencing
+    #   starlette
+    #   typing-inspection
+typing-inspection==0.4.4
+    # via
+    #   fastapi
+    #   mcp
+    #   pydantic
+    #   pydantic-settings
+uncalled-for==0.4.1
+    # via fastmcp-slim
+urllib3==2.8.0
+    # via requests
+uvicorn==0.54.0
+    # via
+    #   -r requirements.in
+    #   fastmcp-slim
+    #   gradio
+    #   mcp
+    #   openenv
+watchfiles==1.3.0
+    # via fastmcp-slim
+websockets==17.2
+    # via
+    #   fastmcp-slim
+    #   openenv

source/scripts/calibrate.py

@@ -0,0 +1,224 @@
+"""Play Qwen3.8-27B (thinking off) against a running server to measure per-task solve rates.
+
+The HF token is read inside this process via huggingface_hub (HF_TOKEN_PATH selects the file);
+it is never printed or written anywhere.
+
+Usage: HF_TOKEN_PATH=... python scripts/calibrate.py --url http://localhost:8000 --episodes 4 --out reports/calibration/run1
+"""
+
+import argparse
+import json
+import random
+import re
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from statistics import mean
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from huggingface_hub import get_token  # noqa: E402
+from pydantic import ValidationError  # noqa: E402
+
+from five_desks.models import DeskAction  # noqa: E402
+from five_desks.tasks import TASK_IDS  # noqa: E402
+from wsclient import Session  # noqa: E402
+
+ROUTER = "https://router.huggingface.co/v1/chat/completions"
+FINISH_ACTION = {"tool": "submit", "answer": {}}
+_decoder = json.JSONDecoder(strict=False)
+
+
+def system_prompt(action_schema: dict) -> str:
+    return (
+        "You are an agent acting in an environment. Reply to every message with exactly one JSON object and "
+        "nothing else: an action that matches the action schema below, or {\"finish\": true} to end the episode.\n"
+        f"Action schema: {json.dumps(action_schema)}"
+    )
+
+
+def first_json_object(text: str):
+    text = re.sub(r"<think>.*?</think>", "", text or "", flags=re.S)
+    for match in re.finditer(r"\{", text):
+        try:
+            obj, _ = _decoder.raw_decode(text[match.start():])
+            if isinstance(obj, dict):
+                return obj
+        except json.JSONDecodeError:
+            continue
+    return None
+
+
+class Model:
+    def __init__(self, model: str, max_tokens: int, temperature: float, thinking: bool = False):
+        self.model, self.max_tokens, self.temperature, self.thinking = model, max_tokens, temperature, thinking
+        self._token = get_token()
+        if not self._token:
+            raise SystemExit("No Hugging Face token found (set HF_TOKEN_PATH).")
+        self.usage = {"prompt_tokens": 0, "completion_tokens": 0, "calls": 0}
+        self._lock = threading.Lock()
+        self.empty_examples = []
+
+    def chat(self, messages):
+        # Some provider responses come back with no content at all; retry those rather than score them.
+        for _ in range(3):
+            content, used, finish = self._chat_once(messages)
+            if content.strip() or finish == "length":
+                break
+        return content, used, finish
+
+    def _chat_once(self, messages):
+        body = {"model": self.model, "messages": messages, "max_tokens": self.max_tokens,
+                "temperature": self.temperature, "chat_template_kwargs": {"enable_thinking": self.thinking}}
+        for attempt in range(5):
+            req = urllib.request.Request(ROUTER, data=json.dumps(body).encode(), headers={
+                "Authorization": f"Bearer {self._token}", "Content-Type": "application/json"})
+            try:
+                with urllib.request.urlopen(req, timeout=180) as response:
+                    data = json.load(response)
+                break
+            except urllib.error.HTTPError as exc:
+                if exc.code in (429, 500, 502, 503, 504) and attempt < 4:
+                    time.sleep(2 ** attempt * 3)
+                    continue
+                raise RuntimeError(f"inference HTTP {exc.code}: {exc.read().decode()[:200]}") from None
+            except (urllib.error.URLError, TimeoutError):  # DNS hiccups and slow responses are retried too
+                if attempt < 4:
+                    time.sleep(2 ** attempt * 3)
+                    continue
+                raise
+        usage = data.get("usage") or {}
+        with self._lock:
+            self.usage["prompt_tokens"] += usage.get("prompt_tokens", 0)
+            self.usage["completion_tokens"] += usage.get("completion_tokens", 0)
+            self.usage["calls"] += 1
+        choice = data["choices"][0]
+        message = choice["message"]
+        content = message.get("content") or ""
+        if not content.strip():
+            with self._lock:
+                self.usage["empty_content"] = self.usage.get("empty_content", 0) + 1
+                self.empty_examples.append({k: v for k, v in message.items() if v})
+        return content, usage.get("completion_tokens", 0), choice.get("finish_reason")
+
+
+def play(url, model, schema, task_id, completion_budget, context_budget):
+    messages = [{"role": "system", "content": system_prompt(schema)}]
+    episode = {"task_id": task_id, "turns": [], "end": None, "reward": 0.0}
+    completion_used = 0
+    with Session(url) as session:
+        episode["seed"] = random.SystemRandom().randrange(2**48)
+        data = session.reset(task_id=task_id, seed=episode["seed"])
+        obs = data["observation"]
+        while True:
+            obs_text = json.dumps({k: v for k, v in obs.items() if k != "metadata" or v})
+            messages.append({"role": "user", "content": obs_text})
+            if len(messages) > 2:
+                completion_used += len(obs_text) // 3  # later observations count against the budget
+            if completion_used >= completion_budget or sum(len(m["content"]) for m in messages) // 3 >= context_budget:
+                episode["end"] = "budget"
+                data = session.step(FINISH_ACTION)
+                break
+            reply, used, finish_reason = model.chat(messages)
+            completion_used += used
+            messages.append({"role": "assistant", "content": reply})
+            episode["turns"].append({"obs": obs_text[:4000], "reply": reply[:2000], "finish_reason": finish_reason, "tokens": used})
+            if finish_reason == "length":
+                episode["end"] = "truncated"
+                data = session.step(FINISH_ACTION)
+                break
+            action = first_json_object(reply)
+            if isinstance(action, dict) and set(action) == {"action"} and isinstance(action["action"], dict):
+                action = action["action"]
+            if action is None:
+                episode["end"] = "empty_reply" if not reply.strip() else "invalid_json"
+                data = session.step(FINISH_ACTION)
+                break
+            if action.get("finish") is True:
+                episode["end"] = "finish"
+                data = session.step(FINISH_ACTION)
+                break
+            try:
+                DeskAction.model_validate(action)
+            except ValidationError:
+                episode["end"] = "schema_invalid"
+                data = session.step(FINISH_ACTION)
+                break
+            data = session.step(action)
+            obs = data["observation"]
+            if data["done"]:
+                episode["end"] = "submitted" if action.get("tool") == "submit" else "out_of_steps"
+                episode["final"] = obs.get("output")
+                break
+    episode["reward"] = data.get("reward") or 0.0
+    episode["n_turns"] = len(episode["turns"])
+    episode["completion_tokens_est"] = completion_used
+    return episode
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url", default="http://localhost:8000")
+    parser.add_argument("--model", default="Qwen/Qwen3.8-27B:deepinfra")
+    parser.add_argument("--episodes", type=int, default=4)
+    parser.add_argument("--tasks", default="", help="comma-separated task ids or prefixes (default: all)")
+    parser.add_argument("--workers", type=int, default=8)
+    parser.add_argument("--max-tokens", type=int, default=1024)
+    parser.add_argument("--temperature", type=float, default=1.0)
+    parser.add_argument("--completion-budget", type=int, default=8192)
+    parser.add_argument("--context-budget", type=int, default=16384)
+    parser.add_argument("--out", required=True)
+    args = parser.parse_args()
+
+    tasks = TASK_IDS
+    if args.tasks:
+        wanted = args.tasks.split(",")
+        tasks = [t for t in TASK_IDS if any(t.startswith(w) for w in wanted)]
+    with urllib.request.urlopen(f"{args.url}/schema", timeout=15) as response:
+        schema = json.load(response)["action"]
+    model = Model(args.model, args.max_tokens, args.temperature)
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    jobs = [t for t in tasks for _ in range(args.episodes)]
+    started = time.monotonic()
+    results = []
+    with ThreadPoolExecutor(args.workers) as pool, open(out / "episodes.jsonl", "w") as log:
+        futures = [pool.submit(play, args.url, model, schema, t, args.completion_budget, args.context_budget) for t in jobs]
+        for fut in futures:
+            try:
+                ep = fut.result()
+            except Exception as exc:  # infrastructure errors are excluded, not scored as 0
+                print("episode error:", exc, file=sys.stderr)
+                continue
+            results.append(ep)
+            log.write(json.dumps(ep) + "\n")
+
+    summary = {}
+    for task_id in tasks:
+        eps = [e for e in results if e["task_id"] == task_id]
+        if not eps:
+            continue
+        rewards = [e["reward"] for e in eps]
+        ends = {}
+        for e in eps:
+            ends[e["end"]] = ends.get(e["end"], 0) + 1
+        summary[task_id] = {"n": len(eps), "mean": round(mean(rewards), 3), "rewards": rewards,
+                            "mixed": len(set(rewards)) > 1, "ends": ends,
+                            "turns": round(mean(e["n_turns"] for e in eps), 1)}
+    report = {"model": args.model, "episodes": len(results), "seconds": round(time.monotonic() - started),
+              "usage": model.usage, "tasks": summary}
+    (out / "summary.json").write_text(json.dumps(report, indent=2) + "\n")
+    (out / "empty_examples.json").write_text(json.dumps(model.empty_examples[:20], indent=2) + "\n")
+    print(f"{'task':24s} {'mean':>5s}  rewards                        ends")
+    for task_id, s in summary.items():
+        print(f"{task_id:24s} {s['mean']:5.2f}  {str(s['rewards']):30s} {s['ends']}")
+    print("usage:", model.usage, "seconds:", report["seconds"])
+
+
+if __name__ == "__main__":
+    main()

source/scripts/calibrate_v2.py

@@ -0,0 +1,144 @@
+"""Calibrate Five Desks against Qwen3.8-27B (thinking off) under the arena's reply rules.
+
+A reply that is not exactly one JSON object, or an action that fails the schema, ends the episode through the
+finish action. With --lenient, a reply with text around one JSON object is played instead: the v2 run showed the
+arena accepts those (industrial trained at 0.80 against 0.31 measured strictly), and v1's lenient calibration
+matched its arena run. The token is read in-process via HF_TOKEN_PATH and never printed.
+
+Usage: HF_TOKEN_PATH=... .venv/bin/python scripts/calibrate_v2.py --url http://localhost:8001 --episodes 8 --out reports/calibration-v2/run1
+"""
+
+import argparse
+import json
+import random
+import sys
+import time
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from statistics import mean
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from pydantic import ValidationError  # noqa: E402
+
+from calibrate import Model, first_json_object, system_prompt  # noqa: E402
+from diligence.environment import TASK_IDS  # noqa: E402
+from diligence.models import ToolAction  # noqa: E402
+from proxy_eval.run import classify, unwrap  # noqa: E402
+from wsclient import Session  # noqa: E402
+
+FINISH = {"tool": "submit", "args": {}}
+
+
+def play(url, model, schema, task_id, completion_budget, context_budget, extra="", lenient=False):
+    messages = [{"role": "system", "content": system_prompt(schema) + extra}]
+    ep = {"task_id": task_id, "turns": [], "end": None, "reward": 0.0, "bad_args": 0, "rescued": 0}
+    used_total, first = 0, True
+    with Session(url, timeout=60) as s:
+        ep["seed"] = random.SystemRandom().randrange(2**48)
+        data = s.reset(task_id=task_id, seed=ep["seed"])
+        while True:
+            obs = json.dumps({k: v for k, v in data["observation"].items() if k != "metadata" or v})
+            messages.append({"role": "user", "content": obs})
+            if not first:
+                used_total += len(obs) // 3
+            first = False
+            if used_total >= completion_budget or sum(len(m["content"]) for m in messages) // 3 >= context_budget:
+                ep["end"], data = "budget", s.step(FINISH)
+                break
+            reply, used, finish_reason = model.chat(messages)
+            used_total += used
+            messages.append({"role": "assistant", "content": reply})
+            ep["turns"].append({"obs": obs[:2500], "reply": reply[:2500]})
+            if finish_reason == "length":
+                ep["end"], data = "truncated", s.step(FINISH)
+                break
+            obj, kind = classify(reply)
+            if kind and lenient and (rescued := first_json_object(reply)) is not None:
+                obj, kind = rescued, None
+                ep["rescued"] += 1
+            if kind:
+                ep["end"], data = kind, s.step(FINISH)
+                break
+            action = unwrap(obj)
+            if action.get("finish") is True:
+                ep["end"], data = "finish", s.step(FINISH)
+                break
+            try:
+                ToolAction.model_validate(action)
+            except ValidationError:
+                ep["end"], data = "schema_invalid", s.step(FINISH)
+                break
+            data = s.step(action)
+            out = data["observation"].get("output", "")
+            if out.startswith(("Unknown tool", "Unknown argument", "Missing argument")) or "must be a" in out[:80]:
+                ep["bad_args"] += 1
+            if data["done"]:
+                ep["end"] = "submitted" if out.startswith("Submitted") else "out_of_steps"
+                break
+    ep["reward"] = data.get("reward") or 0.0
+    ep["n_turns"] = len(ep["turns"])
+    return ep
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--url", default="http://localhost:8001")
+    ap.add_argument("--model", default="Qwen/Qwen3.8-27B:deepinfra")
+    ap.add_argument("--episodes", type=int, default=8)
+    ap.add_argument("--tasks", default="")
+    ap.add_argument("--task-ids", default="", help="explicit comma-separated task ids (for other servers)")
+    ap.add_argument("--workers", type=int, default=8)
+    ap.add_argument("--temperature", type=float, default=1.0)
+    ap.add_argument("--max-tokens", type=int, default=2048)
+    ap.add_argument("--completion-budget", type=int, default=8192)
+    ap.add_argument("--context-budget", type=int, default=16384)
+    ap.add_argument("--system-extra", default="", help="file appended to the system prompt")
+    ap.add_argument("--lenient", action="store_true", help="play the JSON object out of replies with extra text")
+    ap.add_argument("--out", required=True)
+    args = ap.parse_args()
+    tasks = args.task_ids.split(",") if args.task_ids else [
+        t for t in TASK_IDS if not args.tasks or any(t.startswith(p) for p in args.tasks.split(","))]
+    with urllib.request.urlopen(f"{args.url}/schema", timeout=15) as r:
+        schema = json.load(r)["action"]
+    model = Model(args.model, args.max_tokens, args.temperature)
+    extra = "\n\n" + Path(args.system_extra).read_text().strip() if args.system_extra else ""
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    started, results = time.monotonic(), []
+    jobs = [t for t in tasks for _ in range(args.episodes)]
+    with ThreadPoolExecutor(args.workers) as pool, open(out / "episodes.jsonl", "w") as log:
+        for fut in [pool.submit(play, args.url, model, schema, t, args.completion_budget, args.context_budget, extra, args.lenient) for t in jobs]:
+            try:
+                ep = fut.result()
+            except Exception as exc:  # infrastructure errors are excluded, not scored
+                print("episode error:", repr(exc)[:200], file=sys.stderr)
+                continue
+            results.append(ep)
+            log.write(json.dumps(ep) + "\n")
+            log.flush()
+    summary = {}
+    for t in tasks:
+        eps = [e for e in results if e["task_id"] == t]
+        if not eps:
+            continue
+        ends = {}
+        for e in eps:
+            ends[e["end"]] = ends.get(e["end"], 0) + 1
+        summary[t] = {"n": len(eps), "mean": round(mean(e["reward"] for e in eps), 3),
+                      "solved": sum(e["reward"] == 1.0 for e in eps), "rewards": [e["reward"] for e in eps],
+                      "ends": ends, "turns": round(mean(e["n_turns"] for e in eps), 1),
+                      "rescued_replies": sum(e.get("rescued", 0) for e in eps)}
+    report = {"model": args.model, "lenient": args.lenient, "episodes": len(results), "seconds": round(time.monotonic() - started),
+              "usage": model.usage, "tasks": summary}
+    (out / "summary.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(f"{'task':24s} {'mean':>5s} solved  ends")
+    for t, s in summary.items():
+        print(f"{t:24s} {s['mean']:5.2f} {s['solved']:2d}/{s['n']:<2d}  {s['ends']}")
+    print("usage:", model.usage, "seconds:", report["seconds"])
+
+
+if __name__ == "__main__":
+    main()

source/scripts/wsclient.py

@@ -0,0 +1,44 @@
+"""Minimal OpenEnv WebSocket client used by the replay and calibration scripts."""
+
+import json
+from urllib.parse import urlsplit, urlunsplit
+
+from websockets.sync.client import connect
+
+
+def ws_url(base_url: str) -> str:
+    parts = urlsplit(base_url.rstrip("/"))
+    scheme = "wss" if parts.scheme == "https" else "ws"
+    return urlunsplit((scheme, parts.netloc, parts.path + "/ws", "", ""))
+
+
+class Session:
+    def __init__(self, base_url: str, timeout: float = 30):
+        self.timeout = timeout
+        self.sock = connect(ws_url(base_url), open_timeout=timeout, close_timeout=5, max_size=2**22)
+
+    def _send(self, message: dict) -> dict:
+        self.sock.send(json.dumps(message))
+        response = json.loads(self.sock.recv(timeout=self.timeout))
+        if response.get("type") != "observation":
+            raise RuntimeError(f"unexpected response: {response}")
+        data = response["data"]
+        reward = data.get("reward")
+        assert isinstance(data.get("done"), bool), data
+        assert reward is None or (isinstance(reward, (int, float)) and 0 <= reward <= 1), data
+        return data
+
+    def reset(self, **kwargs) -> dict:
+        return self._send({"type": "reset", "data": kwargs})
+
+    def step(self, action: dict) -> dict:
+        return self._send({"type": "step", "data": action})
+
+    def close(self):
+        self.sock.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()

tasks.jsonl

@@ -0,0 +1,18 @@
+{"task_id": "bugfix-finance-l1", "submitted_for_training": true, "qwen3_8_27b_mean_reward": 0.5, "qwen3_8_27b_rewards": [1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0]}
+{"task_id": "bugfix-finance-l2", "submitted_for_training": false, "qwen3_8_27b_mean_reward": 0.125, "qwen3_8_27b_rewards": [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]}
+{"task_id": "bugfix-industrial-l1", "submitted_for_training": false, "qwen3_8_27b_mean_reward": 0.875, "qwen3_8_27b_rewards": [1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0]}
+{"task_id": "bugfix-industrial-l2", "submitted_for_training": true, "qwen3_8_27b_mean_reward": 0.375, "qwen3_8_27b_rewards": [0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0]}
+{"task_id": "bugfix-math-l1", "submitted_for_training": true, "qwen3_8_27b_mean_reward": 0.5, "qwen3_8_27b_rewards": [1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0]}
+{"task_id": "bugfix-math-l2", "submitted_for_training": false, "qwen3_8_27b_mean_reward": 0.375, "qwen3_8_27b_rewards": [1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]}
+{"task_id": "bugfix-media-l1", "submitted_for_training": false, "qwen3_8_27b_mean_reward": 0.375, "qwen3_8_27b_rewards": [0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0]}
+{"task_id": "bugfix-media-l2", "submitted_for_training": true, "qwen3_8_27b_mean_reward": 0.562, "qwen3_8_27b_rewards": [0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0]}
+{"task_id": "bugfix-office-l1", "submitted_for_training": true, "qwen3_8_27b_mean_reward": 0.562, "qwen3_8_27b_rewards": [0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0]}
+{"task_id": "bugfix-office-l2", "submitted_for_training": false, "qwen3_8_27b_mean_reward": 0.625, "qwen3_8_27b_rewards": [0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0]}
+{"task_id": "bugfix-science-l1", "submitted_for_training": true, "qwen3_8_27b_mean_reward": 0.312, "qwen3_8_27b_rewards": [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0]}
+{"task_id": "bugfix-science-l2", "submitted_for_training": false, "qwen3_8_27b_mean_reward": 0.25, "qwen3_8_27b_rewards": [1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]}
+{"task_id": "bugfix-security-l1", "submitted_for_training": false, "qwen3_8_27b_mean_reward": 0.75, "qwen3_8_27b_rewards": [1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0]}
+{"task_id": "bugfix-security-l2", "submitted_for_training": true, "qwen3_8_27b_mean_reward": 0.5, "qwen3_8_27b_rewards": [1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0]}
+{"task_id": "bugfix-software-l1", "submitted_for_training": false, "qwen3_8_27b_mean_reward": 0.75, "qwen3_8_27b_rewards": [1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0]}
+{"task_id": "bugfix-software-l2", "submitted_for_training": true, "qwen3_8_27b_mean_reward": 0.688, "qwen3_8_27b_rewards": [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0]}
+{"task_id": "media-production-l1", "submitted_for_training": false, "qwen3_8_27b_mean_reward": 0.375, "qwen3_8_27b_rewards": [1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0]}
+{"task_id": "media-production-l2", "submitted_for_training": true, "qwen3_8_27b_mean_reward": 0.438, "qwen3_8_27b_rewards": [1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]}