Publish tmax conversion with complete task files and resumable image builder

README.md

@@ -0,0 +1,95 @@
+---
+dataset_info:
+  features:
+  - name: messages
+    list:
+    - name: content
+      dtype: string
+    - name: role
+      dtype: string
+  - name: ground_truth
+    dtype: string
+  - name: dataset
+    dtype: string
+  - name: env_config
+    struct:
+    - name: env_name
+      dtype: string
+    - name: image
+      dtype: string
+    - name: task_id
+      dtype: string
+  - name: source
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 21228188
+    num_examples: 5431
+  download_size: 5213319
+  dataset_size: 21228188
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*
+license: cc-by-4.0
+language:
+- en
+tags:
+- tmax
+- terminal
+- agents
+- reinforcement-learning
+---
+
+# CalibForge for tmax
+
+**Images available:** this conversion reuses verified public upstream images pinned by digest.
+
+All **5,431** task directories from [AweAI-Team/CalibForge](https://huggingface.co/datasets/AweAI-Team/CalibForge), pinned to `fb1e75441a94b8bb0ced08acd6b59e711704d70a`, converted to tmax's `swerl_vanillux_sandbox` format.
+
+The train split uses the same `messages`, `ground_truth`, `dataset`, `env_config`, and `source` schema as the other `hamishivi/agent-task-*` datasets. Messages use the tmax Vanillux templates; `dataset` is `passthrough`. Task IDs are prefixed with `calibforge__` to avoid collisions when combining task archives. `task-manifest.json` maps them back to original paths.
+
+`task-data.tar.gz` contains a directory per task with all original task files preserved byte-for-byte, plus `image.txt`. Instructions, verifiers, build contexts, metadata, and reference solutions are retained. The tmax loader exposes only environment seed files and defers tests until submission; reference solutions are not mounted into the agent sandbox.
+
+## Usage
+
+```python
+from datasets import load_dataset
+from huggingface_hub import hf_hub_download
+
+train = load_dataset("hamishivi/agent-task-calibforge", split="train")
+archive = hf_hub_download("hamishivi/agent-task-calibforge", "task-data.tar.gz", repo_type="dataset")
+```
+
+Extract the archive and set the sandbox `task_data_dir` to the directory containing the task directories. Every row specifies its image explicitly. Task resource requirements and verifier timeouts remain in the original `task.toml`; configure the training harness accordingly.
+
+## Images
+
+The 5,431 public upstream image references are reused and pinned by registry digest. Image manifests were verified accessible before publication.
+
+## Validation and attribution
+
+All rows passed schema and Parquet round-trip checks, and every archived task file was checked against the downloaded source bytes. See `validation.json`. This does not constitute an evaluation of every task or a full training run.
+
+The upstream license is cc-by-4.0. Consult the upstream dataset card for citation and provenance. tmax Vanillux prompts are adapted from mini-swe-agent (MIT).
+
+## Reproducibility and runtime coverage
+
+This conversion targets `hamishivi/tmax-private`, branch `geomean_mask`, commit `9fff7af6e86f2589830637772ff5b10b1c080131`. All original task files are preserved; added task IDs, training rows, and image references adapt the packaging for tmax. See `UPSTREAM_README.md` for the source authors' attribution and citation details.
+
+Validation covers all task records and archived file contents. No container build or runtime task evaluation was performed for this release. Upstream validation claims do not replace testing in your training harness.
+
+## Resumable image builds
+
+Requires Docker Buildx and a Docker Hub login with write access to the target image repository. The script skips published tags and digest-pinned upstream images, saves per-image logs, and retries unfinished builds on the next run.
+
+```sh
+mkdir -p tasks
+tar -xzf task-data.tar.gz -C tasks
+python build_dataset_images.py --task-data-dir tasks --manifest task-manifest.json --workers 8 --timeout 1800
+```
+
+Images built by this script target Linux AMD64. If using another Docker Hub namespace, update image references consistently in the manifest, training records, and task `image.txt` files. The image status file is a publication-time snapshot.
+
+Extract CalibForge on a case-sensitive filesystem (standard Linux filesystems work). One upstream task contains distinct fixtures named `n_structure_capitalized_TRUE.json` and `n_structure_capitalized_True.json`; both are preserved in this archive.

UPSTREAM_README.md

@@ -0,0 +1,110 @@
+---
+pretty_name: CalibForge
+language:
+- en
+size_categories:
+- 1K<n<10K
+tags:
+- terminal
+- bash
+- code
+- docker
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: metadata.jsonl
+---
+
+# CalibForge
+
+[![GitHub](https://img.shields.io/badge/GitHub-Repo-181717?logo=github&logoColor=white)](https://github.com/AweAI-Team/CalibForge)
+[![Hugging Face Datasets](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Datasets-blue)](https://huggingface.co/datasets/AweAI-Team/CalibForge)
+[![Scaffold](https://img.shields.io/badge/%F0%9F%8F%97%EF%B8%8F%20Scaffold-AweAgent-orange.svg)](https://github.com/AweAI-Team/AweAgent/tree/main/recipes/terminal_bench_v2)
+[![License](https://img.shields.io/badge/License-CC%20BY%204.0-green.svg)](LICENSE)
+
+<p align="center">
+  <img src="figures/abstract.png" width="100%" />
+</p>
+
+CalibForge is a collection of 5,431 executable and verifiable terminal-agent tasks constructed with adversarial solver calibration.
+
+CalibForge uses solver behavior during task construction in two complementary ways:
+
+- **Multi-solver calibration** retains tasks that expose disagreement across a heterogeneous solver pool.
+- **Contrastive solver calibration** targets a designated strong-pass and weak-fail capability relation.
+
+## Dataset structure
+
+```text
+CalibForge/
+├── README.md
+├── metadata.jsonl
+├── image_mapping.jsonl
+├── multi_solver/
+│   └── <task_id>/
+│       ├── instruction.md
+│       ├── task.toml
+│       ├── environment/
+│       └── tests/
+└── contrastive_solver/
+    └── <task_id>/
+        ├── instruction.md
+        ├── task.toml
+        ├── environment/
+        └── tests/
+```
+
+| Subset | Calibration criterion | Tasks |
+|:--|:--|--:|
+| `multi_solver` | At least one solver succeeds and at least one solver fails | 1,263 |
+| `contrastive_solver` | The stronger solver succeeds and the designated weaker solver fails | 4,168 |
+| **Total** |  | **5,431** |
+
+Every task directory contains:
+
+- `instruction.md`: the instruction shown to the terminal agent.
+- `task.toml`: task metadata, timeouts, resource requirements, and the public Docker image reference.
+- `environment/`: the Dockerfile and files needed to reproduce the task environment.
+- `tests/`: the verifier entry point and its supporting files.
+
+Each task directory is stored in Harbor style.
+
+## Docker environments
+
+The exact image for each task is recorded in its `task.toml` and in `image_mapping.jsonl`.
+
+For example:
+
+```bash
+docker pull \
+  aweaiteam/calibforge:data-processing_20260415_002933_001_20260514_013004_644492
+```
+
+To inspect a task image interactively:
+
+```bash
+TASK=contrastive_solver/data-processing_20260415_002933_001
+IMAGE=$(python - <<'PY'
+import tomllib
+
+with open("contrastive_solver/data-processing_20260415_002933_001/task.toml", "rb") as f:
+    print(tomllib.load(f)["environment"]["docker_image"])
+PY
+)
+docker run --rm -it "$IMAGE" bash
+```
+
+## Download
+
+Download the complete repository with `huggingface_hub`:
+
+```python
+from huggingface_hub import snapshot_download
+
+snapshot_download(
+    repo_id="AweAI-Team/CalibForge",
+    repo_type="dataset",
+    local_dir="CalibForge",
+)
+```

build_dataset_images.py

@@ -0,0 +1,90 @@
+"""Build missing images from an extracted tmax task archive, with resumable logs.
+
+Example:
+  python build_dataset_images.py --task-data-dir ./tasks --manifest task-manifest.json
+
+Requires Docker Buildx and a Docker Hub login with write access to image repos.
+Targets Linux AMD64; leaves source task files and verifiers unchanged.
+"""
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import json
+from pathlib import Path
+import subprocess
+import time
+import urllib.error
+import urllib.request
+
+
+def existing_tags(repository):
+    url = f'https://hub.docker.com/v2/repositories/{repository}/tags?page_size=100'
+    tags = set()
+    while url:
+        try:
+            with urllib.request.urlopen(url, timeout=30) as response:
+                data = json.load(response)
+        except urllib.error.HTTPError as exc:
+            if exc.code == 404:
+                return tags
+            raise
+        tags.update(item['name'] for item in data['results'])
+        url = data.get('next')
+    return tags
+
+
+def build(entry, args):
+    image = entry['image']
+    name = image.rsplit(':', 1)[-1]
+    state = args.log_dir / f'{name}.json'
+    if not args.force and state.exists() and json.loads(state.read_text()).get('ok'):
+        return dict(image=image,ok=True,skipped=True)
+    context = args.task_data_dir / entry['task_id'] / 'environment'
+    assert (context / 'Dockerfile').is_file(), str(context)
+    log = args.log_dir / f'{name}.log'
+    metadata = args.log_dir / f'{name}.metadata.json'
+    command = ['docker','buildx','build','--platform',args.platform,'--provenance=false','--push','--metadata-file',str(metadata),'-t',image]
+    if args.builder:
+        command += ['--builder',args.builder]
+    command.append(str(context))
+    start = time.monotonic()
+    try:
+        with log.open('w') as output:
+            proc = subprocess.run(command,stdout=output,stderr=subprocess.STDOUT,timeout=args.timeout)
+        result = dict(image=image,task_id=entry['task_id'],ok=proc.returncode==0,exit_code=proc.returncode,seconds=round(time.monotonic()-start,2))
+        if result['ok']:
+            result['digest'] = json.loads(metadata.read_text())['containerimage.digest']
+    except subprocess.TimeoutExpired:
+        result = dict(image=image,task_id=entry['task_id'],ok=False,error='build timeout')
+    state.write_text(json.dumps(result,indent=2)+'\n')
+    return result
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--task-data-dir',required=True,type=Path)
+    parser.add_argument('--manifest',default=Path('task-manifest.json'),type=Path)
+    parser.add_argument('--log-dir',default=Path('image-build-logs'),type=Path)
+    parser.add_argument('--workers',default=8,type=int)
+    parser.add_argument('--timeout',default=900,type=int)
+    parser.add_argument('--platform',default='linux/amd64')
+    parser.add_argument('--builder')
+    parser.add_argument('--max-images',type=int)
+    parser.add_argument('--force',action='store_true')
+    args = parser.parse_args()
+    args.log_dir.mkdir(parents=True,exist_ok=True)
+    entries = list({r['image']:r for r in json.loads(args.manifest.read_text()) if '@sha256:' not in r['image']}.values())
+    if not args.force:
+        repos = {r['image'].rsplit(':',1)[0] for r in entries}
+        published = {f'{repo}:{tag}' for repo in repos for tag in existing_tags(repo)}
+        entries = [r for r in entries if r['image'] not in published]
+    if args.max_images is not None:
+        entries = entries[:args.max_images]
+    print(f'{len(entries)} missing image(s) to build',flush=True)
+    failures = 0
+    with ThreadPoolExecutor(max_workers=args.workers) as pool:
+        for future in as_completed([pool.submit(build,entry,args) for entry in entries]):
+            result = future.result()
+            failures += not result['ok']
+            print(json.dumps(result),flush=True)
+    print(f'Complete: {failures} failed build(s); rerun to retry.',flush=True)
+    raise SystemExit(bool(failures))

data/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b81dcfd174d086faa4aa4d94727b89a628a9a6769f02a23179d817fac1f953f9
+size 5213319

image-build-status.json

@@ -0,0 +1,7 @@
+{
+  "task_counts_by_image_status": {
+    "verified_public_upstream": 5431
+  },
+  "unique_images": 5341,
+  "builds_run_for_this_release": false
+}

task-data.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79672cdec29ec9160b663e99dd0bb17be656c74756dea59c68a4fe2d285abb80
+size 510167808

validation.json

@@ -0,0 +1,19 @@
+{
+  "source": "AweAI-Team/CalibForge",
+  "source_revision": "fb1e75441a94b8bb0ced08acd6b59e711704d70a",
+  "rows": 5431,
+  "unique_task_ids": 5431,
+  "preserved_task_files": 47132,
+  "archive_sha256": "79672cdec29ec9160b663e99dd0bb17be656c74756dea59c68a4fe2d285abb80",
+  "parquet_sha256": "b81dcfd174d086faa4aa4d94727b89a628a9a6769f02a23179d817fac1f953f9",
+  "schema_reference": "hamishivi/agent-task-endless-terminals",
+  "schema_reference_revision": "cb36a05d834fa31a6cc983a89245c11c48141db9",
+  "checks": [
+    "unique task IDs",
+    "reference schema equality",
+    "Parquet round-trip equality",
+    "all task files preserved byte-for-byte",
+    "no unresolved Git LFS pointers",
+    "archive checksum validation"
+  ]
+}