Release corrected SmolCUA v1.1 with cached batching and live progress

Preserve original v1.0; add audited corrected dataset, pretokenization/cache schema 2, greedy cached batching with OOM backoff and last-position logits, live measured progress, and strict self-scoring. Validated with 38 local tests and tiny-model CPU inference parity.

LOCAL_CHANGES.md

@@ -0,0 +1,50 @@
+# Local corrected SmolCUA edition
+
+The benchmark suite uses **SmolCUA v1.1 / local-corrected**. This corrected revision was prepared in the benchmark workspace and retains the `local-corrected` edition identifier for reproducibility. Original v1.0 files remain under `runs/v1_seed_20261023`. Use a new output directory when switching editions. The toolkit defaults to corrected v1.1; original v1.0 is available via `--run-subdir runs/v1_seed_20261023`.
+
+## Question repairs
+
+250 of 5,000 prompts were corrected, 50 in each group:
+
+- TSV: restore the missing three fields, their order, and delimiter requirements.
+- Safe inset: state the missing horizontal/vertical inset and reference edges.
+- Percentage coordinates: state the missing percentages and top-left origin.
+- Scroll offset: explicitly request viewport coordinates.
+- Markdown table: explicitly require Name then Count column order.
+
+Missing values were reconstructed during dataset authoring from the existing authored answer keys. The inference runner never reads keys to construct prompts or choose answers. Options, correct labels, response contracts, per-pass/category counts, and weights remain unchanged. The repaired specifications were checked against the existing choices. This targeted audit is not an exhaustive manual review of all question semantics.
+
+`runs/v1_1_seed_20261023/corrections.json` records every ID and before/after prompt. The new manifest records the original and corrected question hashes, label/weight hashes, edition, and correction count. Per-pass files agree with the combined dataset. Corrected scores are not interchangeable with original v1.0 scores. The original weights are retained for continuity; they have not been recalibrated for the clearer wording.
+
+Rebuild deterministically from the original files:
+
+```sh
+python3 SmolCUA_v1_0/repair_dataset.py
+```
+
+## Runner and scorer fixes
+
+- Reject partial `--score` requests before loading weights or generating responses.
+- Check all compiled prompts against the context limit before Transformers model allocation; preserve the no-truncation policy.
+- Include context limit and manifest hash in resume metadata, and reject incompatible resumes.
+- Reject unknown/duplicate result IDs, malformed resumed answers, and incomplete inference instead of claiming completion.
+- Reject duplicate JSON object keys under the strict response contract.
+- Detect duplicate dataset IDs, invalid answer labels, nonfinite/nonpositive weights, and scoring-file hash mismatches.
+- Report the actual reliability denominator and identify the edition/hash in scores.
+
+Reference-answer scoring reaches 100/100 for weighted score and worst-pass reliability across all 5,000 questions; empty predictions score zero. These are scorer checks, not model results. Geometry repairs are checked by independently computing targets from the repaired prompts. Tests cover resume, context preflight, incomplete inference, and strict parsing.
+
+## Run the local edition
+
+From the workspace root:
+
+```sh
+python SmolCUA_v1_0/run_smolcua.py --model YOUR_MODEL \
+  --backend transformers --prompt-mode plain \
+  --run-dir SmolCUA_v1_0/runs/v1_1_seed_20261023 \
+  --max-model-len 4096 --output-dir results/smolcua-corrected --score
+```
+
+`./benchmark` runs this edition automatically on the prepared Void snapshot. Generation budgets are 48 bytes for short contracts, 192 for JSON choice-with-text, and 512 for raw payloads with the Void byte tokenizer. The corrected prompts and budgets fit its 4096-byte context. SmolCUA scores stay outside the Open SLM Intelligence Index.
+
+No GPU throughput or full real-model benchmark scores have been validated. The toolkit also provides cached batched inference, last-position logits where supported, CUDA OOM backoff, and measured live progress.

README.md

@@ -1,3 +1,120 @@
 ---
+pretty_name: SmolCUA — Computer-Use Aptitude
 license: apache-2.0
+language:
+  - en
+task_categories:
+  - text-generation
+tags:
+  - benchmark
+  - computer-use
+  - instruction-following
+  - small-language-models
+  - reliability
+size_categories:
+  - 1K<n<10K
+configs:
+  - config_name: default
+    data_files:
+      - split: test
+        path: runs/v1_1_seed_20261023/questions_all_passes.jsonl
+  - config_name: original_v1_0
+    data_files:
+      - split: test
+        path: runs/v1_seed_20261023/questions_all_passes.jsonl
 ---
+
+# SmolCUA — Computer-Use Aptitude
+
+SmolCUA evaluates text-based computer-use reasoning: tool selection, next actions,
+strategy switching, instruction following, ambiguity, coding, structured output,
+coordinates, multi-constraint formatting, and state tracking. It is a synthetic
+text benchmark, not live UI automation or a visual computer-use environment.
+
+**1,000 questions per pass, five passes, 5,000 total.** Each question contains four
+options and an explicit response contract. Models generate the answer; there is
+no forced-choice logit shortcut, output repair, or answer extraction.
+
+## Current edition
+
+The default is **corrected v1.1**, recorded as `edition: local-corrected` in its
+manifest for continuity with the local audit. It repairs 250 incomplete or
+ambiguous prompts across five templates. Original v1.0 data remains available in
+`runs/v1_seed_20261023` and the `original_v1_0` dataset configuration. Options,
+answer labels, and weights are unchanged. The editions have different hashes;
+**do not report corrected scores as original v1.0 scores**.
+
+See [LOCAL_CHANGES.md](LOCAL_CHANGES.md) and the per-question
+[corrections](runs/v1_1_seed_20261023/corrections.json). Restored specifications were
+reconstructed during dataset authoring from the original authored answer keys.
+Inference never uses those keys to construct prompts or select answers.
+
+## Run
+
+Download this repository's toolkit files, then:
+
+```sh
+pip install -r requirements-transformers.txt
+python run_smolcua.py --model YOUR_ORG/YOUR_MODEL --backend transformers \
+  --dataset dotlabs/smolcua --prompt-mode plain --max-model-len 4096 \
+  --output-dir results/my-model --score
+```
+
+`plain` is appropriate for base models and provides zero-shot prompts. Use
+`--prompt-mode auto` or `chat` for instruction-tuned models with chat templates.
+There are no few-shot exemplars in either mode. `--dataset-revision COMMIT` pins
+the dataset; `--revision COMMIT` pins model/tokenizer loading.
+
+The repository is a public **self-scoring edition**, including files under
+`private/` for evaluation. The directory name does not make them confidential.
+It is not a blind leaderboard. Disclose exposure to answer keys when reporting
+results; do not use test questions/keys for training.
+
+## Pretokenization and inference
+
+- All selected prompts are compiled in CPU batches before Transformers model
+  weights are loaded. The cache key includes actual prompt contents, dataset
+  identity, tokenizer vocabulary/configuration, and prompt formatting.
+- Cache hits reuse exact input IDs. No prompt truncation is allowed.
+- Transformers uses length/budget buckets, greedy cached decoding, a default
+  batch size of 32, and CUDA OOM backoff down to one. Supported models compute
+  only the last-position logits during generation.
+- Tokenization, model loading, prefill, decode tokens, completed questions,
+  elapsed time, throughput, and ETA appear in flushed progress logs. Long calls
+  get heartbeat updates; no fabricated completion percentage is shown.
+- EOS counts as a generated token; padding after a completed sequence does not.
+  Raw response text is not printed in progress logs.
+- vLLM supports pretokenized inputs and its native generation progress. API
+  mode uses concurrent requests and server-side tokenization.
+
+```sh
+# Compile prompts without allocating model weights:
+python run_smolcua.py --model YOUR_MODEL --pretokenize-only --prompt-mode plain
+
+# Larger batches; CUDA OOM backoff preserves completed answers:
+python run_smolcua.py --model YOUR_MODEL --backend transformers \
+  --batch-size 64 --progress-interval 5 --output-dir results/model --score
+```
+
+Performance depends on model, hardware, padding, and output lengths. Batched
+floating-point inference can differ from single-item inference near logit ties;
+record the batch size and precision. This release does not claim a measured GPU
+speedup. See [RUNNING_AND_PUBLISHING.md](RUNNING_AND_PUBLISHING.md) for settings.
+
+## Scores and outputs
+
+- Mean weighted score (0–100), with category-specific weights.
+- Worst-pass exact-answer reliability: `100 * min(correct per pass) / 1000`.
+- Per-pass, category, response-format, and consistency breakdowns.
+- Raw answers, dataset hash/edition, configuration, token-cache statistics,
+  actual token counts, generation batching statistics, and throughput.
+
+Output files are `predictions.jsonl`, `run_metadata.json`, `performance.json`,
+and `score.json`. `--score` requires all 5,000 responses; partial requests are
+rejected before model loading. The standalone scorer can assess missing answers
+as incorrect. Strict JSON contracts reject duplicate keys.
+
+Weights are research-informed and have not been calibrated against a large
+representative model sample. v1.1 retains v1.0 weights despite clearer wording.
+Reference-answer and empty-answer tests validate scorer behavior; they are not
+model performance results.

RUNNING_AND_PUBLISHING.md

