Make fixed 1000-task fast edition the default (0.2.0)

Batch 64 with OOM backoff, length/budget buckets, cached decoding and no per-token CPU streamer. Versioned 96–256 output budgets. Preserve full2000 as an archived config. Full sandbox reference execution and GPU throughput remain unverified.

README.md

@@ -10,32 +10,37 @@ tags:
 - multilingual
 configs:
 - config_name: default
+  default: true
   data_files:
   - split: test
     path: data/smolscript.parquet
+- config_name: full2000
+  data_files:
+  - split: test
+    path: archive/v0.1.0/smolscript.parquet
 ---
 # SmolScript
 
-An original execution-based benchmark of basic programming for 25M–350M parameter language models. Version **0.1.0**, **2,000 examples**, nine languages, MIT license.
+An original execution-based benchmark of basic programming for 25M–350M parameter language models. Version **0.2.0**, **1,000 default examples**, nine languages, MIT license.
 
-**Release status: execution-unverified candidate.** All 2,000 records have been generated and statically validated. No complete reference execution run or model baseline is claimed. The authoring environment has no Docker/Podman daemon; all 2,000 reference solutions and their negative controls still require execution in the supplied sandbox image. See `validation_report.json` for the machine-readable audit. Do not treat this candidate as a validated leaderboard release until `python validate.py` succeeds.
+**Release status: execution-unverified candidate.** All 1,000 default records have been generated and statically validated. No complete reference execution run or model baseline is claimed. The authoring environment has no Docker/Podman daemon; all 1,000 default reference solutions and their negative controls still require execution in the supplied sandbox image. See `validation_report.json` for the machine-readable audit. Do not treat this candidate as a validated leaderboard release until `python validate.py` succeeds.
 
 ## Composition
 
 | Language | Easy | Medium | Moderate | Total |
 |---|---:|---:|---:|---:|
-| Python | 150 | 75 | 25 | 250 |
-| JavaScript | 150 | 75 | 25 | 250 |
-| HTML | 120 | 60 | 20 | 200 |
-| CSS | 120 | 60 | 20 | 200 |
-| C++ | 135 | 68 | 22 | 225 |
-| C | 135 | 68 | 22 | 225 |
-| Lua | 120 | 60 | 20 | 200 |
-| C# | 135 | 67 | 23 | 225 |
-| Rust | 135 | 67 | 23 | 225 |
-| **Total** | **1,200** | **600** | **200** | **2,000** |
-
-Programming tasks cover arithmetic and conditions, ASCII string transformations, filtered collection reductions, frequency tables, and short combinations of basic operations. JavaScript includes 20 browser DOM/event tasks. HTML tasks check elements, attributes, text, and nesting. CSS tasks check computed properties, selector scope, unaffected distractors, flex row/column geometry, and responsive breakpoints. No generated solution uses external packages.
+| Python | 75 | 38 | 12 | 125 |
+| JavaScript | 75 | 37 | 13 | 125 |
+| HTML | 60 | 30 | 10 | 100 |
+| CSS | 60 | 30 | 10 | 100 |
+| C++ | 68 | 34 | 11 | 113 |
+| C | 68 | 34 | 11 | 113 |
+| Lua | 60 | 30 | 10 | 100 |
+| C# | 67 | 34 | 11 | 112 |
+| Rust | 67 | 33 | 12 | 112 |
+| **Total** | **600** | **300** | **100** | **1,000** |
+
+Programming tasks cover arithmetic and conditions, ASCII string transformations, filtered collection reductions, frequency tables, and short combinations of basic operations. JavaScript includes 10 browser DOM/event tasks in the default subset. HTML tasks check elements, attributes, text, and nesting. CSS tasks check computed properties, selector scope, unaffected distractors, flex row/column geometry, and responsive breakpoints. No generated solution uses external packages.
 
 Tasks are original compositions from an explicit operation grammar, not scraped HumanEval/MBPP/MultiPL-E questions. Variants change operations and observable behavior, not just names or numbers. Shared tasks across programming languages are intentional translations for comparative coverage. Within each language, deterministic behavioral probe fingerprints reject equivalent programming tasks. Web tasks have unique structural specs. Trigram similarity flags are reported; the seven retained pairs differ in count versus sum and have distinct behavior. This is a finite behavioral/structural audit, not a mathematical proof of semantic uniqueness. Difficulty labels are design judgments; empirical calibration on small models remains future work.
 
@@ -66,7 +71,7 @@ python -m unittest discover -s tests -v
 python generators/build.py         # Deterministically regenerate all artifacts
 ```
 
-`validate.py` checks every reference against every hidden test and rejects a deliberately wrong solution for every task. For programming tasks it also checks a plausible near-miss mutation where the hidden inputs distinguish it (missing transformation stage, mapping, or filter). Failure stops validation with the task ID. Missing sandbox/runtime exits 2 and records unverified coverage. Static-only success never marks execution as passed. The reference ASTs for all 250 Python tasks are also parsed by the local unit suite.
+`validate.py` checks every reference against every hidden test and rejects a deliberately wrong solution for every task. For programming tasks it also checks a plausible near-miss mutation where the hidden inputs distinguish it (missing transformation stage, mapping, or filter). Failure stops validation with the task ID. Missing sandbox/runtime exits 2 and records unverified coverage. Static-only success never marks execution as passed. The reference ASTs for all 125 Python tasks are also parsed by the local unit suite.
 
 ## Evaluate a model
 
@@ -76,7 +81,7 @@ python evaluate.py --model HuggingFaceTB/SmolLM2-135M --output results.json --re
 python evaluate.py --model HuggingFaceTB/SmolLM2-135M --language python rust --difficulty easy --output subset.json
 ```
 
-One fixed completion prompt (`smolscript-completion-v1`), one generation, seed 0, greedy decoding, no beam search, and a fixed 384-token output cap. The same completion template is used for base and instruction models; no model-specific chat template is applied. The model revision resolves to an immutable commit and is retained on resume. Use `--revision SHA` for an explicit pin. Prompts contain only instructions, signature, input domain, and web fixture/base styles. References, public examples, hidden tests, and expected answers are never sent to the model.
+One fixed completion prompt (`smolscript-completion-v1`), one generation, seed 0, greedy decoding, no beam search, and versioned task budgets from 96 to 256 tokens. Starting batch size is 64, with automatic CUDA OOM backoff. Prompts are grouped by token budget and length; KV caching and supported last-token logits optimizations are enabled. Progress is reported between batches, avoiding per-token GPU-to-CPU synchronization. The same completion template is used for base and instruction models; no model-specific chat template is applied. The model revision resolves to an immutable commit and is retained on resume. Use `--revision SHA` for an explicit pin. Prompts contain only instructions, signature, input domain, and web fixture/base styles. References, public examples, hidden tests, and expected answers are never sent to the model.
 
 Existing files require `--resume`. Settings, dataset/runner hashes, image ID and selected IDs must match. Completed task results are checkpointed atomically; a generated response is saved before execution, so an execution interruption can reuse it. Partial runs never receive a full score. Use one process per output path (a file lock enforces this). Context overflow is an explicit failure; input prompts are never silently truncated.
 
