Use base-model code completion for SmolScript 0.4.0

Task comments and fixed headers/scaffolds; deterministic prefix assembly and first-function scope extraction without semantic repair. Same 350 tasks/tests and 96–256 token budgets. All 350 reference bodies pass static roundtrip checks. Full runtime validation and model score improvements remain unverified.

README.md

@@ -25,7 +25,7 @@ configs:
 ---
 # SmolScript
 
-An original execution-based benchmark of basic programming for 25M–350M parameter language models. Version **0.3.0**, **350 default examples**, nine languages, MIT license.
+An original execution-based benchmark of basic programming for 25M–350M parameter language models. Evaluator **0.4.0**, **350 default examples** (fixed dataset edition 0.3.0), nine languages, MIT license.
 
 **Release status: execution-unverified candidate.** All 350 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 350 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.
 
@@ -85,7 +85,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 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.
+One fixed completion prompt (`smolscript-base-completion-v2`), 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 task comments, the input domain, supplied standard-library imports, web fixtures/base styles where needed, and a function/markup prefix. Models continue the supplied source directly. 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.
 
@@ -95,7 +95,7 @@ For externally generated code, create JSONL records `{"id":"...","code":"..."}`
 python evaluate.py --predictions predictions.jsonl --output results.json
 ```
 
-Raw code or a single fenced code block is accepted. Multiple or unfinished fences are rejected. Function tasks receive fixed stdin/stdout wrappers. Compiled languages compile once per task, then run a fresh process per test. HTML is parsed with html5lib and checked in Chromium with document scripts disabled. CSS is parsed with tinycss2 and tested against a fixed fixture at the specified widths. Browser tests assert DOM/computed styles and geometry, without image similarity.
+Externally supplied predictions use complete source code (raw code or a single fenced code block). Model inference stores raw continuations and deterministically assembles the supplied prefix before scoring. Multiple or unfinished fences are rejected. Function tasks receive fixed stdin/stdout wrappers. Compiled languages compile once per task, then run a fresh process per test. HTML is parsed with html5lib and checked in Chromium with document scripts disabled. CSS is parsed with tinycss2 and tested against a fixed fixture at the specified widths. Browser tests assert DOM/computed styles and geometry, without image similarity.
 
 ## Metrics
 
@@ -125,7 +125,7 @@ The default split and both local/Modal evaluators now use the same fixed 350 IDs
 
 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-v030.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 reduces the task count from 1,000 to 350 and retains the fast decoding budgets introduced in 0.2.0. Its scores must not be merged with earlier editions. Template IDs are `smolscript-0.3.0` and `cognirank2-v3`; use a new output path. No GPU throughput speedup is claimed without a measured run.
+Example: `python evaluate.py --model HuggingFaceTB/SmolLM2-135M --batch-size 64 --output results-v030.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 reduces the task count from 1,000 to 350 and retains the fast decoding budgets introduced in 0.2.0. Its scores must not be merged with earlier editions. Template IDs are `smolscript-0.4.0` and `cognirank2-v4`; use a new output path. No GPU throughput speedup is claimed without a measured run.
 
 
 ## Browser timeout handling
@@ -142,3 +142,23 @@ Rebuild the Docker image after updating these files. The Modal launcher automati
 CSS styles are inserted synchronously with a DOM style element; the evaluator does not use Playwright 1.56 `add_style_tag`, whose inline-style path waits for a `load` callback. This avoids waiting for that callback on the HTML/CSS pages with scripting disabled. Trusted fixture and baseline errors remain infrastructure failures, separate from candidate execution. Timeout diagnostics now name the precise phase, operation, scenario and language and include bounded worker stderr.
 
 The Modal path first checks runtime availability and a trusted CSS computed-style/distractor probe, before model generation. Worker processes use explicit subprocess UID/GID settings and private writable HOME/XDG/TMP directories; no Python pre-exec callback is used in the threaded launcher. These changes preserve the fixed 350-example dataset and scoring definition. End-to-end Modal browser verification is still required; local tests cover the injection protocol, diagnostic fields, preflight failure and watchdog behavior.