@@ -0,0 +1,94 @@
+# Running and publishing SmolCUA
+
+## Transformers
+
+```sh
+pip install -r requirements-transformers.txt
+python run_smolcua.py --model YOUR_MODEL --backend transformers \
+  --prompt-mode plain --max-model-len 4096 --batch-size 32 \
+  --dataset dotlabs/smolcua --output-dir results/model --score
+```
+
+The default dataset is corrected v1.1 (`runs/v1_1_seed_20261023`). To evaluate
+original v1.0, explicitly pass `--run-subdir runs/v1_seed_20261023`. For a local
+copy, use `--run-dir runs/v1_1_seed_20261023`. Keep editions separate.
+
+The default short response budget is 48 tokens, JSON choice-with-text uses up to
+192, and raw payloads use 512. These are model tokens, which are bytes for Void.
+`--max-model-len` covers prompt plus output for decoder-only models. Prompts
+are never truncated. All prompts are checked before Transformers weights load.
+
+Batches group equal generation budgets and similar input lengths. Generation
+uses greedy decoding and KV caching; models explicitly supporting
+`logits_to_keep`/`num_logits_to_keep` receive a value of one. CUDA OOM reduces the
+batch size and retries only the unsuccessful batch. Other errors propagate.
+Use `--batch-size 1` for single-item comparisons.
+
+## Progress and performance
+
+Progress is written to stderr with flushing, so it works in notebooks, terminals,
+and remote logs. `--progress-interval 5` controls periodic updates; `--quiet`
+suppresses them. Counts measure actual compiled prompts, completed questions,
+and decode tokens. Prefill/model-loading heartbeats show the current stage even
+before the first token arrives. ETA uses completed-item throughput including
+startup cost, and can change as question types and output lengths change.
+
+Generation tokens exclude padding after EOS. Batch/padding/OOM statistics are in
+`performance.json`. Progress counts for a resumed run refer to remaining work;
+performance metadata distinguishes previous responses from new ones.
+
+## Token cache
+
+```sh
+python run_smolcua.py --model YOUR_MODEL --pretokenize-only \
+  --prompt-mode plain --dataset dotlabs/smolcua
+```
+
+The cache is model-specific and content-addressed at `~/.cache/smolcua/tokens`.
+Use `--token-cache-dir PATH`, `--rebuild-token-cache`, or `--no-token-cache`.
+`--tokenize-batch-size` controls CPU encoding batches (default 512). Cache schema
+2 invalidates older caches and includes actual prompt content in its identity.
+
+## Resume
+
+Rerun the same command with `--resume`. The output directory's configuration,
+context limit, and manifest hash must match. Completed answers are checkpointed
+atomically. Failed/incomplete runs do not claim completion. Changing settings or
+model contents requires a new output directory; prefer immutable model revisions.
+
+## vLLM and API
+
+```sh
+pip install -r requirements-vllm.txt
+python run_smolcua.py --model YOUR_MODEL --backend vllm \
+  --batch-size 256 --output-dir results/vllm --score
+
+pip install -r requirements-api.txt
+python run_smolcua.py --model SERVER_MODEL --backend api \
+  --endpoint http://localhost:8000/v1 --api-concurrency 16 \
+  --output-dir results/api --score
+```
+
+vLLM receives compiled token IDs; its native progress reports generation.
+API endpoints receive text and tokenize server-side. API progress can report
+completed requests and returned token usage, not internal server decode steps.
+For API mode, `plain` still uses a chat-completions user message containing the
+plain prompt, so this is not equivalent to a raw completions endpoint.
+
+## Publishing
+
+`publish_smolcua.py` accepts only benchmark sources, documentation, approved
+question/manifest files, correction logs, and self-score keys/weights. Build a
+clean staging folder; do not include token caches, model checkpoints, generated
+responses, credentials, `.DS_Store`, or Python bytecode. Unknown files and
+symlinks are rejected.
+
+```sh
+python publish_smolcua.py --repo dotlabs/smolcua --folder /path/to/clean-release
+python publish_smolcua.py --repo dotlabs/smolcua --folder /path/to/clean-release --publish
+```
+
+Existing repository access settings are preserved. `--gated auto` or
+`--gated manual` changes gating only when explicitly requested. A directory
+called `private` does not enforce confidentiality on the Hub; this package is
+intentionally self-scoring. Review the file list before uploading.

inference_runtime.py

