File size: 7,731 Bytes
b199558 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | ---
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. |