+
+
+## Base-model completion protocol (0.4.0)
+
+The same completion template is used for every model, including instruction models. There is no chat wrapper, conversational instruction block, worked solution, reference implementation, test input, expected answer, or answer-dependent repair. Example prompt ending:
+
+```python
+# Starting with n, double it, then take the last decimal digit of its absolute value. Return the result.
+# Integer n from -120 to 120.
+def solve(n):
+    
+```
+
+The model continues at the indented body. Python headers omit type annotations. JavaScript, C, C++, C#, Rust and Lua receive their function/method openings (including the C# class), and applicable supplied imports. HTML receives a task comment followed by `<`; CSS receives its fixture/context and task as a CSS comment. `examples/base-prompts.json` contains an example for each language. `completion.py` is the authoritative prompt and assembly implementation.
+
+The supplied prefix is attached to the generated continuation. Answer-independent lexical scope extraction keeps the first completed function/class body and discards trailing prose. Python uses indentation tokens; braced languages count delimiters while ignoring ordinary strings/comments (and supported regex/raw/verbatim strings); Lua counts block keywords. These are constrained completion delimiters, not general language parsers. Syntax and behavior are still checked inside the sandbox. Missing delimiters, malformed indentation, expressions, and return values are never repaired, and no closing suffix is invented. Complete entry-point definitions emitted from scratch, including a single fenced code block, are accepted as deterministic formatting alternatives.
+
+Raw continuations and assembled `evaluated_code` are saved separately. The standalone `--predictions` path continues to accept complete code and bypasses the completion prefix. All 350 supplied reference bodies roundtrip through assembly (Python body AST equality, other languages source equality); this is a static assembly check, not complete runtime validation. Full isolated reference execution and a new KLM benchmark run remain outstanding.
+
+Use a **new output path** for `smolscript-0.4.0` / `cognirank2-v4`. Dataset edition/selection 0.3.0 remains fixed; only the evaluation prompt/assembly protocol changes. Old scores are not comparable and must be rerun for leaderboard comparisons. Token budgets, deterministic greedy decoding, batch size 64, eight isolated Modal scoring workers, tests and weights remain the same.

SHA256SUMS

@@ -1,6 +1,6 @@
 ff73ee904edc9381bd1ea24847e41c6176aec22ba4b63321e8354562f24ba5ce  .gitignore
 8719af4397a8387b8f04140613943545f8ecd90f06529dcab9e68a94927d13fe  LICENSE
-f1025bcd6a338e93766ddeacb39f2aaf9edb743b9f418968f46bcd13aa14b862  README.md
+ed646bff1e37aaa95e039cabd8a3d58ed18485179de096e37f5ddf7a7223966e  README.md
 2447d09ae445094c1ae59df644b46e3ca2f4cc64de630966b94bd5db8b8bf0ac  archive/v0.1.0/hidden.jsonl
 1926bca1b0c6b2244554577135a9c3c305b18fd834c654803b4e8480fff0d3d9  archive/v0.1.0/smolscript.jsonl
 7bf25948750648aa036bdf277cfd7c38597c98aa06131e805628b9055a7938d9  archive/v0.1.0/smolscript.parquet
@@ -9,22 +9,24 @@ f1025bcd6a338e93766ddeacb39f2aaf9edb743b9f418968f46bcd13aa14b862  README.md
 1c17c3515e86e2c4bc25c84b45b9f086c87efd98e1d75a7f4b42772b9d88176e  archive/v0.2.0/smolscript.jsonl
 358eae399dac7564ea5fb8753734f189aea3932994a22779d543bdcce847e050  archive/v0.2.0/smolscript.parquet
 34c7244ea9160ba090e7c3bc1802ca68cc882f8ee9c29736ea8529d499977677  archive/v0.2.0/solutions.jsonl
+7a057672dbe866e2b8dca92c8fc2a8baf35547831666d41309f20cc09c96344e  completion.py
 9f9798909d3ab3631a457de1bc7e573c546ed3f3b0f78e6bcb82780e280b37b3  data/smolscript.jsonl
 ad56c7186df28d84a23912a7fa2ec28b6762240a33b7b2a49412ce5b47319862  data/smolscript.parquet
-96bc6e69d752e9fee97389dd15d921173f603c9ce972b1defa49549e977032b1  evaluate.py
-9395164c1296d2d71c6c61a9ed367564c6a06d5933f0aeb2ed62d652561c857d  examples/local-test-report.json
+0eaebae91f30afdebb84183619620f3eb73257ba3ab7c09572f0a982c5c99cd6  evaluate.py
+9ee4551be1a573d2bb94f41935f94028ab538d3b6e4ba957d6bf9a9076fefd67  examples/base-prompts.json
+3c1e0c66200ec31a08d316a012ac30456c06c90521360db8a150a3a56357e255  examples/local-test-report.json
 713855348ffc53f49b03a0df47b67294fe2d3593054636eec12b9f184fb3534e  examples/result-format.json