@@ -0,0 +1,174 @@
+"""Shared batched generation and measured, log-friendly progress (no prompt text)."""
+import gc
+import inspect
+import sys
+import threading
+import time
+from itertools import groupby
+
+from token_cache import padded_batch
+
+
+class Progress:
+    def __init__(self, label, total=0, quiet=False, interval=5):
+        self.label, self.total, self.quiet = label, total, quiet
+        self.interval = interval
+        self.done = self.tokens = 0
+        self.stage = 'starting'
+        self.started = time.monotonic()
+        self.last = 0.0
+        self.lock = threading.RLock()
+        self.stop = threading.Event()
+
+    def update(self, stage=None, done=None, tokens=None, force=False):
+        with self.lock:
+            if stage is not None:
+                self.stage = stage
+            if done is not None:
+                self.done = done
+            if tokens is not None:
+                self.tokens = tokens
+            self.render(force)
+
+    def render(self, force=False):
+        now = time.monotonic()
+        if self.quiet or (not force and now-self.last < self.interval):
+            return
+        self.last = now
+        elapsed = max(now-self.started, 1e-6)
+        rate = self.done/elapsed
+        eta = f'{(self.total-self.done)/rate:.0f}s' if rate and self.total else 'pending'
+        print(f'{self.label}: {self.stage} | {self.done}/{self.total} complete | '
+              f'{self.tokens} generated tokens | {rate:.2f}/s | elapsed {elapsed:.0f}s | ETA {eta}',
+              file=sys.stderr, flush=True)
+
+    def __enter__(self):
+        self.update(force=True)
+        def heartbeat():
+            while not self.stop.wait(self.interval):
+                with self.lock:
+                    self.render()
+        self.thread = threading.Thread(target=heartbeat, daemon=True)
+        if not self.quiet:
+            self.thread.start()
+        return self
+
+    def __exit__(self, kind, value, tb):
+        self.stop.set()
+        if self.thread.is_alive():
+            self.thread.join(timeout=1)
+        self.update(stage='failed' if kind else 'finished', force=True)
+
+
+def eos_ids(model, tokenizer):
+    value = getattr(model.generation_config, 'eos_token_id', None)
+    if value is None:
+        value = tokenizer.eos_token_id
+    return set(value if isinstance(value, (list, tuple)) else [] if value is None else [value])
+
+
+class TokenProgress:
+    """Transformers streamer: count actual decode steps without decoding text."""
+    def __init__(self, progress, batch_size, eos, base_tokens=0):
+        self.progress = progress
+        self.active = [True]*batch_size
+        self.eos = eos
+        self.first = True
+        self.count = 0
+        self.base = base_tokens
+
+    def put(self, value):
+        if self.first:  # Initial prompt (or decoder-start IDs), not generated tokens.
+            self.first = False
+            return
+        values = value.tolist()
+        for i, token in enumerate(values):
+            if self.active[i]:
+                self.count += 1
+                if token in self.eos:
+                    self.active[i] = False
+        self.progress.update(stage='decoding', tokens=self.base+self.count)
+
+    def end(self):
+        pass
+
+
+def trim_after_eos(sequences, eos):
+    result = []
+    for tokens in sequences:
+        end = next((i+1 for i,t in enumerate(tokens) if t in eos), len(tokens))
+        result.append(tokens[:end])
+    return result
+
+
+def generate_batches(model, tokenizer, compiled, rows, budget_for, batch_size, emit,
+                     progress, is_seq2seq=False, keep_special_tokens=False):
+    """Length/budget buckets, KV cache, greedy decoding, and CUDA OOM backoff."""
+    import torch
+    ordered = sorted(rows, key=lambda q: (budget_for(q), len(compiled[q['id']]['input_ids'])))
+    eos = eos_ids(model, tokenizer)
+    done = tokens_done = 0
+    effective_batch = batch_size
+    stats = dict(batches=0, oom_retries=0, generated_tokens=0, input_tokens=0, padded_input_tokens=0)
+    # Models exposing this documented optimization need only the next-token logits
+    # during generation, not a vocabulary projection for every prefill position.
+    generation_options = {}
+    forward = getattr(model, 'forward', None)
+    if forward is not None and not is_seq2seq:
+        parameters = inspect.signature(forward).parameters
+        for name in ('logits_to_keep', 'num_logits_to_keep'):
+            if name in parameters:
+                generation_options[name] = 1
+                break
+    stats['last_token_logits'] = bool(generation_options)
+
+    def generate(group, budget):
+        data = padded_batch([compiled[q['id']] for q in group], tokenizer.pad_token_id, tokenizer.padding_side)
+        width = data['input_ids'].shape[1]
+        device = model.get_input_embeddings().weight.device
+        data = {k:v.to(device) for k,v in data.items()}
+        progress.update(stage=f'prefill batch={len(group)} input_width={width}', force=True)
+        stream = TokenProgress(progress, len(group), eos, tokens_done)
+        # Explicit defaults prevent a checkpoint's sampling/beam config changing the task.
+        output = model.generate(**data, max_new_tokens=budget, do_sample=False, num_beams=1,
+                                num_return_sequences=1, pad_token_id=tokenizer.pad_token_id,
+                                use_cache=True, streamer=stream, return_dict_in_generate=False,
+                                output_scores=False, **generation_options)
+        prefix = 1 if is_seq2seq else width
+        sequences = trim_after_eos(output[:, prefix:].tolist(), eos)
+        answers = tokenizer.batch_decode(sequences, skip_special_tokens=not keep_special_tokens,
+                                         clean_up_tokenization_spaces=False)
+        if len(answers) != len(group):
+            raise RuntimeError('Generation returned an unexpected number of sequences')
+        return answers, [len(s) for s in sequences], width
+
+    with torch.inference_mode():
+        for budget, family in groupby(ordered, key=budget_for):
+            family = list(family)
+            offset = 0
+            while offset < len(family):
+                group = family[offset:offset+effective_batch]
+                try:
+                    answers, lengths, width = generate(group, budget)
+                except torch.cuda.OutOfMemoryError:
+                    if len(group) == 1:
+                        raise
+                    effective_batch = max(1, len(group)//2)
+                    stats['oom_retries'] += 1
+                    progress.update(stage=f'CUDA OOM; retry batch={effective_batch}', tokens=tokens_done, force=True)
+                else:
+                    emit([(q['id'], text, length) for q,text,length in zip(group,answers,lengths)])
+                    done += len(group)
+                    tokens_done += sum(lengths)
+                    stats['batches'] += 1
+                    stats['input_tokens'] += sum(len(compiled[q['id']]['input_ids']) for q in group)
+                    stats['padded_input_tokens'] += width*len(group)
+                    progress.update(stage='batch saved', done=done, tokens=tokens_done, force=True)
+                    offset += len(group)
+                    continue
+                # Release the exception traceback (and its tensors) before GC.
+                gc.collect()
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+    stats.update(generated_tokens=tokens_done, final_batch_size=effective_batch)
+    return stats

publish_smolcua.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""Publish a prepared SmolCUA dataset folder to Hugging Face (opt-in)."""
+from __future__ import annotations
+import argparse
+from pathlib import Path
+
+
+def files_in(root):
+    # Only pre-approved benchmark files are eligible for upload.
+    # This prevents accidentally leaking local token caches, model responses,
+    # user credentials or debug traces when using the folder as a workdir.
+    allowed_root = {'README.md', 'RUNNING_AND_PUBLISHING.md', 'run_smolcua.py',
+                    'token_cache.py', 'score_smolcua.py', 'response_formats.py',
+                    'publish_smolcua.py', 'inference_runtime.py', 'repair_dataset.py',
+                    'LOCAL_CHANGES.md', 'requirements-vllm.txt',
+                    'requirements-transformers.txt', 'requirements-api.txt'}
+    allowed_run = {'manifest.json', 'questions_all_passes.jsonl', 'corrections.json'} | {
+        f'pass_{i:02d}_questions.jsonl' for i in range(1, 6)}
+    allowed_private = {'answers_all_passes.jsonl', 'weights_all_passes.jsonl'}
+    included = []
+    for f in sorted(root.rglob('*')):
+        if f.is_symlink():
+            raise ValueError(f'Symlinks are not allowed in upload folder: {f}')
+        if not f.is_file():
+            continue
+        parts = f.relative_to(root).parts
+        approved = (len(parts) == 1 and parts[0] in allowed_root or
+                    len(parts) == 3 and parts[0] == 'runs' and parts[1] in ('v1_seed_20261023', 'v1_1_seed_20261023')
+                    and parts[2] in allowed_run or
+                    len(parts) == 4 and parts[0] == 'runs' and parts[1] in ('v1_seed_20261023', 'v1_1_seed_20261023') and parts[2] == 'private'
+                    and parts[3] in allowed_private)
+        if approved:
+            included.append(str(f.relative_to(root)))
+        else:
+            raise ValueError(f'Unrecognized file in upload folder: {f}. '
+                             'Remove local cache/results before publishing.')
+    return included
+
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--repo',default='dotlabs/smolcua')
+    p.add_argument('--folder',type=Path,required=True,help='Prebuilt hf_selfscore or hf_blind folder')
+    p.add_argument('--gated',choices=['auto','manual'],default=None,help='Only change gating if explicitly requested')
+    p.add_argument('--publish',action='store_true',help='Actually create and upload; without it only show files')
+    args=p.parse_args()
+    root=args.folder.resolve()
+    if not (root/'README.md').is_file():raise FileNotFoundError('No dataset card: '+str(root/'README.md'))
+    if not (root/'runs'/'v1_seed_20261023'/'questions_all_passes.jsonl').is_file():
+        raise FileNotFoundError('Full questions file missing')
+    print('Dataset:',args.repo,'\nFolder:',root,'\nFiles:')
+    for name in files_in(root):print('  '+name)
+    if not args.publish:
+        print('\nDry run only. Use --publish to perform the actual upload.')
+        return
+    from huggingface_hub import HfApi
+    api=HfApi()
+    api.create_repo(repo_id=args.repo,repo_type='dataset',exist_ok=True)
+    # Preserve the repository's visibility/access policy unless explicitly changed.
+    if args.gated is not None:
+        api.update_repo_settings(repo_id=args.repo,repo_type='dataset',gated=args.gated)
+    api.upload_folder(repo_id=args.repo,repo_type='dataset',folder_path=str(root),
+                      commit_message='Release corrected SmolCUA v1.1 with cached batching and live progress')
+    print('Uploaded to https://huggingface.co/datasets/'+args.repo)
+    print('Verify gated access status in the dataset Settings tab.')
+
+if __name__=='__main__':main()

repair_dataset.py

@@ -0,0 +1,96 @@
+"""Build a local corrected edition; preserve the original v1.0 files.
+
+Missing specifications are reconstructed from the author-provided keyed payloads.
+This is dataset authoring, never inference-time answer access. Every changed ID
+and its original/replacement question is recorded for review.
+"""
+import hashlib
+import json
+import re
+from pathlib import Path
+from decimal import Decimal
+
+from response_formats import unwrap_option
+
+BASE = Path(__file__).resolve().parent
+SOURCE = BASE / 'runs/v1_seed_20261023'
+DEST = BASE / 'runs/v1_1_seed_20261023'
+
+
+def load(path):
+    return [json.loads(line) for line in path.read_text().splitlines() if line.strip()]
+
+
+def save_rows(path, rows):
+    path.write_text(''.join(json.dumps(r, ensure_ascii=False) + '\n' for r in rows))
+
+
+def repair_question(q, answer):
+    text = q['question']
+    payload = unwrap_option(q['options'][answer], q['option_presentation'])
+    skill = q['subskill']
+    if skill == 'tsv_fields':
+        fields = payload.split('\t')
+        if len(fields) != 3:
+            raise ValueError(f'Invalid authored TSV answer: {q["id"]}')
+        spec = ('Produce one TSV record with exactly three fields, in this order: '
+                + ', '.join(f'`{f}`' for f in fields)
+                + '. Separate fields with one literal tab; no header, trailing tab, or extra fields.')
+    elif skill == 'safe_inset':
+        x1, x2, y1, y2 = map(int, re.search(r'x=(\d+)\.\.(\d+), y=(\d+)\.\.(\d+)', text).groups())
+        x, y = map(int, re.fullmatch(r'\((\d+), (\d+)\)', payload).groups())
+        if not x1 < x < x2 or not y1 < y < y2:
+            raise ValueError(f'Authored inset is outside control: {q["id"]}')
+        spec = f'Use a top-left origin. Click exactly {x-x1} pixels right of the left edge and {y-y1} pixels below the top edge. What is the click point?'
+    elif skill == 'percentage_to_pixels':
+        width, height = map(int, re.search(r'(\d+)×(\d+) pixels', text).groups())
+        x, y = map(int, re.fullmatch(r'\((\d+), (\d+)\)', payload).groups())
+        px, py = Decimal(x)*100/width, Decimal(y)*100/height
+        spec = f'With a top-left origin, the target is at {px.normalize():f}% of the width from the left and {py.normalize():f}% of the height from the top. What is its pixel coordinate?'
+    elif skill == 'scroll_offset':
+        spec = 'Convert the given page coordinate to viewport coordinates by subtracting the horizontal and vertical scroll offsets respectively.'
+    elif skill == 'markdown_table':
+        spec = 'The columns must appear in the stated order: Name first, Count second, with the corresponding values in that order.'
+    else:
+        return text
+    # Put the restored specification before the output contract, preserving wrappers.
+    marker = '\n\nFor every option below,' if '\n\nFor every option below,' in text else '\nANSWER CONTRACT:'
+    if marker not in text:
+        raise ValueError(f'Missing answer contract: {q["id"]}')
+    return text.replace(marker, '\n\n' + spec + marker, 1)
+
+
+def main():
+    manifest = json.loads((SOURCE/'manifest.json').read_text())
+    data = (SOURCE/'questions_all_passes.jsonl').read_bytes()
+    if hashlib.sha256(data).hexdigest() != manifest['question_file_sha256']:
+        raise ValueError('Original question hash mismatch')
+    questions = load(SOURCE/'questions_all_passes.jsonl')
+    keys = {r['id']: r for r in load(SOURCE/'private/answers_all_passes.jsonl')}
+    changes = []
+    for q in questions:
+        before = q['question']
+        q['question'] = repair_question(q, keys[q['id']]['answer'])
+        if before != q['question']:
+            changes.append(dict(id=q['id'], subskill=q['subskill'], before=before, after=q['question']))
+    (DEST/'private').mkdir(parents=True, exist_ok=True)
+    save_rows(DEST/'questions_all_passes.jsonl', questions)
+    for p in range(1, manifest['passes']+1):
+        save_rows(DEST/f'pass_{p:02d}_questions.jsonl', [q for q in questions if q['pass']==p])
+    hashes = {}
+    for name in ('answers_all_passes.jsonl', 'weights_all_passes.jsonl'):
+        data = (SOURCE/'private'/name).read_bytes()
+        (DEST/'private'/name).write_bytes(data)
+        hashes[name] = hashlib.sha256(data).hexdigest()
+    manifest.update(version='1.1', edition='local-corrected', source_version='1.0',
+                    source_question_file_sha256=manifest['question_file_sha256'],
+                    question_file_sha256=hashlib.sha256((DEST/'questions_all_passes.jsonl').read_bytes()).hexdigest(),
+                    scoring_file_sha256=hashes, corrected_questions=len(changes),
+                    notes='Local prompt repairs reconstructed from authored answer keys; options, labels and weights unchanged. Not interchangeable with original v1.0 scores.')
+    (DEST/'manifest.json').write_text(json.dumps(manifest, indent=2)+'\n')
+    (DEST/'corrections.json').write_text(json.dumps(changes, indent=2, ensure_ascii=False)+'\n')
+    print(f'Created {DEST}: {len(changes)} corrected questions')
+
+
+if __name__ == '__main__':
+    main()

requirements-api.txt

@@ -0,0 +1,2 @@
+openai>=1.80
+huggingface_hub>=0.32

requirements-transformers.txt

@@ -0,0 +1,4 @@
+torch>=2.2
+transformers>=4.51
+accelerate>=1.0
+huggingface_hub>=0.32

requirements-vllm.txt

@@ -0,0 +1,2 @@
+vllm>=0.10
+huggingface_hub>=0.32

response_formats.py

@@ -0,0 +1,63 @@
+"""SmolCUA v1.0 format parsing, preserved from the benchmark's authoritative scorer."""
+from __future__ import annotations
+import ast
+import json
+import re
+import xml.etree.ElementTree as ET
+LETTERS=('A','B','C','D')
+
+def _unique_object(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError('Duplicate JSON key')
+        result[key] = value
+    return result
+
+def unwrap_option(encoded: str, kind: str) -> str:
+    if kind=='plain':return encoded
+    if kind=='json_envelope':return json.loads(encoded)['candidate']
+    if kind=='xml_envelope':return ET.fromstring(encoded).text or ''
+    if kind=='markdown_quote':return '\n'.join(line[2:] for line in encoded.split('\n'))
+    if kind=='fenced_block':
+        assert encoded.startswith('~~~candidate\n') and encoded.endswith('\n~~~')
+        return encoded[len('~~~candidate\n'):-len('\n~~~')]
+    if kind=='yaml_block':
+        assert encoded.startswith('candidate: |\n')
+        return '\n'.join(line[2:] for line in encoded[len('candidate: |\n'):].split('\n'))
+    if kind=='quoted_string':return json.loads(encoded)
+    if kind=='tagged_section':
+        assert encoded.startswith('BEGIN CANDIDATE\n') and encoded.endswith('\nEND CANDIDATE')
+        return encoded[len('BEGIN CANDIDATE\n'):-len('\nEND CANDIDATE')]
+    if kind=='python_string':
+        assert encoded.startswith('candidate = ')
+        return ast.literal_eval(encoded[len('candidate = '):])
+    raise KeyError(kind)
+
+def parse_response(text: str,kind: str,opts_unwrapped: dict) -> str|None:
+    if not isinstance(text,str):return None
+    if kind=='letter':return text if text in LETTERS else None
+    if kind=='ordinal':return LETTERS[int(text)-1] if text in ('1','2','3','4') else None
+    if kind=='json_choice':
+        try:r=json.loads(text, object_pairs_hook=_unique_object)
+        except (ValueError,TypeError):return None
+        return r['choice'] if isinstance(r,dict) and set(r)=={'choice'} and r['choice'] in LETTERS else None
+    if kind=='json_choice_text':
+        try:r=json.loads(text, object_pairs_hook=_unique_object)
+        except (ValueError,TypeError):return None
+        if not isinstance(r,dict) or set(r)!={'choice','text'}:return None
+        c=r['choice'];return c if c in LETTERS and r['text']==opts_unwrapped[c] else None
+    if kind=='yaml_choice':
+        m=re.fullmatch(r'selected: ([A-D])',text);return m.group(1) if m else None
+    if kind=='xml_choice':
+        m=re.fullmatch(r'<selection>([A-D])</selection>',text);return m.group(1) if m else None
+    if kind=='csv_choice':
+        m=re.fullmatch(r'selected,([A-D])',text);return m.group(1) if m else None
+    if kind=='bracket_choice':
+        m=re.fullmatch(r'\[([A-D])\]',text);return m.group(1) if m else None
+    if kind=='pipe_choice':
+        m=re.fullmatch(r'pick\|([A-D])',text);return m.group(1) if m else None
+    if kind=='raw_payload':
+        matches=[k for k,v in opts_unwrapped.items() if text==v]
+        return matches[0] if len(matches)==1 else None
+    raise KeyError(kind)

run_smolcua.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python3
+"""SmolCUA v1.0 pretokenized text-model evaluation: vLLM, Transformers, or API.
+
+Examples:
+    python run_smolcua.py --model Qwen/Qwen2.5-1.5B-Instruct --backend vllm --score
+    python run_smolcua.py --model dotlabs/void.1 --backend transformers --prompt-mode plain
+    python run_smolcua.py --model my-server-model --backend api --endpoint http://localhost:8000/v1
+
+No answer extraction, forced choice, or format repair is performed. The model's
+EXACT generated text is saved, so the scorer can test instruction compliance.
+"""
+from __future__ import annotations
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import gc
+from itertools import groupby
+
+from token_cache import compile_tokens
+from inference_runtime import Progress, generate_batches
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+import random
+import sys
+import time
+
+DEFAULT_REPO='dotlabs/smolcua'
+DEFAULT_RUN='runs/v1_1_seed_20261023'
+
+
+def read_jsonl(path):
+    with open(path, encoding='utf-8') as f:
+        return [json.loads(s) for s in f if s.strip()]
+
+
+def write_atomic_json(path, value):
+    tmp=path.with_name(path.name+'.tmp')
+    tmp.write_text(json.dumps(value,indent=2,ensure_ascii=False)+'\n',encoding='utf-8')
+    tmp.replace(path)
+
+
+def write_atomic_jsonl(path, rows):
+    tmp=path.with_name(path.name+'.tmp')
+    with open(tmp,'w',encoding='utf-8') as f:
+        for row in rows:f.write(json.dumps(row,ensure_ascii=False)+'\n')
+    tmp.replace(path)
+
+
+def format_prompt(q):
+    # The base question already includes its own ANSWER CONTRACT.
+    return q['question']+'\n\n'+'\n'.join(f"{k}. {q['options'][k]}" for k in 'ABCD')
+
+
+def build_messages(prompt):
+    return [{'role':'user','content':prompt}]
+
+
+def build_plain(prompt):
+    return prompt+'\n\nAnswer:\n'
+
+
+def make_chat_prompt(tokenizer, prompt, mode, template_kwargs):
+    if mode=='plain' or (mode=='auto' and not getattr(tokenizer,'chat_template',None)):
+        return build_plain(prompt)
+    if mode=='chat' and not getattr(tokenizer,'chat_template',None):
+        raise ValueError('No chat template in tokenizer; choose --prompt-mode plain')
+    return tokenizer.apply_chat_template(build_messages(prompt), tokenize=False,
+                                         add_generation_prompt=True,**template_kwargs)
+
+
+def token_budget(q, args):
+    fmt=q['response_format']
+    if fmt=='raw_payload':return args.max_new_tokens
+    if fmt=='json_choice_text':return min(args.max_new_tokens,max(192,args.short_max_new_tokens))
+    return min(args.max_new_tokens,args.short_max_new_tokens)
+
+
+def _prepare_all_tokens(pending, tokenizer, args):
+    # Compiles the entire selected benchmark before the first GPU request,
+    # including rows already scored in a resumed run. Cache hits skip CPU encoding.
+    questions = getattr(args, '_all_rows', pending)
+    sha256 = getattr(args, '_dataset_sha256', '')
+    indexed, info = compile_tokens(questions, tokenizer, args, sha256,
+                                   getattr(args, '_format_prompt', format_prompt),
+                                   prompt_builder=getattr(args, '_prompt_builder', None))
+    args._token_cache_info = info
+    if not getattr(args, 'quiet', False):
+        print(f"Pretokenization: {info['status']} | {info['count']} prompts | "
+              f"{info['input_tokens']:,} tokens | {info['elapsed_seconds']:.2f}s | "
+              f"cache={info['path']}", flush=True)
+    return indexed
+
+
+def validate_context(rows, compiled, args, context_limit, is_seq2seq=False):
+    if not context_limit:
+        return
+    for q in rows:
+        required = len(compiled[q['id']]['input_ids'])
+        if not is_seq2seq:
+            required += token_budget(q, args)
+        if required > context_limit:
+            raise ValueError(f'{q["id"]}: input + response needs {required} tokens, '
+                             f'exceeds model context ({context_limit}); no truncation is allowed')
+
+
+def run_vllm(pending, args, emit):
+    from vllm import LLM, SamplingParams
+    kw = dict(model=args.model, trust_remote_code=args.trust_remote_code,
+              dtype=args.dtype, tensor_parallel_size=args.tensor_parallel,
+              gpu_memory_utilization=args.gpu_memory_utilization,
+              enforce_eager=args.enforce_eager,
+              enable_prefix_caching=not args.disable_prefix_cache)
+    if args.revision:
+        kw['revision'] = args.revision
+    if getattr(args, 'tokenizer', None):
+        kw['tokenizer'] = args.tokenizer
+    if getattr(args, 'tokenizer_revision', None):
+        kw['tokenizer_revision'] = args.tokenizer_revision
+    if args.max_model_len:
+        kw['max_model_len'] = args.max_model_len
+    if args.quantization:
+        kw['quantization'] = args.quantization
+    llm = LLM(**kw)
+    tokenizer = llm.get_tokenizer()
+    if getattr(tokenizer, 'pad_token_id', None) is None and getattr(tokenizer, 'eos_token_id', None) is not None:
+        tokenizer.pad_token = tokenizer.eos_token
+    compiled = _prepare_all_tokens(pending, tokenizer, args)
+    validate_context(getattr(args, '_all_rows', pending), compiled, args, args.max_model_len)
+    # Large models benefit from having similar-size prompts in the same chunk.
+    # Each question retains its exact max-token budget and original ID.
+    ordered = sorted(pending, key=lambda q: (token_budget(q, args), len(compiled[q['id']]['input_ids'])))
+    for off in range(0, len(ordered), args.batch_size):
+        group = ordered[off:off+args.batch_size]
+        # TokensPrompt skips vLLM's text tokenization entirely.
+        inputs = [{'prompt_token_ids': compiled[q['id']]['input_ids']} for q in group]
+        sampling = [SamplingParams(temperature=0.0, top_p=1.0, n=1,
+                                   max_tokens=token_budget(q, args), seed=args.seed)
+                    for q in group]
+        result = llm.generate(inputs, sampling_params=sampling, use_tqdm=not args.quiet)
+        if len(result) != len(group):
+            raise RuntimeError('vLLM returned unexpected number of results')
+        emit([(q['id'], out.outputs[0].text, len(out.outputs[0].token_ids))
+              for q, out in zip(group, result)])
+    del llm
+
+
+def run_transformers(pending, args, emit):
+    with Progress(getattr(args, "progress_label", "SmolCUA"), len(pending), args.quiet,
+                  getattr(args, "progress_interval", 5)) as progress:
+        args._progress = progress
+        try:
+            return _run_transformers(pending, args, emit, progress)
+        finally:
+            del args._progress
+
+
+def _run_transformers(pending, args, emit, progress):
+    import torch
+    from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer, AutoConfig
+    progress.update(stage='loading tokenizer/config', force=True)
+    model_kw = {'trust_remote_code': args.trust_remote_code}
+    if args.revision:
+        model_kw['revision'] = args.revision
+    tokenizer_kwargs = {'trust_remote_code': args.trust_remote_code}
+    if getattr(args, 'tokenizer_revision', None) or args.revision:
+        tokenizer_kwargs['revision'] = getattr(args, 'tokenizer_revision', None) or args.revision
+    tokenizer = AutoTokenizer.from_pretrained(getattr(args, 'tokenizer', None) or args.model,
+                                               **tokenizer_kwargs)
+    config = AutoConfig.from_pretrained(args.model, **model_kw)
+    if tokenizer.pad_token_id is None:
+        if tokenizer.eos_token_id is None:
+            raise ValueError('Tokenizer has neither PAD nor EOS token')
+        tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = 'right' if getattr(config, 'is_encoder_decoder', False) else 'left'
+    # Tokenize before model weights are allocated; model.generate never sees text.
+    compiled = _prepare_all_tokens(pending, tokenizer, args)
+    is_seq2seq = bool(getattr(config, 'is_encoder_decoder', False))
+    context_limit = args.max_model_len or getattr(config, 'max_position_embeddings', None)
+    validate_context(getattr(args, '_all_rows', pending), compiled, args, context_limit, is_seq2seq)
+    dtype_map = {'auto': 'auto', 'float16': torch.float16,
+                 'bfloat16': torch.bfloat16, 'float32': torch.float32}
+    device = getattr(args, 'device', None) or ('cuda' if torch.cuda.is_available() else (
+        'mps' if hasattr(torch.backends, 'mps') and torch.backends.mps.is_available() else 'cpu'))
+    if not device.startswith('cuda') and args.dtype in ('float16', 'bfloat16'):
+        print('Warning: requested low precision on non-CUDA device', file=sys.stderr)
+    kwargs = dict(model_kw, dtype=dtype_map[args.dtype], low_cpu_mem_usage=True)
+    if device.startswith('cuda'):
+        kwargs['device_map'] = device
+    elif device == 'mps':
+        kwargs['device_map'] = 'mps'
+    is_seq2seq = bool(getattr(config, 'is_encoder_decoder', False))
+    cls = AutoModelForSeq2SeqLM if is_seq2seq else AutoModelForCausalLM
+    progress.update(stage='loading model weights', force=True)
+    try:
+        model = cls.from_pretrained(args.model, **kwargs)
+    except (TypeError, ValueError) as exc:
+        if 'dtype' not in str(exc):
+            raise
+        kwargs['torch_dtype'] = kwargs.pop('dtype')
+        model = cls.from_pretrained(args.model, **kwargs)
+    if device == 'cpu':
+        model = model.to('cpu')
+    model.eval()
+    progress.update(stage='model ready', force=True)
+    args._generation_stats = generate_batches(
+        model, tokenizer, compiled, pending, lambda q: token_budget(q, args),
+        args.batch_size, emit, progress, is_seq2seq=is_seq2seq,
+        keep_special_tokens=getattr(args, 'keep_special_tokens', False))
+    del model
+    gc.collect()
+
+def run_api(pending,args,emit):
+    # For vLLM servers, TGI-compatible OpenAI endpoints, remote HF deployments, etc.
+    from openai import OpenAI
+    if not args.endpoint:raise ValueError('--endpoint is required for --backend api')
+    api_key=os.getenv(args.api_key_env,'EMPTY')
+    client=OpenAI(base_url=args.endpoint,api_key=api_key,max_retries=args.api_retries,
+                  timeout=args.api_timeout)
+    def request(q):
+        prompt=format_prompt(q)
+        if args.prompt_mode=='plain':
+            msg=[{'role':'user','content':build_plain(prompt)}]
+        else:msg=build_messages(prompt)
+        answer=client.chat.completions.create(model=args.model,messages=msg,
+                                               max_tokens=token_budget(q,args),
+                                               temperature=0,seed=args.seed)
+        choice=answer.choices[0]
+        content=choice.message.content
+        if content is None:content=''
+        return (q['id'],content,getattr(answer.usage,'completion_tokens',0) or 0)
+    # Bounded concurrent I/O. Never silently swallow failed requests.
+    with ThreadPoolExecutor(max_workers=args.api_concurrency) as pool:
+        futures={pool.submit(request,q):q['id'] for q in pending}
+        done=[]
+        for future in as_completed(futures):
+            done.append(future.result())
+            if len(done)>=args.batch_size:
+                emit(done);done=[]
+        if done:emit(done)
+
+
+def parse_passes(value,total):
+    if value=='all':return set(range(1,total+1))
+    out={int(p) for p in value.split(',')}
+    if not out or not out.issubset(set(range(1,total+1))):
+        raise ValueError(f'Invalid passes {value}; expected 1..{total}')
+    return out
+
+
+def resolve_run_dir(args):
+    if args.run_dir:
+        directory=Path(args.run_dir)
+        if not (directory/'manifest.json').exists():raise FileNotFoundError(directory/'manifest.json')
+        return directory
+    from huggingface_hub import snapshot_download
+    # Explicit selection only; avoid pulling gigabytes or private generator sources.
+    patterns=[f'{args.run_subdir}/manifest.json',f'{args.run_subdir}/questions_all_passes.jsonl']
+    if args.score:patterns.extend([f'{args.run_subdir}/private/answers_all_passes.jsonl',
+                                    f'{args.run_subdir}/private/weights_all_passes.jsonl'])
+    root=Path(snapshot_download(repo_id=args.dataset,repo_type='dataset',revision=args.dataset_revision,
+                                allow_patterns=patterns,token=True if os.getenv('HF_TOKEN') else None))
+    return root/args.run_subdir
+
+
+def build_parser():
+    ap=argparse.ArgumentParser(description=__doc__,formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    ap.add_argument('--model',required=True,help='Hugging Face model repo ID, local path or deployed API model name')
+    ap.add_argument('--backend',choices=['auto','vllm','transformers','api'],default='auto')
+    ap.add_argument('--dataset',default=DEFAULT_REPO)
+    ap.add_argument('--dataset-revision',default=None)
+    ap.add_argument('--run-subdir',default=DEFAULT_RUN)
+    ap.add_argument('--run-dir',help='Use an existing local run directory (offline)')
+    ap.add_argument('--output-dir',default='results/smolcua_run')
+    ap.add_argument('--passes',default='all',help='all or comma-separated pass numbers')
+    ap.add_argument('--limit',type=int,default=0,help='Only for quick smoke tests; not a valid published score')
+    ap.add_argument('--score',action='store_true',help='Require label and weight files and compute weighted + reliability scores')
+    ap.add_argument('--resume',action='store_true',help='Resume only if run metadata matches')
+    ap.add_argument('--batch-size',type=int,default=0,help='0 = auto (vLLM 256, Transformers 32, API 32); Transformers backs off on CUDA OOM')
+    ap.add_argument('--max-new-tokens',type=int,default=512,help='Upper bound for raw payloads')
+    ap.add_argument('--short-max-new-tokens',type=int,default=48,help='Token budget for short response formats')
+    ap.add_argument('--dtype',choices=['auto','float16','bfloat16','float32'],default='auto')
+    ap.add_argument('--tensor-parallel',type=int,default=1)
+    ap.add_argument('--gpu-memory-utilization',type=float,default=0.90)
+    ap.add_argument('--max-model-len',type=int,default=0)
+    ap.add_argument('--quantization',default=None)
+    ap.add_argument('--revision',default=None,help='Pinned model revision for reproducibility')
+    ap.add_argument('--trust-remote-code',action='store_true',help='Only for models you trust; executes third-party code')
+    ap.add_argument('--tokenizer',default=None,help='Optional HF tokenizer repository (defaults to --model)')
+    ap.add_argument('--tokenizer-revision',default=None,help='Optional tokenizer revision (defaults to --revision)')
+    ap.add_argument('--token-cache-dir',default='~/.cache/smolcua/tokens',
+                    help='Persistent, content-addressed CPU token cache (keep local)')
+    ap.add_argument('--no-token-cache',action='store_true',help='Pretokenize once in memory without saving')
+    ap.add_argument('--rebuild-token-cache',action='store_true',help='Discard any matching on-disk token cache')
+    ap.add_argument('--tokenize-batch-size',type=int,default=512,help='CPU tokenization batch size')
+    ap.add_argument('--pretokenize-only',action='store_true',
+                    help='Compile all requested prompts on CPU then exit; no model weights/GPU required')
+    ap.add_argument('--prompt-mode',choices=['auto','chat','plain'],default='auto')
+    ap.add_argument('--chat-template-kwargs',type=json.loads,default={},help='JSON object, e.g. {"enable_thinking": false}')
+    ap.add_argument('--disable-prefix-cache',action='store_true')
+    ap.add_argument('--enforce-eager',action='store_true')
+    ap.add_argument('--seed',type=int,default=42)
+    ap.add_argument('--endpoint',help='OpenAI-compatible /v1 URL for API backend')
+    ap.add_argument('--api-key-env',default='OPENAI_API_KEY')
+    ap.add_argument('--api-concurrency',type=int,default=16)
+    ap.add_argument('--api-retries',type=int,default=3)
+    ap.add_argument('--api-timeout',type=int,default=120)
+    ap.add_argument('--quiet',action='store_true')
+    ap.add_argument('--progress-interval', type=float, default=5, help='Seconds between live progress updates')
+    return ap
+
+
+def main(argv=None):
+    ap = build_parser()
+    args=ap.parse_args(argv)
+    if args.progress_interval <= 0:ap.error('--progress-interval must be positive')
+    if args.batch_size<0 or args.max_new_tokens<1 or args.short_max_new_tokens<1 or args.tokenize_batch_size<1:ap.error('batch and token limits must be positive')
+    if args.limit < 0 or args.max_model_len < 0 or args.api_concurrency < 1:
+        ap.error('limit/context must be nonnegative; API concurrency must be positive')
+    if not isinstance(args.chat_template_kwargs,dict):ap.error('--chat-template-kwargs must be a JSON object')
+    if args.backend=='auto':
+        has_vllm=importlib.util.find_spec('vllm') is not None
+        if has_vllm:
+            try:
+                import torch
+                has_vllm=torch.cuda.is_available()
+            except ImportError:has_vllm=False
+        args.backend='vllm' if has_vllm else 'transformers'
+    if args.batch_size==0:args.batch_size={'vllm':256,'transformers':32,'api':32}[args.backend]
+    if args.pretokenize_only and not importlib.util.find_spec('transformers'):
+        ap.error('For --pretokenize-only install transformers: pip install transformers')
+    if not args.pretokenize_only and args.backend=='vllm' and not importlib.util.find_spec('vllm'):
+        ap.error('vllm is not installed; use --backend transformers or pip install vllm')
+    if not args.pretokenize_only and args.backend=='transformers' and not importlib.util.find_spec('transformers'):
+        ap.error('transformers is not installed; pip install torch transformers accelerate')
+    if not args.pretokenize_only and args.backend=='api' and not importlib.util.find_spec('openai'):
+        ap.error('openai is not installed; pip install openai')
+    directory=resolve_run_dir(args)
+    manifest=json.loads((directory/'manifest.json').read_text(encoding='utf-8'))
+    questions_path=directory/'questions_all_passes.jsonl'
+    digest=hashlib.sha256(questions_path.read_bytes()).hexdigest()
+    if digest!=manifest['question_file_sha256']:raise ValueError('Dataset questions SHA256 does not match manifest')
+    if args.score and not args.pretokenize_only:
+        for name in ('answers_all_passes.jsonl','weights_all_passes.jsonl'):
+            if not (directory/'private'/name).exists():
+                raise FileNotFoundError("Scoring requested, but ground truth is not in this edition. Use the self-score edition or omit --score.")
+    rows=read_jsonl(questions_path)
+    if len(rows)!=manifest['total_instances']:raise ValueError('Unexpected number of questions')
+    selected=parse_passes(args.passes,manifest['passes'])
+    rows=[r for r in rows if r['pass'] in selected]
+    if args.limit:rows=rows[:args.limit]
+    if args.score and not args.pretokenize_only and len(rows) != manifest['total_instances']:
+        raise ValueError('--score requires all questions and passes; remove --limit/--passes or omit --score')
+    if len({r['id'] for r in rows})!=len(rows):raise ValueError('Duplicate question IDs')
+    # In --pretokenize-only mode, precompile every selected question without
+    # loading weights. This is useful as a CPU-only preparation step.
+    if args.pretokenize_only:
+        from transformers import AutoTokenizer
+        tok_kw = {'trust_remote_code': args.trust_remote_code}
+        revision = args.tokenizer_revision or args.revision
+        if revision:
+            tok_kw['revision'] = revision
+        tok = AutoTokenizer.from_pretrained(args.tokenizer or args.model, **tok_kw)
+        if getattr(tok, 'pad_token_id', None) is None and getattr(tok, 'eos_token_id', None) is not None:
+            tok.pad_token = tok.eos_token
+        _, info = compile_tokens(rows, tok, args, digest, format_prompt)
+        print(json.dumps(info, indent=2, ensure_ascii=False))
+        return
+    out_dir=Path(args.output_dir);out_dir.mkdir(parents=True,exist_ok=True)
+    metadata={'model':args.model,'backend':args.backend,'model_revision':args.revision,'tokenizer':args.tokenizer,
+              'tokenizer_revision':args.tokenizer_revision,
+              'dataset_sha256':digest,'passes':sorted(selected),'limit':args.limit,
+              'prompt_mode':args.prompt_mode,'chat_template_kwargs':args.chat_template_kwargs,
+              'dtype':args.dtype,'quantization':args.quantization,'seed':args.seed,
+              'max_new_tokens':args.max_new_tokens,'short_max_new_tokens':args.short_max_new_tokens,
+              'tensor_parallel':args.tensor_parallel,'endpoint':args.endpoint,
+              'max_model_len':args.max_model_len,
+              'manifest_sha256':hashlib.sha256((directory/'manifest.json').read_bytes()).hexdigest(),
+              'pretokenize_schema':1}
+    meta_file=out_dir/'run_metadata.json';pred_file=out_dir/'predictions.jsonl'
+    if args.resume:
+        if not meta_file.exists():raise FileNotFoundError('Cannot resume: run_metadata.json missing')
+        if json.loads(meta_file.read_text(encoding='utf-8'))!=metadata:
+            raise ValueError('Resume metadata mismatch; choose a new --output-dir')
+        previous=read_jsonl(pred_file) if pred_file.exists() else []
+    else:
+        if meta_file.exists() or pred_file.exists():
+            raise FileExistsError('Output directory contains results. Use --resume or a new --output-dir')
+        previous=[];write_atomic_json(meta_file,metadata)
+    full={r['id']:r for r in previous}
+    wanted_ids = {q['id'] for q in rows}
+    if len(full)!=len(previous) or any(r['id'] not in wanted_ids for r in previous):
+        raise ValueError('Prior predictions contain duplicate or foreign IDs')
+    if any(not isinstance(r.get('answer'), str) for r in previous):
+        raise ValueError('Prior predictions must contain text answers')
+    pending=[r for r in rows if r['id'] not in full]
+    args._all_rows=rows
+    args._dataset_sha256=digest
+    # Shuffle deterministically to prevent running an easier category first; keep IDs for scoring.
+    rng=random.Random(args.seed);rng.shuffle(pending)
+    generated_tokens=0
+    started=time.perf_counter()
+    def emit(out):
+        nonlocal generated_tokens
+        for rid,txt,n in out:
+            if rid not in wanted_ids:raise ValueError(f'Unknown inference result {rid}')
+            if rid in full:raise ValueError(f'Duplicate inference result {rid}')
+            if not isinstance(txt,str):raise TypeError('Model output must be a text string')
+            full[rid]={'id':rid,'answer':txt}
+            generated_tokens+=n
+        # One atomic save per batch; crash-safe resumability.
+        write_atomic_jsonl(pred_file,[full[q['id']] for q in rows if q['id'] in full])
+        progress = getattr(args, '_progress', None)
+        if progress and args.backend != 'transformers':
+            progress.update(stage='responses saved', done=len(full)-len(previous), tokens=generated_tokens, force=True)
+    if pending:
+        if args.backend == 'transformers':
+            run_transformers(pending,args,emit)
+        else:
+            with Progress('SmolCUA', len(pending), args.quiet, args.progress_interval) as progress:
+                args._progress = progress
+                progress.update(stage='loading vLLM' if args.backend == 'vllm' else 'API requests in flight', force=True)
+                try:
+                    {'vllm':run_vllm,'api':run_api}[args.backend](pending,args,emit)
+                finally:
+                    del args._progress
+    if set(full) != wanted_ids:
+        raise RuntimeError('Inference ended with missing predictions; partial results retained for --resume')
+    elapsed=max(1e-6,time.perf_counter()-started)
+    report=dict(metadata,token_cache=getattr(args,'_token_cache_info',None),
+                generation=getattr(args,'_generation_stats',None),
+                attempted=len(full),expected=len(rows),new_predictions=len(pending),
+                elapsed_seconds=round(elapsed,3),questions_per_second=round(len(pending)/elapsed,3),
+                generated_tokens=generated_tokens,
+                generated_tokens_per_second=round(generated_tokens/elapsed,3),
+                speed_note='Only new predictions measured; load/tokenization included; no GPU speed validated here.')
+    write_atomic_json(out_dir/'performance.json',report)
+    if args.score:
+        if len(rows)!=manifest['total_instances'] or len(full)!=manifest['total_instances']:
+            raise ValueError('--score requires full benchmark and all passes; partial predictions saved')
+        for name in ('answers_all_passes.jsonl','weights_all_passes.jsonl'):
+            if not (directory/'private'/name).exists():
+                raise FileNotFoundError('Labels are not available. Blind releases need an external evaluator; use self-score release.')
+        from score_smolcua import score
+        results=score(pred_file,directory)
+        write_atomic_json(out_dir/'score.json',results)
+        print(f"Weighted: {results['mean_weighted_score_100']:.4f}/100 | "
+              f"Reliability: {results['reliability_score_100']:.4f}/100 "
+              f"({results['reliability_exact_correct']}/{results['reliability_exact_total']} worst pass)")
+    print(f"Completed {len(full)}/{len(rows)}. Saved to {out_dir}. "
+          f"New throughput: {report['questions_per_second']:.2f} questions/s")
+
+if __name__=='__main__':main()

runs/v1_1_seed_20261023/manifest.json

@@ -0,0 +1,76 @@
+{
+  "benchmark": "SmolCUA",
+  "version": "1.1",
+  "seed": 20261023,
+  "passes": 5,
+  "questions_per_pass": 1000,
+  "total_instances": 5000,
+  "categories": {
+    "tool_use": 100,
+    "best_next_action": 100,
+    "strategy_switching": 100,
+    "instruction_following": 100,
+    "ambiguity_understanding": 100,
+    "coding": 100,
+    "structured_output": 100,
+    "coordinate_reasoning": 100,
+    "multi_constraint_format": 100,
+    "state_tracking": 100
+  },
+  "category_points": {
+    "tool_use": 10.0,
+    "best_next_action": 10.0,
+    "strategy_switching": 13.0,
+    "instruction_following": 8.0,
+    "ambiguity_understanding": 12.0,
+    "coding": 10.0,
+    "structured_output": 7.0,
+    "coordinate_reasoning": 8.0,
+    "multi_constraint_format": 9.0,
+    "state_tracking": 13.0
+  },
+  "option_styles": [
+    "plain",
+    "json_envelope",
+    "xml_envelope",
+    "markdown_quote",
+    "fenced_block",
+    "yaml_block",
+    "quoted_string",
+    "tagged_section",
+    "python_string"
+  ],
+  "response_styles": [
+    "letter",
+    "ordinal",
+    "json_choice",
+    "json_choice_text",
+    "yaml_choice",
+    "xml_choice",
+    "csv_choice",
+    "bracket_choice",
+    "pipe_choice",
+    "raw_payload"
+  ],
+  "response_style_frequency_per_category_per_pass": 10,
+  "question_file_sha256": "cc73cbf46f695d8e9284bc1f3cf5e73d8497dc29962a2bd6ebdd4497e3e38590",
+  "world_sha256": "fd2eeb1324ebb6ebb012edf9b807f1715aa58558d4a165b2a9e13277d742d8f1",
+  "overrides_sha256": null,
+  "oracle_counts": {
+    "preserved_semantics": 1783,
+    "authored_semantic_branch": 1217,
+    "executed_python": 500,
+    "derived_structured_format": 500,
+    "derived_geometry": 500,
+    "derived_format": 500
+  },
+  "notes": "Local prompt repairs reconstructed from authored answer keys; options, labels and weights unchanged. Not interchangeable with original v1.0 scores.",
+  "edition": "local-corrected",
+  "source_version": "1.0",
+  "source_question_file_sha256": "ad11f4fb6b280f688b3a40fd04ecf6aa248714b3d035497f31dcbb0e81ef1c1f",
+  "scoring_file_sha256": {
+    "answers_all_passes.jsonl": "9816fe4cec5ec6aae7b0990727d0d38bba13ed14ff0c2d73fce5ac64a09df8b2",
+    "weights_all_passes.jsonl": "3d38027d263c311c5e5e954d05766238f2b835d13eb17acdbc4e6224e0617bf7"
+  },
+  "corrected_questions": 250
+}

runs/v1_seed_20261023/manifest.json

@@ -0,0 +1,68 @@
+{
+  "benchmark": "SmolCUA",
+  "version": "1.0",
+  "seed": 20261023,
+  "passes": 5,
+  "questions_per_pass": 1000,
+  "total_instances": 5000,
+  "categories": {
+    "tool_use": 100,
+    "best_next_action": 100,
+    "strategy_switching": 100,
+    "instruction_following": 100,
+    "ambiguity_understanding": 100,
+    "coding": 100,
+    "structured_output": 100,
+    "coordinate_reasoning": 100,
+    "multi_constraint_format": 100,
+    "state_tracking": 100
+  },
+  "category_points": {
+    "tool_use": 10.0,
+    "best_next_action": 10.0,
+    "strategy_switching": 13.0,
+    "instruction_following": 8.0,
+    "ambiguity_understanding": 12.0,
+    "coding": 10.0,
+    "structured_output": 7.0,
+    "coordinate_reasoning": 8.0,
+    "multi_constraint_format": 9.0,
+    "state_tracking": 13.0
+  },
+  "option_styles": [
+    "plain",
+    "json_envelope",
+    "xml_envelope",
+    "markdown_quote",
+    "fenced_block",
+    "yaml_block",
+    "quoted_string",
+    "tagged_section",
+    "python_string"
+  ],
+  "response_styles": [
+    "letter",
+    "ordinal",
+    "json_choice",
+    "json_choice_text",
+    "yaml_choice",
+    "xml_choice",
+    "csv_choice",
+    "bracket_choice",
+    "pipe_choice",
+    "raw_payload"
+  ],
+  "response_style_frequency_per_category_per_pass": 10,
+  "question_file_sha256": "ad11f4fb6b280f688b3a40fd04ecf6aa248714b3d035497f31dcbb0e81ef1c1f",
+  "world_sha256": "fd2eeb1324ebb6ebb012edf9b807f1715aa58558d4a165b2a9e13277d742d8f1",
+  "overrides_sha256": null,
+  "oracle_counts": {
+    "preserved_semantics": 1783,
+    "authored_semantic_branch": 1217,
+    "executed_python": 500,
+    "derived_structured_format": 500,
+    "derived_geometry": 500,
+    "derived_format": 500
+  },
+  "notes": "Author-curated alternative task branches and bounded answer-preserving transformations. No claim of unrestricted semantic substitution."
+}

score_smolcua.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""SmolCUA v1.0 strict response-format scorer with worst-case reliability.
+
+Input JSONL: {"id":"P01-CU-01-001","answer":"..."}
+The `answer` field is the string that the model emitted, exactly, using the
+question's required response contract. Incorrect formatting = incorrect item.
+Use all five or more passes; omitted answers are wrong, not excluded.
+"""
+from __future__ import annotations
+import argparse, collections, hashlib, json, statistics, math
+from pathlib import Path
+from response_formats import parse_response, unwrap_option
+
+
+def load(path):
+    return [json.loads(line) for line in path.read_text(encoding='utf8').splitlines() if line.strip()]
+
+
+def indexed(path):
+    rows = load(path)
+    result = {r['id']: r for r in rows}
+    if len(result) != len(rows):
+        raise ValueError(f'Duplicate IDs in {path.name}')
+    return result
+
+
+def score(pred_path,run_dir):
+    m=json.loads((run_dir/'manifest.json').read_text(encoding='utf8'))
+    if m['version'] not in ('1.0', '1.1') or m['passes']<5:raise ValueError('Expected supported SmolCUA run, at least five passes')
+    qpath=run_dir/'questions_all_passes.jsonl'
+    if hashlib.sha256(qpath.read_bytes()).hexdigest()!=m['question_file_sha256']:
+        raise ValueError('Public-question integrity hash mismatch')
+    for name, digest in m.get('scoring_file_sha256', {}).items():
+        if name not in ('answers_all_passes.jsonl', 'weights_all_passes.jsonl'):
+            raise ValueError('Unexpected scoring filename')
+        if hashlib.sha256((run_dir/'private'/name).read_bytes()).hexdigest() != digest:
+            raise ValueError('Scoring-file integrity hash mismatch')
+    questions=indexed(qpath)
+    keys=indexed(run_dir/'private'/'answers_all_passes.jsonl')
+    weights=indexed(run_dir/'private'/'weights_all_passes.jsonl')
+    if set(questions)!=set(keys) or set(keys)!=set(weights) or len(questions)!=m['total_instances']:
+        raise ValueError('Question/answer/weight set is inconsistent')
+    if any(keys[rid]['answer'] not in ('A', 'B', 'C', 'D') for rid in keys):
+        raise ValueError('Invalid answer key')
+    if any(not math.isfinite(w['max_points']) or w['max_points'] <= 0 for w in weights.values()):
+        raise ValueError('Weights must be finite and positive')
+    preds={};parsed={};format_bad=[]
+    for i,r in enumerate(load(pred_path),1):
+        rid=r.get('id')
+        if rid not in questions:raise ValueError(f'Unknown question ID on prediction line {i}: {rid!r}')
+        if rid in preds:raise ValueError(f'Duplicate prediction for {rid}')
+        if 'answer' not in r:raise ValueError(f'Missing answer field for {rid}')
+        preds[rid]=r['answer']
+        q=questions[rid]
+        raw={k:unwrap_option(v,q['option_presentation']) for k,v in q['options'].items()}
+        parsed[rid]=parse_response(r['answer'],q['response_format'],raw)
+        if parsed[rid] is None:format_bad.append(rid)
+    passes=[];cat_pass=collections.defaultdict(list);style_data=collections.defaultdict(lambda:[0,0,0]);stable=collections.defaultdict(list)
+    for rid,q in questions.items():
+        sty=q['response_format'];style_data[sty][0]+=1
+        if rid in preds:style_data[sty][1]+=1
+        if parsed.get(rid)==keys[rid]['answer']:style_data[sty][2]+=1
+        stable[q['item_id']].append(parsed.get(rid)==keys[rid]['answer'])
+    for p in range(1,m['passes']+1):
+        item_ids=[rid for rid,q in questions.items() if q['pass']==p]
+        if len(item_ids)!=m['questions_per_pass']:raise ValueError('Unequal pass lengths')
+        correct_ids=[rid for rid in item_ids if parsed.get(rid)==keys[rid]['answer']]
+        earned=sum(weights[rid]['max_points'] for rid in correct_ids)
+        per_cat={}
+        for cat,total in m['categories'].items():
+            part=[rid for rid in item_ids if questions[rid]['category']==cat]
+            if len(part)!=total:raise ValueError(f'Bad number of questions in {cat}')
+            good=sum(parsed.get(rid)==keys[rid]['answer'] for rid in part)
+            cw=sum(weights[rid]['max_points'] for rid in part if parsed.get(rid)==keys[rid]['answer'])
+            entry={'correct':good,'total':len(part),'accuracy_pct':round(good*100/len(part),4),
+                   'weighted_points':round(cw,6),'category_budget':m['category_points'][cat]}
+            cat_pass[cat].append(entry);per_cat[cat]=entry
+        passes.append({'pass':p,'correct':len(correct_ids),'total':len(item_ids),
+                       'attempted':sum(rid in preds for rid in item_ids),
+                       'unweighted_accuracy_pct':round(len(correct_ids)*100/len(item_ids),4),
+                       'weighted_score_100':round(earned,6),'per_category':per_cat})
+    weakest=min(s['correct'] for s in passes)
+    performance=[s['weighted_score_100'] for s in passes]
+    per_cat_reliability={c:{'worst_exact_correct':min(s['correct'] for s in subs),
+                            'out_of':m['categories'][c],
+                            'worst_accuracy_pct':round(100*min(s['correct'] for s in subs)/m['categories'][c],4)}
+                         for c,subs in cat_pass.items()}
+    consistency=collections.Counter(sum(vals) for vals in stable.values())
+    return {'benchmark':f"SmolCUA v{m['version']}",'edition':m.get('edition', 'original'),
+            'dataset_sha256':m['question_file_sha256'],'passes':m['passes'],
+            'mean_weighted_score_100':round(statistics.mean(performance),4),
+            'mean_unweighted_accuracy_pct':round(statistics.mean(s['unweighted_accuracy_pct'] for s in passes),4),
+            'worst_weighted_pass_score_100':round(min(performance),4),
+            'reliability_exact_correct':weakest,'reliability_exact_total':m['questions_per_pass'],
+            'reliability_score_100':round(weakest*100/m['questions_per_pass'],4),
+            'reliability_worst_passes':[s['pass'] for s in passes if s['correct']==weakest],
+            'reliability_definition':'Min exact answer count across all passes; must satisfy required syntax; unweighted; missing answers count as incorrect.',
+            'per_category_reliability':per_cat_reliability,
+            'per_category_mean':{c:{'mean_accuracy_pct':round(statistics.mean(s['accuracy_pct'] for s in subs),4),
+                                    'mean_weighted_points':round(statistics.mean(s['weighted_points'] for s in subs),4)}
+                                 for c,subs in cat_pass.items()},
+            'per_response_format':{s:{'total':v[0],'attempted':v[1],'correct':v[2],
+                                     'accuracy_pct':round(v[2]*100/v[0],4)} for s,v in style_data.items()},
+            'invalid_format_submissions':len(format_bad),'invalid_format_question_ids':format_bad[:25],
+            'total_correct':sum(s['correct'] for s in passes),'total_questions':len(questions),
+            'full_coverage_pct':round(len(preds)*100/len(questions),4),
+            'pass_weighted_stddev':round(statistics.pstdev(performance),4),
+            'stable_positions_correct_on_all_passes':consistency[m['passes']],
+            'stable_positions_correct_on_no_passes':consistency[0],
+            'per_pass':passes}
+
+
+def main():
+    ap=argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('predictions',type=Path)
+    ap.add_argument('--run-dir',type=Path,default=Path(__file__).resolve().parent/'runs'/'v1_seed_20261023')
+    ap.add_argument('--output',type=Path)
+    a=ap.parse_args()
+    result=score(a.predictions,a.run_dir)
+    result_json=json.dumps(result,ensure_ascii=False,indent=2)
+    if a.output:a.output.write_text(result_json+'\n',encoding='utf8')
+    print(result_json)
+
+if __name__=='__main__':main()

token_cache.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Content-addressed, model-specific token compilation for SmolCUA.
+
+This module is intentionally independent of torch/vLLM. Fast HF tokenizers
+process *all* selected benchmark prompts in CPU batches before inference;
+inference engines only consume token IDs. A content-addressed persistent cache
+skips that CPU work on later runs of the same model and dataset revision.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import statistics
+import time
+
+VERSION = 2
+
+
+def stable_json(value):
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(',', ':'), default=str)
+
+
+def sha(value):
+    return hashlib.sha256(value if isinstance(value, bytes) else str(value).encode('utf-8')).hexdigest()
+
+
+def tokenizer_fingerprint(tokenizer):
+    """Fingerprint the *actual* tokenizer, not only its HF repository name.
+
+    The backend tokenization graph changes if merges/vocabulary/pre-tokenizer
+    change without a revision bump. Slow custom tokenizers use their vocab.
+    """
+    fp = hashlib.sha256()
+    for obj in (type(tokenizer).__module__ + '.' + type(tokenizer).__qualname__,
+                getattr(tokenizer, 'init_kwargs', {}),
+                getattr(tokenizer, 'special_tokens_map', {}),
+                getattr(tokenizer, 'added_tokens_decoder', {}),
+                getattr(tokenizer, 'chat_template', None),
+                getattr(tokenizer, 'bos_token_id', None),
+                getattr(tokenizer, 'eos_token_id', None)):
+        fp.update(sha(stable_json(obj)).encode())
+    backend = getattr(tokenizer, 'backend_tokenizer', None)
+    if backend is not None and hasattr(backend, 'to_str'):
+        fp.update(sha(backend.to_str()).encode())
+    elif hasattr(tokenizer, 'get_vocab'):
+        fp.update(sha(stable_json(tokenizer.get_vocab())).encode())
+    return fp.hexdigest()
+
+
+def compile_key(rows, tokenizer, args, dataset_sha):
+    settings = {
+        'cache_version': VERSION,
+        'dataset_sha256': dataset_sha,
+        'selected_ids_sha256': sha(stable_json([r['id'] for r in rows])),
+        'tokenizer_repo': getattr(args, 'tokenizer', None) or args.model,
+        'tokenizer_revision': getattr(args, 'tokenizer_revision', None) or args.revision,
+        'tokenizer_fingerprint': tokenizer_fingerprint(tokenizer),
+        'prompt_mode': args.prompt_mode,
+        'chat_template_kwargs': args.chat_template_kwargs,
+        'prompt_formatter_version': getattr(args, 'prompt_formatter_version', 'smolcua:1'),
+        'prompt_content_sha256': sha(stable_json(rows)),
+    }
+    return sha(stable_json(settings)), settings
+
+
+def effective_style(tokenizer, mode):
+    has_template = bool(getattr(tokenizer, 'chat_template', None))
+    if mode == 'chat' and not has_template:
+        raise ValueError('This tokenizer has no chat template: use --prompt-mode plain')
+    return ('chat' if has_template else 'plain') if mode == 'auto' else mode
+
+
+def build_text(row, tokenizer, mode, template_kwargs, format_prompt):
+    prompt = format_prompt(row)
+    if effective_style(tokenizer, mode) == 'plain':
+        return prompt + '\n\nAnswer:\n'
+    return tokenizer.apply_chat_template(
+        [{'role': 'user', 'content': prompt}], tokenize=False,
+        add_generation_prompt=True, **template_kwargs)
+
+
+def token_stats(items):
+    lengths = sorted(len(v['input_ids']) for v in items.values())
+    if not lengths:
+        return {'count': 0, 'input_tokens': 0, 'max_input_tokens': 0, 'p50_input_tokens': 0, 'p95_input_tokens': 0}
+    return {'count': len(lengths), 'input_tokens': sum(lengths),
+            'max_input_tokens': lengths[-1],
+            'p50_input_tokens': int(statistics.median(lengths)),
+            'p95_input_tokens': lengths[min(len(lengths)-1, int((len(lengths)-1)*.95))]}
+
+
+def compile_tokens(rows, tokenizer, args, dataset_sha, format_prompt, prompt_builder=None):
+    """Return (id -> tokenized prompt, performance info).
+
+    The entire list is compiled *before* the first model.generate call. Reused
+    caches preserve exact token sequences and do not repeat tokenizer calls.
+    Cache files are local to the evaluating user; never upload token caches or
+    real model responses with the public benchmark questions.
+    """
+    progress = getattr(args, '_progress', None)
+    if progress:
+        progress.update(stage=f'checking token cache ({len(rows)} prompts)', force=True)
+    started = time.perf_counter()
+    key, settings = compile_key(rows, tokenizer, args, dataset_sha)
+    cache_root = Path(getattr(args, 'token_cache_dir', None) or '~/.cache/smolcua/tokens').expanduser()
+    use_disk = not getattr(args, 'no_token_cache', False)
+    rebuild = getattr(args, 'rebuild_token_cache', False)
+    path = cache_root / (key + '.json') if use_disk else None
+    wanted_ids = [r['id'] for r in rows]
+
+    if path is not None and path.exists() and not rebuild:
+        try:
+            obj = json.loads(path.read_text(encoding='utf-8'))
+            valid = (obj.get('settings') == settings and
+                     list(obj.get('items', {})) == wanted_ids and
+                     obj.get('tokens_sha256') == sha(stable_json(obj.get('items', {}))))
+            if valid:
+                items = obj['items']
+                valid = all(isinstance(p.get('input_ids'), list) and p['input_ids'] and
+                            all(isinstance(t, int) and t >= 0 for t in p['input_ids'])
+                            for p in items.values())
+            if valid:
+                if progress:
+                    progress.update(stage=f'token cache hit: {len(items)}/{len(rows)} prompts', force=True)
+                return items, {
+                    'status': 'hit', 'path': str(path), 'elapsed_seconds': round(time.perf_counter()-started, 4),
+                    **token_stats(items)}
+        except (OSError, ValueError, KeyError, TypeError, AttributeError):
+            pass  # A stale/partial cache is rebuilt, not silently used.
+
+    batch_size = int(getattr(args, 'tokenize_batch_size', 512))
+    if batch_size <= 0:
+        raise ValueError('--tokenize-batch-size must be positive')
+    items = {}
+    for off in range(0, len(rows), batch_size):
+        group = rows[off:off+batch_size]
+        prompts = [prompt_builder(q) if prompt_builder else build_text(q, tokenizer, args.prompt_mode, args.chat_template_kwargs, format_prompt)
+                   for q in group]
+        # Batched Rust tokenizer threads when available; no padding and NEVER truncate.
+        # Chat templates already inject their own special tokens, so disable
+        # add_special_tokens to avoid BOS/EOS duplication.
+        enc = tokenizer(prompts, add_special_tokens=False, padding=False,
+                        truncation=False, return_attention_mask=False)
+        ids = enc['input_ids']
+        if len(ids) != len(group):
+            raise ValueError('Tokenizer returned incorrect number of sequences')
+        types = enc.get('token_type_ids') if hasattr(enc, 'get') else None
+        for i, (row, sequence) in enumerate(zip(group, ids)):
+            seq = [int(t) for t in sequence]
+            if not seq or min(seq) < 0:
+                raise ValueError(f'Empty/invalid tokenized benchmark prompt: {row["id"]}')
+            if row['id'] in items:
+                raise ValueError(f'Duplicate row ID: {row["id"]}')
+            item = {'input_ids': seq}
+            if types is not None:
+                t = [int(x) for x in types[i]]
+                if len(t) != len(seq):
+                    raise ValueError('token_type_ids shape mismatch')
+                item['token_type_ids'] = t
+            items[row['id']] = item
+        if progress:
+            progress.update(stage=f'pretokenized {len(items)}/{len(rows)} prompts', force=True)
+        elif not getattr(args, 'quiet', False):
+            print(f'Pretokenized {len(items)}/{len(rows)} prompts', flush=True)
+    if path is not None:
+        cache_root.mkdir(parents=True, exist_ok=True, mode=0o700)
+        tmp = path.with_name(path.name + f'.{os.getpid()}.tmp')
+        try:
+            with open(tmp, 'w', encoding='utf-8') as f:
+                os.chmod(tmp, 0o600)
+                json.dump({'settings': settings, 'items': items, 'tokens_sha256': sha(stable_json(items))},
+                          f, ensure_ascii=False, separators=(',', ':'))
+            os.replace(tmp, path)
+        finally:
+            if tmp.exists():
+                tmp.unlink()
+    return items, {'status': 'built' if use_disk else 'memory', 'path': str(path) if path else None,
+                   'elapsed_seconds': round(time.perf_counter()-started, 4), **token_stats(items)}
+
+
+def padded_batch(group, pad_token_id, padding_side='left', include_token_types=True):
+    """Pad cached token IDs directly into torch tensors without tokenizer calls."""
+    import torch
+    if not group:
+        raise ValueError('Cannot pad an empty group')
+    if pad_token_id is None:
+        raise ValueError('Tokenizer must have a valid pad token ID for Transformers batching')
+    maxlen = max(len(t['input_ids']) for t in group)
+    input_ids = torch.full((len(group), maxlen), int(pad_token_id), dtype=torch.long)
+    attention_mask = torch.zeros((len(group), maxlen), dtype=torch.long)
+    has_types = include_token_types and all('token_type_ids' in t for t in group)
+    types = torch.zeros((len(group), maxlen), dtype=torch.long) if has_types else None
+    for i, item in enumerate(group):
+        toks = item['input_ids']
+        start = (maxlen - len(toks)) if padding_side == 'left' else 0
+        end = start + len(toks)
+        input_ids[i, start:end] = torch.as_tensor(toks, dtype=torch.long)
+        attention_mask[i, start:end] = 1
+        if has_types:
+            types[i, start:end] = torch.as_tensor(item['token_type_ids'], dtype=torch.long)
+    out = {'input_ids': input_ids, 'attention_mask': attention_mask}
+    if has_types:
+        out['token_type_ids'] = types
+    return out