| --- |
| license: mit |
| language: |
| - en |
| configs: |
| - config_name: tbd |
| data_files: TerminalBench-DockerLess.jsonl |
| tags: |
| - terminal |
| - bench |
| - dockerless |
| --- |
| # TerminalBench-DockerLess |
|
|
| Terminal-Bench tasks are directories (instruction, environment, solution, tests) |
| executed inside a Docker image. This is the same task model with the image |
| replaced by a setup script, so a trial needs only `bash`, `git` and `python` — |
| no daemon, no network, no build step. |
|
|
| Rows carry the classic Terminal-Bench `task.yaml` fields, a rendered |
| `task.toml` in the Harbor 1.4 schema, and the whole task directory inline. One |
| extra `dockerless` object says how to build the environment without Docker. |
|
|
| ``` |
| TerminalBench-DockerLess.jsonl 4 tasks, 52.5 KiB (~13.4k tokens) |
| build_dataset.py flattens tasks/ into rows, then verifies the file |
| run_harness.py trial runner: --solution, --baseline, --predictions |
| tasks/ the four task directories (source of truth) |
| tools/validate.py schema, leakage and non-triviality checks |
| tools/make_controls.py builds the partial-credit negative control |
| tools/mk_access_log.py regenerates the access.log fixture |
| reports/ harness output for solution / baseline / partial |
| ``` |
|
|
| ## Tasks |
|
|
| | task_id | difficulty | category | verifier tests | fails before any agent | oracle | |
| | --- | --- | --- | --- | --- | --- | |
| | `tbdl-access-log-report` | medium | data-processing | 10 | 10 | pass | |
| | `tbdl-git-recovery` | hard | software-engineering | 10 | 9 | pass | |
| | `tbdl-csv-canon` | hard | data-processing | 8 | 8 | pass | |
| | `tbdl-build-repair` | hard | software-engineering | 4 | 4 | pass | |
| |
| Difficulty is kept Terminal-Bench-shaped: each task needs real terminal work |
| across several steps and fails if any one part is skipped. |
| |
| - **access-log-report** — a damaged nginx-style log where the user-agent carries |
| escaped quotes, so splitting on `"` breaks; produce an exact JSON aggregate, |
| a nearest-rank p95, a malformed-line index and a gzip copy, idempotently. |
| - **git-recovery** — restore a deleted module from the *right* historical |
| revision, resurrect an unreachable commit found via `git fsck`, tag a release |
| commit, ignore two untracked artefacts without deleting them, and leave a clean |
| tree without rewriting the five original commits. |
| - **csv-canon** — write a byte-exact CSV→TSV canonicaliser: BOM, CRLF, RFC 4180 |
| quoting, embedded newlines, `Decimal` numeric rewriting, byte-order sorting, |
| and three distinct exit codes with exact stderr lines. |
| - **build-repair** — a build that dies on an unbound shell variable, then on a |
| missing output directory, then produces a report missing its last record with a |
| truncated mean; all three must be fixed without touching `data/` or `tests/`. |
| |
| ## Row schema |
| |
| | field | notes | |
| | --- | --- | |
| | `task_id` | `tbdl-<task>` | |
| | `instruction` | the full `instruction.md` text | |
| | `author_name`, `author_email` | as in `task.yaml` | |
| | `difficulty`, `category`, `tags` | `easy` / `medium` / `hard` | |
| | `parser_name` | `pytest` | |
| | `max_agent_timeout_sec`, `max_test_timeout_sec` | enforced by the harness | |
| | `expert_time_estimate_min`, `junior_time_estimate_min` | author estimates | |
| | `task_yaml` | the row rendered as a classic Terminal-Bench `task.yaml` | |
| | `task_toml` | the row rendered as a Harbor `task.toml` (`schema_version = "1.4"`) | |
| | `dockerfile` | the original image spec, kept for fidelity (not executed) | |
| | `solution` | `solution/solve.sh`, the oracle | |
| | `tests` | `{"test.sh": ..., "test_outputs.py": ...}` | |
| | `dockerless.setup` | replaces the Dockerfile: builds the environment | |
| | `dockerless.files` | workspace snapshot written before setup runs | |
| | `dockerless.test_cmd` | empty = run `tests/test.sh` | |
| | `dockerless.baseline_failures` | verifier tests that already fail before any agent acts | |
|
|
| ## How the environment is replaced |
|
|
| | Terminal-Bench | here | |
| | --- | --- | |
| | `environment/Dockerfile` + `docker build` | `dockerless.setup` run in a fresh directory | |
| | `/workspace` | `$TB_WORK` | |
| | `/logs/verifier/reward.txt` | the harness computes reward from the pytest run | |
| | `tests/test.sh` | same file, run with `cwd=$TB_WORK` | |
|
|
| Each trial gets a throwaway root: |
|
|
| ``` |
| $TB_ROOT/ |
| workspace/ agent cwd |
| home/ HOME |
| tmp/ TMPDIR |
| bin/ prepended to PATH (contains a python3 shim) |
| tests/ verifier, uploaded after the agent finishes |
| ``` |
|
|
| ## Running it |
|
|
| ```bash |
| python -m pip install pytest # the only dependency |
| python build_dataset.py # rebuild + verify (oracle 4/4, baseline 0/4) |
| python run_harness.py --solution # oracle, expect 4/4 |
| python run_harness.py --baseline # no agent, expect 0/4 |
| python run_harness.py --predictions predictions/partial.jsonl |
| ``` |
|
|
| A prediction is `{"task_id", "agent_script"}`: a shell script run in the |
| workspace, which is the Docker-free stand-in for "the agent did its work". |
| `resolved` means every verifier test passed (reward `1.0`), the Terminal-Bench |
| rule. |
|
|
| ## Verified results |
|
|
| ``` |
| $ python run_harness.py --solution |
| tbdl-access-log-report 1.0 10/10 |
| tbdl-git-recovery 1.0 10/10 |
| tbdl-csv-canon 1.0 8/8 |
| tbdl-build-repair 1.0 4/4 |
| resolved 4/4 (100.0%) |
| |
| $ python run_harness.py --baseline -> 0/4 |
| $ python run_harness.py --predictions predictions/partial.jsonl |
| tbdl-access-log-report 0.0 9/10 p95 off by one rank |
| tbdl-git-recovery 0.0 5/10 wrong revision, no wip rescue |
| tbdl-csv-canon 0.0 5/8 BOM kept, rows unsorted |
| tbdl-build-repair 0.0 1/4 shell fixed, Python faults left |
| resolved 0/4 (0.0%) |
| ``` |
|
|
| The partial control is the important one: each attempt is a *plausible* half-fix |
| and each still scores zero, while the per-test counts show the verifier is |
| grading the whole task rather than one easy assertion. |
|
|
| `build_dataset.py` refuses to write a row when a task already passes with no |
| agent at all, and it re-runs the finished JSONL through the harness in both |
| modes, so the file cannot drift from its verification. |
|
|
| ## Budget |
|
|
| Measured for `max_tokens = 2048`, `context = 240000`: |
|
|
| - instruction: 1.3k–2.4k characters (~350–600 tokens) per task |
| - whole dataset: 52.5 KiB ≈ 13.4k tokens, so all four rows fit in one context |
| - each task is solvable with many short turns: the oracle scripts are 40–90 |
| lines total, so no single completion needs more than ~1k tokens |
|
|
| ## Deliberate deviations |
|
|
| - **`setup.sh` instead of a Dockerfile.** The Dockerfile is still shipped in the |
| row for fidelity, but the environment is rebuilt by a script so the benchmark |
| runs on a laptop with no daemon. |
| - **Host toolchain, not a pinned image.** Tasks are written against |
| `bash` + `git` + `python` + coreutils only, and the verifier avoids symlinks, |
| signals, `/proc` and permission bits so it behaves the same on Linux, macOS and |
| Windows/Git Bash. |
| - **`agent_script` predictions.** A full Terminal-Bench harness drives a model |
| turn by turn; here a prediction is the script that performs the same actions, |
| which makes the benchmark reproducible without an inference loop. |
| - **Static `reward`.** Multi-step tasks and `multi_step_reward_strategy` are not |
| used; every task is single-step with an all-or-nothing reward. |
| |
| ## Platform note |
| |
| On Windows, `bash` on `PATH` is often the WSL launcher. The harness resolves a |
| real POSIX shell (Git Bash), proves it works with a probe, and exports it to the |
| verifier as `TB_BASH`; verifier code that shells out should use |
| `os.environ.get("TB_BASH", "bash")`. A `python3` shim is placed in `$TB_ROOT/bin` |
| so scripts with `#!/usr/bin/env python3` run unchanged. |