-b0871e1f323ac493a0e413d1ac085b1cda3c94e496a1bfecac11aa58773d3144  generation_settings.py
+af0da7e2ef72cb6ac992aac4a83ddfe200e2512b5e26209882b403cb2b48ea4a  generation_settings.py
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  generators/__init__.py
-230994809f72326493338a9d585441440234e8f9fd199705802f8b6986a9f72c  generators/build.py
+8f14ca3a1a122d0d4ab34420e0c5493299166554aa296ec503af3e53e1847485  generators/build.py
 e1cf493b995f15470c56c097b73e7403ae06f74f5d12cbb3a43ce522514d8577  generators/code.py
 60be0a7ac6fcd3dfd8b663fc19af189aba3acfdd923219dc6cc1972033380240  generators/specs.py
 c800d0237c7f4342fb636b6e54f15616a9547406f165e7ad7f96965cd6b9a4d1  generators/subset.py
 ae6a8d5109035027b71df7eb7297e7c0b811a4a98c649e1729a3fe2a2c09c5bf  generators/web.py
-10139496eb032542b30694584038332005978ad5978727f2017956190fd19ab4  manifest.json
+8a834a5d375b4fa14d9b1416d47056e0533c8338401aff505e98767349e38673  manifest.json
 6bac32e6045f1788e8b68e96ff6ee41f1b2152cca1b17de24be405025f294930  metrics.py
 e00a185b961e80e1e1e86e6ddf97ec470d10e1c7b2bed44eb221af42a0eb6972  private_tests/hidden.jsonl
-d45aab2646a9bfa15ab1636ce3af71b7ce9dffb49037bfd565e51cea967ceae5  pyproject.toml
+8e37b2b9360b8283ef7f99a5702b5575d66c34e88e9d59c0f9631437fd30aa61  pyproject.toml
 d736311f2645f4bdc7bac3316d858788118af4d551290d3924299f96935bd886  references/solutions.jsonl
 5a3cb2a82cf3784c41fc9f9046fe6806d5bbe7ce8ae415a9ed1c373abcfe7826  runners/__init__.py
 965bc9e3dabfc3fba4b745994b43118c456be477edcc34a3ba929ebf39e19ce9  runners/c_runner.py
@@ -44,9 +46,10 @@ d9ebf5141e3c1928879865050bf3ad7773613084fe62a0ff7eac8d1ea69f8cc4  runners/sandbo
 53098a63b7d2053a4d8494c340e63d924646255c297d31e78c0025ef552c6cd6  sandbox/Dockerfile
 013cc442aa61d4b85f1986b111ea9adea5f9749bf0cef5176faa67963c900e7c  sandbox/supervisor.py
 538b3c7176b678e6a2b2a55a52aaa2e4a03accc20b2d7d850ee67695f5ecdc9f  sandbox/worker.py
+f58268efbe40e27869f903e8b482b28e1e55213705be8c72e2fb6f5b0b95336c  tests/test_completion.py
 c155b14ce8fa94dd4a179c22e6ab13accadffcf3571f384d27985ba916cbf864  tests/test_core.py
 14f40a4b954c81dcf6cb8a2bdf361023e8cea36b54b31e40657f92f39433c124  tests/test_watchdog.py
 ffba2ed9eabec6186a7568ff0535c9733841b661f7c1e420770dbeb47d87dbae  validate.py
 845d1ef1d45133e04908e1ff187281b9af9f4e48c2bec1994f91b1b191d5d563  validation_report.json
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  validators/__init__.py
-bb8e3616596f04614913a52aa37f0a4dffd0ec64a3fc9af63d8d12fafbee37ae  validators/dataset.py
+8bf1f3115935b74be29476ebe5f6965e45f92e12e76679c343b17f6d2215b6a4  validators/dataset.py

completion.py