@@ -108,3 +113,12 @@ metadata = json.loads(rows[0]['metadata'])
 ```
 
 The generator, runners and audit reports are included in this repository. Record the Hugging Face repository commit, manifest checksums, generation settings, dependency versions and image ID with any reported result.
+
+
+## Fast default (0.2.0)
+
+The default split and both local/Modal evaluators now use the same fixed 1,000 IDs, selected from the original edition by deterministic SHA256 ranking within language, difficulty, family and category strata. The selection manifest lists every ID and its hash. IDs, instructions, references and tests are preserved for selected tasks. The original 2,000-task edition is archived under `archive/v0.1.0`; Hugging Face users can request config `full2000`. Current evaluation commands use the 1,000-task edition.
+
+The language budgets (before a 32-token moderate-task allowance, capped at 256) are Python 128, JavaScript 192, HTML 160, CSS 96, C++ 224, C 256, Lua 160, C# 256, Rust 256. They depend only on language/difficulty, never reference solutions. `--max-new-tokens N` overrides these budgets for a separately recorded experiment; `--batch-size N` overrides the default 64. A response that hits its cap is scored as generated; incorrect or incomplete code still fails the normal execution tests. Generation statistics include token-limit completions, OOM retries, final batch size, elapsed generation time and measured token throughput.
+
+Example: `python evaluate.py --model HuggingFaceTB/SmolLM2-135M --batch-size 64 --output results-v020.json`. Generated batches are checkpointed before execution, and resume skips their inference. Numerical batching differences can change greedy outputs for near-tied logits. This release changes both the task count and output budgets, so its scores must not be merged with 0.1.0 results. Template IDs are `smolscript-0.2.0` and `cognirank2-v2`; use a new output path. No GPU throughput speedup is claimed without a measured run.

SHA256SUMS

@@ -1,27 +1,35 @@
 ff73ee904edc9381bd1ea24847e41c6176aec22ba4b63321e8354562f24ba5ce  .gitignore
 8719af4397a8387b8f04140613943545f8ecd90f06529dcab9e68a94927d13fe  LICENSE
-24908849b2c3cac77e1c0cc1aa82b943c4f8c377bc3930b526f0e4f49e1fa7de  README.md
-1926bca1b0c6b2244554577135a9c3c305b18fd834c654803b4e8480fff0d3d9  data/smolscript.jsonl
-7bf25948750648aa036bdf277cfd7c38597c98aa06131e805628b9055a7938d9  data/smolscript.parquet
-d6e1f0dddbe61bbcfa660cd2eaeaf4c2af2ebff06938f4bc046fce1223fc573a  evaluate.py
-b6a465089448e1c2eb7f26c981a1ad3e962d73a0433a337d4e781f4ca9525b65  examples/local-test-report.json
+e7fa9e12b2c6af5e6a6bc568386c408d279f8b71804f9c19eebb2c3968abd850  README.md
+2447d09ae445094c1ae59df644b46e3ca2f4cc64de630966b94bd5db8b8bf0ac  archive/v0.1.0/hidden.jsonl
+1926bca1b0c6b2244554577135a9c3c305b18fd834c654803b4e8480fff0d3d9  archive/v0.1.0/smolscript.jsonl
+7bf25948750648aa036bdf277cfd7c38597c98aa06131e805628b9055a7938d9  archive/v0.1.0/smolscript.parquet
+84d3411fe45189c62ae50fbd31c1dc5795bc099d5037c3a817e3d280f6097e83  archive/v0.1.0/solutions.jsonl
+1c17c3515e86e2c4bc25c84b45b9f086c87efd98e1d75a7f4b42772b9d88176e  data/smolscript.jsonl
+358eae399dac7564ea5fb8753734f189aea3932994a22779d543bdcce847e050  data/smolscript.parquet
+e2fb32b17e0cb933d08ee8cb87a19f5fa23861a5c37821946a45d9130b04305e  evaluate.py
+6bfe2567a060ed374e969977fdeba471888469abae6b177c8bfc142b8ab1d034  examples/local-test-report.json
 713855348ffc53f49b03a0df47b67294fe2d3593054636eec12b9f184fb3534e  examples/result-format.json
+504a839870b7e2c5612004fac14977d71affbf1601a151e7d7dc559e1ee4afc4  generation_settings.py
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  generators/__init__.py
-eeb947e9704931e5b23ed79aee180e4dd49708f9294d7481f51c7da2f5c33e7e  generators/build.py
+7747bc86067cc139f4e2803375ab1734ab6d6cb84b70c9e4aca75f099aac3f10  generators/build.py
 e1cf493b995f15470c56c097b73e7403ae06f74f5d12cbb3a43ce522514d8577  generators/code.py
 60be0a7ac6fcd3dfd8b663fc19af189aba3acfdd923219dc6cc1972033380240  generators/specs.py
+1e7fbc836f69bceef811880a81baf44cee6c087b884480c58937882eacbb4145  generators/subset.py
 ae6a8d5109035027b71df7eb7297e7c0b811a4a98c649e1729a3fe2a2c09c5bf  generators/web.py
-62a01609810b5c488f4a5abe284063b41b780c382046a9da7cc2a6ca755b5488  manifest.json
+dea4320cec258423c726362d0ba88f76e4dec089da0b9d2315b8f84d832bdf8d  manifest.json
 6bac32e6045f1788e8b68e96ff6ee41f1b2152cca1b17de24be405025f294930  metrics.py
-2447d09ae445094c1ae59df644b46e3ca2f4cc64de630966b94bd5db8b8bf0ac  private_tests/hidden.jsonl
-a2de1bc75c21817ba1883ee4c5aa04b60a0f4288f3f45893e1c7e71e435f1997  pyproject.toml
-84d3411fe45189c62ae50fbd31c1dc5795bc099d5037c3a817e3d280f6097e83  references/solutions.jsonl
+55c240d74282889fa2829fb307bf42649fb04876f5ebeb9e6f95cd934bcc105a  private_tests/hidden.jsonl
+21600943097b1154d2492a51d6c859ea0efcf37ff3b1c5c7c8a81f66c178135d  pyproject.toml
+34c7244ea9160ba090e7c3bc1802ca68cc882f8ee9c29736ea8529d499977677  references/solutions.jsonl
 5a3cb2a82cf3784c41fc9f9046fe6806d5bbe7ce8ae415a9ed1c373abcfe7826  runners/__init__.py
 965bc9e3dabfc3fba4b745994b43118c456be477edcc34a3ba929ebf39e19ce9  runners/c_runner.py
 47eaf32ac4ce76fcfbd01d515f6befccfcd2bf6c277447a73e8b7b58fa7e96f8  runners/common.py
 17c846633f3730669790ee2f11fc93661648eedc950c96d47996d0db4514672b  runners/cpp_runner.py
 e87545f911f6f25238b1f84ed0ac1602900676b77cb3dd5f1560cd62e0b931e4  runners/csharp_runner.py
 96e542ceb76e18759aa8f19fd87beef3612e535f7b9f04944a6bdf1e2fddffec  runners/css_runner.py
+09518f5cd7cc4898e3814bdf24750631f528c65ee1dce16acbf8941424a8fbfc  runners/hf_runtime.py
+72ec02e2935256b3480af0516ff827e047841dbcd46aca9f5bcfef7e0e9b1677  runners/hf_tokens.py
 3a02716d96a0061567f50514b5e5df3b30812ed21b524f772ebcb12de915f585  runners/html_runner.py
 21c05c048f2cfcc6e263645b6322527cd8869e6530f3bc8dc11aaf54bb777f5e  runners/javascript_runner.py
 2941363382d517261153a7d38a9f49c63fd2dbb4c52b851bc0d1726f8196f4e9  runners/lua_runner.py
@@ -30,9 +38,9 @@ efabd7a4b829eb917116a2f51358a8fa8056370dbb57f6b6a9646c1cd342ffc5  runners/python
 63514e35b2687742ea6453e15d089da5a6cb4ab57ca0100da6189b187511ecf7  runners/rust_runner.py
 824119581e0bf1c913059fdf506c26494c9aa2f65f718f08630ff5fe74779ff3  runners/sandbox.py
 4fb1552346d86503372e6762f3ddcb0fc7e7e0be2cc1209f419b7c5e37aeccdc  sandbox/Dockerfile
-39adc44592af2d485b8755baa0b90b94e987b8a76b37dd70cc7c879285b6faaa  sandbox/worker.py
-eb5c448ef50f2a7f4f08be8d9b6a0d9719180c6c144b56b8514803312338902b  tests/test_core.py
-44d0be27ea6bb4050d2e6cfdcc0926400999e8cea3f62ed0bba5303231a424ab  validate.py
-cb6e2f58736c45a63635c574ed989ff7910ad2cb81ad59f8a444594c78066ab4  validation_report.json
+331503e3e4ef8dfce8c82caee8face396275c272b43c7cd61bcca1f535db76ad  sandbox/worker.py
+97cbf114bf5c4a9fa5065888b6f8499ae68a49d98f8133674c31b5a2697ddac2  tests/test_core.py
+402d9fc0fce6516ae7aa962d5441cbd6f8b15ba4eab1131d3effc9b20344c20a  validate.py
+a445f277404f0265fd1aec441067e9e9bb34fb03b36becbe95f7bc6de94ff9c5  validation_report.json
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  validators/__init__.py
-c21a19dd9e2b362c6634eac0334765d0b6edf0a567bba61a234b3d40bdb13612  validators/dataset.py
+c13c13f6c5bc16c3e36a3f2b811164fbef2ba8af44857d9ff6a725ec79325a98  validators/dataset.py

evaluate.py

@@ -11,6 +11,7 @@ from runners.sandbox import Sandbox
 from metrics import aggregate
 ROOT=Path(__file__).resolve().parent
 PROMPT_VERSION='smolscript-completion-v1'
+from generation_settings import PROTOCOL,DEFAULT_BATCH_SIZE,token_budget
 
 def prompt(row):
     # Only these public fields reach the model. No tests, answers or references.
@@ -26,16 +27,17 @@ def main():
     p=argparse.ArgumentParser(description=__doc__);p.add_argument('--model');p.add_argument('--revision',default='main');p.add_argument('--output',type=Path,required=True)
     p.add_argument('--language',nargs='+',choices=LANGUAGES);p.add_argument('--difficulty',nargs='+',choices=('easy','medium','moderate'))
     p.add_argument('--resume',action='store_true');p.add_argument('--predictions',type=Path,help='JSONL with id and code; bypass model inference')
-    p.add_argument('--image',default='smolscript-runtime:0.1.0');p.add_argument('--engine',default='docker');p.add_argument('--max-new-tokens',type=int,default=384);p.add_argument('--device',default='auto');a=p.parse_args()
+    p.add_argument('--image',default='smolscript-runtime:0.1.0');p.add_argument('--engine',default='docker');p.add_argument('--max-new-tokens',type=int,default=None);p.add_argument('--device',default='auto');p.add_argument('--batch-size',type=int,default=DEFAULT_BATCH_SIZE);a=p.parse_args()
     if not a.model and not a.predictions:p.error('--model or --predictions required')
-    if a.max_new_tokens<1:p.error('--max-new-tokens must be positive')
+    if a.max_new_tokens is not None and a.max_new_tokens<1:p.error('--max-new-tokens must be positive')
+    if a.batch_size<1:p.error('--batch-size must be positive')
     sandbox=Sandbox(a.image,a.engine)
     rows=[r for r in load(ROOT/'data/smolscript.jsonl') if (not a.language or r['language'] in a.language) and (not a.difficulty or r['difficulty'] in a.difficulty)]
     hidden={r['id']:r for r in load(ROOT/'private_tests/hidden.jsonl')}
-    files=['data/smolscript.jsonl','private_tests/hidden.jsonl','evaluate.py','metrics.py']+[str(p.relative_to(ROOT)) for p in sorted((ROOT/'runners').glob('*.py'))]+['sandbox/worker.py']
+    files=['data/smolscript.jsonl','private_tests/hidden.jsonl','evaluate.py','metrics.py','generation_settings.py']+[str(p.relative_to(ROOT)) for p in sorted((ROOT/'runners').glob('*.py'))]+['sandbox/worker.py']
     fingerprint={f:hashlib.sha256((ROOT/f).read_bytes()).hexdigest() for f in files}
     settings={'model':a.model,'requested_revision':a.revision,'language':a.language,'difficulty':a.difficulty,
-       'max_new_tokens':a.max_new_tokens,'prompt_version':PROMPT_VERSION,'dataset':fingerprint,'sandbox':sandbox.identity,
+       'max_new_tokens':a.max_new_tokens,'batch_size':a.batch_size,'decode_protocol':PROTOCOL,'prompt_version':PROMPT_VERSION,'dataset':fingerprint,'sandbox':sandbox.identity,
        'predictions_sha':hashlib.sha256(a.predictions.read_bytes()).hexdigest() if a.predictions else None}
     if a.output.exists() and not a.resume:p.error('Output exists; use --resume or a new path')
     state=json.loads(a.output.read_text()) if a.output.exists() else {'settings':settings,'results':[],'complete':False}
@@ -63,20 +65,31 @@ def main():
         done={r['id'] for r in state['results']}
         if len(done)!=len(state['results']) or done-set(r['id'] for r in rows):raise ValueError('Corrupt resume IDs')
         save(a.output,state)
+        if not a.predictions:
+            from runners.hf_runtime import Progress,generate_batches
+            generated=state.setdefault('generations',{})
+            if state.get('pending'):generated[state['pending']['id']]=state['pending']['generation']
+            pending=[r for r in rows if r['id'] not in done and r['id'] not in generated]
+            if tokenizer.pad_token_id is None:tokenizer.pad_token=tokenizer.eos_token
+            tokenizer.padding_side='left'
+            encoded=tokenizer([prompt(r) for r in pending],return_token_type_ids=False) if pending else {'input_ids':[],'attention_mask':[]}
+            compiled={r['id']:{'input_ids':encoded['input_ids'][i],'attention_mask':encoded['attention_mask'][i]} for i,r in enumerate(pending)}
+            budgets={r['id']:a.max_new_tokens or token_budget(r) for r in pending}
+            native=getattr(model.config,'max_position_embeddings',getattr(model.config,'n_positions',4096))
+            for r in pending:
+                if len(compiled[r['id']]['input_ids'])+budgets[r['id']]>native:
+                    raise ValueError('Insufficient context for generation: '+r['id'])
+            def emit(batch):
+                generated.update({rid:text for rid,text,_ in batch});save(a.output,state)
+            with Progress('SmolScript',len(pending)) as progress:
+                state['generation_stats']=generate_batches(model,tokenizer,compiled,pending,
+                    lambda r:budgets[r['id']],a.batch_size,emit,progress,stream_tokens=False)
         for row in rows:
             if row['id'] in done:continue
-            if state.get('pending',{}).get('id')==row['id']:
-                text=state['pending']['generation']
-            elif a.predictions:
+            if a.predictions:
                 if row['id'] not in codes:raise ValueError('Missing prediction '+row['id'])
                 text=codes[row['id']]
-            else:
-                encoded=tokenizer(prompt(row),return_tensors='pt',return_token_type_ids=False).to(model.device)
-                native=getattr(model.config,'max_position_embeddings',getattr(model.config,'n_positions',4096))
-                if encoded['input_ids'].shape[1]+a.max_new_tokens>native:
-                    raise ValueError('Insufficient context for fixed generation settings: '+row['id'])
-                with torch.inference_mode():out=model.generate(**encoded,max_new_tokens=a.max_new_tokens,do_sample=False,num_beams=1,pad_token_id=tokenizer.pad_token_id if tokenizer.pad_token_id is not None else tokenizer.eos_token_id)
-                text=tokenizer.decode(out[0,encoded['input_ids'].shape[1]:],skip_special_tokens=True)
+            else:text=state['generations'][row['id']]
             state['pending']={'id':row['id'],'generation':text};save(a.output,state)
             try:code=extract_code(text)
             except ValueError as e:result={'passed':False,'syntax_success':False,'tests':[],'error':str(e)}

examples/local-test-report.json

@@ -1,25 +1,26 @@
 {
   "unit_tests": {
-    "passed": 8,
+    "passed": 10,
     "command": "python -m unittest discover -s tests -q"
   },
-  "python_reference_ast_parse": 250,
+  "python_reference_ast_parse": 125,
   "candidate_execution_on_host": false,
   "reference_execution": {
     "verified": 0,
-    "unverified": 2000
+    "unverified": 1000
   },
   "unverified_by_language": {
-    "python": 250,
-    "javascript": 250,
-    "html": 200,
-    "css": 200,
-    "cpp": 225,
-    "c": 225,
-    "lua": 200,
-    "csharp": 225,
-    "rust": 225
+    "python": 125,
+    "javascript": 125,
+    "html": 100,
+    "css": 100,
+    "cpp": 113,
+    "c": 113,
+    "lua": 100,
+    "csharp": 112,
+    "rust": 112
   },
-  "blocked_reason": "Docker/Podman unavailable; no isolated runtime for reference and negative-control execution.",
-  "model_baselines": "not run"
+  "blocked_reason": "Docker/Podman unavailable; full isolated reference and negative-control execution remains unverified.",
+  "model_baselines": "not run",
+  "gpu_throughput_benchmark": "not run"
 }

generation_settings.py

@@ -0,0 +1,8 @@
+"""Versioned decoding policy; never reads references or hidden answers."""
+PROTOCOL='smolscript-0.2.0'
+DEFAULT_BATCH_SIZE=64
+MAX_NEW_TOKENS=256
+
+def token_budget(row):
+    base={'python':128,'javascript':192,'html':160,'css':96,'cpp':224,'c':256,'lua':160,'csharp':256,'rust':256}[row['language']]
+    return min(MAX_NEW_TOKENS,base+(32 if row['difficulty']=='moderate' else 0))

generators/build.py

@@ -9,10 +9,11 @@ from generators.specs import task_specs,oracle,probes
 from generators.code import render,signature
 from generators.web import html_tasks,css_tasks,dom_tasks,BASE_CSS
 
-ALLOCATION={'python':(150,75,25),'javascript':(150,75,25),'html':(120,60,20),'css':(120,60,20),
+FULL_ALLOCATION={'python':(150,75,25),'javascript':(150,75,25),'html':(120,60,20),'css':(120,60,20),
             'cpp':(135,68,22),'c':(135,68,22),'lua':(120,60,20),'csharp':(135,67,23),'rust':(135,67,23)}
 NAMES={'python':'Python','javascript':'JavaScript','html':'HTML','css':'CSS','cpp':'C++','c':'C','lua':'Lua','csharp':'C#','rust':'Rust'}
 VERSION='smolscript-0.1.0'
+from generators.subset import ALLOCATION,select,VERSION as DEFAULT_VERSION
 
 def stable(value):return json.dumps(value,sort_keys=True,separators=(',',':'),ensure_ascii=False)
 def sha(value):return hashlib.sha256(stable(value).encode()).hexdigest()
@@ -38,7 +39,7 @@ def build():
             if discrimination(best)==0:raise ValueError('Cannot distinguish hidden tasks')
             chosen.append(best)
         suites[kind]=chosen
-    for lang,counts in ALLOCATION.items():
+    for lang,counts in FULL_ALLOCATION.items():
         items=[]
         if lang in ('html','css'):items=html_tasks() if lang=='html' else css_tasks()
         else:
@@ -94,6 +95,19 @@ def build():
                  'timeout_seconds':3,'metadata':metadata}
             public.append(row);private.append({'id':rid,'tests':hidden,'spec':spec});references.append({'id':rid,'reference_solution':reference})
     assert len(public)==2000
+    # Preserve the original edition outside the default HF split.
+    archive=ROOT/'archive/v0.1.0'
+    archive.mkdir(parents=True,exist_ok=True)
+    write_rows(archive/'smolscript.jsonl',public)
+    write_rows(archive/'hidden.jsonl',private)
+    write_rows(archive/'solutions.jsonl',references)
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    pq.write_table(pa.Table.from_pylist([{**r,'tests':stable(r['tests']),'metadata':stable(r['metadata'])} for r in public]),archive/'smolscript.parquet',compression='zstd')
+    public=select(public)
+    ids={r['id'] for r in public}
+    private=[r for r in private if r['id'] in ids]
+    references=[r for r in references if r['id'] in ids]
     for directory in ('data','private_tests','references'): (ROOT/directory).mkdir(exist_ok=True)
     write_rows(ROOT/'data/smolscript.jsonl',public)
     write_rows(ROOT/'private_tests/hidden.jsonl',private)
@@ -103,12 +117,14 @@ def build():
     # HF-compatible nested metadata; JSON strings give consistent test schemas across modalities.
     parquet_rows=[{**r,'tests':stable(r['tests']),'metadata':stable(r['metadata'])} for r in public]
     pq.write_table(pa.Table.from_pylist(parquet_rows),ROOT/'data/smolscript.parquet',compression='zstd')
-    manifest={'version':VERSION,'examples':2000,'languages':{k:sum(v) for k,v in ALLOCATION.items()},
-              'difficulty':{'easy':1200,'medium':600,'moderate':200},'generator_seed':7301,
-              'validation_status':'execution_unverified','files':{}}
+    manifest={'version':DEFAULT_VERSION,'examples':1000,'languages':{k:sum(v) for k,v in ALLOCATION.items()},
+              'difficulty':{'easy':600,'medium':300,'moderate':100},'generator_seed':7301,
+              'validation_status':'execution_unverified','selection_protocol':DEFAULT_VERSION,
+              'selected_ids':[r['id'] for r in public],
+              'selection_sha256':hashlib.sha256(('\n'.join(r['id'] for r in public)+'\n').encode()).hexdigest(),'files':{}}
     for name in ('data/smolscript.jsonl','data/smolscript.parquet','private_tests/hidden.jsonl','references/solutions.jsonl'):
         manifest['files'][name]=hashlib.sha256((ROOT/name).read_bytes()).hexdigest()
     (ROOT/'manifest.json').write_text(json.dumps(manifest,indent=2)+'\n')
-    print('Generated exactly 2000 examples and matching private tests/references.')
+    print('Generated fixed 1000-example default; archived original 2000 tasks.')
 
 if __name__=='__main__':build()

generators/subset.py

@@ -0,0 +1,23 @@
+"""Fixed 1,000-task default, stratified by language/difficulty/task family."""
+from collections import defaultdict
+import hashlib
+ALLOCATION={'python':(75,38,12),'javascript':(75,37,13),'html':(60,30,10),'css':(60,30,10),
+            'cpp':(68,34,11),'c':(68,34,11),'lua':(60,30,10),'csharp':(67,34,11),'rust':(67,33,12)}
+VERSION='smolscript-0.2.0'
+
+def select(rows):
+    chosen=set()
+    for lang,counts in ALLOCATION.items():
+        for diff,count in zip(('easy','medium','moderate'),counts):
+            groups=defaultdict(list)
+            for r in rows:
+                if r['language']==lang and r['difficulty']==diff:groups[(r['metadata']['family'],r['category'])].append(r)
+            total=sum(map(len,groups.values()))
+            quotas={k:count*len(v)//total for k,v in groups.items()}
+            for k in sorted(groups,key=lambda k:(-(count*len(groups[k])%total),k))[:count-sum(quotas.values())]:quotas[k]+=1
+            for k,group in groups.items():
+                ranked=sorted(group,key=lambda r:hashlib.sha256((VERSION+':'+r['id']).encode()).digest())
+                chosen.update(r['id'] for r in ranked[:quotas[k]])
+    result=[{**r,'metadata':{**r['metadata'],'protocol':VERSION}} for r in rows if r['id'] in chosen]
+    assert len(result)==1000
+    return result

manifest.json

@@ -1,28 +1,1032 @@
 {
-  "version": "smolscript-0.1.0",
-  "examples": 2000,
+  "version": "smolscript-0.2.0",
+  "examples": 1000,
   "languages": {
-    "python": 250,
-    "javascript": 250,
-    "html": 200,
-    "css": 200,
-    "cpp": 225,
-    "c": 225,
-    "lua": 200,
-    "csharp": 225,
-    "rust": 225
+    "python": 125,
+    "javascript": 125,
+    "html": 100,
+    "css": 100,
+    "cpp": 113,
+    "c": 113,
+    "lua": 100,
+    "csharp": 112,
+    "rust": 112
   },
   "difficulty": {
-    "easy": 1200,
-    "medium": 600,
-    "moderate": 200
+    "easy": 600,
+    "medium": 300,
+    "moderate": 100
   },
   "generator_seed": 7301,
   "validation_status": "execution_unverified",
+  "selection_protocol": "smolscript-0.2.0",
+  "selected_ids": [
+    "smolscript-python-0003",
+    "smolscript-python-0004",
+    "smolscript-python-0006",
+    "smolscript-python-0007",
+    "smolscript-python-0008",
+    "smolscript-python-0011",
+    "smolscript-python-0015",
+    "smolscript-python-0020",
+    "smolscript-python-0023",
+    "smolscript-python-0024",
+    "smolscript-python-0025",
+    "smolscript-python-0027",
+    "smolscript-python-0028",
+    "smolscript-python-0030",
+    "smolscript-python-0033",
+    "smolscript-python-0035",
+    "smolscript-python-0036",
+    "smolscript-python-0038",
+    "smolscript-python-0039",
+    "smolscript-python-0041",
+    "smolscript-python-0044",
+    "smolscript-python-0047",
+    "smolscript-python-0048",
+    "smolscript-python-0050",
+    "smolscript-python-0054",
+    "smolscript-python-0056",
+    "smolscript-python-0058",
+    "smolscript-python-0059",
+    "smolscript-python-0061",
+    "smolscript-python-0066",
+    "smolscript-python-0067",
+    "smolscript-python-0068",
+    "smolscript-python-0069",
+    "smolscript-python-0070",
+    "smolscript-python-0073",
+    "smolscript-python-0074",
+    "smolscript-python-0075",
+    "smolscript-python-0076",
+    "smolscript-python-0078",
+    "smolscript-python-0080",
+    "smolscript-python-0081",
+    "smolscript-python-0082",
+    "smolscript-python-0084",
+    "smolscript-python-0087",
+    "smolscript-python-0091",
+    "smolscript-python-0092",
+    "smolscript-python-0095",
+    "smolscript-python-0098",
+    "smolscript-python-0099",
+    "smolscript-python-0101",
+    "smolscript-python-0104",
+    "smolscript-python-0107",
+    "smolscript-python-0108",
+    "smolscript-python-0113",
+    "smolscript-python-0114",
+    "smolscript-python-0115",
+    "smolscript-python-0119",
+    "smolscript-python-0123",
+    "smolscript-python-0126",
+    "smolscript-python-0130",
+    "smolscript-python-0131",
+    "smolscript-python-0132",
+    "smolscript-python-0133",
+    "smolscript-python-0134",
+    "smolscript-python-0135",
+    "smolscript-python-0136",
+    "smolscript-python-0137",
+    "smolscript-python-0138",
+    "smolscript-python-0139",
+    "smolscript-python-0141",
+    "smolscript-python-0143",
+    "smolscript-python-0145",
+    "smolscript-python-0147",
+    "smolscript-python-0148",
+    "smolscript-python-0149",
+    "smolscript-python-0152",
+    "smolscript-python-0153",
+    "smolscript-python-0155",
+    "smolscript-python-0156",
+    "smolscript-python-0158",
+    "smolscript-python-0159",
+    "smolscript-python-0160",
+    "smolscript-python-0161",
+    "smolscript-python-0167",
+    "smolscript-python-0168",
+    "smolscript-python-0169",
+    "smolscript-python-0174",
+    "smolscript-python-0176",
+    "smolscript-python-0177",
+    "smolscript-python-0179",
+    "smolscript-python-0181",
+    "smolscript-python-0183",
+    "smolscript-python-0184",
+    "smolscript-python-0188",
+    "smolscript-python-0190",
+    "smolscript-python-0192",
+    "smolscript-python-0193",
+    "smolscript-python-0194",
+    "smolscript-python-0196",
+    "smolscript-python-0197",
+    "smolscript-python-0199",
+    "smolscript-python-0200",
+    "smolscript-python-0203",
+    "smolscript-python-0205",
+    "smolscript-python-0208",
+    "smolscript-python-0209",
+    "smolscript-python-0213",
+    "smolscript-python-0215",
+    "smolscript-python-0217",
+    "smolscript-python-0218",
+    "smolscript-python-0219",
+    "smolscript-python-0222",
+    "smolscript-python-0223",
+    "smolscript-python-0226",
+    "smolscript-python-0229",
+    "smolscript-python-0230",
+    "smolscript-python-0231",
+    "smolscript-python-0232",
+    "smolscript-python-0236",
+    "smolscript-python-0237",
+    "smolscript-python-0238",
+    "smolscript-python-0242",
+    "smolscript-python-0243",
+    "smolscript-python-0245",
+    "smolscript-python-0246",
+    "smolscript-javascript-0001",
+    "smolscript-javascript-0002",
+    "smolscript-javascript-0004",
+    "smolscript-javascript-0009",
+    "smolscript-javascript-0010",
+    "smolscript-javascript-0012",
+    "smolscript-javascript-0014",
+    "smolscript-javascript-0015",
+    "smolscript-javascript-0016",
+    "smolscript-javascript-0017",
+    "smolscript-javascript-0018",
+    "smolscript-javascript-0021",
+    "smolscript-javascript-0024",
+    "smolscript-javascript-0025",
+    "smolscript-javascript-0027",
+    "smolscript-javascript-0029",
+    "smolscript-javascript-0030",
+    "smolscript-javascript-0031",
+    "smolscript-javascript-0035",
+    "smolscript-javascript-0036",
+    "smolscript-javascript-0037",
+    "smolscript-javascript-0038",
+    "smolscript-javascript-0039",
+    "smolscript-javascript-0040",
+    "smolscript-javascript-0042",
+    "smolscript-javascript-0043",
+    "smolscript-javascript-0044",
+    "smolscript-javascript-0047",
+    "smolscript-javascript-0049",
+    "smolscript-javascript-0051",
+    "smolscript-javascript-0052",
+    "smolscript-javascript-0054",
+    "smolscript-javascript-0055",
+    "smolscript-javascript-0056",
+    "smolscript-javascript-0059",
+    "smolscript-javascript-0060",
+    "smolscript-javascript-0063",
+    "smolscript-javascript-0065",
+    "smolscript-javascript-0066",
+    "smolscript-javascript-0067",
+    "smolscript-javascript-0074",
+    "smolscript-javascript-0077",
+    "smolscript-javascript-0078",
+    "smolscript-javascript-0081",
+    "smolscript-javascript-0082",
+    "smolscript-javascript-0088",
+    "smolscript-javascript-0093",
+    "smolscript-javascript-0094",
+    "smolscript-javascript-0095",
+    "smolscript-javascript-0096",
+    "smolscript-javascript-0097",
+    "smolscript-javascript-0099",
+    "smolscript-javascript-0101",
+    "smolscript-javascript-0102",
+    "smolscript-javascript-0103",
+    "smolscript-javascript-0106",
+    "smolscript-javascript-0108",
+    "smolscript-javascript-0111",
+    "smolscript-javascript-0114",
+    "smolscript-javascript-0116",
+    "smolscript-javascript-0118",
+    "smolscript-javascript-0119",
+    "smolscript-javascript-0122",
+    "smolscript-javascript-0123",
+    "smolscript-javascript-0124",
+    "smolscript-javascript-0125",
+    "smolscript-javascript-0131",
+    "smolscript-javascript-0132",
+    "smolscript-javascript-0135",
+    "smolscript-javascript-0138",
+    "smolscript-javascript-0144",
+    "smolscript-javascript-0145",
+    "smolscript-javascript-0146",
+    "smolscript-javascript-0149",
+    "smolscript-javascript-0150",
+    "smolscript-javascript-0151",
+    "smolscript-javascript-0152",
+    "smolscript-javascript-0153",
+    "smolscript-javascript-0154",
+    "smolscript-javascript-0156",
+    "smolscript-javascript-0157",
+    "smolscript-javascript-0159",
+    "smolscript-javascript-0161",
+    "smolscript-javascript-0163",
+    "smolscript-javascript-0164",
+    "smolscript-javascript-0165",
+    "smolscript-javascript-0166",
+    "smolscript-javascript-0167",
+    "smolscript-javascript-0168",
+    "smolscript-javascript-0169",
+    "smolscript-javascript-0170",
+    "smolscript-javascript-0171",
+    "smolscript-javascript-0177",
+    "smolscript-javascript-0178",
+    "smolscript-javascript-0179",
+    "smolscript-javascript-0182",
+    "smolscript-javascript-0185",
+    "smolscript-javascript-0187",
+    "smolscript-javascript-0188",
+    "smolscript-javascript-0194",
+    "smolscript-javascript-0199",
+    "smolscript-javascript-0201",
+    "smolscript-javascript-0204",
+    "smolscript-javascript-0209",
+    "smolscript-javascript-0210",
+    "smolscript-javascript-0213",
+    "smolscript-javascript-0216",
+    "smolscript-javascript-0217",
+    "smolscript-javascript-0219",
+    "smolscript-javascript-0220",
+    "smolscript-javascript-0223",
+    "smolscript-javascript-0226",
+    "smolscript-javascript-0227",
+    "smolscript-javascript-0228",
+    "smolscript-javascript-0229",
+    "smolscript-javascript-0232",
+    "smolscript-javascript-0234",
+    "smolscript-javascript-0235",
+    "smolscript-javascript-0240",
+    "smolscript-javascript-0241",
+    "smolscript-javascript-0242",
+    "smolscript-javascript-0243",
+    "smolscript-javascript-0246",
+    "smolscript-javascript-0247",
+    "smolscript-javascript-0250",
+    "smolscript-html-0003",
+    "smolscript-html-0004",
+    "smolscript-html-0007",
+    "smolscript-html-0008",
+    "smolscript-html-0015",
+    "smolscript-html-0017",
+    "smolscript-html-0019",
+    "smolscript-html-0020",
+    "smolscript-html-0022",
+    "smolscript-html-0023",
+    "smolscript-html-0025",
+    "smolscript-html-0027",
+    "smolscript-html-0028",
+    "smolscript-html-0031",
+    "smolscript-html-0034",
+    "smolscript-html-0035",
+    "smolscript-html-0036",
+    "smolscript-html-0037",
+    "smolscript-html-0038",
+    "smolscript-html-0039",
+    "smolscript-html-0040",
+    "smolscript-html-0042",
+    "smolscript-html-0045",
+    "smolscript-html-0047",
+    "smolscript-html-0048",
+    "smolscript-html-0049",
+    "smolscript-html-0050",
+    "smolscript-html-0054",
+    "smolscript-html-0059",
+    "smolscript-html-0061",
+    "smolscript-html-0062",
+    "smolscript-html-0065",
+    "smolscript-html-0067",
+    "smolscript-html-0069",
+    "smolscript-html-0074",
+    "smolscript-html-0075",
+    "smolscript-html-0076",
+    "smolscript-html-0079",
+    "smolscript-html-0080",
+    "smolscript-html-0082",
+    "smolscript-html-0088",
+    "smolscript-html-0089",
+    "smolscript-html-0091",
+    "smolscript-html-0093",
+    "smolscript-html-0094",
+    "smolscript-html-0095",
+    "smolscript-html-0096",
+    "smolscript-html-0097",
+    "smolscript-html-0098",
+    "smolscript-html-0100",
+    "smolscript-html-0101",
+    "smolscript-html-0106",
+    "smolscript-html-0107",
+    "smolscript-html-0110",
+    "smolscript-html-0112",
+    "smolscript-html-0114",
+    "smolscript-html-0116",
+    "smolscript-html-0118",
+    "smolscript-html-0119",
+    "smolscript-html-0120",
+    "smolscript-html-0121",
+    "smolscript-html-0122",
+    "smolscript-html-0123",
+    "smolscript-html-0125",
+    "smolscript-html-0127",
+    "smolscript-html-0129",
+    "smolscript-html-0130",
+    "smolscript-html-0132",
+    "smolscript-html-0133",
+    "smolscript-html-0135",
+    "smolscript-html-0141",
+    "smolscript-html-0142",
+    "smolscript-html-0143",
+    "smolscript-html-0146",
+    "smolscript-html-0150",
+    "smolscript-html-0152",
+    "smolscript-html-0159",
+    "smolscript-html-0160",
+    "smolscript-html-0161",
+    "smolscript-html-0163",
+    "smolscript-html-0164",
+    "smolscript-html-0165",
+    "smolscript-html-0166",
+    "smolscript-html-0167",
+    "smolscript-html-0169",
+    "smolscript-html-0170",
+    "smolscript-html-0171",
+    "smolscript-html-0176",
+    "smolscript-html-0178",
+    "smolscript-html-0179",
+    "smolscript-html-0182",
+    "smolscript-html-0184",
+    "smolscript-html-0186",
+    "smolscript-html-0188",
+    "smolscript-html-0190",
+    "smolscript-html-0192",
+    "smolscript-html-0195",
+    "smolscript-html-0198",
+    "smolscript-html-0199",
+    "smolscript-html-0200",
+    "smolscript-css-0006",
+    "smolscript-css-0007",
+    "smolscript-css-0009",
+    "smolscript-css-0010",
+    "smolscript-css-0011",
+    "smolscript-css-0012",
+    "smolscript-css-0013",
+    "smolscript-css-0015",
+    "smolscript-css-0019",
+    "smolscript-css-0020",
+    "smolscript-css-0021",
+    "smolscript-css-0023",
+    "smolscript-css-0026",
+    "smolscript-css-0027",
+    "smolscript-css-0028",
+    "smolscript-css-0030",
+    "smolscript-css-0035",
+    "smolscript-css-0037",
+    "smolscript-css-0039",
+    "smolscript-css-0041",
+    "smolscript-css-0042",
+    "smolscript-css-0043",
+    "smolscript-css-0044",
+    "smolscript-css-0046",
+    "smolscript-css-0047",
+    "smolscript-css-0049",
+    "smolscript-css-0050",
+    "smolscript-css-0054",
+    "smolscript-css-0055",
+    "smolscript-css-0056",
+    "smolscript-css-0058",
+    "smolscript-css-0060",
+    "smolscript-css-0061",
+    "smolscript-css-0062",
+    "smolscript-css-0063",
+    "smolscript-css-0066",
+    "smolscript-css-0067",
+    "smolscript-css-0068",
+    "smolscript-css-0071",
+    "smolscript-css-0072",
+    "smolscript-css-0073",
+    "smolscript-css-0074",
+    "smolscript-css-0076",
+    "smolscript-css-0079",
+    "smolscript-css-0086",
+    "smolscript-css-0091",
+    "smolscript-css-0095",
+    "smolscript-css-0096",
+    "smolscript-css-0102",
+    "smolscript-css-0103",
+    "smolscript-css-0106",
+    "smolscript-css-0108",
+    "smolscript-css-0109",
+    "smolscript-css-0110",
+    "smolscript-css-0111",
+    "smolscript-css-0112",
+    "smolscript-css-0113",
+    "smolscript-css-0114",
+    "smolscript-css-0115",
+    "smolscript-css-0120",
+    "smolscript-css-0122",
+    "smolscript-css-0123",
+    "smolscript-css-0124",
+    "smolscript-css-0127",
+    "smolscript-css-0133",
+    "smolscript-css-0135",
+    "smolscript-css-0136",
+    "smolscript-css-0138",
+    "smolscript-css-0140",
+    "smolscript-css-0143",
+    "smolscript-css-0146",
+    "smolscript-css-0147",
+    "smolscript-css-0149",
+    "smolscript-css-0153",
+    "smolscript-css-0156",
+    "smolscript-css-0157",
+    "smolscript-css-0158",
+    "smolscript-css-0159",
+    "smolscript-css-0160",
+    "smolscript-css-0163",
+    "smolscript-css-0165",
+    "smolscript-css-0166",
+    "smolscript-css-0168",
+    "smolscript-css-0169",
+    "smolscript-css-0170",
+    "smolscript-css-0171",
+    "smolscript-css-0173",
+    "smolscript-css-0176",
+    "smolscript-css-0178",
+    "smolscript-css-0179",
+    "smolscript-css-0181",
+    "smolscript-css-0187",
+    "smolscript-css-0189",
+    "smolscript-css-0190",
+    "smolscript-css-0191",
+    "smolscript-css-0195",
+    "smolscript-css-0196",
+    "smolscript-css-0197",
+    "smolscript-css-0199",
+    "smolscript-css-0200",
+    "smolscript-cpp-0001",
+    "smolscript-cpp-0003",
+    "smolscript-cpp-0007",
+    "smolscript-cpp-0008",
+    "smolscript-cpp-0012",
+    "smolscript-cpp-0013",
+    "smolscript-cpp-0018",
+    "smolscript-cpp-0020",
+    "smolscript-cpp-0022",
+    "smolscript-cpp-0023",
+    "smolscript-cpp-0025",
+    "smolscript-cpp-0029",
+    "smolscript-cpp-0032",
+    "smolscript-cpp-0033",
+    "smolscript-cpp-0035",
+    "smolscript-cpp-0037",
+    "smolscript-cpp-0038",
+    "smolscript-cpp-0040",
+    "smolscript-cpp-0044",
+    "smolscript-cpp-0046",
+    "smolscript-cpp-0048",
+    "smolscript-cpp-0049",
+    "smolscript-cpp-0050",
+    "smolscript-cpp-0053",
+    "smolscript-cpp-0054",
+    "smolscript-cpp-0058",
+    "smolscript-cpp-0059",
+    "smolscript-cpp-0060",
+    "smolscript-cpp-0061",
+    "smolscript-cpp-0062",
+    "smolscript-cpp-0064",
+    "smolscript-cpp-0065",
+    "smolscript-cpp-0067",
+    "smolscript-cpp-0072",
+    "smolscript-cpp-0073",
+    "smolscript-cpp-0074",
+    "smolscript-cpp-0077",
+    "smolscript-cpp-0078",
+    "smolscript-cpp-0079",
+    "smolscript-cpp-0080",
+    "smolscript-cpp-0081",
+    "smolscript-cpp-0082",
+    "smolscript-cpp-0084",
+    "smolscript-cpp-0085",
+    "smolscript-cpp-0086",
+    "smolscript-cpp-0087",
+    "smolscript-cpp-0089",
+    "smolscript-cpp-0090",
+    "smolscript-cpp-0093",
+    "smolscript-cpp-0094",
+    "smolscript-cpp-0095",
+    "smolscript-cpp-0096",
+    "smolscript-cpp-0097",
+    "smolscript-cpp-0098",
+    "smolscript-cpp-0099",
+    "smolscript-cpp-0100",
+    "smolscript-cpp-0101",
+    "smolscript-cpp-0107",
+    "smolscript-cpp-0108",
+    "smolscript-cpp-0111",
+    "smolscript-cpp-0113",
+    "smolscript-cpp-0115",
+    "smolscript-cpp-0118",
+    "smolscript-cpp-0121",
+    "smolscript-cpp-0122",
+    "smolscript-cpp-0126",
+    "smolscript-cpp-0132",
+    "smolscript-cpp-0135",
+    "smolscript-cpp-0136",
+    "smolscript-cpp-0137",
+    "smolscript-cpp-0140",
+    "smolscript-cpp-0142",
+    "smolscript-cpp-0143",
+    "smolscript-cpp-0144",
+    "smolscript-cpp-0146",
+    "smolscript-cpp-0147",
+    "smolscript-cpp-0149",
+    "smolscript-cpp-0150",
+    "smolscript-cpp-0151",
+    "smolscript-cpp-0153",
+    "smolscript-cpp-0154",
+    "smolscript-cpp-0155",
+    "smolscript-cpp-0156",
+    "smolscript-cpp-0157",
+    "smolscript-cpp-0160",
+    "smolscript-cpp-0164",
+    "smolscript-cpp-0165",
+    "smolscript-cpp-0168",
+    "smolscript-cpp-0169",
+    "smolscript-cpp-0175",
+    "smolscript-cpp-0176",
+    "smolscript-cpp-0177",
+    "smolscript-cpp-0178",
+    "smolscript-cpp-0181",
+    "smolscript-cpp-0184",
+    "smolscript-cpp-0186",
+    "smolscript-cpp-0187",
+    "smolscript-cpp-0191",
+    "smolscript-cpp-0194",
+    "smolscript-cpp-0197",
+    "smolscript-cpp-0199",
+    "smolscript-cpp-0201",
+    "smolscript-cpp-0204",
+    "smolscript-cpp-0205",
+    "smolscript-cpp-0207",
+    "smolscript-cpp-0210",
+    "smolscript-cpp-0212",
+    "smolscript-cpp-0213",
+    "smolscript-cpp-0215",
+    "smolscript-cpp-0216",
+    "smolscript-cpp-0218",
+    "smolscript-cpp-0220",
+    "smolscript-cpp-0222",
+    "smolscript-c-0001",
+    "smolscript-c-0002",
+    "smolscript-c-0008",
+    "smolscript-c-0013",
+    "smolscript-c-0014",
+    "smolscript-c-0016",
+    "smolscript-c-0017",
+    "smolscript-c-0019",
+    "smolscript-c-0022",
+    "smolscript-c-0023",
+    "smolscript-c-0024",
+    "smolscript-c-0025",
+    "smolscript-c-0026",
+    "smolscript-c-0030",
+    "smolscript-c-0031",
+    "smolscript-c-0032",
+    "smolscript-c-0034",
+    "smolscript-c-0037",
+    "smolscript-c-0038",
+    "smolscript-c-0039",
+    "smolscript-c-0041",
+    "smolscript-c-0044",
+    "smolscript-c-0045",
+    "smolscript-c-0051",
+    "smolscript-c-0057",
+    "smolscript-c-0058",
+    "smolscript-c-0060",
+    "smolscript-c-0062",
+    "smolscript-c-0066",
+    "smolscript-c-0067",
+    "smolscript-c-0068",
+    "smolscript-c-0072",
+    "smolscript-c-0073",
+    "smolscript-c-0075",
+    "smolscript-c-0077",
+    "smolscript-c-0078",
+    "smolscript-c-0081",
+    "smolscript-c-0083",
+    "smolscript-c-0085",
+    "smolscript-c-0086",
+    "smolscript-c-0089",
+    "smolscript-c-0091",
+    "smolscript-c-0092",
+    "smolscript-c-0096",
+    "smolscript-c-0097",
+    "smolscript-c-0098",
+    "smolscript-c-0099",
+    "smolscript-c-0100",
+    "smolscript-c-0101",
+    "smolscript-c-0102",
+    "smolscript-c-0103",
+    "smolscript-c-0105",
+    "smolscript-c-0107",
+    "smolscript-c-0108",
+    "smolscript-c-0109",
+    "smolscript-c-0114",
+    "smolscript-c-0115",
+    "smolscript-c-0116",
+    "smolscript-c-0117",
+    "smolscript-c-0118",
+    "smolscript-c-0123",
+    "smolscript-c-0124",
+    "smolscript-c-0128",
+    "smolscript-c-0130",
+    "smolscript-c-0131",
+    "smolscript-c-0132",
+    "smolscript-c-0133",
+    "smolscript-c-0134",
+    "smolscript-c-0139",
+    "smolscript-c-0140",
+    "smolscript-c-0143",
+    "smolscript-c-0145",
+    "smolscript-c-0146",
+    "smolscript-c-0147",
+    "smolscript-c-0148",
+    "smolscript-c-0151",
+    "smolscript-c-0153",
+    "smolscript-c-0154",
+    "smolscript-c-0155",
+    "smolscript-c-0156",
+    "smolscript-c-0161",
+    "smolscript-c-0162",
+    "smolscript-c-0166",
+    "smolscript-c-0168",
+    "smolscript-c-0169",
+    "smolscript-c-0173",
+    "smolscript-c-0175",
+    "smolscript-c-0179",
+    "smolscript-c-0180",
+    "smolscript-c-0181",
+    "smolscript-c-0182",
+    "smolscript-c-0183",
+    "smolscript-c-0185",
+    "smolscript-c-0187",
+    "smolscript-c-0190",
+    "smolscript-c-0191",
+    "smolscript-c-0192",
+    "smolscript-c-0193",
+    "smolscript-c-0194",
+    "smolscript-c-0198",
+    "smolscript-c-0202",
+    "smolscript-c-0203",
+    "smolscript-c-0204",
+    "smolscript-c-0205",
+    "smolscript-c-0207",
+    "smolscript-c-0208",
+    "smolscript-c-0210",
+    "smolscript-c-0214",
+    "smolscript-c-0215",
+    "smolscript-c-0217",
+    "smolscript-c-0221",
+    "smolscript-c-0223",
+    "smolscript-c-0224",
+    "smolscript-lua-0001",
+    "smolscript-lua-0002",
+    "smolscript-lua-0004",
+    "smolscript-lua-0005",
+    "smolscript-lua-0006",
+    "smolscript-lua-0011",
+    "smolscript-lua-0015",
+    "smolscript-lua-0016",
+    "smolscript-lua-0019",
+    "smolscript-lua-0020",
+    "smolscript-lua-0024",
+    "smolscript-lua-0026",
+    "smolscript-lua-0027",
+    "smolscript-lua-0030",
+    "smolscript-lua-0036",
+    "smolscript-lua-0037",
+    "smolscript-lua-0039",
+    "smolscript-lua-0042",
+    "smolscript-lua-0045",
+    "smolscript-lua-0046",
+    "smolscript-lua-0053",
+    "smolscript-lua-0054",
+    "smolscript-lua-0055",
+    "smolscript-lua-0056",
+    "smolscript-lua-0057",
+    "smolscript-lua-0061",
+    "smolscript-lua-0062",
+    "smolscript-lua-0063",
+    "smolscript-lua-0064",
+    "smolscript-lua-0065",
+    "smolscript-lua-0067",
+    "smolscript-lua-0069",
+    "smolscript-lua-0070",
+    "smolscript-lua-0072",
+    "smolscript-lua-0073",
+    "smolscript-lua-0075",
+    "smolscript-lua-0077",
+    "smolscript-lua-0078",
+    "smolscript-lua-0079",
+    "smolscript-lua-0080",
+    "smolscript-lua-0081",
+    "smolscript-lua-0082",
+    "smolscript-lua-0084",
+    "smolscript-lua-0086",
+    "smolscript-lua-0089",
+    "smolscript-lua-0090",
+    "smolscript-lua-0095",
+    "smolscript-lua-0097",
+    "smolscript-lua-0099",
+    "smolscript-lua-0100",
+    "smolscript-lua-0105",
+    "smolscript-lua-0106",
+    "smolscript-lua-0107",
+    "smolscript-lua-0112",
+    "smolscript-lua-0114",
+    "smolscript-lua-0116",
+    "smolscript-lua-0117",
+    "smolscript-lua-0118",
+    "smolscript-lua-0119",
+    "smolscript-lua-0120",
+    "smolscript-lua-0122",
+    "smolscript-lua-0123",
+    "smolscript-lua-0125",
+    "smolscript-lua-0127",
+    "smolscript-lua-0128",
+    "smolscript-lua-0129",
+    "smolscript-lua-0130",
+    "smolscript-lua-0135",
+    "smolscript-lua-0139",
+    "smolscript-lua-0140",
+    "smolscript-lua-0141",
+    "smolscript-lua-0142",
+    "smolscript-lua-0143",
+    "smolscript-lua-0144",
+    "smolscript-lua-0145",
+    "smolscript-lua-0151",
+    "smolscript-lua-0152",
+    "smolscript-lua-0153",
+    "smolscript-lua-0155",
+    "smolscript-lua-0158",
+    "smolscript-lua-0159",
+    "smolscript-lua-0162",
+    "smolscript-lua-0164",
+    "smolscript-lua-0165",
+    "smolscript-lua-0167",
+    "smolscript-lua-0168",
+    "smolscript-lua-0169",
+    "smolscript-lua-0173",
+    "smolscript-lua-0174",
+    "smolscript-lua-0177",
+    "smolscript-lua-0181",
+    "smolscript-lua-0183",
+    "smolscript-lua-0186",
+    "smolscript-lua-0188",
+    "smolscript-lua-0191",
+    "smolscript-lua-0192",
+    "smolscript-lua-0193",
+    "smolscript-lua-0195",
+    "smolscript-lua-0196",
+    "smolscript-lua-0199",
+    "smolscript-csharp-0003",
+    "smolscript-csharp-0004",
+    "smolscript-csharp-0005",
+    "smolscript-csharp-0006",
+    "smolscript-csharp-0007",
+    "smolscript-csharp-0008",
+    "smolscript-csharp-0009",
+    "smolscript-csharp-0010",
+    "smolscript-csharp-0012",
+    "smolscript-csharp-0013",
+    "smolscript-csharp-0018",
+    "smolscript-csharp-0019",
+    "smolscript-csharp-0021",
+    "smolscript-csharp-0023",
+    "smolscript-csharp-0024",
+    "smolscript-csharp-0025",
+    "smolscript-csharp-0028",
+    "smolscript-csharp-0032",
+    "smolscript-csharp-0033",
+    "smolscript-csharp-0034",
+    "smolscript-csharp-0039",
+    "smolscript-csharp-0040",
+    "smolscript-csharp-0041",
+    "smolscript-csharp-0042",
+    "smolscript-csharp-0047",
+    "smolscript-csharp-0051",
+    "smolscript-csharp-0052",
+    "smolscript-csharp-0053",
+    "smolscript-csharp-0056",
+    "smolscript-csharp-0057",
+    "smolscript-csharp-0065",
+    "smolscript-csharp-0068",
+    "smolscript-csharp-0070",
+    "smolscript-csharp-0073",
+    "smolscript-csharp-0075",
+    "smolscript-csharp-0076",
+    "smolscript-csharp-0078",
+    "smolscript-csharp-0080",
+    "smolscript-csharp-0081",
+    "smolscript-csharp-0082",
+    "smolscript-csharp-0084",
+    "smolscript-csharp-0085",
+    "smolscript-csharp-0086",
+    "smolscript-csharp-0087",
+    "smolscript-csharp-0090",
+    "smolscript-csharp-0093",
+    "smolscript-csharp-0097",
+    "smolscript-csharp-0099",
+    "smolscript-csharp-0101",
+    "smolscript-csharp-0103",
+    "smolscript-csharp-0105",
+    "smolscript-csharp-0108",
+    "smolscript-csharp-0112",
+    "smolscript-csharp-0113",
+    "smolscript-csharp-0114",
+    "smolscript-csharp-0116",
+    "smolscript-csharp-0117",
+    "smolscript-csharp-0119",
+    "smolscript-csharp-0120",
+    "smolscript-csharp-0122",
+    "smolscript-csharp-0123",
+    "smolscript-csharp-0125",
+    "smolscript-csharp-0126",
+    "smolscript-csharp-0128",
+    "smolscript-csharp-0129",
+    "smolscript-csharp-0132",
+    "smolscript-csharp-0134",
+    "smolscript-csharp-0136",
+    "smolscript-csharp-0139",
+    "smolscript-csharp-0143",
+    "smolscript-csharp-0145",
+    "smolscript-csharp-0146",
+    "smolscript-csharp-0148",
+    "smolscript-csharp-0149",
+    "smolscript-csharp-0155",
+    "smolscript-csharp-0156",
+    "smolscript-csharp-0157",
+    "smolscript-csharp-0158",
+    "smolscript-csharp-0159",
+    "smolscript-csharp-0165",
+    "smolscript-csharp-0166",
+    "smolscript-csharp-0167",
+    "smolscript-csharp-0169",
+    "smolscript-csharp-0172",
+    "smolscript-csharp-0173",
+    "smolscript-csharp-0174",
+    "smolscript-csharp-0175",
+    "smolscript-csharp-0176",
+    "smolscript-csharp-0178",
+    "smolscript-csharp-0179",
+    "smolscript-csharp-0180",
+    "smolscript-csharp-0181",
+    "smolscript-csharp-0182",
+    "smolscript-csharp-0185",
+    "smolscript-csharp-0187",
+    "smolscript-csharp-0190",
+    "smolscript-csharp-0192",
+    "smolscript-csharp-0195",
+    "smolscript-csharp-0197",
+    "smolscript-csharp-0201",
+    "smolscript-csharp-0202",
+    "smolscript-csharp-0204",
+    "smolscript-csharp-0205",
+    "smolscript-csharp-0209",
+    "smolscript-csharp-0210",
+    "smolscript-csharp-0212",
+    "smolscript-csharp-0213",
+    "smolscript-csharp-0215",
+    "smolscript-csharp-0216",
+    "smolscript-csharp-0217",
+    "smolscript-csharp-0222",
+    "smolscript-csharp-0224",
+    "smolscript-rust-0002",
+    "smolscript-rust-0003",
+    "smolscript-rust-0005",
+    "smolscript-rust-0006",
+    "smolscript-rust-0007",
+    "smolscript-rust-0008",
+    "smolscript-rust-0014",
+    "smolscript-rust-0015",
+    "smolscript-rust-0016",
+    "smolscript-rust-0017",
+    "smolscript-rust-0019",
+    "smolscript-rust-0021",
+    "smolscript-rust-0022",
+    "smolscript-rust-0023",
+    "smolscript-rust-0029",
+    "smolscript-rust-0030",
+    "smolscript-rust-0031",
+    "smolscript-rust-0032",
+    "smolscript-rust-0033",
+    "smolscript-rust-0034",
+    "smolscript-rust-0040",
+    "smolscript-rust-0041",
+    "smolscript-rust-0044",
+    "smolscript-rust-0045",
+    "smolscript-rust-0046",
+    "smolscript-rust-0047",
+    "smolscript-rust-0050",
+    "smolscript-rust-0051",
+    "smolscript-rust-0052",
+    "smolscript-rust-0054",
+    "smolscript-rust-0055",
+    "smolscript-rust-0056",
+    "smolscript-rust-0057",
+    "smolscript-rust-0059",
+    "smolscript-rust-0060",
+    "smolscript-rust-0063",
+    "smolscript-rust-0065",
+    "smolscript-rust-0069",
+    "smolscript-rust-0070",
+    "smolscript-rust-0071",
+    "smolscript-rust-0073",
+    "smolscript-rust-0078",
+    "smolscript-rust-0082",
+    "smolscript-rust-0083",
+    "smolscript-rust-0087",
+    "smolscript-rust-0089",
+    "smolscript-rust-0090",
+    "smolscript-rust-0091",
+    "smolscript-rust-0092",
+    "smolscript-rust-0094",
+    "smolscript-rust-0096",
+    "smolscript-rust-0098",
+    "smolscript-rust-0099",
+    "smolscript-rust-0101",
+    "smolscript-rust-0102",
+    "smolscript-rust-0105",
+    "smolscript-rust-0106",
+    "smolscript-rust-0112",
+    "smolscript-rust-0113",
+    "smolscript-rust-0115",
+    "smolscript-rust-0116",
+    "smolscript-rust-0118",
+    "smolscript-rust-0120",
+    "smolscript-rust-0121",
+    "smolscript-rust-0132",
+    "smolscript-rust-0133",
+    "smolscript-rust-0134",
+    "smolscript-rust-0136",
+    "smolscript-rust-0138",
+    "smolscript-rust-0140",
+    "smolscript-rust-0142",
+    "smolscript-rust-0143",
+    "smolscript-rust-0146",
+    "smolscript-rust-0148",
+    "smolscript-rust-0150",
+    "smolscript-rust-0151",
+    "smolscript-rust-0152",
+    "smolscript-rust-0155",
+    "smolscript-rust-0156",
+    "smolscript-rust-0158",
+    "smolscript-rust-0159",
+    "smolscript-rust-0160",
+    "smolscript-rust-0162",
+    "smolscript-rust-0164",
+    "smolscript-rust-0165",
+    "smolscript-rust-0167",
+    "smolscript-rust-0171",
+    "smolscript-rust-0172",
+    "smolscript-rust-0176",
+    "smolscript-rust-0178",
+    "smolscript-rust-0182",
+    "smolscript-rust-0184",
+    "smolscript-rust-0188",
+    "smolscript-rust-0190",
+    "smolscript-rust-0194",
+    "smolscript-rust-0196",
+    "smolscript-rust-0197",
+    "smolscript-rust-0198",
+    "smolscript-rust-0199",
+    "smolscript-rust-0200",
+    "smolscript-rust-0203",
+    "smolscript-rust-0204",
+    "smolscript-rust-0210",
+    "smolscript-rust-0213",
+    "smolscript-rust-0214",
+    "smolscript-rust-0215",
+    "smolscript-rust-0216",
+    "smolscript-rust-0218",
+    "smolscript-rust-0220",
+    "smolscript-rust-0221",
+    "smolscript-rust-0224",
+    "smolscript-rust-0225"
+  ],
+  "selection_sha256": "9937192b809cc8548b16bcc6c56ab9cbc762816be03a44e46c08170b48213e0a",
   "files": {
-    "data/smolscript.jsonl": "1926bca1b0c6b2244554577135a9c3c305b18fd834c654803b4e8480fff0d3d9",
-    "data/smolscript.parquet": "7bf25948750648aa036bdf277cfd7c38597c98aa06131e805628b9055a7938d9",
-    "private_tests/hidden.jsonl": "2447d09ae445094c1ae59df644b46e3ca2f4cc64de630966b94bd5db8b8bf0ac",
-    "references/solutions.jsonl": "84d3411fe45189c62ae50fbd31c1dc5795bc099d5037c3a817e3d280f6097e83"
+    "data/smolscript.jsonl": "1c17c3515e86e2c4bc25c84b45b9f086c87efd98e1d75a7f4b42772b9d88176e",
+    "data/smolscript.parquet": "358eae399dac7564ea5fb8753734f189aea3932994a22779d543bdcce847e050",
+    "private_tests/hidden.jsonl": "55c240d74282889fa2829fb307bf42649fb04876f5ebeb9e6f95cd934bcc105a",
+    "references/solutions.jsonl": "34c7244ea9160ba090e7c3bc1802ca68cc882f8ee9c29736ea8529d499977677"
   }
 }

pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=68"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "smolscript"
-version = "0.1.0"
+version = "0.2.0"
 description = "A small-model multilingual execution benchmark"
 requires-python = ">=3.11"
 license = {text = "MIT"}

runners/hf_runtime.py

@@ -0,0 +1,190 @@
+"""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 .hf_tokens 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, stream_tokens=True):
+    """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)
+    started=time.monotonic()
+    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, eos_completions=0, token_limit_completions=0,
+                 token_limit_question_ids=[])
+    # 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['token_streamer'] = stream_tokens
+    stats['last_token_logits'] = bool(generation_options)
+    # Tokenizers can emit segment IDs even when their paired model rejects them.
+    # Keep cached IDs intact, but pass them only to models declaring support.
+    include_token_types = any(
+        method is not None and 'token_type_ids' in inspect.signature(method).parameters
+        for method in (forward, getattr(model, 'prepare_inputs_for_generation', None))
+    )
+
+    def generate(group, budget):
+        data = padded_batch([compiled[q['id']] for q in group], tokenizer.pad_token_id,
+                            tokenizer.padding_side, include_token_types=include_token_types)
+        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 if stream_tokens else None, 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, [bool(s and s[-1] in eos) for s in sequences]
+
+    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, ended = 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['eos_completions'] += sum(ended)
+                    limited = [q['id'] for q,n,end in zip(group,lengths,ended) if n >= budget and not end]
+                    stats['token_limit_completions'] += len(limited)
+                    stats['token_limit_question_ids'] = (stats['token_limit_question_ids'] + limited)[:25]
+                    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()
+    elapsed=max(time.monotonic()-started,1e-9)
+    stats.update(generated_tokens=tokens_done, final_batch_size=effective_batch,
+                 generation_wall_seconds=elapsed, generated_tokens_per_second=tokens_done/elapsed)
+    return stats

runners/hf_tokens.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:2-direct-answer'),
+        '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

sandbox/worker.py

@@ -10,17 +10,17 @@ import tempfile
 from protocol import COMMANDS,wrap_source
 
 
-def limits(seconds):
+def limits(seconds,file_limit):
     os.setsid()
     resource.setrlimit(resource.RLIMIT_CPU,(seconds,seconds+1))
-    resource.setrlimit(resource.RLIMIT_FSIZE,(1024*1024,1024*1024))
+    resource.setrlimit(resource.RLIMIT_FSIZE,(file_limit,file_limit))
     resource.setrlimit(resource.RLIMIT_CORE,(0,0))
 
 
-def execute(command,stdin,seconds):
+def execute(command,stdin,seconds,file_limit=1024*1024):
     with tempfile.TemporaryFile() as out,tempfile.TemporaryFile() as err:
         p=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=out,stderr=err,
-            preexec_fn=lambda:limits(seconds),env={'PATH':os.environ['PATH'],'HOME':'/tmp','LANG':'C.UTF-8',
+            preexec_fn=lambda:limits(seconds,file_limit),env={'PATH':os.environ['PATH'],'HOME':'/tmp','LANG':'C.UTF-8',
             'LC_ALL':'C.UTF-8','TZ':'UTC','PYTHONHASHSEED':'0','MONO_THREADS_PER_CPU':'1'})
         timed_out=False
         try:p.communicate(stdin.encode(),timeout=seconds+1)
@@ -38,7 +38,7 @@ def execute(command,stdin,seconds):
 def program(request):
     filename,compile_cmd,run_cmd=COMMANDS[request['language']]
     Path(filename).write_text(wrap_source(request['language'],request['kind'],request['code']))
-    compilation=execute(compile_cmd,'',30)
+    compilation=execute(compile_cmd,'',30,file_limit=64*1024*1024)
     syntax=compilation['exit_code']==0 and not compilation['timeout']
     if not syntax:return {'syntax_success':False,'compilation':compilation,'observations':[]}
     observations=[]

tests/test_core.py

@@ -12,6 +12,24 @@ from runners.sandbox import Sandbox,SandboxUnavailable
 from validators.dataset import load
 
 class CoreTests(unittest.TestCase):
+    def test_default_subset_is_fixed_and_preserves_original_tasks(self):
+        from generators.subset import select
+        from collections import Counter
+        archive=load(ROOT/'archive/v0.1.0/smolscript.jsonl')
+        rows=load(ROOT/'data/smolscript.jsonl')
+        self.assertEqual(len(rows),1000)
+        self.assertEqual(select(archive),rows)
+        self.assertEqual(select(list(reversed(archive)))[::-1],rows)
+        self.assertEqual(Counter(r['difficulty'] for r in rows),{'easy':600,'medium':300,'moderate':100})
+        original={r['id']:r for r in archive}
+        for r in rows:
+            for key in ('prompt','output_format','tests'):self.assertEqual(r[key],original[r['id']][key])
+    def test_decode_settings_do_not_read_solutions(self):
+        from generation_settings import DEFAULT_BATCH_SIZE,token_budget
+        self.assertEqual(DEFAULT_BATCH_SIZE,64)
+        rows=load(ROOT/'data/smolscript.jsonl')
+        self.assertTrue(all(96<=token_budget(r)<=256 for r in rows))
+
     def test_prompt_has_no_reference_or_tests(self):
         row=load(ROOT/'data/smolscript.jsonl')[0];row['tests']=[{'input':'SECRET_TEST','expected':'SECRET_ANSWER'}];row['reference_solution']='SECRET_REFERENCE'
         text=prompt(row)

validate.py

@@ -13,7 +13,7 @@ def main():
     report=check(ROOT);report['reference_execution']='unverified';report['negative_controls']='unverified'
     try:
         if a.static_only:
-            report['remaining']='All 2000 references and negative controls require sandbox execution.';return 0
+            report['remaining']='All 1000 references and negative controls require sandbox execution.';return 0
         sandbox=Sandbox(a.image,a.engine)
         report['sandbox']=sandbox.identity
         report['runtimes']=sandbox.run({'diagnostic':True},60)['runtimes']
@@ -48,7 +48,7 @@ def main():
             if not result['passed'] or negative['passed'] or (mutant and mutant['passed']):
                 raise ValueError('Reference or negative control failed: '+rid)
             if len(results)%25==0:
-                print(f'Validated {len(results)}/2000',flush=True);a.output.write_text(json.dumps(report,indent=2)+'\n')
+                print(f'Validated {len(results)}/1000',flush=True);a.output.write_text(json.dumps(report,indent=2)+'\n')
         report['reference_execution']='passed';report['negative_controls']='passed';return 0
     except SandboxUnavailable as e:
         report['blocked_reason']=str(e);report['unverified_languages']=['python','javascript','html','css','cpp','c','lua','csharp','rust'];print(str(e));return 2

validation_report.json

@@ -1,30 +1,30 @@
 {
   "static_validation": "passed",
-  "examples": 2000,
+  "examples": 1000,
   "languages": {
-    "python": 250,
-    "javascript": 250,
-    "html": 200,
-    "css": 200,
-    "cpp": 225,
-    "c": 225,
-    "lua": 200,
-    "csharp": 225,
-    "rust": 225
+    "python": 125,
+    "javascript": 125,
+    "html": 100,
+    "css": 100,
+    "cpp": 113,
+    "c": 113,
+    "lua": 100,
+    "csharp": 112,
+    "rust": 112
   },
   "difficulty": {
-    "easy": 1200,
-    "medium": 600,
-    "moderate": 200
+    "easy": 600,
+    "medium": 300,
+    "moderate": 100
   },
   "categories": {
-    "arithmetic_conditions": 492,
-    "strings": 468,
-    "collections_loops": 540,
-    "frequency_tables": 80,
-    "dom_events": 20,
-    "semantic_structure": 200,
-    "styles_layout": 200
+    "arithmetic_conditions": 246,
+    "strings": 234,
+    "collections_loops": 271,
+    "frequency_tables": 39,
+    "dom_events": 10,
+    "semantic_structure": 100,
+    "styles_layout": 100
   },
   "prompt_words": {
     "min": 13,
@@ -38,26 +38,6 @@
   "exact_duplicates": 0,
   "semantic_duplicates_within_language": 0,
   "near_text_pairs": [
-    {
-      "a": "smolscript-python-0173",
-      "b": "smolscript-python-0188",
-      "trigram_jaccard": 0.8667
-    },
-    {
-      "a": "smolscript-javascript-0173",
-      "b": "smolscript-javascript-0188",
-      "trigram_jaccard": 0.8667
-    },
-    {
-      "a": "smolscript-cpp-0158",
-      "b": "smolscript-cpp-0173",
-      "trigram_jaccard": 0.8667
-    },
-    {
-      "a": "smolscript-c-0158",
-      "b": "smolscript-c-0173",
-      "trigram_jaccard": 0.8667
-    },
     {
       "a": "smolscript-lua-0143",
       "b": "smolscript-lua-0158",
@@ -67,27 +47,11 @@
       "a": "smolscript-csharp-0158",
       "b": "smolscript-csharp-0173",
       "trigram_jaccard": 0.8667
-    },
-    {
-      "a": "smolscript-rust-0158",
-      "b": "smolscript-rust-0173",
-      "trigram_jaccard": 0.8667
     }
   ],
   "semantic_check_scope": "finite deterministic probes plus exact DSL/DOM/CSS spec equality; not a general equivalence proof",
   "cross_language_policy": "Aligned original tasks intentionally recur across languages for comparable coverage.",
   "reference_execution": "unverified",
   "negative_controls": "unverified",
-  "blocked_reason": "docker is unavailable; install Docker/Podman and build sandbox/Dockerfile. No host fallback exists.",
-  "unverified_languages": [
-    "python",
-    "javascript",
-    "html",
-    "css",
-    "cpp",
-    "c",
-    "lua",
-    "csharp",
-    "rust"
-  ]
+  "remaining": "All 1000 references and negative controls require sandbox execution."
 }

validators/dataset.py

@@ -16,11 +16,11 @@ def load(path):
 
 def check(root):
     rows=load(root/'data/smolscript.jsonl');hidden=load(root/'private_tests/hidden.jsonl');refs=load(root/'references/solutions.jsonl')
-    assert len(rows)==2000,'Expected exactly 2000 examples'
+    assert len(rows)==1000,'Expected exactly 1000 examples'
     assert Counter(r['language'] for r in rows)=={k:sum(v) for k,v in ALLOCATION.items()},'Language allocation'
-    assert Counter(r['difficulty'] for r in rows)=={'easy':1200,'medium':600,'moderate':200},'Difficulty allocation'
+    assert Counter(r['difficulty'] for r in rows)=={'easy':600,'medium':300,'moderate':100},'Difficulty allocation'
     assert {r['id'] for r in rows}=={r['id'] for r in hidden}=={r['id'] for r in refs},'Private/public ID mismatch'
-    assert len({r['prompt'] for r in rows})==2000,'Duplicate prompts'
+    assert len({r['prompt'] for r in rows})==1000,'Duplicate prompts'
     hm={r['id']:r for r in hidden};rm={r['id']:r for r in refs}
     hidden_behavior={};seen={};behavior={};categories=Counter();lengths=[];solutions=[];similarity=[]
     by_language=defaultdict(list)