Datasets:

noodcon
/

TerminalBench-DockerLess

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

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.