@@ -0,0 +1,160 @@
+"""Fixed base-model code completion. No reference/test fields are read."""
+import io
+import re
+import tokenize
+PROMPT_VERSION='smolscript-base-completion-v2'
+SIGNATURES={
+ 'python':{'scalar':'def solve(n):','string':'def solve(s):','array':'def solve(values):'},
+ 'javascript':{'scalar':'function solve(n)','string':'function solve(s)','array':'function solve(values)','dom':'function setup()'},
+ 'cpp':{'scalar':'long long solve(long long n)','string':'std::string solve(std::string s)','array':'long long solve(const std::vector<long long>& values)'},
+ 'c':{'scalar':'long long solve(long long n)','string':'const char *solve(const char *input)','array':'long long solve(const long long *values, int length)'},
+ 'lua':{'scalar':'function solve(n)','string':'function solve(s)','array':'function solve(values)'},
+ 'csharp':{'scalar':'public static long Solve(long n)','string':'public static string Solve(string s)','array':'public static long Solve(long[] values)'},
+ 'rust':{'scalar':'fn solve(mut n: i64) -> i64','string':'fn solve(mut s: String) -> String','array':'fn solve(values: Vec<i64>) -> i64'},
+}
+
+def prefix(row):
+    lang=row['language'];kind=row['metadata']['family']
+    if lang=='html':return '<'
+    if lang=='css':return ''
+    header=SIGNATURES[lang][kind]
+    if lang=='python':return header+'\n    '
+    if lang=='lua':return header+'\n  '
+    if kind=='dom':return header+' {\n  '
+    if lang=='csharp':return 'public class Solution {\n'+header+' {\n    '
+    return header+' {\n    '
+
+def prompt(row):
+    from runners.protocol import HEADERS
+    lang=row['language'];meta=row['metadata']
+    task=re.sub(r'^In [^,]+,\s*','',row['prompt'])
+    task=task.replace(' Return CSS only.','').replace(' Return an HTML fragment.','')
+    task=task.removeprefix('Implement setup(). ')
+    details=[task]
+    if meta.get('input_domain'):details.append(meta['input_domain'])
+    context=[]
+    if meta.get('fixture'):context.append('HTML fixture: '+meta['fixture'])
+    if meta.get('base_css'):context.append('Existing CSS: '+meta['base_css'])
+    details=context+details
+    if lang=='html':comment='<!-- '+ ' '.join(details).replace('-->','-- >')+' -->\n'
+    elif lang=='css':comment='/* '+ ' '.join(details).replace('*/','* /')+' */\n'
+    else:
+        marker='#' if lang=='python' else '--' if lang=='lua' else '//'
+        comment='\n'.join(marker+' '+line for line in details)+'\n'
+    return comment+HEADERS.get(lang,'')+prefix(row)
+
+
+def _brace_end(source):
+    """First complete braced function/class, ignoring quoted strings/comments.
+
+    Lexer-only delimiting: never evaluate, fix or choose code by test success.
+    """
+    depth=0;opened=False;i=0;previous=''
+    while i<len(source):
+        if source.startswith('//',i):
+            end=source.find('\n',i);i=len(source) if end<0 else end+1;continue
+        if source.startswith('/*',i):
+            end=source.find('*/',i+2)
+            if end<0:return len(source)
+            i=end+2;continue
+        # C/C++/C#/JS/Rust strings and character literals; Rust lifetimes are
+        # identifiers, not single-quoted characters.
+        ch=source[i]
+        raw=re.match(r'(?:u8|u|U|L)?R"([^\s()\\]{0,16})\(',source[i:])
+        if raw:
+            end=source.find(')'+raw.group(1)+'"',i+raw.end())
+            if end<0:return len(source)
+            i=end+len(raw.group(1))+2;previous='v';continue
+        word=re.match(r'[A-Za-z_$][\w$]*',source[i:])
+        if word:
+            previous=word.group();i+=len(previous);continue
+        if ch in ('"','`') or (ch=="'" and re.match(r"'(?:\\.|[^'\\\n])'",source[i:])):
+            quote=ch;verbatim=quote=='"' and i>0 and source[i-1]=='@';i+=1
+            while i<len(source):
+                if source[i]=='\\' and not verbatim:i+=2;continue
+                if source[i]==quote:
+                    if quote=='"' and i+1<len(source) and source[i+1]=='"' and verbatim:
+                        i+=2;continue
+                    i+=1;break
+                i+=1
+            previous='v';continue
+        # JS regular-expression literals occurring where an expression begins.
+        if ch=='/' and previous in ('=', '(', ',', ':', '[', '!', '?', 'return', 'throw', 'case', '=>'):
+            j=i+1;inside=False
+            while j<len(source) and source[j]!='\n':
+                if source[j]=='\\':j+=2;continue
+                if source[j]=='[':inside=True
+                if source[j]==']':inside=False
+                if source[j]=='/' and not inside:i=j+1;break
+                j+=1
+            else:i+=1
+            previous='v';continue
+        if ch=='{':depth+=1;opened=True
+        elif ch=='}':
+            depth-=1
+            if opened and depth==0:return i+1
+        if not ch.isspace():previous='=>' if ch=='>' and previous=='=' else ch
+        i+=1
+    return len(source)
+
+
+def _python_end(source):
+    depth=0;body=False
+    try:
+        for token in tokenize.generate_tokens(io.StringIO(source).readline):
+            if token.type==tokenize.INDENT:depth+=1;body=True
+            elif token.type==tokenize.DEDENT:
+                depth-=1
+                if body and depth==0:return sum(len(x) for x in source.splitlines(keepends=True)[:token.start[0]-1])
+    except (tokenize.TokenError,IndentationError):pass
+    return len(source)
+
+
+def _lua_end(source):
+    # Tokenize strings/comments first, then count Lua's block delimiters.
+    pattern=r'--\[\[.*?\]\]|--[^\n]*|\[(=*)\[.*?\]\1\]|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|\b(?:function|if|for|while|do|repeat|end|until)\b'
+    depth=0;loops=0
+    for match in re.finditer(pattern,source,re.S):
+        word=match.group()
+        if word in ('function','if','repeat'):depth+=1
+        elif word in ('for','while'):depth+=1;loops+=1
+        elif word=='do':
+            if loops:loops-=1
+            else:depth+=1
+        elif word in ('end','until'):
+            depth-=1
+            if depth==0:return match.end()
+    return len(source)
+
+
+def assemble(row,continuation):
+    """Attach the supplied header; keep the first completed entry-point scope.
+
+    No indentation, expressions, missing delimiters or return values are repaired.
+    A complete function emitted from scratch is accepted as a format alternative.
+    """
+    lang=row['language']
+    text=continuation
+    if text.lstrip().startswith('```'):
+        from runners.common import extract_code
+        text=extract_code(text)
+    expected=prefix(row)
+    starts={
+       'python':r'^def\s+solve\s*\(', 'javascript':r'^(?:async\s+)?function\s+(?:solve|setup)\s*\(',
+       'lua':r'^function\s+solve\s*\(', 'csharp':r'^public\s+class\s+Solution\b',
+       'rust':r'^fn\s+solve\s*\(', 'cpp':r'^(?:long\s+long|std::string)\s+solve\s*\(',
+       'c':r'^(?:long\s+long|const\s+char\s*\*)\s*solve\s*\(',
+    }
+    complete_python=False
+    if lang=='python':
+        import ast
+        try:complete_python=any(isinstance(n,ast.FunctionDef) and n.name=='solve' for n in ast.parse(text).body)
+        except SyntaxError:pass
+    if complete_python:code=text.lstrip()
+    elif lang in starts and re.match(starts[lang],text.lstrip()):code=text.lstrip()
+    elif lang=='html' and text.lstrip().startswith('<'):code=text.lstrip()
+    else:code=expected+text
+    if lang=='python' and not complete_python:code=code[:_python_end(code)]
+    elif lang=='lua':code=code[:_lua_end(code)]
+    elif lang not in ('html','css','python'):code=code[:_brace_end(code)]
+    return code.rstrip()+'\n'

evaluate.py

@@ -10,16 +10,9 @@ from runners.common import extract_code
 from runners.sandbox import Sandbox
 from metrics import aggregate
 ROOT=Path(__file__).resolve().parent
-PROMPT_VERSION='smolscript-completion-v1'
+from completion import prompt,assemble,PROMPT_VERSION
 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.
-    fixture=row['metadata'].get('fixture','');base=row['metadata'].get('base_css','')
-    return ('Write code for the following task. Use the standard library only. Return code only.\n'
-        +row['prompt']+'\n'+row['output_format']+'\n'+(row['metadata'].get('input_domain') or '')
-        +('\nHTML fixture:\n'+fixture if fixture else '')+('\nExisting CSS:\n'+base if base else '')+'\nCode:\n')
-
 def save(path,value):
     path.parent.mkdir(parents=True,exist_ok=True);temp=path.with_suffix('.tmp');temp.write_text(json.dumps(value,indent=2,allow_nan=False)+'\n');temp.replace(path)
 
@@ -34,7 +27,7 @@ def main():
     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','generation_settings.py']+[str(p.relative_to(ROOT)) for p in sorted((ROOT/'runners').glob('*.py'))]+['sandbox/worker.py','sandbox/supervisor.py']
+    files=['data/smolscript.jsonl','private_tests/hidden.jsonl','evaluate.py','metrics.py','generation_settings.py','completion.py']+[str(p.relative_to(ROOT)) for p in sorted((ROOT/'runners').glob('*.py'))]+['sandbox/worker.py','sandbox/supervisor.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,'batch_size':a.batch_size,'decode_protocol':PROTOCOL,'prompt_version':PROMPT_VERSION,'dataset':fingerprint,'sandbox':sandbox.identity,
@@ -57,8 +50,8 @@ def main():
             snapshot=snapshot_download(a.model,revision=state.get('resolved_revision') or a.revision)
             revision=Path(snapshot).name
             state['resolved_revision']=revision
-            tokenizer=AutoTokenizer.from_pretrained(snapshot)
-            model=AutoModelForCausalLM.from_pretrained(snapshot,torch_dtype='auto',device_map=a.device)
+            tokenizer=AutoTokenizer.from_pretrained(snapshot,trust_remote_code=True)
+            model=AutoModelForCausalLM.from_pretrained(snapshot,trust_remote_code=True,torch_dtype='auto',device_map=a.device)
             model.eval();torch.manual_seed(0)
             import importlib.metadata
             state['environment']={'python':sys.version,'packages':{n:importlib.metadata.version(n) for n in ('torch','transformers','huggingface-hub')},'device':str(model.device)}
@@ -91,10 +84,11 @@ def main():
                 text=codes[row['id']]
             else:text=state['generations'][row['id']]
             state['pending']={'id':row['id'],'generation':text};save(a.output,state)
-            try:code=extract_code(text)
+            code=None
+            try:code=extract_code(text) if a.predictions else assemble(row,text)
             except ValueError as e:result={'passed':False,'syntax_success':False,'tests':[],'error':str(e)}
             else:result=get_runner(row['language']).evaluate(row,code,hidden[row['id']],sandbox)
-            state['results'].append({'id':row['id'],'language':row['language'],'difficulty':row['difficulty'],'generation':text,**result})
+            state['results'].append({'id':row['id'],'language':row['language'],'difficulty':row['difficulty'],'generation':text,'evaluated_code':code,**result})
             state.pop('pending',None)
             save(a.output,state);print(f"{len(state['results'])}/{len(rows)} {row['id']} {'PASS' if result['passed'] else 'FAIL'}",flush=True)
         state['metrics']=aggregate(state['results'],[r['id'] for r in rows],full_run=not(a.language or a.difficulty));state['complete']=True;save(a.output,state)

examples/base-prompts.json

@@ -0,0 +1,65 @@
+[
+  {
+    "id": "smolscript-python-0015",
+    "language": "python",
+    "prompt_version": "smolscript-base-completion-v2",
+    "completion_prompt": "# Starting with n, double it, then take the last decimal digit of its absolute value. Return the result.\n# Integer n from -120 to 120.\ndef solve(n):\n    ",
+    "supplied_prefix": "def solve(n):\n    "
+  },
+  {
+    "id": "smolscript-javascript-0010",
+    "language": "javascript",
+    "prompt_version": "smolscript-base-completion-v2",
+    "completion_prompt": "// Starting with ASCII string s, replace each run of spaces with one space, then keep the first floor(length/2) characters. Return the result.\n// ASCII s of at most 80 characters, without newlines.\nfunction solve(s) {\n    ",
+    "supplied_prefix": "function solve(s) {\n    "
+  },
+  {
+    "id": "smolscript-html-0003",
+    "language": "html",
+    "prompt_version": "smolscript-base-completion-v2",
+    "completion_prompt": "<!-- Create an h1 heading reading Welcome. On its outer element, set right-to-left direction via dir. -->\n<",
+    "supplied_prefix": "<"
+  },
+  {
+    "id": "smolscript-css-0010",
+    "language": "css",
+    "prompt_version": "smolscript-base-completion-v2",
+    "completion_prompt": "/* HTML fixture: <div id=\"scope\"><div id=\"target\" class=\"target\" data-kind=\"card\">Alpha<span>One</span><span>Two</span></div><div class=\"other\">Beta</div></div><div class=\"target\" id=\"outside\">Outside</div> Existing CSS: * { box-sizing: content-box; } .target,.other { border: 1px solid black; width:200px; height:80px; min-width:0; max-width:none; margin:0; padding:0; display:block; position:static; } Style every element with class target: set font-weight to 700. Leave other elements unchanged. */\n",
+    "supplied_prefix": ""
+  },
+  {
+    "id": "smolscript-cpp-0003",
+    "language": "cpp",
+    "prompt_version": "smolscript-base-completion-v2",
+    "completion_prompt": "// Starting with n, clamp it to the inclusive range -5 to 5, then subtract it from ten. Return the result.\n// Integer n from -120 to 120.\n#include <iostream>\n#include <string>\n#include <vector>\n#include <algorithm>\n#include <cstdlib>\nlong long solve(long long n) {\n    ",
+    "supplied_prefix": "long long solve(long long n) {\n    "
+  },
+  {
+    "id": "smolscript-c-0001",
+    "language": "c",
+    "prompt_version": "smolscript-base-completion-v2",
+    "completion_prompt": "// Starting with n, replace it with 1 if negative, otherwise 0, then add one. Return the result.\n// Integer n from -120 to 120.\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\nlong long solve(long long n) {\n    ",
+    "supplied_prefix": "long long solve(long long n) {\n    "
+  },
+  {
+    "id": "smolscript-lua-0001",
+    "language": "lua",
+    "prompt_version": "smolscript-base-completion-v2",
+    "completion_prompt": "-- Starting with n, replace it with 1 if negative, otherwise 0, then add one. Return the result.\n-- Integer n from -120 to 120.\nfunction solve(n)\n  ",
+    "supplied_prefix": "function solve(n)\n  "
+  },
+  {
+    "id": "smolscript-csharp-0003",
+    "language": "csharp",
+    "prompt_version": "smolscript-base-completion-v2",
+    "completion_prompt": "// Starting with n, clamp it to the inclusive range -5 to 5, then subtract it from ten. Return the result.\n// Integer n from -120 to 120.\nusing System;\nusing System.Linq;\nusing System.Collections.Generic;\npublic class Solution {\npublic static long Solve(long n) {\n    ",
+    "supplied_prefix": "public class Solution {\npublic static long Solve(long n) {\n    "
+  },
+  {
+    "id": "smolscript-rust-0002",
+    "language": "rust",
+    "prompt_version": "smolscript-base-completion-v2",
+    "completion_prompt": "// Starting with ASCII string s, convert lowercase ASCII letters to uppercase, then convert uppercase ASCII letters to lowercase. Return the result.\n// ASCII s of at most 80 characters, without newlines.\nuse std::io::{self, Read};\nfn solve(mut s: String) -> String {\n    ",
+    "supplied_prefix": "fn solve(mut s: String) -> String {\n    "
+  }
+]

examples/local-test-report.json

@@ -1,6 +1,6 @@
 {
   "unit_tests": {
-    "passed": 21,
+    "passed": 28,
     "command": "python -m unittest discover -s tests -q"
   },
   "python_reference_ast_parse": 44,
@@ -21,9 +21,15 @@
     "rust": 39
   },
   "blocked_reason": "Docker/Podman unavailable; full isolated reference and negative-control execution remains unverified.",
-  "model_baselines": "not run",
+  "model_baselines": "No 0.4.0 model baseline run",
   "gpu_throughput_benchmark": "not run",
   "watchdog_policy": "phase-watchdog-v1",
   "watchdog_test_execution": "trusted synthetic workers; candidate generations not executed on host",
-  "browser_setup_patch": "synchronous-css-private-home-v1"
+  "browser_setup_patch": "synchronous-css-private-home-v1",
+  "reference_body_assembly": {
+    "checked": 350,
+    "method": "Python body AST equality; other languages source equality",
+    "execution": false
+  },
+  "prompt_version": "smolscript-base-completion-v2"
 }

generation_settings.py

@@ -1,5 +1,5 @@
 """Versioned decoding policy; never reads references or hidden answers."""
-PROTOCOL='smolscript-0.3.0'
+PROTOCOL='smolscript-0.4.0'
 DEFAULT_BATCH_SIZE=64
 MAX_NEW_TOKENS=256
 

generators/build.py

@@ -125,7 +125,8 @@ 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':DEFAULT_VERSION,'examples':350,'languages':{k:sum(v) for k,v in ALLOCATION.items()},
+    from generation_settings import PROTOCOL
+    manifest={'evaluation_protocol':PROTOCOL,'version':DEFAULT_VERSION,'examples':350,'languages':{k:sum(v) for k,v in ALLOCATION.items()},
               'difficulty':{'easy':210,'medium':105,'moderate':35},'generator_seed':7301,
               'validation_status':'execution_unverified','selection_protocol':DEFAULT_VERSION,
               'selected_ids':[r['id'] for r in public],

manifest.json

@@ -1,4 +1,5 @@
 {
+  "evaluation_protocol": "smolscript-0.4.0",
   "version": "smolscript-0.3.0",
   "examples": 350,
   "languages": {

pyproject.toml

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

tests/test_completion.py

@@ -0,0 +1,63 @@
+import ast
+import json
+from pathlib import Path
+import sys
+import unittest
+ROOT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(ROOT))
+from completion import prompt,prefix,assemble,PROMPT_VERSION
+from validators.dataset import load
+
+class CompletionTests(unittest.TestCase):
+    def setUp(self):self.rows=load(ROOT/'data/smolscript.jsonl')
+    def test_prompt_ends_with_header_and_never_reads_answers(self):
+        for row in self.rows:
+            text=prompt(row)
+            self.assertTrue(text.endswith(prefix(row)))
+            changed={**row,'reference_solution':'SECRET_REFERENCE','tests':[{'input':'SECRET_INPUT','expected':'SECRET_ANSWER'}]}
+            self.assertEqual(prompt(changed),text)
+            self.assertNotIn('Return code only',text)
+            self.assertNotIn('function function',text)
+    def test_python_has_no_type_annotation_boilerplate(self):
+        row=next(r for r in self.rows if r['language']=='python')
+        self.assertEqual(prefix(row),'def solve(n):\n    ')
+        text=assemble(row,'return abs(2*n)%10\n\nQuestion: explain this code')
+        ast.parse(text);self.assertNotIn('Question:',text)
+    def test_every_reference_body_roundtrips_without_solution_repairs(self):
+        refs={r['id']:r['reference_solution'] for r in load(ROOT/'references/solutions.jsonl')}
+        for row in self.rows:
+            lang=row['language'];ref=refs[row['id']]
+            if lang=='html':tail=ref[1:]
+            elif lang=='css':tail=ref
+            elif lang=='python':tail=ref.split('\n',1)[1][4:]
+            else:
+                self.assertTrue(ref.startswith(prefix(row)),row['id'])
+                tail=ref[len(prefix(row)):]
+            result=assemble(row,tail)
+            if lang=='python':
+                self.assertEqual(ast.dump(ast.Module(body=ast.parse(ref).body[0].body,type_ignores=[])),ast.dump(ast.Module(body=ast.parse(result).body[0].body,type_ignores=[])),row['id'])
+                self.assertEqual(len(ast.parse(ref).body[0].body),len(ast.parse(result).body[0].body),row['id'])
+            else:self.assertEqual(result,ref.rstrip()+'\n',row['id'])
+    def test_scopes_ignore_strings_and_preserve_nested_blocks(self):
+        row=next(r for r in self.rows if r['language']=='javascript' and r['metadata']['family']=='scalar')
+        code=assemble(row,'if (n) { return "}"; }\n    return 0;\n}\nExplanation: done')
+        self.assertIn('return 0;',code);self.assertNotIn('Explanation',code)
+    def test_delimiters_inside_regex_raw_and_verbatim_strings(self):
+        cases=[('javascript','return /[{}]/.test("}");\n}'),
+               ('cpp','return std::string(R"tag(} \" {)tag");\n}'),
+               ('csharp','return @"a "" } "" b";\n}\n}')]
+        for lang,tail in cases:
+            row=next(r for r in self.rows if r['language']==lang)
+            self.assertEqual(assemble(row,tail+'\nExplanation: done'),prefix(row)+tail+'\n',lang)
+
+    def test_truncated_body_is_not_given_missing_braces(self):
+        row=next(r for r in self.rows if r['language']=='javascript')
+        self.assertFalse(assemble(row,'return 3;').rstrip().endswith('}'))
+    def test_complete_function_and_fenced_output_are_accepted(self):
+        row=next(r for r in self.rows if r['language']=='python')
+        whole='def solve(n):\n    return abs(n)\n'
+        self.assertEqual(assemble(row,whole),whole)
+        self.assertIn('return "```"',assemble(row,'return "```"'))
+        self.assertEqual(assemble(row,'```python\n'+whole+'```'),whole)
+        with self.assertRaises(ValueError):assemble(row,'```python\nreturn n')
+
+if __name__=='__main__':unittest.main()

validators/dataset.py

@@ -60,6 +60,8 @@ def check(root):
     decoded=[{**r,'tests':json.loads(r['tests']),'metadata':json.loads(r['metadata'])} for r in parquet]
     assert decoded==rows,'JSONL/Parquet mismatch'
     manifest=json.loads((root/'manifest.json').read_text())
+    from generation_settings import PROTOCOL
+    assert manifest['evaluation_protocol']==PROTOCOL,'Evaluation protocol mismatch'
     for name,digest in manifest['files'].items():assert hashlib.sha256((root/name).read_bytes()).hexdigest()==digest,('Hash mismatch',name)
     return {'static_validation':'passed','examples':len(rows),'languages':dict(Counter(r['language'] for r in rows)),
        'difficulty':dict(Counter(r['difficulty'] for r in rows)),'categories':dict(categories),